refactor(dpos2.0): remove tx3index

blockchain/chainstoreffldb.go

@@ -408,8 +408,23 @@ func (c *ChainStoreFFLDB) GetUTXO(programHash *Uint168) ([]*common.UTXO, error)
 	return c.indexManager.FetchUTXO(programHash)
 }
 
+func DBFetchTx3IndexEntry(dbTx database.Tx, txHash *Uint256) bool {
+	hashIndex := dbTx.Metadata().Bucket(Tx3IndexBucketName)
+	value := hashIndex.Get(txHash[:])
+	if bytes.Equal(value, Tx3IndexValue) {
+		return true
+	}
+	return false
+}
+
 func (c *ChainStoreFFLDB) IsTx3Exist(txHash *Uint256) bool {
-	return c.indexManager.IsTx3Exist(txHash)
+	exist := false
+	_ = c.db.View(func(dbTx database.Tx) error {
+		exist = DBFetchTx3IndexEntry(dbTx, txHash)
+		return nil
+	})
+
+	return exist
 }
 
 func (c *ChainStoreFFLDB) IsSideChainReturnDepositExist(txHash *Uint256) bool {

blockchain/indexers/common.go

@@ -69,9 +69,6 @@ type IndexManager interface {
 	// FetchUTXO retrieval the utxo set of a account address
 	FetchUTXO(programHash *common.Uint168) ([]*common2.UTXO, error)
 
-	// IsTx3Exist use to find if tx3 exist in DB
-	IsTx3Exist(txHash *common.Uint256) bool
-
 	// IsSideChainReturnDepositExist use to find if return deposit exist in DB
 	IsSideChainReturnDepositExist(txHash *common.Uint256) bool
 }

blockchain/indexers/manager.go

@@ -506,16 +506,6 @@ func (m *Manager) FetchUTXO(programHash *common.Uint168) ([]*common2.UTXO, error
 	return utxos, nil
 }
 
-func (m *Manager) IsTx3Exist(txHash *common.Uint256) bool {
-	exist := false
-	_ = m.db.View(func(dbTx database.Tx) error {
-		exist = DBFetchTx3IndexEntry(dbTx, txHash)
-		return nil
-	})
-
-	return exist
-}
-
 func (m *Manager) IsSideChainReturnDepositExist(txHash *common.Uint256) bool {
 	exist := false
 	_ = m.db.View(func(dbTx database.Tx) error {
@@ -534,10 +524,9 @@ func NewManager(db database.DB, params *config.Params) *Manager {
 	txIndex := NewTxIndex(db)
 	unspentIndex := NewUnspentIndex(db, params)
 	utxoIndex := NewUtxoIndex(db, unspentIndex)
-	tx3Index := NewTx3Index(db)
 	returnDepositIndex := NewReturnDepositIndex(db)
 	var enabledIndexes []Indexer
-	enabledIndexes = append(enabledIndexes, txIndex, unspentIndex, utxoIndex, tx3Index, returnDepositIndex)
+	enabledIndexes = append(enabledIndexes, txIndex, unspentIndex, utxoIndex, returnDepositIndex)
 	return &Manager{
 		db:             db,
 		enabledIndexes: enabledIndexes,

common/bucketname.go

@@ -5,4 +5,11 @@ var (
 	// ProposalDraftDataBucketName is the name of the DB bucket used to house the
 	// proposal releated draft data and draft hash.
 	ProposalDraftDataBucketName = []byte("proposaldraftdata")
+
+	// Tx3IndexBucketName is the key of the tx3 index and the DB bucket used
+	// to house it.
+	Tx3IndexBucketName = []byte("tx3hash")
+
+	// Tx3IndexValue is placeholder for tx3 index
+	Tx3IndexValue = []byte{1}
 )

core/transaction/withdrawfromsidechaintransaction.go

@@ -9,6 +9,7 @@ import (
 	"bytes"
 	"encoding/hex"
 	"errors"
+	"github.com/elastos/Elastos.ELA/database"
 	"math"
 	"math/big"
 
@@ -326,3 +327,87 @@ func checkSchnorrWithdrawFromSidechain(t interfaces.Transaction, pld *payload.Wi
 	}
 	return nil
 }
+
+func (t *WithdrawFromSideChainTransaction) GetSaveProcessor() (database.TXProcessor, elaerr.ELAError) {
+
+	witPayload := t.Payload().(*payload.WithdrawFromSideChain)
+	if t.PayloadVersion() == payload.WithdrawFromSideChainVersion {
+		return func(dbTx database.Tx) error {
+			err := blockchain.TryCreateBucket(dbTx, common.Tx3IndexBucketName)
+			if err != nil {
+				return err
+			}
+			for _, hash := range witPayload.SideChainTransactionHashes {
+				err = blockchain.DBPutData(dbTx, common.Tx3IndexBucketName,
+					hash[:], common.Tx3IndexValue)
+				if err != nil {
+					return err
+				}
+			}
+
+			return nil
+		}, nil
+	} else if t.PayloadVersion() == payload.WithdrawFromSideChainVersionV1 {
+		return func(dbTx database.Tx) error {
+			err := blockchain.TryCreateBucket(dbTx, common.Tx3IndexBucketName)
+			if err != nil {
+				return err
+			}
+			for _, output := range t.Outputs() {
+				if output.Type != common2.OTWithdrawFromSideChain {
+					continue
+				}
+				witPayload, ok := output.Payload.(*outputpayload.Withdraw)
+				if !ok {
+					continue
+				}
+				err = blockchain.DBPutData(dbTx, common.Tx3IndexBucketName,
+					witPayload.SideChainTransactionHash[:], common.Tx3IndexValue)
+				if err != nil {
+					return err
+				}
+			}
+
+			return nil
+		}, nil
+	}
+
+	return nil, nil
+}
+
+func (t *WithdrawFromSideChainTransaction) GetRollbackProcessor() (database.TXProcessor, elaerr.ELAError) {
+
+	witPayload := t.Payload().(*payload.WithdrawFromSideChain)
+	if t.PayloadVersion() == payload.WithdrawFromSideChainVersion {
+		return func(dbTx database.Tx) error {
+			for _, hash := range witPayload.SideChainTransactionHashes {
+				err := blockchain.DBRemoveData(dbTx, common.Tx3IndexBucketName, hash[:])
+				if err != nil {
+					return err
+				}
+			}
+
+			return nil
+		}, nil
+	} else if t.PayloadVersion() == payload.WithdrawFromSideChainVersionV1 {
+		return func(dbTx database.Tx) error {
+			for _, output := range t.Outputs() {
+				if output.Type != common2.OTWithdrawFromSideChain {
+					continue
+				}
+				witPayload, ok := output.Payload.(*outputpayload.Withdraw)
+				if !ok {
+					continue
+				}
+				err := blockchain.DBRemoveData(dbTx, common.Tx3IndexBucketName, witPayload.SideChainTransactionHash[:])
+				if err != nil {
+					return err
+				}
+			}
+
+			return nil
+		}, nil
+	}
+
+	return nil, nil
+}

errors/errcode_test.go

@@ -21,7 +21,7 @@ func TestSimple(t *testing.T) {
 	innerErr := errors.New("inner error")
 	err = Simple(ErrFail, innerErr)
 	assert.Equal(t, ErrFail, err.Code())
-	assert.Equal(t, ErrMap[ErrFail], err.Error())
+	assert.Equal(t, ErrMap[ErrFail]+":"+innerErr.Error(), err.Error())
 	assert.Equal(t, innerErr, err.InnerError())
 }
 

errors/jsonformat_test.go

@@ -21,9 +21,9 @@ func TestToJsonFormatter(t *testing.T) {
 
 	formatter := ToJsonFormatter(simpleParent)
 	assert.Equal(t, int(simpleParentCode), formatter.Code)
-	assert.Equal(t, ErrMap[simpleParentCode], formatter.Description)
+	assert.Equal(t, ErrMap[simpleParentCode]+":"+ErrMap[simpleChildCode]+":"+plainErr.Error(), formatter.Description)
 	assert.Equal(t, int(simpleChildCode), formatter.Inner.Code)
-	assert.Equal(t, ErrMap[simpleChildCode], formatter.Inner.Description)
+	assert.Equal(t, ErrMap[simpleChildCode]+":"+plainErr.Error(), formatter.Inner.Description)
 	assert.Equal(t, int(ErrFail), formatter.Inner.Inner.Code)
 	assert.Equal(t, plainErr.Error(), formatter.Inner.Inner.Description)
 }