Improve Eth JSON-RPC API handling of native messages

[Stebalien]

E.g., code like

lotus/node/impl/full/eth_utils.go

Lines 483 to 499 in 6e22c08

	func ethTxFromNativeMessage(ctx context.Context, msg *types.Message, sa StateAPI) ethtypes.EthTx {
	// We don't care if we error here, conversion is best effort for non-eth transactions
	from, _ := lookupEthAddress(ctx, msg.From, sa)
	to, _ := lookupEthAddress(ctx, msg.To, sa)
	return ethtypes.EthTx{
	To: &to,
	From: from,
	Nonce: ethtypes.EthUint64(msg.Nonce),
	ChainID: ethtypes.EthUint64(build.Eip155ChainId),
	Value: ethtypes.EthBigInt(msg.Value),
	Type: ethtypes.Eip1559TxType,
	Gas: ethtypes.EthUint64(msg.GasLimit),
	MaxFeePerGas: ethtypes.EthBigInt(msg.GasFeeCap),
	MaxPriorityFeePerGas: ethtypes.EthBigInt(msg.GasPremium),
	AccessList: []ethtypes.EthHash{},
	}
	}

Right now, we:

1. Blindly convert without translating parameters, etc.
2. Discard, e.g., the message number.
3. Ignore errors converting from/to addresses.

Instead, we need to:

1. Translate parameters & return values the same way we translate them in the tracing API. I.e., we need to call these two methods:

   lotus/node/impl/full/eth_trace.go

   Lines 293 to 353 in 6e22c08

   	func handleFilecoinMethodInput(method abi.MethodNum, codec uint64, params []byte) ([]byte, error) {
   	NATIVE_METHOD_SELECTOR := []byte{0x86, 0x8e, 0x10, 0xc4}
   	EVM_WORD_SIZE := 32
   	staticArgs := []uint64{
   	uint64(method),
   	codec,
   	uint64(EVM_WORD_SIZE) * 3,
   	uint64(len(params)),
   	}
   	totalWords := len(staticArgs) + (len(params) / EVM_WORD_SIZE)
   	if len(params)%EVM_WORD_SIZE != 0 {
   	totalWords++
   	}
   	len := 4 + totalWords*EVM_WORD_SIZE
   	w := &bytes.Buffer{}
   	err := binary.Write(w, binary.BigEndian, NATIVE_METHOD_SELECTOR)
   	if err != nil {
   	return nil, fmt.Errorf("handleFilecoinMethodInput: failed writing method selector: %w", err)
   	}
   	for _, arg := range staticArgs {
   	err := writePadded(w, arg, 32)
   	if err != nil {
   	return nil, fmt.Errorf("handleFilecoinMethodInput: %w", err)
   	}
   	}
   	err = binary.Write(w, binary.BigEndian, params)
   	if err != nil {
   	return nil, fmt.Errorf("handleFilecoinMethodInput: failed writing params: %w", err)
   	}
   	remain := len - w.Len()
   	for i := 0; i < remain; i++ {
   	err = binary.Write(w, binary.BigEndian, uint8(0))
   	if err != nil {
   	return nil, fmt.Errorf("handleFilecoinMethodInput: failed writing tailing zeros: %w", err)
   	}
   	}
   	return w.Bytes(), nil
   	}
   	func handleFilecoinMethodOutput(exitCode exitcode.ExitCode, codec uint64, data []byte) ([]byte, error) {
   	w := &bytes.Buffer{}
   	values := []interface{}{uint32(exitCode), codec, uint32(w.Len()), uint32(len(data))}
   	for _, v := range values {
   	err := writePadded(w, v, 32)
   	if err != nil {
   	return nil, fmt.Errorf("handleFilecoinMethodOutput: %w", err)
   	}
   	}
   	err := binary.Write(w, binary.BigEndian, data)
   	if err != nil {
   	return nil, fmt.Errorf("handleFilecoinMethodOutput: failed writing data: %w", err)
   	}
   	return w.Bytes(), nil
   	}

2. Try harder to lookup the correct addresses. Although there will likely be some impossible cases.

[Stebalien]

Ignore errors converting from/to addresses.

So, an additional issue here is that we lookup addresses with an "empty tsk". That means we'll use whatever we consider to be our latest "head" instead of the state-tree after the message executed, and will fail (intermittently) on re-org.