vm: add dynamic opcode pricing by Turalchik · Pull Request #4087 · nspcc-dev/neo-go

Turalchik · 2025-11-18T14:29:00Z

codecov · 2025-11-27T19:19:23Z

Codecov Report

❌ Patch coverage is 68.24818% with 87 lines in your changes missing coverage. Please review.
✅ Project coverage is 83.44%. Comparing base (6c2e5a6) to head (8deae27).

Files with missing lines	Patch %	Lines
pkg/core/fee/opcode.go	7.22%	77 Missing ⚠️
pkg/core/interop/context.go	33.33%	2 Missing and 2 partials ⚠️
pkg/vm/vm.go	97.74%	2 Missing and 2 partials ⚠️
pkg/core/interop/gas_price.go	33.33%	2 Missing ⚠️

Additional details and impacted files

@@            Coverage Diff             @@
##           master    #4087      +/-   ##
==========================================
- Coverage   83.51%   83.44%   -0.07%     
==========================================
  Files         359      359              
  Lines       43910    44130     +220     
==========================================
+ Hits        36670    36824     +154     
- Misses       5437     5497      +60     
- Partials     1803     1809       +6

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:

❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

AnnaShaleva

@Turalchik, conflicts.

The first part of review, will submit more later.

AnnaShaleva · 2026-01-15T09:28:57Z

Conflicts.

AnnaShaleva · 2026-04-08T12:56:54Z

+
+func OpcodeDynamic(base int64, op opcode.Opcode, args *vm.PriceArgs) int64 {
+	if dynamicCoefficients[op] == nil {
+		fmt.Println(op, args)


Shouldn't be here.

AnnaShaleva · 2026-04-08T12:58:52Z

+	if dynamicCoefficients[op] == nil {
+		fmt.Println(op, args)
+	}
+	return base * max(1, dynamicCoefficients[op](args)/factor)


Shouldn't be like that. Calculate the overall price of all opcodes in the script and then divide the resulting sum by the factor.

AnnaShaleva · 2026-04-08T13:03:24Z

+}
+
+func AppendGas(args *vm.PriceArgs) int64 {
+	return dotInts(appendW, []int64{int64(args.Refs), int64(args.NClonedItems), 1})


Additional slice allocation on every opcode doesn't bring us anything good. Remove dotInts, use direct multiplication.

AnnaShaleva · 2026-04-08T13:31:21Z

 		for range n {
 			key := v.estack.popNoRef()
 			val := v.estack.popNoRef().value
+			numComparisons += m.Len()


Is it m.Len() or the number of iterations over cycle? m.Len() may be different from the number of iterations in case if map has duplicated entries.

I do not know how we can find out the number of comparisons if Add cannot return it #4202 (comment).

It's just a question. OK, I think we're fine with m.Len() here.

AnnaShaleva · 2026-04-08T13:34:01Z

-			v.estack.PushItem(t.Value().([]stackitem.MapElement)[index].Value.Dup())
+			m := t.Value().([]stackitem.MapElement)
+			item = m[i].Value.Dup()


No need to declare m, useless variable.

AnnaShaleva · 2026-04-08T13:39:32Z

+		r := v.refs
+		var (
+			item = v.estack.Pop()
+			n    int
+		)


Move r under var declaration.

AnnaShaleva · 2026-04-08T13:40:37Z


-func (v *VM) cpValues(src iter.Seq[stackitem.Item], n int, isReferenced bool) []stackitem.Item {
-	arr := make([]stackitem.Item, 0, n)
+func (v *VM) cpValues(src iter.Seq[stackitem.Item], n int, isReferenced bool) ([]stackitem.Item, int) {


Doc for int return is needed.

AnnaShaleva · 2026-04-08T13:43:39Z

+	defer func(canGetPrice bool) {
+		if canGetPrice {
+			v.gasConsumed += v.getPrice(op, parameter, priceArgs)
+		}


Can't do this directly. We need to preserve the old behaviour for pre-Gorgon and introduce new behaviour starting from Gorgon.

AnnaShaleva · 2026-04-10T15:18:37Z

 	if scparser.IsSignatureContract(script) {
 		size += 67 + io.GetVarSize(script)
-		netFee += Opcode(base, opcode.PUSHDATA1, opcode.PUSHDATA1) + base*ECDSAVerifyPrice
+		netFee += Opcode(base, opcode.PUSHDATA1, opcode.PUSHDATA1)/factor + base*ECDSAVerifyPrice


Two problems here:

fee.Opcode() behaviour change

The behaviour of Opcode() shouldn't be changed because it's an exported API that may be used by some external users.

I see two possible solutions:

I

Divide the result of fee.Opcode by factor internally, inside fee.Opcode itself (it will return Datoshi then).

Use new OpcodeV0 function as VM's PriceGetter for pre-Gorgon (it will return Datoshi*factor, but with old coefficients).

Use new OpcodeV1 function as VM's PriceGetter for post-Gorgon (also will return `Datoshi*factor, but with new coefficients).

II

Add an extra factor argument to Opcode. Use pre-Gorgon coefficients if factor is 0 and use post-Gorgon coefficients otherwise.

@roman-khimov, do you have other suggestions? Which one do you prefer?

fee.Calculate() becomes Gorgon-dependent.

The behaviour of fee.Calculate (and other similar and dependent APIs) becomes Gorgon-dependent.

I can suggest introducing fee.CalculateV0 (using pre-Gorgon coefficients and returning Datoshi*factor) and fee.CalculateV1 (using post-Gorgon coefficients, returning Datoshi*factor). Dependent functions will have to switch between two implementations by themselves based on Gorgon. It's also important to keep the original behaviour of fee.Calculate unchanged.

@roman-khimov also need your opinion on that.

AnnaShaleva · 2026-04-10T15:19:25Z

+const factor = 1000
+
+// Opcode price weights used in dynamic fee formulas.
+// All values are multiplied by vm.OpcodePriceMultiplier.


Suggested change

// All values are multiplied by vm.OpcodePriceMultiplier.

// All values are multiplied by [vm.OpcodePriceMultiplier].

Use it for every link in doc.

AnnaShaleva · 2026-04-10T15:24:17Z

+)
+
+// OpcodeV1 returns opcode pricing used since Gorgon hardfork,
+// supporting dynamic (input-dependent) costs.


s/(input-dependent)/(parameter-dependent)

AnnaShaleva · 2026-04-10T15:31:23Z

+	}
+)
+
+// OpcodeV1 returns opcode pricing used since Gorgon hardfork,


returns opcode pricing

... in the unit of Datoshi*[vm.OpcodePriceMultiplier]

AnnaShaleva · 2026-04-10T15:38:33Z

 		opcode.PUSH4, // amount of args
 		opcode.PACK,  // pack args
-	)
+	) / vm.OpcodePriceMultiplier


It's OK for the old version of Opcode to divide by vm.OpcodePriceMultiplier in the middle of the script calculation. However, it won't be OK for OpcodeV1; the division should happen after the final price is known and the final value should be rounded up to cover non-integer remnant.

AnnaShaleva · 2026-04-10T15:39:34Z

-// Array fields are still copied by reference.
-func (i *Struct) Clone() (*Struct, error) {
+// Clone returns a Struct with all Struct fields copied by the value
+// and number of cloned items. Array fields are still copied by reference.


s/items/fields

... including the struct itself.

AnnaShaleva · 2026-04-10T15:41:01Z


+// PriceArgs contains opcode-specific parameters used to calculate dynamic price.
+type PriceArgs struct {
+	// Typ specifies type of stack item involved in opcode.


s/stack item/[stackitem.Item]

s/involved in opcode/which in most of the cases serves as an operand of the given opcode.

AnnaShaleva · 2026-04-10T15:45:47Z

 }

+// PriceArgs contains opcode-specific parameters used to calculate dynamic price.
+type PriceArgs struct {


s/PriceArgs/OpcodePriceArgs or something like that?

Just because vm.PriceArgs is too wide definition if referred from an external user package.

AnnaShaleva · 2026-04-10T15:56:11Z

+	// Size is size of compound type, buffer or bytearray length,
+	// number slots or stack elements.
+	Size int


Suggested change

// Size is size of compound type, buffer or bytearray length,

// number slots or stack elements.

Size int

// Size denotes one of the following:

// - the number of elements in the compound type (i.e. the length of Array or Struct, the number of key-value pairs in Map);

// - the length of Buffer or ByteArray;

// - the number of VM slot cells or stack elements involved into opcode handling.

Size int

@Turalchik we need to be specific and precise. Imagine external users using this parameter to calculate something.

And may be it's worth to rename Size to Length?

Close #4043. Signed-off-by: Tural Devrishev <tural@nspcc.ru>

Turalchik requested review from AnnaShaleva and roman-khimov as code owners November 18, 2025 14:29

Turalchik marked this pull request as draft November 18, 2025 14:29

Turalchik force-pushed the dynamic-opcode-pricing branch from b84940d to bf06cda Compare November 27, 2025 19:13

Turalchik force-pushed the dynamic-opcode-pricing branch 22 times, most recently from bb928b3 to 43b4467 Compare December 4, 2025 10:30

Turalchik force-pushed the dynamic-opcode-pricing branch from 43b4467 to 995606b Compare December 5, 2025 17:24

Turalchik force-pushed the dynamic-opcode-pricing branch 2 times, most recently from 174df2d to 0315022 Compare December 16, 2025 16:11

Turalchik force-pushed the dynamic-opcode-pricing branch 17 times, most recently from 0de3721 to 5196698 Compare December 22, 2025 07:50

AnnaShaleva reviewed Dec 23, 2025

View reviewed changes

AnnaShaleva reviewed Jan 15, 2026

View reviewed changes

Turalchik mentioned this pull request Jan 16, 2026

Dynamic opcode pricing #4043

Open

AnnaShaleva reviewed Apr 7, 2026

View reviewed changes

Turalchik mentioned this pull request Apr 8, 2026

vm: add models for dynamic opcode prices #4218

Draft

AnnaShaleva reviewed Apr 8, 2026

View reviewed changes

AnnaShaleva reviewed Apr 10, 2026

View reviewed changes

vm: add dynamic opcode pricing

8deae27

Close #4043. Signed-off-by: Tural Devrishev <tural@nspcc.ru>

	// All values are multiplied by vm.OpcodePriceMultiplier.
	// All values are multiplied by [vm.OpcodePriceMultiplier].

Conversation

Turalchik commented Nov 18, 2025

Uh oh!

codecov Bot commented Nov 27, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Codecov Report

Uh oh!

AnnaShaleva left a comment • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

AnnaShaleva commented Jan 15, 2026

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

fee.Opcode() behaviour change

I

II

fee.Calculate() becomes Gorgon-dependent.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

codecov Bot commented Nov 27, 2025 •

edited

Loading

AnnaShaleva left a comment •

edited

Loading

`fee.Opcode()` behaviour change

`fee.Calculate()` becomes Gorgon-dependent.