0f7b7099d8
Handle conflicts (#244) * Handle conflicts * Update go mod file versions * Make lint changes Disassociate block number from the indexer object Update ipld-eth-db ref Refactor builder code to make it reusable Use prefix comparison for account selective statediffing Update builder unit tests Add mode to write to CSV files in statediff file writer (#249) * Change file writing mode to csv files * Implement writer interface for file indexer * Implement option for csv or sql in file mode * Close files in CSV writer * Add tests for CSV file mode * Implement CSV file for watched addresses * Separate test configs for CSV and SQL * Refactor common code for file indexer tests Update indexer to include block hash in receipts and logs (#256) * Update indexer to include block hash in receipts and logs * Upgrade ipld-eth-db image in docker-compose to run tests Use watched addresses from direct indexing params by default while serving statediff APIs (#262) * Use watched addresses from direct indexing params in statediff APIs by default * Avoid using indexer object when direct indexing is off * Add nil check before accessing watched addresses from direct indexing params
1064 lines
32 KiB
Go
1064 lines
32 KiB
Go
// VulcanizeDB
|
|
// Copyright © 2022 Vulcanize
|
|
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package file_test
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"math/big"
|
|
"os"
|
|
"testing"
|
|
|
|
"github.com/ipfs/go-cid"
|
|
blockstore "github.com/ipfs/go-ipfs-blockstore"
|
|
dshelp "github.com/ipfs/go-ipfs-ds-help"
|
|
"github.com/jmoiron/sqlx"
|
|
"github.com/multiformats/go-multihash"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
"github.com/ethereum/go-ethereum/rlp"
|
|
"github.com/ethereum/go-ethereum/statediff/indexer/database/file"
|
|
"github.com/ethereum/go-ethereum/statediff/indexer/database/sql/postgres"
|
|
"github.com/ethereum/go-ethereum/statediff/indexer/interfaces"
|
|
"github.com/ethereum/go-ethereum/statediff/indexer/ipld"
|
|
"github.com/ethereum/go-ethereum/statediff/indexer/mocks"
|
|
"github.com/ethereum/go-ethereum/statediff/indexer/models"
|
|
"github.com/ethereum/go-ethereum/statediff/indexer/shared"
|
|
"github.com/ethereum/go-ethereum/statediff/indexer/test_helpers"
|
|
sdtypes "github.com/ethereum/go-ethereum/statediff/types"
|
|
)
|
|
|
|
var (
|
|
legacyData = mocks.NewLegacyData()
|
|
mockLegacyBlock *types.Block
|
|
legacyHeaderCID cid.Cid
|
|
|
|
sqlxdb *sqlx.DB
|
|
err error
|
|
ind interfaces.StateDiffIndexer
|
|
|
|
ipfsPgGet = `SELECT data FROM public.blocks
|
|
WHERE key = $1 AND block_number = $2`
|
|
watchedAddressesPgGet = `SELECT * FROM eth_meta.watched_addresses`
|
|
|
|
tx1, tx2, tx3, tx4, tx5, rct1, rct2, rct3, rct4, rct5 []byte
|
|
mockBlock *types.Block
|
|
headerCID, trx1CID, trx2CID, trx3CID, trx4CID, trx5CID cid.Cid
|
|
rct1CID, rct2CID, rct3CID, rct4CID, rct5CID cid.Cid
|
|
rctLeaf1, rctLeaf2, rctLeaf3, rctLeaf4, rctLeaf5 []byte
|
|
state1CID, state2CID, storageCID cid.Cid
|
|
contract1Address, contract2Address, contract3Address, contract4Address string
|
|
contract1CreatedAt, contract2CreatedAt, contract3CreatedAt, contract4CreatedAt uint64
|
|
lastFilledAt, watchedAt1, watchedAt2, watchedAt3 uint64
|
|
)
|
|
|
|
func init() {
|
|
if os.Getenv("MODE") != "statediff" {
|
|
fmt.Println("Skipping statediff test")
|
|
os.Exit(0)
|
|
}
|
|
|
|
mockBlock = mocks.MockBlock
|
|
txs, rcts := mocks.MockBlock.Transactions(), mocks.MockReceipts
|
|
|
|
buf := new(bytes.Buffer)
|
|
txs.EncodeIndex(0, buf)
|
|
tx1 = make([]byte, buf.Len())
|
|
copy(tx1, buf.Bytes())
|
|
buf.Reset()
|
|
|
|
txs.EncodeIndex(1, buf)
|
|
tx2 = make([]byte, buf.Len())
|
|
copy(tx2, buf.Bytes())
|
|
buf.Reset()
|
|
|
|
txs.EncodeIndex(2, buf)
|
|
tx3 = make([]byte, buf.Len())
|
|
copy(tx3, buf.Bytes())
|
|
buf.Reset()
|
|
|
|
txs.EncodeIndex(3, buf)
|
|
tx4 = make([]byte, buf.Len())
|
|
copy(tx4, buf.Bytes())
|
|
buf.Reset()
|
|
|
|
txs.EncodeIndex(4, buf)
|
|
tx5 = make([]byte, buf.Len())
|
|
copy(tx5, buf.Bytes())
|
|
buf.Reset()
|
|
|
|
rcts.EncodeIndex(0, buf)
|
|
rct1 = make([]byte, buf.Len())
|
|
copy(rct1, buf.Bytes())
|
|
buf.Reset()
|
|
|
|
rcts.EncodeIndex(1, buf)
|
|
rct2 = make([]byte, buf.Len())
|
|
copy(rct2, buf.Bytes())
|
|
buf.Reset()
|
|
|
|
rcts.EncodeIndex(2, buf)
|
|
rct3 = make([]byte, buf.Len())
|
|
copy(rct3, buf.Bytes())
|
|
buf.Reset()
|
|
|
|
rcts.EncodeIndex(3, buf)
|
|
rct4 = make([]byte, buf.Len())
|
|
copy(rct4, buf.Bytes())
|
|
buf.Reset()
|
|
|
|
rcts.EncodeIndex(4, buf)
|
|
rct5 = make([]byte, buf.Len())
|
|
copy(rct5, buf.Bytes())
|
|
buf.Reset()
|
|
|
|
headerCID, _ = ipld.RawdataToCid(ipld.MEthHeader, mocks.MockHeaderRlp, multihash.KECCAK_256)
|
|
trx1CID, _ = ipld.RawdataToCid(ipld.MEthTx, tx1, multihash.KECCAK_256)
|
|
trx2CID, _ = ipld.RawdataToCid(ipld.MEthTx, tx2, multihash.KECCAK_256)
|
|
trx3CID, _ = ipld.RawdataToCid(ipld.MEthTx, tx3, multihash.KECCAK_256)
|
|
trx4CID, _ = ipld.RawdataToCid(ipld.MEthTx, tx4, multihash.KECCAK_256)
|
|
trx5CID, _ = ipld.RawdataToCid(ipld.MEthTx, tx5, multihash.KECCAK_256)
|
|
state1CID, _ = ipld.RawdataToCid(ipld.MEthStateTrie, mocks.ContractLeafNode, multihash.KECCAK_256)
|
|
state2CID, _ = ipld.RawdataToCid(ipld.MEthStateTrie, mocks.AccountLeafNode, multihash.KECCAK_256)
|
|
storageCID, _ = ipld.RawdataToCid(ipld.MEthStorageTrie, mocks.StorageLeafNode, multihash.KECCAK_256)
|
|
|
|
receiptTrie := ipld.NewRctTrie()
|
|
|
|
receiptTrie.Add(0, rct1)
|
|
receiptTrie.Add(1, rct2)
|
|
receiptTrie.Add(2, rct3)
|
|
receiptTrie.Add(3, rct4)
|
|
receiptTrie.Add(4, rct5)
|
|
|
|
rctLeafNodes, keys, _ := receiptTrie.GetLeafNodes()
|
|
|
|
rctleafNodeCids := make([]cid.Cid, len(rctLeafNodes))
|
|
orderedRctLeafNodes := make([][]byte, len(rctLeafNodes))
|
|
for i, rln := range rctLeafNodes {
|
|
var idx uint
|
|
|
|
r := bytes.NewReader(keys[i].TrieKey)
|
|
rlp.Decode(r, &idx)
|
|
rctleafNodeCids[idx] = rln.Cid()
|
|
orderedRctLeafNodes[idx] = rln.RawData()
|
|
}
|
|
|
|
rct1CID = rctleafNodeCids[0]
|
|
rct2CID = rctleafNodeCids[1]
|
|
rct3CID = rctleafNodeCids[2]
|
|
rct4CID = rctleafNodeCids[3]
|
|
rct5CID = rctleafNodeCids[4]
|
|
|
|
rctLeaf1 = orderedRctLeafNodes[0]
|
|
rctLeaf2 = orderedRctLeafNodes[1]
|
|
rctLeaf3 = orderedRctLeafNodes[2]
|
|
rctLeaf4 = orderedRctLeafNodes[3]
|
|
rctLeaf5 = orderedRctLeafNodes[4]
|
|
|
|
contract1Address = "0x5d663F5269090bD2A7DC2390c911dF6083D7b28F"
|
|
contract2Address = "0x6Eb7e5C66DB8af2E96159AC440cbc8CDB7fbD26B"
|
|
contract3Address = "0xcfeB164C328CA13EFd3C77E1980d94975aDfedfc"
|
|
contract4Address = "0x0Edf0c4f393a628DE4828B228C48175b3EA297fc"
|
|
contract1CreatedAt = uint64(1)
|
|
contract2CreatedAt = uint64(2)
|
|
contract3CreatedAt = uint64(3)
|
|
contract4CreatedAt = uint64(4)
|
|
|
|
lastFilledAt = uint64(0)
|
|
watchedAt1 = uint64(10)
|
|
watchedAt2 = uint64(15)
|
|
watchedAt3 = uint64(20)
|
|
}
|
|
|
|
func expectTrue(t *testing.T, value bool) {
|
|
if !value {
|
|
t.Fatalf("Assertion failed")
|
|
}
|
|
}
|
|
|
|
func resetDB(t *testing.T) {
|
|
file.TearDownDB(t, sqlxdb)
|
|
|
|
connStr := postgres.DefaultConfig.DbConnectionString()
|
|
sqlxdb, err = sqlx.Connect("postgres", connStr)
|
|
if err != nil {
|
|
t.Fatalf("failed to connect to db with connection string: %s err: %v", connStr, err)
|
|
}
|
|
}
|
|
|
|
func testLegacyPublishAndIndexHeaderIPLDs(t *testing.T) {
|
|
pgStr := `SELECT cid, td, reward, block_hash, coinbase
|
|
FROM eth.header_cids
|
|
WHERE block_number = $1`
|
|
// check header was properly indexed
|
|
type res struct {
|
|
CID string
|
|
TD string
|
|
Reward string
|
|
BlockHash string `db:"block_hash"`
|
|
Coinbase string `db:"coinbase"`
|
|
}
|
|
header := new(res)
|
|
err = sqlxdb.QueryRowx(pgStr, legacyData.BlockNumber.Uint64()).StructScan(header)
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, legacyHeaderCID.String(), header.CID)
|
|
require.Equal(t, legacyData.MockBlock.Difficulty().String(), header.TD)
|
|
require.Equal(t, "5000000000000011250", header.Reward)
|
|
require.Equal(t, legacyData.MockBlock.Coinbase().String(), header.Coinbase)
|
|
require.Nil(t, legacyData.MockHeader.BaseFee)
|
|
}
|
|
|
|
func testPublishAndIndexHeaderIPLDs(t *testing.T) {
|
|
pgStr := `SELECT cid, td, reward, block_hash, coinbase
|
|
FROM eth.header_cids
|
|
WHERE block_number = $1`
|
|
// check header was properly indexed
|
|
type res struct {
|
|
CID string
|
|
TD string
|
|
Reward string
|
|
BlockHash string `db:"block_hash"`
|
|
Coinbase string `db:"coinbase"`
|
|
}
|
|
header := new(res)
|
|
err = sqlxdb.QueryRowx(pgStr, mocks.BlockNumber.Uint64()).StructScan(header)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
require.Equal(t, headerCID.String(), header.CID)
|
|
require.Equal(t, mocks.MockBlock.Difficulty().String(), header.TD)
|
|
require.Equal(t, "2000000000000021250", header.Reward)
|
|
require.Equal(t, mocks.MockHeader.Coinbase.String(), header.Coinbase)
|
|
dc, err := cid.Decode(header.CID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
mhKey := dshelp.MultihashToDsKey(dc.Hash())
|
|
prefixedKey := blockstore.BlockPrefix.String() + mhKey.String()
|
|
var data []byte
|
|
err = sqlxdb.Get(&data, ipfsPgGet, prefixedKey, mocks.BlockNumber.Uint64())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
require.Equal(t, mocks.MockHeaderRlp, data)
|
|
}
|
|
|
|
func testPublishAndIndexTransactionIPLDs(t *testing.T) {
|
|
// check that txs were properly indexed and published
|
|
trxs := make([]string, 0)
|
|
pgStr := `SELECT transaction_cids.cid FROM eth.transaction_cids INNER JOIN eth.header_cids ON (transaction_cids.header_id = header_cids.block_hash)
|
|
WHERE header_cids.block_number = $1`
|
|
err = sqlxdb.Select(&trxs, pgStr, mocks.BlockNumber.Uint64())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
require.Equal(t, 5, len(trxs))
|
|
expectTrue(t, test_helpers.ListContainsString(trxs, trx1CID.String()))
|
|
expectTrue(t, test_helpers.ListContainsString(trxs, trx2CID.String()))
|
|
expectTrue(t, test_helpers.ListContainsString(trxs, trx3CID.String()))
|
|
expectTrue(t, test_helpers.ListContainsString(trxs, trx4CID.String()))
|
|
expectTrue(t, test_helpers.ListContainsString(trxs, trx5CID.String()))
|
|
|
|
transactions := mocks.MockBlock.Transactions()
|
|
type txResult struct {
|
|
TxType uint8 `db:"tx_type"`
|
|
Value string
|
|
}
|
|
for _, c := range trxs {
|
|
dc, err := cid.Decode(c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
mhKey := dshelp.MultihashToDsKey(dc.Hash())
|
|
prefixedKey := blockstore.BlockPrefix.String() + mhKey.String()
|
|
var data []byte
|
|
err = sqlxdb.Get(&data, ipfsPgGet, prefixedKey, mocks.BlockNumber.Uint64())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
txTypeAndValueStr := `SELECT tx_type, value FROM eth.transaction_cids WHERE cid = $1`
|
|
switch c {
|
|
case trx1CID.String():
|
|
require.Equal(t, tx1, data)
|
|
txRes := new(txResult)
|
|
err = sqlxdb.QueryRowx(txTypeAndValueStr, c).StructScan(txRes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if txRes.TxType != 0 {
|
|
t.Fatalf("expected LegacyTxType (0), got %d", txRes.TxType)
|
|
}
|
|
if txRes.Value != transactions[0].Value().String() {
|
|
t.Fatalf("expected tx value %s got %s", transactions[0].Value().String(), txRes.Value)
|
|
}
|
|
case trx2CID.String():
|
|
require.Equal(t, tx2, data)
|
|
txRes := new(txResult)
|
|
err = sqlxdb.QueryRowx(txTypeAndValueStr, c).StructScan(txRes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if txRes.TxType != 0 {
|
|
t.Fatalf("expected LegacyTxType (0), got %d", txRes.TxType)
|
|
}
|
|
if txRes.Value != transactions[1].Value().String() {
|
|
t.Fatalf("expected tx value %s got %s", transactions[1].Value().String(), txRes.Value)
|
|
}
|
|
case trx3CID.String():
|
|
require.Equal(t, tx3, data)
|
|
txRes := new(txResult)
|
|
err = sqlxdb.QueryRowx(txTypeAndValueStr, c).StructScan(txRes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if txRes.TxType != 0 {
|
|
t.Fatalf("expected LegacyTxType (0), got %d", txRes.TxType)
|
|
}
|
|
if txRes.Value != transactions[2].Value().String() {
|
|
t.Fatalf("expected tx value %s got %s", transactions[2].Value().String(), txRes.Value)
|
|
}
|
|
case trx4CID.String():
|
|
require.Equal(t, tx4, data)
|
|
txRes := new(txResult)
|
|
err = sqlxdb.QueryRowx(txTypeAndValueStr, c).StructScan(txRes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if txRes.TxType != types.AccessListTxType {
|
|
t.Fatalf("expected AccessListTxType (1), got %d", txRes.TxType)
|
|
}
|
|
if txRes.Value != transactions[3].Value().String() {
|
|
t.Fatalf("expected tx value %s got %s", transactions[3].Value().String(), txRes.Value)
|
|
}
|
|
accessListElementModels := make([]models.AccessListElementModel, 0)
|
|
pgStr = "SELECT cast(access_list_elements.block_number AS TEXT), access_list_elements.index, access_list_elements.tx_id, " +
|
|
"access_list_elements.address, access_list_elements.storage_keys FROM eth.access_list_elements " +
|
|
"INNER JOIN eth.transaction_cids ON (tx_id = transaction_cids.tx_hash) WHERE cid = $1 ORDER BY access_list_elements.index ASC"
|
|
err = sqlxdb.Select(&accessListElementModels, pgStr, c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(accessListElementModels) != 2 {
|
|
t.Fatalf("expected two access list entries, got %d", len(accessListElementModels))
|
|
}
|
|
model1 := models.AccessListElementModel{
|
|
BlockNumber: mocks.BlockNumber.String(),
|
|
Index: accessListElementModels[0].Index,
|
|
Address: accessListElementModels[0].Address,
|
|
}
|
|
model2 := models.AccessListElementModel{
|
|
BlockNumber: mocks.BlockNumber.String(),
|
|
Index: accessListElementModels[1].Index,
|
|
Address: accessListElementModels[1].Address,
|
|
StorageKeys: accessListElementModels[1].StorageKeys,
|
|
}
|
|
require.Equal(t, mocks.AccessListEntry1Model, model1)
|
|
require.Equal(t, mocks.AccessListEntry2Model, model2)
|
|
case trx5CID.String():
|
|
require.Equal(t, tx5, data)
|
|
txRes := new(txResult)
|
|
err = sqlxdb.QueryRowx(txTypeAndValueStr, c).StructScan(txRes)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if txRes.TxType != types.DynamicFeeTxType {
|
|
t.Fatalf("expected DynamicFeeTxType (2), got %d", txRes.TxType)
|
|
}
|
|
if txRes.Value != transactions[4].Value().String() {
|
|
t.Fatalf("expected tx value %s got %s", transactions[4].Value().String(), txRes.Value)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func testPublishAndIndexLogIPLDs(t *testing.T) {
|
|
rcts := make([]string, 0)
|
|
pgStr := `SELECT receipt_cids.leaf_cid FROM eth.receipt_cids, eth.transaction_cids, eth.header_cids
|
|
WHERE receipt_cids.tx_id = transaction_cids.tx_hash
|
|
AND transaction_cids.header_id = header_cids.block_hash
|
|
AND header_cids.block_number = $1
|
|
ORDER BY transaction_cids.index`
|
|
err = sqlxdb.Select(&rcts, pgStr, mocks.BlockNumber.Uint64())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
type logIPLD struct {
|
|
Index int `db:"index"`
|
|
Address string `db:"address"`
|
|
Data []byte `db:"data"`
|
|
Topic0 string `db:"topic0"`
|
|
Topic1 string `db:"topic1"`
|
|
}
|
|
for i := range rcts {
|
|
results := make([]logIPLD, 0)
|
|
pgStr = `SELECT log_cids.index, log_cids.address, log_cids.topic0, log_cids.topic1, data FROM eth.log_cids
|
|
INNER JOIN eth.receipt_cids ON (log_cids.rct_id = receipt_cids.tx_id)
|
|
INNER JOIN public.blocks ON (log_cids.leaf_mh_key = blocks.key)
|
|
WHERE receipt_cids.leaf_cid = $1 ORDER BY eth.log_cids.index ASC`
|
|
err = sqlxdb.Select(&results, pgStr, rcts[i])
|
|
require.NoError(t, err)
|
|
|
|
// expecting MockLog1 and MockLog2 for mockReceipt4
|
|
expectedLogs := mocks.MockReceipts[i].Logs
|
|
require.Equal(t, len(expectedLogs), len(results))
|
|
|
|
var nodeElements []interface{}
|
|
for idx, r := range results {
|
|
// Attempt to decode the log leaf node.
|
|
err = rlp.DecodeBytes(r.Data, &nodeElements)
|
|
require.NoError(t, err)
|
|
if len(nodeElements) == 2 {
|
|
logRaw, err := rlp.EncodeToBytes(expectedLogs[idx])
|
|
require.NoError(t, err)
|
|
// 2nd element of the leaf node contains the encoded log data.
|
|
require.Equal(t, nodeElements[1].([]byte), logRaw)
|
|
} else {
|
|
logRaw, err := rlp.EncodeToBytes(expectedLogs[idx])
|
|
require.NoError(t, err)
|
|
// raw log was IPLDized
|
|
require.Equal(t, r.Data, logRaw)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func testPublishAndIndexReceiptIPLDs(t *testing.T) {
|
|
// check receipts were properly indexed and published
|
|
rcts := make([]string, 0)
|
|
pgStr := `SELECT receipt_cids.leaf_cid FROM eth.receipt_cids, eth.transaction_cids, eth.header_cids
|
|
WHERE receipt_cids.tx_id = transaction_cids.tx_hash
|
|
AND transaction_cids.header_id = header_cids.block_hash
|
|
AND header_cids.block_number = $1 order by transaction_cids.index`
|
|
err = sqlxdb.Select(&rcts, pgStr, mocks.BlockNumber.Uint64())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
require.Equal(t, 5, len(rcts))
|
|
expectTrue(t, test_helpers.ListContainsString(rcts, rct1CID.String()))
|
|
expectTrue(t, test_helpers.ListContainsString(rcts, rct2CID.String()))
|
|
expectTrue(t, test_helpers.ListContainsString(rcts, rct3CID.String()))
|
|
expectTrue(t, test_helpers.ListContainsString(rcts, rct4CID.String()))
|
|
expectTrue(t, test_helpers.ListContainsString(rcts, rct5CID.String()))
|
|
|
|
for idx, c := range rcts {
|
|
result := make([]models.IPLDModel, 0)
|
|
pgStr = `SELECT data
|
|
FROM eth.receipt_cids
|
|
INNER JOIN public.blocks ON (receipt_cids.leaf_mh_key = public.blocks.key)
|
|
WHERE receipt_cids.leaf_cid = $1`
|
|
err = sqlxdb.Select(&result, pgStr, c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// Decode the log leaf node.
|
|
var nodeElements []interface{}
|
|
err = rlp.DecodeBytes(result[0].Data, &nodeElements)
|
|
require.NoError(t, err)
|
|
|
|
expectedRct, err := mocks.MockReceipts[idx].MarshalBinary()
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, expectedRct, nodeElements[1].([]byte))
|
|
|
|
dc, err := cid.Decode(c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
mhKey := dshelp.MultihashToDsKey(dc.Hash())
|
|
prefixedKey := blockstore.BlockPrefix.String() + mhKey.String()
|
|
var data []byte
|
|
err = sqlxdb.Get(&data, ipfsPgGet, prefixedKey, mocks.BlockNumber.Uint64())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
postStatePgStr := `SELECT post_state FROM eth.receipt_cids WHERE leaf_cid = $1`
|
|
switch c {
|
|
case rct1CID.String():
|
|
require.Equal(t, rctLeaf1, data)
|
|
var postStatus uint64
|
|
pgStr = `SELECT post_status FROM eth.receipt_cids WHERE leaf_cid = $1`
|
|
err = sqlxdb.Get(&postStatus, pgStr, c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
require.Equal(t, mocks.ExpectedPostStatus, postStatus)
|
|
case rct2CID.String():
|
|
require.Equal(t, rctLeaf2, data)
|
|
var postState string
|
|
err = sqlxdb.Get(&postState, postStatePgStr, c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
require.Equal(t, mocks.ExpectedPostState1, postState)
|
|
case rct3CID.String():
|
|
require.Equal(t, rctLeaf3, data)
|
|
var postState string
|
|
err = sqlxdb.Get(&postState, postStatePgStr, c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
require.Equal(t, mocks.ExpectedPostState2, postState)
|
|
case rct4CID.String():
|
|
require.Equal(t, rctLeaf4, data)
|
|
var postState string
|
|
err = sqlxdb.Get(&postState, postStatePgStr, c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
require.Equal(t, mocks.ExpectedPostState3, postState)
|
|
case rct5CID.String():
|
|
require.Equal(t, rctLeaf5, data)
|
|
var postState string
|
|
err = sqlxdb.Get(&postState, postStatePgStr, c)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
require.Equal(t, mocks.ExpectedPostState3, postState)
|
|
}
|
|
}
|
|
}
|
|
|
|
func testPublishAndIndexStateIPLDs(t *testing.T) {
|
|
// check that state nodes were properly indexed and published
|
|
stateNodes := make([]models.StateNodeModel, 0)
|
|
pgStr := `SELECT state_cids.cid, state_cids.state_leaf_key, state_cids.node_type, state_cids.state_path, state_cids.header_id
|
|
FROM eth.state_cids INNER JOIN eth.header_cids ON (state_cids.header_id = header_cids.block_hash)
|
|
WHERE header_cids.block_number = $1 AND node_type != 3`
|
|
err = sqlxdb.Select(&stateNodes, pgStr, mocks.BlockNumber.Uint64())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
require.Equal(t, 2, len(stateNodes))
|
|
for _, stateNode := range stateNodes {
|
|
var data []byte
|
|
dc, err := cid.Decode(stateNode.CID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
mhKey := dshelp.MultihashToDsKey(dc.Hash())
|
|
prefixedKey := blockstore.BlockPrefix.String() + mhKey.String()
|
|
err = sqlxdb.Get(&data, ipfsPgGet, prefixedKey, mocks.BlockNumber.Uint64())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
pgStr = `SELECT cast(block_number AS TEXT), header_id, state_path, cast(balance AS TEXT), nonce, code_hash, storage_root from eth.state_accounts WHERE header_id = $1 AND state_path = $2`
|
|
var account models.StateAccountModel
|
|
err = sqlxdb.Get(&account, pgStr, stateNode.HeaderID, stateNode.Path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if stateNode.CID == state1CID.String() {
|
|
require.Equal(t, 2, stateNode.NodeType)
|
|
require.Equal(t, common.BytesToHash(mocks.ContractLeafKey).Hex(), stateNode.StateKey)
|
|
require.Equal(t, []byte{'\x06'}, stateNode.Path)
|
|
require.Equal(t, mocks.ContractLeafNode, data)
|
|
require.Equal(t, models.StateAccountModel{
|
|
BlockNumber: mocks.BlockNumber.String(),
|
|
HeaderID: account.HeaderID,
|
|
StatePath: stateNode.Path,
|
|
Balance: "0",
|
|
CodeHash: mocks.ContractCodeHash.Bytes(),
|
|
StorageRoot: mocks.ContractRoot,
|
|
Nonce: 1,
|
|
}, account)
|
|
}
|
|
if stateNode.CID == state2CID.String() {
|
|
require.Equal(t, 2, stateNode.NodeType)
|
|
require.Equal(t, common.BytesToHash(mocks.AccountLeafKey).Hex(), stateNode.StateKey)
|
|
require.Equal(t, []byte{'\x0c'}, stateNode.Path)
|
|
require.Equal(t, mocks.AccountLeafNode, data)
|
|
require.Equal(t, models.StateAccountModel{
|
|
BlockNumber: mocks.BlockNumber.String(),
|
|
HeaderID: account.HeaderID,
|
|
StatePath: stateNode.Path,
|
|
Balance: "1000",
|
|
CodeHash: mocks.AccountCodeHash.Bytes(),
|
|
StorageRoot: mocks.AccountRoot,
|
|
Nonce: 0,
|
|
}, account)
|
|
}
|
|
}
|
|
|
|
// check that Removed state nodes were properly indexed and published
|
|
stateNodes = make([]models.StateNodeModel, 0)
|
|
pgStr = `SELECT state_cids.cid, state_cids.state_leaf_key, state_cids.node_type, state_cids.state_path, state_cids.header_id
|
|
FROM eth.state_cids INNER JOIN eth.header_cids ON (state_cids.header_id = header_cids.block_hash)
|
|
WHERE header_cids.block_number = $1 AND node_type = 3`
|
|
err = sqlxdb.Select(&stateNodes, pgStr, mocks.BlockNumber.Uint64())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
require.Equal(t, 2, len(stateNodes))
|
|
for idx, stateNode := range stateNodes {
|
|
var data []byte
|
|
dc, err := cid.Decode(stateNode.CID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
mhKey := dshelp.MultihashToDsKey(dc.Hash())
|
|
prefixedKey := blockstore.BlockPrefix.String() + mhKey.String()
|
|
require.Equal(t, shared.RemovedNodeMhKey, prefixedKey)
|
|
err = sqlxdb.Get(&data, ipfsPgGet, prefixedKey, mocks.BlockNumber.Uint64())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if idx == 0 {
|
|
require.Equal(t, shared.RemovedNodeStateCID, stateNode.CID)
|
|
require.Equal(t, common.BytesToHash(mocks.RemovedLeafKey).Hex(), stateNode.StateKey)
|
|
require.Equal(t, []byte{'\x02'}, stateNode.Path)
|
|
require.Equal(t, []byte{}, data)
|
|
}
|
|
if idx == 1 {
|
|
require.Equal(t, shared.RemovedNodeStateCID, stateNode.CID)
|
|
require.Equal(t, common.BytesToHash(mocks.Contract2LeafKey).Hex(), stateNode.StateKey)
|
|
require.Equal(t, []byte{'\x07'}, stateNode.Path)
|
|
require.Equal(t, []byte{}, data)
|
|
}
|
|
}
|
|
}
|
|
|
|
func testPublishAndIndexStorageIPLDs(t *testing.T) {
|
|
// check that storage nodes were properly indexed
|
|
storageNodes := make([]models.StorageNodeWithStateKeyModel, 0)
|
|
pgStr := `SELECT cast(storage_cids.block_number AS TEXT), storage_cids.cid, state_cids.state_leaf_key, storage_cids.storage_leaf_key, storage_cids.node_type, storage_cids.storage_path
|
|
FROM eth.storage_cids, eth.state_cids, eth.header_cids
|
|
WHERE (storage_cids.state_path, storage_cids.header_id) = (state_cids.state_path, state_cids.header_id)
|
|
AND state_cids.header_id = header_cids.block_hash
|
|
AND header_cids.block_number = $1
|
|
AND storage_cids.node_type != 3`
|
|
err = sqlxdb.Select(&storageNodes, pgStr, mocks.BlockNumber.Uint64())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
require.Equal(t, 1, len(storageNodes))
|
|
require.Equal(t, models.StorageNodeWithStateKeyModel{
|
|
BlockNumber: mocks.BlockNumber.String(),
|
|
CID: storageCID.String(),
|
|
NodeType: 2,
|
|
StorageKey: common.BytesToHash(mocks.StorageLeafKey).Hex(),
|
|
StateKey: common.BytesToHash(mocks.ContractLeafKey).Hex(),
|
|
Path: []byte{},
|
|
}, storageNodes[0])
|
|
var data []byte
|
|
dc, err := cid.Decode(storageNodes[0].CID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
mhKey := dshelp.MultihashToDsKey(dc.Hash())
|
|
prefixedKey := blockstore.BlockPrefix.String() + mhKey.String()
|
|
err = sqlxdb.Get(&data, ipfsPgGet, prefixedKey, mocks.BlockNumber.Uint64())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
require.Equal(t, mocks.StorageLeafNode, data)
|
|
|
|
// check that Removed storage nodes were properly indexed
|
|
storageNodes = make([]models.StorageNodeWithStateKeyModel, 0)
|
|
pgStr = `SELECT cast(storage_cids.block_number AS TEXT), storage_cids.cid, state_cids.state_leaf_key, storage_cids.storage_leaf_key, storage_cids.node_type, storage_cids.storage_path
|
|
FROM eth.storage_cids, eth.state_cids, eth.header_cids
|
|
WHERE (storage_cids.state_path, storage_cids.header_id) = (state_cids.state_path, state_cids.header_id)
|
|
AND state_cids.header_id = header_cids.block_hash
|
|
AND header_cids.block_number = $1
|
|
AND storage_cids.node_type = 3
|
|
ORDER BY storage_path`
|
|
err = sqlxdb.Select(&storageNodes, pgStr, mocks.BlockNumber.Uint64())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
require.Equal(t, 3, len(storageNodes))
|
|
expectedStorageNodes := []models.StorageNodeWithStateKeyModel{
|
|
{
|
|
BlockNumber: mocks.BlockNumber.String(),
|
|
CID: shared.RemovedNodeStorageCID,
|
|
NodeType: 3,
|
|
StorageKey: common.BytesToHash(mocks.RemovedLeafKey).Hex(),
|
|
StateKey: common.BytesToHash(mocks.ContractLeafKey).Hex(),
|
|
Path: []byte{'\x03'},
|
|
},
|
|
{
|
|
BlockNumber: mocks.BlockNumber.String(),
|
|
CID: shared.RemovedNodeStorageCID,
|
|
NodeType: 3,
|
|
StorageKey: common.BytesToHash(mocks.Storage2LeafKey).Hex(),
|
|
StateKey: common.BytesToHash(mocks.Contract2LeafKey).Hex(),
|
|
Path: []byte{'\x0e'},
|
|
},
|
|
{
|
|
BlockNumber: mocks.BlockNumber.String(),
|
|
CID: shared.RemovedNodeStorageCID,
|
|
NodeType: 3,
|
|
StorageKey: common.BytesToHash(mocks.Storage3LeafKey).Hex(),
|
|
StateKey: common.BytesToHash(mocks.Contract2LeafKey).Hex(),
|
|
Path: []byte{'\x0f'},
|
|
},
|
|
}
|
|
for idx, storageNode := range storageNodes {
|
|
require.Equal(t, expectedStorageNodes[idx], storageNode)
|
|
dc, err = cid.Decode(storageNode.CID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
mhKey = dshelp.MultihashToDsKey(dc.Hash())
|
|
prefixedKey = blockstore.BlockPrefix.String() + mhKey.String()
|
|
require.Equal(t, shared.RemovedNodeMhKey, prefixedKey, mocks.BlockNumber.Uint64())
|
|
err = sqlxdb.Get(&data, ipfsPgGet, prefixedKey, mocks.BlockNumber.Uint64())
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
require.Equal(t, []byte{}, data)
|
|
}
|
|
}
|
|
|
|
func testLoadEmptyWatchedAddresses(t *testing.T) {
|
|
expectedData := []common.Address{}
|
|
|
|
rows, err := ind.LoadWatchedAddresses()
|
|
require.NoError(t, err)
|
|
|
|
expectTrue(t, len(rows) == len(expectedData))
|
|
for idx, row := range rows {
|
|
require.Equal(t, expectedData[idx], row)
|
|
}
|
|
}
|
|
|
|
type res struct {
|
|
Address string `db:"address"`
|
|
CreatedAt uint64 `db:"created_at"`
|
|
WatchedAt uint64 `db:"watched_at"`
|
|
LastFilledAt uint64 `db:"last_filled_at"`
|
|
}
|
|
|
|
func testInsertWatchedAddresses(t *testing.T, resetAndDumpData func(*testing.T)) {
|
|
args := []sdtypes.WatchAddressArg{
|
|
{
|
|
Address: contract1Address,
|
|
CreatedAt: contract1CreatedAt,
|
|
},
|
|
{
|
|
Address: contract2Address,
|
|
CreatedAt: contract2CreatedAt,
|
|
},
|
|
}
|
|
expectedData := []res{
|
|
{
|
|
Address: contract1Address,
|
|
CreatedAt: contract1CreatedAt,
|
|
WatchedAt: watchedAt1,
|
|
LastFilledAt: lastFilledAt,
|
|
},
|
|
{
|
|
Address: contract2Address,
|
|
CreatedAt: contract2CreatedAt,
|
|
WatchedAt: watchedAt1,
|
|
LastFilledAt: lastFilledAt,
|
|
},
|
|
}
|
|
|
|
err = ind.InsertWatchedAddresses(args, big.NewInt(int64(watchedAt1)))
|
|
require.NoError(t, err)
|
|
resetAndDumpData(t)
|
|
|
|
rows := []res{}
|
|
err = sqlxdb.Select(&rows, watchedAddressesPgGet)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expectTrue(t, len(rows) == len(expectedData))
|
|
for idx, row := range rows {
|
|
require.Equal(t, expectedData[idx], row)
|
|
}
|
|
}
|
|
|
|
func testInsertAlreadyWatchedAddresses(t *testing.T, resetAndDumpData func(*testing.T)) {
|
|
args := []sdtypes.WatchAddressArg{
|
|
{
|
|
Address: contract3Address,
|
|
CreatedAt: contract3CreatedAt,
|
|
},
|
|
{
|
|
Address: contract2Address,
|
|
CreatedAt: contract2CreatedAt,
|
|
},
|
|
}
|
|
expectedData := []res{
|
|
{
|
|
Address: contract1Address,
|
|
CreatedAt: contract1CreatedAt,
|
|
WatchedAt: watchedAt1,
|
|
LastFilledAt: lastFilledAt,
|
|
},
|
|
{
|
|
Address: contract2Address,
|
|
CreatedAt: contract2CreatedAt,
|
|
WatchedAt: watchedAt1,
|
|
LastFilledAt: lastFilledAt,
|
|
},
|
|
{
|
|
Address: contract3Address,
|
|
CreatedAt: contract3CreatedAt,
|
|
WatchedAt: watchedAt2,
|
|
LastFilledAt: lastFilledAt,
|
|
},
|
|
}
|
|
|
|
err = ind.InsertWatchedAddresses(args, big.NewInt(int64(watchedAt2)))
|
|
require.NoError(t, err)
|
|
resetAndDumpData(t)
|
|
|
|
rows := []res{}
|
|
err = sqlxdb.Select(&rows, watchedAddressesPgGet)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expectTrue(t, len(rows) == len(expectedData))
|
|
for idx, row := range rows {
|
|
require.Equal(t, expectedData[idx], row)
|
|
}
|
|
}
|
|
|
|
func testRemoveWatchedAddresses(t *testing.T, resetAndDumpData func(*testing.T)) {
|
|
args := []sdtypes.WatchAddressArg{
|
|
{
|
|
Address: contract3Address,
|
|
CreatedAt: contract3CreatedAt,
|
|
},
|
|
{
|
|
Address: contract2Address,
|
|
CreatedAt: contract2CreatedAt,
|
|
},
|
|
}
|
|
expectedData := []res{
|
|
{
|
|
Address: contract1Address,
|
|
CreatedAt: contract1CreatedAt,
|
|
WatchedAt: watchedAt1,
|
|
LastFilledAt: lastFilledAt,
|
|
},
|
|
}
|
|
|
|
err = ind.RemoveWatchedAddresses(args)
|
|
require.NoError(t, err)
|
|
resetAndDumpData(t)
|
|
|
|
rows := []res{}
|
|
err = sqlxdb.Select(&rows, watchedAddressesPgGet)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expectTrue(t, len(rows) == len(expectedData))
|
|
for idx, row := range rows {
|
|
require.Equal(t, expectedData[idx], row)
|
|
}
|
|
}
|
|
|
|
func testRemoveNonWatchedAddresses(t *testing.T, resetAndDumpData func(*testing.T)) {
|
|
args := []sdtypes.WatchAddressArg{
|
|
{
|
|
Address: contract1Address,
|
|
CreatedAt: contract1CreatedAt,
|
|
},
|
|
{
|
|
Address: contract2Address,
|
|
CreatedAt: contract2CreatedAt,
|
|
},
|
|
}
|
|
expectedData := []res{}
|
|
|
|
err = ind.RemoveWatchedAddresses(args)
|
|
require.NoError(t, err)
|
|
resetAndDumpData(t)
|
|
|
|
rows := []res{}
|
|
err = sqlxdb.Select(&rows, watchedAddressesPgGet)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expectTrue(t, len(rows) == len(expectedData))
|
|
for idx, row := range rows {
|
|
require.Equal(t, expectedData[idx], row)
|
|
}
|
|
}
|
|
|
|
func testSetWatchedAddresses(t *testing.T, resetAndDumpData func(*testing.T)) {
|
|
args := []sdtypes.WatchAddressArg{
|
|
{
|
|
Address: contract1Address,
|
|
CreatedAt: contract1CreatedAt,
|
|
},
|
|
{
|
|
Address: contract2Address,
|
|
CreatedAt: contract2CreatedAt,
|
|
},
|
|
{
|
|
Address: contract3Address,
|
|
CreatedAt: contract3CreatedAt,
|
|
},
|
|
}
|
|
expectedData := []res{
|
|
{
|
|
Address: contract1Address,
|
|
CreatedAt: contract1CreatedAt,
|
|
WatchedAt: watchedAt2,
|
|
LastFilledAt: lastFilledAt,
|
|
},
|
|
{
|
|
Address: contract2Address,
|
|
CreatedAt: contract2CreatedAt,
|
|
WatchedAt: watchedAt2,
|
|
LastFilledAt: lastFilledAt,
|
|
},
|
|
{
|
|
Address: contract3Address,
|
|
CreatedAt: contract3CreatedAt,
|
|
WatchedAt: watchedAt2,
|
|
LastFilledAt: lastFilledAt,
|
|
},
|
|
}
|
|
|
|
err = ind.SetWatchedAddresses(args, big.NewInt(int64(watchedAt2)))
|
|
require.NoError(t, err)
|
|
resetAndDumpData(t)
|
|
|
|
rows := []res{}
|
|
err = sqlxdb.Select(&rows, watchedAddressesPgGet)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expectTrue(t, len(rows) == len(expectedData))
|
|
for idx, row := range rows {
|
|
require.Equal(t, expectedData[idx], row)
|
|
}
|
|
}
|
|
|
|
func testSetAlreadyWatchedAddresses(t *testing.T, resetAndDumpData func(*testing.T)) {
|
|
args := []sdtypes.WatchAddressArg{
|
|
{
|
|
Address: contract4Address,
|
|
CreatedAt: contract4CreatedAt,
|
|
},
|
|
{
|
|
Address: contract2Address,
|
|
CreatedAt: contract2CreatedAt,
|
|
},
|
|
{
|
|
Address: contract3Address,
|
|
CreatedAt: contract3CreatedAt,
|
|
},
|
|
}
|
|
expectedData := []res{
|
|
{
|
|
Address: contract4Address,
|
|
CreatedAt: contract4CreatedAt,
|
|
WatchedAt: watchedAt3,
|
|
LastFilledAt: lastFilledAt,
|
|
},
|
|
{
|
|
Address: contract2Address,
|
|
CreatedAt: contract2CreatedAt,
|
|
WatchedAt: watchedAt3,
|
|
LastFilledAt: lastFilledAt,
|
|
},
|
|
{
|
|
Address: contract3Address,
|
|
CreatedAt: contract3CreatedAt,
|
|
WatchedAt: watchedAt3,
|
|
LastFilledAt: lastFilledAt,
|
|
},
|
|
}
|
|
|
|
err = ind.SetWatchedAddresses(args, big.NewInt(int64(watchedAt3)))
|
|
require.NoError(t, err)
|
|
resetAndDumpData(t)
|
|
|
|
rows := []res{}
|
|
err = sqlxdb.Select(&rows, watchedAddressesPgGet)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expectTrue(t, len(rows) == len(expectedData))
|
|
for idx, row := range rows {
|
|
require.Equal(t, expectedData[idx], row)
|
|
}
|
|
}
|
|
|
|
func testLoadWatchedAddresses(t *testing.T) {
|
|
expectedData := []common.Address{
|
|
common.HexToAddress(contract4Address),
|
|
common.HexToAddress(contract2Address),
|
|
common.HexToAddress(contract3Address),
|
|
}
|
|
|
|
rows, err := ind.LoadWatchedAddresses()
|
|
require.NoError(t, err)
|
|
|
|
expectTrue(t, len(rows) == len(expectedData))
|
|
for idx, row := range rows {
|
|
require.Equal(t, expectedData[idx], row)
|
|
}
|
|
}
|
|
|
|
func testClearWatchedAddresses(t *testing.T, resetAndDumpData func(*testing.T)) {
|
|
expectedData := []res{}
|
|
|
|
err = ind.ClearWatchedAddresses()
|
|
require.NoError(t, err)
|
|
resetAndDumpData(t)
|
|
|
|
rows := []res{}
|
|
err = sqlxdb.Select(&rows, watchedAddressesPgGet)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expectTrue(t, len(rows) == len(expectedData))
|
|
for idx, row := range rows {
|
|
require.Equal(t, expectedData[idx], row)
|
|
}
|
|
}
|
|
|
|
func testClearEmptyWatchedAddresses(t *testing.T, resetAndDumpData func(*testing.T)) {
|
|
expectedData := []res{}
|
|
|
|
err = ind.ClearWatchedAddresses()
|
|
require.NoError(t, err)
|
|
resetAndDumpData(t)
|
|
|
|
rows := []res{}
|
|
err = sqlxdb.Select(&rows, watchedAddressesPgGet)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
expectTrue(t, len(rows) == len(expectedData))
|
|
for idx, row := range rows {
|
|
require.Equal(t, expectedData[idx], row)
|
|
}
|
|
}
|