initial implementation of unSafe mode

mock/context/runtimeContextMock.go

@@ -19,6 +19,7 @@ type RuntimeContextMock struct {
 	CallFunction             string
 	VMType                   []byte
 	ReadOnlyFlag             bool
+	UnsafeModeFlag           bool
 	VerifyCode               bool
 	CurrentBreakpointValue   vmhost.BreakpointValue
 	PointsUsed               uint64
@@ -314,6 +315,16 @@ func (r *RuntimeContextMock) UseGasBoundedShouldFailExecution() bool {
 	return true
 }
 
+// IsUnsafeMode mocked method
+func (r *RuntimeContextMock) IsUnsafeMode() bool {
+	return r.UnsafeModeFlag
+}
+
+// SetUnsafeMode mocked method
+func (r *RuntimeContextMock) SetUnsafeMode(unsafeMode bool) {
+	r.UnsafeModeFlag = unsafeMode
+}
+
 // FailExecution mocked method
 func (r *RuntimeContextMock) FailExecution(_ error) {
 }

mock/context/runtimeContextWrapper.go

@@ -72,6 +72,10 @@ type RuntimeContextWrapper struct {
 	// function that will be called by the corresponding RuntimeContext function implementation (by default this will call the same wrapped context function)
 	SetReadOnlyFunc func(readOnly bool)
 	// function that will be called by the corresponding RuntimeContext function implementation (by default this will call the same wrapped context function)
+	IsUnsafeModeFunc func() bool
+	// function that will be called by the corresponding RuntimeContext function implementation (by default this will call the same wrapped context function)
+	SetUnsafeModeFunc func(readOnly bool)
+	// function that will be called by the corresponding RuntimeContext function implementation (by default this will call the same wrapped context function)
 	StartWasmerInstanceFunc func(contract []byte, gasLimit uint64, newCode bool) error
 	// function that will be called by the corresponding RuntimeContext function implementation (by default this will call the same wrapped context function)
 	ClearWarmInstanceCacheFunc func()
@@ -224,6 +228,14 @@ func NewRuntimeContextWrapper(inputRuntimeContext *vmhost.RuntimeContext) *Runti
 		runtimeWrapper.runtimeContext.SetReadOnly(readOnly)
 	}
 
+	runtimeWrapper.IsUnsafeModeFunc = func() bool {
+		return runtimeWrapper.runtimeContext.IsUnsafeMode()
+	}
+
+	runtimeWrapper.SetUnsafeModeFunc = func(unSafe bool) {
+		runtimeWrapper.runtimeContext.SetUnsafeMode(unSafe)
+	}
+
 	runtimeWrapper.StartWasmerInstanceFunc = func(contract []byte, gasLimit uint64, newCode bool) error {
 		return runtimeWrapper.runtimeContext.StartWasmerInstance(contract, gasLimit, newCode)
 	}
@@ -429,6 +441,16 @@ func (contextWrapper *RuntimeContextWrapper) SetReadOnly(readOnly bool) {
 	contextWrapper.SetReadOnlyFunc(readOnly)
 }
 
+// IsUnsafeMode calls corresponding xxxFunc function, that by default in turn calls the original method of the wrapped RuntimeContext
+func (contextWrapper *RuntimeContextWrapper) IsUnsafeMode() bool {
+	return contextWrapper.IsUnsafeModeFunc()
+}
+
+// SetUnsafeMode calls corresponding xxxFunc function, that by default in turn calls the original method of the wrapped RuntimeContext
+func (contextWrapper *RuntimeContextWrapper) SetUnsafeMode(unsafeMode bool) {
+	contextWrapper.SetUnsafeModeFunc(unsafeMode)
+}
+
 // StartWasmerInstance calls corresponding xxxFunc function, that by default in turn calls the original method of the wrapped RuntimeContext
 func (contextWrapper *RuntimeContextWrapper) StartWasmerInstance(contract []byte, gasLimit uint64, newCode bool) error {
 	return contextWrapper.StartWasmerInstanceFunc(contract, gasLimit, newCode)

mock/mockery/RuntimeContext.go

@@ -14,10 +14,19 @@ type MockRuntimeContext struct {
 	mock.Mock
 }
 
-// RemoveCodeUpgradeFromArgs -
+// RemoveCodeUpgradeFromArgs provides a mock function with given fields
 func (_m *MockRuntimeContext) RemoveCodeUpgradeFromArgs() {
 }
 
+// IsUnsafeMode provides a mock function with given fields
+func (_m *MockRuntimeContext) IsUnsafeMode() bool {
+	return false
+}
+
+// SetUnsafeMode provides a mock function with given fields
+func (_m *MockRuntimeContext) SetUnsafeMode(_ bool) {
+}
+
 // AddError provides a mock function with given fields: err, otherInfo
 func (_m *MockRuntimeContext) AddError(err error, otherInfo ...string) {
 	_va := make([]interface{}, len(otherInfo))

test/contracts/unsafeOps/unsafeOps.c

@@ -0,0 +1,24 @@
+#include "../mxvm/context.h"
+
+// Forward declaration of the C functions, assuming they are linked externally
+void mx_activate_unsafe_mode(void);
+void mx_deactivate_unsafe_mode(void);
+void bigIntTDiv(int, int, int);
+
+void activateUnsafeMode(void) {
+    mx_activate_unsafe_mode();
+}
+
+void deactivateUnsafeMode(void) {
+    mx_deactivate_unsafe_mode();
+}
+
+void testDivByZero(void) {
+    int a = bigIntNew(1);
+    int b = bigIntNew(0);
+    int c = bigIntNew(0);
+    bigIntTDiv(c, a, b);
+}
+
+// Dummy function to satisfy the build system
+void _start() {}

test/contracts/unsafeOps/unsafeOps.export

@@ -0,0 +1,3 @@
+activateUnsafeMode
+deactivateUnsafeMode
+testDivByZero

vmhost/contexts/runtime.go

@@ -45,6 +45,11 @@ var mapBarnardOpcodes = map[string]struct{}{
 	"managedGetESDTTokenType":                      {},
 }
 
+var mapFailConditionalOpcodes = map[string]struct{}{
+	"ActivateUnsafeMode":   {},
+	"DeactivateUnsafeMode": {},
+}
+
 const warmCacheSize = 100
 
 type runtimeContext struct {
@@ -56,6 +61,7 @@ type runtimeContext struct {
 	readOnly             bool
 	verifyCode           bool
 	maxInstanceStackSize uint64
+	unsafeMode           bool
 
 	vmExecutor executor.Executor
 
@@ -124,6 +130,7 @@ func (context *runtimeContext) InitState() {
 	context.callFunction = ""
 	context.verifyCode = false
 	context.readOnly = false
+	context.unsafeMode = false
 	context.iTracker.InitState()
 	context.errors = nil
 
@@ -398,6 +405,7 @@ func (context *runtimeContext) PushState() {
 		codeAddress:  context.codeAddress,
 		callFunction: context.callFunction,
 		readOnly:     context.readOnly,
+		unsafeMode:   context.unsafeMode,
 	}
 	newState.SetVMInput(context.vmInput)
 
@@ -426,6 +434,7 @@ func (context *runtimeContext) PopSetActiveState() {
 	context.codeAddress = prevState.codeAddress
 	context.callFunction = prevState.callFunction
 	context.readOnly = prevState.readOnly
+	context.unsafeMode = prevState.unsafeMode
 }
 
 // PopDiscard removes the latest entry from the state stack
@@ -638,6 +647,29 @@ func (context *runtimeContext) FailExecution(err error) {
 	logRuntime.Trace("execution failed", "message", traceMessage)
 }
 
+// FailExecutionConditionally informs Wasmer to immediately stop the execution of the contract
+// with BreakpointExecutionFailed and sets the corresponding VMOutput fields accordingly, if the unsafe mode is not active.
+// If unsafe mode is active, it just logs the error.
+func (context *runtimeContext) FailExecutionConditionally(err error) {
+	if context.IsUnsafeMode() {
+		logRuntime.Trace("execution would have failed, but unsafe mode is active", "err", err)
+		context.AddError(err)
+		return
+	}
+
+	context.FailExecution(err)
+}
+
+// IsUnsafeMode returns true if mode is unsafe
+func (context *runtimeContext) IsUnsafeMode() bool {
+	return context.unsafeMode
+}
+
+// SetUnsafeMode sets the current mode of running
+func (context *runtimeContext) SetUnsafeMode(unsafeMode bool) {
+	context.unsafeMode = unsafeMode
+}
+
 // SignalUserError informs Wasmer to immediately stop the execution of the contract
 // with BreakpointSignalError and sets the corresponding VMOutput fields accordingly
 func (context *runtimeContext) SignalUserError(message string) {
@@ -704,6 +736,14 @@ func (context *runtimeContext) VerifyContractCode() error {
 		}
 	}
 
+	if !enableEpochsHandler.IsFlagEnabled(vmhost.FailConditionallyFlag) {
+		err = context.checkIfContainsFailConditionalOpcodes()
+		if err != nil {
+			logRuntime.Trace("verify contract code", "error", err)
+			return err
+		}
+	}
+
 	logRuntime.Trace("verified contract code")
 
 	return nil
@@ -727,6 +767,15 @@ func (context *runtimeContext) checkIfContainsBarnardOpcodes() error {
 	return nil
 }
 
+func (context *runtimeContext) checkIfContainsFailConditionalOpcodes() error {
+	for funcName := range mapFailConditionalOpcodes {
+		if context.iTracker.Instance().IsFunctionImported(funcName) {
+			return vmhost.ErrContractInvalid
+		}
+	}
+	return nil
+}
+
 // UseGasBoundedShouldFailExecution returns true when flag activated
 func (context *runtimeContext) UseGasBoundedShouldFailExecution() bool {
 	return context.host.EnableEpochsHandler().IsFlagEnabled(vmhost.UseGasBoundedShouldFailExecutionFlag)

vmhost/errors.go

@@ -337,3 +337,6 @@ var ErrTooManyTransfersFromBuiltInFunction = errors.New("too many transfers from
 
 // ErrTimeLockExpired signals that timelock has expired
 var ErrTimeLockExpired = errors.New("time lock expired")
+
+// ErrWrongType signals that wrong type is read from buffer
+var ErrWrongType = errors.New("incompatible type")

vmhost/flags.go

@@ -36,5 +36,8 @@ const (
 	// AsyncV3Flag defines the flag that activates the fix for get balance from the Barnard release
 	AsyncV3Flag core.EnableEpochFlag = "AsyncV3Flag"
 
+	// FailConditionallyFlag defines the flag that activates the new opcodes and possibility for failing conditionally
+	FailConditionallyFlag core.EnableEpochFlag = "FailConditionallyFlag"
+
 	// all new flags must be added to allFlags slice from hostCore/host
 )

vmhost/hostCore/host.go

@@ -48,6 +48,7 @@ var allFlags = []core.EnableEpochFlag{
 	vmhost.FixGetBalanceFlag,
 	vmhost.AsyncV3FixesFlag,
 	vmhost.AsyncV3Flag,
+	vmhost.FailConditionallyFlag,
 }
 
 // vmHost implements HostContext interface.
@@ -56,8 +57,7 @@ type vmHost struct {
 	mutExecution     sync.RWMutex
 	closingInstance  bool
 	executionTimeout time.Duration
-
-	ethInput []byte
+	ethInput         []byte
 
 	blockchainContext   vmhost.BlockchainContext
 	runtimeContext      vmhost.RuntimeContext

vmhost/interface.go

@@ -144,6 +144,8 @@ type RuntimeContext interface {
 	IsFunctionImported(name string) bool
 	ReadOnly() bool
 	SetReadOnly(readOnly bool)
+	IsUnsafeMode() bool
+	SetUnsafeMode(unsafeMode bool)
 	StartWasmerInstance(contract []byte, gasLimit uint64, newCode bool) error
 	ClearWarmInstanceCache()
 	SetMaxInstanceStackSize(uint64)