feat: eth_getStorageAt standard empty response

Author: ptrus

archive/client.go

@@ -32,23 +32,20 @@ func (c *Client) LatestBlock() uint64 {
 func (c *Client) GetStorageAt(
 	ctx context.Context,
 	address common.Address,
-	position hexutil.Big,
+	position common.Hash,
 	blockNr uint64,
-) (hexutil.Big, error) {
+) (hexutil.Bytes, error) {
 	storageBytes, err := c.inner.StorageAt(
 		ctx,
 		address,
-		common.BigToHash((*big.Int)(&position)),
+		position,
 		new(big.Int).SetUint64(blockNr),
 	)
 	if err != nil {
-		return hexutil.Big{}, fmt.Errorf("archive: failed to query storage: %w", err)
+		return nil, fmt.Errorf("archive: failed to query storage: %w", err)
 	}
 
-	// Oh for fuck's sake.
-	var storageBig big.Int
-	storageBig.SetBytes(storageBytes)
-	return hexutil.Big(storageBig), nil
+	return storageBytes, nil
 }
 
 func (c *Client) GetBalance(

rpc/eth/api.go

@@ -58,7 +58,7 @@ type API interface {
 	// GetBlockTransactionCountByNumber returns the number of transactions in the block.
 	GetBlockTransactionCountByNumber(ctx context.Context, blockNum ethrpc.BlockNumber) (hexutil.Uint, error)
 	// GetStorageAt returns the storage value at the provided position.
-	GetStorageAt(ctx context.Context, address common.Address, position hexutil.Big, blockNrOrHash ethrpc.BlockNumberOrHash) (hexutil.Big, error)
+	GetStorageAt(ctx context.Context, address common.Address, position common.Hash, blockNrOrHash ethrpc.BlockNumberOrHash) (hexutil.Bytes, error)
 	// GetBalance returns the provided account's balance up to the provided block number.
 	GetBalance(ctx context.Context, address common.Address, blockNrOrHash ethrpc.BlockNumberOrHash) (*hexutil.Big, error)
 	// ChainId return the EIP-155 chain id for the current network.
@@ -232,33 +232,25 @@ func (api *publicAPI) GetBlockTransactionCountByNumber(ctx context.Context, bloc
 	return hexutil.Uint(n), nil
 }
 
-func (api *publicAPI) GetStorageAt(ctx context.Context, address common.Address, position hexutil.Big, blockNrOrHash ethrpc.BlockNumberOrHash) (hexutil.Big, error) {
-	logger := api.Logger.With("method", "eth_getStorageAt", "address", address, "position", position, "block_or_hash", blockNrOrHash)
+func (api *publicAPI) GetStorageAt(ctx context.Context, address common.Address, slot common.Hash, blockNrOrHash ethrpc.BlockNumberOrHash) (hexutil.Bytes, error) {
+	logger := api.Logger.With("method", "eth_getStorageAt", "address", address, "slot", slot, "block_or_hash", blockNrOrHash)
 	logger.Debug("request")
 
 	round, err := api.getBlockRound(ctx, logger, blockNrOrHash)
 	if err != nil {
-		return hexutil.Big{}, err
+		return hexutil.Bytes{}, err
 	}
 	if api.shouldQueryArchive(round) {
-		return api.archiveClient.GetStorageAt(ctx, address, position, round)
+		return api.archiveClient.GetStorageAt(ctx, address, slot, round)
 	}
 
-	// EVM module takes index as H256, which needs leading zeros.
-	position256 := make([]byte, 32)
-	// Unmarshalling to hexutil.Big rejects overlong inputs. Verify in `TestRejectOverlong`.
-	position.ToInt().FillBytes(position256)
-
 	ethmod := evm.NewV1(api.client)
-	res, err := ethmod.Storage(ctx, round, address[:], position256)
+	res, err := ethmod.Storage(ctx, round, address[:], slot[:])
 	if err != nil {
 		logger.Error("failed to query storage", "err", err)
-		return hexutil.Big{}, ErrInternalError
+		return nil, ErrInternalError
 	}
-	// Some apps expect no leading zeros, so output as big integer.
-	var resultBI big.Int
-	resultBI.SetBytes(res)
-	return hexutil.Big(resultBI), nil
+	return res[:], nil
 }
 
 func (api *publicAPI) GetBalance(ctx context.Context, address common.Address, blockNrOrHash ethrpc.BlockNumberOrHash) (*hexutil.Big, error) {

rpc/eth/metrics/api.go

@@ -286,11 +286,11 @@ func (m *metricsWrapper) GetLogs(ctx context.Context, filter filters.FilterCrite
 }
 
 // GetStorageAt implements eth.API.
-func (m *metricsWrapper) GetStorageAt(ctx context.Context, address common.Address, position hexutil.Big, blockNrOrHash ethrpc.BlockNumberOrHash) (res hexutil.Big, err error) {
+func (m *metricsWrapper) GetStorageAt(ctx context.Context, address common.Address, slot common.Hash, blockNrOrHash ethrpc.BlockNumberOrHash) (res hexutil.Bytes, err error) {
 	r, s, f, i, d := metrics.GetAPIMethodMetrics("eth_getStorageAt")
 	defer metrics.InstrumentCaller(r, s, f, i, d, &err)()
 
-	res, err = m.api.GetStorageAt(ctx, address, position, blockNrOrHash)
+	res, err = m.api.GetStorageAt(ctx, address, slot, blockNrOrHash)
 	return
 }
 

tests/rpc/tx_test.go

@@ -430,6 +430,44 @@ func TestEth_GetCode(t *testing.T) {
 	require.NotEmpty(t, storedCode)
 }
 
+func TestEth_GetStorageZero(t *testing.T) {
+	ec := localClient(t, false)
+
+	code := common.FromHex(strings.TrimSpace(evmSolTestCompiledHex))
+
+	chainID, err := ec.ChainID(context.Background())
+	require.Nil(t, err, "get chainid")
+
+	nonce, err := ec.NonceAt(context.Background(), tests.TestKey1.EthAddress, nil)
+	require.Nil(t, err, "get nonce failed")
+	t.Logf("got nonce: %v", nonce)
+
+	// Create transaction
+	tx := types.NewContractCreation(nonce, big.NewInt(0), GasLimit, GasPrice, code)
+	signer := types.LatestSignerForChainID(chainID)
+	signature, err := crypto.Sign(signer.Hash(tx).Bytes(), tests.TestKey1.Private)
+	require.Nil(t, err, "sign tx")
+
+	signedTx, err := tx.WithSignature(signer, signature)
+	require.Nil(t, err, "pack tx")
+
+	err = ec.SendTransaction(context.Background(), signedTx)
+	require.Nil(t, err, "send transaction failed")
+
+	ctx, cancel := context.WithTimeout(context.Background(), ethTimeout)
+	defer cancel()
+
+	receipt, err := waitTransaction(ctx, ec, signedTx.Hash())
+	require.NoError(t, err)
+	t.Logf("SignedTx hash: %s", signedTx.Hash().Hex())
+	t.Logf("Contract address: %s", receipt.ContractAddress)
+
+	key := common.HexToHash("0x0")
+	res, err := ec.StorageAt(context.Background(), receipt.ContractAddress, key, nil)
+	require.NoError(t, err, "get storage at")
+	require.Equal(t, len(res), 32, "storage at should return 32 bytes (even if zero)")
+}
+
 func TestEth_Call(t *testing.T) {
 	abidata := `
 		[