Merge pull request #1099 from oasisprotocol/ptrus/feature/parse-precompile-result

analyzer/runtime: Parse precompile results

Author: ptrus

.changelog/1093.feature.md

@@ -0,0 +1 @@
+analyzer/runtime: Parse precompile results

analyzer/runtime/evm/precompile.go

@@ -0,0 +1,54 @@
+package evm
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/oasisprotocol/oasis-core/go/common/cbor"
+
+	"github.com/oasisprotocol/nexus/analyzer/util/addresses"
+	"github.com/oasisprotocol/nexus/api/v1/types"
+)
+
+var (
+	// 0x0100000000000000000000000000000000000103
+	subcallPrecompile = addresses.FromBech32("oasis1qzr543mmela3xwflqtz3e0l8jzp8tupf3v59r6qn")
+
+	typeUint256, _ = abi.NewType("uint256", "", nil)
+	typeBytes, _   = abi.NewType("bytes", "", nil)
+)
+
+// IsSubcallPrecompile checks if the address is the subcall precompile address.
+func IsSubcallPrecompile(address types.Address) bool {
+	return address == subcallPrecompile
+}
+
+// EVMMaybeUnmarshalPrecompileResult tries to unmarshal a precompile result.
+func EVMMaybeUnmarshalPrecompileResult(result []byte) (uint32, string, error) {
+	// Try parsing the output:
+	// https://github.com/oasisprotocol/oasis-sdk/blob/deca9369166757b3075dc4414d7450340fdaa779/runtime-sdk/modules/evm/src/precompile/subcall.rs#L97-L106
+	var output []byte
+	if err := cbor.Unmarshal(result, &output); err != nil {
+		return 0, "", fmt.Errorf("unmarshal precompile result: %w", err)
+	}
+
+	args := abi.Arguments{
+		{Type: typeUint256, Name: "status_code"},
+		{Type: typeBytes, Name: "module"},
+	}
+	out, err := args.Unpack(output)
+	if err != nil {
+		return 0, "", fmt.Errorf("unpack precompile result: %w", err)
+	}
+	if len(out) != 2 {
+		return 0, "", fmt.Errorf("expected 2 arguments, got %d", len(out))
+	}
+
+	statusCode := out[0].(*big.Int).Uint64()
+	if statusCode == 0 {
+		return 0, "", nil
+	}
+
+	return uint32(statusCode), string(out[1].([]byte)), nil
+}

analyzer/runtime/evm/precompile_test.go

@@ -0,0 +1,47 @@
+package evm
+
+import (
+	"encoding/hex"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/oasisprotocol/oasis-core/go/common/cbor"
+)
+
+func TestPrecompileResult(t *testing.T) {
+	testCases := []struct {
+		name       string
+		result     string
+		statusCode uint32
+		module     string
+	}{
+		// https://github.com/oasisprotocol/nexus/issues/1093
+		{
+			name:       "failed precompile",
+			result:     "000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000004636f726500000000000000000000000000000000000000000000000000000000",
+			statusCode: 10,
+			module:     "core",
+		},
+		{
+			name:       "success precompile",
+			result:     "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000001f600000000000000000000000000000000000000000000000000000000000000",
+			statusCode: 0,
+			module:     "",
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Prepare the precompile result.
+			result, err := hex.DecodeString(tc.result)
+			require.NoError(t, err)
+
+			// Test unmarshalling.
+			statusCode, module, err := EVMMaybeUnmarshalPrecompileResult(cbor.Marshal(result))
+			require.NoError(t, err)
+			require.Equal(t, tc.statusCode, statusCode)
+			require.Equal(t, tc.module, module)
+		})
+	}
+}

analyzer/runtime/extract.go

@@ -560,6 +560,23 @@ func ExtractRound(blockHeader nodeapi.RuntimeBlockHeader, txrs []nodeapi.Runtime
 						for _, signer := range blockTransactionData.SignerData {
 							registerTokenDecrease(blockData.TokenBalanceChanges, evm.NativeRuntimeTokenAddress, signer.Address, reckonedAmount)
 						}
+
+					}
+
+					// Subcall precompile.
+					if evm.IsSubcallPrecompile(to) && txr.Result.Ok != nil {
+						// Try parsing precompile results.
+						statusCode, module, err := evm.EVMMaybeUnmarshalPrecompileResult(txr.Result.Ok)
+						if err != nil {
+							logger.Error("error unmarshalling precompile result", "err", err)
+						}
+						if statusCode != 0 {
+							blockTransactionData.Success = common.Ptr(false)
+							blockTransactionData.Error = &TxError{
+								Code:   statusCode,
+								Module: module,
+							}
+						}
 					}
 
 					// TODO: maybe parse known token methods (ERC-20 etc)

analyzer/util/addresses/addresses.go

@@ -70,3 +70,10 @@ func SliceFromSet(accounts map[apiTypes.Address]struct{}) []apiTypes.Address {
 	}
 	return addrs
 }
+
+func FromBech32(bech32 string) apiTypes.Address {
+	address := sdkTypes.NewAddressFromBech32(bech32)
+	// Address is valid, otherwise the above call panics.
+	addr, _ := FromSdkAddress(&address)
+	return addr
+}