Merge master into rc/supernova 2026.07.30

math/overflow.go

@@ -90,3 +90,23 @@ func SubInt(a, b int) int {
 	log.Trace("SubInt underflow", "a", a, "b", b)
 	return builtinMath.MinInt64
 }
+
+// MulInt32 performs multiplication on int32 and logs an error if the multiplication overflows
+func MulInt32(a, b int32) int32 {
+	res, err := MulInt32WithErr(a, b)
+	if err != nil {
+		log.Trace("MulInt32 overflow", "a", a, "b", b)
+		return builtinMath.MaxInt32
+	}
+
+	return res
+}
+
+// MulInt32WithErr performs multiplication on int32 and returns an error if the multiplication overflows
+func MulInt32WithErr(a, b int32) (int32, error) {
+	wide := int64(a) * int64(b)
+	if wide > builtinMath.MaxInt32 || wide < builtinMath.MinInt32 {
+		return builtinMath.MaxInt32, ErrMultiplicationOverflow
+	}
+	return int32(wide), nil
+}

mock/context/runtimeContextMock.go

@@ -320,6 +320,11 @@ func (r *RuntimeContextMock) UseGasBoundedShouldFailExecution() bool {
 	return true
 }
 
+// AttributeExtraGasUsage mocked method
+func (r *RuntimeContextMock) AttributeExtraGasUsage() bool {
+	return true
+}
+
 // FailExecution mocked method
 func (r *RuntimeContextMock) FailExecution(_ error) {
 }

mock/context/runtimeContextWrapper.go

@@ -479,6 +479,11 @@ func (contextWrapper *RuntimeContextWrapper) UseGasBoundedShouldFailExecution()
 	return contextWrapper.runtimeContext.UseGasBoundedShouldFailExecution()
 }
 
+// AttributeExtraGasUsage calls corresponding xxxFunc function, that by default in turn calls the original method of the wrapped RuntimeContext
+func (contextWrapper *RuntimeContextWrapper) AttributeExtraGasUsage() bool {
+	return contextWrapper.runtimeContext.AttributeExtraGasUsage()
+}
+
 // GetVMExecutor calls corresponding xxxFunc function, that by default in turn calls the original method of the wrapped RuntimeContext
 func (contextWrapper *RuntimeContextWrapper) GetVMExecutor() executor.Executor {
 	return contextWrapper.GetVMExecutorFunc()

vmhost/contexts/runtime.go

@@ -267,7 +267,7 @@ func (context *runtimeContext) makeInstanceFromContractByteCode(contract []byte,
 		context.iTracker.SetCodeHash(codeHash)
 	}
 
-	if newCode {
+	if newCode || context.verifyCode {
 		err = context.VerifyContractCode()
 		if err != nil {
 			context.iTracker.ForceCleanInstance(true)
@@ -733,6 +733,11 @@ func (context *runtimeContext) UseGasBoundedShouldFailExecution() bool {
 	return context.host.EnableEpochsHandler().IsFlagEnabled(vmhost.UseGasBoundedShouldFailExecutionFlag)
 }
 
+// AttributeExtraGasUsage returns true when flag is activated
+func (context *runtimeContext) AttributeExtraGasUsage() bool {
+	return context.host.EnableEpochsHandler().IsFlagEnabled(vmhost.AttributeExtraGasUsageFlag)
+}
+
 // GetPointsUsed returns the gas amount spent by the currently running Wasmer instance.
 func (context *runtimeContext) GetPointsUsed() uint64 {
 	if check.IfNil(context.iTracker.Instance()) {

vmhost/flags.go

@@ -30,5 +30,8 @@ const (
 	// FixGetBalanceFlag defines the flag that activates the fix for get balance from the Barnard release
 	FixGetBalanceFlag core.EnableEpochFlag = "FixGetBalanceFlag"
 
+	// AttributeExtraGasUsageFlag defines the flag that activates the extra gas usage for extra attributes
+	AttributeExtraGasUsageFlag core.EnableEpochFlag = "AttributeExtraGasUsageFlag"
+
 	// all new flags must be added to allFlags slice from hostCore/host
 )

vmhost/hostCore/execution.go

@@ -891,7 +891,7 @@ func (host *vmHost) execute(input *vmcommon.ContractCallInput) error {
 	// Replace the current Wasmer instance of the Runtime with a new one; this
 	// assumes that the instance was preserved on the Runtime instance stack
 	// before calling executeSmartContractCall().
-	err = runtime.StartWasmerInstance(contract, metering.GetGasForExecution(), false)
+	err = runtime.StartWasmerInstance(contract, metering.GetGasForExecution(), input.AllowInitFunction)
 	if err != nil {
 		return err
 	}

vmhost/hostCore/host.go

@@ -46,6 +46,7 @@ var allFlags = []core.EnableEpochFlag{
 	vmhost.ValidationOnGobDecodeFlag,
 	vmhost.BarnardOpcodesFlag,
 	vmhost.FixGetBalanceFlag,
+	vmhost.AttributeExtraGasUsageFlag,
 }
 
 // vmHost implements HostContext interface.

vmhost/hosttest/execution_test.go

@@ -949,7 +949,7 @@ func TestExecution_ManagedBuffers(t *testing.T) {
 			test.CreateInstanceContract(test.ParentAddress).
 				WithCode(test.GetTestSCCode("managed-buffers", "../../"))).
 		WithInput(test.CreateTestContractCallInputBuilder().
-			WithGasProvided(100000).
+			WithGasProvided(1000000).
 			WithFunction(mBuffer[functionNumber]). // mBufferFromBigIntUnsignedTest
 			WithArguments([]byte{byte(numberOfReps)}).
 			Build()).

vmhost/interface.go

@@ -155,6 +155,7 @@ type RuntimeContext interface {
 	GetPointsUsed() uint64
 	SetPointsUsed(gasPoints uint64)
 	UseGasBoundedShouldFailExecution() bool
+	AttributeExtraGasUsage() bool
 	CleanInstance()
 
 	AddError(err error, otherInfo ...string)

vmhost/vmhooks/baseOps.go

@@ -1016,9 +1016,10 @@ func (context *VMHooksImpl) MultiTransferESDTNFTExecute(
 		return 1
 	}
 
+	numArgsFromMemory := math.MulInt32(numTokenTransfers, parsers.ArgsPerTransfer)
 	transferArgs, _, err := context.getArgumentsFromMemory(
 		host,
-		numTokenTransfers*parsers.ArgsPerTransfer,
+		numArgsFromMemory,
 		tokenTransfersArgsLengthOffset,
 		tokenTransferDataOffset,
 	)

vmhost/vmhooks/bigIntOps.go

@@ -773,6 +773,8 @@ func (context *VMHooksImpl) BigIntEMod(destinationHandle, op1Handle, op2Handle i
 	dest.Mod(a, b) // Mod implements Euclidean division (unlike Go)
 }
 
+const maxSqrtLen = 8000
+
 // BigIntSqrt VMHooks implementation.
 // @autogenerate(VMHooks)
 func (context *VMHooksImpl) BigIntSqrt(destinationHandle, opHandle int32) {
@@ -804,6 +806,12 @@ func (context *VMHooksImpl) BigIntSqrt(destinationHandle, opHandle int32) {
 		context.FailExecution(vmhost.ErrBadLowerBounds)
 		return
 	}
+
+	if context.GetRuntimeContext().AttributeExtraGasUsage() && a.BitLen() > maxSqrtLen {
+		context.FailExecution(vmhost.ErrBadUpperBounds)
+		return
+	}
+
 	dest.Sqrt(a)
 }
 

vmhost/vmhooks/manBufOps.go

@@ -534,6 +534,13 @@ func (context *VMHooksImpl) MBufferFromBigIntUnsigned(mBufferHandle int32, bigIn
 		return 1
 	}
 
+	byteLen := (value.BitLen() + 7) / 8
+	err = chargeGasForExtraLength(byteLen, context.GetVMHost())
+	if err != nil {
+		context.FailExecution(err)
+		return -1
+	}
+
 	managedType.SetBytes(mBufferHandle, value.Bytes())
 
 	return 0
@@ -558,6 +565,13 @@ func (context *VMHooksImpl) MBufferFromBigIntSigned(mBufferHandle int32, bigIntH
 		return 1
 	}
 
+	byteLen := (value.BitLen() + 7) / 8
+	err = chargeGasForExtraLength(byteLen, context.GetVMHost())
+	if err != nil {
+		context.FailExecution(err)
+		return -1
+	}
+
 	managedType.SetBytes(mBufferHandle, twos.ToBytes(value))
 	return 0
 }

vmhost/vmhooks/managedei.go

@@ -57,6 +57,7 @@ const (
 )
 
 const EGLDTokenName = "EGLD-000000" // TODO: maybe move to core?
+const safeAttributeLength = 100
 
 // ManagedSCAddress VMHooks implementation.
 // @autogenerate(VMHooks)
@@ -1528,6 +1529,12 @@ func ManagedIsESDTPausedWithHost(host vmhost.VMHost, tokenIDHandle int32) int32
 		return -1
 	}
 
+	err = chargeGasForExtraLength(len(tokenID), host)
+	if err != nil {
+		FailExecution(host, err)
+		return -1
+	}
+
 	if blockchain.IsPaused(tokenID) {
 		return 1
 	}
@@ -1669,10 +1676,27 @@ func ManagedIsBuiltinFunctionWithHost(host vmhost.VMHost, functionNameHandle int
 		return -1
 	}
 
+	lenFuncName := len(mBuffFunctionName)
+	err = chargeGasForExtraLength(lenFuncName, host)
+	if err != nil {
+		FailExecution(host, err)
+		return -1
+	}
+
 	isBuiltinFunction := host.IsBuiltinFunctionName(string(mBuffFunctionName))
 	if isBuiltinFunction {
 		return 1
 	}
 
 	return 0
 }
+
+func chargeGasForExtraLength(lenAttribute int, host vmhost.VMHost) error {
+	if !host.Runtime().AttributeExtraGasUsage() || lenAttribute < safeAttributeLength {
+		return nil
+	}
+
+	metering := host.Metering()
+	gasToUse := math.MulUint64(metering.GasSchedule().BaseOperationCost.DataCopyPerByte, uint64(lenAttribute))
+	return metering.UseGasBounded(gasToUse)
+}

vmhost/vmhookstest/manBuffers_test.go

@@ -226,7 +226,7 @@ func TestManBuffers_mBufferFromBigIntUnsigned(t *testing.T) {
 			test.CreateInstanceContract(test.ParentAddress).
 				WithCode(test.GetTestSCCode("managed-buffers", "../../"))).
 		WithInput(test.CreateTestContractCallInputBuilder().
-			WithGasProvided(100000).
+			WithGasProvided(1000000).
 			WithFunction("mBufferFromBigIntUnsignedTest").
 			WithArguments([]byte{byte(numberOfReps)}).
 			Build()).