ipld-eth-server/pkg/ipfs/mocks/test_data.go

// VulcanizeDB
// Copyright © 2019 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 mocks

import (
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"math/big"
	rand2 "math/rand"

	"github.com/ipfs/go-block-format"
	"github.com/vulcanize/vulcanizedb/libraries/shared/streamer"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/state"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/params"
	"github.com/ethereum/go-ethereum/rlp"
	"github.com/ethereum/go-ethereum/statediff"
	log "github.com/sirupsen/logrus"

	"github.com/vulcanize/vulcanizedb/pkg/ipfs"
)

// Test variables
var (
	// block data
	BlockNumber = big.NewInt(rand2.Int63())
	MockHeader  = types.Header{
		Time:        0,
		Number:      BlockNumber,
		Root:        common.HexToHash("0x0"),
		TxHash:      common.HexToHash("0x0"),
		ReceiptHash: common.HexToHash("0x0"),
	}
	MockTransactions, MockReceipts, senderAddr = createTransactionsAndReceipts()
	ReceiptsRlp, _                             = rlp.EncodeToBytes(MockReceipts)
	MockBlock                                  = types.NewBlock(&MockHeader, MockTransactions, nil, MockReceipts)
	MockBlockRlp, _                            = rlp.EncodeToBytes(MockBlock)
	MockHeaderRlp, _                           = rlp.EncodeToBytes(MockBlock.Header())
	MockTrxMeta                                = []*ipfs.TrxMetaData{
		{
			CID: "", // This is empty until we go to publish to ipfs
			Src: senderAddr.Hex(),
			Dst: "0x0000000000000000000000000000000000000000",
		},
		{
			CID: "",
			Src: senderAddr.Hex(),
			Dst: "0x0000000000000000000000000000000000000001",
		},
	}
	MockRctMeta = []*ipfs.ReceiptMetaData{
		{
			CID: "",
			Topic0s: []string{
				"0x0000000000000000000000000000000000000000000000000000000000000004",
			},
			ContractAddress: "0x0000000000000000000000000000000000000000",
		},
		{
			CID: "",
			Topic0s: []string{
				"0x0000000000000000000000000000000000000000000000000000000000000005",
			},
			ContractAddress: "0x0000000000000000000000000000000000000001",
		},
	}

	// statediff data
	CodeHash            = common.Hex2Bytes("0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470")
	NonceValue          = rand2.Uint64()
	anotherNonceValue   = rand2.Uint64()
	BalanceValue        = rand2.Int63()
	anotherBalanceValue = rand2.Int63()
	ContractRoot        = common.HexToHash("0x56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421")
	StoragePath         = common.HexToHash("0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470").Bytes()
	StorageKey          = common.HexToHash("0000000000000000000000000000000000000000000000000000000000000001").Bytes()
	StorageValue        = common.Hex2Bytes("0x03")
	storage             = []statediff.StorageDiff{{
		Key:   StorageKey,
		Value: StorageValue,
		Path:  StoragePath,
		Proof: [][]byte{},
		Leaf:  true,
	}}
	emptyStorage           = make([]statediff.StorageDiff, 0)
	Address                = common.HexToAddress("0xaE9BEa628c4Ce503DcFD7E305CaB4e29E7476592")
	ContractLeafKey        = ipfs.AddressToKey(Address)
	AnotherAddress         = common.HexToAddress("0xaE9BEa628c4Ce503DcFD7E305CaB4e29E7476593")
	AnotherContractLeafKey = ipfs.AddressToKey(AnotherAddress)
	testAccount            = state.Account{
		Nonce:    NonceValue,
		Balance:  big.NewInt(BalanceValue),
		Root:     ContractRoot,
		CodeHash: CodeHash,
	}
	anotherTestAccount = state.Account{
		Nonce:    anotherNonceValue,
		Balance:  big.NewInt(anotherBalanceValue),
		Root:     common.HexToHash("0x"),
		CodeHash: nil,
	}
	ValueBytes, _        = rlp.EncodeToBytes(testAccount)
	AnotherValueBytes, _ = rlp.EncodeToBytes(anotherTestAccount)
	CreatedAccountDiffs  = []statediff.AccountDiff{
		{
			Key:     ContractLeafKey.Bytes(),
			Value:   ValueBytes,
			Storage: storage,
			Leaf:    true,
		},
		{
			Key:     AnotherContractLeafKey.Bytes(),
			Value:   AnotherValueBytes,
			Storage: emptyStorage,
			Leaf:    true,
		},
	}

	MockStateDiff = statediff.StateDiff{
		BlockNumber:     BlockNumber,
		BlockHash:       MockBlock.Hash(),
		CreatedAccounts: CreatedAccountDiffs,
	}
	MockStateDiffBytes, _ = rlp.EncodeToBytes(MockStateDiff)
	MockStateNodes        = map[common.Hash]ipfs.StateNode{
		ContractLeafKey: {
			Value: ValueBytes,
			Leaf:  true,
		},
		AnotherContractLeafKey: {
			Value: AnotherValueBytes,
			Leaf:  true,
		},
	}
	MockStorageNodes = map[common.Hash][]ipfs.StorageNode{
		ContractLeafKey: {
			{
				Key:   common.BytesToHash(StorageKey),
				Value: StorageValue,
				Leaf:  true,
			},
		},
	}

	// aggregate payloads
	MockStateDiffPayload = statediff.Payload{
		BlockRlp:     MockBlockRlp,
		StateDiffRlp: MockStateDiffBytes,
		ReceiptsRlp:  ReceiptsRlp,
	}

	MockIPLDPayload = &ipfs.IPLDPayload{
		BlockNumber: big.NewInt(1),
		BlockHash:   MockBlock.Hash(),
		Receipts:    MockReceipts,
		HeaderRLP:   MockHeaderRlp,
		BlockBody:   MockBlock.Body(),
		TrxMetaData: []*ipfs.TrxMetaData{
			{
				CID: "",
				Src: senderAddr.Hex(),
				Dst: "0x0000000000000000000000000000000000000000",
			},
			{
				CID: "",
				Src: senderAddr.Hex(),
				Dst: "0x0000000000000000000000000000000000000001",
			},
		},
		ReceiptMetaData: []*ipfs.ReceiptMetaData{
			{
				CID: "",
				Topic0s: []string{
					"0x0000000000000000000000000000000000000000000000000000000000000004",
				},
				ContractAddress: "0x0000000000000000000000000000000000000000",
			},
			{
				CID: "",
				Topic0s: []string{
					"0x0000000000000000000000000000000000000000000000000000000000000005",
				},
				ContractAddress: "0x0000000000000000000000000000000000000001",
			},
		},
		StorageNodes: MockStorageNodes,
		StateNodes:   MockStateNodes,
	}

	MockCIDPayload = &ipfs.CIDPayload{
		BlockNumber: "1",
		BlockHash:   MockBlock.Hash(),
		HeaderCID:   "mockHeaderCID",
		UncleCIDs:   make(map[common.Hash]string),
		TransactionCIDs: map[common.Hash]*ipfs.TrxMetaData{
			MockTransactions[0].Hash(): {
				CID: "mockTrxCID1",
				Dst: "0x0000000000000000000000000000000000000000",
				Src: senderAddr.Hex(),
			},
			MockTransactions[1].Hash(): {
				CID: "mockTrxCID2",
				Dst: "0x0000000000000000000000000000000000000001",
				Src: senderAddr.Hex(),
			},
		},
		ReceiptCIDs: map[common.Hash]*ipfs.ReceiptMetaData{
			MockTransactions[0].Hash(): {
				CID:             "mockRctCID1",
				Topic0s:         []string{"0x0000000000000000000000000000000000000000000000000000000000000004"},
				ContractAddress: "0x0000000000000000000000000000000000000000",
			},
			MockTransactions[1].Hash(): {
				CID:             "mockRctCID2",
				Topic0s:         []string{"0x0000000000000000000000000000000000000000000000000000000000000005"},
				ContractAddress: "0x0000000000000000000000000000000000000001",
			},
		},
		StateNodeCIDs: map[common.Hash]ipfs.StateNodeCID{
			ContractLeafKey: {
				CID:  "mockStateCID1",
				Leaf: true,
				Key:  "",
			},
			AnotherContractLeafKey: {
				CID:  "mockStateCID2",
				Leaf: true,
				Key:  "",
			},
		},
		StorageNodeCIDs: map[common.Hash][]ipfs.StorageNodeCID{
			ContractLeafKey: {
				{
					CID:      "mockStorageCID",
					Key:      "0x0000000000000000000000000000000000000000000000000000000000000001",
					Leaf:     true,
					StateKey: "",
				},
			},
		},
	}

	MockCIDWrapper = &ipfs.CIDWrapper{
		BlockNumber:  big.NewInt(1),
		Headers:      []string{"mockHeaderCID"},
		Transactions: []string{"mockTrxCID1", "mockTrxCID2"},
		Receipts:     []string{"mockRctCID1", "mockRctCID2"},
		Uncles:       []string{},
		StateNodes: []ipfs.StateNodeCID{
			{
				CID:  "mockStateCID1",
				Leaf: true,
				Key:  ContractLeafKey.Hex(),
			},
			{
				CID:  "mockStateCID2",
				Leaf: true,
				Key:  AnotherContractLeafKey.Hex(),
			},
		},
		StorageNodes: []ipfs.StorageNodeCID{
			{
				CID:      "mockStorageCID",
				Leaf:     true,
				StateKey: ContractLeafKey.Hex(),
				Key:      "0x0000000000000000000000000000000000000000000000000000000000000001",
			},
		},
	}

	MockIPLDWrapper = ipfs.IPLDWrapper{
		BlockNumber: big.NewInt(1),
		Headers: []blocks.Block{
			blocks.NewBlock(MockHeaderRlp),
		},
		Transactions: []blocks.Block{
			blocks.NewBlock(MockTransactions.GetRlp(0)),
			blocks.NewBlock(MockTransactions.GetRlp(1)),
		},
		Receipts: []blocks.Block{
			blocks.NewBlock(MockReceipts.GetRlp(0)),
			blocks.NewBlock(MockReceipts.GetRlp(1)),
		},
		StateNodes: map[common.Hash]blocks.Block{
			ContractLeafKey:        blocks.NewBlock(ValueBytes),
			AnotherContractLeafKey: blocks.NewBlock(AnotherValueBytes),
		},
		StorageNodes: map[common.Hash]map[common.Hash]blocks.Block{
			ContractLeafKey: {
				common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"): blocks.NewBlock(StorageValue),
			},
		},
	}

	MockSeeNodePayload = streamer.SuperNodePayload{
		BlockNumber:     big.NewInt(1),
		HeadersRlp:      [][]byte{MockHeaderRlp},
		TransactionsRlp: [][]byte{MockTransactions.GetRlp(0), MockTransactions.GetRlp(1)},
		ReceiptsRlp:     [][]byte{MockTransactions.GetRlp(0), MockTransactions.GetRlp(1)},
		StateNodesRlp: map[common.Hash][]byte{
			ContractLeafKey:        ValueBytes,
			AnotherContractLeafKey: AnotherValueBytes,
		},
		StorageNodesRlp: map[common.Hash]map[common.Hash][]byte{
			ContractLeafKey: {
				common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000001"): StorageValue,
			},
		},
	}
)

// createTransactionsAndReceipts is a helper function to generate signed mock transactions and mock receipts with mock logs
func createTransactionsAndReceipts() (types.Transactions, types.Receipts, common.Address) {
	// make transactions
	trx1 := types.NewTransaction(0, common.HexToAddress("0x0"), big.NewInt(1000), 50, big.NewInt(100), nil)
	trx2 := types.NewTransaction(1, common.HexToAddress("0x1"), big.NewInt(2000), 100, big.NewInt(200), nil)
	transactionSigner := types.MakeSigner(params.MainnetChainConfig, BlockNumber)
	mockCurve := elliptic.P256()
	mockPrvKey, err := ecdsa.GenerateKey(mockCurve, rand.Reader)
	if err != nil {
		log.Fatal(err)
	}
	signedTrx1, err := types.SignTx(trx1, transactionSigner, mockPrvKey)
	if err != nil {
		log.Fatal(err)
	}
	signedTrx2, err := types.SignTx(trx2, transactionSigner, mockPrvKey)
	if err != nil {
		log.Fatal(err)
	}
	senderAddr, err := types.Sender(transactionSigner, signedTrx1) // same for both trx
	if err != nil {
		log.Fatal(err)
	}
	// make receipts
	mockTopic1 := common.HexToHash("0x04")
	mockReceipt1 := types.NewReceipt(common.HexToHash("0x0").Bytes(), false, 50)
	mockReceipt1.ContractAddress = common.HexToAddress("0xaE9BEa628c4Ce503DcFD7E305CaB4e29E7476592")
	mockLog1 := &types.Log{
		Topics: []common.Hash{mockTopic1},
	}
	mockReceipt1.Logs = []*types.Log{mockLog1}
	mockReceipt1.TxHash = signedTrx1.Hash()
	mockTopic2 := common.HexToHash("0x05")
	mockReceipt2 := types.NewReceipt(common.HexToHash("0x1").Bytes(), false, 100)
	mockReceipt2.ContractAddress = common.HexToAddress("0xaE9BEa628c4Ce503DcFD7E305CaB4e29E7476593")
	mockLog2 := &types.Log{
		Topics: []common.Hash{mockTopic2},
	}
	mockReceipt2.Logs = []*types.Log{mockLog2}
	mockReceipt2.TxHash = signedTrx2.Hash()
	return types.Transactions{signedTrx1, signedTrx2}, types.Receipts{mockReceipt1, mockReceipt2}, senderAddr
}