feat(evm): network methods, submission and finality (#2094)

Signed-off-by: atharrva01 <atharvaborade568@gmail.com>

Author: atharrva01

x/token/services/network/evm/abi/abi.go

@@ -119,3 +119,51 @@ func readWordAsLength(word []byte, what string) (int, error) {
 
 // maxInt is the largest value of the platform int, used to bound-check ABI lengths before conversion.
 const maxInt = int(^uint(0) >> 1)
+
+// DecodeBytes32 decodes a single bytes32 return value.
+func DecodeBytes32(ret []byte) ([32]byte, error) {
+	var out [32]byte
+	if len(ret) < wordLength {
+		return out, errors.Errorf("abi: bytes32 return too short: %d bytes", len(ret))
+	}
+	copy(out[:], ret[:wordLength])
+
+	return out, nil
+}
+
+// DecodeBoolArray decodes a bool[] return value: a head word holding the offset to the tail, then at
+// the tail a length word followed by one word per element (zero is false, anything else true).
+func DecodeBoolArray(ret []byte) ([]bool, error) {
+	if len(ret) < wordLength {
+		return nil, errors.Errorf("abi: bool array return too short for offset word: %d bytes", len(ret))
+	}
+	offset, err := readWordAsLength(ret[:wordLength], "offset")
+	if err != nil {
+		return nil, err
+	}
+	if offset > len(ret)-wordLength {
+		return nil, errors.Errorf("abi: bool array offset %d out of bounds (len %d)", offset, len(ret))
+	}
+	length, err := readWordAsLength(ret[offset:offset+wordLength], "length")
+	if err != nil {
+		return nil, err
+	}
+	body := ret[offset+wordLength:]
+	if length > len(body)/wordLength {
+		return nil, errors.Errorf("abi: bool array length %d exceeds the %d available words", length, len(body)/wordLength)
+	}
+
+	out := make([]bool, length)
+	for i := range length {
+		word := body[i*wordLength : (i+1)*wordLength]
+		for _, b := range word {
+			if b != 0 {
+				out[i] = true
+
+				break
+			}
+		}
+	}
+
+	return out, nil
+}

x/token/services/network/evm/driver.go

@@ -12,6 +12,7 @@ import (
 	"github.com/LFDT-Panurus/panurus/token/services/config"
 	"github.com/LFDT-Panurus/panurus/token/services/logging"
 	"github.com/LFDT-Panurus/panurus/token/services/network/driver"
+	"github.com/LFDT-Panurus/panurus/x/token/services/network/evm/client"
 )
 
 var logger = logging.MustGetLogger()
@@ -20,12 +21,14 @@ var logger = logging.MustGetLogger()
 // i.e. token.tms.<tms-id>.services.network.evm. Its presence marks a TMS as an EVM network.
 const EVMConfigKey = "services.network.evm"
 
-// networkResolver decides whether a (network, channel) pair is served by the EVM driver. It is a
-// small seam over the configuration so the driver's routing can be unit-tested without a full
-// config service.
+// networkResolver decides whether a (network, channel) pair is served by the EVM driver, and yields
+// that network's configuration. It is a small seam over the configuration service so the driver's
+// routing can be unit-tested without a full config service.
 type networkResolver interface {
 	// IsEVMNetwork reports whether the given network/channel has an EVM network configuration.
 	IsEVMNetwork(network, channel string) bool
+	// ConfigFor returns the EVM configuration for the given network/channel.
+	ConfigFor(network, channel string) (*Config, error)
 }
 
 // Driver is the EVM network driver factory. It implements driver.Driver: the network provider calls
@@ -46,13 +49,26 @@ func NewDriver(configService *config.Service) driver.Driver {
 
 // New returns an EVM Network for the given network/channel, or an error if that network is not
 // configured for EVM (so the network provider falls through to the next registered driver).
+//
+// The endorsement service and the submitter are supplied by the SDK wiring, which owns the key
+// material and the FSC view manager they need; a Network built here can serve queries and assemble
+// approvals once they are injected.
 func (d *Driver) New(network, channel string) (driver.Network, error) {
 	if !d.resolver.IsEVMNetwork(network, channel) {
 		return nil, errors.Errorf("evm: no evm network configuration for [%s:%s]", network, channel)
 	}
 	logger.Debugf("creating evm network [%s:%s]", network, channel)
 
-	return newNetwork(network), nil
+	config, err := d.resolver.ConfigFor(network, channel)
+	if err != nil {
+		return nil, err
+	}
+	evmClient, err := client.NewJSONRPCClient(config.Endpoint, nil)
+	if err != nil {
+		return nil, errors.Wrapf(err, "evm: failed to create a client for [%s:%s]", network, channel)
+	}
+
+	return NewNetwork(network, config, evmClient, nil, nil)
 }
 
 // configNetworkResolver resolves EVM networks from the token-sdk configuration.
@@ -78,3 +94,21 @@ func (r *configNetworkResolver) IsEVMNetwork(network, channel string) bool {
 
 	return false
 }
+
+// ConfigFor loads and validates the EVM configuration of the first TMS declaring it for the given
+// network/channel. Every TMS on one EVM network shares the endpoint and chain, so the first match is
+// the network's configuration.
+func (r *configNetworkResolver) ConfigFor(network, channel string) (*Config, error) {
+	configs, err := r.cs.Configurations()
+	if err != nil {
+		return nil, errors.Wrapf(err, "evm: failed to load token-sdk configurations for [%s:%s]", network, channel)
+	}
+	for _, c := range configs {
+		id := c.ID()
+		if id.Network == network && id.Channel == channel && c.IsSet(EVMConfigKey) {
+			return LoadConfig(c)
+		}
+	}
+
+	return nil, errors.Errorf("evm: no evm network configuration for [%s:%s]", network, channel)
+}

x/token/services/network/evm/driver_test.go

@@ -9,11 +9,16 @@ package evm
 import (
 	"testing"
 
+	"github.com/LFDT-Panurus/panurus/token/services/network/driver"
+	"github.com/LFDT-Panurus/panurus/x/token/services/network/evm/client/mock"
+
+	"github.com/hyperledger-labs/fabric-smart-client/pkg/utils/errors"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-// fakeResolver reports a fixed set of (network|channel) pairs as EVM networks.
+// fakeResolver reports a fixed set of (network|channel) pairs as EVM networks and yields a minimal
+// valid configuration for them.
 type fakeResolver struct {
 	evm map[string]bool
 }
@@ -22,6 +27,16 @@ func (f fakeResolver) IsEVMNetwork(network, channel string) bool {
 	return f.evm[network+"|"+channel]
 }
 
+func (f fakeResolver) ConfigFor(network, channel string) (*Config, error) {
+	if !f.IsEVMNetwork(network, channel) {
+		return nil, errors.Errorf("no evm configuration for [%s:%s]", network, channel)
+	}
+	c := validConfig()
+	c.applyDefaults()
+
+	return c, c.Validate()
+}
+
 func TestDriverNewRouting(t *testing.T) {
 	d := &Driver{resolver: fakeResolver{evm: map[string]bool{"evm-net|": true}}}
 
@@ -41,15 +56,40 @@ func TestDriverNewRouting(t *testing.T) {
 	assert.Error(t, err)
 }
 
-// TestNetworkStubNotImplemented documents that the skeleton's behavioural methods are wired to the
-// interface but not yet implemented, so a mis-registration surfaces as a clear error rather than a
-// nil-pointer panic.
-func TestNetworkStubNotImplemented(t *testing.T) {
-	n := newNetwork("evm-net")
+// TestNetworkSurfaceIsWired checks the methods that used to be stubs now answer through the finality
+// manager rather than returning a not-implemented error.
+func TestNetworkSurfaceIsWired(t *testing.T) {
+	evm := &mock.EVMClient{}
+	// getTokenRequestHash returns the zero hash: the anchor has not been applied.
+	evm.CallReturns(make([]byte, 32), nil)
+	n := testNetwork(t, evm, nil)
 
 	assert.NotNil(t, n.NewEnvelope())
-	err := n.Broadcast(t.Context(), &Envelope{})
-	require.ErrorIs(t, err, errNotImplemented)
-	_, err = n.Ledger()
-	assert.ErrorIs(t, err, errNotImplemented)
+
+	ledger, err := n.Ledger()
+	require.NoError(t, err)
+	require.NotNil(t, ledger)
+
+	// An anchor the chain has never seen is Unknown: never the invalid zero code, and never Invalid,
+	// because a reverted apply is indistinguishable from one still pending (design 7.4).
+	status, hash, _, err := n.GetTransactionStatus(t.Context(), "token", anchorHex(0x01))
+	require.NoError(t, err)
+	assert.Equal(t, driver.Unknown, status)
+	assert.Nil(t, hash)
+
+	code, err := ledger.Status(anchorHex(0x01))
+	require.NoError(t, err)
+	assert.Equal(t, driver.Unknown, code)
+}
+
+// TestNetworkRejectsMalformedTransactionID checks the anchor-shaped identifier is validated rather
+// than silently producing a wrong on-chain lookup.
+func TestNetworkRejectsMalformedTransactionID(t *testing.T) {
+	n := testNetwork(t, nil, nil)
+
+	_, _, _, err := n.GetTransactionStatus(t.Context(), "token", "not-a-valid-anchor")
+	require.Error(t, err)
+
+	err = n.AddFinalityListener("token", "not-a-valid-anchor", nil)
+	require.Error(t, err)
 }