package itests import ( "context" "encoding/hex" "encoding/json" "os" "reflect" "strconv" "testing" "time" "github.com/stretchr/testify/require" "golang.org/x/crypto/sha3" "github.com/filecoin-project/go-state-types/big" "github.com/filecoin-project/go-state-types/manifest" gstStore "github.com/filecoin-project/go-state-types/store" "github.com/filecoin-project/lotus/api" "github.com/filecoin-project/lotus/blockstore" "github.com/filecoin-project/lotus/build" "github.com/filecoin-project/lotus/chain/actors/builtin/evm" "github.com/filecoin-project/lotus/chain/types" "github.com/filecoin-project/lotus/chain/types/ethtypes" "github.com/filecoin-project/lotus/itests/kit" ) // TestDeployment smoke tests the deployment of a contract via the // Ethereum JSON-RPC endpoint, from an EEOA. func TestDeployment(t *testing.T) { blockTime := 100 * time.Millisecond client, _, ens := kit.EnsembleMinimal( t, kit.MockProofs(), kit.ThroughRPC()) miners := ens.InterconnectAll().BeginMining(blockTime) ctx, cancel := context.WithTimeout(context.Background(), time.Minute) defer cancel() // install contract contractHex, err := os.ReadFile("./contracts/SimpleCoin.hex") require.NoError(t, err) contract, err := hex.DecodeString(string(contractHex)) require.NoError(t, err) // create a new Ethereum account key, ethAddr, deployer := client.EVM().NewAccount() // send some funds to the f410 address kit.SendFunds(ctx, t, client, deployer, types.FromFil(10)) // verify balances. bal := client.EVM().AssertAddressBalanceConsistent(ctx, deployer) require.Equal(t, types.FromFil(10), bal) // verify the deployer address is an Placeholder. client.AssertActorType(ctx, deployer, manifest.PlaceholderKey) gaslimit, err := client.EthEstimateGas(ctx, ethtypes.EthCall{ From: ðAddr, Data: contract, }) require.NoError(t, err) maxPriorityFeePerGas, err := client.EthMaxPriorityFeePerGas(ctx) require.NoError(t, err) // now deploy a contract from the placeholder, and validate it went well tx := ethtypes.EthTxArgs{ ChainID: build.Eip155ChainId, Value: big.Zero(), Nonce: 0, MaxFeePerGas: types.NanoFil, MaxPriorityFeePerGas: big.Int(maxPriorityFeePerGas), GasLimit: int(gaslimit), Input: contract, V: big.Zero(), R: big.Zero(), S: big.Zero(), } client.EVM().SignTransaction(&tx, key.PrivateKey) pendingFilter, err := client.EthNewPendingTransactionFilter(ctx) require.NoError(t, err) // Pause so we can test that everything works while the message is in the message pool. for _, miner := range miners { miner.Pause() } hash := client.EVM().SubmitTransaction(ctx, &tx) mpoolTx, err := client.EthGetTransactionByHash(ctx, &hash) require.NoError(t, err) require.NotNil(t, mpoolTx) // require that the hashes are identical require.Equal(t, hash, mpoolTx.Hash) // these fields should be nil because the tx hasn't landed on chain. require.Nil(t, mpoolTx.BlockNumber) require.Nil(t, mpoolTx.BlockHash) require.Nil(t, mpoolTx.TransactionIndex) // We should be able to get the message CID immediately. mCid, err := client.EthGetMessageCidByTransactionHash(ctx, &hash) require.NoError(t, err) require.NotNil(t, mCid) // ... and it should map back to the transaction hash. mHash, err := client.EthGetTransactionHashByCid(ctx, *mCid) require.NoError(t, err) require.NotNil(t, mHash) require.Equal(t, hash, *mHash) changes, err := client.EthGetFilterChanges(ctx, pendingFilter) require.NoError(t, err) require.Len(t, changes.Results, 1) require.Equal(t, hash.String(), changes.Results[0]) // Unpause mining. for _, miner := range miners { miner.Restart() } // Wait for the message to land. _, err = client.StateWaitMsg(ctx, *mCid, 3, api.LookbackNoLimit, false) require.NoError(t, err) // Then lookup the receipt. receipt, err := client.EthGetTransactionReceipt(ctx, hash) require.NoError(t, err) require.NotNil(t, receipt) // logs must be an empty array, not a nil value, to avoid tooling compatibility issues require.Empty(t, receipt.Logs) // a correctly formed logs bloom, albeit empty, has 256 zeroes require.Len(t, receipt.LogsBloom, 256) require.Equal(t, ethtypes.EthBytes(make([]byte, 256)), receipt.LogsBloom) // Success. require.EqualValues(t, ethtypes.EthUint64(0x1), receipt.Status) // Verify that the chain transaction now has new fields set. chainTx, err := client.EthGetTransactionByHash(ctx, &hash) require.NoError(t, err) // require that the hashes are identical require.Equal(t, hash, chainTx.Hash) require.NotNil(t, chainTx.BlockNumber) require.Greater(t, uint64(*chainTx.BlockNumber), uint64(0)) require.NotNil(t, chainTx.BlockHash) require.NotEmpty(t, *chainTx.BlockHash) require.NotNil(t, chainTx.TransactionIndex) require.Equal(t, uint64(*chainTx.TransactionIndex), uint64(0)) // only transaction // should return error with non-existent block hash nonExistentHash, err := ethtypes.ParseEthHash("0x62a80aa9262a3e1d3db0706af41c8535257b6275a283174cabf9d108d8946059") require.Nil(t, err) _, err = client.EthGetBlockByHash(ctx, nonExistentHash, false) require.NotNil(t, err) // verify block information block1, err := client.EthGetBlockByHash(ctx, *chainTx.BlockHash, false) require.Nil(t, err) require.Equal(t, block1.Hash, *chainTx.BlockHash) require.Equal(t, block1.Number, *chainTx.BlockNumber) for _, tx := range block1.Transactions { _, ok := tx.(string) require.True(t, ok) } require.Contains(t, block1.Transactions, hash.String()) // make sure the block got from EthGetBlockByNumber is the same blkNum := strconv.FormatInt(int64(*chainTx.BlockNumber), 10) block2, err := client.EthGetBlockByNumber(ctx, blkNum, false) require.Nil(t, err) require.True(t, reflect.DeepEqual(block1, block2)) // verify that the block contains full tx objects block3, err := client.EthGetBlockByHash(ctx, *chainTx.BlockHash, true) require.Nil(t, err) require.Equal(t, block3.Hash, *chainTx.BlockHash) require.Equal(t, block3.Number, *chainTx.BlockNumber) // the call went through json-rpc and the response was unmarshaled // into map[string]interface{}, so it has to be converted into ethtypes.EthTx var foundTx *ethtypes.EthTx for _, obj := range block3.Transactions { j, err := json.Marshal(obj) require.Nil(t, err) var tx ethtypes.EthTx err = json.Unmarshal(j, &tx) require.Nil(t, err) if tx.Hash == chainTx.Hash { foundTx = &tx } } require.NotNil(t, foundTx) require.True(t, reflect.DeepEqual(*foundTx, *chainTx)) // make sure the _full_ block got from EthGetBlockByNumber is the same block4, err := client.EthGetBlockByNumber(ctx, blkNum, true) require.Nil(t, err) require.True(t, reflect.DeepEqual(block3, block4)) // Verify that the deployer is now an account. client.AssertActorType(ctx, deployer, manifest.EthAccountKey) // Verify that the nonce was incremented. nonce, err := client.MpoolGetNonce(ctx, deployer) require.NoError(t, err) require.EqualValues(t, 1, nonce) // Verify that the deployer is now an account. client.AssertActorType(ctx, deployer, manifest.EthAccountKey) // Get contract address. contractAddr, err := client.EVM().ComputeContractAddress(ethAddr, 0).ToFilecoinAddress() require.NoError(t, err) client.AssertActorType(ctx, contractAddr, "evm") // Check bytecode and bytecode hash match. contractAct, err := client.StateGetActor(ctx, contractAddr, types.EmptyTSK) require.NoError(t, err) bs := blockstore.NewAPIBlockstore(client) ctxStore := gstStore.WrapBlockStore(ctx, bs) evmSt, err := evm.Load(ctxStore, contractAct) require.NoError(t, err) byteCodeCid, err := evmSt.GetBytecodeCID() require.NoError(t, err) byteCode, err := bs.Get(ctx, byteCodeCid) require.NoError(t, err) byteCodeHashChain, err := evmSt.GetBytecodeHash() require.NoError(t, err) hasher := sha3.NewLegacyKeccak256() hasher.Write(byteCode.RawData()) byteCodeHash := hasher.Sum(nil) require.Equal(t, byteCodeHashChain[:], byteCodeHash) byteCodeSt, err := evmSt.GetBytecode() require.NoError(t, err) require.Equal(t, byteCode.RawData(), byteCodeSt) }