[KLC-2516] [KLR-13] Nondeterministic contract deployment outcome timeout boundary

kvm/mock/context/runtimeContextMock.go

@@ -42,6 +42,7 @@ type RuntimeContextMock struct {
 	InstanceMock             executor.Instance
 	SignalErrorMessage       string
 	FailExecutionErr         error
+	FailExecutionCalled      func(err error)
 }
 
 // InitState mocked method
@@ -317,6 +318,9 @@ func (r *RuntimeContextMock) ManagedMapAPIErrorShouldFailExecution() bool {
 // FailExecution mocked method
 func (r *RuntimeContextMock) FailExecution(err error) {
 	r.FailExecutionErr = err
+	if r.FailExecutionCalled != nil {
+		r.FailExecutionCalled(err)
+	}
 }
 
 // SetCustomCallFunction mocked method

kvm/vmhost/hostCore/host.go

@@ -472,6 +472,29 @@ func (host *vmHost) handleTimeout(cancelHook context.CancelFunc, done <-chan str
 	return vmhost.ErrExecutionFailedWithTimeout
 }
 
+// waitExecutionWithDeterministicCompletion waits for execution completion or timeout.
+// If both completion and timeout are observable at the same boundary, completion wins:
+// a closed done channel proves execution finished within budget, while an expired
+// context also reflects how long this goroutine waited to be scheduled.
+func (host *vmHost) waitExecutionWithDeterministicCompletion(
+	ctx context.Context,
+	cancelHook context.CancelFunc,
+	done <-chan struct{},
+) error {
+	select {
+	case <-done:
+		return nil
+	case <-ctx.Done():
+		// Deterministic tie-breaker: if execution also completed, completion wins.
+		select {
+		case <-done:
+			return nil
+		default:
+			return host.handleTimeout(cancelHook, done)
+		}
+	}
+}
+
 // RunSmartContractCreate executes the deployment of a new contract
 func (host *vmHost) RunSmartContractCreate(input *vmcommon.ContractCreateInput) (vmOutput *vmcommon.VMOutput, err error) {
 	err = validateVMInput(&input.VMInput)
@@ -534,12 +557,8 @@ func (host *vmHost) RunSmartContractCreate(input *vmcommon.ContractCreateInput)
 		host.logFromGasTracer("init")
 	}()
 
-	select {
-	case <-done:
-		// Normal termination
-		return
-	case <-ctx.Done():
-		err = host.handleTimeout(cancel, done)
+	if timeoutErr := host.waitExecutionWithDeterministicCompletion(ctx, cancel, done); timeoutErr != nil {
+		err = timeoutErr
 	}
 
 	return
@@ -618,11 +637,8 @@ func (host *vmHost) RunSmartContractCall(input *vmcommon.ContractCallInput) (vmO
 		host.logFromGasTracer(input.Function)
 	}()
 
-	select {
-	case <-done:
-		// Normal termination.
-	case <-ctx.Done():
-		err = host.handleTimeout(cancel, done)
+	if timeoutErr := host.waitExecutionWithDeterministicCompletion(ctx, cancel, done); timeoutErr != nil {
+		err = timeoutErr
 	}
 
 	return vmOutput, err

kvm/vmhost/hostCore/timeout_tiebreaker_test.go

@@ -0,0 +1,96 @@
+package hostCore
+
+import (
+	"context"
+	"testing"
+
+	contextmock "github.com/klever-io/klever-go/kvm/mock/context"
+	"github.com/klever-io/klever-go/kvm/vmhost"
+	"github.com/stretchr/testify/require"
+)
+
+func TestVmHost_WaitExecutionWithDeterministicCompletion_DoneOnly(t *testing.T) {
+	t.Parallel()
+
+	runtimeCtx := &contextmock.RuntimeContextMock{}
+	host := &vmHost{runtimeContext: runtimeCtx}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	hookCtx, cancelHook := context.WithCancel(context.Background())
+	done := make(chan struct{})
+	close(done)
+
+	err := host.waitExecutionWithDeterministicCompletion(ctx, cancelHook, done)
+	require.NoError(t, err)
+	require.Nil(t, runtimeCtx.FailExecutionErr)
+
+	select {
+	case <-hookCtx.Done():
+		t.Fatalf("hook context should not be canceled on normal completion")
+	default:
+	}
+}
+
+func TestVmHost_WaitExecutionWithDeterministicCompletion_TimeoutWhileExecutionInFlight(t *testing.T) {
+	t.Parallel()
+
+	timeoutStarted := make(chan struct{})
+	runtimeCtx := &contextmock.RuntimeContextMock{
+		FailExecutionCalled: func(error) { close(timeoutStarted) },
+	}
+	host := &vmHost{runtimeContext: runtimeCtx}
+
+	ctx, cancel := context.WithCancel(context.Background())
+	cancel()
+
+	hookCtx, cancelHook := context.WithCancel(context.Background())
+	done := make(chan struct{})
+	go func() {
+		<-timeoutStarted
+		close(done)
+	}()
+
+	err := host.waitExecutionWithDeterministicCompletion(ctx, cancelHook, done)
+	require.Equal(t, vmhost.ErrExecutionFailedWithTimeout, err)
+	require.Equal(t, vmhost.ErrExecutionFailedWithTimeout, runtimeCtx.FailExecutionErr)
+
+	select {
+	case <-done:
+	default:
+		t.Fatalf("timeout path should wait for execution to finish before returning")
+	}
+
+	select {
+	case <-hookCtx.Done():
+	default:
+		t.Fatalf("hook context should be canceled on timeout")
+	}
+}
+
+func TestVmHost_WaitExecutionWithDeterministicCompletion_TieBreakerCompletionWins(t *testing.T) {
+	t.Parallel()
+
+	for i := 0; i < 100; i++ {
+		runtimeCtx := &contextmock.RuntimeContextMock{}
+		host := &vmHost{runtimeContext: runtimeCtx}
+
+		ctx, cancel := context.WithCancel(context.Background())
+		cancel()
+
+		hookCtx, cancelHook := context.WithCancel(context.Background())
+		done := make(chan struct{})
+		close(done)
+
+		err := host.waitExecutionWithDeterministicCompletion(ctx, cancelHook, done)
+		require.NoError(t, err)
+		require.Nil(t, runtimeCtx.FailExecutionErr)
+
+		select {
+		case <-hookCtx.Done():
+			t.Fatalf("hook context should not be canceled when completion wins the tie")
+		default:
+		}
+	}
+}