synapsecns/sanguine

package db_test

import (
    "math/big"

    "github.com/brianvoe/gofakeit/v6"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    . "github.com/stretchr/testify/assert"
    "github.com/synapsecns/sanguine/services/scribe/db"
)

func (t *DBSuite) TestStoreRetrieveReceipt() {
    t.RunOnAllDBs(func(testDB db.EventDB) {
        txHashRandom := gofakeit.Int64()
        chainID := gofakeit.Uint32()
        txHashA := common.BigToHash(big.NewInt(txHashRandom))
        txHashB := common.BigToHash(big.NewInt(txHashRandom + 1))
        randomLogsA := []types.Log{
            t.MakeRandomLog(txHashA),
            t.MakeRandomLog(txHashA),
        }
        randomLogsA[0].BlockNumber = 4
        randomLogsA[1].BlockNumber = 3
        randomLogsB := []types.Log{
            t.MakeRandomLog(txHashB),
            t.MakeRandomLog(txHashB),
        }
        randomLogsB[0].BlockNumber = 2
        randomLogsB[1].BlockNumber = 1

        // Store all random logs, since `RetrieveReceipt` needs to query them to build the Receipt.
        for _, log := range randomLogsA {
            err := testDB.StoreLogs(t.GetTestContext(), chainID, log)
            Nil(t.T(), err)
        }
        for _, log := range randomLogsB {
            err := testDB.StoreLogs(t.GetTestContext(), chainID+1, log)
            Nil(t.T(), err)
        }

        // Store two receipts with different tx hashes.
        receiptA := types.Receipt{
            Type:              gofakeit.Uint8(),
            PostState:         []byte(gofakeit.Sentence(10)),
            Status:            gofakeit.Uint64(),
            CumulativeGasUsed: gofakeit.Uint64(),
            Bloom:             types.BytesToBloom([]byte(gofakeit.Sentence(10))),
            Logs: []*types.Log{
                &randomLogsA[0],
                &randomLogsA[1],
            },
            TxHash:           txHashA,
            ContractAddress:  common.BigToAddress(big.NewInt(gofakeit.Int64())),
            GasUsed:          gofakeit.Uint64(),
            BlockNumber:      big.NewInt(1),
            TransactionIndex: uint(gofakeit.Uint64()),
        }
        err := testDB.StoreReceipt(t.GetTestContext(), chainID, receiptA)
        Nil(t.T(), err)

        receiptB := types.Receipt{
            Type:              gofakeit.Uint8(),
            PostState:         []byte(gofakeit.Sentence(10)),
            Status:            gofakeit.Uint64(),
            CumulativeGasUsed: gofakeit.Uint64(),
            Bloom:             types.BytesToBloom([]byte(gofakeit.Sentence(10))),
            Logs: []*types.Log{
                &randomLogsB[0],
                &randomLogsB[1],
            },
            TxHash:           txHashB,
            ContractAddress:  common.BigToAddress(big.NewInt(gofakeit.Int64())),
            GasUsed:          gofakeit.Uint64(),
            BlockNumber:      big.NewInt(2),
            TransactionIndex: uint(gofakeit.Uint64()),
        }
        err = testDB.StoreReceipt(t.GetTestContext(), chainID+1, receiptB)
        Nil(t.T(), err)

        // Ensure the receipts from the database match the ones stored.
        receiptFilter := db.ReceiptFilter{
            TxHash:  txHashA.String(),
            ChainID: chainID,
        }
        retrievedReceiptA, err := testDB.RetrieveReceiptsWithFilter(t.GetTestContext(), receiptFilter, 1)
        Nil(t.T(), err)

        resA, err := receiptA.MarshalJSON()
        Nil(t.T(), err)
        resB, err := retrievedReceiptA[0].MarshalJSON()
        Nil(t.T(), err)
        Equal(t.T(), resA, resB)

        receiptFilter = db.ReceiptFilter{
            TxHash:  txHashB.String(),
            ChainID: chainID + 1,
        }
        retrievedReceiptB, err := testDB.RetrieveReceiptsWithFilter(t.GetTestContext(), receiptFilter, 1)
        Nil(t.T(), err)

        resA, err = receiptB.MarshalJSON()
        Nil(t.T(), err)
        resB, err = retrievedReceiptB[0].MarshalJSON()
        Nil(t.T(), err)
        Equal(t.T(), resA, resB)

        // Ensure RetrieveAllReceipts gets all receipts.
        allReceipts, err := testDB.RetrieveReceiptsWithFilter(t.GetTestContext(), db.ReceiptFilter{}, 1)
        Nil(t.T(), err)
        Equal(t.T(), 2, len(allReceipts))
    })
}

func (t *DBSuite) TestDeleteReceiptsForBlockHash() {
    t.RunOnAllDBs(func(testDB db.EventDB) {
        chainID := gofakeit.Uint32()

        // Store a receipt.
        receipt := t.MakeRandomReceipt(common.BigToHash(big.NewInt(gofakeit.Int64())))
        receipt.BlockHash = common.BigToHash(big.NewInt(5))
        err := testDB.StoreReceipt(t.GetTestContext(), chainID, receipt)
        Nil(t.T(), err)

        // Ensure the receipt is in the database.
        receiptFilter := db.ReceiptFilter{
            ChainID:   chainID,
            BlockHash: receipt.BlockHash.String(),
        }
        retrievedReceipts, err := testDB.RetrieveReceiptsWithFilter(t.GetTestContext(), receiptFilter, 1)
        Nil(t.T(), err)
        Equal(t.T(), 1, len(retrievedReceipts))

        // Delete the receipt.
        err = testDB.DeleteReceiptsForBlockHash(t.GetTestContext(), chainID, receipt.BlockHash)
        Nil(t.T(), err)

        // Ensure the receipt is not in the database.
        retrievedReceipts, err = testDB.RetrieveReceiptsWithFilter(t.GetTestContext(), receiptFilter, 1)
        Nil(t.T(), err)
        Equal(t.T(), 0, len(retrievedReceipts))
    })
}

func (t *DBSuite) MakeRandomReceipt(txHash common.Hash) types.Receipt {
    return types.Receipt{
        Type:              gofakeit.Uint8(),
        PostState:         []byte(gofakeit.Sentence(10)),
        Status:            gofakeit.Uint64(),
        CumulativeGasUsed: gofakeit.Uint64(),
        Bloom:             types.BytesToBloom([]byte(gofakeit.Sentence(10))),
        Logs:              []*types.Log{},
        TxHash:            txHash,
        ContractAddress:   common.BigToAddress(big.NewInt(gofakeit.Int64())),
        GasUsed:           gofakeit.Uint64(),
        BlockNumber:       big.NewInt(int64(gofakeit.Uint32())),
        TransactionIndex:  uint(gofakeit.Uint64()),
    }
}

func (t *DBSuite) TestRetrieveReceiptsWithStaleBlockHash() {
    t.RunOnAllDBs(func(testDB db.EventDB) {
        chainID := gofakeit.Uint32()
        startBlock := 2
        hash1 := common.BigToHash(big.NewInt(1))
        hash2 := common.BigToHash(big.NewInt(2))
        hash3 := common.BigToHash(big.NewInt(3))
        newHash2 := common.BigToHash(big.NewInt(22))
        blockHashes := []common.Hash{hash1, hash2, hash3}
        blockHashesStr := []string{hash1.String(), newHash2.String(), hash3.String()}

        for i := 0; i < 10; i++ {
            receipt := t.MakeRandomReceipt(common.BigToHash(big.NewInt(gofakeit.Int64())))
            receipt.BlockNumber = big.NewInt(int64(i))
            receipt.BlockHash = blockHashes[i%3]
            err := testDB.StoreReceipt(t.GetTestContext(), chainID, receipt)
            Nil(t.T(), err)
        }

        // Retrieve the receipts
        retrievedReceipts, err := testDB.RetrieveReceiptsWithStaleBlockHash(t.GetTestContext(), chainID, blockHashesStr, uint64(startBlock), 10)
        Nil(t.T(), err)

        // Ensure the correct receipts (all the ones with hash 2) were retrieved
        Equal(t.T(), 2, len(retrievedReceipts))
        Equal(t.T(), hash2, retrievedReceipts[0].BlockHash)
    })
}