[Chore] Re-enable E2E tests

.github/workflows/pull-request-develop.yml

@@ -97,7 +97,6 @@ jobs:
           nix develop --command go test -v ./bindings/... -tags="integration"
 
       - name: Run Operations Tests
-        if: false # disabled until MCMS package is updated for the new Sui gRPC client
         env:
           TEST_DB_URL: postgres://localhost:5432/chainlink_test?sslmode=disable&user=postgres&password=postgres
         run: |
@@ -142,7 +141,6 @@ jobs:
           nix develop --command sui genesis --force --with-faucet
 
       - name: Run System Integration Tests
-        if: false # disabled until MCMS package is updated for the new Sui gRPC client
         env:
           TEST_DB_URL: postgres://localhost:5432/chainlink_test?sslmode=disable&user=postgres&password=postgres
         run: |

bindings/bind/bcs_deserialize.go

@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
+	"io"
 	"math/big"
 	"reflect"
 	"strings"
@@ -28,7 +29,7 @@ func DeserializeBCS(data []byte, moveTypes []string) ([]any, error) {
 	deserializer := mystenbcs.NewDecoder(reader)
 	ret := make([]any, 0, len(moveTypes))
 	for _, moveType := range moveTypes {
-		decoded, _, err := bcsDeserializeType(deserializer, moveType)
+		decoded, _, err := bcsDeserializeType(reader, deserializer, moveType)
 		if err != nil {
 			return ret, err
 		}
@@ -41,11 +42,7 @@ func DeserializeBCS(data []byte, moveTypes []string) ([]any, error) {
 	return ret, nil
 }
 
-func bcsDeserializeType(deserializer *mystenbcs.Decoder, moveType string) (any, reflect.Type, error) {
-	if _, ok := bcsStructDecoders[moveType]; ok {
-		return nil, nil, fmt.Errorf("struct decoder path not supported in DeserializeBCS for type %s", moveType)
-	}
-
+func bcsDeserializeType(reader io.Reader, deserializer *mystenbcs.Decoder, moveType string) (any, reflect.Type, error) {
 	switch {
 	case moveType == "bool":
 		var res bool
@@ -72,15 +69,16 @@ func bcsDeserializeType(deserializer *mystenbcs.Decoder, moveType string) (any,
 		typ, err := bcsDecode(deserializer, &res)
 		return res, typ, err
 	case strings.HasPrefix(moveType, "vector<") && strings.HasSuffix(moveType, ">"):
-		return bcsDeserializeSlice(deserializer, moveType)
+		return bcsDeserializeSlice(reader, deserializer, moveType)
 	case moveType == "address":
 		return bcsDeserializeAddress(deserializer)
 	case moveType == "u128":
 		return bcsDeserializeBigInt(deserializer, moveType, 16)
 	case moveType == "u256":
 		return bcsDeserializeBigInt(deserializer, moveType, 32)
 	default:
-		return nil, nil, fmt.Errorf("unsupported type for BCS deserialization: %s", moveType)
+		// custom move structs are decoded by their IDs
+		return bcsDeserializeAddress(deserializer)
 	}
 }
 
@@ -91,17 +89,28 @@ func bcsDecode(deserializer *mystenbcs.Decoder, target any) (reflect.Type, error
 	return reflect.TypeOf(target).Elem(), nil
 }
 
-func bcsDeserializeSlice(deserializer *mystenbcs.Decoder, moveType string) (any, reflect.Type, error) {
+func bcsDeserializeSlice(reader io.Reader, deserializer *mystenbcs.Decoder, moveType string) (any, reflect.Type, error) {
 	innerType := moveType[len("vector<") : len(moveType)-1]
-	var length uint64
-	if _, err := deserializer.Decode(&length); err != nil {
+
+	// vector<u8> uses ULEB128 length + raw bytes; mystenbcs handles this natively.
+	if innerType == "u8" {
+		var res []byte
+		typ, err := bcsDecode(deserializer, &res)
+		return res, typ, err
+	}
+
+	length, _, err := mystenbcs.ULEB128Decode[uint64](reader)
+	if err != nil {
 		return nil, nil, fmt.Errorf("failed to decode vector length: %w", err)
 	}
+	if length > uint64(^uint(0)>>1) {
+		return nil, nil, fmt.Errorf("vector length %d out of range", length)
+	}
 
 	elements := make([]any, length)
 	var elemType reflect.Type
 	for i := uint64(0); i < length; i++ {
-		dec, refT, err := bcsDeserializeType(deserializer, innerType)
+		dec, refT, err := bcsDeserializeType(reader, deserializer, innerType)
 		if err != nil {
 			return nil, nil, err
 		}

bindings/bind/compile.go

@@ -299,6 +299,7 @@ func compilePackageInternal(packageName contracts.Package, namedAddresses map[st
 		filepath.Join(dstRoot, "ccip", "ccip_offramp"),
 		filepath.Join(dstRoot, "ccip", "ccip_burn_mint_token"),
 		filepath.Join(dstRoot, "ccip", "ccip_dummy_receiver"),
+		filepath.Join(dstRoot, "ccip", "ccip_broken_receiver"),
 		filepath.Join(dstRoot, "ccip", "managed_token"),
 		filepath.Join(dstRoot, "ccip", "managed_token_faucet"),
 		filepath.Join(dstRoot, "ccip", "mock_eth_token"),
@@ -479,7 +480,7 @@ func compilePackageInternal(packageName contracts.Package, namedAddresses map[st
 		}
 	}
 
-	if packageName == contracts.CCIPDummyReceiver {
+	if packageName == contracts.CCIPDummyReceiver || packageName == contracts.CCIPBrokenReceiver {
 		mcmsAddr := namedAddresses["mcms"]
 		if !isZeroAddress(mcmsAddr) {
 			mcmsDir := filepath.Join(dstRoot, "mcms", "mcms")

bindings/bind/grpc_response.go

@@ -38,6 +38,18 @@ func mapExecuteResponseToModels(resp *suirpcv2.ExecuteTransactionResponse) (*mod
 		result.ObjectChanges = mapChangedObjectsToModels(tx.Effects.GetChangedObjects())
 	}
 
+	if tx.GetEvents() != nil {
+		events := tx.GetEvents().GetEvents()
+		for _, event := range events {
+			result.Events = append(result.Events, models.SuiEventResponse{
+				PackageId:         event.GetPackageId(),
+				TransactionModule: event.GetModule(),
+				Type:              event.GetEventType(),
+				ParsedJson:        event.GetJson().AsInterface().(map[string]any),
+			})
+		}
+	}
+
 	return result, nil
 }
 
@@ -181,6 +193,12 @@ func transactionChangedObjectsReadMaskPaths() []string {
 		"effects.changed_objects.output_version",
 		"effects.changed_objects.output_digest",
 		"effects.changed_objects.input_version",
+		"events",
+		"events.events",
+		"events.events.package_id",
+		"events.events.module",
+		"events.events.event_type",
+		"events.events.json",
 	}
 }
 

bindings/bind/publish.go

@@ -134,7 +134,7 @@ func FindObjectIdFromPublishTx(tx models.SuiTransactionBlockResponse, module, ob
 
 // FindCoinObjectIdFromTx finds a coin object ID from a transaction response by looking for created objects of type Coin<T>
 func FindCoinObjectIdFromTx(tx models.SuiTransactionBlockResponse, coinType string) (string, error) {
-	expectedType := fmt.Sprintf("0x2::coin::Coin<%s>", coinType)
+	expectedType := fmt.Sprintf("0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<%s>", coinType)
 
 	for _, change := range tx.ObjectChanges {
 		if change.Type == "created" && change.ObjectType == expectedType {

bindings/bind/type_converter.go

@@ -280,7 +280,7 @@ func convertPureValueToCallArg(typeName string, value any) (*transaction.CallArg
 	case "vector<u8>":
 		valueToEncode, err = convertToByteArray(value)
 
-	case "0x1::string::String":
+	case "0x1::string::String", "ascii::String":
 		str, ok := value.(string)
 		if !ok {
 			return nil, fmt.Errorf("expected string, got %T", value)
@@ -554,7 +554,7 @@ func convertVectorToBCS(innerType string, value any) (any, error) {
 
 		return result, nil
 
-	case "0x1::string::String":
+	case "0x1::string::String", "ascii::String":
 		result := make([]string, rv.Len())
 		for i := range rv.Len() {
 			elem := rv.Index(i).Interface()

bindings/tests/testenv/testenv.go

@@ -55,7 +55,7 @@ var (
 	refMu    sync.Mutex
 )
 
-func SetupEnvironment(t *testing.T) (utils.SuiSigner, client.BindingsClient) {
+func SetupEnvironment(t *testing.T) (utils.SuiSigner, client.SuiPTBClient) {
 	t.Helper()
 
 	log := logger.Test(t)
@@ -147,7 +147,7 @@ func Cleanup() {
 
 // CreateTestAccount creates a new test account with funding from the faucet.
 // This requires the test environment to be set up first (via Setup() or SetupEnvironment()).
-func CreateTestAccount(t *testing.T) (utils.SuiSigner, client.BindingsClient) {
+func CreateTestAccount(t *testing.T) (utils.SuiSigner, client.SuiPTBClient) {
 	t.Helper()
 
 	refMu.Lock()
@@ -256,7 +256,7 @@ func (te *TestEnvironment) cleanup() {
 	te.cleanupLocked()
 }
 
-func createPTBClient(log logger.Logger) (client.BindingsClient, error) {
+func createPTBClient(log logger.Logger) (client.SuiPTBClient, error) {
 	ptbClient, err := client.NewPTBClient(log, client.PTBClientConfig{
 		GrpcTarget:            fmt.Sprintf("%s:%d", loopbackHost, instance.rpcPort),
 		GrpcToken:             "test",