Repository: neo-project/neo-vm Branch: master Commit: 9af8dbd56c8f Files: 270 Total size: 1.4 MB Directory structure: gitextract_7tmmrk3b/ ├── .editorconfig ├── .github/ │ └── workflows/ │ └── main.yml ├── .gitignore ├── LICENSE ├── README.md ├── benchmarks/ │ └── Neo.VM.Benchmarks/ │ ├── Benchmarks.POC.cs │ ├── Benchmarks_VMHotPaths.cs │ ├── Builders/ │ │ ├── Helper.cs │ │ ├── Instruction.cs │ │ ├── InstructionBuilder.cs │ │ └── JumpTarget.cs │ ├── Neo.VM.Benchmarks.csproj │ ├── OpCodes/ │ │ ├── Arrays/ │ │ │ └── OpCode.ReverseN.cs │ │ ├── Benchmark.Opcode.cs │ │ ├── BenchmarkEngine.cs │ │ ├── BenchmarkMode.cs │ │ ├── Benchmarks_StackOps.cs │ │ └── OpCodeBase.cs │ ├── Program.cs │ ├── TestArray.cs │ ├── TestStruct.cs │ └── VMTypes/ │ ├── Benchmarks_Convert.cs │ └── Benchmarks_DeepCopy.cs ├── neo-vm.sln ├── src/ │ └── Neo.VM/ │ ├── BadScriptException.cs │ ├── CatchableException.cs │ ├── Collections/ │ │ └── OrderedDictionary.cs │ ├── Debugger.cs │ ├── EvaluationStack.cs │ ├── ExceptionHandlingContext.cs │ ├── ExceptionHandlingState.cs │ ├── ExecutionContext.SharedStates.cs │ ├── ExecutionContext.cs │ ├── ExecutionEngine.cs │ ├── ExecutionEngineLimits.cs │ ├── IReferenceCounter.cs │ ├── Instruction.cs │ ├── IsExternalInit.cs │ ├── JumpTable/ │ │ ├── JumpTable.Bitwisee.cs │ │ ├── JumpTable.Compound.cs │ │ ├── JumpTable.Control.cs │ │ ├── JumpTable.Numeric.cs │ │ ├── JumpTable.Push.cs │ │ ├── JumpTable.Slot.cs │ │ ├── JumpTable.Splice.cs │ │ ├── JumpTable.Stack.cs │ │ ├── JumpTable.Types.cs │ │ └── JumpTable.cs │ ├── Neo.VM.csproj │ ├── OpCode.cs │ ├── OperandSizeAttribute.cs │ ├── RCVersion.cs │ ├── ReferenceCounter.cs │ ├── ReferenceCounterV2.cs │ ├── ReferenceEqualityComparer.cs │ ├── Script.cs │ ├── ScriptBuilder.cs │ ├── Slot.cs │ ├── StronglyConnectedComponents/ │ │ └── Tarjan.cs │ ├── Types/ │ │ ├── Array.cs │ │ ├── Boolean.cs │ │ ├── Buffer.cs │ │ ├── ByteString.cs │ │ ├── CompoundType.cs │ │ ├── Integer.cs │ │ ├── InteropInterface.cs │ │ ├── Map.cs │ │ ├── Null.cs │ │ ├── Pointer.cs │ │ ├── PrimitiveType.cs │ │ ├── StackItem.Vertex.cs │ │ ├── StackItem.cs │ │ ├── StackItemType.cs │ │ └── Struct.cs │ ├── Unsafe.cs │ ├── Utility.cs │ ├── VMState.cs │ └── VMUnhandledException.cs └── tests/ └── Neo.VM.Tests/ ├── Converters/ │ ├── ScriptConverter.cs │ └── UppercaseEnum.cs ├── Extensions/ │ ├── JsonExtensions.cs │ └── StringExtensions.cs ├── Helpers/ │ └── RandomHelper.cs ├── Neo.VM.Tests.csproj ├── Properties/ │ └── AssemblyInfo.cs ├── Tests/ │ ├── OpCodes/ │ │ ├── Arithmetic/ │ │ │ ├── GE.json │ │ │ ├── GT.json │ │ │ ├── LE.json │ │ │ ├── LT.json │ │ │ ├── MODMUL.json │ │ │ ├── MODPOW.json │ │ │ ├── NOT.json │ │ │ ├── NUMEQUAL.json │ │ │ ├── NUMNOTEQUAL.json │ │ │ ├── POW.json │ │ │ ├── SHL.json │ │ │ ├── SHR.json │ │ │ ├── SIGN.json │ │ │ └── SQRT.json │ │ ├── Arrays/ │ │ │ ├── APPEND.json │ │ │ ├── CLEARITEMS.json │ │ │ ├── HASKEY.json │ │ │ ├── KEYS.json │ │ │ ├── NEWARRAY.json │ │ │ ├── NEWARRAY0.json │ │ │ ├── NEWARRAY_T.json │ │ │ ├── NEWMAP.json │ │ │ ├── NEWSTRUCT.json │ │ │ ├── NEWSTRUCT0.json │ │ │ ├── PACK.json │ │ │ ├── PACKMAP.json │ │ │ ├── PACKSTRUCT.json │ │ │ ├── PICKITEM.json │ │ │ ├── POPITEM.json │ │ │ ├── REMOVE.json │ │ │ ├── REVERSEITEMS.json │ │ │ ├── SETITEM.json │ │ │ ├── SIZE.json │ │ │ ├── UNPACK.json │ │ │ └── VALUES.json │ │ ├── BitwiseLogic/ │ │ │ ├── AND.json │ │ │ ├── EQUAL.json │ │ │ ├── INVERT.json │ │ │ ├── NOTEQUAL.json │ │ │ ├── OR.json │ │ │ └── XOR.json │ │ ├── Control/ │ │ │ ├── ABORT.json │ │ │ ├── ABORTMSG.json │ │ │ ├── ASSERT.json │ │ │ ├── ASSERTMSG.json │ │ │ ├── CALL.json │ │ │ ├── CALLA.json │ │ │ ├── CALL_L.json │ │ │ ├── JMP.json │ │ │ ├── JMPEQ.json │ │ │ ├── JMPEQ_L.json │ │ │ ├── JMPGE.json │ │ │ ├── JMPGE_L.json │ │ │ ├── JMPGT.json │ │ │ ├── JMPGT_L.json │ │ │ ├── JMPIF.json │ │ │ ├── JMPIFNOT.json │ │ │ ├── JMPIFNOT_L.json │ │ │ ├── JMPIF_L.json │ │ │ ├── JMPLE.json │ │ │ ├── JMPLE_L.json │ │ │ ├── JMPLT.json │ │ │ ├── JMPLT_L.json │ │ │ ├── JMPNE.json │ │ │ ├── JMPNE_L.json │ │ │ ├── JMP_L.json │ │ │ ├── NOP.json │ │ │ ├── RET.json │ │ │ ├── SYSCALL.json │ │ │ ├── THROW.json │ │ │ ├── TRY_CATCH.json │ │ │ ├── TRY_CATCH_FINALLY.json │ │ │ ├── TRY_CATCH_FINALLY10.json │ │ │ ├── TRY_CATCH_FINALLY2.json │ │ │ ├── TRY_CATCH_FINALLY3.json │ │ │ ├── TRY_CATCH_FINALLY4.json │ │ │ ├── TRY_CATCH_FINALLY5.json │ │ │ ├── TRY_CATCH_FINALLY6.json │ │ │ ├── TRY_CATCH_FINALLY7.json │ │ │ ├── TRY_CATCH_FINALLY8.json │ │ │ ├── TRY_CATCH_FINALLY9.json │ │ │ └── TRY_FINALLY.json │ │ ├── Push/ │ │ │ ├── PUSHA.json │ │ │ ├── PUSHDATA1.json │ │ │ ├── PUSHDATA2.json │ │ │ ├── PUSHDATA4.json │ │ │ ├── PUSHINT8_to_PUSHINT256.json │ │ │ ├── PUSHM1_to_PUSH16.json │ │ │ └── PUSHNULL.json │ │ ├── Slot/ │ │ │ ├── INITSLOT.json │ │ │ ├── INITSSLOT.json │ │ │ ├── LDARG.json │ │ │ ├── LDARG0.json │ │ │ ├── LDARG1.json │ │ │ ├── LDARG2.json │ │ │ ├── LDARG3.json │ │ │ ├── LDARG4.json │ │ │ ├── LDARG5.json │ │ │ ├── LDARG6.json │ │ │ ├── LDLOC.json │ │ │ ├── LDLOC0.json │ │ │ ├── LDLOC1.json │ │ │ ├── LDLOC2.json │ │ │ ├── LDLOC3.json │ │ │ ├── LDLOC4.json │ │ │ ├── LDLOC5.json │ │ │ ├── LDLOC6.json │ │ │ ├── LDSFLD.json │ │ │ ├── LDSFLD0.json │ │ │ ├── LDSFLD1.json │ │ │ ├── LDSFLD2.json │ │ │ ├── LDSFLD3.json │ │ │ ├── LDSFLD4.json │ │ │ ├── LDSFLD5.json │ │ │ ├── LDSFLD6.json │ │ │ ├── STARG.json │ │ │ ├── STARG0.json │ │ │ ├── STARG1.json │ │ │ ├── STARG2.json │ │ │ ├── STARG3.json │ │ │ ├── STARG4.json │ │ │ ├── STARG5.json │ │ │ ├── STARG6.json │ │ │ ├── STLOC.json │ │ │ ├── STSFLD.json │ │ │ ├── STSFLD0.json │ │ │ ├── STSFLD1.json │ │ │ ├── STSFLD2.json │ │ │ ├── STSFLD3.json │ │ │ ├── STSFLD4.json │ │ │ ├── STSFLD5.json │ │ │ └── STSFLD6.json │ │ ├── Splice/ │ │ │ ├── CAT.json │ │ │ ├── LEFT.json │ │ │ ├── MEMCPY.json │ │ │ ├── NEWBUFFER.json │ │ │ ├── RIGHT.json │ │ │ └── SUBSTR.json │ │ ├── Stack/ │ │ │ ├── CLEAR.json │ │ │ ├── DEPTH.json │ │ │ ├── DROP.json │ │ │ ├── NIP.json │ │ │ ├── OVER.json │ │ │ ├── PICK.json │ │ │ ├── REVERSE3.json │ │ │ ├── REVERSE4.json │ │ │ ├── REVERSEN.json │ │ │ ├── ROLL.json │ │ │ ├── ROT.json │ │ │ ├── SWAP.json │ │ │ ├── TUCK.json │ │ │ └── XDROP.json │ │ └── Types/ │ │ ├── CONVERT.json │ │ ├── ISNULL.json │ │ └── ISTYPE.json │ └── Others/ │ ├── Debugger.json │ ├── Init.json │ ├── InvocationLimits.json │ ├── OtherCases.json │ ├── ScriptLogic.json │ ├── StackItemLimits.json │ └── StackLimits.json ├── Types/ │ ├── TestEngine.cs │ ├── VMUT.cs │ ├── VMUTActionType.cs │ ├── VMUTEntry.cs │ ├── VMUTExecutionContextState.cs │ ├── VMUTExecutionEngineState.cs │ ├── VMUTStackItem.cs │ ├── VMUTStackItemType.cs │ └── VMUTStep.cs ├── UT_Debugger.cs ├── UT_EvaluationStack.cs ├── UT_ExecutionContext.cs ├── UT_ReferenceCounter.cs ├── UT_ReferenceCounterComprehensive.cs ├── UT_Script.cs ├── UT_ScriptBuilder.cs ├── UT_Slot.cs ├── UT_StackItem.cs ├── UT_Struct.cs ├── UT_Unsafe.cs ├── UT_Utility.cs ├── UT_VMJson.cs └── VMJsonTestBase.cs ================================================ FILE CONTENTS ================================================ ================================================ FILE: .editorconfig ================================================ ############################### # Core EditorConfig Options # ############################### # dotnet-format requires version 3.1.37601 # dotnet tool update -g dotnet-format # remember to have: git config --global core.autocrlf false #(which is usually default) # top-most EditorConfig file root = true # Don't use tabs for indentation. [*] indent_style = space insert_final_newline = true trim_trailing_whitespace = true charset = utf-8 end_of_line = lf # (Please don't specify an indent_size here; that has too many unintended consequences.) spelling_exclusion_path = SpellingExclusions.dic # Code files [*.{cs,csx,vb,vbx}] indent_size = 4 insert_final_newline = true trim_trailing_whitespace = true charset = utf-8 # XML project files [*.{csproj,vbproj,vcxproj,vcxproj.filters,proj,projitems,shproj}] indent_size = 2 # XML config files [*.{props,targets,ruleset,config,nuspec,resx,vsixmanifest,vsct}] indent_size = 2 # JSON files [*.json] indent_size = 2 # Powershell files [*.ps1] indent_size = 2 # Shell script files [*.sh] end_of_line = lf indent_size = 2 # YAML files [*.yml] end_of_line = lf indent_size = 2 # Dotnet code style settings: [*.{cs,vb}] # Use file-scoped namespace csharp_style_namespace_declarations = file_scoped:warning # Member can be made 'readonly' csharp_style_prefer_readonly_struct_member = true dotnet_diagnostic.IDE0251.severity = warning dotnet_diagnostic.CS1591.severity = silent // Use primary constructor csharp_style_prefer_primary_constructors = false # Sort using and Import directives with System.* appearing first dotnet_sort_system_directives_first = false dotnet_separate_import_directive_groups = false # Avoid "this." and "Me." if not necessary dotnet_style_qualification_for_field = false:warning dotnet_style_qualification_for_property = false:warning dotnet_style_qualification_for_method = false:warning dotnet_style_qualification_for_event = false:warning # Use language keywords instead of framework type names for type references dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion dotnet_style_predefined_type_for_member_access = true:suggestion # Suggest more modern language features when available dotnet_style_object_initializer = true:warning dotnet_style_collection_initializer = true:warning dotnet_style_coalesce_expression = true:suggestion dotnet_style_null_propagation = true:suggestion dotnet_style_explicit_tuple_names = true:suggestion dotnet_style_prefer_collection_expression = never # Whitespace options dotnet_style_allow_multiple_blank_lines_experimental = false # Non-private static fields are PascalCase dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.severity = suggestion dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.symbols = non_private_static_fields dotnet_naming_rule.non_private_static_fields_should_be_pascal_case.style = non_private_static_field_style dotnet_naming_symbols.non_private_static_fields.applicable_kinds = field dotnet_naming_symbols.non_private_static_fields.applicable_accessibilities = public, protected, internal, protected_internal, private_protected dotnet_naming_symbols.non_private_static_fields.required_modifiers = static dotnet_naming_style.non_private_static_field_style.capitalization = pascal_case # Non-private readonly fields are PascalCase dotnet_naming_rule.non_private_readonly_fields_should_be_pascal_case.severity = suggestion dotnet_naming_rule.non_private_readonly_fields_should_be_pascal_case.symbols = non_private_readonly_fields dotnet_naming_rule.non_private_readonly_fields_should_be_pascal_case.style = non_private_readonly_field_style dotnet_naming_symbols.non_private_readonly_fields.applicable_kinds = field dotnet_naming_symbols.non_private_readonly_fields.applicable_accessibilities = public, protected, internal, protected_internal, private_protected dotnet_naming_symbols.non_private_readonly_fields.required_modifiers = readonly dotnet_naming_style.non_private_readonly_field_style.capitalization = pascal_case # Local functions are PascalCase dotnet_naming_rule.local_functions_should_be_pascal_case.severity = suggestion dotnet_naming_rule.local_functions_should_be_pascal_case.symbols = local_functions dotnet_naming_rule.local_functions_should_be_pascal_case.style = local_function_style dotnet_naming_symbols.local_functions.applicable_kinds = local_function dotnet_naming_style.local_function_style.capitalization = pascal_case file_header_template = Copyright (C) 2015-2026 The Neo Project.\n\n{fileName} file belongs to the neo project and is free\nsoftware distributed under the MIT software license, see the\naccompanying file LICENSE in the main directory of the\nrepository or http://www.opensource.org/licenses/mit-license.php\nfor more details.\n\nRedistribution and use in source and binary forms with or without\nmodifications are permitted. # Require file header dotnet_diagnostic.IDE0073.severity = warning # RS0016: Only enable if API files are present dotnet_public_api_analyzer.require_api_files = true # IDE0055: Fix formatting # Workaround for https://github.com/dotnet/roslyn/issues/70570 dotnet_diagnostic.IDE0055.severity = warning # CSharp code style settings: [*.cs] # Newline settings csharp_new_line_before_open_brace = all csharp_new_line_before_else = true csharp_new_line_before_catch = true csharp_new_line_before_finally = true csharp_new_line_before_members_in_object_initializers = true csharp_new_line_before_members_in_anonymous_types = true csharp_new_line_between_query_expression_clauses = true # Indentation preferences csharp_indent_block_contents = true csharp_indent_braces = false csharp_indent_case_contents = true csharp_indent_case_contents_when_block = true csharp_indent_switch_labels = true csharp_indent_labels = flush_left # Whitespace options csharp_style_allow_embedded_statements_on_same_line_experimental = false csharp_style_allow_blank_lines_between_consecutive_braces_experimental = false csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental = false csharp_style_allow_blank_line_after_token_in_conditional_expression_experimental = false csharp_style_allow_blank_line_after_token_in_arrow_expression_clause_experimental = false # Prefer method-like constructs to have a block body csharp_style_expression_bodied_methods = false:none csharp_style_expression_bodied_constructors = false:none csharp_style_expression_bodied_operators = false:none # Prefer property-like constructs to have an expression-body csharp_style_expression_bodied_properties = true:none csharp_style_expression_bodied_indexers = true:none csharp_style_expression_bodied_accessors = true:none # IDE0230: Use UTF-8 string literal csharp_style_prefer_utf8_string_literals = true:silent # Suggest more modern language features when available csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion csharp_style_pattern_matching_over_as_with_null_check = true:suggestion csharp_style_inlined_variable_declaration = true:suggestion csharp_style_throw_expression = true:suggestion csharp_style_conditional_delegate_call = true:suggestion csharp_style_prefer_extended_property_pattern = true:suggestion # Space preferences csharp_space_after_cast = false csharp_space_after_colon_in_inheritance_clause = true csharp_space_after_comma = true csharp_space_after_dot = false csharp_space_after_keywords_in_control_flow_statements = true csharp_space_after_semicolon_in_for_statement = true csharp_space_around_binary_operators = before_and_after csharp_space_around_declaration_statements = do_not_ignore csharp_space_before_colon_in_inheritance_clause = true csharp_space_before_comma = false csharp_space_before_dot = false csharp_space_before_open_square_brackets = false csharp_space_before_semicolon_in_for_statement = false csharp_space_between_empty_square_brackets = false csharp_space_between_method_call_empty_parameter_list_parentheses = false csharp_space_between_method_call_name_and_opening_parenthesis = false csharp_space_between_method_call_parameter_list_parentheses = false csharp_space_between_method_declaration_empty_parameter_list_parentheses = false csharp_space_between_method_declaration_name_and_open_parenthesis = false csharp_space_between_method_declaration_parameter_list_parentheses = false csharp_space_between_parentheses = false csharp_space_between_square_brackets = false # Blocks are allowed csharp_prefer_braces = true:silent csharp_preserve_single_line_blocks = true csharp_preserve_single_line_statements = true # IDE0060: Remove unused parameter dotnet_diagnostic.IDE0060.severity = none [src/{Analyzers,CodeStyle,Features,Workspaces,EditorFeatures,VisualStudio}/**/*.{cs,vb}] # Avoid "this." and "Me." if not necessary dotnet_diagnostic.IDE0003.severity = warning dotnet_diagnostic.IDE0009.severity = warning # IDE0011: Add braces csharp_prefer_braces = when_multiline:warning # NOTE: We need the below severity entry for Add Braces due to https://github.com/dotnet/roslyn/issues/44201 dotnet_diagnostic.IDE0011.severity = warning # IDE0040: Add accessibility modifiers dotnet_diagnostic.IDE0040.severity = warning # IDE0052: Remove unread private member dotnet_diagnostic.IDE0052.severity = warning # IDE0059: Unnecessary assignment to a value dotnet_diagnostic.IDE0059.severity = warning # Use collection expression for array dotnet_diagnostic.IDE0300.severity = warning # CA1012: Abstract types should not have public constructors dotnet_diagnostic.CA1012.severity = warning # CA1822: Make member static dotnet_diagnostic.CA1822.severity = warning # csharp_style_allow_embedded_statements_on_same_line_experimental dotnet_diagnostic.IDE2001.severity = warning # csharp_style_allow_blank_lines_between_consecutive_braces_experimental dotnet_diagnostic.IDE2002.severity = warning # csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimental dotnet_diagnostic.IDE2004.severity = warning # csharp_style_allow_blank_line_after_token_in_conditional_expression_experimental dotnet_diagnostic.IDE2005.severity = warning # csharp_style_allow_blank_line_after_token_in_arrow_expression_clause_experimental dotnet_diagnostic.IDE2006.severity = warning [src/{VisualStudio}/**/*.{cs,vb}] # CA1822: Make member static # There is a risk of accidentally breaking an internal API that partners rely on though IVT. dotnet_code_quality.CA1822.api_surface = private ================================================ FILE: .github/workflows/main.yml ================================================ name: .NET Core Test and Publish on: push: branches: [master] pull_request: env: DOTNET_VERSION: 10.0.x jobs: Test: runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v6 - name: Setup .NET Core uses: actions/setup-dotnet@v5 with: dotnet-version: | ${{ env.DOTNET_VERSION }} - name: Check format run: | dotnet format --verify-no-changes --verbosity diagnostic - name: Test run: | find tests -name *.csproj | xargs -I % dotnet add % package coverlet.msbuild dotnet test /p:CollectCoverage=true /p:CoverletOutputFormat=lcov /p:CoverletOutput=${GITHUB_WORKSPACE}/coverage/lcov - name: Codecov uses: codecov/codecov-action@v6 with: token: ${{ secrets.CODECOV_TOKEN }} files: ${{ github.workspace }}/TestResults/coverage/coverage.info fail_ci_if_error: false PublishMyGet: if: github.ref == 'refs/heads/master' && startsWith(github.repository, 'neo-project/') needs: Test runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v6 with: fetch-depth: 0 - name: Setup .NET Core uses: actions/setup-dotnet@v5 with: dotnet-version: ${{ env.DOTNET_VERSION }} - name: Pack with dotnet run: git rev-list --count HEAD |xargs printf "CI%05d" |xargs dotnet pack -c Debug -o out --include-source --version-suffix - name: Publish to MyGet run: dotnet nuget push out/*.nupkg -s https://www.myget.org/F/neo/api/v2/package -k ${MYGET_TOKEN} -ss https://www.myget.org/F/neo/symbols/api/v2/package -sk ${MYGET_TOKEN} env: MYGET_TOKEN: ${{ secrets.MYGET_TOKEN }} Release: if: github.ref == 'refs/heads/master' && startsWith(github.repository, 'neo-project/') needs: Test runs-on: ubuntu-latest steps: - name: Checkout uses: actions/checkout@v6 - name: Get version id: get_version run: | sudo apt install xmlstarlet find src -name *.csproj | xargs xmlstarlet sel -t -v "concat('version=v',//Version/text())" | xargs echo >> $GITHUB_OUTPUT - name: Check tag if: steps.get_version.outputs.version != 'v' && startsWith(steps.get_version.outputs.version, 'v') id: check_tag run: curl -s -I ${{ format('https://github.com/{0}/releases/tag/{1}', github.repository, steps.get_version.outputs.version) }} | head -n 1 | cut -d$' ' -f2 | xargs printf "statusCode=%s" | xargs echo >> $GITHUB_OUTPUT - name: Create release if: steps.check_tag.outputs.statusCode == '404' id: create_release uses: actions/create-release@v1 env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} with: tag_name: ${{ steps.get_version.outputs.version }} release_name: ${{ steps.get_version.outputs.version }} prerelease: ${{ contains(steps.get_version.outputs.version, '-') }} - name: Setup .NET Core if: steps.check_tag.outputs.statusCode == '404' uses: actions/setup-dotnet@v5 with: dotnet-version: ${{ env.DOTNET_VERSION }} - name: Publish to NuGet if: steps.check_tag.outputs.statusCode == '404' run: | dotnet pack -o out -c Release dotnet nuget push out/*.nupkg -s https://api.nuget.org/v3/index.json -k ${NUGET_TOKEN} env: NUGET_TOKEN: ${{ secrets.NUGET_TOKEN }} ================================================ FILE: .gitignore ================================================ ## Ignore Visual Studio temporary files, build results, and ## files generated by popular Visual Studio add-ons. # User-specific files *.suo *.user *.userosscache *.sln.docstates # User-specific files (MonoDevelop/Xamarin Studio) *.userprefs # Build results [Dd]ebug/ [Dd]ebugPublic/ [Rr]elease/ [Rr]eleases/ x64/ x86/ bld/ [Bb]in/ [Oo]bj/ [Ll]og/ # Visual Studio 2015 cache/options directory .vs/ # Git worktrees (project-local) .worktrees/ # Uncomment if you have tasks that create the project's static files in wwwroot #wwwroot/ # MSTest test Results [Tt]est[Rr]esult*/ [Bb]uild[Ll]og.* # NUNIT *.VisualState.xml TestResult.xml # Build Results of an ATL Project [Dd]ebugPS/ [Rr]eleasePS/ dlldata.c # DNX project.lock.json artifacts/ *_i.c *_p.c *_i.h *.ilk *.meta *.obj *.pch *.pdb *.pgc *.pgd *.rsp *.sbr *.tlb *.tli *.tlh *.tmp *.tmp_proj *.log *.vspscc *.vssscc .builds *.pidb *.svclog *.scc # Chutzpah Test files _Chutzpah* # Visual C++ cache files ipch/ *.aps *.ncb *.opendb *.opensdf *.sdf *.cachefile *.VC.db *.VC.VC.opendb # Visual Studio profiler *.psess *.vsp *.vspx *.sap # TFS 2012 Local Workspace $tf/ # Guidance Automation Toolkit *.gpState # ReSharper is a .NET coding add-in _ReSharper*/ *.[Rr]e[Ss]harper *.DotSettings.user # JustCode is a .NET coding add-in .JustCode # TeamCity is a build add-in _TeamCity* # DotCover is a Code Coverage Tool *.dotCover # NCrunch _NCrunch_* .*crunch*.local.xml nCrunchTemp_* # MightyMoose *.mm.* AutoTest.Net/ # Web workbench (sass) .sass-cache/ # Installshield output folder [Ee]xpress/ # DocProject is a documentation generator add-in DocProject/buildhelp/ DocProject/Help/*.HxT DocProject/Help/*.HxC DocProject/Help/*.hhc DocProject/Help/*.hhk DocProject/Help/*.hhp DocProject/Help/Html2 DocProject/Help/html # Click-Once directory publish/ # Publish Web Output *.[Pp]ublish.xml *.azurePubxml # TODO: Comment the next line if you want to checkin your web deploy settings # but database connection strings (with potential passwords) will be unencrypted *.pubxml *.publishproj # Microsoft Azure Web App publish settings. Comment the next line if you want to # checkin your Azure Web App publish settings, but sensitive information contained # in these scripts will be unencrypted PublishScripts/ # NuGet Packages *.nupkg # The packages folder can be ignored because of Package Restore **/packages/* # except build/, which is used as an MSBuild target. !**/packages/build/ # Uncomment if necessary however generally it will be regenerated when needed #!**/packages/repositories.config # NuGet v3's project.json files produces more ignoreable files *.nuget.props *.nuget.targets # Microsoft Azure Build Output csx/ *.build.csdef # Microsoft Azure Emulator ecf/ rcf/ # Windows Store app package directories and files AppPackages/ BundleArtifacts/ Package.StoreAssociation.xml _pkginfo.txt # Visual Studio cache files # files ending in .cache can be ignored *.[Cc]ache # but keep track of directories ending in .cache !*.[Cc]ache/ # Others ClientBin/ ~$* *~ *.dbmdl *.dbproj.schemaview *.pfx *.publishsettings node_modules/ orleans.codegen.cs # Since there are multiple workflows, uncomment next line to ignore bower_components # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) #bower_components/ # RIA/Silverlight projects Generated_Code/ # Backup & report files from converting an old project file # to a newer Visual Studio version. Backup files are not needed, # because we have git ;-) _UpgradeReport_Files/ Backup*/ UpgradeLog*.XML UpgradeLog*.htm # SQL Server files *.mdf *.ldf # Business Intelligence projects *.rdl.data *.bim.layout *.bim_*.settings # Microsoft Fakes FakesAssemblies/ # GhostDoc plugin setting file *.GhostDoc.xml # Node.js Tools for Visual Studio .ntvs_analysis.dat # Visual Studio 6 build log *.plg # Visual Studio 6 workspace options file *.opt # Visual Studio LightSwitch build output **/*.HTMLClient/GeneratedArtifacts **/*.DesktopClient/GeneratedArtifacts **/*.DesktopClient/ModelManifest.xml **/*.Server/GeneratedArtifacts **/*.Server/ModelManifest.xml _Pvt_Extensions # Paket dependency manager .paket/paket.exe paket-files/ # FAKE - F# Make .fake/ # JetBrains Rider .idea/ *.sln.iml ================================================ FILE: LICENSE ================================================ MIT License Copyright (c) 2016 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: README.md ================================================ neo-logo # NeoVM — The NEO Virtual Machine [![NuGet](https://img.shields.io/nuget/v/Neo.VM.svg)](https://www.nuget.org/packages/Neo.VM/) [![Coverage Status](https://coveralls.io/repos/github/neo-project/neo-vm/badge.svg)](https://coveralls.io/github/neo-project/neo-vm) [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE) NeoVM is the lightweight, deterministic, stack-based virtual machine that executes Neo smart contracts. It’s designed to be embeddable, predictable, and portable across platforms. For an overview and deep dives (architecture, stacks, instruction set), see the official developer docs. ([NEO Developer Resource](https://developers.neo.org/docs/n3/foundation/neovm)) --- ## Features * **Deterministic & Turing-complete** execution for smart contracts. * **Small, embeddable runtime** suitable for host applications beyond the Neo blockchain. * **Clear isolation boundary**: external effects are provided by the host via an interop/syscall layer (e.g., ApplicationEngine in Neo). * **Rich instruction set** (control flow, stacks, arithmetic, crypto, data structures). --- ## Packages The VM is published as a NuGet package: ``` dotnet add package Neo.VM ``` This adds the VM to your project; you can then embed and drive it from your host application. Targets **.NET 10.0** and **.NET Standard 2.1** (compatible with a wide range of runtimes). --- ## Contributing Contributions are welcome! Typical flow: 1. Fork the repo and create a feature branch. 2. Make changes with tests (`tests/Neo.VM.Tests`). 3. Ensure `dotnet test` passes and follow standard C# conventions. 4. Open a pull request with a clear description and rationale. --- ## See also * **neo (core library)** — base classes, ledger, P2P, IO. ([Github](https://github.com/neo-project/neo)) * **neo-devpack-dotnet** — C# → NeoVM compiler and developer toolkit. ([Github](https://github.com/neo-project/neo-devpack-dotnet)) ================================================ FILE: benchmarks/Neo.VM.Benchmarks/Benchmarks.POC.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Benchmarks.POC.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using BenchmarkDotNet.Attributes; using System.Diagnostics; namespace Neo.VM.Benchmarks; public class Benchmarks_PoCs { [Benchmark] public static void NeoIssue2528() { // https://github.com/neo-project/neo/issues/2528 // L01: INITSLOT 1, 0 // L02: NEWARRAY0 // L03: DUP // L04: DUP // L05: PUSHINT16 2043 // L06: STLOC 0 // L07: PUSH1 // L08: PACK // L09: LDLOC 0 // L10: DEC // L11: STLOC 0 // L12: LDLOC 0 // L13: JMPIF_L L07 // L14: PUSH1 // L15: PACK // L16: APPEND // L17: PUSHINT32 38000 // L18: STLOC 0 // L19: PUSH0 // L20: PICKITEM // L21: LDLOC 0 // L22: DEC // L23: STLOC 0 // L24: LDLOC 0 // L25: JMPIF_L L19 // L26: DROP Run("VwEAwkpKAfsHdwARwG8AnXcAbwAl9////xHAzwJwlAAAdwAQzm8AnXcAbwAl9////0U="); } [Benchmark] public static void NeoVMIssue418() { // https://github.com/neo-project/neo-vm/issues/418 // L00: NEWARRAY0 // L01: PUSH0 // L02: PICK // L03: PUSH1 // L04: PACK // L05: PUSH1 // L06: PICK // L07: PUSH1 // L08: PACK // L09: INITSSLOT 1 // L10: PUSHINT16 510 // L11: DEC // L12: STSFLD0 // L13: PUSH1 // L14: PICK // L15: PUSH1 // L16: PICK // L17: PUSH2 // L18: PACK // L19: REVERSE3 // L20: PUSH2 // L21: PACK // L22: LDSFLD0 // L23: DUP // L24: JMPIF L11 // L25: DROP // L26: ROT // L27: DROP Run("whBNEcARTRHAVgEB/gGdYBFNEU0SwFMSwFhKJPNFUUU="); } [Benchmark] public static void NeoIssue2723() { // L00: INITSSLOT 1 // L01: PUSHINT32 130000 // L02: STSFLD 0 // L03: PUSHINT32 1048576 // L04: NEWBUFFER // L05: DROP // L06: LDSFLD 0 // L07: DEC // L08: DUP // L09: STSFLD 0 // L10: JMPIF L03 Run("VgEC0PsBAGcAAgAAEACIRV8AnUpnACTz"); } // Below are PoCs from issue https://github.com/neo-project/neo/issues/2723 by @dusmart [Benchmark] public static void PoC_NewBuffer() { // INITSLOT 0100 // PUSHINT32 23000000 // STLOC 00 // PUSHINT32 1048576 // NEWBUFFER // DROP // LDLOC 00 // DEC // STLOC 00 // LDLOC 00 // JMPIF_L f2ffffff // CLEAR // RET Run("VwEAAsDzXgF3AAIAABAAiEVvAJ13AG8AJfL///9JQA=="); } [Benchmark] public static void PoC_Cat() { // INITSLOT 0100 // PUSHINT32 1048575 // NEWBUFFER // PUSH1 // NEWBUFFER // PUSHINT32 133333337 // STLOC 00 // OVER // OVER // CAT // DROP // LDLOC 00 // DEC // STLOC 00 // LDLOC 00 // JMPIF_L f5ffffff // CLEAR // RET Run("VwEAAv//DwCIEYgCWYHyB3cAS0uLRW8AnXcAbwAl9f///0lA"); } [Benchmark] public static void PoC_Left() { // INITSLOT 0100 // PUSHINT32 1048576 // NEWBUFFER // PUSHINT32 133333337 // STLOC 00 // DUP // PUSHINT32 1048576 // LEFT // DROP // LDLOC 00 // DEC // STLOC 00 // LDLOC 00 // JMPIF_L f1ffffff // CLEAR // RET Run("VwEAAgAAEACIAlmB8gd3AEoCAAAQAI1FbwCddwBvACXx////SUA="); } [Benchmark] public static void PoC_Right() { // INITSLOT 0100 // PUSHINT32 1048576 // NEWBUFFER // PUSHINT32 133333337 // STLOC 00 // DUP // PUSHINT32 1048576 // RIGHT // DROP // LDLOC 00 // DEC // STLOC 00 // LDLOC 00 // JMPIF_L f1ffffff // CLEAR // RET Run("VwEAAgAAEACIAlmB8gd3AEoCAAAQAI5FbwCddwBvACXx////SUA="); } [Benchmark] public static void PoC_ReverseN() { // INITSLOT 0100 // PUSHINT16 2040 // STLOC 00 // PUSHDATA1 aaabbbbbbbbbcccccccdddddddeeeeeeefffffff // LDLOC 00 // DEC // STLOC 00 // LDLOC 00 // JMPIF_L cfffffff // PUSHINT32 23000000 // STLOC 00 // PUSHINT16 2040 // REVERSEN // LDLOC 00 // DEC // STLOC 00 // LDLOC 00 // JMPIF_L f5ffffff // CLEAR // RET Run("VwEAAfgHdwAMKGFhYWJiYmJiYmJiYmNjY2NjY2NkZGRkZGRkZWVlZWVlZWZmZmZmZmZvAJ13AG8AJc////8CwPNeAXcAAfgHVW8AnXcAbwAl9f///0lA"); } [Benchmark] public static void PoC_Substr() { // INITSLOT 0100 // PUSHINT32 1048576 // NEWBUFFER // PUSHINT32 133333337 // STLOC 00 // DUP // PUSH0 // PUSHINT32 1048576 // SUBSTR // DROP // LDLOC 00 // DEC // STLOC 00 // LDLOC 00 // JMPIF_L f0ffffff // CLEAR // RET Run("VwEAAgAAEACIAlmB8gd3AEoQAgAAEACMRW8AnXcAbwAl8P///0lA"); } [Benchmark] public static void PoC_NewArray() { // INITSLOT 0100 // PUSHINT32 1333333337 // STLOC 00 // PUSHINT16 2040 // NEWARRAY // DROP // LDLOC 00 // DEC // STLOC 00 // LDLOC 00 // JMPIF_L f4ffffff // RET Run("VwEAAlkNeU93AAH4B8NFbwCddwBvACX0////QA=="); } [Benchmark] public static void PoC_NewStruct() { // INITSLOT 0100 // PUSHINT32 1333333337 // STLOC 00 // PUSHINT16 2040 // NEWSTRUCT // DROP // LDLOC 00 // DEC // STLOC 00 // LDLOC 00 // JMPIF_L f4ffffff // RET Run("VwEAAlkNeU93AAH4B8ZFbwCddwBvACX0////QA=="); } [Benchmark] public static void PoC_Roll() { // INITSLOT 0100 // PUSHINT16 2040 // STLOC 00 // PUSHDATA1 aaabbbbbbbbbcccccccdddddddeeeeeeefffffff // LDLOC 00 // DEC // STLOC 00 // LDLOC 00 // JMPIF_L cfffffff // PUSHINT32 23000000 // STLOC 00 // PUSHINT16 2039 // ROLL // LDLOC 00 // DEC // STLOC 00 // LDLOC 00 // JMPIF_L f5ffffff // CLEAR // RET Run("VwEAAfgHdwAMKGFhYWJiYmJiYmJiYmNjY2NjY2NkZGRkZGRkZWVlZWVlZWZmZmZmZmZvAJ13AG8AJc////8CwPNeAXcAAfcHUm8AnXcAbwAl9f///0lA"); } [Benchmark] public static void PoC_XDrop() { // INITSLOT 0100 // PUSHINT16 2040 // STLOC 00 // PUSHDATA1 aaabbbbbbbbbcccccccdddddddeeeeeeefffffff // LDLOC 00 // DEC // STLOC 00 // LDLOC 00 // JMPIF_L cfffffff // PUSHINT32 23000000 // STLOC 00 // PUSHINT16 2039 // XDROP // DUP // LDLOC 00 // DEC // STLOC 00 // LDLOC 00 // JMPIF_L f4ffffff // CLEAR // RET Run("VwEAAfgHdwAMKGFhYWJiYmJiYmJiYmNjY2NjY2NkZGRkZGRkZWVlZWVlZWZmZmZmZmZvAJ13AG8AJc////8CwPNeAXcAAfcHSEpvAJ13AG8AJfT///9JQA=="); } [Benchmark] public static void PoC_MemCpy() { // INITSLOT 0100 // PUSHINT32 1048576 // NEWBUFFER // PUSHINT32 1048576 // NEWBUFFER // PUSHINT32 133333337 // STLOC 00 // OVER // PUSH0 // PUSH2 // PICK // PUSH0 // PUSHINT32 1048576 // MEMCPY // LDLOC 00 // DEC // STLOC 00 // LDLOC 00 // JMPIF_L eeffffff // CLEAR // RET Run("VwEAAgAAEACIAgAAEACIAlmB8gd3AEsQEk0QAgAAEACJbwCddwBvACXu////SUA="); } [Benchmark] public static void PoC_Unpack() { // INITSLOT 0200 // PUSHINT16 1010 // NEWARRAY // STLOC 01 // PUSHINT32 1333333337 // STLOC 00 // LDLOC 01 // UNPACK // CLEAR // LDLOC 00 // DEC // STLOC 00 // LDLOC 00 // JMPIF_L f5ffffff // RET Run("VwIAAfIDw3cBAlkNeU93AG8BwUlvAJ13AG8AJfX///9A"); } [Benchmark] public static void PoC_GetScriptContainer() { // SYSCALL System.Runtime.GetScriptContainer // DROP // JMP fa Run("QS1RCDBFIvo="); } private static void Run(string poc) { byte[] script = Convert.FromBase64String(poc); using ExecutionEngine engine = new(); engine.LoadScript(script); engine.Execute(); Debug.Assert(engine.State == VMState.HALT); } } ================================================ FILE: benchmarks/Neo.VM.Benchmarks/Benchmarks_VMHotPaths.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Benchmarks_VMHotPaths.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using BenchmarkDotNet.Attributes; using Neo.VM.Types; using System; using System.Collections.Generic; using System.Linq; using VMArray = Neo.VM.Types.Array; namespace Neo.VM.Benchmarks; public class Benchmarks_ArrayBuild { [Params(1, 8, 32, 256, 1024)] public int N { get; set; } private static readonly StackItem Item = StackItem.Null; [Benchmark] public VMArray BuildWithListFill() { var referenceCounter = new ReferenceCounter(); var items = new List(N); for (int i = 0; i < N; i++) items.Add(Item); return new VMArray(referenceCounter, items); } [Benchmark] public VMArray BuildWithArrayFill() { var referenceCounter = new ReferenceCounter(); var itemArray = new StackItem[N]; System.Array.Fill(itemArray, Item); return new VMArray(referenceCounter, itemArray); } } public class Benchmarks_MapSubItems { [Params(1, 8, 32, 256, 1024)] public int N { get; set; } private Map _map = null!; [GlobalSetup] public void Setup() { _map = new Map(); for (int i = 0; i < N; i++) _map[new Integer(i)] = new Integer(i + 1); } [Benchmark] public int EnumerateYield() { int count = 0; foreach (var _ in SubItemsYield(_map)) count++; return count; } [Benchmark] public int EnumerateConcat() { int count = 0; foreach (var _ in SubItemsConcat(_map)) count++; return count; } private static IEnumerable SubItemsYield(Map map) { foreach (var key in map.Keys) yield return key; foreach (var value in map.Values) yield return value; } private static IEnumerable SubItemsConcat(Map map) => map.Keys.Concat(map.Values); } public class Benchmarks_ListCopy { private const int SourceCount = 4096; [Params(1, 8, 32, 256, 1024, 2048)] public int CopyCount { get; set; } private List _source = null!; private List _target = null!; [GlobalSetup] public void Setup() { _source = new List(SourceCount); for (int i = 0; i < SourceCount; i++) _source.Add(StackItem.Null); _target = new List(CopyCount); } [Benchmark] public int AddRangeSkip() { _target.Clear(); _target.AddRange(_source.Skip(_source.Count - CopyCount)); return _target.Count; } [Benchmark] public int ManualLoop() { _target.Clear(); int start = _source.Count - CopyCount; for (int i = start; i < _source.Count; i++) _target.Add(_source[i]); return _target.Count; } } public class Benchmarks_InstructionAdvance { [Params(1024, 4096, 16384)] public int InstructionCount { get; set; } private Script _script = null!; private ExecutionContext _context = null!; [GlobalSetup] public void Setup() { var bytes = new byte[InstructionCount]; System.Array.Fill(bytes, (byte)OpCode.PUSH0); _script = new Script(bytes); _context = new ExecutionContext(_script, 0, new ReferenceCounter()); } [IterationSetup] public void IterationSetup() { WarmInstructionCache(); _context.InstructionPointer = 0; } [Benchmark] public Instruction? AdvanceWithMoveNext() { Instruction? last = null; while (true) { last = _context.CurrentInstruction ?? Instruction.RET; if (!_context.MoveNext()) break; } return last; } [Benchmark] public Instruction? AdvanceWithPointer() { Instruction? last = null; while (true) { var current = _context.CurrentInstruction; if (current is null) break; last = current; _context.InstructionPointer += current.Size; } return last; } private void WarmInstructionCache() { while (true) { var current = _context.CurrentInstruction; if (current is null) break; _context.InstructionPointer += current.Size; } } } ================================================ FILE: benchmarks/Neo.VM.Benchmarks/Builders/Helper.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Helper.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System.Buffers.Binary; namespace Neo.VM.Benchmarks.Builders; public static class Helper { public static void RebuildOffsets(this IReadOnlyList instructions) { var offset = 0; foreach (var instruction in instructions) { instruction._offset = offset; offset += instruction.Size; } } public static void RebuildOperands(this IReadOnlyList instructions) { foreach (var instruction in instructions) { if (instruction._target is null) continue; bool isLong; if (instruction._opCode >= OpCode.JMP && instruction._opCode <= OpCode.CALL_L) isLong = (instruction._opCode - OpCode.JMP) % 2 != 0; else isLong = instruction._opCode == OpCode.PUSHA || instruction._opCode == OpCode.CALLA || instruction._opCode == OpCode.TRY_L || instruction._opCode == OpCode.ENDTRY_L; if (instruction._opCode == OpCode.TRY || instruction._opCode == OpCode.TRY_L) { var offset1 = instruction._target._instruction?._offset - instruction._offset ?? 0; var offset2 = instruction._target2!._instruction?._offset - instruction._offset ?? 0; if (isLong) { instruction._operand = new byte[sizeof(int) + sizeof(int)]; BinaryPrimitives.WriteInt32LittleEndian(instruction._operand, offset1); BinaryPrimitives.WriteInt32LittleEndian(instruction._operand.AsSpan(sizeof(int)), offset2); } else { instruction._operand = new byte[sizeof(sbyte) + sizeof(sbyte)]; var sbyte1 = checked((sbyte)offset1); var sbyte2 = checked((sbyte)offset2); instruction._operand[0] = unchecked((byte)sbyte1); instruction._operand[1] = unchecked((byte)sbyte2); } } else { int offset = instruction._target._instruction!._offset - instruction._offset; if (isLong) { instruction._operand = BitConverter.GetBytes(offset); } else { var sbyte1 = checked((sbyte)offset); instruction._operand = [unchecked((byte)sbyte1)]; } } } } } ================================================ FILE: benchmarks/Neo.VM.Benchmarks/Builders/Instruction.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Instruction.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.CodeAnalysis; using System.Diagnostics; using System.Reflection; namespace Neo.VM.Benchmarks.Builders; [DebuggerDisplay("{_opCode}")] public class Instruction { private static readonly int[] s_operandSizePrefixTable = new int[256]; private static readonly int[] s_operandSizeTable = new int[256]; public OpCode _opCode; public byte[]? _operand; public JumpTarget? _target; public JumpTarget? _target2; public int _offset; public int Size { get { int prefixSize = s_operandSizePrefixTable[(int)_opCode]; return prefixSize > 0 ? sizeof(OpCode) + _operand!.Length : sizeof(OpCode) + s_operandSizeTable[(int)_opCode]; } } static Instruction() { foreach (var field in typeof(OpCode).GetFields(BindingFlags.Public | BindingFlags.Static)) { var attribute = field.GetCustomAttribute(); if (attribute is null) continue; var index = (int)(OpCode)field.GetValue(null)!; s_operandSizePrefixTable[index] = attribute.SizePrefix; s_operandSizeTable[index] = attribute.Size; } } public byte[] ToArray() { if (_operand is null) return [(byte)_opCode]; return _operand.Prepend((byte)_opCode).ToArray(); } } ================================================ FILE: benchmarks/Neo.VM.Benchmarks/Builders/InstructionBuilder.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // InstructionBuilder.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System.Buffers.Binary; using System.Numerics; namespace Neo.VM.Benchmarks.Builders; internal class InstructionBuilder { private readonly List _instructions = new(); public InstructionBuilder() { } internal Instruction AddInstruction(Instruction instruction) { _instructions.Add(instruction); return instruction; } internal Instruction AddInstruction(OpCode opcode) { return AddInstruction(new Instruction { _opCode = opcode }); } internal Instruction Jump(OpCode opcode, JumpTarget target) { return AddInstruction(new Instruction { _opCode = opcode, _target = target }); } internal void Push(bool value) { AddInstruction(value ? OpCode.PUSHT : OpCode.PUSHF); } internal Instruction Ret() => AddInstruction(OpCode.RET); internal Instruction Push(BigInteger number) { if (number >= -1 && number <= 16) return AddInstruction(number == -1 ? OpCode.PUSHM1 : OpCode.PUSH0 + (byte)(int)number); Span buffer = stackalloc byte[32]; if (!number.TryWriteBytes(buffer, out var bytesWritten, isUnsigned: false, isBigEndian: false)) throw new ArgumentOutOfRangeException(nameof(number)); var instruction = bytesWritten switch { 1 => new Instruction { _opCode = OpCode.PUSHINT8, _operand = PadRight(buffer, bytesWritten, 1, number.Sign < 0).ToArray() }, 2 => new Instruction { _opCode = OpCode.PUSHINT16, _operand = PadRight(buffer, bytesWritten, 2, number.Sign < 0).ToArray() }, <= 4 => new Instruction { _opCode = OpCode.PUSHINT32, _operand = PadRight(buffer, bytesWritten, 4, number.Sign < 0).ToArray() }, <= 8 => new Instruction { _opCode = OpCode.PUSHINT64, _operand = PadRight(buffer, bytesWritten, 8, number.Sign < 0).ToArray() }, <= 16 => new Instruction { _opCode = OpCode.PUSHINT128, _operand = PadRight(buffer, bytesWritten, 16, number.Sign < 0).ToArray() }, <= 32 => new Instruction { _opCode = OpCode.PUSHINT256, _operand = PadRight(buffer, bytesWritten, 32, number.Sign < 0).ToArray() }, _ => throw new ArgumentOutOfRangeException($"Number too large: {bytesWritten}") }; AddInstruction(instruction); return instruction; } internal Instruction Push(string s) { return Push(s.ToStrictUtf8Bytes()); } internal Instruction Push(byte[] data) { OpCode opcode; byte[] buffer; switch (data.Length) { case <= byte.MaxValue: opcode = OpCode.PUSHDATA1; buffer = new byte[sizeof(byte) + data.Length]; buffer[0] = (byte)data.Length; Buffer.BlockCopy(data, 0, buffer, sizeof(byte), data.Length); break; case <= ushort.MaxValue: opcode = OpCode.PUSHDATA2; buffer = new byte[sizeof(ushort) + data.Length]; BinaryPrimitives.WriteUInt16LittleEndian(buffer, (ushort)data.Length); Buffer.BlockCopy(data, 0, buffer, sizeof(ushort), data.Length); break; default: opcode = OpCode.PUSHDATA4; buffer = new byte[sizeof(uint) + data.Length]; BinaryPrimitives.WriteUInt32LittleEndian(buffer, (uint)data.Length); Buffer.BlockCopy(data, 0, buffer, sizeof(uint), data.Length); break; } return AddInstruction(new Instruction { _opCode = opcode, _operand = buffer }); } internal void Push(object? obj) { switch (obj) { case bool data: Push(data); break; case byte[] data: Push(data); break; case string data: Push(data); break; case BigInteger data: Push(data); break; case char data: Push((ushort)data); break; case sbyte data: Push(data); break; case byte data: Push(data); break; case short data: Push(data); break; case ushort data: Push(data); break; case int data: Push(data); break; case uint data: Push(data); break; case long data: Push(data); break; case ulong data: Push(data); break; case Enum data: Push(BigInteger.Parse(data.ToString("d"))); break; case null: AddInstruction(OpCode.PUSHNULL); break; default: throw new NotSupportedException($"Unsupported constant value: {obj}"); } } // Helper method to reverse stack items internal void ReverseStackItems(int count) { switch (count) { case 2: AddInstruction(OpCode.SWAP); break; case 3: AddInstruction(OpCode.REVERSE3); break; case 4: AddInstruction(OpCode.REVERSE4); break; default: Push(count); AddInstruction(OpCode.REVERSEN); break; } } internal static ReadOnlySpan PadRight(Span buffer, int dataLength, int padLength, bool negative) { byte pad = negative ? (byte)0xff : (byte)0; for (int x = dataLength; x < padLength; x++) buffer[x] = pad; return buffer[..padLength]; } internal Instruction IsType(Types.StackItemType type) { return AddInstruction(new Instruction { _opCode = OpCode.ISTYPE, _operand = [(byte)type] }); } internal Instruction ChangeType(Types.StackItemType type) { return AddInstruction(new Instruction { _opCode = OpCode.CONVERT, _operand = [(byte)type] }); } internal byte[] ToArray() { var instructions = _instructions.ToArray(); instructions.RebuildOffsets(); instructions.RebuildOperands(); return instructions.Select(p => p.ToArray()).SelectMany(p => p).ToArray(); } } ================================================ FILE: benchmarks/Neo.VM.Benchmarks/Builders/JumpTarget.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // JumpTarget.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. namespace Neo.VM.Benchmarks.Builders; public class JumpTarget { public Instruction? _instruction; } ================================================ FILE: benchmarks/Neo.VM.Benchmarks/Neo.VM.Benchmarks.csproj ================================================ Exe net10.0 enable enable false ================================================ FILE: benchmarks/Neo.VM.Benchmarks/OpCodes/Arrays/OpCode.ReverseN.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // OpCode.ReverseN.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Benchmarks.Builders; namespace Neo.VM.Benchmarks.OpCodes.Arrays; public class OpCode_ReverseN : OpCodeBase { protected override byte[] CreateScript(BenchmarkMode benchmarkMode) { var builder = new InstructionBuilder(); var initBegin = new JumpTarget(); builder.AddInstruction(new Builders.Instruction { _opCode = OpCode.INITSLOT, _operand = [1, 0] }); builder.Push(ItemCount); builder.AddInstruction(OpCode.STLOC0); initBegin._instruction = builder.AddInstruction(OpCode.NOP); builder.Push(0); builder.AddInstruction(OpCode.LDLOC0); builder.AddInstruction(OpCode.DEC); builder.AddInstruction(OpCode.STLOC0); builder.AddInstruction(OpCode.LDLOC0); builder.Jump(OpCode.JMPIF, initBegin); if (benchmarkMode == BenchmarkMode.BaseLine) { return builder.ToArray(); } builder.Push(ItemCount); builder.AddInstruction(OpCode.REVERSEN); if (benchmarkMode == BenchmarkMode.OneGAS) { // just keep running until GAS is exhausted var loopStart = new JumpTarget { _instruction = builder.AddInstruction(OpCode.NOP) }; builder.Push(ItemCount); builder.AddInstruction(OpCode.REVERSEN); builder.Jump(OpCode.JMP, loopStart); } return builder.ToArray(); } } // for 0 // BenchmarkDotNet v0.13.12, Windows 11 (10.0.22631.4249/23H2/2023Update/SunValley3) // Intel Core i9-14900HX, 1 CPU, 32 logical and 24 physical cores // .NET SDK 8.0.205 // [Host] : .NET 8.0.5 (8.0.524.21615), X64 RyuJIT AVX2 // DefaultJob : .NET 8.0.5 (8.0.524.21615), X64 RyuJIT AVX2 // // // | Method | ItemCount | Mean | Error | StdDev | Median | Ratio | RatioSD | // |--------------------- |---------- |-----------------:|--------------:|---------------:|-----------------:|----------:|---------:| // | Bench_ReverseN | 1 | 63.43 us | 0.466 us | 0.518 us | 63.45 us | 0.99 | 0.01 | // | Bench_OneGasReverseN | 1 | 403,904.11 us | 6,492.511 us | 6,073.099 us | 402,932.40 us | 6,315.67 | 89.44 | // | Bench_BaseLine | 1 | 63.96 us | 0.763 us | 0.714 us | 63.92 us | 1.00 | 0.00 | // | | | | | | | | | // | Bench_ReverseN | 2 | 62.55 us | 0.988 us | 0.924 us | 62.46 us | 0.95 | 0.02 | // | Bench_OneGasReverseN | 2 | 424,297.10 us | 8,453.137 us | 7,493.486 us | 423,912.90 us | 6,446.21 | 118.35 | // | Bench_BaseLine | 2 | 65.83 us | 0.845 us | 0.749 us | 65.95 us | 1.00 | 0.00 | // | | | | | | | | | // | Bench_ReverseN | 4 | 63.93 us | 0.418 us | 0.371 us | 63.89 us | 0.95 | 0.03 | // | Bench_OneGasReverseN | 4 | 443,708.92 us | 6,689.013 us | 6,256.907 us | 444,636.60 us | 6,560.69 | 229.86 | // | Bench_BaseLine | 4 | 67.64 us | 1.281 us | 1.524 us | 67.79 us | 1.00 | 0.00 | // | | | | | | | | | // | Bench_ReverseN | 8 | 66.69 us | 0.757 us | 0.671 us | 66.69 us | 1.00 | 0.02 | // | Bench_OneGasReverseN | 8 | 463,571.38 us | 6,614.687 us | 6,187.382 us | 465,568.00 us | 6,963.59 | 85.80 | // | Bench_BaseLine | 8 | 66.64 us | 0.870 us | 0.771 us | 66.68 us | 1.00 | 0.00 | // | | | | | | | | | // | Bench_ReverseN | 16 | 65.85 us | 0.994 us | 0.929 us | 65.61 us | 0.94 | 0.02 | // | Bench_OneGasReverseN | 16 | 740,905.55 us | 71,090.901 us | 209,613.127 us | 653,644.75 us | 9,341.86 | 3,092.85 | // | Bench_BaseLine | 16 | 70.08 us | 1.376 us | 1.638 us | 70.15 us | 1.00 | 0.00 | // | | | | | | | | | // | Bench_ReverseN | 32 | 66.47 us | 0.928 us | 2.187 us | 65.77 us | 1.02 | 0.04 | // | Bench_OneGasReverseN | 32 | 631,596.65 us | 11,060.847 us | 10,346.323 us | 629,654.10 us | 9,360.06 | 221.36 | // | Bench_BaseLine | 32 | 67.49 us | 0.900 us | 0.842 us | 67.56 us | 1.00 | 0.00 | // | | | | | | | | | // | Bench_ReverseN | 64 | 72.21 us | 0.921 us | 0.862 us | 72.05 us | 1.02 | 0.02 | // | Bench_OneGasReverseN | 64 | 787,570.95 us | 6,915.746 us | 6,468.994 us | 786,778.70 us | 11,090.76 | 177.74 | // | Bench_BaseLine | 64 | 71.02 us | 0.946 us | 0.884 us | 71.06 us | 1.00 | 0.00 | // | | | | | | | | | // | Bench_ReverseN | 128 | 80.17 us | 0.723 us | 0.676 us | 80.19 us | 0.98 | 0.01 | // | Bench_OneGasReverseN | 128 | 1,134,510.61 us | 14,991.714 us | 14,023.259 us | 1,133,177.90 us | 13,828.61 | 184.58 | // | Bench_BaseLine | 128 | 81.90 us | 0.623 us | 0.553 us | 81.77 us | 1.00 | 0.00 | // | | | | | | | | | // | Bench_ReverseN | 256 | 98.24 us | 1.140 us | 1.067 us | 98.05 us | 0.99 | 0.01 | // | Bench_OneGasReverseN | 256 | 1,785,906.33 us | 13,785.746 us | 12,895.195 us | 1,788,819.30 us | 18,067.20 | 198.87 | // | Bench_BaseLine | 256 | 98.85 us | 0.961 us | 0.899 us | 98.95 us | 1.00 | 0.00 | // | | | | | | | | | // | Bench_ReverseN | 512 | 136.19 us | 1.614 us | 1.510 us | 136.34 us | 1.02 | 0.02 | // | Bench_OneGasReverseN | 512 | 3,100,087.41 us | 16,564.249 us | 15,494.209 us | 3,097,066.60 us | 23,209.57 | 381.50 | // | Bench_BaseLine | 512 | 133.60 us | 2.144 us | 2.006 us | 132.73 us | 1.00 | 0.00 | // | | | | | | | | | // | Bench_ReverseN | 1024 | 207.06 us | 2.213 us | 2.070 us | 206.76 us | 1.01 | 0.01 | // | Bench_OneGasReverseN | 1024 | 5,762,294.72 us | 20,289.404 us | 16,942.572 us | 5,764,133.80 us | 28,109.14 | 349.87 | // | Bench_BaseLine | 1024 | 205.07 us | 2.360 us | 2.208 us | 205.07 us | 1.00 | 0.00 | // | | | | | | | | | // | Bench_ReverseN | 2040 | 345.09 us | 4.271 us | 3.995 us | 345.40 us | 0.97 | 0.01 | // | Bench_OneGasReverseN | 2040 | 11,005,147.03 us | 37,306.455 us | 33,071.200 us | 11,003,479.70 us | 31,019.36 | 356.02 | // | Bench_BaseLine | 2040 | 354.62 us | 4.623 us | 4.325 us | 353.32 us | 1.00 | 0.00 | // for StackItems that has a size of maximum stack size. // | Method | ItemCount | Mean | Error | StdDev | // |--------------------- |---------- |----------------:|--------------:|--------------:| // | Bench_ReverseN | 1 | 104.0 us | 0.77 us | 0.72 us | // | Bench_OneGasReverseN | 1 | 389,585.4 us | 4,740.18 us | 4,433.96 us | // | Bench_ReverseN | 2 | 148.3 us | 2.25 us | 2.10 us | // | Bench_OneGasReverseN | 2 | 417,831.5 us | 6,651.20 us | 6,221.53 us | // | Bench_ReverseN | 4 | 231.8 us | 3.92 us | 3.67 us | // | Bench_OneGasReverseN | 4 | 428,442.6 us | 8,034.41 us | 7,515.39 us | // | Bench_ReverseN | 8 | 387.8 us | 5.23 us | 4.89 us | // | Bench_OneGasReverseN | 8 | 448,046.9 us | 6,270.18 us | 5,235.89 us | // | Bench_ReverseN | 16 | 240.0 us | 7.30 us | 21.53 us | // | Bench_OneGasReverseN | 16 | 522,904.3 us | 7,157.93 us | 6,695.54 us | // | Bench_ReverseN | 32 | 302.4 us | 9.53 us | 27.79 us | // | Bench_OneGasReverseN | 32 | 626,536.6 us | 6,629.69 us | 6,201.42 us | // | Bench_ReverseN | 64 | 1,728.3 us | 34.27 us | 58.19 us | // | Bench_OneGasReverseN | 64 | 827,284.5 us | 15,943.00 us | 14,913.09 us | // | Bench_ReverseN | 128 | 3,704.5 us | 73.98 us | 175.82 us | // | Bench_OneGasReverseN | 128 | 1,125,104.6 us | 10,629.65 us | 9,942.98 us | // | Bench_ReverseN | 256 | 6,381.1 us | 127.42 us | 290.21 us | // | Bench_OneGasReverseN | 256 | 1,804,355.7 us | 9,690.50 us | 8,590.37 us | // | Bench_ReverseN | 512 | 9,485.9 us | 184.52 us | 492.52 us | // | Bench_OneGasReverseN | 512 | 3,159,411.1 us | 28,901.54 us | 27,034.52 us | // | Bench_ReverseN | 1024 | 14,125.6 us | 282.51 us | 577.08 us | // | Bench_OneGasReverseN | 1024 | 5,799,154.5 us | 33,817.93 us | 31,633.31 us | // | Bench_ReverseN | 2040 | 22,868.0 us | 449.84 us | 929.00 us | // | Bench_OneGasReverseN | 2040 | 11,100,853.9 us | 159,980.97 us | 141,818.97 us | ================================================ FILE: benchmarks/Neo.VM.Benchmarks/OpCodes/Benchmark.Opcode.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Benchmark.Opcode.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. namespace Neo.VM.Benchmarks.OpCodes; public class Benchmark_Opcode { internal static readonly long OneGasDatoshi = 1_0000_0000; public static readonly IReadOnlyDictionary OpCodePrices = new Dictionary { [OpCode.PUSHINT8] = 1 << 0, [OpCode.PUSHINT16] = 1 << 0, [OpCode.PUSHINT32] = 1 << 0, [OpCode.PUSHINT64] = 1 << 0, [OpCode.PUSHINT128] = 1 << 2, [OpCode.PUSHINT256] = 1 << 2, [OpCode.PUSHT] = 1 << 0, [OpCode.PUSHF] = 1 << 0, [OpCode.PUSHA] = 1 << 2, [OpCode.PUSHNULL] = 1 << 0, [OpCode.PUSHDATA1] = 1 << 3, [OpCode.PUSHDATA2] = 1 << 9, [OpCode.PUSHDATA4] = 1 << 12, [OpCode.PUSHM1] = 1 << 0, [OpCode.PUSH0] = 1 << 0, [OpCode.PUSH1] = 1 << 0, [OpCode.PUSH2] = 1 << 0, [OpCode.PUSH3] = 1 << 0, [OpCode.PUSH4] = 1 << 0, [OpCode.PUSH5] = 1 << 0, [OpCode.PUSH6] = 1 << 0, [OpCode.PUSH7] = 1 << 0, [OpCode.PUSH8] = 1 << 0, [OpCode.PUSH9] = 1 << 0, [OpCode.PUSH10] = 1 << 0, [OpCode.PUSH11] = 1 << 0, [OpCode.PUSH12] = 1 << 0, [OpCode.PUSH13] = 1 << 0, [OpCode.PUSH14] = 1 << 0, [OpCode.PUSH15] = 1 << 0, [OpCode.PUSH16] = 1 << 0, [OpCode.NOP] = 1 << 0, [OpCode.JMP] = 1 << 1, [OpCode.JMP_L] = 1 << 1, [OpCode.JMPIF] = 1 << 1, [OpCode.JMPIF_L] = 1 << 1, [OpCode.JMPIFNOT] = 1 << 1, [OpCode.JMPIFNOT_L] = 1 << 1, [OpCode.JMPEQ] = 1 << 1, [OpCode.JMPEQ_L] = 1 << 1, [OpCode.JMPNE] = 1 << 1, [OpCode.JMPNE_L] = 1 << 1, [OpCode.JMPGT] = 1 << 1, [OpCode.JMPGT_L] = 1 << 1, [OpCode.JMPGE] = 1 << 1, [OpCode.JMPGE_L] = 1 << 1, [OpCode.JMPLT] = 1 << 1, [OpCode.JMPLT_L] = 1 << 1, [OpCode.JMPLE] = 1 << 1, [OpCode.JMPLE_L] = 1 << 1, [OpCode.CALL] = 1 << 9, [OpCode.CALL_L] = 1 << 9, [OpCode.CALLA] = 1 << 9, [OpCode.CALLT] = 1 << 15, [OpCode.ABORT] = 0, [OpCode.ABORTMSG] = 0, [OpCode.ASSERT] = 1 << 0, [OpCode.ASSERTMSG] = 1 << 0, [OpCode.THROW] = 1 << 9, [OpCode.TRY] = 1 << 2, [OpCode.TRY_L] = 1 << 2, [OpCode.ENDTRY] = 1 << 2, [OpCode.ENDTRY_L] = 1 << 2, [OpCode.ENDFINALLY] = 1 << 2, [OpCode.RET] = 0, [OpCode.SYSCALL] = 0, [OpCode.DEPTH] = 1 << 1, [OpCode.DROP] = 1 << 1, [OpCode.NIP] = 1 << 1, [OpCode.XDROP] = 1 << 4, [OpCode.CLEAR] = 1 << 4, [OpCode.DUP] = 1 << 1, [OpCode.OVER] = 1 << 1, [OpCode.PICK] = 1 << 1, [OpCode.TUCK] = 1 << 1, [OpCode.SWAP] = 1 << 1, [OpCode.ROT] = 1 << 1, [OpCode.ROLL] = 1 << 4, [OpCode.REVERSE3] = 1 << 1, [OpCode.REVERSE4] = 1 << 1, [OpCode.REVERSEN] = 1 << 4, [OpCode.INITSSLOT] = 1 << 4, [OpCode.INITSLOT] = 1 << 6, [OpCode.LDSFLD0] = 1 << 1, [OpCode.LDSFLD1] = 1 << 1, [OpCode.LDSFLD2] = 1 << 1, [OpCode.LDSFLD3] = 1 << 1, [OpCode.LDSFLD4] = 1 << 1, [OpCode.LDSFLD5] = 1 << 1, [OpCode.LDSFLD6] = 1 << 1, [OpCode.LDSFLD] = 1 << 1, [OpCode.STSFLD0] = 1 << 1, [OpCode.STSFLD1] = 1 << 1, [OpCode.STSFLD2] = 1 << 1, [OpCode.STSFLD3] = 1 << 1, [OpCode.STSFLD4] = 1 << 1, [OpCode.STSFLD5] = 1 << 1, [OpCode.STSFLD6] = 1 << 1, [OpCode.STSFLD] = 1 << 1, [OpCode.LDLOC0] = 1 << 1, [OpCode.LDLOC1] = 1 << 1, [OpCode.LDLOC2] = 1 << 1, [OpCode.LDLOC3] = 1 << 1, [OpCode.LDLOC4] = 1 << 1, [OpCode.LDLOC5] = 1 << 1, [OpCode.LDLOC6] = 1 << 1, [OpCode.LDLOC] = 1 << 1, [OpCode.STLOC0] = 1 << 1, [OpCode.STLOC1] = 1 << 1, [OpCode.STLOC2] = 1 << 1, [OpCode.STLOC3] = 1 << 1, [OpCode.STLOC4] = 1 << 1, [OpCode.STLOC5] = 1 << 1, [OpCode.STLOC6] = 1 << 1, [OpCode.STLOC] = 1 << 1, [OpCode.LDARG0] = 1 << 1, [OpCode.LDARG1] = 1 << 1, [OpCode.LDARG2] = 1 << 1, [OpCode.LDARG3] = 1 << 1, [OpCode.LDARG4] = 1 << 1, [OpCode.LDARG5] = 1 << 1, [OpCode.LDARG6] = 1 << 1, [OpCode.LDARG] = 1 << 1, [OpCode.STARG0] = 1 << 1, [OpCode.STARG1] = 1 << 1, [OpCode.STARG2] = 1 << 1, [OpCode.STARG3] = 1 << 1, [OpCode.STARG4] = 1 << 1, [OpCode.STARG5] = 1 << 1, [OpCode.STARG6] = 1 << 1, [OpCode.STARG] = 1 << 1, [OpCode.NEWBUFFER] = 1 << 8, [OpCode.MEMCPY] = 1 << 11, [OpCode.CAT] = 1 << 11, [OpCode.SUBSTR] = 1 << 11, [OpCode.LEFT] = 1 << 11, [OpCode.RIGHT] = 1 << 11, [OpCode.INVERT] = 1 << 2, [OpCode.AND] = 1 << 3, [OpCode.OR] = 1 << 3, [OpCode.XOR] = 1 << 3, [OpCode.EQUAL] = 1 << 5, [OpCode.NOTEQUAL] = 1 << 5, [OpCode.SIGN] = 1 << 2, [OpCode.ABS] = 1 << 2, [OpCode.NEGATE] = 1 << 2, [OpCode.INC] = 1 << 2, [OpCode.DEC] = 1 << 2, [OpCode.ADD] = 1 << 3, [OpCode.SUB] = 1 << 3, [OpCode.MUL] = 1 << 3, [OpCode.DIV] = 1 << 3, [OpCode.MOD] = 1 << 3, [OpCode.POW] = 1 << 6, [OpCode.SQRT] = 1 << 6, [OpCode.MODMUL] = 1 << 5, [OpCode.MODPOW] = 1 << 11, [OpCode.SHL] = 1 << 3, [OpCode.SHR] = 1 << 3, [OpCode.NOT] = 1 << 2, [OpCode.BOOLAND] = 1 << 3, [OpCode.BOOLOR] = 1 << 3, [OpCode.NZ] = 1 << 2, [OpCode.NUMEQUAL] = 1 << 3, [OpCode.NUMNOTEQUAL] = 1 << 3, [OpCode.LT] = 1 << 3, [OpCode.LE] = 1 << 3, [OpCode.GT] = 1 << 3, [OpCode.GE] = 1 << 3, [OpCode.MIN] = 1 << 3, [OpCode.MAX] = 1 << 3, [OpCode.WITHIN] = 1 << 3, [OpCode.PACKMAP] = 1 << 11, [OpCode.PACKSTRUCT] = 1 << 11, [OpCode.PACK] = 1 << 11, [OpCode.UNPACK] = 1 << 11, [OpCode.NEWARRAY0] = 1 << 4, [OpCode.NEWARRAY] = 1 << 9, [OpCode.NEWARRAY_T] = 1 << 9, [OpCode.NEWSTRUCT0] = 1 << 4, [OpCode.NEWSTRUCT] = 1 << 9, [OpCode.NEWMAP] = 1 << 3, [OpCode.SIZE] = 1 << 2, [OpCode.HASKEY] = 1 << 6, [OpCode.KEYS] = 1 << 4, [OpCode.VALUES] = 1 << 13, [OpCode.PICKITEM] = 1 << 6, [OpCode.APPEND] = 1 << 13, [OpCode.SETITEM] = 1 << 13, [OpCode.REVERSEITEMS] = 1 << 13, [OpCode.REMOVE] = 1 << 4, [OpCode.CLEARITEMS] = 1 << 4, [OpCode.POPITEM] = 1 << 4, [OpCode.ISNULL] = 1 << 1, [OpCode.ISTYPE] = 1 << 1, [OpCode.CONVERT] = 1 << 13, }; internal static void RunScript(byte[] script) { LoadScript(script).ExecuteBenchmark(); } internal static BenchmarkEngine RunScriptUntil(byte[] script, OpCode opCode) { return LoadScript(script).ExecuteUntil(opCode); } internal static BenchmarkEngine LoadScript(byte[] script) { var engine = new BenchmarkEngine(); engine.LoadScript(script); return engine; } } ================================================ FILE: benchmarks/Neo.VM.Benchmarks/OpCodes/BenchmarkEngine.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // BenchmarkEngine.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; using System.Diagnostics; using System.Runtime.CompilerServices; namespace Neo.VM.Benchmarks.OpCodes; /// /// A simple benchmark engine for . /// public class BenchmarkEngine : ExecutionEngine { private readonly Dictionary _opcodeStats = new(); private readonly Dictionary> _breakPoints = new(); private long _gasConsumed = 0; public BenchmarkEngine() : base(ComposeJumpTable()) { } /// /// Add a breakpoint at the specified position of the specified script. The VM will break the execution when it reaches the breakpoint. /// /// The script to add the breakpoint. /// The position of the breakpoint in the script. public void AddBreakPoint(Script script, uint position) { if (!_breakPoints.TryGetValue(script, out var hashset)) { hashset = []; _breakPoints.Add(script, hashset); } hashset.Add(position); } /// /// Start or continue execution of the VM. /// /// Returns the state of the VM after the execution. public BenchmarkEngine ExecuteUntil(OpCode opCode) { if (State == VMState.BREAK) State = VMState.NONE; while (State == VMState.NONE) { ExecuteNext(); try { var instruction = CurrentContext!.CurrentInstruction!.OpCode; if (instruction == opCode) break; } catch { break; } } return this; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public void ExecuteBenchmark() { while (State != VMState.HALT && State != VMState.FAULT) { #if DEBUG var stopwatch = Stopwatch.StartNew(); #endif ExecuteNext(); #if DEBUG stopwatch.Stop(); UpdateOpcodeStats(CurrentContext!.CurrentInstruction!.OpCode, stopwatch.Elapsed); #endif } #if DEBUG PrintOpcodeStats(); #endif } [MethodImpl(MethodImplOptions.AggressiveInlining)] public void ExecuteOneGASBenchmark() { while (State != VMState.HALT && State != VMState.FAULT) { var instruction = CurrentContext!.CurrentInstruction ?? Instruction.RET; _gasConsumed += Benchmark_Opcode.OpCodePrices[instruction.OpCode]; if (_gasConsumed >= Benchmark_Opcode.OneGasDatoshi) { State = VMState.HALT; } #if DEBUG var stopwatch = Stopwatch.StartNew(); #endif ExecuteNext(); #if DEBUG stopwatch.Stop(); UpdateOpcodeStats(instruction.OpCode, stopwatch.Elapsed); #endif } #if DEBUG PrintOpcodeStats(); #endif } [MethodImpl(MethodImplOptions.AggressiveInlining)] public void ExecuteTwentyGASBenchmark() { while (State != VMState.HALT && State != VMState.FAULT) { var instruction = CurrentContext!.CurrentInstruction ?? Instruction.RET; _gasConsumed += Benchmark_Opcode.OpCodePrices[instruction.OpCode]; if (_gasConsumed >= 20 * Benchmark_Opcode.OneGasDatoshi) { State = VMState.HALT; } #if DEBUG var stopwatch = Stopwatch.StartNew(); #endif ExecuteNext(); #if DEBUG stopwatch.Stop(); UpdateOpcodeStats(instruction.OpCode, stopwatch.Elapsed); #endif } #if DEBUG PrintOpcodeStats(); #endif } [MethodImpl(MethodImplOptions.AggressiveInlining)] public void ExecuteOpCodesBenchmark() { while (State != VMState.HALT && State != VMState.FAULT) { var instruction = CurrentContext!.CurrentInstruction ?? Instruction.RET; _gasConsumed += Benchmark_Opcode.OpCodePrices[instruction.OpCode]; if (_gasConsumed >= Benchmark_Opcode.OneGasDatoshi) { State = VMState.HALT; } #if DEBUG var stopwatch = Stopwatch.StartNew(); #endif ExecuteNext(); #if DEBUG stopwatch.Stop(); UpdateOpcodeStats(instruction.OpCode, stopwatch.Elapsed); #endif } #if DEBUG PrintOpcodeStats(); #endif } protected override void OnFault(Exception ex) { base.OnFault(ex); // throw ex; } private void UpdateOpcodeStats(OpCode opcode, TimeSpan elapsed) { if (!_opcodeStats.TryGetValue(opcode, out var value)) { _opcodeStats[opcode] = (1, elapsed); } else { var (count, totalTime) = value; _opcodeStats[opcode] = (count + 1, totalTime + elapsed); } } private void PrintOpcodeStats() { Console.WriteLine("Opcode Statistics:"); foreach (var kvp in _opcodeStats) { Console.WriteLine($"{kvp.Key,-15} " + $"Count: {kvp.Value.Count,8} " + $"Total Time: {kvp.Value.TotalTime.TotalMilliseconds * 1000,10:F2} μs " + $"Avg Time: {kvp.Value.TotalTime.TotalMilliseconds * 1000 / kvp.Value.Count,10:F2} μs"); } } private static JumpTable ComposeJumpTable() { var jumpTable = new JumpTable(); jumpTable[OpCode.SYSCALL] = OnSysCall; return jumpTable; } private static void OnSysCall(ExecutionEngine engine, Instruction instruction) { uint method = instruction.TokenU32; if (method == 0x77777777) engine.CurrentContext!.EvaluationStack.Push(StackItem.FromInterface(new object())); else if (method == 0xaddeadde) engine.JumpTable.ExecuteThrow(engine, "error"); else throw new Exception(); } } ================================================ FILE: benchmarks/Neo.VM.Benchmarks/OpCodes/BenchmarkMode.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // BenchmarkMode.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. namespace Neo.VM.Benchmarks.OpCodes; public enum BenchmarkMode { SimpleOpCode, OneGAS, BaseLine } ================================================ FILE: benchmarks/Neo.VM.Benchmarks/OpCodes/Benchmarks_StackOps.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Benchmarks_StackOps.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using BenchmarkDotNet.Attributes; namespace Neo.VM.Benchmarks.OpCodes; [MemoryDiagnoser] [CsvExporter] [MarkdownExporterAttribute.GitHub] [InvocationCount(1)] public class Benchmarks_StackOps { private const int RepeatCount = 1000; private const int MultipleCount = 50; private const int MultipleIterations = RepeatCount * MultipleCount; // Keep description strings in sync with RepeatCount/MultipleCount. private const string SwapShallowDescription = "SWAP_Shallow_2x1000"; private const string SwapDeepDescription = "SWAP_Deep_100x1000"; private const string SwapMultipleDescription = "SWAP_Multiple_50x1000"; private const string RotShallowDescription = "ROT_Shallow_3x1000"; private const string RotDeepDescription = "ROT_Deep_100x1000"; private const string RotMultipleDescription = "ROT_Multiple_50x1000"; private BenchmarkEngine _engine = null!; private byte[] _swapShallowScript = []; private byte[] _swapDeepScript = []; private byte[] _swapMultipleScript = []; private byte[] _rotShallowScript = []; private byte[] _rotDeepScript = []; private byte[] _rotMultipleScript = []; [GlobalSetup] public void GlobalSetup() { _swapShallowScript = BuildScript(sb => { sb.EmitPush(1); sb.EmitPush(2); for (int i = 0; i < RepeatCount; i++) sb.Emit(OpCode.SWAP); }); _swapDeepScript = BuildScript(sb => { for (int i = 0; i < 100; i++) sb.EmitPush(i); for (int i = 0; i < RepeatCount; i++) sb.Emit(OpCode.SWAP); }); _swapMultipleScript = BuildScript(sb => { sb.EmitPush(1); sb.EmitPush(2); for (int i = 0; i < MultipleIterations; i++) sb.Emit(OpCode.SWAP); }); _rotShallowScript = BuildScript(sb => { sb.EmitPush(1); sb.EmitPush(2); sb.EmitPush(3); for (int i = 0; i < RepeatCount; i++) sb.Emit(OpCode.ROT); }); _rotDeepScript = BuildScript(sb => { for (int i = 0; i < 100; i++) sb.EmitPush(i); for (int i = 0; i < RepeatCount; i++) sb.Emit(OpCode.ROT); }); _rotMultipleScript = BuildScript(sb => { sb.EmitPush(1); sb.EmitPush(2); sb.EmitPush(3); for (int i = 0; i < MultipleIterations; i++) sb.Emit(OpCode.ROT); }); } private static byte[] BuildScript(Action build) { using var sb = new ScriptBuilder(); build(sb); return sb.ToArray(); } private void SetupEngine(byte[] script) { _engine = new BenchmarkEngine(); _engine.LoadScript(script); } #region SWAP Benchmarks [IterationSetup(Target = nameof(Bench_SWAP_Shallow))] public void Setup_SWAP_Shallow() => SetupEngine(_swapShallowScript); [Benchmark(Description = SwapShallowDescription)] public void Bench_SWAP_Shallow() { _engine.ExecuteBenchmark(); } [IterationSetup(Target = nameof(Bench_SWAP_Deep))] public void Setup_SWAP_Deep() => SetupEngine(_swapDeepScript); [Benchmark(Description = SwapDeepDescription)] public void Bench_SWAP_Deep() { _engine.ExecuteBenchmark(); } [IterationSetup(Target = nameof(Bench_SWAP_Multiple))] public void Setup_SWAP_Multiple() => SetupEngine(_swapMultipleScript); [Benchmark(Description = SwapMultipleDescription)] public void Bench_SWAP_Multiple() { _engine.ExecuteBenchmark(); } #endregion #region ROT Benchmarks [IterationSetup(Target = nameof(Bench_ROT_Shallow))] public void Setup_ROT_Shallow() => SetupEngine(_rotShallowScript); [Benchmark(Description = RotShallowDescription)] public void Bench_ROT_Shallow() { _engine.ExecuteBenchmark(); } [IterationSetup(Target = nameof(Bench_ROT_Deep))] public void Setup_ROT_Deep() => SetupEngine(_rotDeepScript); [Benchmark(Description = RotDeepDescription)] public void Bench_ROT_Deep() { _engine.ExecuteBenchmark(); } [IterationSetup(Target = nameof(Bench_ROT_Multiple))] public void Setup_ROT_Multiple() => SetupEngine(_rotMultipleScript); [Benchmark(Description = RotMultipleDescription)] public void Bench_ROT_Multiple() { _engine.ExecuteBenchmark(); } #endregion } ================================================ FILE: benchmarks/Neo.VM.Benchmarks/OpCodes/OpCodeBase.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // OpCodeBase.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using BenchmarkDotNet.Attributes; namespace Neo.VM.Benchmarks.OpCodes; public abstract class OpCodeBase { [Params(1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2040)] public int ItemCount { get; set; } = 10; protected byte[] baseLineScript = Array.Empty(); protected byte[] script = Array.Empty(); protected byte[] multiScript = Array.Empty(); [GlobalSetup] public void Setup() { script = CreateScript(BenchmarkMode.SimpleOpCode); multiScript = CreateScript(BenchmarkMode.OneGAS); baseLineScript = CreateScript(BenchmarkMode.BaseLine); } [Benchmark(Baseline = true)] public void Bench_BaseLine() => Benchmark_Opcode.RunScript(baseLineScript); [Benchmark] public void Bench_OneOpCode() => Benchmark_Opcode.RunScript(script); /// /// Benchmark how long 1 GAS can run. /// [Benchmark] public void Bench_OneGAS() => Benchmark_Opcode.LoadScript(multiScript).ExecuteOneGASBenchmark(); protected abstract byte[] CreateScript(BenchmarkMode benchmarkMode); } ================================================ FILE: benchmarks/Neo.VM.Benchmarks/Program.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Program.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using BenchmarkDotNet.Attributes; using BenchmarkDotNet.Running; using Neo.VM.Benchmarks; using System.Reflection; // Define the benchmark or execute class if (Environment.GetEnvironmentVariable("NEO_VM_BENCHMARK") != null) { BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args); } else { var benchmarkType = typeof(Benchmarks_PoCs); var instance = Activator.CreateInstance(benchmarkType); benchmarkType.GetMethods(BindingFlags.Public | BindingFlags.Instance) .FirstOrDefault(m => m.GetCustomAttribute() != null)? .Invoke(instance, null); // setup var methods = benchmarkType.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static) .Where(m => m.DeclaringType == benchmarkType && !m.GetCustomAttributes().Any()); foreach (var method in methods) { method.Invoke(instance, null); } } ================================================ FILE: benchmarks/Neo.VM.Benchmarks/TestArray.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // TestArray.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; using System.Collections; namespace Neo.VM.Benchmarks; public class TestArray : CompoundType, IReadOnlyList { protected readonly List InnerList; /// /// Get or set item in the array. /// /// The index of the item in the array. /// The item at the specified index. public StackItem this[int index] { get => InnerList[index]; set { if (IsReadOnly) throw new InvalidOperationException("The object is readonly."); ReferenceCounter?.RemoveReference(InnerList[index], this); InnerList[index] = value; ReferenceCounter?.AddReference(value, this); } } /// /// The number of items in the array. /// public override int Count => InnerList.Count; public override IEnumerable SubItems => InnerList; public override int SubItemsCount => InnerList.Count; public override StackItemType Type => StackItemType.Array; /// /// Create an array containing the specified items. /// /// The items to be included in the array. public TestArray(IEnumerable? items = null) : this(null, items) { } /// /// Create an array containing the specified items. And make the array use the specified . /// /// The to be used by this array. /// The items to be included in the array. public TestArray(IReferenceCounter? referenceCounter, IEnumerable? items = null) : base(referenceCounter) { InnerList = items switch { null => new List(), List list => list, _ => new List(items) }; if (referenceCounter != null) foreach (StackItem item in InnerList) referenceCounter.AddReference(item, this); } /// /// Add a new item at the end of the array. /// /// The item to be added. public void Add(StackItem item) { if (IsReadOnly) throw new InvalidOperationException("The object is readonly."); InnerList.Add(item); ReferenceCounter?.AddReference(item, this); } public override void Clear() { if (IsReadOnly) throw new InvalidOperationException("The object is readonly."); if (ReferenceCounter != null) foreach (StackItem item in InnerList) ReferenceCounter.RemoveReference(item, this); InnerList.Clear(); } public override StackItem ConvertTo(StackItemType type) { if (Type == StackItemType.Array && type == StackItemType.Struct) return new Struct(ReferenceCounter, new List(InnerList)); return base.ConvertTo(type); } internal sealed override StackItem DeepCopy(Dictionary refMap, bool asImmutable) { if (refMap.TryGetValue(this, out StackItem? mappedItem)) return mappedItem; var result = this is TestStruct ? new TestStruct(ReferenceCounter) : new TestArray(ReferenceCounter); refMap.Add(this, result); foreach (StackItem item in InnerList) result.Add(item.DeepCopy(refMap, asImmutable)); result.IsReadOnly = true; return result; } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } public IEnumerator GetEnumerator() { return InnerList.GetEnumerator(); } /// /// Remove the item at the specified index. /// /// The index of the item to be removed. public void RemoveAt(int index) { if (IsReadOnly) throw new InvalidOperationException("The object is readonly."); ReferenceCounter?.RemoveReference(InnerList[index], this); InnerList.RemoveAt(index); } /// /// Reverse all items in the array. /// public void Reverse() { if (IsReadOnly) throw new InvalidOperationException("The object is readonly."); InnerList.Reverse(); } } ================================================ FILE: benchmarks/Neo.VM.Benchmarks/TestStruct.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // TestStruct.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; namespace Neo.VM.Benchmarks; public class TestStruct : TestArray { public override StackItemType Type => StackItemType.Struct; /// /// Create a structure with the specified fields. /// /// The fields to be included in the structure. public TestStruct(IEnumerable? fields = null) : this(null, fields) { } /// /// Create a structure with the specified fields. And make the structure use the specified . /// /// The to be used by this structure. /// The fields to be included in the structure. public TestStruct(IReferenceCounter? referenceCounter, IEnumerable? fields = null) : base(referenceCounter, fields) { } /// /// Create a new structure with the same content as this structure. All nested structures will be copied by value. /// /// Execution engine limits /// The copied structure. public TestStruct Clone(ExecutionEngineLimits limits) { int count = (int)(limits.MaxStackSize - 1); TestStruct result = new(ReferenceCounter); Queue queue = new(); queue.Enqueue(result); queue.Enqueue(this); while (queue.Count > 0) { TestStruct a = queue.Dequeue(); TestStruct b = queue.Dequeue(); foreach (StackItem item in b) { count--; if (count < 0) throw new InvalidOperationException("Beyond clone limits!"); if (item is TestStruct sb) { TestStruct sa = new(ReferenceCounter); a.Add(sa); queue.Enqueue(sa); queue.Enqueue(sb); } else { a.Add(item); } } } return result; } public override StackItem ConvertTo(StackItemType type) { if (type == StackItemType.Array) return new TestArray(ReferenceCounter, new List(InnerList)); return base.ConvertTo(type); } public override bool Equals(StackItem? other) { throw new NotSupportedException(); } internal override bool Equals(StackItem? other, ExecutionEngineLimits limits) { if (other is not TestStruct s) return false; Stack stack1 = new(); Stack stack2 = new(); stack1.Push(this); stack2.Push(s); uint count = limits.MaxStackSize; uint maxComparableSize = limits.MaxComparableSize; while (stack1.Count > 0) { if (count-- == 0) throw new InvalidOperationException("Too many struct items to compare."); StackItem a = stack1.Pop(); StackItem b = stack2.Pop(); if (a is ByteString byteString) { if (!byteString.Equals(b, ref maxComparableSize)) return false; } else { if (maxComparableSize == 0) throw new InvalidOperationException("The operand exceeds the maximum comparable size."); maxComparableSize -= 1; if (a is TestStruct sa) { if (ReferenceEquals(a, b)) continue; if (b is not TestStruct sb) return false; if (sa.Count != sb.Count) return false; foreach (StackItem item in sa) stack1.Push(item); foreach (StackItem item in sb) stack2.Push(item); } else { if (!a.Equals(b)) return false; } } } return true; } } ================================================ FILE: benchmarks/Neo.VM.Benchmarks/VMTypes/Benchmarks_Convert.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Benchmarks_Convert.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using BenchmarkDotNet.Attributes; using Neo.VM.Types; using Array = Neo.VM.Types.Array; using Buffer = Neo.VM.Types.Buffer; namespace Neo.VM.Benchmarks.VMTypes; public class Benchmarks_Convert { private Dictionary>? testItemsByType; [GlobalSetup] public void Setup() { testItemsByType = CreateTestItemsByType(); } [Benchmark] [ArgumentsSource(nameof(GetTypeConversionPairs))] public void BenchConvertTo(StackItemType fromType, StackItemType toType) { if (testItemsByType is null) throw new InvalidOperationException($"{nameof(testItemsByType)} not initialized"); foreach (var item in testItemsByType[fromType]) { try { _ = item.ConvertTo(toType); } catch (Exception) { // Ignore invalid casts as they're expected for some conversions } } } public static IEnumerable GetTypeConversionPairs() { var types = Enum.GetValues(); foreach (var fromType in types) { foreach (var toType in types) { yield return new object[] { fromType, toType }; } } } private static Dictionary> CreateTestItemsByType() { var referenceCounter = new ReferenceCounter(); var result = new Dictionary>(); foreach (StackItemType type in Enum.GetValues()) { result[type] = new List(); } result[StackItemType.Boolean].Add(StackItem.True); result[StackItemType.Boolean].Add(StackItem.False); result[StackItemType.Integer].Add(new Integer(42)); result[StackItemType.Integer].Add(new Integer(-1)); result[StackItemType.ByteString].Add(new ByteString(new byte[] { 1, 2, 3 })); result[StackItemType.ByteString].Add(new ByteString(new byte[] { 255, 0, 128 })); // Create a 128-byte buffer var longBuffer = new byte[128]; for (int i = 0; i < 128; i++) longBuffer[i] = (byte)(i % 256); result[StackItemType.Buffer].Add(new Buffer(longBuffer)); result[StackItemType.Buffer].Add(new Buffer(new byte[128])); // Another 128-byte buffer, all zeros // Create an array with 10 items var longArray = new Array(referenceCounter); for (int i = 0; i < 10; i++) longArray.Add(new Integer(i)); result[StackItemType.Array].Add(longArray); result[StackItemType.Array].Add(new Array(referenceCounter) { StackItem.True, new ByteString(new byte[] { 3, 4, 5 }) }); // Create a struct with 10 items var longStruct = new Struct(referenceCounter); for (int i = 0; i < 10; i++) longStruct.Add(new Integer(i * 10)); result[StackItemType.Struct].Add(longStruct); result[StackItemType.Struct].Add(new Struct(referenceCounter) { StackItem.False, new Buffer(new byte[] { 6, 7, 8 }) }); // Create a map with 10 items var longMap = new Map(referenceCounter); for (int i = 0; i < 10; i++) longMap[new Integer(i)] = new ByteString(new byte[] { (byte)(i * 20) }); result[StackItemType.Map].Add(longMap); result[StackItemType.Map].Add(new Map(referenceCounter) { [new ByteString(new byte[] { 9 })] = StackItem.True }); result[StackItemType.InteropInterface].Add(new InteropInterface(new object())); result[StackItemType.InteropInterface].Add(new InteropInterface("test string")); return result; } } // BenchmarkDotNet v0.13.12, Windows 11 (10.0.22631.4249/23H2/2023Update/SunValley3) // Intel Core i9-14900HX, 1 CPU, 32 logical and 24 physical cores // .NET SDK 8.0.205 // [Host] : .NET 8.0.5 (8.0.524.21615), X64 RyuJIT AVX2 // DefaultJob : .NET 8.0.5 (8.0.524.21615), X64 RyuJIT AVX2 // // // | Method | fromType | toType | Mean | Error | StdDev | // |--------------- |----------------- |----------------- |-------------:|------------:|------------:| // | BenchConvertTo | Any | Any | 1.762 ns | 0.0195 ns | 0.0182 ns | // | BenchConvertTo | Any | Pointer | 1.791 ns | 0.0196 ns | 0.0183 ns | // | BenchConvertTo | Any | Boolean | 1.774 ns | 0.0245 ns | 0.0229 ns | // | BenchConvertTo | Any | Integer | 1.781 ns | 0.0236 ns | 0.0220 ns | // | BenchConvertTo | Any | ByteString | 1.767 ns | 0.0255 ns | 0.0226 ns | // | BenchConvertTo | Any | Buffer | 1.774 ns | 0.0217 ns | 0.0203 ns | // | BenchConvertTo | Any | Array | 1.770 ns | 0.0412 ns | 0.0385 ns | // | BenchConvertTo | Any | Struct | 1.787 ns | 0.0227 ns | 0.0212 ns | // | BenchConvertTo | Any | Map | 1.796 ns | 0.0292 ns | 0.0273 ns | // | BenchConvertTo | Any | InteropInterface | 1.820 ns | 0.0549 ns | 0.0675 ns | // | BenchConvertTo | Pointer | Any | 2.312 ns | 0.0210 ns | 0.0175 ns | // | BenchConvertTo | Pointer | Pointer | 2.337 ns | 0.0157 ns | 0.0146 ns | // | BenchConvertTo | Pointer | Boolean | 2.352 ns | 0.0190 ns | 0.0169 ns | // | BenchConvertTo | Pointer | Integer | 2.334 ns | 0.0231 ns | 0.0216 ns | // | BenchConvertTo | Pointer | ByteString | 2.317 ns | 0.0298 ns | 0.0279 ns | // | BenchConvertTo | Pointer | Buffer | 2.329 ns | 0.0274 ns | 0.0256 ns | // | BenchConvertTo | Pointer | Array | 2.338 ns | 0.0257 ns | 0.0241 ns | // | BenchConvertTo | Pointer | Struct | 2.336 ns | 0.0318 ns | 0.0298 ns | // | BenchConvertTo | Pointer | Map | 2.351 ns | 0.0676 ns | 0.0903 ns | // | BenchConvertTo | Pointer | InteropInterface | 2.281 ns | 0.0133 ns | 0.0125 ns | // | BenchConvertTo | Boolean | Any | 5,926.451 ns | 118.1195 ns | 136.0266 ns | // | BenchConvertTo | Boolean | Pointer | 6,001.282 ns | 15.3048 ns | 12.7802 ns | // | BenchConvertTo | Boolean | Boolean | 4.459 ns | 0.0151 ns | 0.0133 ns | // | BenchConvertTo | Boolean | Integer | 14.104 ns | 0.1526 ns | 0.1428 ns | // | BenchConvertTo | Boolean | ByteString | 11.650 ns | 0.0539 ns | 0.0450 ns | // | BenchConvertTo | Boolean | Buffer | 26.106 ns | 0.1549 ns | 0.1449 ns | // | BenchConvertTo | Boolean | Array | 5,813.116 ns | 28.1911 ns | 26.3700 ns | // | BenchConvertTo | Boolean | Struct | 5,809.844 ns | 19.1249 ns | 15.9702 ns | // | BenchConvertTo | Boolean | Map | 6,061.558 ns | 29.3991 ns | 27.4999 ns | // | BenchConvertTo | Boolean | InteropInterface | 5,924.682 ns | 80.5533 ns | 75.3496 ns | // | BenchConvertTo | Integer | Any | 5,240.903 ns | 41.0628 ns | 38.4102 ns | // | BenchConvertTo | Integer | Pointer | 5,479.116 ns | 75.8232 ns | 70.9251 ns | // | BenchConvertTo | Integer | Boolean | 5.981 ns | 0.0445 ns | 0.0416 ns | // | BenchConvertTo | Integer | Integer | 4.277 ns | 0.0177 ns | 0.0166 ns | // | BenchConvertTo | Integer | ByteString | 19.053 ns | 0.2125 ns | 0.1883 ns | // | BenchConvertTo | Integer | Buffer | 32.782 ns | 0.1653 ns | 0.1380 ns | // | BenchConvertTo | Integer | Array | 4,693.207 ns | 14.2446 ns | 12.6275 ns | // | BenchConvertTo | Integer | Struct | 4,737.341 ns | 60.1813 ns | 56.2936 ns | // | BenchConvertTo | Integer | Map | 4,808.431 ns | 23.5380 ns | 22.0174 ns | // | BenchConvertTo | Integer | InteropInterface | 4,684.409 ns | 24.7033 ns | 21.8989 ns | // | BenchConvertTo | ByteString | Any | 5,833.857 ns | 20.1553 ns | 18.8533 ns | // | BenchConvertTo | ByteString | Pointer | 5,807.973 ns | 11.7754 ns | 10.4386 ns | // | BenchConvertTo | ByteString | Boolean | 33.007 ns | 0.1574 ns | 0.1472 ns | // | BenchConvertTo | ByteString | Integer | 23.622 ns | 0.0755 ns | 0.0669 ns | // | BenchConvertTo | ByteString | ByteString | 4.288 ns | 0.0152 ns | 0.0142 ns | // | BenchConvertTo | ByteString | Buffer | 24.881 ns | 0.0889 ns | 0.0788 ns | // | BenchConvertTo | ByteString | Array | 6,030.813 ns | 19.9562 ns | 18.6670 ns | // | BenchConvertTo | ByteString | Struct | 5,811.185 ns | 24.0781 ns | 22.5226 ns | // | BenchConvertTo | ByteString | Map | 5,866.820 ns | 17.0315 ns | 15.0980 ns | // | BenchConvertTo | ByteString | InteropInterface | 5,757.124 ns | 16.3184 ns | 14.4658 ns | // | BenchConvertTo | Buffer | Any | 4,886.279 ns | 17.1370 ns | 14.3102 ns | // | BenchConvertTo | Buffer | Pointer | 4,698.364 ns | 14.5491 ns | 12.1492 ns | // | BenchConvertTo | Buffer | Boolean | 6.130 ns | 0.0323 ns | 0.0302 ns | // | BenchConvertTo | Buffer | Integer | 4,645.764 ns | 15.8146 ns | 14.7930 ns | // | BenchConvertTo | Buffer | ByteString | 29.874 ns | 0.1518 ns | 0.1268 ns | // | BenchConvertTo | Buffer | Buffer | 4.939 ns | 0.0190 ns | 0.0178 ns | // | BenchConvertTo | Buffer | Array | 4,683.427 ns | 21.3813 ns | 20.0001 ns | // | BenchConvertTo | Buffer | Struct | 4,680.762 ns | 15.7220 ns | 13.9371 ns | // | BenchConvertTo | Buffer | Map | 4,706.510 ns | 14.2061 ns | 12.5934 ns | // | BenchConvertTo | Buffer | InteropInterface | 4,703.050 ns | 15.8002 ns | 14.0064 ns | // | BenchConvertTo | Array | Any | 4,652.710 ns | 23.2061 ns | 20.5716 ns | // | BenchConvertTo | Array | Pointer | 4,625.049 ns | 12.4455 ns | 11.6415 ns | // | BenchConvertTo | Array | Boolean | 5.568 ns | 0.0181 ns | 0.0169 ns | // | BenchConvertTo | Array | Integer | 4,659.897 ns | 19.8036 ns | 18.5243 ns | // | BenchConvertTo | Array | ByteString | 4,663.020 ns | 12.4988 ns | 11.6914 ns | // | BenchConvertTo | Array | Buffer | 4,680.281 ns | 14.9748 ns | 13.2748 ns | // | BenchConvertTo | Array | Array | 4.246 ns | 0.0124 ns | 0.0110 ns | // | BenchConvertTo | Array | Struct | 1,193.106 ns | 98.5374 ns | 285.8748 ns | // | BenchConvertTo | Array | Map | 4,742.631 ns | 35.5855 ns | 33.2867 ns | // | BenchConvertTo | Array | InteropInterface | 4,670.743 ns | 9.3547 ns | 7.8116 ns | // | BenchConvertTo | Struct | Any | 4,643.558 ns | 31.0451 ns | 29.0396 ns | // | BenchConvertTo | Struct | Pointer | 4,867.925 ns | 22.2347 ns | 19.7105 ns | // | BenchConvertTo | Struct | Boolean | 5.581 ns | 0.0251 ns | 0.0235 ns | // | BenchConvertTo | Struct | Integer | 4,653.442 ns | 17.7417 ns | 16.5956 ns | // | BenchConvertTo | Struct | ByteString | 4,646.242 ns | 13.7830 ns | 12.8926 ns | // | BenchConvertTo | Struct | Buffer | 4,776.205 ns | 14.1918 ns | 13.2751 ns | // | BenchConvertTo | Struct | Array | 1,622.573 ns | 144.8116 ns | 398.8532 ns | // | BenchConvertTo | Struct | Struct | 4.195 ns | 0.0327 ns | 0.0290 ns | // | BenchConvertTo | Struct | Map | 4,672.579 ns | 17.6257 ns | 16.4871 ns | // | BenchConvertTo | Struct | InteropInterface | 4,653.476 ns | 8.2047 ns | 7.6747 ns | // | BenchConvertTo | Map | Any | 4,676.540 ns | 15.2010 ns | 13.4753 ns | // | BenchConvertTo | Map | Pointer | 4,663.489 ns | 13.7871 ns | 12.2219 ns | // | BenchConvertTo | Map | Boolean | 5.535 ns | 0.0205 ns | 0.0192 ns | // | BenchConvertTo | Map | Integer | 4,661.275 ns | 12.4402 ns | 11.6366 ns | // | BenchConvertTo | Map | ByteString | 4,662.482 ns | 25.7111 ns | 24.0502 ns | // | BenchConvertTo | Map | Buffer | 4,859.809 ns | 18.2981 ns | 16.2208 ns | // | BenchConvertTo | Map | Array | 4,627.149 ns | 10.7487 ns | 9.5285 ns | // | BenchConvertTo | Map | Struct | 4,646.504 ns | 22.4190 ns | 20.9707 ns | // | BenchConvertTo | Map | Map | 4.160 ns | 0.0180 ns | 0.0169 ns | // | BenchConvertTo | Map | InteropInterface | 4,667.024 ns | 14.1790 ns | 13.2630 ns | // | BenchConvertTo | InteropInterface | Any | 4,700.511 ns | 17.4725 ns | 15.4889 ns | // | BenchConvertTo | InteropInterface | Pointer | 4,705.819 ns | 25.2035 ns | 23.5754 ns | // | BenchConvertTo | InteropInterface | Boolean | 5.557 ns | 0.0244 ns | 0.0228 ns | // | BenchConvertTo | InteropInterface | Integer | 4,695.410 ns | 21.8674 ns | 20.4547 ns | // | BenchConvertTo | InteropInterface | ByteString | 4,674.552 ns | 18.8705 ns | 17.6515 ns | // | BenchConvertTo | InteropInterface | Buffer | 4,649.237 ns | 23.9084 ns | 22.3639 ns | // | BenchConvertTo | InteropInterface | Array | 4,827.652 ns | 29.7153 ns | 27.7957 ns | // | BenchConvertTo | InteropInterface | Struct | 4,624.202 ns | 10.3563 ns | 8.0855 ns | // | BenchConvertTo | InteropInterface | Map | 4,695.310 ns | 23.1192 ns | 21.6257 ns | // | BenchConvertTo | InteropInterface | InteropInterface | 4.137 ns | 0.0156 ns | 0.0138 ns | ================================================ FILE: benchmarks/Neo.VM.Benchmarks/VMTypes/Benchmarks_DeepCopy.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Benchmarks_DeepCopy.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using BenchmarkDotNet.Attributes; using Array = Neo.VM.Types.Array; namespace Neo.VM.Benchmarks.VMTypes; public class Benchmarks_DeepCopy { public static IEnumerable<(int Depth, int ElementsPerLevel)> ParamSource() { int[] depths = [2, 4]; int[] elementsPerLevel = [2, 4, 6]; foreach (var depth in depths) { foreach (var elements in elementsPerLevel) { if (depth <= 8 || elements <= 2) { yield return (depth, elements); } } } } [ParamsSource(nameof(ParamSource))] public (int Depth, int ElementsPerLevel) Params; [Benchmark] public void BenchNestedArrayDeepCopy() { var root = new Array(new ReferenceCounter()); CreateNestedArray(root, Params.Depth, Params.ElementsPerLevel); _ = root.DeepCopy(); } [Benchmark] public void BenchNestedArrayDeepCopyWithReferenceCounter() { var referenceCounter = new ReferenceCounter(); var root = new Array(referenceCounter); CreateNestedArray(root, Params.Depth, Params.ElementsPerLevel, referenceCounter); _ = root.DeepCopy(); } [Benchmark] public void BenchNestedTestArrayDeepCopy() { var root = new TestArray(new ReferenceCounter()); CreateNestedTestArray(root, Params.Depth, Params.ElementsPerLevel); _ = root.DeepCopy(); } [Benchmark] public void BenchNestedTestArrayDeepCopyWithReferenceCounter() { var referenceCounter = new ReferenceCounter(); var root = new TestArray(referenceCounter); CreateNestedTestArray(root, Params.Depth, Params.ElementsPerLevel, referenceCounter); _ = root.DeepCopy(); } private static void CreateNestedArray(Array? rootArray, int depth, int elementsPerLevel = 1, IReferenceCounter? referenceCounter = null) { if (depth < 0) { throw new ArgumentException("Depth must be non-negative", nameof(depth)); } ArgumentNullException.ThrowIfNull(rootArray); if (depth == 0) { return; } for (var i = 0; i < elementsPerLevel; i++) { var childArray = new Array(referenceCounter); rootArray.Add(childArray); CreateNestedArray(childArray, depth - 1, elementsPerLevel, referenceCounter); } } private static void CreateNestedTestArray(TestArray rootArray, int depth, int elementsPerLevel = 1, IReferenceCounter? referenceCounter = null) { if (depth < 0) { throw new ArgumentException("Depth must be non-negative", nameof(depth)); } ArgumentNullException.ThrowIfNull(rootArray); if (depth == 0) { return; } for (var i = 0; i < elementsPerLevel; i++) { var childArray = new TestArray(referenceCounter); rootArray.Add(childArray); CreateNestedTestArray(childArray, depth - 1, elementsPerLevel, referenceCounter); } } } ================================================ FILE: neo-vm.sln ================================================ Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 VisualStudioVersion = 17.2.32505.173 MinimumVisualStudioVersion = 10.0.40219.1 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{0F08E36C-9F18-423D-8F8C-C8C2FACF00F7}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.VM", "src\Neo.VM\Neo.VM.csproj", "{6A621185-36A9-4E1A-8D3D-462D19503E32}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{210DA31B-019E-48CE-9498-D56A7987C4E6}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.VM.Tests", "tests\Neo.VM.Tests\Neo.VM.Tests.csproj", "{56063C9E-49B3-4CE2-96C5-E5F7ECACC5FC}" EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "benchmarks", "benchmarks", "{68EA7507-C4D7-4BF1-9552-D6ACDC00C209}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Neo.VM.Benchmarks", "benchmarks\Neo.VM.Benchmarks\Neo.VM.Benchmarks.csproj", "{1F7EE0A2-3803-478E-B4FE-EB62F076767B}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Release|Any CPU = Release|Any CPU EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {6A621185-36A9-4E1A-8D3D-462D19503E32}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {6A621185-36A9-4E1A-8D3D-462D19503E32}.Debug|Any CPU.Build.0 = Debug|Any CPU {6A621185-36A9-4E1A-8D3D-462D19503E32}.Release|Any CPU.ActiveCfg = Release|Any CPU {6A621185-36A9-4E1A-8D3D-462D19503E32}.Release|Any CPU.Build.0 = Release|Any CPU {56063C9E-49B3-4CE2-96C5-E5F7ECACC5FC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {56063C9E-49B3-4CE2-96C5-E5F7ECACC5FC}.Debug|Any CPU.Build.0 = Debug|Any CPU {56063C9E-49B3-4CE2-96C5-E5F7ECACC5FC}.Release|Any CPU.ActiveCfg = Release|Any CPU {56063C9E-49B3-4CE2-96C5-E5F7ECACC5FC}.Release|Any CPU.Build.0 = Release|Any CPU {1F7EE0A2-3803-478E-B4FE-EB62F076767B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {1F7EE0A2-3803-478E-B4FE-EB62F076767B}.Debug|Any CPU.Build.0 = Debug|Any CPU {1F7EE0A2-3803-478E-B4FE-EB62F076767B}.Release|Any CPU.ActiveCfg = Release|Any CPU {1F7EE0A2-3803-478E-B4FE-EB62F076767B}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(NestedProjects) = preSolution {6A621185-36A9-4E1A-8D3D-462D19503E32} = {0F08E36C-9F18-423D-8F8C-C8C2FACF00F7} {56063C9E-49B3-4CE2-96C5-E5F7ECACC5FC} = {210DA31B-019E-48CE-9498-D56A7987C4E6} {1F7EE0A2-3803-478E-B4FE-EB62F076767B} = {68EA7507-C4D7-4BF1-9552-D6ACDC00C209} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {F8AC7AA8-85DE-4A98-9B58-BA08AB813C99} EndGlobalSection EndGlobal ================================================ FILE: src/Neo.VM/BadScriptException.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // BadScriptException.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; namespace Neo.VM; /// /// Represents the exception thrown when the bad script is parsed. /// public class BadScriptException : Exception { /// /// Initializes a new instance of the class. /// public BadScriptException() { } /// /// Initializes a new instance of the class with a specified error message. /// /// The message that describes the error. public BadScriptException(string message) : base(message) { } } ================================================ FILE: src/Neo.VM/CatchableException.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // CatchableException.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; namespace Neo.VM; public class CatchableException : Exception { public CatchableException(string message) : base(message) { } } ================================================ FILE: src/Neo.VM/Collections/OrderedDictionary.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // OrderedDictionary.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. #if !NET5_0_OR_GREATER using System.Collections; using System.Collections.Generic; using System.Collections.ObjectModel; using System.Diagnostics.CodeAnalysis; using System.Linq; namespace Neo.VM.Collections; class OrderedDictionary : IDictionary where TKey : notnull { private class TItem { public readonly TKey Key; public TValue Value; public TItem(TKey key, TValue value) { Key = key; Value = value; } } private class InternalCollection : KeyedCollection { protected override TKey GetKeyForItem(TItem item) { return item.Key; } } private readonly InternalCollection collection = new(); public int Count => collection.Count; public bool IsReadOnly => false; public ICollection Keys => collection.Select(p => p.Key).ToArray(); public ICollection Values => collection.Select(p => p.Value).ToArray(); public TValue this[TKey key] { get { return collection[key].Value; } set { if (collection.TryGetValue(key, out var entry)) entry.Value = value; else Add(key, value); } } public void Add(TKey key, TValue value) { collection.Add(new TItem(key, value)); } public bool ContainsKey(TKey key) { return collection.Contains(key); } public bool Remove(TKey key) { return collection.Remove(key); } public bool TryGetValue(TKey key, out TValue value) { if (collection.TryGetValue(key, out var entry)) { value = entry.Value; return true; } value = default!; return false; } void ICollection>.Add(KeyValuePair item) { Add(item.Key, item.Value); } public void Clear() { collection.Clear(); } bool ICollection>.Contains(KeyValuePair item) { return collection.Contains(item.Key); } void ICollection>.CopyTo(KeyValuePair[] array, int arrayIndex) { for (int i = 0; i < collection.Count; i++) array[i + arrayIndex] = new KeyValuePair(collection[i].Key, collection[i].Value); } bool ICollection>.Remove(KeyValuePair item) { return collection.Remove(item.Key); } IEnumerator> IEnumerable>.GetEnumerator() { return collection.Select(p => new KeyValuePair(p.Key, p.Value)).GetEnumerator(); } IEnumerator IEnumerable.GetEnumerator() { return collection.Select(p => new KeyValuePair(p.Key, p.Value)).GetEnumerator(); } } #endif ================================================ FILE: src/Neo.VM/Debugger.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Debugger.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System.Collections.Generic; namespace Neo.VM; /// /// A simple debugger for . /// public class Debugger { private readonly ExecutionEngine _engine; private readonly Dictionary> _breakPoints = new(); /// /// Create a debugger on the specified . /// /// The to attach the debugger. public Debugger(ExecutionEngine engine) { _engine = engine; } /// /// Add a breakpoint at the specified position of the specified script. /// The VM will break the execution when it reaches the breakpoint. /// /// The script to add the breakpoint. /// The position of the breakpoint in the script. public void AddBreakPoint(Script script, uint position) { if (!_breakPoints.TryGetValue(script, out var hashset)) { hashset = new HashSet(); _breakPoints.Add(script, hashset); } hashset.Add(position); } /// /// Start or continue execution of the VM. /// /// Returns the state of the VM after the execution. public VMState Execute() { if (_engine.State == VMState.BREAK) _engine.State = VMState.NONE; while (_engine.State == VMState.NONE) ExecuteAndCheckBreakPoints(); return _engine.State; } private void ExecuteAndCheckBreakPoints() { _engine.ExecuteNext(); if (_engine.State == VMState.NONE && _engine.InvocationStack.Count > 0 && _breakPoints.Count > 0) { if (_breakPoints.TryGetValue(_engine.CurrentContext!.Script, out var hashset) && hashset.Contains((uint)_engine.CurrentContext.InstructionPointer)) { _engine.State = VMState.BREAK; } } } /// /// Removes the breakpoint at the specified position in the specified script. /// /// The script to remove the breakpoint. /// The position of the breakpoint in the script. /// /// if the breakpoint is successfully found and removed; /// otherwise, . /// public bool RemoveBreakPoint(Script script, uint position) { if (!_breakPoints.TryGetValue(script, out var hashset)) return false; if (!hashset.Remove(position)) return false; if (hashset.Count == 0) _breakPoints.Remove(script); return true; } /// /// Execute the next instruction. /// If the instruction involves a call to a method, /// it steps into the method and breaks the execution on the first instruction of that method. /// /// The VM state after the instruction is executed. public VMState StepInto() { if (_engine.State == VMState.HALT || _engine.State == VMState.FAULT) return _engine.State; _engine.ExecuteNext(); if (_engine.State == VMState.NONE) _engine.State = VMState.BREAK; return _engine.State; } /// /// Execute until the currently executed method is returned. /// /// The VM state after the currently executed method is returned. public VMState StepOut() { if (_engine.State == VMState.BREAK) _engine.State = VMState.NONE; int c = _engine.InvocationStack.Count; while (_engine.State == VMState.NONE && _engine.InvocationStack.Count >= c) ExecuteAndCheckBreakPoints(); if (_engine.State == VMState.NONE) _engine.State = VMState.BREAK; return _engine.State; } /// /// Execute the next instruction. /// If the instruction involves a call to a method, it does not step into the method (it steps over it instead). /// /// The VM state after the instruction is executed. public VMState StepOver() { if (_engine.State == VMState.HALT || _engine.State == VMState.FAULT) return _engine.State; _engine.State = VMState.NONE; int c = _engine.InvocationStack.Count; do { ExecuteAndCheckBreakPoints(); } while (_engine.State == VMState.NONE && _engine.InvocationStack.Count > c); if (_engine.State == VMState.NONE) _engine.State = VMState.BREAK; return _engine.State; } } ================================================ FILE: src/Neo.VM/EvaluationStack.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // EvaluationStack.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; using System; using System.Collections; using System.Collections.Generic; using System.Linq; using System.Runtime.CompilerServices; namespace Neo.VM; /// /// Represents the evaluation stack in the VM. /// public sealed class EvaluationStack : IReadOnlyList { private readonly List _innerList = []; private readonly IReferenceCounter _referenceCounter; internal IReferenceCounter ReferenceCounter => _referenceCounter; internal EvaluationStack(IReferenceCounter referenceCounter) { _referenceCounter = referenceCounter; } public StackItem this[int index] { get => Peek(index); } public IReadOnlyList this[Range range] { get { var start = range.Start.GetOffset(_innerList.Count); var end = range.End.GetOffset(_innerList.Count); if (start > end) throw new ArgumentOutOfRangeException(nameof(range), "Range start must be less than or equal to end."); List copyList = new(_innerList); copyList.Reverse(); return copyList.GetRange(start, end - start); } } /// /// Gets the number of items on the stack. /// public int Count => _innerList.Count; internal void Clear() { foreach (var item in _innerList) _referenceCounter.RemoveStackReference(item); _innerList.Clear(); } internal void CopyTo(EvaluationStack stack, int count = -1) { if (count < -1 || count > _innerList.Count) throw new ArgumentOutOfRangeException(nameof(count), $"Out of stack bounds: {count}/{_innerList.Count}"); if (count == 0) return; if (count == -1 || count == _innerList.Count) stack._innerList.AddRange(_innerList); else stack._innerList.AddRange(_innerList.Skip(_innerList.Count - count)); } public IEnumerator GetEnumerator() { return _innerList.GetEnumerator(); } IEnumerator IEnumerable.GetEnumerator() { return _innerList.GetEnumerator(); } [MethodImpl(MethodImplOptions.AggressiveInlining)] internal void Insert(int index, StackItem item) { if (index > _innerList.Count) throw new InvalidOperationException($"Insert index is out of stack bounds: {index}/{_innerList.Count}"); _innerList.Insert(_innerList.Count - index, item); _referenceCounter.AddStackReference(item); } internal void MoveTo(EvaluationStack stack, int count = -1) { if (count == 0) return; CopyTo(stack, count); if (count == -1 || count == _innerList.Count) _innerList.Clear(); else _innerList.RemoveRange(_innerList.Count - count, count); } /// /// Returns the item at the specified index from the top of the stack without removing it. /// /// The index of the object from the top of the stack. /// The item at the specified index. [MethodImpl(MethodImplOptions.AggressiveInlining)] public StackItem Peek(int index = 0) { if (index >= _innerList.Count) throw new InvalidOperationException($"Peek index is out of stack bounds: {index}/{_innerList.Count}"); if (index < 0) { index += _innerList.Count; if (index < 0) throw new InvalidOperationException($"Peek index is out of stack bounds: {index}/{_innerList.Count}"); } return _innerList[_innerList.Count - index - 1]; } /// /// Pushes an item onto the top of the stack. /// /// The item to be pushed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public void Push(StackItem item) { _innerList.Add(item); _referenceCounter.AddStackReference(item); } [MethodImpl(MethodImplOptions.AggressiveInlining)] internal void Reverse(int n) { if (n < 0 || n > _innerList.Count) throw new ArgumentOutOfRangeException(nameof(n), $"Out of stack bounds: {n}/{_innerList.Count}"); if (n <= 1) return; _innerList.Reverse(_innerList.Count - n, n); } /// /// Swaps two items on the stack by their indices from the top. /// This is an O(1) operation that doesn't trigger reference counting changes. /// Note: The caller must ensure indices are within bounds and non-negative. /// /// First index from top of stack. /// Second index from top of stack. [MethodImpl(MethodImplOptions.AggressiveInlining)] internal void Swap(int index1, int index2) { if (index1 == index2) return; int actualIndex1 = _innerList.Count - index1 - 1; int actualIndex2 = _innerList.Count - index2 - 1; // Direct swap - no reference counting needed since items stay on stack (_innerList[actualIndex1], _innerList[actualIndex2]) = (_innerList[actualIndex2], _innerList[actualIndex1]); } /// /// Removes and returns the item at the top of the stack. /// /// The item removed from the top of the stack. [MethodImpl(MethodImplOptions.AggressiveInlining)] public StackItem Pop() { return Remove(0); } /// /// Removes and returns the item at the top of the stack and convert it to the specified type. /// /// The type to convert to. /// The item removed from the top of the stack. [MethodImpl(MethodImplOptions.AggressiveInlining)] public T Pop() where T : StackItem { return Remove(0); } internal T Remove(int index) where T : StackItem { if (index >= _innerList.Count) throw new ArgumentOutOfRangeException(nameof(index), $"Out of stack bounds: {index}/{_innerList.Count}"); if (index < 0) { index += _innerList.Count; if (index < 0) throw new ArgumentOutOfRangeException(nameof(index), $"Out of stack bounds: {index}/{_innerList.Count}"); } index = _innerList.Count - index - 1; if (_innerList[index] is not T item) throw new InvalidCastException($"The item can't be casted to type {typeof(T)}"); _innerList.RemoveAt(index); _referenceCounter.RemoveStackReference(item); return item; } public override string ToString() { return $"[{string.Join(", ", _innerList.Select(p => $"{p.Type}({p})"))}]"; } } ================================================ FILE: src/Neo.VM/ExceptionHandlingContext.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // ExceptionHandlingContext.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System.Diagnostics; namespace Neo.VM; /// /// Represents the context used for exception handling. /// [DebuggerDisplay("State={State}, CatchPointer={CatchPointer}, FinallyPointer={FinallyPointer}, EndPointer={EndPointer}")] public sealed class ExceptionHandlingContext { /// /// The position of the block. /// public int CatchPointer { get; } /// /// The position of the block. /// public int FinallyPointer { get; } /// /// The end position of the -- block. /// public int EndPointer { get; internal set; } = -1; /// /// Indicates whether the block is included in the context. /// public bool HasCatch => CatchPointer >= 0; /// /// Indicates whether the block is included in the context. /// public bool HasFinally => FinallyPointer >= 0; /// /// Indicates the state of the context. /// public ExceptionHandlingState State { get; internal set; } = ExceptionHandlingState.Try; internal ExceptionHandlingContext(int catchPointer, int finallyPointer) { CatchPointer = catchPointer; FinallyPointer = finallyPointer; } } ================================================ FILE: src/Neo.VM/ExceptionHandlingState.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // ExceptionHandlingState.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. namespace Neo.VM; /// /// Indicates the state of the . /// public enum ExceptionHandlingState : byte { /// /// Indicates that the block is being executed. /// Try, /// /// Indicates that the block is being executed. /// Catch, /// /// Indicates that the block is being executed. /// Finally } ================================================ FILE: src/Neo.VM/ExecutionContext.SharedStates.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // ExecutionContext.SharedStates.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Collections.Generic; namespace Neo.VM; partial class ExecutionContext { private class SharedStates { public readonly Script Script; public readonly EvaluationStack EvaluationStack; public Slot? StaticFields; public readonly Dictionary States; public SharedStates(Script script, IReferenceCounter referenceCounter) { Script = script; EvaluationStack = new(referenceCounter); States = new(); } } } ================================================ FILE: src/Neo.VM/ExecutionContext.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // ExecutionContext.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Collections.Generic; using System.Diagnostics; using System.Runtime.CompilerServices; namespace Neo.VM; /// /// Represents a frame in the VM execution stack. /// [DebuggerDisplay("InstructionPointer={InstructionPointer}")] public sealed partial class ExecutionContext { private readonly SharedStates _sharedStates; private int _instructionPointer; /// /// Indicates the number of values that the context should return when it is unloaded. /// public int RVCount { get; } /// /// The script to run in this context. /// public Script Script => _sharedStates.Script; /// /// The evaluation stack for this context. /// public EvaluationStack EvaluationStack => _sharedStates.EvaluationStack; /// /// The slot used to store the static fields. /// public Slot? StaticFields { get => _sharedStates.StaticFields; internal set => _sharedStates.StaticFields = value; } /// /// The slot used to store the local variables of the current method. /// public Slot? LocalVariables { get; internal set; } /// /// The slot used to store the arguments of the current method. /// public Slot? Arguments { get; internal set; } /// /// The stack containing nested . /// public Stack? TryStack { get; internal set; } /// /// The pointer indicating the current instruction. /// public int InstructionPointer { get { return _instructionPointer; } internal set { if (value < 0 || value > Script.Length) throw new ArgumentOutOfRangeException(nameof(value), $"Out of script bounds: {value}/{Script.Length}"); _instructionPointer = value; } } /// /// Returns the current . /// public Instruction? CurrentInstruction { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return GetInstruction(InstructionPointer); } } /// /// Returns the next . /// public Instruction? NextInstruction { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { var current = CurrentInstruction; if (current is null) return null; return GetInstruction(InstructionPointer + current.Size); } } internal ExecutionContext(Script script, int rvcount, IReferenceCounter referenceCounter) : this(new SharedStates(script, referenceCounter), rvcount, 0) { } private ExecutionContext(SharedStates sharedStates, int rvcount, int initialPosition) { if (rvcount < -1 || rvcount > ushort.MaxValue) throw new ArgumentOutOfRangeException(nameof(rvcount), $"Out of range: {rvcount}"); _sharedStates = sharedStates; RVCount = rvcount; InstructionPointer = initialPosition; } /// /// Clones the context so that they share the same script, stack, and static fields. /// /// The cloned context. public ExecutionContext Clone() { return Clone(InstructionPointer); } /// /// Clones the context so that they share the same script, stack, and static fields. /// /// The instruction pointer of the new context. /// The cloned context. public ExecutionContext Clone(int initialPosition) { return new ExecutionContext(_sharedStates, 0, initialPosition); } [MethodImpl(MethodImplOptions.AggressiveInlining)] private Instruction? GetInstruction(int ip) => ip >= Script.Length ? null : Script.GetInstruction(ip); /// /// Gets custom data of the specified type. If the data does not exist, create a new one. /// /// The type of data to be obtained. /// A delegate used to create the entry. If factory is null, new() will be used. /// The custom data of the specified type. public T GetState(Func? factory = null) where T : class, new() { if (!_sharedStates.States.TryGetValue(typeof(T), out var value)) { value = factory is null ? new T() : factory(); _sharedStates.States[typeof(T)] = value; } return (T)value; } internal bool MoveNext() { var current = CurrentInstruction; if (current is null) return false; InstructionPointer += current.Size; return InstructionPointer < Script.Length; } } ================================================ FILE: src/Neo.VM/ExecutionEngine.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // ExecutionEngine.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; using System; using System.Collections.Generic; using System.Runtime.CompilerServices; namespace Neo.VM; /// /// Represents the VM used to execute the script. /// public class ExecutionEngine : IDisposable { private VMState _state = VMState.BREAK; internal bool isJumping = false; public JumpTable JumpTable { get; } /// /// Restrictions on the VM. /// public ExecutionEngineLimits Limits { get; } /// /// Used for reference counting of objects in the VM. /// public IReferenceCounter ReferenceCounter { get; } /// /// The invocation stack of the VM. /// public Stack InvocationStack { get; } = new(); /// /// The top frame of the invocation stack. /// public ExecutionContext? CurrentContext { get; private set; } /// /// The bottom frame of the invocation stack. /// public ExecutionContext? EntryContext { get; private set; } /// /// The stack to store the return values. /// public EvaluationStack ResultStack { get; } /// /// The VM object representing the uncaught exception. /// public StackItem? UncaughtException { get; internal set; } /// /// The current state of the VM. /// public VMState State { get { return _state; } protected internal set { if (_state != value) { _state = value; OnStateChanged(); } } } /// /// Initializes a new instance of the class. /// /// The jump table to be used. public ExecutionEngine(JumpTable? jumpTable = null) : this(jumpTable, new ReferenceCounterV2(), ExecutionEngineLimits.Default) { } /// /// Initializes a new instance of the class /// with the specified and . /// /// The jump table to be used. /// The reference counter to be used. /// Restrictions on the VM. internal ExecutionEngine(JumpTable? jumpTable, IReferenceCounter referenceCounter, ExecutionEngineLimits limits) { JumpTable = jumpTable ?? JumpTable.Default; Limits = limits; ReferenceCounter = referenceCounter; ResultStack = new(referenceCounter); } public void Dispose() { Dispose(true); GC.SuppressFinalize(this); } protected virtual void Dispose(bool disposing) { if (disposing) { InvocationStack.Clear(); } } /// /// Start execution of the VM. /// /// public virtual VMState Execute() { if (State == VMState.BREAK) State = VMState.NONE; while (State != VMState.HALT && State != VMState.FAULT) ExecuteNext(); return State; } /// /// Execute the next instruction. /// protected internal void ExecuteNext() { if (InvocationStack.Count == 0) { State = VMState.HALT; } else { try { ExecutionContext context = CurrentContext!; Instruction? currentInstruction = context.CurrentInstruction; Instruction instruction = currentInstruction ?? Instruction.RET; PreExecuteInstruction(instruction); #if VMPERF Console.WriteLine("op:[" + this.CurrentContext.InstructionPointer.ToString("X04") + "]" + this.CurrentContext.CurrentInstruction?.OpCode + " " + this.CurrentContext.EvaluationStack); #endif try { JumpTable[instruction.OpCode](this, instruction); } catch (CatchableException ex) when (Limits.CatchEngineExceptions) { JumpTable.ExecuteThrow(this, ex.Message); } PostExecuteInstruction(instruction); if (!isJumping && currentInstruction != null) context.InstructionPointer += instruction.Size; isJumping = false; } catch (Exception e) { OnFault(e); } } } /// /// Loads the specified context into the invocation stack. /// /// The context to load. public virtual void LoadContext(ExecutionContext context) { if (InvocationStack.Count >= Limits.MaxInvocationStackSize) throw new InvalidOperationException($"MaxInvocationStackSize exceed: {InvocationStack.Count}"); InvocationStack.Push(context); EntryContext ??= context; CurrentContext = context; } /// /// Called when a context is unloaded. /// /// The context being unloaded. internal protected virtual void ContextUnloaded(ExecutionContext context) { if (InvocationStack.Count == 0) { CurrentContext = null; EntryContext = null; } else { CurrentContext = InvocationStack.Peek(); } if (context.StaticFields != null && context.StaticFields != CurrentContext?.StaticFields) { context.StaticFields.ClearReferences(); } context.LocalVariables?.ClearReferences(); context.Arguments?.ClearReferences(); } /// /// Create a new context with the specified script without loading. /// /// The script used to create the context. /// The number of values that the context should return when it is unloaded. /// The pointer indicating the current instruction. /// The created context. [MethodImpl(MethodImplOptions.AggressiveInlining)] protected ExecutionContext CreateContext(Script script, int rvcount, int initialPosition) { return new ExecutionContext(script, rvcount, ReferenceCounter) { InstructionPointer = initialPosition }; } /// /// Create a new context with the specified script and load it. /// /// The script used to create the context. /// The number of values that the context should return when it is unloaded. /// The pointer indicating the current instruction. /// The created context. public ExecutionContext LoadScript(Script script, int rvcount = -1, int initialPosition = 0) { var context = CreateContext(script, rvcount, initialPosition); LoadContext(context); return context; } /// /// Called when an exception that cannot be caught by the VM is thrown. /// /// The exception that caused the state. protected virtual void OnFault(Exception ex) { State = VMState.FAULT; #if VMPERF if (ex != null) { Console.Error.WriteLine(ex); } #endif } /// /// Called when the state of the VM changed. /// protected virtual void OnStateChanged() { } /// /// Returns the item at the specified index from the top of the current stack without removing it. /// /// The index of the object from the top of the stack. /// The item at the specified index. [MethodImpl(MethodImplOptions.AggressiveInlining)] public StackItem Peek(int index = 0) { return CurrentContext!.EvaluationStack.Peek(index); } /// /// Removes and returns the item at the top of the current stack. /// /// The item removed from the top of the stack. [MethodImpl(MethodImplOptions.AggressiveInlining)] public StackItem Pop() { return CurrentContext!.EvaluationStack.Pop(); } /// /// Removes and returns the item at the top of the current stack and convert it to the specified type. /// /// The type to convert to. /// The item removed from the top of the stack. [MethodImpl(MethodImplOptions.AggressiveInlining)] public T Pop() where T : StackItem { return CurrentContext!.EvaluationStack.Pop(); } /// /// Called after an instruction is executed. /// protected virtual void PostExecuteInstruction(Instruction instruction) { ReferenceCounter.CheckPostExecution(); } /// /// Called before an instruction is executed. /// protected virtual void PreExecuteInstruction(Instruction instruction) { } /// /// Pushes an item onto the top of the current stack. /// /// The item to be pushed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public void Push(StackItem item) { CurrentContext!.EvaluationStack.Push(item); } } ================================================ FILE: src/Neo.VM/ExecutionEngineLimits.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // ExecutionEngineLimits.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Runtime.CompilerServices; namespace Neo.VM; /// /// Represents the restrictions on the VM. /// public sealed record ExecutionEngineLimits { /// /// The default strategy. /// public static readonly ExecutionEngineLimits Default = new(); /// /// The maximum number of bits that and can shift. /// public int MaxShift { get; init; } = 256; /// /// The maximum number of items that can be contained in the VM's evaluation stacks and slots. /// public uint MaxStackSize { get; init; } = 2 * 1024; /// /// The maximum size of an item in the VM. /// public uint MaxItemSize { get; init; } = ushort.MaxValue * 2; /// /// The largest comparable size. /// If a or exceeds this size, /// comparison operations on it cannot be performed in the VM. /// public uint MaxComparableSize { get; init; } = 65536; /// /// The maximum number of frames in the invocation stack of the VM. /// public uint MaxInvocationStackSize { get; init; } = 1024; /// /// The maximum nesting depth of -- blocks. /// public uint MaxTryNestingDepth { get; init; } = 16; /// /// Allow to catch the ExecutionEngine Exceptions /// public bool CatchEngineExceptions { get; init; } = true; /// /// Assert that the size of the item meets the limit. /// /// The size to be checked. [MethodImpl(MethodImplOptions.AggressiveInlining)] public void AssertMaxItemSize(int size) { if (size < 0 || size > MaxItemSize) { throw new InvalidOperationException($"MaxItemSize exceed: {size}/{MaxItemSize}"); } } /// /// Assert that the number of bits shifted meets the limit. /// /// The number of bits shifted. [MethodImpl(MethodImplOptions.AggressiveInlining)] public void AssertShift(int shift) { if (shift > MaxShift || shift < 0) { throw new InvalidOperationException($"Invalid shift value: {shift}/{MaxShift}"); } } } ================================================ FILE: src/Neo.VM/IReferenceCounter.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // IReferenceCounter.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; namespace Neo.VM; /// /// Used for reference counting of objects in the VM. /// public interface IReferenceCounter { /// /// Reference Counter version /// RCVersion Version { get; } /// /// Gets the count of references. /// int Count { get; } /// /// Adds an item to the zero-referred list. /// /// This method is used when an item has no remaining references. /// It adds the item to the zero-referred list to be checked for cleanup later. /// /// Use this method when you detect that an item has zero references and may need to be cleaned up. /// /// The item to add. void AddZeroReferred(StackItem item); /// /// Adds a reference to a specified item with a parent compound type. /// /// This method is used when an item gains a new reference through a parent compound type. /// It increments the reference count and updates the tracking structures if necessary. /// /// Use this method when you need to add a reference from a compound type to a stack item. /// /// The item to add a reference to. /// The parent compound type. void AddReference(StackItem item, CompoundType parent); /// /// Adds a stack reference to a specified item with a count. /// /// This method is used when an item gains a new stack reference, usually due to being pushed onto the evaluation stack. /// It increments the reference count and updates the tracking structures if necessary. /// /// Use this method when you need to add one or more stack references to a stack item. /// /// The item to add a stack reference to. /// The number of references to add. void AddStackReference(StackItem item, int count = 1); /// /// Removes a reference from a specified item with a parent compound type. /// /// This method is used when an item loses a reference from a parent compound type. /// It decrements the reference count and updates the tracking structures if necessary. /// /// Use this method when you need to remove a reference from a compound type to a stack item. /// /// The item to remove a reference from. /// The parent compound type. void RemoveReference(StackItem item, CompoundType parent); /// /// Removes a stack reference from a specified item. /// /// This method is used when an item loses a stack reference, usually due to being popped off the evaluation stack. /// It decrements the reference count and updates the tracking structures if necessary. /// /// Use this method when you need to remove one or more stack references from a stack item. /// /// The item to remove a stack reference from. void RemoveStackReference(StackItem item); /// /// Checks and processes items that have zero references. /// This method is used to check items in the zero-referred list and clean up those that are no longer needed. /// /// The current reference count. int CheckZeroReferred(); /// /// Validate reference counters after execution and throw if limits are violated. /// void CheckPostExecution(); } ================================================ FILE: src/Neo.VM/Instruction.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Instruction.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Buffers.Binary; using System.Diagnostics; using System.Reflection; using System.Runtime.CompilerServices; using System.Text; namespace Neo.VM; /// /// Represents instructions in the VM script. /// [DebuggerDisplay("OpCode={OpCode}")] public class Instruction { /// /// Represents the instruction with . /// public static Instruction RET { get; } = new Instruction(OpCode.RET); /// /// The of the instruction. /// public readonly OpCode OpCode; /// /// The operand of the instruction. /// public readonly ReadOnlyMemory Operand; private static readonly int[] OperandSizePrefixTable = new int[256]; private static readonly int[] OperandSizeTable = new int[256]; /// /// Gets the size of the instruction. /// public int Size { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { var prefixSize = OperandSizePrefixTable[(byte)OpCode]; return prefixSize > 0 ? 1 + prefixSize + Operand.Length : 1 + OperandSizeTable[(byte)OpCode]; } } /// /// Gets the first operand as . /// public short TokenI16 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return BinaryPrimitives.ReadInt16LittleEndian(Operand.Span); } } /// /// Gets the first operand as . /// public int TokenI32 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return BinaryPrimitives.ReadInt32LittleEndian(Operand.Span); } } /// /// Gets the second operand as . /// public int TokenI32_1 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return BinaryPrimitives.ReadInt32LittleEndian(Operand.Span[4..]); } } /// /// Gets the first operand as . /// public sbyte TokenI8 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return (sbyte)Operand.Span[0]; } } /// /// Gets the second operand as . /// public sbyte TokenI8_1 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return (sbyte)Operand.Span[1]; } } /// /// Gets the operand as . /// public string TokenString { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return Encoding.ASCII.GetString(Operand.Span); } } /// /// Gets the first operand as . /// public ushort TokenU16 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return BinaryPrimitives.ReadUInt16LittleEndian(Operand.Span); } } /// /// Gets the first operand as . /// public uint TokenU32 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return BinaryPrimitives.ReadUInt32LittleEndian(Operand.Span); } } /// /// Gets the first operand as . /// public byte TokenU8 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return Operand.Span[0]; } } /// /// Gets the second operand as . /// public byte TokenU8_1 { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return Operand.Span[1]; } } static Instruction() { foreach (FieldInfo field in typeof(OpCode).GetFields(BindingFlags.Public | BindingFlags.Static)) { var attribute = field.GetCustomAttribute(); if (attribute == null) continue; var index = (byte)(OpCode)field.GetValue(null)!; OperandSizePrefixTable[index] = attribute.SizePrefix; OperandSizeTable[index] = attribute.Size; } } private Instruction(OpCode opcode) { OpCode = opcode; #if NET5_0_OR_GREATER if (!Enum.IsDefined(opcode)) throw new BadScriptException(); #else if (!Enum.IsDefined(typeof(OpCode), opcode)) throw new BadScriptException(); #endif } internal Instruction(ReadOnlyMemory script, int ip) : this((OpCode)script.Span[ip++]) { var span = script.Span; var operandSizePrefix = OperandSizePrefixTable[(byte)OpCode]; var operandSize = 0; switch (operandSizePrefix) { case 0: operandSize = OperandSizeTable[(byte)OpCode]; break; case 1: if (ip >= span.Length) throw new BadScriptException($"Instruction out of bounds. InstructionPointer: {ip}"); operandSize = span[ip]; break; case 2: if (ip + 1 >= span.Length) throw new BadScriptException($"Instruction out of bounds. InstructionPointer: {ip}"); operandSize = BinaryPrimitives.ReadUInt16LittleEndian(span[ip..]); break; case 4: if (ip + 3 >= span.Length) throw new BadScriptException($"Instruction out of bounds. InstructionPointer: {ip}"); operandSize = BinaryPrimitives.ReadInt32LittleEndian(span[ip..]); if (operandSize < 0) throw new BadScriptException($"Instruction out of bounds. InstructionPointer: {ip}, operandSize: {operandSize}"); break; } ip += operandSizePrefix; if (operandSize > 0) { if (ip + operandSize > script.Length) throw new BadScriptException($"Instrucion out of bounds. InstructionPointer: {ip}, operandSize: {operandSize}, length: {script.Length}"); Operand = script.Slice(ip, operandSize); } } } ================================================ FILE: src/Neo.VM/IsExternalInit.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // IsExternalInit.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. #if !NET5_0_OR_GREATER #pragma warning disable IDE0130 using System.ComponentModel; namespace System.Runtime.CompilerServices; /// /// Reserved to be used by the compiler for tracking metadata. /// This class should not be used by developers in source code. /// [EditorBrowsable(EditorBrowsableState.Never)] internal static class IsExternalInit { } #endif ================================================ FILE: src/Neo.VM/JumpTable/JumpTable.Bitwisee.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // JumpTable.Bitwisee.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System.Runtime.CompilerServices; namespace Neo.VM; partial class JumpTable { /// /// Flips all of the bits of an integer. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Invert(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop().GetInteger(); engine.Push(~x); } /// /// Computes the bitwise AND of two integers. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void And(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); engine.Push(x1 & x2); } /// /// Computes the bitwise OR of two integers. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Or(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); engine.Push(x1 | x2); } /// /// Computes the bitwise XOR (exclusive OR) of two integers. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void XOr(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); engine.Push(x1 ^ x2); } /// /// Determines whether two objects are equal according to the execution engine's comparison rules. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Equal(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop(); var x1 = engine.Pop(); engine.Push(x1.Equals(x2, engine.Limits)); } /// /// Determines whether two objects are not equal according to the execution engine's comparison rules. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void NotEqual(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop(); var x1 = engine.Pop(); engine.Push(!x1.Equals(x2, engine.Limits)); } } ================================================ FILE: src/Neo.VM/JumpTable/JumpTable.Compound.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // JumpTable.Compound.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; using System; using System.Linq; using System.Numerics; using System.Runtime.CompilerServices; using Array = System.Array; using Buffer = Neo.VM.Types.Buffer; using VMArray = Neo.VM.Types.Array; namespace Neo.VM; partial class JumpTable { /// /// Packs a map from the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2n+1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PackMap(ExecutionEngine engine, Instruction instruction) { var size = (int)engine.Pop().GetInteger(); if (size < 0 || size * 2 > engine.CurrentContext!.EvaluationStack.Count) throw new InvalidOperationException($"The map size is out of valid range, 2*{size}/[0, {engine.CurrentContext!.EvaluationStack.Count}]."); Map map = new(engine.ReferenceCounter); for (var i = 0; i < size; i++) { var key = engine.Pop(); var value = engine.Pop(); map[key] = value; } engine.Push(map); } /// /// Packs a struct from the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop n+1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PackStruct(ExecutionEngine engine, Instruction instruction) { var size = (int)engine.Pop().GetInteger(); if (size < 0 || size > engine.CurrentContext!.EvaluationStack.Count) throw new InvalidOperationException($"The struct size is out of valid range, {size}/[0, {engine.CurrentContext!.EvaluationStack.Count}]."); Struct @struct = new(engine.ReferenceCounter); for (var i = 0; i < size; i++) { var item = engine.Pop(); @struct.Add(item); } engine.Push(@struct); } /// /// Packs an array from the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop n+1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Pack(ExecutionEngine engine, Instruction instruction) { var size = (int)engine.Pop().GetInteger(); if (size < 0 || size > engine.CurrentContext!.EvaluationStack.Count) throw new InvalidOperationException($"The array size is out of valid range, {size}/[0, {engine.CurrentContext!.EvaluationStack.Count}]."); VMArray array = new(engine.ReferenceCounter); for (var i = 0; i < size; i++) { var item = engine.Pop(); array.Add(item); } engine.Push(array); } /// /// Unpacks a compound type from the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 2n+1 or n+1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Unpack(ExecutionEngine engine, Instruction instruction) { var compound = engine.Pop(); switch (compound) { case Map map: foreach (var (key, value) in map.Reverse()) { engine.Push(value); engine.Push(key); } break; case VMArray array: for (var i = array.Count - 1; i >= 0; i--) { engine.Push(array[i]); } break; default: throw new InvalidOperationException($"Invalid type for {instruction.OpCode}: {compound.Type}"); } engine.Push(compound.Count); } /// /// Creates a new empty array with zero elements on the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// /// Pop 0, Push 1 /// TODO: Change to NewNullArray method or add it? /// [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void NewArray0(ExecutionEngine engine, Instruction instruction) { engine.Push(new VMArray(engine.ReferenceCounter)); } /// /// Creates a new array with a specified number of elements on the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void NewArray(ExecutionEngine engine, Instruction instruction) { var n = (int)engine.Pop().GetInteger(); if (n < 0 || n > engine.Limits.MaxStackSize) throw new InvalidOperationException($"The array size is out of valid range, {n}/[0, {engine.Limits.MaxStackSize}]."); var nullArray = new StackItem[n]; Array.Fill(nullArray, StackItem.Null); engine.Push(new VMArray(engine.ReferenceCounter, nullArray)); } /// /// Creates a new array with a specified number of elements and a specified type on the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void NewArray_T(ExecutionEngine engine, Instruction instruction) { var n = (int)engine.Pop().GetInteger(); if (n < 0 || n > engine.Limits.MaxStackSize) throw new InvalidOperationException($"The array size is out of valid range, {n}/[0, {engine.Limits.MaxStackSize}]."); var type = (StackItemType)instruction.TokenU8; #if NET5_0_OR_GREATER if (!Enum.IsDefined(type)) #else if (!Enum.IsDefined(typeof(StackItemType), type)) #endif throw new InvalidOperationException($"Invalid type for {instruction.OpCode}: {instruction.TokenU8}"); var item = instruction.TokenU8 switch { (byte)StackItemType.Boolean => StackItem.False, (byte)StackItemType.Integer => Integer.Zero, (byte)StackItemType.ByteString => ByteString.Empty, _ => StackItem.Null }; var itemArray = new StackItem[n]; Array.Fill(itemArray, item); engine.Push(new VMArray(engine.ReferenceCounter, itemArray)); } /// /// Creates a new empty struct with zero elements on the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 0, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void NewStruct0(ExecutionEngine engine, Instruction instruction) { engine.Push(new Struct(engine.ReferenceCounter)); } /// /// Creates a new struct with a specified number of elements on the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void NewStruct(ExecutionEngine engine, Instruction instruction) { var n = (int)engine.Pop().GetInteger(); if (n < 0 || n > engine.Limits.MaxStackSize) throw new InvalidOperationException($"The struct size is out of valid range, {n}/[0, {engine.Limits.MaxStackSize}]."); var nullArray = new StackItem[n]; Array.Fill(nullArray, StackItem.Null); engine.Push(new Struct(engine.ReferenceCounter, nullArray)); } /// /// Creates a new empty map on the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 0, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void NewMap(ExecutionEngine engine, Instruction instruction) { engine.Push(new Map(engine.ReferenceCounter)); } /// /// Gets the size of the top item on the evaluation stack and pushes it onto the stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Size(ExecutionEngine engine, Instruction instruction) { // TODO: we should be able to optimize by using peek instead of dup and pop var x = engine.Pop(); switch (x) { case CompoundType compound: engine.Push(compound.Count); break; case PrimitiveType primitive: engine.Push(primitive.Size); break; case Buffer buffer: engine.Push(buffer.Size); break; default: throw new InvalidOperationException($"Invalid type for {instruction.OpCode}: {x.Type}"); } } /// /// Checks whether the top item on the evaluation stack has the specified key. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void HasKey(ExecutionEngine engine, Instruction instruction) { var key = engine.Pop(); var x = engine.Pop(); // Check the type of the top item and perform the corresponding action. switch (x) { // For arrays, check if the index is within bounds and push the result onto the stack. case VMArray array: { var index = key.GetInteger(); if (index < 0 || index >= engine.Limits.MaxItemSize) throw new InvalidOperationException($"The index {index} is invalid for OpCode {instruction.OpCode}."); engine.Push(index < array.Count); break; } // For maps, check if the key exists and push the result onto the stack. case Map map: { engine.Push(map.ContainsKey(key)); break; } // For buffers, check if the index is within bounds and push the result onto the stack. case Buffer buffer: { var index = key.GetInteger(); if (index < 0 || index >= engine.Limits.MaxItemSize) throw new InvalidOperationException($"The index {index} is invalid for OpCode {instruction.OpCode}."); engine.Push(index < buffer.Size); break; } // For byte strings, check if the index is within bounds and push the result onto the stack. case ByteString array: { var index = key.GetInteger(); if (index < 0 || index >= engine.Limits.MaxItemSize) throw new InvalidOperationException($"The index {index} is invalid for OpCode {instruction.OpCode}."); engine.Push(index < array.Size); break; } default: throw new InvalidOperationException($"Invalid type for {instruction.OpCode}: {x.Type}"); } } /// /// Retrieves the keys of a map and pushes them onto the evaluation stack as an array. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Keys(ExecutionEngine engine, Instruction instruction) { var map = engine.Pop(); engine.Push(new VMArray(engine.ReferenceCounter, map.Keys)); } /// /// Retrieves the values of a compound type and pushes them onto the evaluation stack as an array. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Values(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop(); var values = x switch { VMArray array => array, Map map => map.Values, _ => throw new InvalidOperationException($"Invalid type for {instruction.OpCode}: {x.Type}"), }; VMArray newArray = new(engine.ReferenceCounter); foreach (var item in values) if (item is Struct s) newArray.Add(s.Clone(engine.Limits)); else newArray.Add(item); engine.Push(newArray); } /// /// Retrieves the item from an array, map, buffer, or byte string based on the specified key, /// and pushes it onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PickItem(ExecutionEngine engine, Instruction instruction) { var key = engine.Pop(); var x = engine.Pop(); switch (x) { case VMArray array: { var index = key.GetInteger(); if (index < 0 || index >= array.Count) throw new CatchableException($"The index of {nameof(VMArray)} is out of range, {index}/[0, {array.Count})."); engine.Push(array[(int)index]); break; } case Map map: { if (!map.TryGetValue(key, out var value)) throw new CatchableException($"Key {key} not found in {nameof(Map)}."); engine.Push(value); break; } case PrimitiveType primitive: { var byteArray = primitive.GetSpan(); var index = key.GetInteger(); if (index < 0 || index >= byteArray.Length) throw new CatchableException($"The index of {nameof(PrimitiveType)} is out of range, {index}/[0, {byteArray.Length})."); engine.Push((BigInteger)byteArray[(int)index]); break; } case Buffer buffer: { var index = key.GetInteger(); if (index < 0 || index >= buffer.Size) throw new CatchableException($"The index of {nameof(Buffer)} is out of range, {index}/[0, {buffer.Size})."); engine.Push((BigInteger)buffer.InnerBuffer.Span[(int)index]); break; } default: throw new InvalidOperationException($"Invalid type for {instruction.OpCode}: {x.Type}"); } } /// /// Appends an item to the end of the specified array. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Append(ExecutionEngine engine, Instruction instruction) { var newItem = engine.Pop(); var array = engine.Pop(); if (newItem is Struct s) newItem = s.Clone(engine.Limits); array.Add(newItem); if (engine.ReferenceCounter.Version == RCVersion.V2 && array.IsStackReferenced) engine.ReferenceCounter.AddStackReference(newItem); } /// /// A value v, index n (or key) and an array (or map) are taken from main stack. Attribution array[n]=v (or map[n]=v) is performed. /// /// /// The execution engine. /// The instruction being executed. /// Pop 3, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void SetItem(ExecutionEngine engine, Instruction instruction) { var value = engine.Pop(); if (value is Struct s) value = s.Clone(engine.Limits); var key = engine.Pop(); var x = engine.Pop(); var isRC2 = engine.ReferenceCounter.Version == RCVersion.V2; switch (x) { case VMArray array: { var index = key.GetInteger(); if (index < 0 || index >= array.Count) throw new CatchableException($"The index of {nameof(VMArray)} is out of range, {index}/[0, {array.Count})."); var i = (int)index; if (isRC2 && array.IsStackReferenced) engine.ReferenceCounter.RemoveStackReference(array[i]); array[i] = value; if (isRC2 && array.IsStackReferenced) engine.ReferenceCounter.AddStackReference(value); break; } case Map map: { if (isRC2 && map.IsStackReferenced) { if (!map.TryGetValue(key, out var value1)) { engine.ReferenceCounter.AddStackReference(key); } else { engine.ReferenceCounter.RemoveStackReference(value1); } engine.ReferenceCounter.AddStackReference(value); } map[key] = value; break; } case Buffer buffer: { var index = key.GetInteger(); if (index < 0 || index >= buffer.Size) throw new CatchableException($"The index of {nameof(Buffer)} is out of range, {index}/[0, {buffer.Size})."); if (value is not PrimitiveType p) throw new InvalidOperationException($"Only primitive type values can be set in {nameof(Buffer)} in {instruction.OpCode}."); var b = p.GetInteger(); if (b < sbyte.MinValue || b > byte.MaxValue) throw new InvalidOperationException($"Overflow in {instruction.OpCode}, {b} is not a byte type."); buffer.InnerBuffer.Span[(int)index] = (byte)b; break; } default: throw new InvalidOperationException($"Invalid type for {instruction.OpCode}: {x.Type}"); } } /// /// Reverses the order of items in the specified array or buffer. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void ReverseItems(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop(); switch (x) { case VMArray array: array.Reverse(); break; case Buffer buffer: buffer.InnerBuffer.Span.Reverse(); break; default: throw new InvalidOperationException($"Invalid type for {instruction.OpCode}: {x.Type}"); } } /// /// Removes the item at the specified index from the array or map. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Remove(ExecutionEngine engine, Instruction instruction) { var key = engine.Pop(); var x = engine.Pop(); switch (x) { case VMArray array: var index = key.GetInteger(); if (index < 0 || index >= array.Count) throw new InvalidOperationException($"The index of {nameof(VMArray)} is out of range, {index}/[0, {array.Count})."); var i = (int)index; var item = array[i]; array.RemoveAt(i); if (engine.ReferenceCounter.Version == RCVersion.V2 && array.IsStackReferenced) engine.ReferenceCounter.RemoveStackReference(item); break; case Map map: var old = map.Remove(key); if (old is not null && engine.ReferenceCounter.Version == RCVersion.V2 && map.IsStackReferenced) { engine.ReferenceCounter.RemoveStackReference(key); engine.ReferenceCounter.RemoveStackReference(old); } break; default: throw new InvalidOperationException($"Invalid type for {instruction.OpCode}: {x.Type}"); } } /// /// Clears all items from the compound type. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void ClearItems(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop(); if (engine.ReferenceCounter.Version == RCVersion.V2 && x.IsStackReferenced) { foreach (var xSubItem in x.SubItems) { engine.ReferenceCounter.RemoveStackReference(xSubItem); } } x.Clear(); } /// /// Removes and returns the item at the top of the specified array. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PopItem(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop(); var index = x.Count - 1; var item = x[index]; engine.Push(item); x.RemoveAt(index); if (engine.ReferenceCounter.Version == RCVersion.V2 && x.IsStackReferenced) engine.ReferenceCounter.RemoveStackReference(item); } } ================================================ FILE: src/Neo.VM/JumpTable/JumpTable.Control.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // JumpTable.Control.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; using System; using System.Collections.Generic; using System.Runtime.CompilerServices; namespace Neo.VM; partial class JumpTable { /// /// No operation. Does nothing. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Nop(ExecutionEngine engine, Instruction instruction) { } /// /// Jumps to the specified offset from the current instruction pointer, /// where the offset is obtained from the first operand of the instruction and interpreted as a signed byte. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Jmp(ExecutionEngine engine, Instruction instruction) { ExecuteJumpOffset(engine, instruction.TokenI8); } /// /// Jumps to the specified offset from the current instruction pointer, /// where the offset is obtained from the first operand of the instruction and interpreted as a 32-bit signed integer. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Jmp_L(ExecutionEngine engine, Instruction instruction) { ExecuteJumpOffset(engine, instruction.TokenI32); } /// /// Jumps to the specified offset from the current instruction pointer /// if the boolean result of popping the evaluation stack is true. /// The offset is obtained from the instruction's first operand interpreted as a signed byte. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. /// Pop 1, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void JmpIf(ExecutionEngine engine, Instruction instruction) { if (engine.Pop().GetBoolean()) ExecuteJumpOffset(engine, instruction.TokenI8); } /// /// Jumps to the specified offset from the current instruction pointer /// if the boolean result of popping the evaluation stack is true. /// The offset is obtained from the instruction's first operand interpreted as a 32-bit signed integer. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. /// Pop 1, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void JmpIf_L(ExecutionEngine engine, Instruction instruction) { if (engine.Pop().GetBoolean()) ExecuteJumpOffset(engine, instruction.TokenI32); } /// /// Jumps to the specified offset from the current instruction pointer /// if the boolean result of popping the evaluation stack is false. /// The offset is obtained from the instruction's first operand interpreted as a signed byte. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. /// Pop 1, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void JmpIfNot(ExecutionEngine engine, Instruction instruction) { if (!engine.Pop().GetBoolean()) ExecuteJumpOffset(engine, instruction.TokenI8); } /// /// Jumps to the specified offset from the current instruction pointer /// if the boolean result of popping the evaluation stack is false. /// The offset is obtained from the instruction's first operand interpreted as a 32-bit signed integer. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. /// Pop 1, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void JmpIfNot_L(ExecutionEngine engine, Instruction instruction) { if (!engine.Pop().GetBoolean()) ExecuteJumpOffset(engine, instruction.TokenI32); } /// /// Jumps to the specified offset from the current instruction pointer /// if the two integers popped from the evaluation stack are equal. /// The offset is obtained from the instruction's first operand interpreted as a signed byte. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. /// Pop 2, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void JmpEq(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); if (x1 == x2) ExecuteJumpOffset(engine, instruction.TokenI8); } /// /// Jumps to the specified offset from the current instruction pointer /// if the two integers popped from the evaluation stack are equal. /// The offset is obtained from the instruction's first operand interpreted as a 32-bit signed integer. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. /// Pop 2, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void JmpEq_L(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); if (x1 == x2) ExecuteJumpOffset(engine, instruction.TokenI32); } /// /// Jumps to the specified offset from the current instruction pointer /// if the two integers popped from the evaluation stack are not equal. /// The offset is obtained from the instruction's first operand interpreted as a signed byte. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. /// Pop 2, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void JmpNe(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); if (x1 != x2) ExecuteJumpOffset(engine, instruction.TokenI8); } /// /// Jumps to the specified offset from the current instruction pointer /// if the two integers popped from the evaluation stack are not equal. /// The offset is obtained from the instruction's first operand interpreted as a 32-bit signed integer. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. /// Pop 2, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void JmpNe_L(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); if (x1 != x2) ExecuteJumpOffset(engine, instruction.TokenI32); } /// /// Jumps to the specified offset from the current instruction pointer /// if the first integer pushed onto the evaluation stack is greater than the second integer. /// The offset is obtained from the instruction's first operand interpreted as a signed byte. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. /// Pop 2, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void JmpGt(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); if (x1 > x2) ExecuteJumpOffset(engine, instruction.TokenI8); } /// /// Jumps to the specified offset from the current instruction pointer /// if the first integer pushed onto the evaluation stack is greater than the second integer. /// The offset is obtained from the instruction's first operand interpreted as a 32-bit signed integer. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. /// Pop 2, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void JmpGt_L(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); if (x1 > x2) ExecuteJumpOffset(engine, instruction.TokenI32); } /// /// Jumps to the specified offset from the current instruction pointer /// if the first integer pushed onto the evaluation stack is greater than or equal to the second integer. /// The offset is obtained from the instruction's first operand interpreted as a signed byte. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. /// Pop 2, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void JmpGe(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); if (x1 >= x2) ExecuteJumpOffset(engine, instruction.TokenI8); } /// /// Jumps to the specified offset from the current instruction pointer /// if the first integer pushed onto the evaluation stack is greater than or equal to the second integer. /// The offset is obtained from the instruction's first operand interpreted as a 32-bit signed integer. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. /// Pop 2, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void JmpGe_L(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); if (x1 >= x2) ExecuteJumpOffset(engine, instruction.TokenI32); } /// /// Jumps to the specified offset from the current instruction pointer /// if the first integer pushed onto the evaluation stack is less than the second integer. /// The offset is obtained from the instruction's first operand interpreted as a signed byte. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. /// Pop 2, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void JmpLt(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); if (x1 < x2) ExecuteJumpOffset(engine, instruction.TokenI8); } /// /// Jumps to the specified offset from the current instruction pointer /// if the first integer pushed onto the evaluation stack is less than the second integer. /// The offset is obtained from the instruction's first operand interpreted as a 32-bit signed integer. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. /// Pop 2, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void JmpLt_L(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); if (x1 < x2) ExecuteJumpOffset(engine, instruction.TokenI32); } /// /// Jumps to the specified offset from the current instruction pointer /// if the first integer pushed onto the evaluation stack is less than or equal to the second integer. /// The offset is obtained from the instruction's first operand interpreted as a signed byte. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. /// Pop 2, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void JmpLe(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); if (x1 <= x2) ExecuteJumpOffset(engine, instruction.TokenI8); } /// /// Jumps to the specified offset from the current instruction pointer /// if the first integer pushed onto the evaluation stack is less than or equal to the second integer. /// The offset is obtained from the instruction's first operand interpreted as a 32-bit signed integer. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. /// Pop 2, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void JmpLe_L(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); if (x1 <= x2) ExecuteJumpOffset(engine, instruction.TokenI32); } /// /// Calls a method specified by the offset from the current instruction pointer. /// The offset is obtained from the instruction's first operand interpreted as a signed byte. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Call(ExecutionEngine engine, Instruction instruction) { ExecuteCall(engine, checked(engine.CurrentContext!.InstructionPointer + instruction.TokenI8)); } /// /// Calls a method specified by the offset from the current instruction pointer. /// The offset is obtained from the instruction's first operand interpreted as a 32-bit signed integer. /// /// /// The execution engine. /// The instruction containing the offset as the first operand. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Call_L(ExecutionEngine engine, Instruction instruction) { ExecuteCall(engine, checked(engine.CurrentContext!.InstructionPointer + instruction.TokenI32)); } /// /// Calls a method specified by the pointer pushed onto the evaluation stack. /// It verifies if the pointer belongs to the current script. /// /// /// The execution engine. /// The current instruction. /// Pop 1, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void CallA(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop(); if (x.Script != engine.CurrentContext!.Script) throw new InvalidOperationException("Pointers can't be shared between scripts"); ExecuteCall(engine, x.Position); } /// /// Calls the function described by the token. /// /// /// The execution engine. /// The current instruction. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void CallT(ExecutionEngine engine, Instruction instruction) { throw new InvalidOperationException($"Token not found: {instruction.TokenU16}"); } /// /// Aborts the execution by turning the virtual machine state to FAULT immediately, and the exception cannot be caught. /// /// /// The execution engine. /// The current instruction. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Abort(ExecutionEngine engine, Instruction instruction) { throw new Exception($"{OpCode.ABORT} is executed."); } /// /// Pop the top value of the stack. If it's false, exit vm execution and set vm state to FAULT. /// /// /// The execution engine. /// The current instruction. /// Pop 1, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Assert(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop().GetBoolean(); if (!x) throw new Exception($"{OpCode.ASSERT} is executed with false result."); } /// /// Pop the top value of the stack, and throw it. /// /// /// The execution engine. /// The current instruction. /// Pop 1, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Throw(ExecutionEngine engine, Instruction instruction) { ExecuteThrow(engine, engine.Pop()); } /// /// Initiates a try block with the specified catch and finally offsets. /// If there's no catch block, set CatchOffset to 0. If there's no finally block, set FinallyOffset to 0. /// where the catch offset is obtained from the first operand of the instruction and interpreted as a signed byte， /// the catch offset is obtained from the second operand of the instruction and interpreted as a signed byte. /// /// /// The execution engine. /// The current instruction. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Try(ExecutionEngine engine, Instruction instruction) { int catchOffset = instruction.TokenI8; int finallyOffset = instruction.TokenI8_1; ExecuteTry(engine, catchOffset, finallyOffset); } /// /// Initiates a try block with the specified catch and finally offsets. /// If there's no catch block, set CatchOffset to 0. If there's no finally block, set FinallyOffset to 0. /// where the catch offset is obtained from the first operand of the instruction and interpreted as a 32-bit signed integer， /// the catch offset is obtained from the second operand of the instruction and interpreted as a 32-bit signed integer. /// /// /// The execution engine. /// The current instruction. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Try_L(ExecutionEngine engine, Instruction instruction) { var catchOffset = instruction.TokenI32; var finallyOffset = instruction.TokenI32_1; ExecuteTry(engine, catchOffset, finallyOffset); } /// /// Ensures that the appropriate surrounding finally blocks are executed, /// then unconditionally transfers control to the specific target instruction represented as a 1-byte signed offset /// from the beginning of the current instruction. /// /// /// The execution engine. /// The current instruction. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void EndTry(ExecutionEngine engine, Instruction instruction) { var endOffset = instruction.TokenI8; ExecuteEndTry(engine, endOffset); } /// /// Ensures that the appropriate surrounding finally blocks are executed, /// then unconditionally transfers control to the specific target instruction represented as a 4-byte signed offset /// from the beginning of the current instruction. /// /// /// The execution engine. /// The current instruction. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void EndTry_L(ExecutionEngine engine, Instruction instruction) { var endOffset = instruction.TokenI32; ExecuteEndTry(engine, endOffset); } /// /// Ends the finally block. If no exception occurs or is caught, /// the VM jumps to the target instruction specified by ENDTRY/ENDTRY_L. /// Otherwise, the VM rethrows the exception to the upper layer. /// /// /// The execution engine. /// The current instruction. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void EndFinally(ExecutionEngine engine, Instruction instruction) { if (engine.CurrentContext!.TryStack is null) throw new InvalidOperationException($"The corresponding TRY block cannot be found."); if (!engine.CurrentContext.TryStack.TryPop(out var currentTry)) throw new InvalidOperationException($"The corresponding TRY block cannot be found."); if (engine.UncaughtException is null) engine.CurrentContext.InstructionPointer = currentTry.EndPointer; else ExecuteThrow(engine, engine.UncaughtException); engine.isJumping = true; } /// /// Returns from the current method. /// /// /// The execution engine. /// The current instruction. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Ret(ExecutionEngine engine, Instruction instruction) { var context_pop = engine.InvocationStack.Pop(); var stack_eval = engine.InvocationStack.Count == 0 ? engine.ResultStack : engine.InvocationStack.Peek().EvaluationStack; if (context_pop.EvaluationStack != stack_eval) { if (context_pop.RVCount >= 0 && context_pop.EvaluationStack.Count != context_pop.RVCount) // This exception indicates a mismatch between the expected and actual number of stack items. // It typically occurs due to compilation errors caused by potential issues in the compiler, resulting in either too many or too few // items left on the stack compared to what was anticipated by the return value count. // When you run into this problem, try to reach core-devs at https://github.com/neo-project/neo for help. throw new InvalidOperationException($"Return value count mismatch: expected {context_pop.RVCount}, but got {context_pop.EvaluationStack.Count} items on the evaluation stack"); context_pop.EvaluationStack.CopyTo(stack_eval); } if (engine.InvocationStack.Count == 0) engine.State = VMState.HALT; engine.ContextUnloaded(context_pop); engine.isJumping = true; } /// /// Calls to an interop service. /// /// /// The execution engine. /// The current instruction. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Syscall(ExecutionEngine engine, Instruction instruction) { throw new InvalidOperationException($"Syscall not found: {instruction.TokenU32}"); } #region Execute methods /// /// Executes a call operation by loading a new execution context at the specified position. /// /// The execution engine. /// The position to load the new execution context. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void ExecuteCall(ExecutionEngine engine, int position) { engine.LoadContext(engine.CurrentContext!.Clone(position)); } /// /// Executes the end of a try block, either popping it from the try stack or transitioning to the finally block. /// /// The execution engine. /// The offset to the end of the try block. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void ExecuteEndTry(ExecutionEngine engine, int endOffset) { if (engine.CurrentContext!.TryStack is null) throw new InvalidOperationException($"The corresponding TRY block cannot be found."); if (!engine.CurrentContext.TryStack.TryPeek(out var currentTry)) throw new InvalidOperationException($"The corresponding TRY block cannot be found."); if (currentTry.State == ExceptionHandlingState.Finally) throw new InvalidOperationException($"The opcode {OpCode.ENDTRY} can't be executed in a FINALLY block."); var endPointer = checked(engine.CurrentContext.InstructionPointer + endOffset); if (currentTry.HasFinally) { currentTry.State = ExceptionHandlingState.Finally; currentTry.EndPointer = endPointer; engine.CurrentContext.InstructionPointer = currentTry.FinallyPointer; } else { engine.CurrentContext.TryStack.Pop(); engine.CurrentContext.InstructionPointer = endPointer; } engine.isJumping = true; } /// /// Executes a jump operation to the specified position. /// /// The execution engine. /// The position to jump to. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void ExecuteJump(ExecutionEngine engine, int position) { if (position < 0 || position >= engine.CurrentContext!.Script.Length) throw new ArgumentOutOfRangeException($"Jump out of range for position: {position}"); engine.CurrentContext.InstructionPointer = position; engine.isJumping = true; } /// /// Executes a jump operation with the specified offset from the current instruction pointer. /// /// The execution engine. /// The offset from the current instruction pointer. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void ExecuteJumpOffset(ExecutionEngine engine, int offset) { ExecuteJump(engine, checked(engine.CurrentContext!.InstructionPointer + offset)); } /// /// Executes a try block operation with the specified catch and finally offsets. /// /// The execution engine. /// The catch block offset. /// The finally block offset. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void ExecuteTry(ExecutionEngine engine, int catchOffset, int finallyOffset) { if (catchOffset == 0 && finallyOffset == 0) throw new InvalidOperationException($"catchOffset and finallyOffset can't both be 0 in a TRY block."); if (engine.CurrentContext!.TryStack is null) engine.CurrentContext.TryStack = new Stack(); else if (engine.CurrentContext.TryStack.Count >= engine.Limits.MaxTryNestingDepth) throw new InvalidOperationException("MaxTryNestingDepth exceed."); var catchPointer = catchOffset == 0 ? -1 : checked(engine.CurrentContext.InstructionPointer + catchOffset); var finallyPointer = finallyOffset == 0 ? -1 : checked(engine.CurrentContext.InstructionPointer + finallyOffset); engine.CurrentContext.TryStack.Push(new ExceptionHandlingContext(catchPointer, finallyPointer)); } /// /// Executes a throw operation, handling any surrounding try-catch-finally blocks. /// /// The execution engine. /// The exception to throw. public virtual void ExecuteThrow(ExecutionEngine engine, StackItem? ex) { engine.UncaughtException = ex; var pop = 0; foreach (var executionContext in engine.InvocationStack) { if (executionContext.TryStack != null) { while (executionContext.TryStack.TryPeek(out var tryContext)) { if (tryContext.State == ExceptionHandlingState.Finally || (tryContext.State == ExceptionHandlingState.Catch && !tryContext.HasFinally)) { executionContext.TryStack.Pop(); continue; } for (var i = 0; i < pop; i++) { engine.ContextUnloaded(engine.InvocationStack.Pop()); } if (tryContext.State == ExceptionHandlingState.Try && tryContext.HasCatch) { tryContext.State = ExceptionHandlingState.Catch; engine.Push(engine.UncaughtException!); executionContext.InstructionPointer = tryContext.CatchPointer; engine.UncaughtException = null; } else { tryContext.State = ExceptionHandlingState.Finally; executionContext.InstructionPointer = tryContext.FinallyPointer; } engine.isJumping = true; return; } } ++pop; } throw new VMUnhandledException(engine.UncaughtException!); } #endregion } ================================================ FILE: src/Neo.VM/JumpTable/JumpTable.Numeric.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // JumpTable.Numeric.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System.Numerics; using System.Runtime.CompilerServices; namespace Neo.VM; partial class JumpTable { /// /// Computes the sign of the specified integer. /// If the value is negative, puts -1; if positive, puts 1; if zero, puts 0. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Sign(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop().GetInteger(); engine.Push(x.Sign); } /// /// Computes the absolute value of the specified integer. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Abs(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop().GetInteger(); engine.Push(BigInteger.Abs(x)); } /// /// Computes the negation of the specified integer. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Negate(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop().GetInteger(); engine.Push(-x); } /// /// Increments the specified integer by one. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Inc(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop().GetInteger(); engine.Push(x + 1); } /// /// Decrements the specified integer by one. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Dec(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop().GetInteger(); engine.Push(x - 1); } /// /// Computes the sum of two integers. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Add(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); engine.Push(x1 + x2); } /// /// Computes the difference between two integers. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Sub(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); engine.Push(x1 - x2); } /// /// Computes the product of two integers. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Mul(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); engine.Push(x1 * x2); } /// /// Computes the quotient of two integers. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Div(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); engine.Push(x1 / x2); } /// /// Computes the remainder after dividing a by b. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Mod(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); engine.Push(x1 % x2); } /// /// Computes the result of raising a number to the specified power. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Pow(ExecutionEngine engine, Instruction instruction) { var exponent = (int)engine.Pop().GetInteger(); engine.Limits.AssertShift(exponent); var value = engine.Pop().GetInteger(); engine.Push(BigInteger.Pow(value, exponent)); } /// /// Returns the square root of a specified number. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Sqrt(ExecutionEngine engine, Instruction instruction) { engine.Push(engine.Pop().GetInteger().Sqrt()); } /// /// Computes the modular multiplication of two integers. /// /// /// The execution engine. /// The instruction being executed. /// Pop 3, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void ModMul(ExecutionEngine engine, Instruction instruction) { var modulus = engine.Pop().GetInteger(); var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); engine.Push(x1 * x2 % modulus); } /// /// Computes the modular exponentiation of an integer. /// /// /// The execution engine. /// The instruction being executed. /// Pop 3, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void ModPow(ExecutionEngine engine, Instruction instruction) { var modulus = engine.Pop().GetInteger(); var exponent = engine.Pop().GetInteger(); var value = engine.Pop().GetInteger(); var result = exponent == -1 ? value.ModInverse(modulus) : BigInteger.ModPow(value, exponent, modulus); engine.Push(result); } /// /// Computes the left shift of an integer. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Shl(ExecutionEngine engine, Instruction instruction) { var shift = (int)engine.Pop().GetInteger(); engine.Limits.AssertShift(shift); var x = engine.Pop().GetInteger(); engine.Push(x << shift); } /// /// Computes the right shift of an integer. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Shr(ExecutionEngine engine, Instruction instruction) { var shift = (int)engine.Pop().GetInteger(); engine.Limits.AssertShift(shift); var x = engine.Pop().GetInteger(); engine.Push(x >> shift); } /// /// If the input is 0 or 1, it is flipped. Otherwise the output will be 0. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Not(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop().GetBoolean(); engine.Push(!x); } /// /// Computes the logical AND of the top two stack items and pushes the result onto the stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void BoolAnd(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetBoolean(); var x1 = engine.Pop().GetBoolean(); engine.Push(x1 && x2); } /// /// Computes the logical OR of the top two stack items and pushes the result onto the stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void BoolOr(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetBoolean(); var x1 = engine.Pop().GetBoolean(); engine.Push(x1 || x2); } /// /// Determines whether the top stack item is not zero and pushes the result onto the stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Nz(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop().GetInteger(); engine.Push(!x.IsZero); } /// /// Determines whether the top two stack items are equal and pushes the result onto the stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void NumEqual(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); engine.Push(x1 == x2); } /// /// Determines whether the top two stack items are not equal and pushes the result onto the stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void NumNotEqual(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); engine.Push(x1 != x2); } /// /// Determines whether the two integer at the top of the stack, x1 are less than x2, and pushes the result onto the stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Lt(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop(); var x1 = engine.Pop(); if (x1.IsNull || x2.IsNull) engine.Push(false); else engine.Push(x1.GetInteger() < x2.GetInteger()); } /// /// Determines whether the two integer at the top of the stack, x1 are less than or equal to x2, and pushes the result onto the stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Le(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop(); var x1 = engine.Pop(); if (x1.IsNull || x2.IsNull) engine.Push(false); else engine.Push(x1.GetInteger() <= x2.GetInteger()); } /// /// Determines whether the two integer at the top of the stack, x1 are greater than x2, and pushes the result onto the stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Gt(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop(); var x1 = engine.Pop(); if (x1.IsNull || x2.IsNull) engine.Push(false); else engine.Push(x1.GetInteger() > x2.GetInteger()); } /// /// Determines whether the two integer at the top of the stack, x1 are greater than or equal to x2, and pushes the result onto the stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Ge(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop(); var x1 = engine.Pop(); if (x1.IsNull || x2.IsNull) engine.Push(false); else engine.Push(x1.GetInteger() >= x2.GetInteger()); } /// /// Computes the minimum of the top two stack items and pushes the result onto the stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Min(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); engine.Push(BigInteger.Min(x1, x2)); } /// /// Computes the maximum of the top two stack items and pushes the result onto the stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Max(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetInteger(); var x1 = engine.Pop().GetInteger(); engine.Push(BigInteger.Max(x1, x2)); } /// /// Determines whether the top stack item is within the range specified by the next two top stack items /// and pushes the result onto the stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 3, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Within(ExecutionEngine engine, Instruction instruction) { var b = engine.Pop().GetInteger(); var a = engine.Pop().GetInteger(); var x = engine.Pop().GetInteger(); engine.Push(a <= x && x < b); } } ================================================ FILE: src/Neo.VM/JumpTable/JumpTable.Push.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // JumpTable.Push.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; using System; using System.Numerics; using System.Runtime.CompilerServices; namespace Neo.VM; partial class JumpTable { /// /// Pushes an 8-bit signed integer onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PushInt8(ExecutionEngine engine, Instruction instruction) { engine.Push(new BigInteger(instruction.Operand.Span)); } /// /// Pushes an 16-bit signed integer onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PushInt16(ExecutionEngine engine, Instruction instruction) { engine.Push(new BigInteger(instruction.Operand.Span)); } /// /// Pushes an 32-bit signed integer onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PushInt32(ExecutionEngine engine, Instruction instruction) { engine.Push(new BigInteger(instruction.Operand.Span)); } /// /// Pushes an 64-bit signed integer onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PushInt64(ExecutionEngine engine, Instruction instruction) { engine.Push(new BigInteger(instruction.Operand.Span)); } /// /// Pushes an 128-bit signed integer onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PushInt128(ExecutionEngine engine, Instruction instruction) { engine.Push(new BigInteger(instruction.Operand.Span)); } /// /// Pushes an 256-bit signed integer onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PushInt256(ExecutionEngine engine, Instruction instruction) { engine.Push(new BigInteger(instruction.Operand.Span)); } /// /// Pushes a boolean value of true onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PushT(ExecutionEngine engine, Instruction instruction) { engine.Push(StackItem.True); } /// /// Pushes a boolean value of false onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PushF(ExecutionEngine engine, Instruction instruction) { engine.Push(StackItem.False); } /// /// Pushes the address of the specified instruction onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PushA(ExecutionEngine engine, Instruction instruction) { var position = checked(engine.CurrentContext!.InstructionPointer + instruction.TokenI32); if (position < 0 || position > engine.CurrentContext.Script.Length) throw new InvalidOperationException($"Bad pointer address(Instruction instruction) {position}"); engine.Push(new Pointer(engine.CurrentContext.Script, position)); } /// /// Pushes a null onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PushNull(ExecutionEngine engine, Instruction instruction) { engine.Push(StackItem.Null); } /// /// Pushes a byte array with a length prefix onto the evaluation stack. /// The length of the array is 1 byte. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PushData1(ExecutionEngine engine, Instruction instruction) { engine.Limits.AssertMaxItemSize(instruction.Operand.Length); engine.Push(instruction.Operand); } /// /// Pushes a byte array with a length prefix onto the evaluation stack. /// The length of the array is 1 bytes. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PushData2(ExecutionEngine engine, Instruction instruction) { engine.Limits.AssertMaxItemSize(instruction.Operand.Length); engine.Push(instruction.Operand); } /// /// Pushes a byte array with a length prefix onto the evaluation stack. /// The length of the array is 4 bytes. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PushData4(ExecutionEngine engine, Instruction instruction) { engine.Limits.AssertMaxItemSize(instruction.Operand.Length); engine.Push(instruction.Operand); } /// /// Pushes the integer value of -1 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void PushM1(ExecutionEngine engine, Instruction instruction) { engine.Push(-1); } /// /// Pushes the integer value of 0 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push0(ExecutionEngine engine, Instruction instruction) { engine.Push(0); } /// /// Pushes the integer value of 1 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push1(ExecutionEngine engine, Instruction instruction) { engine.Push(1); } /// /// Pushes the integer value of 2 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push2(ExecutionEngine engine, Instruction instruction) { engine.Push(2); } /// /// Pushes the integer value of 3 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push3(ExecutionEngine engine, Instruction instruction) { engine.Push(3); } /// /// Pushes the integer value of 4 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push4(ExecutionEngine engine, Instruction instruction) { engine.Push(4); } /// /// Pushes the integer value of 5 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push5(ExecutionEngine engine, Instruction instruction) { engine.Push(5); } /// /// Pushes the integer value of 6 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push6(ExecutionEngine engine, Instruction instruction) { engine.Push(6); } /// /// Pushes the integer value of 7 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push7(ExecutionEngine engine, Instruction instruction) { engine.Push(7); } /// /// Pushes the integer value of 8 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push8(ExecutionEngine engine, Instruction instruction) { engine.Push(8); } /// /// Pushes the integer value of 9 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push9(ExecutionEngine engine, Instruction instruction) { engine.Push(9); } /// /// Pushes the integer value of 10 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push10(ExecutionEngine engine, Instruction instruction) { engine.Push(10); } /// /// Pushes the integer value of 11 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push11(ExecutionEngine engine, Instruction instruction) { engine.Push(11); } /// /// Pushes the integer value of 12 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push12(ExecutionEngine engine, Instruction instruction) { engine.Push(12); } /// /// Pushes the integer value of 13 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push13(ExecutionEngine engine, Instruction instruction) { engine.Push(13); } /// /// Pushes the integer value of 14 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push14(ExecutionEngine engine, Instruction instruction) { engine.Push(14); } /// /// Pushes the integer value of 15 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push15(ExecutionEngine engine, Instruction instruction) { engine.Push(15); } /// /// Pushes the integer value of 16 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Push16(ExecutionEngine engine, Instruction instruction) { engine.Push(16); } } ================================================ FILE: src/Neo.VM/JumpTable/JumpTable.Slot.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // JumpTable.Slot.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; using System; using System.Runtime.CompilerServices; namespace Neo.VM; partial class JumpTable { /// /// Initializes the static field slot in the current execution context. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void InitSSlot(ExecutionEngine engine, Instruction instruction) { if (engine.CurrentContext!.StaticFields != null) throw new InvalidOperationException($"{instruction.OpCode} cannot be executed twice."); if (instruction.TokenU8 == 0) throw new InvalidOperationException($"The operand {instruction.TokenU8} is invalid for OpCode.{instruction.OpCode}."); engine.CurrentContext.StaticFields = new Slot(instruction.TokenU8, engine.ReferenceCounter); } /// /// Initializes the local variable slot or the argument slot in the current execution context. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void InitSlot(ExecutionEngine engine, Instruction instruction) { if (engine.CurrentContext!.LocalVariables != null || engine.CurrentContext.Arguments != null) throw new InvalidOperationException($"{instruction.OpCode} cannot be executed twice."); if (instruction.TokenU16 == 0) throw new InvalidOperationException($"The operand {instruction.TokenU16} is invalid for OpCode.{instruction.OpCode}."); if (instruction.TokenU8 > 0) { engine.CurrentContext.LocalVariables = new Slot(instruction.TokenU8, engine.ReferenceCounter); } if (instruction.TokenU8_1 > 0) { var items = new StackItem[instruction.TokenU8_1]; for (var i = 0; i < instruction.TokenU8_1; i++) { items[i] = engine.Pop(); } engine.CurrentContext.Arguments = new Slot(items, engine.ReferenceCounter); } } /// /// Loads the value at index 0 from the static field slot onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdSFld0(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.StaticFields, 0); } /// /// Loads the value at index 1 from the static field slot onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdSFld1(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.StaticFields, 1); } /// /// Loads the value at index 2 from the static field slot onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdSFld2(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.StaticFields, 2); } /// /// Loads the value at index 3 from the static field slot onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdSFld3(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.StaticFields, 3); } /// /// Loads the value at index 4 from the static field slot onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdSFld4(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.StaticFields, 4); } /// /// Loads the value at index 5 from the static field slot onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdSFld5(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.StaticFields, 5); } /// /// Loads the value at index 6 from the static field slot onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdSFld6(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.StaticFields, 6); } /// /// Loads the static field at a specified index onto the evaluation stack. /// The index is represented as a 1-byte unsigned integer. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdSFld(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.StaticFields, instruction.TokenU8); } /// /// Stores the value at index 0 from the evaluation stack into the static field slot. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StSFld0(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.StaticFields, 0); } /// /// Stores the value at index 1 from the evaluation stack into the static field slot. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StSFld1(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.StaticFields, 1); } /// /// Stores the value at index 2 from the evaluation stack into the static field slot. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StSFld2(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.StaticFields, 2); } /// /// Stores the value at index 3 from the evaluation stack into the static field slot. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StSFld3(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.StaticFields, 3); } /// /// Stores the value at index 4 from the evaluation stack into the static field slot. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StSFld4(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.StaticFields, 4); } /// /// Stores the value at index 5 from the evaluation stack into the static field slot. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StSFld5(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.StaticFields, 5); } /// /// Stores the value at index 6 from the evaluation stack into the static field slot. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StSFld6(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.StaticFields, 6); } /// /// Stores the value on top of the evaluation stack in the static field list at a specified index. /// The index is represented as a 1-byte unsigned integer. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StSFld(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.StaticFields, instruction.TokenU8); } /// /// Loads the local variable at index 0 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdLoc0(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.LocalVariables, 0); } /// /// Loads the local variable at index 1 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdLoc1(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.LocalVariables, 1); } /// /// Loads the local variable at index 2 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdLoc2(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.LocalVariables, 2); } /// /// Loads the local variable at index 3 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdLoc3(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.LocalVariables, 3); } /// /// Loads the local variable at index 4 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdLoc4(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.LocalVariables, 4); } /// /// Loads the local variable at index 5 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdLoc5(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.LocalVariables, 5); } /// /// Loads the local variable at index 6 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdLoc6(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.LocalVariables, 6); } /// /// Loads the local variable at a specified index onto the evaluation stack. /// The index is represented as a 1-byte unsigned integer. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdLoc(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.LocalVariables, instruction.TokenU8); } /// /// Stores the value on top of the evaluation stack in the local variable list at index 0. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StLoc0(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.LocalVariables, 0); } /// /// Stores the value on top of the evaluation stack in the local variable list at index 1. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StLoc1(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.LocalVariables, 1); } /// /// Stores the value on top of the evaluation stack in the local variable list at index 2. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StLoc2(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.LocalVariables, 2); } /// /// Stores the value on top of the evaluation stack in the local variable list at index 3. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StLoc3(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.LocalVariables, 3); } /// /// Stores the value on top of the evaluation stack in the local variable list at index 4. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StLoc4(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.LocalVariables, 4); } /// /// Stores the value on top of the evaluation stack in the local variable list at index 5. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StLoc5(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.LocalVariables, 5); } /// /// Stores the value on top of the evaluation stack in the local variable list at index 6. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StLoc6(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.LocalVariables, 6); } /// /// Stores the value on top of the evaluation stack in the local variable list at a specified index. /// The index is represented as a 1-byte unsigned integer. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StLoc(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.LocalVariables, instruction.TokenU8); } /// /// Loads the argument at index 0 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdArg0(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.Arguments, 0); } /// /// Loads the argument at index 1 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdArg1(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.Arguments, 1); } /// /// Loads the argument at index 2 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdArg2(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.Arguments, 2); } /// /// Loads the argument at index 3 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdArg3(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.Arguments, 3); } /// /// Loads the argument at index 4 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdArg4(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.Arguments, 4); } /// /// Loads the argument at index 5 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdArg5(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.Arguments, 5); } /// /// Loads the argument at index 6 onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdArg6(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.Arguments, 6); } /// /// Loads the argument at a specified index onto the evaluation stack. /// The index is represented as a 1-byte unsigned integer. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void LdArg(ExecutionEngine engine, Instruction instruction) { ExecuteLoadFromSlot(engine, engine.CurrentContext!.Arguments, instruction.TokenU8); } /// /// Stores the value on top of the evaluation stack in the argument slot at index 0. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StArg0(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.Arguments, 0); } /// /// Stores the value on top of the evaluation stack in the argument slot at index 1. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StArg1(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.Arguments, 1); } /// /// Stores the value on top of the evaluation stack in the argument slot at index 2. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StArg2(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.Arguments, 2); } /// /// Stores the value on top of the evaluation stack in the argument slot at index 3. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StArg3(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.Arguments, 3); } /// /// Stores the value on top of the evaluation stack in the argument slot at index 4. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StArg4(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.Arguments, 4); } /// /// Stores the value on top of the evaluation stack in the argument slot at index 5. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StArg5(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.Arguments, 5); } /// /// Stores the value on top of the evaluation stack in the argument slot at index 6. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StArg6(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.Arguments, 6); } /// /// Stores the value on top of the evaluation stack in the argument slot at a specified index. /// The index is represented as a 1-byte unsigned integer. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void StArg(ExecutionEngine engine, Instruction instruction) { ExecuteStoreToSlot(engine, engine.CurrentContext!.Arguments, instruction.TokenU8); } #region Execute methods /// /// Executes the store operation into the specified slot at the given index. /// /// The execution engine. /// The slot to store the value. /// The index within the slot. public virtual void ExecuteStoreToSlot(ExecutionEngine engine, Slot? slot, int index) { if (slot is null) throw new InvalidOperationException("Slot has not been initialized."); if (index < 0 || index >= slot.Count) throw new InvalidOperationException($"Index out of range when storing to slot: {index}, {index}/[0, {slot.Count})."); slot[index] = engine.Pop(); } /// /// Executes the load operation from the specified slot at the given index onto the evaluation stack. /// /// The execution engine. /// The slot to load the value from. /// The index within the slot. public virtual void ExecuteLoadFromSlot(ExecutionEngine engine, Slot? slot, int index) { if (slot is null) throw new InvalidOperationException("Slot has not been initialized."); if (index < 0 || index >= slot.Count) throw new InvalidOperationException($"Index out of range when loading from slot: {index}, {index}/[0, {slot.Count})."); engine.Push(slot[index]); } #endregion } ================================================ FILE: src/Neo.VM/JumpTable/JumpTable.Splice.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // JumpTable.Splice.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Runtime.CompilerServices; using Buffer = Neo.VM.Types.Buffer; namespace Neo.VM; partial class JumpTable { /// /// Creates a new buffer with the specified length and pushes it onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void NewBuffer(ExecutionEngine engine, Instruction instruction) { int length = (int)engine.Pop().GetInteger(); engine.Limits.AssertMaxItemSize(length); engine.Push(new Buffer(length)); } /// /// Copies a specified number of bytes from one buffer to another buffer. /// /// /// The execution engine. /// The instruction being executed. /// Pop 5, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Memcpy(ExecutionEngine engine, Instruction instruction) { int count = (int)engine.Pop().GetInteger(); if (count < 0) throw new InvalidOperationException($"The count can not be negative for {nameof(OpCode.MEMCPY)}, count: {count}."); int si = (int)engine.Pop().GetInteger(); if (si < 0) throw new InvalidOperationException($"The source index can not be negative for {nameof(OpCode.MEMCPY)}, index: {si}."); ReadOnlySpan src = engine.Pop().GetSpan(); if (checked(si + count) > src.Length) throw new InvalidOperationException($"The source index + count is out of range for {nameof(OpCode.MEMCPY)}, index: {si}, count: {count}, {si}/[0, {src.Length}]."); int di = (int)engine.Pop().GetInteger(); if (di < 0) throw new InvalidOperationException($"The destination index can not be negative for {nameof(OpCode.MEMCPY)}, index: {si}."); Buffer dst = engine.Pop(); if (checked(di + count) > dst.Size) throw new InvalidOperationException($"The destination index + count is out of range for {nameof(OpCode.MEMCPY)}, index: {di}, count: {count}, {di}/[0, {dst.Size}]."); // TODO: check if we can optimize the memcpy by using peek instead of dup then pop src.Slice(si, count).CopyTo(dst.InnerBuffer.Span[di..]); } /// /// Concatenates two buffers and pushes the result onto the evaluation stack. /// The result is the first pushed item concatenated with the second pushed item. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Cat(ExecutionEngine engine, Instruction instruction) { var x2 = engine.Pop().GetSpan(); var x1 = engine.Pop().GetSpan(); int length = x1.Length + x2.Length; engine.Limits.AssertMaxItemSize(length); Buffer result = new(length, false); x1.CopyTo(result.InnerBuffer.Span); x2.CopyTo(result.InnerBuffer.Span[x1.Length..]); engine.Push(result); } /// /// Extracts a sub-buffer from the specified buffer and pushes it onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 3, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void SubStr(ExecutionEngine engine, Instruction instruction) { int count = (int)engine.Pop().GetInteger(); if (count < 0) throw new InvalidOperationException($"The count can not be negative for {nameof(OpCode.SUBSTR)}, count: {count}."); int index = (int)engine.Pop().GetInteger(); if (index < 0) throw new InvalidOperationException($"The index can not be negative for {nameof(OpCode.SUBSTR)}, index: {index}."); var x = engine.Pop().GetSpan(); if (checked(index + count) > x.Length) throw new InvalidOperationException($"The index + count is out of range for {nameof(OpCode.SUBSTR)}, index: {index}, count: {count}, {index + count}/[0, {x.Length}]."); Buffer result = new(count, false); x.Slice(index, count).CopyTo(result.InnerBuffer.Span); engine.Push(result); } /// /// Extracts a specified number of characters from the left side of the buffer and pushes them onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Left(ExecutionEngine engine, Instruction instruction) { int count = (int)engine.Pop().GetInteger(); if (count < 0) throw new InvalidOperationException($"The count can not be negative for {nameof(OpCode.LEFT)}, count: {count}."); var x = engine.Pop().GetSpan(); if (count > x.Length) throw new InvalidOperationException($"The count is out of range for {nameof(OpCode.LEFT)}, {count}/[0, {x.Length}]."); Buffer result = new(count, false); x[..count].CopyTo(result.InnerBuffer.Span); engine.Push(result); } /// /// Extracts a specified number of characters from the right side of the buffer and pushes them onto the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Right(ExecutionEngine engine, Instruction instruction) { int count = (int)engine.Pop().GetInteger(); if (count < 0) throw new InvalidOperationException($"The count can not be negative for {nameof(OpCode.RIGHT)}, count: {count}."); var x = engine.Pop().GetSpan(); if (count > x.Length) throw new InvalidOperationException($"The count is out of range for {nameof(OpCode.RIGHT)}, {count}/[0, {x.Length}]."); Buffer result = new(count, false); x[^count..^0].CopyTo(result.InnerBuffer.Span); engine.Push(result); } } ================================================ FILE: src/Neo.VM/JumpTable/JumpTable.Stack.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // JumpTable.Stack.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; using System; using System.Runtime.CompilerServices; namespace Neo.VM; partial class JumpTable { /// /// Pushes the number of stack items in the evaluation stack onto the stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 0, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Depth(ExecutionEngine engine, Instruction instruction) { engine.Push(engine.CurrentContext!.EvaluationStack.Count); } /// /// Removes the top item from the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Drop(ExecutionEngine engine, Instruction instruction) { engine.Pop(); } /// /// Removes the second-to-top stack item. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Nip(ExecutionEngine engine, Instruction instruction) { engine.CurrentContext!.EvaluationStack.Remove(1); } /// /// Removes the n-th item from the top of the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void XDrop(ExecutionEngine engine, Instruction instruction) { var n = (int)engine.Pop().GetInteger(); if (n < 0) throw new InvalidOperationException($"The negative value {n} is invalid for OpCode.{instruction.OpCode}."); engine.CurrentContext!.EvaluationStack.Remove(n); } /// /// Clears all items from the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Clear(ExecutionEngine engine, Instruction instruction) { engine.CurrentContext!.EvaluationStack.Clear(); } /// /// Duplicates the item on the top of the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 0, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Dup(ExecutionEngine engine, Instruction instruction) { engine.Push(engine.Peek()); } /// /// Copies the second item from the top of the evaluation stack and pushes the copy onto the stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 0, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Over(ExecutionEngine engine, Instruction instruction) { engine.Push(engine.Peek(1)); } /// /// Copies the nth item from the top of the evaluation stack and pushes the copy onto the stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Pick(ExecutionEngine engine, Instruction instruction) { var n = (int)engine.Pop().GetInteger(); if (n < 0) throw new InvalidOperationException($"The negative value {n} is invalid for OpCode.{instruction.OpCode}."); engine.Push(engine.Peek(n)); } /// /// Copies the top item on the evaluation stack and inserts the copy between the first and second items. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Tuck(ExecutionEngine engine, Instruction instruction) { engine.CurrentContext!.EvaluationStack.Insert(2, engine.Peek()); } /// /// Swaps the top two items on the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 0, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Swap(ExecutionEngine engine, Instruction instruction) { var stack = engine.CurrentContext!.EvaluationStack; if (stack.Count < 2) throw new ArgumentOutOfRangeException($"Swap index is out of stack bounds: 1/{stack.Count}"); stack.Swap(0, 1); } /// /// Left rotates the top three items on the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 0, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Rot(ExecutionEngine engine, Instruction instruction) { // ROT: [a, b, c] -> [b, c, a] (c is top) // Equivalent to: swap(1,2), swap(0,1) var stack = engine.CurrentContext!.EvaluationStack; if (stack.Count < 3) throw new ArgumentOutOfRangeException($"Swap index is out of stack bounds: 2/{stack.Count}"); stack.Swap(1, 2); stack.Swap(0, 1); } /// /// The item n back in the stack is moved to the top. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Roll(ExecutionEngine engine, Instruction instruction) { var n = (int)engine.Pop().GetInteger(); if (n < 0) throw new InvalidOperationException($"The negative value {n} is invalid for OpCode.{instruction.OpCode}."); if (n == 0) return; var x = engine.CurrentContext!.EvaluationStack.Remove(n); engine.Push(x); } /// /// Reverses the order of the top 3 items on the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Reverse3(ExecutionEngine engine, Instruction instruction) { engine.CurrentContext!.EvaluationStack.Reverse(3); } /// /// Reverses the order of the top 4 items on the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Reverse4(ExecutionEngine engine, Instruction instruction) { engine.CurrentContext!.EvaluationStack.Reverse(4); } /// /// Reverses the order of the top n items on the evaluation stack. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void ReverseN(ExecutionEngine engine, Instruction instruction) { var n = (int)engine.Pop().GetInteger(); engine.CurrentContext!.EvaluationStack.Reverse(n); } } ================================================ FILE: src/Neo.VM/JumpTable/JumpTable.Types.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // JumpTable.Types.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; using System; using System.Runtime.CompilerServices; namespace Neo.VM; partial class JumpTable { /// /// Determines whether the item on top of the evaluation stack is null. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void IsNull(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop(); engine.Push(x.IsNull); } /// /// Determines whether the item on top of the evaluation stack has a specified type. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void IsType(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop(); var type = (StackItemType)instruction.TokenU8; #if NET5_0_OR_GREATER if (type == StackItemType.Any || !Enum.IsDefined(type)) #else if (type == StackItemType.Any || !Enum.IsDefined(typeof(StackItemType), type)) #endif throw new InvalidOperationException($"Invalid type: {type}"); engine.Push(x.Type == type); } /// /// Converts the item on top of the evaluation stack to a specified type. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 1 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void Convert(ExecutionEngine engine, Instruction instruction) { var x = engine.Pop(); engine.Push(x.ConvertTo((StackItemType)instruction.TokenU8)); } /// /// Aborts execution with a specified message. /// /// /// The execution engine. /// The instruction being executed. /// Pop 1, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void AbortMsg(ExecutionEngine engine, Instruction instruction) { var msg = engine.Pop().GetString(); throw new Exception($"{OpCode.ABORTMSG} is executed. Reason: {msg}"); } /// /// Asserts a condition with a specified message, throwing an exception if the condition is false. /// /// /// The execution engine. /// The instruction being executed. /// Pop 2, Push 0 [MethodImpl(MethodImplOptions.AggressiveInlining)] public virtual void AssertMsg(ExecutionEngine engine, Instruction instruction) { var msg = engine.Pop().GetString(); var x = engine.Pop().GetBoolean(); if (!x) throw new Exception($"{OpCode.ASSERTMSG} is executed with false result. Reason: {msg}"); } } ================================================ FILE: src/Neo.VM/JumpTable/JumpTable.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // JumpTable.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Runtime.CompilerServices; namespace Neo.VM; public partial class JumpTable { /// /// Default JumpTable /// public static readonly JumpTable Default = new(); public delegate void DelAction(ExecutionEngine engine, Instruction instruction); protected readonly DelAction[] Table = new DelAction[byte.MaxValue]; public DelAction this[OpCode opCode] { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => Table[(byte)opCode]; [MethodImpl(MethodImplOptions.AggressiveInlining)] set { Table[(byte)opCode] = value; } } /// /// Jump table constructor /// /// Throw an exception if the opcode was already set public JumpTable() { // Fill defined foreach (var mi in GetType().GetMethods()) { if (Enum.TryParse(mi.Name, true, out var opCode)) { if (Table[(byte)opCode] is not null) { throw new InvalidOperationException($"Opcode {opCode} is already defined."); } #if NET5_0_OR_GREATER Table[(byte)opCode] = mi.CreateDelegate(this); #else Table[(byte)opCode] = (DelAction)mi.CreateDelegate(typeof(DelAction), this); #endif } } // Fill with undefined for (var x = 0; x < Table.Length; x++) { if (Table[x] is not null) continue; Table[x] = InvalidOpcode; } } public virtual void InvalidOpcode(ExecutionEngine engine, Instruction instruction) { throw new InvalidOperationException($"Opcode {instruction.OpCode} is undefined."); } } ================================================ FILE: src/Neo.VM/Neo.VM.csproj ================================================  2015-2025 The Neo Project Neo virtual machine 3.9.3 The Neo Project netstandard2.1;net10.0 latest NEO;AntShares;Blockchain;Smart Contract;VM https://github.com/neo-project/neo-vm MIT git https://github.com/neo-project/neo-vm.git true enable true ================================================ FILE: src/Neo.VM/OpCode.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // OpCode.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; namespace Neo.VM; /// /// Represents the opcode of an . /// public enum OpCode : byte { #region Constants /// /// Pushes a 1-byte signed integer onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// [OperandSize(Size = 1)] PUSHINT8 = 0x00, /// /// Pushes a 2-bytes signed integer onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// [OperandSize(Size = 2)] PUSHINT16 = 0x01, /// /// Pushes a 4-bytes signed integer onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// [OperandSize(Size = 4)] PUSHINT32 = 0x02, /// /// Pushes an 8-bytes signed integer onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// [OperandSize(Size = 8)] PUSHINT64 = 0x03, /// /// Pushes a 16-bytes signed integer onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// [OperandSize(Size = 16)] PUSHINT128 = 0x04, /// /// Pushes a 32-bytes signed integer onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// [OperandSize(Size = 32)] PUSHINT256 = 0x05, /// /// Pushes the boolean value onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSHT = 0x08, /// /// Pushes the boolean value onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSHF = 0x09, /// /// Converts the 4-bytes offset to an , and pushes it onto the stack. /// /// The execution will be faulted if the current position + offset is out of script range[0, script.Length). /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// [OperandSize(Size = 4)] PUSHA = 0x0A, /// /// The item is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSHNULL = 0x0B, /// /// The next byte contains the number of bytes to be pushed onto the stack. /// The data format: |1-byte unsigned size|data|. /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// [OperandSize(SizePrefix = 1)] PUSHDATA1 = 0x0C, /// /// The next two bytes contain the number of bytes to be pushed onto the stack. /// The data format: |2-byte little-endian unsigned size|data|. /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// [OperandSize(SizePrefix = 2)] PUSHDATA2 = 0x0D, /// /// The next four bytes contain the number of bytes to be pushed onto the stack. /// The data format: |4-byte little-endian unsigned size|data|. /// /// The execution will be faulted if the datasize is out of MaxItemSize. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// [OperandSize(SizePrefix = 4)] PUSHDATA4 = 0x0E, /// /// The number -1 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSHM1 = 0x0F, /// /// The number 0 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH0 = 0x10, /// /// The number 1 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH1 = 0x11, /// /// The number 2 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH2 = 0x12, /// /// The number 3 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH3 = 0x13, /// /// The number 4 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH4 = 0x14, /// /// The number 5 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH5 = 0x15, /// /// The number 6 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH6 = 0x16, /// /// The number 7 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH7 = 0x17, /// /// The number 8 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH8 = 0x18, /// /// The number 9 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH9 = 0x19, /// /// The number 10 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH10 = 0x1A, /// /// The number 11 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH11 = 0x1B, /// /// The number 12 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH12 = 0x1C, /// /// The number 13 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH13 = 0x1D, /// /// The number 14 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH14 = 0x1E, /// /// The number 15 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH15 = 0x1F, /// /// The number 16 is pushed onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PUSH16 = 0x20, #endregion #region Flow control /// /// The operation does nothing. It is intended to fill in space if opcodes are patched. /// /// /// Push: 0 item(s) /// Pop: 0 item(s) /// /// NOP = 0x21, /// /// Unconditionally transfers control to a target instruction. /// The target instruction is represented as a 1-byte signed offset from the beginning of the current instruction. /// /// The execution will be faulted if the target offset is out of script range[0, script.Length). /// /// /// Push: 0 item(s) /// Pop: 0 item(s) /// /// [OperandSize(Size = 1)] JMP = 0x22, /// /// Unconditionally transfers control to a target instruction. /// The target instruction is represented as a 4-bytes little-endian signed offset from the beginning of the current instruction. /// /// The execution will be faulted if the target offset is out of script range[0, script.Length). /// /// /// Push: 0 item(s) /// Pop: 0 item(s) /// /// [OperandSize(Size = 4)] JMP_L = 0x23, /// /// Transfers control to a target instruction if the value is true value (true, non-null, non-zero). /// The target instruction is represented as a 1-byte signed offset from the beginning of the current instruction. /// /// The execution will be faulted if the target offset is out of script range[0, script.Length). /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// [OperandSize(Size = 1)] JMPIF = 0x24, /// /// Transfers control to a target instruction if the value is true value (true, non-null, non-zero). /// The target instruction is represented as a 4-bytes little-endian signed offset from the beginning of the current instruction. /// /// The execution will be faulted if the target offset is out of script range[0, script.Length). /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// [OperandSize(Size = 4)] JMPIF_L = 0x25, /// /// Transfers control to a target instruction if the value is false value (false, null, zero). /// The target instruction is represented as a 1-byte signed offset from the beginning of the current instruction. /// /// If the target offset is out of script range[0, script.Length), the execution will be faulted. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// [OperandSize(Size = 1)] JMPIFNOT = 0x26, /// /// Transfers control to a target instruction if the value is false value (false, null, zero). /// The target instruction is represented as a 4-bytes little-endian signed offset from the beginning of the current instruction. /// /// The execution will be faulted if the target offset is out of script range[0, script.Length). /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// [OperandSize(Size = 4)] JMPIFNOT_L = 0x27, /// /// Transfers control to a target instruction if the top two items are equal. /// The target instruction is represented as a 1-byte signed offset from the beginning of the current instruction. /// /// If any item is not an integer, it will be converted to an integer then compared. /// /// The execution will be faulted if: /// 1. the target offset is out of script range[0, script.Length). /// 2. One or both of items cannot convert to integer. /// /// /// Push: 0 item(s) /// Pop: 2 item(s) /// /// [OperandSize(Size = 1)] JMPEQ = 0x28, /// /// Transfers control to a target instruction if the top two items are equal. /// The target instruction is represented as a 4-bytes signed offset from the beginning of the current instruction. /// /// If any item is not an integer, it will be converted to an integer then compared. /// /// The execution will be faulted if: /// 1. the target offset is out of script range[0, script.Length). /// 2. One or both of items cannot convert to an integer. /// /// /// Push: 0 item(s) /// Pop: 2 item(s) /// /// [OperandSize(Size = 4)] JMPEQ_L = 0x29, /// /// Transfers control to a target instruction when the top two items are not equal. /// The target instruction is represented as a 1-byte signed offset from the beginning of the current instruction. /// /// If any item is not an integer, it will be converted to an integer then compared. /// /// The execution will be faulted if: /// 1. the target offset is out of script range[0, script.Length). /// 2. One or both of items cannot convert to an integer. /// /// /// Push: 0 item(s) /// Pop: 2 item(s) /// /// [OperandSize(Size = 1)] JMPNE = 0x2A, /// /// Transfers control to a target instruction when the top two items are not equal. /// The target instruction is represented as a 4-bytes signed offset from the beginning of the current instruction. /// /// If any item is not an integer, it will be converted to an integer then compared. /// /// The execution will be faulted if: /// 1. the target offset is out of script range[0, script.Length). /// 2. One or both of items cannot convert to an integer. /// /// /// Push: 0 item(s) /// Pop: 2 item(s) /// /// [OperandSize(Size = 4)] JMPNE_L = 0x2B, /// /// Transfers control to a target instruction if first pushed item(the second in the stack) is greater than the second pushed item. /// The target instruction is represented as a 1-byte signed offset from the beginning of the current instruction. /// /// If any item is not an integer, it will be converted to an integer then compared. /// /// The execution will be faulted if: /// 1. the target offset is out of script range[0, script.Length). /// 2. One or both of items cannot represent as an integer. /// /// /// Push: 0 item(s) /// Pop: 2 item(s) /// /// [OperandSize(Size = 1)] JMPGT = 0x2C, /// /// Transfers control to a target instruction if first pushed item(the second in the stack) is greater than the second pushed item. /// The target instruction is represented as a 4-bytes signed offset from the beginning of the current instruction. /// /// If any item is not an integer, it will be converted to an integer then compared. /// /// The execution will be faulted if: /// 1. the target offset is out of script range[0, script.Length). /// 2. One or both of items cannot represent as an integer. /// /// /// Push: 0 item(s) /// Pop: 2 item(s) /// /// [OperandSize(Size = 4)] JMPGT_L = 0x2D, /// /// Transfers control to a target instruction if first pushed item(the second in the stack) is greater than or equal to the second pushed item. /// The target instruction is represented as a 1-byte signed offset from the beginning of the current instruction. /// /// If any item is not an integer, it will be converted to an integer then compared. /// /// The execution will be faulted if: /// 1. the target offset is out of script range[0, script.Length). /// 2. One or both of items cannot represent as an integer. /// /// /// Push: 0 item(s) /// Pop: 2 item(s) /// /// [OperandSize(Size = 1)] JMPGE = 0x2E, /// /// Transfers control to a target instruction if first pushed item(the second in the stack) is greater than or equal to the second pushed item. /// The target instruction is represented as a 4-bytes signed offset from the beginning of the current instruction. /// /// If any item is not an integer, it will be converted to an integer then compared. /// /// The execution will be faulted if: /// 1. the target offset is out of script range[0, script.Length). /// 2. One or both of items cannot represent as an integer. /// /// /// Push: 0 item(s) /// Pop: 2 item(s) /// /// [OperandSize(Size = 4)] JMPGE_L = 0x2F, /// /// Transfers control to a target instruction if first pushed item(the second in the stack) is less than the second pushed item. /// The target instruction is represented as a 1-byte signed offset from the beginning of the current instruction. /// /// If any item is not an integer, it will be converted to an integer then compared. /// /// The execution will be faulted if: /// 1. the target offset is out of script range[0, script.Length). /// 2. One or both of items cannot represent as an integer. /// /// /// Push: 0 item(s) /// Pop: 2 item(s) /// /// [OperandSize(Size = 1)] JMPLT = 0x30, /// /// Transfers control to a target instruction if first pushed item(the second in the stack) is less than the second pushed item. /// The target instruction is represented as a 4-bytes signed offset from the beginning of the current instruction. /// /// If any item is not an integer, it will be converted to an integer then compared. /// /// The execution will be faulted if: /// 1. the target offset is out of script range[0, script.Length). /// 2. One or both of items cannot represent as an integer. /// /// /// Push: 0 item(s) /// Pop: 2 item(s) /// /// [OperandSize(Size = 4)] JMPLT_L = 0x31, /// /// Transfers control to a target instruction if first pushed item(the second in the stack) is less than or equal to the second pushed item. /// The target instruction is represented as a 1-byte signed offset from the beginning of the current instruction. /// /// If any item is not an integer, it will be converted to an integer then compared. /// /// The execution will be faulted if: /// 1. the target offset is out of script range[0, script.Length). /// 2. One or both of items cannot represent as an integer. /// /// /// Push: 0 item(s) /// Pop: 2 item(s) /// /// [OperandSize(Size = 1)] JMPLE = 0x32, /// /// Transfers control to a target instruction if first pushed item(the second in the stack) is less than or equal to the second pushed item. /// The target instruction is represented as a 4-bytes signed offset from the beginning of the current instruction. /// /// If any item is not an integer, it will be converted to an integer then compared. /// /// The execution will be faulted if: /// 1. the target offset is out of script range[0, script.Length). /// 2. One or both of items cannot represent as an integer. /// /// /// Push: 0 item(s) /// Pop: 2 item(s) /// /// [OperandSize(Size = 4)] JMPLE_L = 0x33, /// /// Calls the function at the target address which is represented as a 1-byte signed offset from the beginning of the current instruction. /// /// /// The execution will be faulted if the target address is out of script range[0, script.Length). /// /// [OperandSize(Size = 1)] CALL = 0x34, /// /// Calls the function at the target address which is represented as a 4-bytes little-endian signed offset from the beginning of the current instruction. /// /// /// The execution will be faulted if the target address is out of script range[0, script.Length). /// /// [OperandSize(Size = 4)] CALL_L = 0x35, /// /// Pop the pointer of a function from the stack, and call the function. /// /// /// The execution will be faulted if the pointer is not from the current script or not a valid pointer. /// /// CALLA = 0x36, /// /// Calls the function which is described by the token. /// [OperandSize(Size = 2)] CALLT = 0x37, /// /// It turns the vm state to FAULT immediately, and cannot be caught. /// /// /// Push: 0 item(s) /// Pop: 0 item(s) /// /// ABORT = 0x38, /// /// Pop the top value of the stack. If it's false value (false, null, zero), exit vm execution and set vm state to FAULT. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// ASSERT = 0x39, /// /// Pop the top value of the stack, and throw it. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// THROW = 0x3A, /// /// TRY CatchOffset(sbyte) FinallyOffset(sbyte). If there's no catch body, set CatchOffset 0. If there's no finally body, set FinallyOffset 0. /// /// The execution will be faulted if: /// 1. `catch` and `finally` are not provided both. /// 2. the `try` can not be nested more than `MaxTryNestingDepth`. /// 3. the `catch` or `finally` offset is out of script range[0, script.Length). /// /// [OperandSize(Size = 2)] TRY = 0x3B, /// /// TRY_L CatchOffset(int) FinallyOffset(int). If there's no catch body, set CatchOffset 0. If there's no finally body, set FinallyOffset 0. /// /// The execution will be faulted if: /// 1. `catch` and `finally` are not provided both. /// 2. the `try` can not be nested more than `MaxTryNestingDepth`. /// 3. the `catch` or `finally` offset is out of script range[0, script.Length). /// /// [OperandSize(Size = 8)] TRY_L = 0x3C, /// /// Ensures that the appropriate surrounding finally blocks are executed. /// And then unconditionally transfers control to the specific target instruction, /// which is represented as a 1-byte signed offset from the beginning of the current instruction. /// /// The execution will be faulted if: /// 1. the corresponding `try` is not provided. /// 2. the end offset is out of script range[0, script.Length). /// /// [OperandSize(Size = 1)] ENDTRY = 0x3D, /// /// Ensures that the appropriate surrounding finally blocks are executed. /// And then unconditionally transfers control to the specific target instruction, /// which is represented as a 4-byte little-endian signed offset from the beginning of the current instruction. /// /// The execution will be faulted if: /// 1. the corresponding `try` is not provided. /// 2. the end offset is out of script range[0, script.Length). /// /// [OperandSize(Size = 4)] ENDTRY_L = 0x3E, /// /// End finally, If no exception happen or be catched, vm will jump to the target instruction of ENDTRY/ENDTRY_L. /// Otherwise, vm will rethrow the exception to upper layer. /// /// The execution will be faulted if the corresponding `try` is not provided. /// /// ENDFINALLY = 0x3F, /// /// Returns from the current method. /// RET = 0x40, /// /// Calls to an interop service. /// [OperandSize(Size = 4)] SYSCALL = 0x41, #endregion #region Stack /// /// Pushes the number of stack items onto the stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// DEPTH = 0x43, /// /// Removes the top stack item. /// /// a b c -> a b /// /// The execution will be faulted if the stack is empty. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// DROP = 0x45, /// /// Removes the second-to-top stack item. /// /// a b c -> a c /// /// The execution will be faulted if the stack has less than 2 items. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// NIP = 0x46, /// /// The item n back in the main stack is removed. The top item indicates the number of items to be removed. /// If the top item is not an integer, it will be converted to an integer. /// /// /// The execution will be faulted if: /// 1. The top item cannot convert to an integer. /// 2. The stack has less than n+1 items. /// /// /// Push: 0 item(s) /// Pop: n+1 item(s) /// /// XDROP = 0x48, /// /// Clear the stack /// CLEAR = 0x49, /// /// Duplicates the top stack item. /// /// a b c -> a b c c /// /// The execution will be faulted if the stack is empty. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// DUP = 0x4A, /// /// Copies the second-to-top stack item to the top. /// /// a b c -> a b c b /// /// The execution will be faulted if the stack has less than 2 items. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// OVER = 0x4B, /// /// The item n back in the stack is copied to the top. The top item indicates the index of the item to be copied. /// If the top item is not an integer, it will be converted to an integer. /// /// a b c d 2 -> a b c d b /// index => 3[2]1 0 /// /// /// The execution will be faulted if: /// 1. The top item cannot convert to an integer. /// 2. The stack has less than n+1 items. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// PICK = 0x4D, /// /// The item at the top of the stack is copied and inserted before the second-to-top item. /// /// a b c -> a c b c /// /// The execution will be faulted if the stack has less than 2 items. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// TUCK = 0x4E, /// /// The top two items on the stack are swapped. /// /// a b -> b a /// /// The execution will be faulted if the stack has less than 2 items. /// /// /// Push: 0 item(s) /// Pop: 0 item(s) /// /// SWAP = 0x50, /// /// The top three items on the stack are rotated to the left. /// /// a b c -> b c a /// /// The execution will be faulted if the stack has less than 3 items. /// /// /// Push: 0 item(s) /// Pop: 0 item(s) /// /// ROT = 0x51, /// /// The item n back in the stack is moved to the top. The top item indicates the index of the item to be moved. /// If the top item is not an integer, it will be converted to an integer. /// /// a b c d 2 -> a c d b /// index => 3[2]1 0 /// /// /// The execution will be faulted if: /// 1. The top item cannot convert to an integer. /// 2. The stack has less than n+1 items. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// ROLL = 0x52, /// /// Reverse the order of the top 3 items on the stack. /// /// a b c -> c b a /// /// The execution will be faulted if the stack has less than 3 items. /// /// /// Push: 0 item(s) /// Pop: 0 item(s) /// /// REVERSE3 = 0x53, /// /// Reverse the order of the top 4 items on the stack. /// /// a b c d -> d c b a /// /// The execution will be faulted if the stack has less than 4 items. /// /// /// Push: 0 item(s) /// Pop: 0 item(s) /// /// REVERSE4 = 0x54, /// /// Pop the number N on the stack, and reverse the order of the top N items on the stack. /// If the top item is not an integer, it will be converted to an integer. /// /// a b c d 3 -> a d c b /// /// The execution will be faulted if: /// 1. The top item cannot convert to an integer. /// 2. The stack has less than n+1 items. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// REVERSEN = 0x55, #endregion #region Slot /// /// Initialize the static field list for the current execution context. /// /// /// The execution will be faulted if: /// 1. The static field list for the current execution context has been initialized. /// 2. The operand is 0. /// /// /// Push: 0 item(s) /// Pop: 0 item(s) /// /// [OperandSize(Size = 1)] INITSSLOT = 0x56, /// /// Initialize the argument slot and/or the local variable list for the current execution context. /// It has two uint8 operands: The first is the number of local variables, and the second is the number of arguments. /// Two operands cannot both be 0. /// /// /// The execution will be faulted if: /// 1. The argument slot and/or the local variable list for the current execution context has been initialized. /// 2. Two operands are both 0. /// /// [OperandSize(Size = 2)] INITSLOT = 0x57, /// /// Loads the static field at index 0 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDSFLD0 = 0x58, /// /// Loads the static field at index 1 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDSFLD1 = 0x59, /// /// Loads the static field at index 2 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDSFLD2 = 0x5A, /// /// Loads the static field at index 3 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDSFLD3 = 0x5B, /// /// Loads the static field at index 4 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDSFLD4 = 0x5C, /// /// Loads the static field at index 5 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDSFLD5 = 0x5D, /// /// Loads the static field at index 6 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDSFLD6 = 0x5E, /// /// Loads the static field at a specified index onto the evaluation stack. /// The index is represented as a 1-byte unsigned integer. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// [OperandSize(Size = 1)] LDSFLD = 0x5F, /// /// Stores the value on top of the evaluation stack in the static field list at index 0. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STSFLD0 = 0x60, /// /// Stores the value on top of the evaluation stack in the static field list at index 1. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STSFLD1 = 0x61, /// /// Stores the value on top of the evaluation stack in the static field list at index 2. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STSFLD2 = 0x62, /// /// Stores the value on top of the evaluation stack in the static field list at index 3. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STSFLD3 = 0x63, /// /// Stores the value on top of the evaluation stack in the static field list at index 4. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STSFLD4 = 0x64, /// /// Stores the value on top of the evaluation stack in the static field list at index 5. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STSFLD5 = 0x65, /// /// Stores the value on top of the evaluation stack in the static field list at index 6. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STSFLD6 = 0x66, /// /// Stores the value on top of the evaluation stack in the static field list at a specified index. /// The index is represented as a 1-byte unsigned integer. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// [OperandSize(Size = 1)] STSFLD = 0x67, /// /// Loads the local variable at index 0 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDLOC0 = 0x68, /// /// Loads the local variable at index 1 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDLOC1 = 0x69, /// /// Loads the local variable at index 2 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDLOC2 = 0x6A, /// /// Loads the local variable at index 3 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDLOC3 = 0x6B, /// /// Loads the local variable at index 4 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDLOC4 = 0x6C, /// /// Loads the local variable at index 5 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDLOC5 = 0x6D, /// /// Loads the local variable at index 6 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDLOC6 = 0x6E, /// /// Loads the local variable at a specified index onto the evaluation stack. /// The index is represented as a 1-byte unsigned integer. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// [OperandSize(Size = 1)] LDLOC = 0x6F, /// /// Stores the value on top of the evaluation stack in the local variable list at index 0. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STLOC0 = 0x70, /// /// Stores the value on top of the evaluation stack in the local variable list at index 1. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STLOC1 = 0x71, /// /// Stores the value on top of the evaluation stack in the local variable list at index 2. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STLOC2 = 0x72, /// /// Stores the value on top of the evaluation stack in the local variable list at index 3. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STLOC3 = 0x73, /// /// Stores the value on top of the evaluation stack in the local variable list at index 4. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STLOC4 = 0x74, /// /// Stores the value on top of the evaluation stack in the local variable list at index 5. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STLOC5 = 0x75, /// /// Stores the value on top of the evaluation stack in the local variable list at index 6. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STLOC6 = 0x76, /// /// Stores the value on top of the evaluation stack in the local variable list at a specified index. /// The index is represented as a 1-byte unsigned integer. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// [OperandSize(Size = 1)] STLOC = 0x77, /// /// Loads the argument at index 0 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDARG0 = 0x78, /// /// Loads the argument at index 1 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDARG1 = 0x79, /// /// Loads the argument at index 2 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDARG2 = 0x7A, /// /// Loads the argument at index 3 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDARG3 = 0x7B, /// /// Loads the argument at index 4 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDARG4 = 0x7C, /// /// Loads the argument at index 5 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDARG5 = 0x7D, /// /// Loads the argument at index 6 onto the evaluation stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// LDARG6 = 0x7E, /// /// Loads the argument at a specified index onto the evaluation stack. /// The index is represented as a 1-byte unsigned integer. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// [OperandSize(Size = 1)] LDARG = 0x7F, /// /// Stores the value on top of the evaluation stack in the argument slot at index 0. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STARG0 = 0x80, /// /// Stores the value on top of the evaluation stack in the argument slot at index 1. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STARG1 = 0x81, /// /// Stores the value on top of the evaluation stack in the argument slot at index 2. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STARG2 = 0x82, /// /// Stores the value on top of the evaluation stack in the argument slot at index 3. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STARG3 = 0x83, /// /// Stores the value on top of the evaluation stack in the argument slot at index 4. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STARG4 = 0x84, /// /// Stores the value on top of the evaluation stack in the argument slot at index 5. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STARG5 = 0x85, /// /// Stores the value on top of the evaluation stack in the argument slot at index 6. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// STARG6 = 0x86, /// /// Stores the value on top of the evaluation stack in the argument slot at a specified index. /// The index is represented as a 1-byte unsigned integer. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// [OperandSize(Size = 1)] STARG = 0x87, #endregion #region Splice /// /// Creates a new and pushes it onto the stack, and the top item is the length of the buffer. /// If the top item is not an integer, it will be converted to an integer. /// /// new Buffer(a) /// /// The execution will be faulted if: /// 1. The top item cannot be converted to an integer. /// 2. The length is negative or exceeds the maximum item size. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// NEWBUFFER = 0x88, /// /// Copies a range of bytes from one to another. /// Using this opcode will require to dup the destination buffer. /// If the destination start index, source start index or count is not an integer, it will be converted to an integer. /// /// c[d..e].CopyTo(a[b..]); /// /// /// The top 5 items in the stack are(The `count` item is the top item): /// | destination buffer | destination start index | source buffer | source start index | count . /// /// /// The execution will be faulted if: /// 1. the destination start index, source start index or count cannot be converted to integer. /// 2. The destination start index, source start index or count is negative(or converted value is negative). /// 3. The destination start index + count is out of the destination buffer range. /// 4. The source start index + count is out of the source buffer range. /// /// /// Push: 0 item(s) /// Pop: 5 item(s) /// /// MEMCPY = 0x89, /// /// Concatenates two items as a buffer. The result is the first pushed item concatenated with the second pushed item(the top item). /// If item is not a buffer, it will be converted to a buffer(bytes) and then concatenated. /// /// a.concat(b) /// /// /// The execution will be faulted if: /// 1. the total length exceeds the maximum item size. /// 2. One or both items cannot be converted to a buffer. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// CAT = 0x8B, /// /// Pushes a sub-buffer from the source buffer onto the evaluation stack. /// The first pushed item is the source buffer, the second pushed item is the start index, the third pushed item is the count(the top item). /// If the start index or count is not an integer, it will be converted to an integer. /// If the source buffer is not a buffer, it will be converted to a buffer(bytes). /// /// a[b..c] /// /// The execution will be faulted if: /// 1. The start index or count cannot be converted to integer. /// 2. The source buffer cannot be converted to buffer(bytes). /// 3. The start index or count is negative(or converted value is negative). /// 4. The start index + count is out of the source buffer range. /// /// /// Push: 1 item(s) /// Pop: 3 item(s) /// /// SUBSTR = 0x8C, /// /// Keeps only characters left of the specified point in a buffer. /// The first pushed item is the source buffer, the second pushed item is the count(the top item). /// If the count is not an integer, it will be converted to an integer. /// If the source buffer is not a buffer, it will be converted to a buffer(bytes). /// /// a[..b] /// /// The execution will be faulted if: /// 1. The count cannot be converted to integer. /// 2. The source buffer cannot be converted to buffer(bytes). /// 3. The count is negative(or converted value is negative) or out of the source buffer range. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// LEFT = 0x8D, /// /// Keeps only characters right of the specified point in a buffer. /// The first pushed item is the source buffer, the second pushed item is the count(the top item). /// If the count is not an integer, it will be converted to an integer. /// If the source buffer is not a buffer, it will be converted to a buffer(bytes). /// /// a[^b..^0] /// /// The execution will be faulted if: /// 1. The count cannot be converted to integer. /// 2. The source buffer cannot be converted to buffer(bytes). /// 3. The count is negative(or converted value is negative) or out of the source buffer range. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// RIGHT = 0x8E, #endregion #region Bitwise logic /// /// Pops the top stack item and pushes the result of flipping all the bits in the item. /// If the item is not an integer, it will be converted to an integer. /// /// ~a /// /// The execution will be faulted if the item cannot be converted to integer. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// INVERT = 0x90, /// /// Pops the top two stack items and pushes the result of the boolean and between each bit in the items. /// If the items are not integers, they will be converted to integers. /// /// a&b /// /// The execution will be faulted if the items cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// AND = 0x91, /// /// Pops the top two stack items and pushes the result of the boolean or between each bit in the items. /// If the inputs are not integers, they will be converted to integers. /// /// a|b /// /// The execution will be faulted if the items cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// OR = 0x92, /// /// Pops the top two stack items and pushes the result of the boolean exclusive or between each bit in the items. /// If the items are not integers, they will be converted to integers. /// /// a^b /// /// The execution will be faulted if the items cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// XOR = 0x93, /// /// Pops the top two stack items and pushes true if the items are exactly equal, false otherwise. /// /// a.Equals(b) /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// EQUAL = 0x97, /// /// Pops the top two stack items and pushes true if the items are not equal, false otherwise. /// /// !a.Equals(b) /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// NOTEQUAL = 0x98, #endregion #region Arithmetic /// /// Pops the top stack item and pushes the sign of the item. /// If the item is negative, push -1; if positive, push 1; if zero, push 0. /// If the item is not an integer, it will be converted to an integer. /// /// a.Sign /// /// The execution will be faulted if the item cannot be converted to an integer. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// SIGN = 0x99, /// /// Pops the top stack item and pushes the absolute value of the item. /// If the item is not an integer, it will be converted to an integer. /// /// abs(a) /// /// The execution will be faulted if: /// 1. the item cannot be converted to an integer. /// 2. the item is the minimum integer value. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// ABS = 0x9A, /// /// Pops the top stack item and pushes the negation of the item. /// If the input is not an integer, it will be converted to an integer. /// /// -a /// /// The execution will be faulted if the item cannot be converted to an integer. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// NEGATE = 0x9B, /// /// Pops the top stack item and pushes the result of adding 1 to the item. /// If the input is not an integer, it will be converted to an integer. /// /// a+1 /// /// The execution will be faulted if the item cannot be converted to an integer. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// INC = 0x9C, /// /// Pops the top stack item and pushes the result of subtracting 1 from the item. /// If the input is not an integer, it will be converted to an integer. /// /// a-1 /// /// The execution will be faulted if the item cannot be converted to an integer. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// DEC = 0x9D, /// /// Pops the top two stack items and pushes the result of adding the first pushed item to the second pushed item(the top item). /// If the inputs are not integers, they will be converted to integers. /// /// a+b /// /// The execution will be faulted if the inputs cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// ADD = 0x9E, /// /// Pops the top two stack items and pushes the result of subtracting the second pushed item(the top item) from the first pushed item. /// If the inputs are not integers, they will be converted to integers. /// /// a-b /// /// The execution will be faulted if the inputs cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// SUB = 0x9F, /// /// Pops the top two stack items and pushes the result of multiplying the first pushed item by the second pushed item(the top item). /// If the inputs are not integers, they will be converted to integers. /// /// a*b /// /// The execution will be faulted if the inputs cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// MUL = 0xA0, /// /// Pops the top two stack items and pushes the result of dividing the first pushed item by the second pushed item(the top item). /// The first pushed item is the dividend, the second pushed item is the divisor(the top item). /// If the inputs are not integers, they will be converted to integers. /// /// a/b /// /// The execution will be faulted if: /// 1. the inputs cannot be converted to integers. /// 2. the divisor is zero. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// DIV = 0xA1, /// /// Pops the top two stack items and pushes the remainder after dividing a by b. /// The first pushed item is the dividend, the second pushed item is the divisor(the top item). /// If the inputs are not integers, they will be converted to integers. /// /// a%b /// /// The execution will be faulted if: /// 1. the inputs cannot be converted to integers. /// 2. the divisor is zero. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// MOD = 0xA2, /// /// Pops the top two stack items and pushes the result of raising value to the exponent power. /// The first pushed item is the exponent, the second pushed item is the value(the top item). /// If the inputs are not integers, they will be converted to integers. /// /// a^b /// /// The execution will be faulted if the inputs cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// POW = 0xA3, /// /// Pops the top stack item and pushes the square root of the item. /// If the input is not an integer, it will be converted to an integer. /// /// sqrt(a) /// /// The execution will be faulted if: /// 1. the input cannot be converted to an integer. /// 2. the input is negative. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// SQRT = 0xA4, /// /// Performs modulus division on a number multiplied by another number. /// The third pushed item is the modulus. /// If the inputs are not integers, they will be converted to integers. /// /// a*b%c /// /// The execution will be faulted if: /// 1. the inputs cannot be converted to integers. /// 2. the modulus is zero. /// /// /// Push: 1 item(s) /// Pop: 3 item(s) /// /// MODMUL = 0xA5, /// /// Performs modulus division on a number raised to the power of another number. /// If the exponent is -1, it will have the calculation of the modular inverse. /// /// The third pushed item is the modulus, the second pushed item is the exponent, the first pushed item is the value(the top item). /// If the inputs are not integers, they will be converted to integers. /// /// modpow(a, b, c) /// /// The execution will be faulted if: /// 1. the inputs cannot be converted to integers. /// 2. the modulus is zero. /// 3. the exponent is negative and not -1. /// /// /// Push: 1 item(s) /// Pop: 3 item(s) /// /// MODPOW = 0xA6, /// /// Pops the top two stack items and shifts the first pushed item left by the second pushed item(the top item) bits, preserving sign. /// If the inputs are not integers, they will be converted to integers. /// /// a<<b /// /// The execution will be faulted if: /// 1. the inputs cannot be converted to integers. /// 2. the shift amount is negative or out of the limit. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// SHL = 0xA8, /// /// Pops the top two stack items and shifts the first pushed item right by the second pushed item(the top item) bits, preserving sign. /// If the inputs are not integers, they will be converted to integers. /// /// a>>b /// /// The execution will be faulted if: /// 1. the inputs cannot be converted to integers. /// 2. the shift amount is negative or out of the limit. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// SHR = 0xA9, /// /// Pushes true if the input is false value (false, null, zero), false otherwise. /// /// !a /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// NOT = 0xAA, /// /// Pops the top two stack items and pushes true if both items are true value (true, not null, not zero), false otherwise. /// /// b && a /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// BOOLAND = 0xAB, /// /// Pops the top two stack items and pushes true if either item is true value (true, not null, not zero), false otherwise. /// /// b || a /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// BOOLOR = 0xAC, /// /// Pops the top stack item and pushes true if the item is not 0, false otherwise. /// If the input is not an integer, it will be converted to an integer. /// /// a != 0 /// /// The execution will be faulted if the input cannot be converted to an integer. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// NZ = 0xB1, /// /// Pops the top two stack items and pushes true if the items are equal in number, false otherwise. /// If the inputs are not integers, they will be converted to integers. /// /// b == a /// /// The execution will be faulted if the inputs cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// NUMEQUAL = 0xB3, /// /// Pops the top two stack items and pushes true if the items are not equal in number, false otherwise. /// If the inputs are not integers, they will be converted to integers. /// /// b != a /// /// The execution will be faulted if the inputs cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// NUMNOTEQUAL = 0xB4, /// /// Pops the top two stack items and pushes true if the first pushed item is less than the second pushed item(the top item), false otherwise. /// If the inputs are not integers, they will be converted to integers. /// /// b>a /// /// The execution will be faulted if the inputs cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// LT = 0xB5, /// /// Pops the top two stack items and pushes true if the first pushed item is less than or equal to the second pushed item(the top item), false otherwise. /// If the inputs are not integers, they will be converted to integers. /// /// b>=a /// /// The execution will be faulted if the inputs cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// LE = 0xB6, /// /// Pops the top two stack items and pushes true if the first pushed item is greater than the second pushed item(the top item), false otherwise. /// If the inputs are not integers, they will be converted to integers. /// /// b>a /// /// The execution will be faulted if the inputs cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// GT = 0xB7, /// /// Pops the top two stack items and pushes true if the first pushed item is greater than or equal to the second pushed item(the top item), false otherwise. /// If the inputs are not integers, they will be converted to integers. /// /// b>=a /// /// The execution will be faulted if the inputs cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// GE = 0xB8, /// /// Pops the top two stack items and pushes the minimum of the two items. /// If the inputs are not integers, they will be converted to integers. /// /// min(a, b) /// /// The execution will be faulted if the inputs cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// MIN = 0xB9, /// /// Pops the top two stack items and pushes the maximum of the two items. /// If the inputs are not integers, they will be converted to integers. /// /// max(a, b) /// /// The execution will be faulted if the inputs cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// MAX = 0xBA, /// /// Pops the top three stack items and pushes true if the first pushed item is within the specified range [left, right), false otherwise. /// If the inputs are not integers, they will be converted to integers. /// /// x within [left, right) /// /// The execution will be faulted if the inputs cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: 3 item(s) /// /// WITHIN = 0xBB, #endregion #region Compound-type /// /// A value n is taken from top of main stack. /// The next n*2 items on main stack are removed, put inside n-sized map and this map is put on top of the main stack. /// If the top item is not an integer, it will be converted to an integer. /// /// | value2 | key2 | value1 | key1 | 2 | -> | map{key1 = value1, key2 = value2} | /// The key should be primitive type and if there are the same key, the last one will be used. /// /// The execution will be faulted if: /// 1. the top item cannot be converted to integers. /// 2. Any key is not a primitive type. /// /// /// Push: 1 item(s) /// Pop: 2n+1 item(s) /// /// PACKMAP = 0xBE, /// /// A value n is taken from top of main stack. /// The next n items on main stack are removed, put inside n-sized struct and this struct is put on top of the main stack. /// If the top item is not an integer, it will be converted to an integer. /// /// /// The execution will be faulted if the top item cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: n+1 item(s) /// /// PACKSTRUCT = 0xBF, /// /// A value n is taken from top of main stack. /// The next n items on main stack are removed, put inside n-sized array and this array is put on top of the main stack. /// If the top item is not an integer, it will be converted to an integer. /// /// /// The execution will be faulted if the top item cannot be converted to integers. /// /// /// Push: 1 item(s) /// Pop: n+1 item(s) /// /// PACK = 0xC0, /// /// A collection is removed from top of the main stack. /// Its elements are put on top of the main stack (in reverse order) and the collection size is also put on the main stack. /// /// /// Push: 2n+1 or n+1 item(s) /// Pop: 1 item(s) /// /// UNPACK = 0xC1, /// /// An empty array (with size 0) is put on top of the main stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// NEWARRAY0 = 0xC2, /// /// A value n is taken from top of main stack. A null-filled array with size n is put on top of the main stack. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// NEWARRAY = 0xC3, /// /// An array of type T with size n filled with the default value of type T(false, 0, empty string or null) is put on top of the main stack. /// If the top item is not an integer, it will be converted to an integer. /// /// /// The execution will be faulted if: /// 1. the top item cannot be converted to integer. /// 2. the type operand is not a valid stack item type. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// [OperandSize(Size = 1)] NEWARRAY_T = 0xC4, /// /// An empty struct (with size 0) is put on top of the main stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// NEWSTRUCT0 = 0xC5, /// /// A value n is taken from top of main stack. A null-filled struct with size n is put on top of the main stack. /// If the top item is not an integer, it will be converted to an integer. /// /// /// The execution will be faulted if the top item cannot be converted to integer. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// NEWSTRUCT = 0xC6, /// /// A empty map is created and put on top of the main stack. /// /// /// Push: 1 item(s) /// Pop: 0 item(s) /// /// NEWMAP = 0xC8, /// /// Pop the top item and push its size. The top item should be an array, map, buffer or primitive type. /// If the top item is an array or map, push its count. /// If the top item is a buffer or primitive type, push its size(in bytes). /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// SIZE = 0xCA, /// /// An input index n (or key) and an array (map, buffer or string) are removed from the top of the main stack. /// Pushes true to the stack if array[n](map[key], or the n-th byte of buffer/string) exist, and false otherwise. /// /// If the target is an array, buffer or string, the index will be converted to an integer. /// The index is the second pushed item(the top item), and the tartget is the first pushed item. /// /// /// The execution will be faulted if: /// 1. The target is an array, buffer or string and the index cannot be converted to integer or is out of range. /// 2. The target is a map and the key is not a primitive type. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// HASKEY = 0xCB, /// /// A map is taken from top of the main stack. The keys of this map are put on top of the main stack. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// KEYS = 0xCC, /// /// An array or map is taken from top of the main stack. The values of this array or map are put on top of the main stack. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// VALUES = 0xCD, /// /// An input index n (or key) and an array (map, buffer or primitive type) are taken from main stack. /// Element array[n], or map[n], or buffer[n], or the n-th byte of primitive type(converted to integer) is put on top of the main stack. /// /// If the target is an array, buffer or primitive type, the index will be converted to an integer. /// The index is the second pushed item(the top item), and the tartget is the first pushed item. /// /// /// The execution will be faulted if: /// 1. The target is an array, buffer or primitive type and the index cannot be converted to integer or is out of range. /// 2. The target is a map and the key is not a primitive type. /// /// /// Push: 1 item(s) /// Pop: 2 item(s) /// /// PICKITEM = 0xCE, /// /// The item on top of main stack is removed and appended to the second item on top of the main stack. /// When we use this opcode, we should dup the second item on top of the main stack before using it. /// /// a a b -> a.concat(b) /// /// /// Push: 0 item(s) /// Pop: 2 item(s) /// /// APPEND = 0xCF, /// /// A value, index n (or key) and an array (or buffer, map) are taken from main stack. /// Attribution array[n] = value (or buffer[n] = value, map[key] = value) is performed. /// /// The `value` is the third pushed item(the top item), the `n` or `key` is the second pushed item, and target is the first pushed item. /// If the target is an array or buffer, the index will be converted to an integer. /// If the tartget is a buffer, the value should within [-128, 255]. /// /// /// Push: 1 item(s) /// Pop: 3 item(s) /// /// SETITEM = 0xD0, /// /// An array or buffer is removed from the top of the main stack and its elements are reversed. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// REVERSEITEMS = 0xD1, /// /// An input index n (or key) and an array (or map)are removed from the top of the main stack. /// Element array[n] (or map[key]) is removed. /// /// The index or key is the second pushed item(the top item), and the array or map is the first pushed item. /// If the target is an array, the index will be converted to an integer. /// /// /// The execution will be faulted if: /// 1. The target is an array and the index cannot be converted to integer or is out of range. /// 2. The target is a map and the key is not a primitive type. /// /// /// Push: 0 item(s) /// Pop: 2 item(s) /// /// REMOVE = 0xD2, /// /// Remove all the items from the compound-type. /// Using this opcode will need to dup the compound-type before using it. /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// CLEARITEMS = 0xD3, /// /// Remove the last element from an array, and push it onto the stack. /// Using this opcode will need to dup the array before using it. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// POPITEM = 0xD4, #endregion #region Types /// /// Pop the top item and push a bool value indicating whether the item is null. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// ISNULL = 0xD8, /// /// Pop the top item and push a bool value indicating whether the item is of the specified type. /// /// /// The execution will be faulted if the type operand(uint8) is invalid. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// [OperandSize(Size = 1)] ISTYPE = 0xD9, /// /// Pop the top item and convert it to the specified type, then push the converted item. /// /// /// The execution will be faulted if: /// 1. The top item cannot convert to the specified type. /// 2. The type operand(uint8) is invalid. /// /// /// Push: 1 item(s) /// Pop: 1 item(s) /// /// [OperandSize(Size = 1)] CONVERT = 0xDB, #endregion #region Extensions /// /// Pops the top stack item. Then, turns the vm state to FAULT immediately, and cannot be caught. /// The top stack value is used as reason. The top item should be string or can be converted to string. /// /// new Exception(a) /// /// /// Push: 0 item(s) /// Pop: 1 item(s) /// /// ABORTMSG = 0xE0, /// /// Pops the top two stack items. /// If the second-to-top stack value is false value (false, null, zero), exits the vm execution and sets the vm state to FAULT. /// In this case, the top stack value is used as reason for the exit. Otherwise, it is ignored. /// /// The top item should be string or can be converted to string. /// /// /// The execution will be faulted if the top item is not string or cannot be converted to string. /// /// /// Push: 0 item(s) /// Pop: 2 item(s) /// /// ASSERTMSG = 0xE1 #endregion } ================================================ FILE: src/Neo.VM/OperandSizeAttribute.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // OperandSizeAttribute.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; namespace Neo.VM; /// /// Indicates the operand length of an . /// [AttributeUsage(AttributeTargets.Field, AllowMultiple = false)] public class OperandSizeAttribute : Attribute { /// /// When it is greater than 0, indicates the size of the operand. /// public int Size { get; set; } /// /// When it is greater than 0, indicates the size prefix of the operand. /// public int SizePrefix { get; set; } } ================================================ FILE: src/Neo.VM/RCVersion.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // RCVersion.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. namespace Neo.VM; public enum RCVersion { V1 = 0, V2 = 1, } ================================================ FILE: src/Neo.VM/ReferenceCounter.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // ReferenceCounter.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.StronglyConnectedComponents; using Neo.VM.Types; using System.Collections.Generic; using System.Linq; using System.Runtime.CompilerServices; namespace Neo.VM; /// /// Used for reference counting of objects in the VM. /// public sealed class ReferenceCounter : IReferenceCounter { private readonly ExecutionEngineLimits _limits; // If set to true, all items will be tracked regardless of their type. private const bool TrackAllItems = false; // Stores items that are being tracked for references. // Only CompoundType and Buffer items are tracked. private readonly HashSet _trackedItems = new(ReferenceEqualityComparer.Instance); // Stores items that have zero references. private readonly HashSet _zeroReferred = new(ReferenceEqualityComparer.Instance); // Caches strongly connected components for optimization. private LinkedList>? _cachedComponents; // Keeps the total count of references. private int _referencesCount = 0; public RCVersion Version { get; } = RCVersion.V1; /// public int Count => _referencesCount; public ReferenceCounter(ExecutionEngineLimits? limits = null) { _limits = limits ?? ExecutionEngineLimits.Default; } /// /// Determines if an item needs to be tracked based on its type. /// /// The item to check. /// True if the item needs to be tracked, otherwise false. [MethodImpl(MethodImplOptions.AggressiveInlining)] private static bool NeedTrack(StackItem item) { // Track all items if TrackAllItems is true. #pragma warning disable CS0162 if (TrackAllItems) return true; #pragma warning restore CS0162 // Track the item if it is a CompoundType or Buffer. if (item is CompoundType or Buffer) return true; return false; } /// public void AddReference(StackItem item, CompoundType parent) { // Increment the reference count. _referencesCount++; // If the item doesn't need to be tracked, return early. // Only track CompoundType and Buffer items. if (!NeedTrack(item)) return; // Invalidate the cached components since the tracked items are changing. _cachedComponents = null; // Add the item to the set of tracked items. _trackedItems.Add(item); // Initialize the ObjectReferences dictionary if it is null. item.ObjectReferences ??= new Dictionary(ReferenceEqualityComparer.Instance); // Add the parent to the item's ObjectReferences dictionary and increment its reference count. if (!item.ObjectReferences.TryGetValue(parent, out var pEntry)) { pEntry = new StackItem.ObjectReferenceEntry(parent); item.ObjectReferences.Add(parent, pEntry); } pEntry.References++; } /// public void AddStackReference(StackItem item, int count = 1) { // Increment the reference count by the specified count. _referencesCount += count; // If the item doesn't need to be tracked, return early. if (!NeedTrack(item)) return; // Add the item to the set of tracked items and to the cached components if needed. if (_trackedItems.Add(item)) _cachedComponents?.AddLast(new HashSet(ReferenceEqualityComparer.Instance) { item }); // Increment the item's stack references by the specified count. item.StackReferences += count; // Remove the item from the _zeroReferred set since it now has references. _zeroReferred.Remove(item); } /// public void AddZeroReferred(StackItem item) { // Add the item to the _zeroReferred set. _zeroReferred.Add(item); // If the item doesn't need to be tracked, return early. if (!NeedTrack(item)) return; // Add the item to the cached components and the set of tracked items. _cachedComponents?.AddLast(new HashSet(ReferenceEqualityComparer.Instance) { item }); _trackedItems.Add(item); } /// public void CheckPostExecution() { if (Count < _limits.MaxStackSize) return; if (CheckZeroReferred() > _limits.MaxStackSize) throw new System.InvalidOperationException($"MaxStackSize exceed: {Count}/{_limits.MaxStackSize}"); } /// /// Checks and processes items that have zero references. /// /// This method is used to check items in the zero-referred list and clean up those that are no longer needed. /// It uses Tarjan's algorithm to find strongly connected components and remove those with no references. /// /// Use this method periodically to clean up items with zero references and free up memory. /// /// The current reference count. public int CheckZeroReferred() { // If there are items with zero references, process them. if (_zeroReferred.Count > 0) { // Clear the zero_referred set since we are going to process all of them. _zeroReferred.Clear(); // If cached components are null, we need to recompute the strongly connected components (SCCs). if (_cachedComponents is null) { // Create a new Tarjan object and invoke it to find all SCCs in the tracked_items graph. Tarjan tarjan = new(_trackedItems); _cachedComponents = tarjan.Invoke(); } // Reset all tracked items' Tarjan algorithm-related fields (DFN, LowLink, and OnStack). foreach (StackItem item in _trackedItems) item.Reset(); // Process each SCC in the cached_components list. for (var node = _cachedComponents.First; node != null;) { var component = node.Value; bool onStack = false; // Check if any item in the SCC is still on the stack. foreach (StackItem item in component) { // An item is considered 'on stack' if it has stack references or if its parent items are still on stack. if (item.StackReferences > 0 || item.ObjectReferences?.Values.Any(p => p.References > 0 && p.Item.OnStack) == true) { onStack = true; break; } } // If any item in the component is on stack, mark all items in the component as on stack. if (onStack) { foreach (StackItem item in component) item.OnStack = true; node = node.Next; } else { // Otherwise, remove the component and clean up the items. foreach (StackItem item in component) { _trackedItems.Remove(item); // If the item is a CompoundType, adjust the reference count and clean up its sub-items. if (item is CompoundType compound) { // Decrease the reference count by the number of sub-items. _referencesCount -= compound.SubItemsCount; foreach (StackItem subitem in compound.SubItems) { // Skip sub-items that are in the same component or don't need tracking. if (component.Contains(subitem)) continue; if (!NeedTrack(subitem)) continue; // Remove the parent reference from the sub-item. subitem.ObjectReferences!.Remove(compound); } } // Perform cleanup for the item. item.Cleanup(); } // Move to the next component and remove the current one from the cached_components list. var nodeToRemove = node; node = node.Next; _cachedComponents.Remove(nodeToRemove); } } } // Return the current total reference count. return _referencesCount; } /// public void RemoveReference(StackItem item, CompoundType parent) { // Decrement the reference count. _referencesCount--; // If the item doesn't need to be tracked, return early. if (!NeedTrack(item)) return; // Invalidate the cached components since the tracked items are changing. _cachedComponents = null; // Decrement the reference count for the parent in the item's ObjectReferences dictionary. item.ObjectReferences![parent].References--; // If the item has no stack references, add it to the zero_referred set. if (item.StackReferences == 0) _zeroReferred.Add(item); } /// public void RemoveStackReference(StackItem item) { // Decrement the reference count. _referencesCount--; // If the item doesn't need to be tracked, return early. if (!NeedTrack(item)) return; // Decrement the item's stack references and add it to the zero_referred set if it has no references. if (--item.StackReferences == 0) _zeroReferred.Add(item); } } ================================================ FILE: src/Neo.VM/ReferenceCounterV2.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // ReferenceCounterV2.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; using System; namespace Neo.VM; /// /// Used for reference counting of objects in the VM. /// public sealed class ReferenceCounterV2 : IReferenceCounter { public RCVersion Version { get; } = RCVersion.V2; private readonly ExecutionEngineLimits _limits; // Keeps the total count of references. private int _referencesCount = 0; /// public int Count => _referencesCount; public ReferenceCounterV2(ExecutionEngineLimits? limits = null) { _limits = limits ?? ExecutionEngineLimits.Default; } /// public void AddReference(StackItem item, CompoundType parent) { throw new NotSupportedException(); } /// public void AddStackReference(StackItem item, int count = 1) { // Increment the reference count by the specified count. _referencesCount += count; if (item is CompoundType compoundType) { // Increment the item's stack references by the specified count. compoundType.StackReferences += count; if (compoundType.StackReferences == count) { foreach (var subItem in compoundType.SubItems) { AddStackReference(subItem); } } } } /// public void AddZeroReferred(StackItem item) { throw new NotSupportedException(); } /// public void CheckPostExecution() { if (Count > _limits.MaxStackSize) throw new InvalidOperationException($"MaxStackSize exceed: {Count}/{_limits.MaxStackSize}"); } /// public int CheckZeroReferred() { throw new NotSupportedException(); } /// public void RemoveReference(StackItem item, CompoundType parent) { throw new NotSupportedException(); } /// public void RemoveStackReference(StackItem item) { // Decrease the reference count. _referencesCount--; if (item is CompoundType compoundType) { // Decrease the item's stack references. compoundType.StackReferences--; if (compoundType.StackReferences == 0) { foreach (var subItem in compoundType.SubItems) { RemoveStackReference(subItem); } } } } } ================================================ FILE: src/Neo.VM/ReferenceEqualityComparer.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // ReferenceEqualityComparer.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System.Collections.Generic; using System.Runtime.CompilerServices; namespace Neo.VM; #if !NET5_0_OR_GREATER // https://github.dev/dotnet/runtime/blob/main/src/libraries/System.Private.CoreLib/src/System/Collections/Generic/ReferenceEqualityComparer.cs public sealed class ReferenceEqualityComparer : IEqualityComparer, System.Collections.IEqualityComparer { private ReferenceEqualityComparer() { } public static ReferenceEqualityComparer Instance { get; } = new ReferenceEqualityComparer(); public new bool Equals(object? x, object? y) => ReferenceEquals(x, y); public int GetHashCode(object? obj) => RuntimeHelpers.GetHashCode(obj!); } #endif ================================================ FILE: src/Neo.VM/Script.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Script.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; using System; using System.Collections.Generic; using System.Diagnostics; using System.Runtime.CompilerServices; namespace Neo.VM; /// /// Represents the script executed in the VM. /// [DebuggerDisplay("Length={Length}")] public class Script { private int _hashCode = 0; private readonly ReadOnlyMemory _value; private readonly bool _strictMode; private readonly Dictionary _instructions = []; /// /// Empty script /// public static Script Empty { get; } = new Script(ReadOnlyMemory.Empty); /// /// The length of the script. /// public int Length { get; } /// /// Gets the at the specified index. /// /// The index to locate. /// The at the specified index. public OpCode this[int index] { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { return (OpCode)_value.Span[index]; } } /// /// Initializes a new instance of the class. /// /// The bytecodes of the script. public Script(ReadOnlyMemory script) : this(script, false) { } /// /// Initializes a new instance of the class. /// /// The bytecodes of the script. /// /// Indicates whether strict mode is enabled. /// In strict mode, the script will be checked, but the loading speed will be slower. /// /// In strict mode, the script was found to contain bad instructions. public Script(ReadOnlyMemory script, bool strictMode) { _value = script; Length = _value.Length; if (strictMode) { for (var ip = 0; ip < script.Length; ip += GetInstruction(ip).Size) { } foreach (var (ip, instruction) in _instructions) { switch (instruction.OpCode) { case OpCode.JMP: case OpCode.JMPIF: case OpCode.JMPIFNOT: case OpCode.JMPEQ: case OpCode.JMPNE: case OpCode.JMPGT: case OpCode.JMPGE: case OpCode.JMPLT: case OpCode.JMPLE: case OpCode.CALL: case OpCode.ENDTRY: if (!_instructions.ContainsKey(checked(ip + instruction.TokenI8))) throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}"); break; case OpCode.PUSHA: case OpCode.JMP_L: case OpCode.JMPIF_L: case OpCode.JMPIFNOT_L: case OpCode.JMPEQ_L: case OpCode.JMPNE_L: case OpCode.JMPGT_L: case OpCode.JMPGE_L: case OpCode.JMPLT_L: case OpCode.JMPLE_L: case OpCode.CALL_L: case OpCode.ENDTRY_L: if (!_instructions.ContainsKey(checked(ip + instruction.TokenI32))) throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}"); break; case OpCode.TRY: if (!_instructions.ContainsKey(checked(ip + instruction.TokenI8))) throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}"); if (!_instructions.ContainsKey(checked(ip + instruction.TokenI8_1))) throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}"); break; case OpCode.TRY_L: if (!_instructions.ContainsKey(checked(ip + instruction.TokenI32))) throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}"); if (!_instructions.ContainsKey(checked(ip + instruction.TokenI32_1))) throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}"); break; case OpCode.NEWARRAY_T: case OpCode.ISTYPE: case OpCode.CONVERT: var type = (StackItemType)instruction.TokenU8; #if NET5_0_OR_GREATER if (!Enum.IsDefined(type)) #else if (!Enum.IsDefined(typeof(StackItemType), type)) #endif throw new BadScriptException(); if (instruction.OpCode != OpCode.NEWARRAY_T && type == StackItemType.Any) throw new BadScriptException($"ip: {ip}, opcode: {instruction.OpCode}"); break; } } } _strictMode = strictMode; } /// /// Get the at the specified position. /// /// The position to get the . /// The at the specified position. /// In strict mode, the was not found at the specified position. [MethodImpl(MethodImplOptions.AggressiveInlining)] public Instruction GetInstruction(int ip) { if (!_instructions.TryGetValue(ip, out var instruction)) { #if NET5_0_OR_GREATER ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(ip, Length); #else if (ip >= Length) throw new ArgumentOutOfRangeException(nameof(ip)); #endif if (_strictMode) throw new ArgumentException($"Instruction not found at position {ip} in strict mode.", nameof(ip)); instruction = new Instruction(_value, ip); _instructions.Add(ip, instruction); } return instruction; } public static implicit operator ReadOnlyMemory(Script script) => script._value; public static implicit operator Script(ReadOnlyMemory script) => new(script); public static implicit operator Script(byte[] script) => new(script); public override int GetHashCode() { if (_hashCode == 0) { _hashCode = HashCode.Combine(_value.Span.XxHash3_32()); } return _hashCode; } } ================================================ FILE: src/Neo.VM/ScriptBuilder.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // ScriptBuilder.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.IO; using System.Numerics; namespace Neo.VM; /// /// A helper class for building scripts. /// public class ScriptBuilder : IDisposable { private readonly MemoryStream _stream; private readonly BinaryWriter _writer; /// /// The length of the script. /// public int Length => (int)_stream.Position; /// /// Initializes a new instance of the class. /// /// The initial capacity of the script. /// /// Thrown when is negative. /// public ScriptBuilder(int initialCapacity = 0) { if (initialCapacity < 0) throw new ArgumentOutOfRangeException(nameof(initialCapacity), "cannot be negative"); _stream = new MemoryStream(initialCapacity); _writer = new BinaryWriter(_stream); } public void Dispose() { _writer.Dispose(); _stream.Dispose(); GC.SuppressFinalize(this); } /// /// Emits an with the specified and operand. /// /// The to be emitted. /// The operand to be emitted. /// A reference to this instance after the emit operation has completed. public ScriptBuilder Emit(OpCode opcode, ReadOnlySpan operand = default) { _writer.Write((byte)opcode); _writer.Write(operand); return this; } /// /// Emits a call with the specified offset. /// /// The offset to be called. /// A reference to this instance after the emit operation has completed. public ScriptBuilder EmitCall(int offset) { if (offset < sbyte.MinValue || offset > sbyte.MaxValue) return Emit(OpCode.CALL_L, BitConverter.GetBytes(offset)); else return Emit(OpCode.CALL, new[] { (byte)offset }); } /// /// Emits a jump with the specified offset. /// /// The to be emitted. It must be a jump /// The offset to jump. /// A reference to this instance after the emit operation has completed. public ScriptBuilder EmitJump(OpCode opcode, int offset) { if (opcode < OpCode.JMP || opcode > OpCode.JMPLE_L) throw new ArgumentOutOfRangeException(nameof(opcode)); if ((int)opcode % 2 == 0 && (offset < sbyte.MinValue || offset > sbyte.MaxValue)) opcode += 1; if ((int)opcode % 2 == 0) return Emit(opcode, new[] { (byte)offset }); else return Emit(opcode, BitConverter.GetBytes(offset)); } /// /// Emits a push with the specified number. /// /// The number to be pushed. /// A reference to this instance after the emit operation has completed. public ScriptBuilder EmitPush(BigInteger value) { if (value >= -1 && value <= 16) return Emit(OpCode.PUSH0 + (byte)(int)value); Span buffer = stackalloc byte[32]; if (!value.TryWriteBytes(buffer, out int bytesWritten, isUnsigned: false, isBigEndian: false)) throw new ArgumentOutOfRangeException(nameof(value)); return bytesWritten switch { 1 => Emit(OpCode.PUSHINT8, PadRight(buffer, bytesWritten, 1, value.Sign < 0)), 2 => Emit(OpCode.PUSHINT16, PadRight(buffer, bytesWritten, 2, value.Sign < 0)), <= 4 => Emit(OpCode.PUSHINT32, PadRight(buffer, bytesWritten, 4, value.Sign < 0)), <= 8 => Emit(OpCode.PUSHINT64, PadRight(buffer, bytesWritten, 8, value.Sign < 0)), <= 16 => Emit(OpCode.PUSHINT128, PadRight(buffer, bytesWritten, 16, value.Sign < 0)), <= 32 => Emit(OpCode.PUSHINT256, PadRight(buffer, bytesWritten, 32, value.Sign < 0)), _ => throw new ArgumentOutOfRangeException(nameof(value), "Invalid value: BigInteger is too large"), }; } /// /// Emits a push with the specified boolean value. /// /// The value to be pushed. /// A reference to this instance after the emit operation has completed. public ScriptBuilder EmitPush(bool value) { return Emit(value ? OpCode.PUSHT : OpCode.PUSHF); } /// /// Emits a push with the specified data. /// /// The data to be pushed. /// A reference to this instance after the emit operation has completed. public ScriptBuilder EmitPush(ReadOnlySpan data) { if (data.Length < 0x100) { Emit(OpCode.PUSHDATA1); _writer.Write((byte)data.Length); _writer.Write(data); } else if (data.Length < 0x10000) { Emit(OpCode.PUSHDATA2); _writer.Write((ushort)data.Length); _writer.Write(data); } else// if (data.Length < 0x100000000L) { Emit(OpCode.PUSHDATA4); _writer.Write(data.Length); _writer.Write(data); } return this; } /// /// Emits a push with the specified . /// /// The to be pushed. /// A reference to this instance after the emit operation has completed. public ScriptBuilder EmitPush(string data) { return EmitPush(data.ToStrictUtf8Bytes()); } /// /// Emits raw script. /// /// The raw script to be emitted. /// A reference to this instance after the emit operation has completed. public ScriptBuilder EmitRaw(ReadOnlySpan script = default) { _writer.Write(script); return this; } /// /// Emits an with . /// /// The operand of . /// A reference to this instance after the emit operation has completed. public ScriptBuilder EmitSysCall(uint api) { return Emit(OpCode.SYSCALL, BitConverter.GetBytes(api)); } /// /// Converts the value of this instance to a byte array. /// /// A byte array contains the script. public byte[] ToArray() { _writer.Flush(); return _stream.ToArray(); } private static ReadOnlySpan PadRight(Span buffer, int dataLength, int padLength, bool negative) { byte pad = negative ? (byte)0xff : (byte)0; for (int x = dataLength; x < padLength; x++) buffer[x] = pad; return buffer[..padLength]; } } ================================================ FILE: src/Neo.VM/Slot.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Slot.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; using System.Collections; using System.Collections.Generic; using Array = System.Array; namespace Neo.VM; /// /// Used to store local variables, arguments and static fields in the VM. /// public class Slot : IReadOnlyList { private readonly IReferenceCounter _referenceCounter; private readonly StackItem[] _items; /// /// Gets the item at the specified index in the slot. /// /// The zero-based index of the item to get. /// The item at the specified index in the slot. public StackItem this[int index] { get { return _items[index]; } internal set { ref var oldValue = ref _items[index]; _referenceCounter.RemoveStackReference(oldValue); oldValue = value; _referenceCounter.AddStackReference(value); } } /// /// Gets the number of items in the slot. /// public int Count => _items.Length; /// /// Creates a slot containing the specified items. /// /// The items to be contained. /// The reference counter to be used. public Slot(StackItem[] items, IReferenceCounter referenceCounter) { _referenceCounter = referenceCounter; _items = items; foreach (StackItem item in items) referenceCounter.AddStackReference(item); } /// /// Create a slot of the specified size. /// /// Indicates the number of items contained in the slot. /// The reference counter to be used. public Slot(int count, IReferenceCounter referenceCounter) { _referenceCounter = referenceCounter; _items = new StackItem[count]; Array.Fill(_items, StackItem.Null); referenceCounter.AddStackReference(StackItem.Null, count); } internal void ClearReferences() { foreach (StackItem item in _items) _referenceCounter.RemoveStackReference(item); } IEnumerator IEnumerable.GetEnumerator() { foreach (StackItem item in _items) yield return item; } IEnumerator IEnumerable.GetEnumerator() { return _items.GetEnumerator(); } } ================================================ FILE: src/Neo.VM/StronglyConnectedComponents/Tarjan.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Tarjan.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Collections.Generic; using T = Neo.VM.Types.StackItem; namespace Neo.VM.StronglyConnectedComponents; class Tarjan { private readonly IEnumerable vertexs; private readonly LinkedList> components = new(); private readonly Stack stack = new(); private int index = 0; public Tarjan(IEnumerable vertexs) { this.vertexs = vertexs; } public LinkedList> Invoke() { foreach (var v in vertexs) { if (v.DFN < 0) { StrongConnectNonRecursive(v); } } return components; } private void StrongConnect(T v) { v.DFN = v.LowLink = ++index; stack.Push(v); v.OnStack = true; foreach (T w in v.Successors) { if (w.DFN < 0) { StrongConnect(w); v.LowLink = Math.Min(v.LowLink, w.LowLink); } else if (w.OnStack) { v.LowLink = Math.Min(v.LowLink, w.DFN); } } if (v.LowLink == v.DFN) { HashSet scc = new(ReferenceEqualityComparer.Instance); T w; do { w = stack.Pop(); w.OnStack = false; scc.Add(w); } while (v != w); components.AddLast(scc); } } private void StrongConnectNonRecursive(T v) { Stack<(T node, T?, IEnumerator?, int)> sstack = new(); sstack.Push((v, null, null, 0)); while (sstack.TryPop(out var state)) { v = state.node; var (_, w, s, n) = state; switch (n) { case 0: v.DFN = v.LowLink = ++index; stack.Push(v); v.OnStack = true; s = v.Successors.GetEnumerator(); goto case 2; case 1: v.LowLink = Math.Min(v.LowLink, w!.LowLink); goto case 2; case 2: while (s!.MoveNext()) { w = s.Current; if (w.DFN < 0) { sstack.Push((v, w, s, 1)); v = w; goto case 0; } else if (w.OnStack) { v.LowLink = Math.Min(v.LowLink, w.DFN); } } if (v.LowLink == v.DFN) { HashSet scc = new(ReferenceEqualityComparer.Instance); do { w = stack.Pop(); w.OnStack = false; scc.Add(w); } while (v != w); components.AddLast(scc); } break; } } } } ================================================ FILE: src/Neo.VM/Types/Array.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Array.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Collections; using System.Collections.Generic; using System.Runtime.CompilerServices; namespace Neo.VM.Types; /// /// Represents an array or a complex object in the VM. /// public class Array : CompoundType, IReadOnlyList { protected readonly List InnerList; /// /// Get or set item in the array. /// /// The index of the item in the array. /// The item at the specified index. public StackItem this[int index] { [MethodImpl(MethodImplOptions.AggressiveInlining)] get => InnerList[index]; set { if (IsReadOnly) throw new InvalidOperationException("The object is readonly."); ReferenceCounter?.RemoveReference(InnerList[index], this); InnerList[index] = value; if (ReferenceCounter != null && value is CompoundType { ReferenceCounter: null }) { throw new InvalidOperationException("Can not set a CompoundType without a ReferenceCounter."); } ReferenceCounter?.AddReference(value, this); } } /// /// The number of items in the array. /// public override int Count => InnerList.Count; public override IEnumerable SubItems => InnerList; public override int SubItemsCount => InnerList.Count; public override StackItemType Type => StackItemType.Array; /// /// Create an array containing the specified items. /// /// The items to be included in the array. public Array(IEnumerable? items = null) : this(null, items) { } /// /// Create an array containing the specified items. And make the array use the specified . /// /// The to be used by this array. /// The items to be included in the array. public Array(IReferenceCounter? referenceCounter, IEnumerable? items = null) : base(referenceCounter) { InnerList = items switch { null => new List(), List list => list, _ => new List(items) }; if (referenceCounter?.Version != RCVersion.V1) return; foreach (var item in InnerList) { if (item is CompoundType { ReferenceCounter: null }) { throw new InvalidOperationException("Can not set a CompoundType without a ReferenceCounter."); } referenceCounter.AddReference(item, this); } } /// /// Add a new item at the end of the array. /// /// The item to be added. public void Add(StackItem item) { if (IsReadOnly) throw new InvalidOperationException("The array is readonly, can not add item."); InnerList.Add(item); if (ReferenceCounter == null) return; if (item is CompoundType { ReferenceCounter: null }) { throw new InvalidOperationException("Can not set a CompoundType without a ReferenceCounter."); } ReferenceCounter.AddReference(item, this); } public override void Clear() { if (IsReadOnly) throw new InvalidOperationException("The array is readonly, can not clear."); if (ReferenceCounter is not null) foreach (StackItem item in InnerList) ReferenceCounter.RemoveReference(item, this); InnerList.Clear(); } public override StackItem ConvertTo(StackItemType type) { if (Type == StackItemType.Array && type == StackItemType.Struct) return new Struct(ReferenceCounter, new List(InnerList)); return base.ConvertTo(type); } internal sealed override StackItem DeepCopy(Dictionary refMap, bool asImmutable) { if (refMap.TryGetValue(this, out StackItem? mappedItem)) return mappedItem; Array result = this is Struct ? new Struct(ReferenceCounter) : new Array(ReferenceCounter); refMap.Add(this, result); foreach (StackItem item in InnerList) result.Add(item.DeepCopy(refMap, asImmutable)); result.IsReadOnly = IsReadOnly || asImmutable; return result; } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } public IEnumerator GetEnumerator() { return InnerList.GetEnumerator(); } /// /// Remove the item at the specified index. /// /// The index of the item to be removed. public void RemoveAt(int index) { if (IsReadOnly) throw new InvalidOperationException("The array is readonly, can not remove item."); ReferenceCounter?.RemoveReference(InnerList[index], this); InnerList.RemoveAt(index); } /// /// Reverse all items in the array. /// public void Reverse() { if (IsReadOnly) throw new InvalidOperationException("The array is readonly, can not reverse."); InnerList.Reverse(); } } ================================================ FILE: src/Neo.VM/Types/Boolean.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Boolean.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Diagnostics; using System.Numerics; using System.Runtime.CompilerServices; namespace Neo.VM.Types; /// /// Represents a boolean ( or ) value in the VM. /// [DebuggerDisplay("Type={GetType().Name}, Value={value}")] public class Boolean : PrimitiveType { private static readonly ReadOnlyMemory TRUE = new byte[] { 1 }; private static readonly ReadOnlyMemory FALSE = new byte[] { 0 }; private readonly bool value; public override ReadOnlyMemory Memory => value ? TRUE : FALSE; public override int Size => sizeof(bool); public override StackItemType Type => StackItemType.Boolean; /// /// Create a new VM object representing the boolean type. /// /// The initial value of the object. internal Boolean(bool value) { this.value = value; } public override bool Equals(StackItem? other) { if (ReferenceEquals(this, other)) return true; if (other is Boolean b) return value == b.value; return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public override bool GetBoolean() { return value; } public override int GetHashCode() { return HashCode.Combine(value); } [MethodImpl(MethodImplOptions.AggressiveInlining)] public override BigInteger GetInteger() { return value ? BigInteger.One : BigInteger.Zero; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator Boolean(bool value) { return value ? True : False; } public override string ToString() { return value.ToString(); } } ================================================ FILE: src/Neo.VM/Types/Buffer.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Buffer.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Buffers; using System.Collections.Generic; using System.Diagnostics; using System.Numerics; namespace Neo.VM.Types; /// /// Represents a memory block that can be used for reading and writing in the VM. /// [DebuggerDisplay("Type={GetType().Name}, Value={System.Convert.ToHexString(GetSpan())}")] public class Buffer : StackItem { /// /// The internal byte array used to store the actual data. /// public readonly Memory InnerBuffer; /// /// The size of the buffer. /// public int Size => InnerBuffer.Length; public override StackItemType Type => StackItemType.Buffer; private readonly byte[] _buffer; private bool _keep_alive = false; /// /// Create a buffer of the specified size. /// /// The size of this buffer. /// Indicates whether the created buffer is zero-initialized. public Buffer(int size, bool zeroInitialize = true) { _buffer = ArrayPool.Shared.Rent(size); InnerBuffer = new Memory(_buffer, 0, size); if (zeroInitialize) InnerBuffer.Span.Clear(); } /// /// Create a buffer with the specified data. /// /// The data to be contained in this buffer. public Buffer(ReadOnlySpan data) : this(data.Length, false) { data.CopyTo(InnerBuffer.Span); } internal override void Cleanup() { if (!_keep_alive) ArrayPool.Shared.Return(_buffer, clearArray: false); } public void KeepAlive() { _keep_alive = true; } public override StackItem ConvertTo(StackItemType type) { switch (type) { case StackItemType.Integer: if (InnerBuffer.Length > Integer.MaxSize) throw new InvalidCastException(); return new BigInteger(InnerBuffer.Span); case StackItemType.ByteString: #if NET5_0_OR_GREATER byte[] clone = GC.AllocateUninitializedArray(InnerBuffer.Length); #else byte[] clone = new byte[InnerBuffer.Length]; #endif InnerBuffer.CopyTo(clone); return clone; default: return base.ConvertTo(type); } } internal override StackItem DeepCopy(Dictionary refMap, bool asImmutable) { if (refMap.TryGetValue(this, out StackItem? mappedItem)) return mappedItem; StackItem result = asImmutable ? new ByteString(InnerBuffer.ToArray()) : new Buffer(InnerBuffer.Span); refMap.Add(this, result); return result; } public override bool GetBoolean() { return true; } public override ReadOnlySpan GetSpan() { return InnerBuffer.Span; } public override string ToString() { return GetSpan().TryToStrictUtf8String(out var str) ? $"(\"{str}\")" : $"(\"Base64: {Convert.ToBase64String(GetSpan())}\")"; } public override int GetHashCode() => throw new NotSupportedException("Mutable buffer does not support GetHashCode."); } ================================================ FILE: src/Neo.VM/Types/ByteString.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // ByteString.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Diagnostics; using System.Numerics; using System.Runtime.CompilerServices; namespace Neo.VM.Types; /// /// Represents an immutable memory block in the VM. /// [DebuggerDisplay("Type={GetType().Name}, Value={System.Convert.ToHexString(GetSpan())}")] public class ByteString : PrimitiveType { /// /// An empty . /// public static readonly ByteString Empty = ReadOnlyMemory.Empty; public override ReadOnlyMemory Memory { get; } public override StackItemType Type => StackItemType.ByteString; /// /// Create a new with the specified data. /// /// The data to be contained in this . public ByteString(ReadOnlyMemory data) { Memory = data; } private bool Equals(ByteString other) { return GetSpan().SequenceEqual(other.GetSpan()); } public override bool Equals(StackItem? other) { if (ReferenceEquals(this, other)) return true; if (other is not ByteString b) return false; return Equals(b); } internal override bool Equals(StackItem? other, ExecutionEngineLimits limits) { uint maxComparableSize = limits.MaxComparableSize; return Equals(other, ref maxComparableSize); } internal bool Equals(StackItem? other, ref uint limits) { if (Size > limits || limits == 0) throw new InvalidOperationException($"The operand exceeds the maximum comparable size, {Size}/{limits}."); uint comparedSize = 1; try { if (other is not ByteString b) return false; comparedSize = Math.Max((uint)Math.Max(Size, b.Size), comparedSize); if (ReferenceEquals(this, b)) return true; if (b.Size > limits) throw new InvalidOperationException($"The operand exceeds the maximum comparable size, {b.Size}/{limits}."); return Equals(b); } finally { limits -= comparedSize; } } [MethodImpl(MethodImplOptions.AggressiveInlining)] public override bool GetBoolean() { if (Size > Integer.MaxSize) throw new InvalidCastException(); return Unsafe.NotZero(GetSpan()); } [MethodImpl(MethodImplOptions.AggressiveInlining)] public override BigInteger GetInteger() { if (Size > Integer.MaxSize) throw new InvalidCastException($"Can not convert {nameof(ByteString)} to an integer, MaxSize of {nameof(Integer)} is exceeded: {Size}/{Integer.MaxSize}."); return new BigInteger(GetSpan()); } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator ReadOnlyMemory(ByteString value) { return value.Memory; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator ReadOnlySpan(ByteString value) { return value.Memory.Span; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator ByteString(byte[] value) { return new ByteString(value); } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator ByteString(ReadOnlyMemory value) { return new ByteString(value); } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator ByteString(string value) { return new ByteString(value.ToStrictUtf8Bytes()); } public override string ToString() { return GetSpan().TryToStrictUtf8String(out var str) ? $"\"{str}\"" : $"\"Base64: {Convert.ToBase64String(GetSpan())}\""; } } ================================================ FILE: src/Neo.VM/Types/CompoundType.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // CompoundType.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Collections.Generic; using System.Diagnostics; namespace Neo.VM.Types; /// /// The base class for complex types in the VM. /// [DebuggerDisplay("Type={GetType().Name}, Count={Count}, Id={System.Collections.Generic.ReferenceEqualityComparer.Instance.GetHashCode(this)}")] public abstract class CompoundType : StackItem { /// /// The reference counter used to count the items in the VM object. /// protected internal readonly IReferenceCounter? ReferenceCounter; /// /// Create a new with the specified reference counter. /// /// The reference counter to be used. protected CompoundType(IReferenceCounter? referenceCounter = null) { if (referenceCounter?.Version == RCVersion.V1) { ReferenceCounter = referenceCounter; referenceCounter.AddZeroReferred(this); } else { ReferenceCounter = null; } } /// /// The number of items in this VM object. /// public abstract int Count { get; } public abstract IEnumerable SubItems { get; } public abstract int SubItemsCount { get; } public bool IsReadOnly { get; protected set; } /// /// Remove all items from the VM object. /// public abstract void Clear(); internal abstract override StackItem DeepCopy(Dictionary refMap, bool asImmutable); public sealed override bool GetBoolean() { return true; } public override int GetHashCode() => throw new NotSupportedException("Mutable compound type does not support GetHashCode."); public override string ToString() { return Count.ToString(); } } ================================================ FILE: src/Neo.VM/Types/Integer.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Integer.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Diagnostics; using System.Numerics; using System.Runtime.CompilerServices; namespace Neo.VM.Types; /// /// Represents an integer value in the VM. /// [DebuggerDisplay("Type={GetType().Name}, Value={value}")] public class Integer : PrimitiveType { /// /// The maximum size of an integer in bytes. /// public const int MaxSize = 32; /// /// Represents the number 0. /// public static readonly Integer Zero = 0; private readonly BigInteger value; public override ReadOnlyMemory Memory => value.IsZero ? ReadOnlyMemory.Empty : value.ToByteArray(); public override int Size { get; } public override StackItemType Type => StackItemType.Integer; /// /// Create an integer with the specified value. /// /// The value of the integer. public Integer(BigInteger value) { if (value.IsZero) { Size = 0; } else { Size = value.GetByteCount(); if (Size > MaxSize) throw new ArgumentException($"Integer size {Size} bytes exceeds maximum allowed size of {MaxSize} bytes.", nameof(value)); } this.value = value; } public override bool Equals(StackItem? other) { if (ReferenceEquals(this, other)) return true; if (other is Integer i) return value == i.value; return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public override bool GetBoolean() { return !value.IsZero; } public override int GetHashCode() { return HashCode.Combine(value); } [MethodImpl(MethodImplOptions.AggressiveInlining)] public override BigInteger GetInteger() { return value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator Integer(sbyte value) { return (BigInteger)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator Integer(byte value) { return (BigInteger)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator Integer(short value) { return (BigInteger)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator Integer(ushort value) { return (BigInteger)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator Integer(int value) { return (BigInteger)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator Integer(uint value) { return (BigInteger)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator Integer(long value) { return (BigInteger)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator Integer(ulong value) { return (BigInteger)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator Integer(BigInteger value) { return new Integer(value); } public override string ToString() { return value.ToString(); } } ================================================ FILE: src/Neo.VM/Types/InteropInterface.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // InteropInterface.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Diagnostics; namespace Neo.VM.Types; /// /// Represents an interface used to interoperate with the outside of the the VM. /// [DebuggerDisplay("Type={GetType().Name}, Value={_object}")] public class InteropInterface : StackItem { private readonly object _object; public override StackItemType Type => StackItemType.InteropInterface; /// /// Create an interoperability interface that wraps the specified . /// /// The wrapped . public InteropInterface(object value) { _object = value ?? throw new ArgumentNullException(nameof(value)); } public override bool Equals(StackItem? other) { if (ReferenceEquals(this, other)) return true; if (other is InteropInterface i) return _object.Equals(i._object); return false; } public override bool GetBoolean() { return true; } public override int GetHashCode() { return HashCode.Combine(_object); } public override T GetInterface() { if (_object is T t) return t; throw new InvalidCastException($"This {nameof(InteropInterface)} can't be casted to type {typeof(T)}."); } public override string ToString() { return _object.ToString() ?? "NULL"; } } ================================================ FILE: src/Neo.VM/Types/Map.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Map.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Collections; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Linq; using System.Runtime.CompilerServices; namespace Neo.VM.Types; /// /// Represents an ordered collection of key-value pairs in the VM. /// public class Map : CompoundType, IReadOnlyDictionary { /// /// Indicates the maximum size of keys in bytes. /// public const int MaxKeySize = 64; #if NET5_0_OR_GREATER private readonly OrderedDictionary dictionary = new(); #else private readonly Collections.OrderedDictionary dictionary = new(); #endif /// /// Gets or sets the element that has the specified key in the map. /// /// The key to locate. /// The element that has the specified key in the map. public StackItem this[PrimitiveType key] { [MethodImpl(MethodImplOptions.AggressiveInlining)] get { if (key.Size > MaxKeySize) throw new ArgumentException($"Key size {key.Size} bytes exceeds maximum allowed size of {MaxKeySize} bytes.", nameof(key)); return dictionary[key]; } set { if (key.Size > MaxKeySize) throw new ArgumentException($"Key size {key.Size} bytes exceeds maximum allowed size of {MaxKeySize} bytes.", nameof(key)); if (IsReadOnly) throw new InvalidOperationException("The map is readonly, can not set value."); if (ReferenceCounter != null) { if (dictionary.TryGetValue(key, out StackItem? old_value)) ReferenceCounter.RemoveReference(old_value, this); else ReferenceCounter.AddReference(key, this); if (value is CompoundType { ReferenceCounter: null }) { throw new InvalidOperationException("Can not set a Map without a ReferenceCounter."); } ReferenceCounter.AddReference(value, this); } dictionary[key] = value; } } public override int Count => dictionary.Count; /// /// Gets an enumerable collection that contains the keys in the map. /// public IEnumerable Keys => dictionary.Keys; public override IEnumerable SubItems => Keys.Concat(Values); public override int SubItemsCount => dictionary.Count * 2; public override StackItemType Type => StackItemType.Map; /// /// Gets an enumerable collection that contains the values in the map. /// public IEnumerable Values => dictionary.Values; /// /// Create a new map with the specified reference counter. /// /// The reference counter to be used. public Map(IReferenceCounter? referenceCounter = null) : base(referenceCounter) { } /// /// Create a new map with the specified dictionary and reference counter. /// /// Dictionary /// Reference Counter public Map(IEnumerable> dictionary, IReferenceCounter? referenceCounter = null) : this(referenceCounter) { foreach (var (k, v) in dictionary) { this[k] = v; } } public override void Clear() { if (IsReadOnly) throw new InvalidOperationException("The map is readonly, can not clear."); if (ReferenceCounter != null) foreach (var pair in dictionary) { ReferenceCounter.RemoveReference(pair.Key, this); ReferenceCounter.RemoveReference(pair.Value, this); } dictionary.Clear(); } /// /// Determines whether the map contains an element that has the specified key. /// /// The key to locate. /// /// if the map contains an element that has the specified key; /// otherwise, . /// public bool ContainsKey(PrimitiveType key) { if (key.Size > MaxKeySize) throw new ArgumentException($"Key size {key.Size} bytes exceeds maximum allowed size of {MaxKeySize} bytes.", nameof(key)); return dictionary.ContainsKey(key); } internal override StackItem DeepCopy(Dictionary refMap, bool asImmutable) { if (refMap.TryGetValue(this, out StackItem? mappedItem)) return mappedItem; Map result = new(ReferenceCounter); refMap.Add(this, result); foreach (var (k, v) in dictionary) result[k] = v.DeepCopy(refMap, asImmutable); result.IsReadOnly = IsReadOnly || asImmutable; return result; } IEnumerator> IEnumerable>.GetEnumerator() { return ((IDictionary)dictionary).GetEnumerator(); } IEnumerator IEnumerable.GetEnumerator() { return ((IDictionary)dictionary).GetEnumerator(); } /// /// Removes the element with the specified key from the map. /// /// The key of the element to remove. /// /// if the element is successfully removed; /// otherwise, . /// public StackItem? Remove(PrimitiveType key) { if (key.Size > MaxKeySize) throw new ArgumentException($"Can not remove key from map, MaxKeySize of {nameof(Map)} is exceeded: {key.Size}/{MaxKeySize}.", nameof(key)); if (IsReadOnly) throw new InvalidOperationException("The map is readonly, can not remove key."); if (!dictionary.Remove(key, out StackItem? oldValue)) return null; ReferenceCounter?.RemoveReference(key, this); ReferenceCounter?.RemoveReference(oldValue, this); return oldValue; } /// /// Gets the value that is associated with the specified key. /// /// The key to locate. /// /// When this method returns, the value associated with the specified key, if the key is found; /// otherwise, . /// /// /// if the map contains an element that has the specified key; /// otherwise, . /// #if NET5_0_OR_GREATER public bool TryGetValue(PrimitiveType key, [MaybeNullWhen(false)] out StackItem value) #else public bool TryGetValue(PrimitiveType key, out StackItem value) #endif { if (key.Size > MaxKeySize) throw new ArgumentException($"Key size {key.Size} bytes exceeds maximum allowed size of {MaxKeySize} bytes.", nameof(key)); return dictionary.TryGetValue(key, out value); } } ================================================ FILE: src/Neo.VM/Types/Null.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Null.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; namespace Neo.VM.Types; /// /// Represents in the VM. /// public class Null : StackItem { public override StackItemType Type => StackItemType.Any; internal Null() { } public override StackItem ConvertTo(StackItemType type) { #if NET5_0_OR_GREATER if (type == StackItemType.Any || !Enum.IsDefined(type)) #else if (type == StackItemType.Any || !Enum.IsDefined(typeof(StackItemType), type)) #endif throw new InvalidCastException($"Type {nameof(Null)} can't be converted to StackItemType: {type}"); return this; } public override bool Equals(StackItem? other) { if (ReferenceEquals(this, other)) return true; return other is Null; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public override bool GetBoolean() { return false; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public override int GetHashCode() { return 0; } [return: MaybeNull] public override T GetInterface() { return default; } public override string? GetString() { return null; } public override string ToString() { return "NULL"; } } ================================================ FILE: src/Neo.VM/Types/Pointer.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Pointer.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Diagnostics; namespace Neo.VM.Types; /// /// Represents the instruction pointer in the VM, used as the target of jump instructions. /// [DebuggerDisplay("Type={GetType().Name}, Position={Position}")] public class Pointer : StackItem { /// /// The object containing this pointer. /// public Script Script { get; } /// /// The position of the pointer in the script. /// public int Position { get; } public override StackItemType Type => StackItemType.Pointer; /// /// Create a code pointer with the specified script and position. /// /// The object containing this pointer. /// The position of the pointer in the script. public Pointer(Script script, int position) { Script = script; Position = position; } public override bool Equals(StackItem? other) { if (other == this) return true; if (other is Pointer p) return Position == p.Position && Script == p.Script; return false; } public override bool GetBoolean() { return true; } public override int GetHashCode() { return HashCode.Combine(Script.GetHashCode(), Position); } public override string ToString() { return Position.ToString(); } } ================================================ FILE: src/Neo.VM/Types/PrimitiveType.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // PrimitiveType.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Collections.Generic; using System.Numerics; using System.Runtime.CompilerServices; namespace Neo.VM.Types; /// /// The base class for primitive types in the VM. /// public abstract class PrimitiveType : StackItem { public abstract ReadOnlyMemory Memory { get; } /// /// The size of the VM object in bytes. /// public virtual int Size => Memory.Length; public override StackItem ConvertTo(StackItemType type) { if (type == Type) return this; return type switch { StackItemType.Integer => GetInteger(), StackItemType.ByteString => Memory, StackItemType.Buffer => new Buffer(GetSpan()), _ => base.ConvertTo(type) }; } internal sealed override StackItem DeepCopy(Dictionary refMap, bool asImmutable) { return this; } public abstract override bool Equals(StackItem? other); public sealed override ReadOnlySpan GetSpan() { return Memory.Span; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator PrimitiveType(sbyte value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator PrimitiveType(byte value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator PrimitiveType(short value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator PrimitiveType(ushort value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator PrimitiveType(int value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator PrimitiveType(uint value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator PrimitiveType(long value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator PrimitiveType(ulong value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator PrimitiveType(BigInteger value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator PrimitiveType(bool value) { return (Boolean)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator PrimitiveType(byte[] value) { return (ByteString)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator PrimitiveType(ReadOnlyMemory value) { return (ByteString)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator PrimitiveType(string value) { return (ByteString)value; } } ================================================ FILE: src/Neo.VM/Types/StackItem.Vertex.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // StackItem.Vertex.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Collections.Generic; using System.Linq; namespace Neo.VM.Types; partial class StackItem { /// /// Represents an entry for an object reference. /// /// This class is used to keep track of references from compound types to other or . /// It contains the referenced item and the number of references to it. /// /// Use this class to manage references from compound types to their child items. /// /// This is used to track references numbers from the same parent to the same child. /// This is used for the purpose of determining strongly connect components. /// /// internal class ObjectReferenceEntry { /// /// The referenced StackItem. /// public StackItem Item; /// /// The number of references to the StackItem. /// public int References; /// /// Initializes a new instance of the ObjectReferenceEntry class with the specified StackItem. /// /// The referenced StackItem. public ObjectReferenceEntry(StackItem item) => Item = item; } /// /// The number of references to this StackItem from the evaluation stack. /// /// This field tracks how many times this item is referenced by the evaluation stack. /// It is incremented when the item is pushed onto the stack and decremented when it is popped off. /// /// Use this field to manage stack references and determine when an item is no longer needed. /// internal int StackReferences = 0; /// /// Indicates whether this is referenced from any VM stack roots. /// internal bool IsStackReferenced => StackReferences != 0; /// /// A dictionary mapping compound types to their object reference entries. /// /// This dictionary is used to track references from compound types to their child items. /// It allows efficient lookup and management of references. /// /// Use this dictionary to manage references from compound types to their children. /// Only and will be assigned an , /// other types will be null. /// internal Dictionary? ObjectReferences; /// /// Depth-First Number for Tarjan's algorithm. /// internal int DFN = -1; /// /// Low-link value for Tarjan's algorithm. /// internal int LowLink = 0; /// /// Stack Item hashcode /// protected int _hashCode = 0; /// /// Indicates whether the item is currently on the stack for Tarjan's algorithm. /// /// /// This should only be used for Tarjan algorithm, it can not be used to indicate /// whether an item is on the stack or not since it can still be false if a value is /// on the stack but the algorithm is not yet running. /// /// internal bool OnStack = false; /// /// Returns the successors of the current item based on object references. /// /// This property provides an enumerable of StackItems that are referenced by this item. /// It is used by Tarjan's algorithm to find strongly connected components. /// /// Use this property when you need to iterate over the successors of a StackItem. /// internal IEnumerable Successors => ObjectReferences?.Values.Where(p => p.References > 0).Select(p => p.Item) ?? System.Array.Empty(); /// /// Resets the strongly connected components-related fields. /// /// This method resets the DFN, LowLink, and OnStack fields to their default values. /// It is used before running Tarjan's algorithm to ensure a clean state. /// /// Use this method to reset the state of a StackItem for strongly connected components analysis. /// internal void Reset() => (DFN, LowLink, OnStack) = (-1, 0, false); /// /// Generates a hash code based on the item's span. /// /// This method provides a hash code for the StackItem based on its byte span. /// It is used for efficient storage and retrieval in hash-based collections. /// /// Use this method when you need a hash code for a StackItem. /// /// The hash code for the StackItem. public override int GetHashCode() { if (_hashCode == 0) { _hashCode = HashCode.Combine(Type, GetSpan().XxHash3_32()); } return _hashCode; } } ================================================ FILE: src/Neo.VM/Types/StackItem.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // StackItem.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Numerics; using System.Runtime.CompilerServices; namespace Neo.VM.Types; /// /// The base class for all types in the VM. /// public abstract partial class StackItem : IEquatable { [ThreadStatic] private static Boolean? tls_true; /// /// Represents in the VM. /// public static Boolean True { get { tls_true ??= new(true); return tls_true; } } [ThreadStatic] private static Boolean? tls_false; /// /// Represents in the VM. /// public static Boolean False { get { tls_false ??= new(false); return tls_false; } } [ThreadStatic] private static Null? tls_null; /// /// Represents in the VM. /// public static StackItem Null { get { tls_null ??= new(); return tls_null; } } /// /// Indicates whether the object is . /// public bool IsNull => this is Null; /// /// The type of this VM object. /// public abstract StackItemType Type { get; } /// /// Convert the VM object to the specified type. /// /// The type to be converted to. /// The converted object. public virtual StackItem ConvertTo(StackItemType type) { if (type == Type) return this; if (type == StackItemType.Boolean) return GetBoolean(); throw new InvalidCastException(); } internal virtual void Cleanup() { } /// /// Copy the object and all its children. /// /// The copied object. public StackItem DeepCopy(bool asImmutable = false) { return DeepCopy(new(ReferenceEqualityComparer.Instance), asImmutable); } internal virtual StackItem DeepCopy(Dictionary refMap, bool asImmutable) { return this; } public sealed override bool Equals(object? obj) { if (ReferenceEquals(this, obj)) return true; if (obj is StackItem item) return Equals(item); return false; } public virtual bool Equals(StackItem? other) { return ReferenceEquals(this, other); } internal virtual bool Equals(StackItem? other, ExecutionEngineLimits limits) { return Equals(other); } /// /// Wrap the specified and return an containing the . /// /// The wrapped . /// public static StackItem FromInterface(object? value) { if (value is null) return Null; return new InteropInterface(value); } /// /// Get the boolean value represented by the VM object. /// /// The boolean value represented by the VM object. public abstract bool GetBoolean(); /// /// Get the integer value represented by the VM object. /// /// The integer value represented by the VM object. public virtual BigInteger GetInteger() { throw new InvalidCastException(); } /// /// Get the wrapped by this interface and convert it to the specified type. /// /// The type to convert to. /// The wrapped . [return: MaybeNull] public virtual T GetInterface() where T : notnull { throw new InvalidCastException(); } /// /// Get the readonly span used to read the VM object data. /// /// public virtual ReadOnlySpan GetSpan() { throw new InvalidCastException(); } /// /// Get the value represented by the VM object. /// /// The value represented by the VM object. public virtual string? GetString() { return GetSpan().ToStrictUtf8String(); } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator StackItem(sbyte value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator StackItem(byte value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator StackItem(short value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator StackItem(ushort value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator StackItem(int value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator StackItem(uint value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator StackItem(long value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator StackItem(ulong value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator StackItem(BigInteger value) { return (Integer)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator StackItem(bool value) { return value ? True : False; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator StackItem(byte[] value) { return (ByteString)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator StackItem(ReadOnlyMemory value) { return (ByteString)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static implicit operator StackItem(string value) { return (ByteString)value; } } ================================================ FILE: src/Neo.VM/Types/StackItemType.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // StackItemType.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. namespace Neo.VM.Types; /// /// An enumeration representing the types in the VM. /// public enum StackItemType : byte { /// /// Represents any type. /// Any = 0x00, /// /// Represents a code pointer. /// Pointer = 0x10, /// /// Represents the boolean ( or ) type. /// Boolean = 0x20, /// /// Represents an integer. /// Integer = 0x21, /// /// Represents an immutable memory block. /// ByteString = 0x28, /// /// Represents a memory block that can be used for reading and writing. /// Buffer = 0x30, /// /// Represents an array or a complex object. /// Array = 0x40, /// /// Represents a structure. /// Struct = 0x41, /// /// Represents an ordered collection of key-value pairs. /// Map = 0x48, /// /// Represents an interface used to interoperate with the outside of the the VM. /// InteropInterface = 0x60, } ================================================ FILE: src/Neo.VM/Types/Struct.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Struct.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Collections.Generic; namespace Neo.VM.Types; /// /// Represents a structure in the VM. /// public class Struct : Array { public override StackItemType Type => StackItemType.Struct; /// /// Create a structure with the specified fields. /// /// The fields to be included in the structure. public Struct(IEnumerable? fields = null) : this(null, fields) { } /// /// Create a structure with the specified fields. And make the structure use the specified . /// /// The to be used by this structure. /// The fields to be included in the structure. public Struct(IReferenceCounter? referenceCounter, IEnumerable? fields = null) : base(referenceCounter, fields) { } /// /// Create a new structure with the same content as this structure. All nested structures will be copied by value. /// /// Execution engine limits /// The copied structure. public Struct Clone(ExecutionEngineLimits limits) { int count = (int)(limits.MaxStackSize - 1); Struct result = new(ReferenceCounter); Queue queue = new(); queue.Enqueue(result); queue.Enqueue(this); while (queue.Count > 0) { Struct a = queue.Dequeue(); Struct b = queue.Dequeue(); foreach (StackItem item in b) { count--; if (count < 0) throw new InvalidOperationException("Beyond struct subitem clone limits!"); if (item is Struct sb) { Struct sa = new(ReferenceCounter); a.Add(sa); queue.Enqueue(sa); queue.Enqueue(sb); } else { a.Add(item); } } } return result; } public override StackItem ConvertTo(StackItemType type) { if (type == StackItemType.Array) return new Array(ReferenceCounter, new List(InnerList)); return base.ConvertTo(type); } public override bool Equals(StackItem? other) { throw new NotSupportedException(); } internal override bool Equals(StackItem? other, ExecutionEngineLimits limits) { if (other is not Struct s) return false; Stack stack1 = new(); Stack stack2 = new(); stack1.Push(this); stack2.Push(s); uint count = limits.MaxStackSize; uint maxComparableSize = limits.MaxComparableSize; while (stack1.Count > 0) { if (count-- == 0) throw new InvalidOperationException("Too many struct items to compare in struct comparison."); StackItem a = stack1.Pop(); StackItem b = stack2.Pop(); if (a is ByteString byteString) { if (!byteString.Equals(b, ref maxComparableSize)) return false; } else { if (maxComparableSize == 0) throw new InvalidOperationException("The operand exceeds the maximum comparable size in struct comparison."); maxComparableSize -= 1; if (a is Struct sa) { if (ReferenceEquals(a, b)) continue; if (b is not Struct sb) return false; if (sa.Count != sb.Count) return false; foreach (StackItem item in sa) stack1.Push(item); foreach (StackItem item in sb) stack2.Push(item); } else { if (!a.Equals(b)) return false; } } } return true; } } ================================================ FILE: src/Neo.VM/Unsafe.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Unsafe.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Runtime.CompilerServices; namespace Neo.VM; unsafe static class Unsafe { [MethodImpl(MethodImplOptions.AggressiveInlining)] public static bool NotZero(ReadOnlySpan x) { int len = x.Length; if (len == 0) return false; fixed (byte* xp = x) { long* xlp = (long*)xp; for (; len >= 8; len -= 8) { if (*xlp != 0) return true; xlp++; } byte* xbp = (byte*)xlp; for (; len > 0; len--) { if (*xbp != 0) return true; xbp++; } } return false; } } ================================================ FILE: src/Neo.VM/Utility.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // Utility.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Diagnostics.CodeAnalysis; using System.IO.Hashing; using System.Numerics; using System.Runtime.CompilerServices; using System.Text; namespace Neo.VM; static class Utility { public static Encoding StrictUTF8 { get; } private const int DefaultXxHash3Seed = 40343; static Utility() { StrictUTF8 = (Encoding)Encoding.UTF8.Clone(); StrictUTF8.DecoderFallback = DecoderFallback.ExceptionFallback; StrictUTF8.EncoderFallback = EncoderFallback.ExceptionFallback; } /// /// Converts a byte span to a strict UTF8 string. /// /// The byte span to convert. /// The converted string. /// True if the conversion is successful, otherwise false. public static bool TryToStrictUtf8String(this ReadOnlySpan bytes, [NotNullWhen(true)] out string? value) { try { value = StrictUTF8.GetString(bytes); return true; } catch { value = default; return false; } } /// /// Converts a byte span to a strict UTF8 string. /// /// The byte span to convert. /// The converted string. [MethodImpl(MethodImplOptions.AggressiveInlining)] public static string ToStrictUtf8String(this ReadOnlySpan value) => StrictUTF8.GetString(value); /// /// Converts a string to a strict UTF8 byte array. /// /// The string to convert. /// The converted byte array. [MethodImpl(MethodImplOptions.AggressiveInlining)] public static byte[] ToStrictUtf8Bytes(this string value) => StrictUTF8.GetBytes(value); /// /// Computes the 32-bit hash value for the specified byte array using the xxhash3 algorithm. /// /// The input to compute the hash code for. /// The seed used by the xxhash3 algorithm. /// The computed hash code. [MethodImpl(MethodImplOptions.AggressiveInlining)] public static int XxHash3_32(this ReadOnlySpan value, long seed = DefaultXxHash3Seed) { return HashCode.Combine(XxHash3.HashToUInt64(value, seed)); } public static BigInteger ModInverse(this BigInteger value, BigInteger modulus) { #if NET5_0_OR_GREATER ArgumentOutOfRangeException.ThrowIfNegativeOrZero(value); ArgumentOutOfRangeException.ThrowIfLessThan(modulus, 2); #else if (value <= 0) throw new ArgumentOutOfRangeException(nameof(value)); if (modulus < 2) throw new ArgumentOutOfRangeException(nameof(modulus)); #endif BigInteger r = value, old_r = modulus, s = 1, old_s = 0; while (r > 0) { BigInteger q = old_r / r; (old_r, r) = (r, old_r % r); (old_s, s) = (s, old_s - q * s); } BigInteger result = old_s % modulus; if (result < 0) result += modulus; if (!(value * result % modulus).IsOne) throw new InvalidOperationException(); return result; } public static BigInteger Sqrt(this BigInteger value) { if (value < 0) throw new InvalidOperationException("value can not be negative"); if (value.IsZero) return BigInteger.Zero; if (value < 4) return BigInteger.One; var z = value; var x = BigInteger.One << (int)(((value - 1).GetBitLength() + 1) >> 1); while (x < z) { z = x; x = (value / x + x) / 2; } return z; } #if !NET5_0_OR_GREATER static int GetBitLength(this BigInteger i) { byte[] b = i.ToByteArray(); return (b.Length - 1) * 8 + BitLen(i.Sign > 0 ? b[^1] : 255 - b[^1]); } [MethodImpl(MethodImplOptions.AggressiveInlining)] static int BitLen(int w) { return (w < 1 << 15 ? (w < 1 << 7 ? (w < 1 << 3 ? (w < 1 << 1 ? (w < 1 << 0 ? (w < 0 ? 32 : 0) : 1) : (w < 1 << 2 ? 2 : 3)) : (w < 1 << 5 ? (w < 1 << 4 ? 4 : 5) : (w < 1 << 6 ? 6 : 7))) : (w < 1 << 11 ? (w < 1 << 9 ? (w < 1 << 8 ? 8 : 9) : (w < 1 << 10 ? 10 : 11)) : (w < 1 << 13 ? (w < 1 << 12 ? 12 : 13) : (w < 1 << 14 ? 14 : 15)))) : (w < 1 << 23 ? (w < 1 << 19 ? (w < 1 << 17 ? (w < 1 << 16 ? 16 : 17) : (w < 1 << 18 ? 18 : 19)) : (w < 1 << 21 ? (w < 1 << 20 ? 20 : 21) : (w < 1 << 22 ? 22 : 23))) : (w < 1 << 27 ? (w < 1 << 25 ? (w < 1 << 24 ? 24 : 25) : (w < 1 << 26 ? 26 : 27)) : (w < 1 << 29 ? (w < 1 << 28 ? 28 : 29) : (w < 1 << 30 ? 30 : 31))))); } #endif } ================================================ FILE: src/Neo.VM/VMState.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // VMState.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. namespace Neo.VM; /// /// Indicates the status of the VM. /// public enum VMState : byte { /// /// Indicates that the execution is in progress or has not yet begun. /// NONE = 0, /// /// Indicates that the execution has been completed successfully. /// HALT = 1 << 0, /// /// Indicates that the execution has ended, and an exception that cannot be caught is thrown. /// FAULT = 1 << 1, /// /// Indicates that a breakpoint is currently being hit. /// BREAK = 1 << 2, } ================================================ FILE: src/Neo.VM/VMUnhandledException.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // VMUnhandledException.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM.Types; using System; using System.Text; using Array = Neo.VM.Types.Array; namespace Neo.VM; /// /// Represents an unhandled exception in the VM. /// Thrown when there is an exception in the VM that is not caught by any script. /// public class VMUnhandledException : Exception { /// /// The unhandled exception in the VM. /// public StackItem ExceptionObject { get; } /// /// Initializes a new instance of the class. /// /// The unhandled exception in the VM. public VMUnhandledException(StackItem ex) : base(GetExceptionMessage(ex)) { ExceptionObject = ex; } private static string GetExceptionMessage(StackItem e) { StringBuilder sb = new("An unhandled exception was thrown."); ByteString? s = e as ByteString; if (s is null && e is Array array && array.Count > 0) s = array[0] as ByteString; if (s != null) { sb.Append(' '); sb.Append(Encoding.UTF8.GetString(s.GetSpan())); } return sb.ToString(); } } ================================================ FILE: tests/Neo.VM.Tests/Converters/ScriptConverter.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // ScriptConverter.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.VisualStudio.TestTools.UnitTesting; using Neo.Test.Extensions; using Neo.VM; using Newtonsoft.Json; using Newtonsoft.Json.Linq; using System; using System.Linq; namespace Neo.Test.Converters; internal class ScriptConverter : JsonConverter { public override bool CanConvert(Type objectType) { return objectType == typeof(byte[]) || objectType == typeof(string); } public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { switch (reader.TokenType) { case JsonToken.String: { if (reader.Value is string str) { Assert.StartsWith("0x", str, $"'0x' prefix required for value: '{str}'"); return str.FromHexString(); } break; } case JsonToken.Bytes: { if (reader.Value is byte[] data) return data; break; } case JsonToken.StartArray: { using var script = new ScriptBuilder(); foreach (var entry in JArray.Load(reader)) { var mul = 1; var value = entry.Value(); if (Enum.IsDefined(typeof(OpCode), value) && Enum.TryParse(value, out var opCode)) { for (int x = 0; x < mul; x++) { script.Emit(opCode); } } else { for (int x = 0; x < mul; x++) { Assert.StartsWith("0x", value, $"'0x' prefix required for value: '{value}'"); script.EmitRaw(value.FromHexString()); } } } return script.ToArray(); } } throw new FormatException(); } public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { if (value is byte[] data) { int ip = 0; var array = new JArray(); try { for (ip = 0; ip < data.Length;) { var instruction = new Instruction(data, ip); array.Add(instruction.OpCode.ToString().ToUpperInvariant()); // Operand Size if (instruction.Size - 1 - instruction.Operand.Length > 0) { array.Add(data.Skip(ip + 1).Take(instruction.Size - 1 - instruction.Operand.Length).ToArray().ToHexString()); } if (!instruction.Operand.IsEmpty) { // Data array.Add(instruction.Operand.ToArray().ToHexString()); } ip += instruction.Size; } } catch { // Something was wrong, but maybe it's intentioned if (Enum.IsDefined(typeof(OpCode), data[ip])) { // Check if it was the content and not the opcode array.Add(((OpCode)data[ip]).ToString().ToUpperInvariant()); array.Add(data[(ip + 1)..].ToHexString()); } else { array.Add(data[ip..].ToHexString()); } } // Write the script writer.WriteStartArray(); foreach (var entry in array) writer.WriteValue(entry.Value()); writer.WriteEndArray(); // Double check - Ensure that the format is exactly the same using var script = new ScriptBuilder(); foreach (var entry in array) { if (Enum.TryParse(entry.Value(), out var opCode)) { script.Emit(opCode); } else { script.EmitRaw(entry.Value().FromHexString()); } } if (script.ToArray().ToHexString() != data.ToHexString()) { throw new FormatException(); } } else { throw new FormatException(); } } } ================================================ FILE: tests/Neo.VM.Tests/Converters/UppercaseEnum.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // UppercaseEnum.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Newtonsoft.Json; using System; namespace Neo.Test.Converters; internal class UppercaseEnum : JsonConverter { public override bool CanConvert(Type objectType) { return objectType.IsEnum; } public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { return Enum.Parse(objectType, reader.Value.ToString(), true); } public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { writer.WriteValue(value.ToString().ToUpperInvariant()); } } ================================================ FILE: tests/Neo.VM.Tests/Extensions/JsonExtensions.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // JsonExtensions.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Newtonsoft.Json; using Newtonsoft.Json.Converters; using Newtonsoft.Json.Serialization; namespace Neo.Test.Extensions; public static class JsonExtensions { private static readonly JsonSerializerSettings _settings; /// /// Static constructor /// static JsonExtensions() { _settings = new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver(), Formatting = Formatting.Indented, NullValueHandling = NullValueHandling.Ignore, }; _settings.Converters.Add(new StringEnumConverter(new CamelCaseNamingStrategy())); } /// /// Deserialize json to object /// /// Type /// Json /// Unit test public static T DeserializeJson(this string input) { return JsonConvert.DeserializeObject(input, _settings); } /// /// Serialize UT to json /// /// Unit test /// Json public static string ToJson(this object ut) { return JsonConvert.SerializeObject(ut, _settings); } } ================================================ FILE: tests/Neo.VM.Tests/Extensions/StringExtensions.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // StringExtensions.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Globalization; namespace Neo.Test.Extensions; internal static class StringExtensions { /// /// Convert buffer to hex string /// /// Data /// Return hex string public static string ToHexString(this byte[] data) { if (data == null) return ""; var m = data.Length; if (m == 0) return ""; var sb = new char[(m * 2) + 2]; sb[0] = '0'; sb[1] = 'x'; for (int x = 0, y = 2; x < m; x++, y += 2) { var hex = data[x].ToString("x2"); sb[y] = hex[0]; sb[y + 1] = hex[1]; } return new string(sb); } /// /// Convert string in Hex format to byte array /// /// Hexadecimal string /// Return byte array public static byte[] FromHexString(this string value) { if (string.IsNullOrEmpty(value)) return Array.Empty(); if (value.StartsWith("0x")) value = value[2..]; if (value.Length % 2 == 1) throw new FormatException(); var result = new byte[value.Length / 2]; for (var i = 0; i < result.Length; i++) result[i] = byte.Parse(value.Substring(i * 2, 2), NumberStyles.AllowHexSpecifier); return result; } } ================================================ FILE: tests/Neo.VM.Tests/Helpers/RandomHelper.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // RandomHelper.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using System; using System.Threading; namespace Neo.Test.Helpers; public class RandomHelper { private const string _randchars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; private static readonly ThreadLocal _rand = new(() => new Random()); /// /// Get random buffer /// /// Length /// Buffer public static byte[] RandBuffer(int length) { var buffer = new byte[length]; _rand.Value.NextBytes(buffer); return buffer; } /// /// Get random string /// /// Length /// Buffer public static string RandString(int length) { var stringChars = new char[length]; for (int i = 0; i < stringChars.Length; i++) { stringChars[i] = _randchars[_rand.Value.Next(_randchars.Length)]; } return new string(stringChars); } } ================================================ FILE: tests/Neo.VM.Tests/Neo.VM.Tests.csproj ================================================ net10.0 Neo.Test true false PreserveNewest ================================================ FILE: tests/Neo.VM.Tests/Properties/AssemblyInfo.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // AssemblyInfo.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.VisualStudio.TestTools.UnitTesting; [assembly: Parallelize(Scope = ExecutionScope.MethodLevel)] ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arithmetic/GE.json ================================================ { "category": "Numeric", "name": "GE same types", "tests": [ { "name": "Without two pushes", "script": [ "GE" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one push", "script": [ "PUSH0", "GE" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "GE", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } } ] }, { "name": "Real test [0,0]", "script": [ "PUSH0", "PUSH0", "GE" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "GE", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [1,0]", "script": [ "PUSH1", "PUSH0", "GE" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "GE", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [0,1]", "script": [ "PUSH0", "PUSH1", "GE" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "GE", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [null,1]", "script": [ "PUSHNULL", "PUSH1", "GE" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "GE", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "null" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [1,null]", "script": [ "PUSH1", "PUSHNULL", "GE" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "GE", "evaluationStack": [ { "type": "null" }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "FAULT test [1,array]", "script": [ "PUSH1", "NEWARRAY0", "GE" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "GE", "evaluationStack": [ { "type": "array", "value": [] }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT", "resultStack": [ { "type": "boolean", "value": false } ] } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arithmetic/GT.json ================================================ { "category": "Numeric", "name": "GT same types", "tests": [ { "name": "Without two pushes", "script": [ "GT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one push", "script": [ "PUSH0", "GT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "GT", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } } ] }, { "name": "Real test [0,0]", "script": [ "PUSH0", "PUSH0", "GT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "GT", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [1,0]", "script": [ "PUSH1", "PUSH0", "GT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "GT", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [0,1]", "script": [ "PUSH0", "PUSH1", "GT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "GT", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [null,1]", "script": [ "PUSHNULL", "PUSH1", "GT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "GT", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "null" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [1,null]", "script": [ "PUSH1", "PUSHNULL", "GT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "GT", "evaluationStack": [ { "type": "null" }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "FAULT test [1,array]", "script": [ "PUSH1", "NEWARRAY0", "GT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "GT", "evaluationStack": [ { "type": "array", "value": [] }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT", "resultStack": [ { "type": "boolean", "value": false } ] } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arithmetic/LE.json ================================================ { "category": "Numeric", "name": "LE same types", "tests": [ { "name": "Without two pushes", "script": [ "LE" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one push", "script": [ "PUSH0", "LE" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "LE", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } } ] }, { "name": "Real test [0,0]", "script": [ "PUSH0", "PUSH0", "LE" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "LE", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [1,0]", "script": [ "PUSH1", "PUSH0", "LE" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "LE", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [0,1]", "script": [ "PUSH0", "PUSH1", "LE" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "LE", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [null,1]", "script": [ "PUSHNULL", "PUSH1", "LE" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "LE", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "null" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [1,null]", "script": [ "PUSH1", "PUSHNULL", "LE" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "LE", "evaluationStack": [ { "type": "null" }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "FAULT test [1,array]", "script": [ "PUSH1", "NEWARRAY0", "LE" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "LE", "evaluationStack": [ { "type": "array", "value": [] }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT", "resultStack": [ { "type": "boolean", "value": false } ] } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arithmetic/LT.json ================================================ { "category": "Numeric", "name": "LT same types", "tests": [ { "name": "Without two pushes", "script": [ "LT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one push", "script": [ "PUSH0", "LT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "LT", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } } ] }, { "name": "Real test [0,0]", "script": [ "PUSH0", "PUSH0", "LT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "LT", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [1,0]", "script": [ "PUSH1", "PUSH0", "LT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "LT", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [0,1]", "script": [ "PUSH0", "PUSH1", "LT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "LT", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [null,1]", "script": [ "PUSHNULL", "PUSH1", "LT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "LT", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "null" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [1,null]", "script": [ "PUSH1", "PUSHNULL", "LT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "LT", "evaluationStack": [ { "type": "null" }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "FAULT test [1,array]", "script": [ "PUSH1", "NEWARRAY0", "LT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "LT", "evaluationStack": [ { "type": "array", "value": [] }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT", "resultStack": [ { "type": "boolean", "value": false } ] } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arithmetic/MODMUL.json ================================================ { "category": "Numeric", "name": "MODMUL", "tests": [ { "name": "Exception - Without items", "script": [ "MODMUL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "MODMUL", "evaluationStack": [] } ] } } ] }, { "name": "Real test (8 * 2 % 3)", "script": [ "PUSH8", "PUSH2", "PUSH3", "MODMUL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "MODMUL", "evaluationStack": [ { "type": "Integer", "value": 3 }, { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 8 } ] } ], "refs": 3 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] }, { "name": "Real test (16 * 2 % 4)", "script": [ "PUSH16", "PUSH2", "PUSH4", "MODMUL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "MODMUL", "evaluationStack": [ { "type": "Integer", "value": 4 }, { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 16 } ] } ], "refs": 3 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": 0 } ], "refs": 1 } } ] }, { "name": "Real test (-3 * 4 % 5)", "script": [ "PUSH3", "NEGATE", "PUSH4", "PUSH5", "MODMUL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "MODMUL", "evaluationStack": [ { "type": "Integer", "value": 5 }, { "type": "Integer", "value": 4 }, { "type": "Integer", "value": -3 } ] } ], "refs": 3 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": -2 } ], "refs": 1 } } ] }, { "name": "Real test (3 * 4 % -5)", "script": [ "PUSH3", "PUSH4", "PUSH5", "NEGATE", "MODMUL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "MODMUL", "evaluationStack": [ { "type": "Integer", "value": -5 }, { "type": "Integer", "value": 4 }, { "type": "Integer", "value": 3 } ] } ], "refs": 3 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": 2 } ], "refs": 1 } } ] }, { "name": "Real test (-3 * 4 % -5)", "script": [ "PUSH3", "NEGATE", "PUSH4", "PUSH5", "NEGATE", "MODMUL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "MODMUL", "evaluationStack": [ { "type": "Integer", "value": -5 }, { "type": "Integer", "value": 4 }, { "type": "Integer", "value": -3 } ] } ], "refs": 3 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": -2 } ], "refs": 1 } } ] }, { "name": "Real test (3 * -4 % -5)", "script": [ "PUSH3", "PUSH4", "NEGATE", "PUSH5", "NEGATE", "MODMUL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "MODMUL", "evaluationStack": [ { "type": "Integer", "value": -5 }, { "type": "Integer", "value": -4 }, { "type": "Integer", "value": 3 } ] } ], "refs": 3 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": -2 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arithmetic/MODPOW.json ================================================ { "category": "Numeric", "name": "MODPOW", "tests": [ { "name": "Exception - Without items", "script": [ "MODPOW" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "MODPOW", "evaluationStack": [] } ] } } ] }, { "name": "Real test (19 ModInverse 141 = 52)", "script": [ "PUSHINT8", "0x13", "PUSHM1", "PUSHINT16", "0x8d00", "MODPOW" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "MODPOW", "evaluationStack": [ { "type": "Integer", "value": 141 }, { "type": "Integer", "value": -1 }, { "type": "Integer", "value": 19 } ] } ], "refs": 3 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": 52 } ], "refs": 1 } } ] }, { "name": "Real test (ModPow 19, 2, 141 = 79)", "script": [ "PUSHINT8", "0x13", "PUSH2", "PUSHINT16", "0x8d00", "MODPOW" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "MODPOW", "evaluationStack": [ { "type": "Integer", "value": 141 }, { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 19 } ] } ], "refs": 3 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": 79 } ], "refs": 1 } } ] }, { "name": "(3 ^ 4) % 5 == 1", "script": [ "PUSH3", "PUSH4", "PUSH5", "MODPOW" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "MODPOW", "evaluationStack": [ { "type": "Integer", "value": 5 }, { "type": "Integer", "value": 4 }, { "type": "Integer", "value": 3 } ] } ], "refs": 3 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] }, { "name": "(-1 ^ 3) % 3 == -1", "script": [ "PUSHM1", "PUSH3", "PUSH3", "MODPOW" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "MODPOW", "evaluationStack": [ { "type": "Integer", "value": 3 }, { "type": "Integer", "value": 3 }, { "type": "Integer", "value": -1 } ] } ], "refs": 3 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": -1 } ], "refs": 1 } } ] }, { "name": "(-1 ^ 3) % -3 == -1", "script": [ "PUSHM1", "PUSH3", "PUSH3", "NEGATE", "MODPOW" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "MODPOW", "evaluationStack": [ { "type": "Integer", "value": -3 }, { "type": "Integer", "value": 3 }, { "type": "Integer", "value": -1 } ] } ], "refs": 3 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": -1 } ], "refs": 1 } } ] }, { "name": "(-3 ^ 5) % -5 == -3", "script": [ "PUSH3", "NEGATE", "PUSH5", "PUSH5", "NEGATE", "MODPOW" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "MODPOW", "evaluationStack": [ { "type": "Integer", "value": -5 }, { "type": "Integer", "value": 5 }, { "type": "Integer", "value": -3 } ] } ], "refs": 3 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": -3 } ], "refs": 1 } } ] }, { "name": "(3 ^ 4) % -5 == 1", "script": [ "PUSH3", "PUSH4", "PUSH5", "NEGATE", "MODPOW" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "MODPOW", "evaluationStack": [ { "type": "Integer", "value": -5 }, { "type": "Integer", "value": 4 }, { "type": "Integer", "value": 3 } ] } ], "refs": 3 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] }, { "name": "(5 ^ -1) % 4 == 1", "script": [ "PUSH5", "PUSHM1", "PUSH4", "MODPOW" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "MODPOW", "evaluationStack": [ { "type": "Integer", "value": 4 }, { "type": "Integer", "value": -1 }, { "type": "Integer", "value": 5 } ] } ], "refs": 3 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arithmetic/NOT.json ================================================ { "category": "Numeric", "name": "NOT", "tests": [ { "name": "Without push", "script": [ "NOT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With bool", "script": [ "PUSH1", "NOT", "NOT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NOT", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "With integer 0x03", "script": [ "PUSH3", "NOT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "NOT", "evaluationStack": [ { "type": "integer", "value": 3 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "With map", "script": [ "NEWMAP", "NOT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "NOT", "evaluationStack": [ { "type": "map", "value": {} } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "With array", "script": [ "PUSH0", "NEWARRAY", "NOT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NOT", "evaluationStack": [ { "type": "array", "value": [] } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "With struct", "script": [ "PUSH0", "NEWSTRUCT", "NOT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NOT", "evaluationStack": [ { "type": "struct", "value": [] } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "With byte array 0x0000", "script": [ "PUSHDATA1", "0x02", "0x0000", "NOT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NOT", "evaluationStack": [ { "type": "ByteString", "value": "0x0000" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "With byte array 0x0001", "script": [ "PUSHDATA1", "0x02", "0x0001", "NOT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NOT", "evaluationStack": [ { "type": "ByteString", "value": "0x0001" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "With interop", "script": [ "SYSCALL", "0x77777777", "NOT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "NOT", "evaluationStack": [ { "type": "interop", "value": "Object" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arithmetic/NUMEQUAL.json ================================================ { "category": "Numeric", "name": "NUMEQUAL same types", "tests": [ { "name": "Without two pushes", "script": [ "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one push", "script": [ "PUSH0", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } } ] }, { "name": "Real test [Bool,Bool]=true", "script": [ "PUSH0", "NOT", "PUSH0", "NOT", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "boolean", "value": true }, { "type": "boolean", "value": true } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Bool,Bool]=false", "script": [ "PUSH0", "NOT", "PUSH0", "NOT", "NOT", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "boolean", "value": false }, { "type": "boolean", "value": true } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Integer,Integer]=true", "script": [ "PUSH1", "PUSH1", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Integer,Integer]=false", "script": [ "PUSH2", "PUSH1", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Array,Array]=Fault", "script": [ "PUSH0", "NEWARRAY", "DUP", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "array", "value": [] }, { "type": "array", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Array,Array]=fault", "script": [ "PUSH0", "NEWARRAY", "PUSH0", "NEWARRAY", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "array", "value": [] }, { "type": "array", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Struct,Struct]=fault with clone", "script": [ "PUSH0", "NEWSTRUCT", "DUP", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "struct", "value": [] }, { "type": "struct", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Struct,Struct]=fault without clone", "script": [ "PUSH0", "NEWSTRUCT", "PUSH0", "NEWSTRUCT", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "struct", "value": [] }, { "type": "struct", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Struct,Struct]=fault", "script": [ "PUSH0", "NEWSTRUCT", "PUSH1", "NEWSTRUCT", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "struct", "value": [ { "type": "Null" } ] }, { "type": "struct", "value": [] } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Map,Map]=Fault", "script": [ "NEWMAP", "DUP", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "map", "value": {} } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Map,Map]=Fault", "script": [ "NEWMAP", "NEWMAP", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "map", "value": {} } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [ByteString,ByteString]=true", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000123" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 39, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=false same length", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x11", "0x0000000000000000000000000000000124", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 39, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=false different length", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x10", "0x00000000000000000000000000000124", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 37, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "ByteString", "value": "0x00000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=false different length", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x10", "0x00000000000000000000000000000124", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 37, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "ByteString", "value": "0x00000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test with clone [Interop,Interop]=fault", "script": [ "SYSCALL", "0x77777777", "DUP", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "DUP", "evaluationStack": [ { "type": "interop", "value": "Object" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "interop", "value": "Object" }, { "type": "interop", "value": "Object" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Interop,Interop]=fault", "script": [ "SYSCALL", "0x77777777", "SYSCALL", "0x77777777", "NUMEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "NUMEQUAL", "evaluationStack": [ { "type": "interop", "value": "Object" }, { "type": "interop", "value": "Object" } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arithmetic/NUMNOTEQUAL.json ================================================ { "category": "Numeric", "name": "NUMNOTEQUAL same types", "tests": [ { "name": "Without two pushes", "script": [ "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one push", "script": [ "PUSH0", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } } ] }, { "name": "Real test [Bool,Bool]=false", "script": [ "PUSH0", "NOT", "PUSH0", "NOT", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "boolean", "value": true }, { "type": "boolean", "value": true } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Bool,Bool]=true", "script": [ "PUSH0", "NOT", "PUSH0", "NOT", "NOT", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "boolean", "value": false }, { "type": "boolean", "value": true } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Integer,Integer]=false", "script": [ "PUSH1", "PUSH1", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Integer,Integer]=true", "script": [ "PUSH2", "PUSH1", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Array,Array]=Fault", "script": [ "PUSH0", "NEWARRAY", "DUP", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "array", "value": [] }, { "type": "array", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Array,Array]=fault", "script": [ "PUSH0", "NEWARRAY", "PUSH0", "NEWARRAY", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "array", "value": [] }, { "type": "array", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Struct,Struct]=fault with clone", "script": [ "PUSH0", "NEWSTRUCT", "DUP", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "struct", "value": [] }, { "type": "struct", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Struct,Struct]=fault without clone", "script": [ "PUSH0", "NEWSTRUCT", "PUSH0", "NEWSTRUCT", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "struct", "value": [] }, { "type": "struct", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Struct,Struct]=fault", "script": [ "PUSH0", "NEWSTRUCT", "PUSH1", "NEWSTRUCT", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "struct", "value": [ { "type": "Null" } ] }, { "type": "struct", "value": [] } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Map,Map]=Fault", "script": [ "NEWMAP", "DUP", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "map", "value": {} } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Map,Map]=Fault", "script": [ "NEWMAP", "NEWMAP", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "map", "value": {} } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [ByteString,ByteString]=false", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000123" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 39, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=true same length", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x11", "0x0000000000000000000000000000000124", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 39, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=true different length", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x10", "0x00000000000000000000000000000124", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 37, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "ByteString", "value": "0x00000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=true different length", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x10", "0x00000000000000000000000000000124", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 37, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "ByteString", "value": "0x00000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test with clone [Interop,Interop]=fault", "script": [ "SYSCALL", "0x77777777", "DUP", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "DUP", "evaluationStack": [ { "type": "interop", "value": "Object" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "interop", "value": "Object" }, { "type": "interop", "value": "Object" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Interop,Interop]=fault", "script": [ "SYSCALL", "0x77777777", "SYSCALL", "0x77777777", "NUMNOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "NUMNOTEQUAL", "evaluationStack": [ { "type": "interop", "value": "Object" }, { "type": "interop", "value": "Object" } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arithmetic/POW.json ================================================ { "category": "Numeric", "name": "POW", "tests": [ { "name": "Exception - Without items", "script": [ "POW" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "POW", "evaluationStack": [] } ] } } ] }, { "name": "Exception - With only one item", "script": [ "PUSH1", "POW" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "POW", "evaluationStack": [] } ] } } ] }, { "name": "Real test 1", "script": [ "PUSH1", "PUSH1", "POW" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] }, { "name": "Real test 1", "script": [ "PUSH9", "PUSH2", "POW" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 81 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": 81 } ], "refs": 1 } } ] }, { "name": "Real test 1", "script": [ "PUSH2", "PUSH9", "POW" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 512 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": 512 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arithmetic/SHL.json ================================================ { "category": "Numeric", "name": "SHL", "tests": [ { "name": "Exception - Above the limit 0 << 257", "script": [ "PUSH0", "PUSHDATA1", "0x02", "0x0101", "SHL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "SHL", "evaluationStack": [ { "type": "ByteString", "value": "0x0101" }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Exception - Below the limit 0 << -257", "script": [ "PUSH0", "PUSHDATA1", "0x02", "0xfffe", "SHL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "SHL", "evaluationStack": [ { "type": "ByteString", "value": "0xFFFE" }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Exception - Operand can't be converted to Integer", "script": [ "NEWARRAY0", "PUSH0", "SHL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "SHL", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "Array", "value": [] } ] } ] } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test 0 << 256", "script": [ "PUSH0", "PUSHDATA1", "0x02", "0x0001", "SHL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "SHL", "evaluationStack": [ { "type": "ByteString", "value": "0x0001" }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 0 } ], "refs": 1 } } ] }, { "name": "Real test 16 << 4", "script": [ "PUSH16", "PUSH4", "SHL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "SHL", "evaluationStack": [ { "type": "integer", "value": 4 }, { "type": "integer", "value": 16 } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 256 } ], "refs": 1 } } ] }, { "name": "Real test 16 << 0", "script": [ "PUSH16", "PUSH0", "SHL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "SHL", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 16 } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 16 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arithmetic/SHR.json ================================================ { "category": "Numeric", "name": "SHR", "tests": [ { "name": "Exception - Above the limit 0 >> 257", "script": [ "PUSH0", "PUSHDATA1", "0x02", "0x0101", "SHR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "SHR", "evaluationStack": [ { "type": "ByteString", "value": "0x0101" }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Exception - Below the limit 0 >> -257", "script": [ "PUSH0", "PUSHDATA1", "0x02", "0xfffe", "SHR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "SHR", "evaluationStack": [ { "type": "ByteString", "value": "0xFFFE" }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Exception - Operand can't be converted to Integer", "script": [ "NEWARRAY0", "PUSH0", "SHR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "SHR", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "Array", "value": [] } ] } ] } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test 0 >> 256", "script": [ "PUSH0", "PUSHDATA1", "0x02", "0x0001", "SHR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "SHR", "evaluationStack": [ { "type": "ByteString", "value": "0x0001" }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 0 } ], "refs": 1 } } ] }, { "name": "Real test 256 >> 0", "script": [ "PUSHDATA1", "0x02", "0x0001", "PUSH0", "SHR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "SHR", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "ByteString", "value": "0x0001" } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 256 } ], "refs": 1 } } ] }, { "name": "Real test 4 >> 16", "script": [ "PUSH4", "PUSH16", "SHR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "SHR", "evaluationStack": [ { "type": "integer", "value": 16 }, { "type": "integer", "value": 4 } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 0 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arithmetic/SIGN.json ================================================ { "category": "Numeric", "name": "SIGN", "tests": [ { "name": "Without push", "script": [ "SIGN" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With bool", "script": [ "PUSH1", "NOT", "SIGN" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "SIGN", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 0 } ], "refs": 1 } } ] }, { "name": "With integer 0x03", "script": [ "PUSH3", "SIGN" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "SIGN", "evaluationStack": [ { "type": "integer", "value": 3 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 1 } ], "refs": 1 } } ] }, { "name": "With integer -1", "script": [ "PUSHM1", "SIGN" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "SIGN", "evaluationStack": [ { "type": "integer", "value": -1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": -1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": -1 } ], "refs": 1 } } ] }, { "name": "With map", "script": [ "NEWMAP", "SIGN" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "SIGN", "evaluationStack": [ { "type": "map", "value": {} } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With array", "script": [ "PUSH0", "NEWARRAY", "SIGN" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "SIGN", "evaluationStack": [ { "type": "array", "value": [] } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With struct", "script": [ "PUSH0", "NEWSTRUCT", "SIGN" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "SIGN", "evaluationStack": [ { "type": "struct", "value": [] } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With byte array 0x0000", "script": [ "PUSHDATA1", "0x02", "0x0000", "SIGN" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "SIGN", "evaluationStack": [ { "type": "ByteString", "value": "0x0000" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 0 } ], "refs": 1 } } ] }, { "name": "With byte array 0x0001", "script": [ "PUSHDATA1", "0x02", "0x0001", "SIGN" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "SIGN", "evaluationStack": [ { "type": "ByteString", "value": "0x0001" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 1 } ], "refs": 1 } } ] }, { "name": "With interop", "script": [ "SYSCALL", "0x77777777", "SIGN" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "SIGN", "evaluationStack": [ { "type": "interop", "value": "Object" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arithmetic/SQRT.json ================================================ { "category": "Numeric", "name": "SQRT", "tests": [ { "name": "Exception - Without items", "script": [ "SQRT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "SQRT", "evaluationStack": [] } ] } } ] }, { "name": "Real test 1", "script": [ "PUSH1", "SQRT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] }, { "name": "Real test with 81", "script": [ "PUSHINT8", "0x51", "SQRT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 9 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": 9 } ], "refs": 1 } } ] }, { "name": "Real test with 15625", "script": [ "PUSHINT16", "0x093d", "SQRT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 125 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": 125 } ], "refs": 1 } } ] }, { "name": "Real test with 4", "script": [ "PUSHINT8", "0x04", "SQRT" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": 2 } ], "refs": 1 } } ] }, { "name": "Real test with 2", "script": [ "PUSHINT8", "0x02", "SQRT" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "invocationStack": [], "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/APPEND.json ================================================ { "category": "Arrays", "name": "APPEND", "tests": [ { "name": "Without push", "script": [ "PUSH1", "APPEND" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Without array", "script": [ "PUSH1", "PUSH2", "APPEND" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Clone test [Array]", "script": [ "INITSSLOT", "0x01", "PUSH0", "NEWARRAY", "DUP", "PUSH5", "APPEND", "STSFLD0", "PUSH0", "NEWARRAY", "DUP", "LDSFLD0", "APPEND", "LDSFLD0", "PUSH6", "APPEND", "LDSFLD0" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "PUSH0", "staticFields": [ { "type": "array", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "refs": 2 } }, { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "DUP", "evaluationStack": [ { "type": "array", "value": [] } ], "staticFields": [ { "type": "array", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "refs": 3 } }, { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 13, "nextInstruction": "LDSFLD0", "evaluationStack": [ { "type": "array", "value": [ { "type": "Array", "value": [ { "type": "Integer", "value": "5" } ] } ] } ], "staticFields": [ { "type": "array", "value": [ { "type": "Integer", "value": "5" } ] } ] } ], "refs": 4 } }, { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 17, "nextInstruction": "RET", "evaluationStack": [ { "type": "array", "value": [ { "type": "Integer", "value": "5" }, { "type": "Integer", "value": "6" } ] }, { "type": "array", "value": [ { "type": "Array", "value": [ { "type": "Integer", "value": "5" }, { "type": "Integer", "value": "6" } ] } ] } ], "staticFields": [ { "type": "array", "value": [ { "type": "Integer", "value": "5" }, { "type": "Integer", "value": "6" } ] } ] } ], "refs": 6 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "array", "value": [ { "type": "Integer", "value": "5" }, { "type": "Integer", "value": "6" } ] }, { "type": "array", "value": [ { "type": "Array", "value": [ { "type": "Integer", "value": "5" }, { "type": "Integer", "value": "6" } ] } ] } ], "refs": 5 } } ] }, { "name": "Clone test [Struct]", "script": [ "INITSSLOT", "0x01", "PUSH0", "NEWSTRUCT", "DUP", "PUSH5", "APPEND", "STSFLD0", "PUSH0", "NEWSTRUCT", "DUP", "LDSFLD0", "APPEND", "LDSFLD0", "PUSH6", "APPEND", "LDSFLD0" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "PUSH0", "staticFields": [ { "type": "struct", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "refs": 2 } }, { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "DUP", "evaluationStack": [ { "type": "struct", "value": [] } ], "staticFields": [ { "type": "struct", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "refs": 3 } }, { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 13, "nextInstruction": "LDSFLD0", "evaluationStack": [ { "type": "struct", "value": [ { "type": "Struct", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "staticFields": [ { "type": "struct", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "refs": 5 } }, { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 17, "nextInstruction": "RET", "evaluationStack": [ { "type": "struct", "value": [ { "type": "Integer", "value": 5 }, { "type": "Integer", "value": 6 } ] }, { "type": "struct", "value": [ { "type": "Struct", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "staticFields": [ { "type": "struct", "value": [ { "type": "Integer", "value": 5 }, { "type": "Integer", "value": 6 } ] } ] } ], "refs": 7 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "struct", "value": [ { "type": "Integer", "value": 5 }, { "type": "Integer", "value": 6 } ] }, { "type": "struct", "value": [ { "type": "Struct", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "refs": 6 } } ] }, { "name": "Real test [Array]", "script": [ "PUSH0", "NEWARRAY", "DUP", "PUSH5", "APPEND" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "APPEND", "evaluationStack": [ { "type": "integer", "value": 5 }, { "type": "array", "value": [] }, { "type": "array", "value": [] } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "array", "value": [ { "type": "Integer", "value": "5" } ] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "array", "value": [ { "type": "Integer", "value": "5" } ] } ], "refs": 2 } } ] }, { "name": "Real test [Struct]", "script": [ "PUSH0", "NEWSTRUCT", "DUP", "PUSH5", "APPEND" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "APPEND", "evaluationStack": [ { "type": "integer", "value": 5 }, { "type": "struct", "value": [] }, { "type": "struct", "value": [] } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "struct", "value": [ { "type": "Integer", "value": "5" } ] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "struct", "value": [ { "type": "Integer", "value": "5" } ] } ], "refs": 2 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/CLEARITEMS.json ================================================ { "category": "Arrays", "name": "CLEARITEMS", "tests": [ { "name": "Without push", "script": [ "CLEARITEMS" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type", "script": [ "PUSH2", "CLEARITEMS" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Array]", "script": [ "PUSH0", "PUSH1", "PUSH2", "PACK", "DUP", "CLEARITEMS" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "DUP", "evaluationStack": [ { "type": "Array", "value": [ { "type": "Integer", "value": 1 }, { "type": "Integer", "value": 0 } ] } ] } ], "refs": 3 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Array", "value": [] } ], "refs": 1 } } ] }, { "name": "Real test [Map]", "script": [ "NEWMAP", "DUP", "PUSH0", "PUSH0", "SETITEM", "DUP", "CLEARITEMS" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Map", "value": {} } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/HASKEY.json ================================================ { "category": "Arrays", "name": "HASKEY", "tests": [ { "name": "Without push", "script": [ "HASKEY" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong key type", "script": [ "PUSH1", "NEWARRAY", "NEWMAP", "HASKEY" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "HASKEY", "evaluationStack": [ { "type": "Map", "value": {} }, { "type": "Array", "value": [ { "type": "Null" } ] } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Struct]", "script": [ "PUSH1", "PUSH1", "PACKSTRUCT", "PUSH0", "HASKEY" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "HASKEY", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "Struct", "value": [ { "type": "integer", "value": 1 } ] } ] } ], "refs": 3 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Buffer]", "script": [ "PUSH2", "NEWBUFFER", "PUSH0", "HASKEY" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Map]", "script": [ "INITSSLOT", "0x01", "NEWMAP", "DUP", "STSFLD0", "PUSH1", "PUSH2", "SETITEM", "LDSFLD0", "PUSH3", "HASKEY", "DROP", "LDSFLD0", "PUSH1", "HASKEY" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "HASKEY", "evaluationStack": [ { "type": "Integer", "value": 3 }, { "type": "map", "value": { "0x01": { "type": "Integer", "value": 2 } } } ], "staticFields": [ { "type": "map", "value": { "0x01": { "type": "Integer", "value": 2 } } } ] } ], "refs": 5 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 11, "nextInstruction": "DROP", "evaluationStack": [ { "type": "Boolean", "value": false } ], "staticFields": [ { "type": "map", "value": { "0x01": { "type": "Integer", "value": 2 } } } ] } ], "refs": 4 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Overflow index [Array]", "script": [ "PUSH1", "NEWARRAY", "PUSHINT64", "0x0000008000000000", "HASKEY" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Underflow index [Array]", "script": [ "PUSH1", "NEWARRAY", "PUSHINT64", "0xffffff7fffffffff", "HASKEY" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Check key size [Map]", "script": [ "NEWMAP", "PUSHINT8", "0x41", "NEWBUFFER", "CONVERT", "0x28", "HASKEY" ], "steps": [ { "actions": [ "stepinto", "stepinto", "stepinto", "stepinto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "HASKEY", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }, { "type": "map", "value": {} } ] } ], "refs": 2 } }, { "actions": [ "stepinto" ], "result": { "state": "FAULT", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "HASKEY", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000" }, { "type": "map", "value": {} } ] } ] } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/KEYS.json ================================================ { "category": "Arrays", "name": "KEYS", "tests": [ { "name": "Keys in map", "script": [ "NEWMAP", "DUP", "DUP", "PUSH0", "PUSH0", "SETITEM", "PUSH1", "PUSH1", "SETITEM", "KEYS" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 0 }, { "type": "Integer", "value": 1 } ] } ], "refs": 3 } } ] }, { "name": "Invalid StackItem [Integer!=Map]", "script": [ "PUSH0", "KEYS" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/NEWARRAY.json ================================================ { "category": "Arrays", "name": "NEWARRAY", "tests": [ { "name": "Without push", "script": [ "NEWARRAY" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With wrong type", "script": [ "NEWMAP", "NEWARRAY" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With negative push", "script": [ "PUSHM1", "NEWARRAY" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH2", "NEWARRAY" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET", "evaluationStack": [ { "type": "array", "value": [ { "type": "Null" }, { "type": "Null" } ] } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "array", "value": [ { "type": "Null" }, { "type": "Null" } ] } ], "refs": 3 } } ] }, { "name": "Clone Struct to Array", "script": [ "PUSH1", "NEWSTRUCT", "DUP", "PUSH0", "PUSH5", "SETITEM", "NEWARRAY" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "NEWARRAY", "evaluationStack": [ { "type": "struct", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/NEWARRAY0.json ================================================ { "category": "Arrays", "name": "NEWARRAY0", "tests": [ { "name": "Real test", "script": [ "NEWARRAY0" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Array", "value": [] } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/NEWARRAY_T.json ================================================ { "category": "Arrays", "name": "NEWARRAY_T", "tests": [ { "name": "Real test [Any]", "script": [ "PUSH2", "NEWARRAY_T", "0x00" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Array", "value": [ { "type": "Null" }, { "type": "Null" } ] } ], "refs": 3 } } ] }, { "name": "Real test [Pointer]", "script": [ "PUSH2", "NEWARRAY_T", "0x10" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Array", "value": [ { "type": "Null" }, { "type": "Null" } ] } ], "refs": 3 } } ] }, { "name": "Real test [Integer]", "script": [ "PUSH2", "NEWARRAY_T", "0x21" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Array", "value": [ { "type": "Integer", "value": 0 }, { "type": "Integer", "value": 0 } ] } ], "refs": 3 } } ] }, { "name": "Real test [ByteString]", "script": [ "PUSH2", "NEWARRAY_T", "0x28" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Array", "value": [ { "type": "ByteString", "value": "0x" }, { "type": "ByteString", "value": "0x" } ] } ], "refs": 3 } } ] }, { "name": "Real test [Buffer]", "script": [ "PUSH2", "NEWARRAY_T", "0x30" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Array", "value": [ { "type": "Null" }, { "type": "Null" } ] } ], "refs": 3 } } ] }, { "name": "Real test [Array]", "script": [ "PUSH2", "NEWARRAY_T", "0x40" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Array", "value": [ { "type": "Null" }, { "type": "Null" } ] } ], "refs": 3 } } ] }, { "name": "Real test [Struct]", "script": [ "PUSH2", "NEWARRAY_T", "0x41" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Array", "value": [ { "type": "Null" }, { "type": "Null" } ] } ], "refs": 3 } } ] }, { "name": "Real test [Map]", "script": [ "PUSH2", "NEWARRAY_T", "0x48" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Array", "value": [ { "type": "Null" }, { "type": "Null" } ] } ], "refs": 3 } } ] }, { "name": "Real test [InteropInterface]", "script": [ "PUSH2", "NEWARRAY_T", "0x60" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Array", "value": [ { "type": "Null" }, { "type": "Null" } ] } ], "refs": 3 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/NEWMAP.json ================================================ { "category": "Arrays", "name": "NEWMAP", "tests": [ { "name": "Real test", "script": [ "NEWMAP" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "RET", "evaluationStack": [ { "type": "map", "value": {} } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "map", "value": {} } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/NEWSTRUCT.json ================================================ { "category": "Arrays", "name": "NEWSTRUCT", "tests": [ { "name": "Without push", "script": [ "NEWSTRUCT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With wrong type", "script": [ "NEWMAP", "NEWSTRUCT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With negative push", "script": [ "PUSHM1", "NEWSTRUCT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH2", "NEWSTRUCT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET", "evaluationStack": [ { "type": "struct", "value": [ { "type": "Null" }, { "type": "Null" } ] } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "struct", "value": [ { "type": "Null" }, { "type": "Null" } ] } ], "refs": 3 } } ] }, { "name": "Clone Array to Struct", "script": [ "PUSH1", "NEWARRAY", "DUP", "PUSH0", "PUSH5", "SETITEM", "NEWSTRUCT" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "NEWSTRUCT", "evaluationStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/NEWSTRUCT0.json ================================================ { "category": "Arrays", "name": "NEWSTRUCT0", "tests": [ { "name": "Real test", "script": [ "NEWSTRUCT0" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Struct", "value": [] } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/PACK.json ================================================ { "category": "Arrays", "name": "PACK", "tests": [ { "name": "Real test", "script": [ "PUSH5", "PUSH6", "PUSH2", "PACK" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 6 }, { "type": "Integer", "value": 5 } ] } ], "refs": 3 } } ] }, { "name": "Not enough size", "script": [ "PUSH5", "PUSH2", "PACK" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type [Map]", "script": [ "NEWMAP", "PACK" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type [Array]", "script": [ "PUSH1", "NEWARRAY", "PACK" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type [Struct]", "script": [ "PUSH1", "NEWSTRUCT", "PACK" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Without items", "script": [ "PACK" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/PACKMAP.json ================================================ { "category": "Arrays", "name": "PACKMAP", "tests": [ { "name": "Real test", "script": [ "PUSH5", "PUSH6", "PUSH1", "PACKMAP" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Map", "value": { "0x06": { "type": "Integer", "value": "5" } } } ], "refs": 3 } } ] }, { "name": "Not enough size", "script": [ "PUSH5", "PUSH1", "PACKMAP" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type [Map]", "script": [ "PUSH1", "PUSH1", "NEWMAP", "PACKMAP" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type [Array]", "script": [ "PUSH1", "PUSH1", "NEWARRAY", "PACKMAP" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type [Struct]", "script": [ "PUSH1", "PUSH1", "NEWSTRUCT", "PACKMAP" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Without items", "script": [ "PACKMAP" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/PACKSTRUCT.json ================================================ { "category": "Arrays", "name": "PACK", "tests": [ { "name": "Real test", "script": [ "PUSH5", "PUSH6", "PUSH2", "PACKSTRUCT" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "struct", "value": [ { "type": "Integer", "value": 6 }, { "type": "Integer", "value": 5 } ] } ], "refs": 3 } } ] }, { "name": "Not enough size", "script": [ "PUSH5", "PUSH2", "PACKSTRUCT" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type [Map]", "script": [ "NEWMAP", "PACKSTRUCT" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type [Array]", "script": [ "PUSH1", "NEWARRAY", "PACKSTRUCT" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type [Struct]", "script": [ "PUSH1", "NEWSTRUCT", "PACKSTRUCT" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Without items", "script": [ "PACKSTRUCT" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/PICKITEM.json ================================================ { "category": "Arrays", "name": "PICKITEM", "tests": [ { "name": "Wrong array", "script": [ "PUSH0", "PUSH0", "PICKITEM" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Without push", "script": [ "PICKITEM" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong key type", "script": [ "PUSH1", "NEWARRAY", "NEWMAP", "PICKITEM" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "PICKITEM", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "array", "value": [ { "type": "Null" } ] } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Out of bounds [Array]", "script": [ "PUSH2", "NEWARRAY", "PUSH3", "PICKITEM" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "PICKITEM", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "array", "value": [ { "type": "Null" }, { "type": "Null" } ] } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Out of bounds [Struct]", "script": [ "PUSH2", "NEWSTRUCT", "PUSH3", "PICKITEM" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "PICKITEM", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "struct", "value": [ { "type": "Null" }, { "type": "Null" } ] } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Array]", "script": [ "INITSSLOT", "0x01", "PUSH3", "NEWARRAY", "STSFLD0", "LDSFLD0", "PUSH0", "PUSH1", "SETITEM", "LDSFLD0", "PUSH1", "PUSH2", "SETITEM", "LDSFLD0", "PUSH2", "PUSH3", "SETITEM", "LDSFLD0", "PUSH2", "PICKITEM" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 19, "nextInstruction": "PICKITEM", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "array", "value": [ { "type": "Integer", "value": 1 }, { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 3 } ] } ], "staticFields": [ { "type": "array", "value": [ { "type": "Integer", "value": 1 }, { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 3 } ] } ] } ], "refs": 6 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 20, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 3 } ], "staticFields": [ { "type": "array", "value": [ { "type": "Integer", "value": 1 }, { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 3 } ] } ] } ], "refs": 5 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 3 } ], "refs": 1 } } ] }, { "name": "Real test [Struct]", "script": [ "INITSSLOT", "0x01", "PUSH3", "NEWSTRUCT", "STSFLD0", "LDSFLD0", "PUSH0", "PUSH1", "SETITEM", "LDSFLD0", "PUSH1", "PUSH2", "SETITEM", "LDSFLD0", "PUSH2", "PUSH3", "SETITEM", "LDSFLD0", "PUSH2", "PICKITEM" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 19, "nextInstruction": "PICKITEM", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "struct", "value": [ { "type": "Integer", "value": 1 }, { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 3 } ] } ], "staticFields": [ { "type": "struct", "value": [ { "type": "Integer", "value": 1 }, { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 3 } ] } ] } ], "refs": 6 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 20, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 3 } ], "staticFields": [ { "type": "struct", "value": [ { "type": "Integer", "value": 1 }, { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 3 } ] } ] } ], "refs": 5 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 3 } ], "refs": 1 } } ] }, { "name": "OutOfBounds with -1 [ByteString]", "script": [ "PUSHDATA1", "0x02", "0x0102", "PUSHM1", "PICKITEM" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "PICKITEM", "evaluationStack": [ { "type": "integer", "value": -1 }, { "type": "ByteString", "value": "0x0102" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "OutOfBounds with more than length [ByteString]", "script": [ "PUSHDATA1", "0x02", "0x0102", "PUSH4", "PICKITEM" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "PICKITEM", "evaluationStack": [ { "type": "integer", "value": 4 }, { "type": "ByteString", "value": "0x0102" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [ByteString]", "script": [ "PUSHDATA1", "0x02", "0x0102", "PUSH0", "PICKITEM" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "PICKITEM", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "ByteString", "value": "0x0102" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 1 } ], "refs": 1 } } ] }, { "name": "Real test [Buffer]", "script": [ "PUSHDATA1", "0x02", "0x0102", "CONVERT", "0x30", "PUSH0", "PICKITEM" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "PICKITEM", "evaluationStack": [ { "type": "Integer", "value": 0 }, { "type": "Buffer", "value": "0x0102" } ] } ], "refs": 2 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/POPITEM.json ================================================ { "category": "Arrays", "name": "POPITEM", "tests": [ { "name": "Real test", "script": [ "PUSH0", "PUSH1", "PUSH2", "PACK", "DUP", "POPITEM", "DROP", "DROP" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "POPITEM", "evaluationStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 1 }, { "type": "Integer", "value": 0 } ] }, { "type": "array", "value": [ { "type": "Integer", "value": 1 }, { "type": "Integer", "value": 0 } ] } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "DROP", "evaluationStack": [ { "type": "Integer", "value": 0 }, { "type": "array", "value": [ { "type": "Integer", "value": 1 } ] } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "DROP", "evaluationStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 1 } ] } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/REMOVE.json ================================================ { "category": "Arrays", "name": "REMOVE", "tests": [ { "name": "Without push", "script": [ "PUSH1", "REMOVE" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Without array", "script": [ "PUSH1", "PUSH2", "REMOVE" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong key", "script": [ "PUSH2", "NEWMAP", "REMOVE" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Out of bounds", "script": [ "PUSH6", "PUSH5", "PUSH2", "PACK", "PUSH2", "REMOVE" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Array]", "script": [ "INITSSLOT", "0x01", "PUSH6", "PUSH5", "PUSH2", "PACK", "STSFLD0", "LDSFLD0", "PUSH0", "REMOVE", "LDSFLD0", "UNPACK" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 9, "nextInstruction": "REMOVE", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "array", "value": [ { "type": "Integer", "value": 5 }, { "type": "Integer", "value": 6 } ] } ], "staticFields": [ { "type": "array", "value": [ { "type": "Integer", "value": 5 }, { "type": "Integer", "value": 6 } ] } ] } ], "refs": 5 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "LDSFLD0", "staticFields": [ { "type": "array", "value": [ { "type": "Integer", "value": 6 } ] } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 6 } ], "refs": 2 } } ] }, { "name": "Real test [Struct]", "script": [ "INITSSLOT", "0x01", "PUSH0", "NEWSTRUCT", "DUP", "PUSH5", "APPEND", "STSFLD0", "LDSFLD0", "PUSH0", "REMOVE", "LDSFLD0", "UNPACK" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "REMOVE", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "struct", "value": [ { "type": "Integer", "value": 5 } ] } ], "staticFields": [ { "type": "struct", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 11, "nextInstruction": "LDSFLD0", "staticFields": [ { "type": "struct", "value": [] } ] } ], "refs": 1 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 0 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/REVERSEITEMS.json ================================================ { "category": "Arrays", "name": "REVERSEITEMS", "tests": [ { "name": "Without push", "script": [ "REVERSEITEMS" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without Array", "script": [ "PUSH9", "REVERSEITEMS" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Array]", "script": [ "PUSH9", "PUSH8", "PUSH2", "PACK", "DUP", "REVERSEITEMS" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RET", "evaluationStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 9 }, { "type": "Integer", "value": 8 } ] } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 9 }, { "type": "Integer", "value": 8 } ] } ], "refs": 3 } } ] }, { "name": "Real test [Buffer]", "script": [ "PUSHDATA1", "0x03", "0x010203", "CONVERT", "0x30", "DUP", "REVERSEITEMS" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Buffer", "value": "0x030201" } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/SETITEM.json ================================================ { "category": "Arrays", "name": "SETITEM", "tests": [ { "name": "Map in key", "script": [ "PUSH1", "NEWMAP", "PUSH0", "SETITEM" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "SETITEM", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "map", "value": {} }, { "type": "integer", "value": 1 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without array", "script": [ "PUSH0", "PUSH0", "PUSH0", "SETITEM" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "SETITEM", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 0 }, { "type": "integer", "value": 0 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without push", "script": [ "SETITEM" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Out of bounds [Array]", "script": [ "PUSH1", "NEWARRAY", "PUSH1", "PUSH5", "SETITEM" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "SETITEM", "evaluationStack": [ { "type": "integer", "value": 5 }, { "type": "integer", "value": 1 }, { "type": "array", "value": [ { "type": "Null" } ] } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Out of bounds [Struct]", "script": [ "PUSH1", "NEWSTRUCT", "PUSH1", "PUSH5", "SETITEM" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "SETITEM", "evaluationStack": [ { "type": "integer", "value": 5 }, { "type": "integer", "value": 1 }, { "type": "struct", "value": [ { "type": "Null" } ] } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Map]", "script": [ "INITSSLOT", "0x01", "NEWMAP", "DUP", "STSFLD0", "PUSH1", "PUSH2", "SETITEM", "LDSFLD0", "PUSH3", "PUSH4", "SETITEM", "LDSFLD0", "PUSH1", "PUSH2", "SETITEM", "LDSFLD0", "RET" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "map", "value": {} } ], "staticFields": [ { "type": "map", "value": {} } ] } ], "refs": 2 } }, { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "SETITEM", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 }, { "type": "map", "value": {} } ], "staticFields": [ { "type": "map", "value": {} } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "LDSFLD0", "staticFields": [ { "type": "map", "value": { "0x01": { "type": "Integer", "value": 2 } } } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 9, "nextInstruction": "PUSH3", "evaluationStack": [ { "type": "map", "value": { "0x01": { "type": "Integer", "value": 2 } } } ], "staticFields": [ { "type": "map", "value": { "0x01": { "type": "Integer", "value": 2 } } } ] } ], "refs": 4 } }, { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 13, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "map", "value": { "0x01": { "type": "Integer", "value": 2 }, "0x03": { "type": "Integer", "value": 4 } } } ], "staticFields": [ { "type": "map", "value": { "0x01": { "type": "Integer", "value": 2 }, "0x03": { "type": "Integer", "value": 4 } } } ] } ], "refs": 6 } }, { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "map", "value": { "0x01": { "type": "Integer", "value": 2 }, "0x03": { "type": "Integer", "value": 4 } } } ], "refs": 5 } } ] }, { "name": "Real test [Array]", "script": [ "PUSH1", "NEWARRAY", "DUP", "PUSH0", "PUSH5", "SETITEM" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "SETITEM", "evaluationStack": [ { "type": "integer", "value": 5 }, { "type": "integer", "value": 0 }, { "type": "array", "value": [ { "type": "Null" } ] }, { "type": "array", "value": [ { "type": "Null" } ] } ] } ], "refs": 5 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RET", "evaluationStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 5 } ] } ], "refs": 2 } } ] }, { "name": "Real test [Struct]", "script": [ "PUSH1", "NEWSTRUCT", "DUP", "PUSH0", "PUSH5", "SETITEM" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "SETITEM", "evaluationStack": [ { "type": "integer", "value": 5 }, { "type": "integer", "value": 0 }, { "type": "struct", "value": [ { "type": "Null" } ] }, { "type": "struct", "value": [ { "type": "Null" } ] } ] } ], "refs": 5 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RET", "evaluationStack": [ { "type": "struct", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "struct", "value": [ { "type": "Integer", "value": 5 } ] } ], "refs": 2 } } ] }, { "name": "Clone test [Array]", "script": [ "INITSSLOT", "0x01", "PUSH1", "NEWARRAY", "DUP", "PUSH0", "PUSH5", "SETITEM", "STSFLD0", "LDSFLD0", "DUP", "PUSH0", "PUSH4", "SETITEM", "LDSFLD0" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "PUSH0", "evaluationStack": [ { "type": "array", "value": [ { "type": "Null" } ] }, { "type": "array", "value": [ { "type": "Null" } ] } ], "staticFields": [ { "type": "Null" } ] } ], "refs": 4 } }, { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "STSFLD0", "evaluationStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 5 } ] } ], "staticFields": [ { "type": "Null" } ] } ], "refs": 3 } }, { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 11, "nextInstruction": "PUSH0", "evaluationStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 5 } ] }, { "type": "array", "value": [ { "type": "Integer", "value": 5 } ] } ], "staticFields": [ { "type": "array", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "refs": 4 } }, { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 14, "nextInstruction": "LDSFLD0", "evaluationStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 4 } ] } ], "staticFields": [ { "type": "array", "value": [ { "type": "Integer", "value": 4 } ] } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 15, "nextInstruction": "RET", "evaluationStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 4 } ] }, { "type": "array", "value": [ { "type": "Integer", "value": 4 } ] } ], "staticFields": [ { "type": "array", "value": [ { "type": "Integer", "value": 4 } ] } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 4 } ] }, { "type": "array", "value": [ { "type": "Integer", "value": 4 } ] } ], "refs": 3 } } ] }, { "name": "Clone test [Struct]", "script": [ "INITSSLOT", "0x01", "PUSH1", "NEWSTRUCT", "DUP", "PUSH0", "PUSH5", "SETITEM", "STSFLD0", "LDSFLD0", "DUP", "PUSH0", "PUSH4", "SETITEM", "LDSFLD0" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "PUSH0", "evaluationStack": [ { "type": "struct", "value": [ { "type": "Null" } ] }, { "type": "struct", "value": [ { "type": "Null" } ] } ], "staticFields": [ { "type": "Null" } ] } ], "refs": 4 } }, { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "STSFLD0", "evaluationStack": [ { "type": "struct", "value": [ { "type": "Integer", "value": 5 } ] } ], "staticFields": [ { "type": "Null" } ] } ], "refs": 3 } }, { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 11, "nextInstruction": "PUSH0", "evaluationStack": [ { "type": "struct", "value": [ { "type": "Integer", "value": 5 } ] }, { "type": "struct", "value": [ { "type": "Integer", "value": 5 } ] } ], "staticFields": [ { "type": "struct", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "refs": 4 } }, { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 14, "nextInstruction": "LDSFLD0", "evaluationStack": [ { "type": "struct", "value": [ { "type": "Integer", "value": 4 } ] } ], "staticFields": [ { "type": "struct", "value": [ { "type": "Integer", "value": 4 } ] } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 15, "nextInstruction": "RET", "evaluationStack": [ { "type": "struct", "value": [ { "type": "Integer", "value": 4 } ] }, { "type": "struct", "value": [ { "type": "Integer", "value": 4 } ] } ], "staticFields": [ { "type": "struct", "value": [ { "type": "Integer", "value": 4 } ] } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "struct", "value": [ { "type": "Integer", "value": 4 } ] }, { "type": "struct", "value": [ { "type": "Integer", "value": 4 } ] } ], "refs": 3 } } ] }, { "name": "Real test [Buffer]", "script": [ "PUSHDATA1", "0x02", "0x0102", "CONVERT", "0x30", "DUP", "PUSH0", "PUSH5", "SETITEM" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 9, "nextInstruction": "SETITEM", "evaluationStack": [ { "type": "Integer", "value": 5 }, { "type": "Integer", "value": 0 }, { "type": "Buffer", "value": "0x0102" }, { "type": "Buffer", "value": "0x0102" } ] } ], "refs": 4 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Buffer", "value": "0x0502" } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/SIZE.json ================================================ { "category": "Arrays", "name": "SIZE", "tests": [ { "name": "Wrong type SYSCALL[0x77777777]+SIZE", "script": [ "SYSCALL", "0x77777777", "SIZE" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "SIZE", "evaluationStack": [ { "type": "interop", "value": "Object" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without PUSH+SIZE", "script": [ "SIZE" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test with ByteString", "script": [ "PUSHDATA1", "0x01", "0x00", "SIZE" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 1 } ], "refs": 1 } } ] }, { "name": "Real test with Buffer", "script": [ "PUSH10", "NEWBUFFER", "SIZE" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 10 } ], "refs": 1 } } ] }, { "name": "Real test with array", "script": [ "PUSH3", "NEWARRAY", "SIZE" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 3 } ] } ], "refs": 1 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 3 } ], "refs": 1 } } ] }, { "name": "Real test with struct", "script": [ "PUSH3", "NEWSTRUCT", "SIZE" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 3 } ] } ], "refs": 1 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 3 } ], "refs": 1 } } ] }, { "name": "Real test with map", "script": [ "NEWMAP", "SIZE" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 0 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/UNPACK.json ================================================ { "category": "Arrays", "name": "UNPACK", "tests": [ { "name": "Without array", "script": [ "PUSH10", "UNPACK" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without push", "script": [ "UNPACK" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without push", "script": [ "PUSH5", "PUSH6", "PUSH2", "PACK", "UNPACK" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "UNPACK", "evaluationStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 6 }, { "type": "Integer", "value": 5 } ] } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 6 }, { "type": "integer", "value": 5 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 6 }, { "type": "integer", "value": 5 } ], "refs": 3 } } ] }, { "name": "With map", "script": [ "PUSH5", "PUSH6", "PUSH1", "PACKMAP", "UNPACK" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 }, { "type": "Integer", "value": 6 }, { "type": "Integer", "value": 5 } ], "refs": 3 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Arrays/VALUES.json ================================================ { "category": "Arrays", "name": "VALUES", "tests": [ { "name": "No StackItem", "script": [ "KEYS" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Invalid StackItem [Integer != (Map|Array|Struct)]", "script": [ "PUSH0", "KEYS" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Values in map", "script": [ "NEWMAP", "DUP", "DUP", "PUSH0", "PUSH2", "SETITEM", "PUSH1", "PUSH4", "SETITEM", "VALUES" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 4 } ] } ], "refs": 3 } } ] }, { "name": "Simple values in array", "script": [ "PUSH2", "NEWARRAY_T", "0x00", "VALUES" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "array", "value": [ { "type": "Null" }, { "type": "Null" } ] } ], "refs": 3 } } ] }, { "name": "Compound value in array [inner struct]", "script": [ "PUSH1", "NEWARRAY", "DUP", "PUSH0", "PUSH2", "NEWSTRUCT", "SETITEM", "VALUES" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "array", "value": [ { "type": "struct", "value": [ { "type": "Null" }, { "type": "Null" } ] } ] } ], "refs": 4 } } ] }, { "name": "Compound value in array [inner map]", "script": [ "PUSH1", "NEWARRAY", "DUP", "PUSH0", "NEWMAP", "DUP", "PUSH0", "PUSH1", "SETITEM", "SETITEM", "VALUES" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "array", "value": [ { "type": "map", "value": { "": { "type": "Integer", "value": 1 } } } ] } ], "refs": 4 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/BitwiseLogic/AND.json ================================================ { "category": "Bitwise Logic", "name": "AND", "tests": [ { "name": "Without two pushes", "script": [ "AND" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one push", "script": [ "PUSH0", "AND" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "AND", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [true,true]=1", "script": [ "PUSH0", "NOT", "PUSH0", "NOT", "AND" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "AND", "evaluationStack": [ { "type": "boolean", "value": true }, { "type": "boolean", "value": true } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] }, { "name": "Real test [false,true]=0", "script": [ "PUSH0", "NOT", "PUSH0", "NOT", "NOT", "AND" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "AND", "evaluationStack": [ { "type": "boolean", "value": false }, { "type": "boolean", "value": true } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 0 } ], "refs": 1 } } ] }, { "name": "Real test [1,1]=1", "script": [ "PUSH1", "PUSH1", "AND" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "AND", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] }, { "name": "Real test [1,2]=0", "script": [ "PUSH2", "PUSH1", "AND" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "AND", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 0 } ], "refs": 1 } } ] }, { "name": "Real test [Array,Array]=FAULT", "script": [ "PUSH0", "NEWARRAY", "DUP", "AND" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "AND", "evaluationStack": [ { "type": "array", "value": [] }, { "type": "array", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Struct,Struct]=FAULT", "script": [ "PUSH0", "NEWSTRUCT", "DUP", "AND" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "AND", "evaluationStack": [ { "type": "struct", "value": [] }, { "type": "struct", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Map,Map]=FAULT", "script": [ "NEWMAP", "DUP", "AND" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "AND", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "map", "value": {} } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [ByteString,ByteString]=11911212070228631137091015067172167745536", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "AND" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "AND", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000123" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 39, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": "11911212070228631137091015067172167745536" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": "11911212070228631137091015067172167745536" } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=10890364969465815746700891244876863111168", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x11", "0x0000000000000000000000000000000124", "AND" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "AND", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 39, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": "10890364969465815746700891244876863111168" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": "10890364969465815746700891244876863111168" } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=0", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x10", "0x00000000000000000000000000000124", "AND" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 37, "nextInstruction": "AND", "evaluationStack": [ { "type": "ByteString", "value": "0x00000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 0 } ], "refs": 1 } } ] }, { "name": "Real test with clone [Interop,Interop]=FAULT", "script": [ "SYSCALL", "0x77777777", "DUP", "AND" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "DUP", "evaluationStack": [ { "type": "interop", "value": "Object" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "AND", "evaluationStack": [ { "type": "interop", "value": "Object" }, { "type": "interop", "value": "Object" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Buffer,Buffer]=FAULT", "script": [ "PUSHDATA1", "0x01AA", "CONVERT", "0x30", "PUSHDATA1", "0x01BB", "CONVERT", "0x30", "AND" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "AND", "evaluationStack": [ { "type": "Buffer", "value": "0xBB" }, { "type": "Buffer", "value": "0xAA" } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/BitwiseLogic/EQUAL.json ================================================ { "category": "Bitwise Logic", "name": "EQUAL same types", "tests": [ { "name": "Without two pushes", "script": [ "EQUAL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one push", "script": [ "PUSH0", "EQUAL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Bool,Bool]=true", "script": [ "PUSH0", "NOT", "PUSH0", "NOT", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "boolean", "value": true }, { "type": "boolean", "value": true } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Bool,Bool]=false", "script": [ "PUSH0", "NOT", "PUSH0", "NOT", "NOT", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "boolean", "value": false }, { "type": "boolean", "value": true } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RET", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Integer,Integer]=true", "script": [ "PUSH1", "PUSH1", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Integer,Integer]=false", "script": [ "PUSH2", "PUSH1", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Array,Array]=true", "script": [ "PUSH0", "NEWARRAY", "DUP", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "array", "value": [] }, { "type": "array", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Array,Array]=false", "script": [ "PUSH0", "NEWARRAY", "PUSH0", "NEWARRAY", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "array", "value": [] }, { "type": "array", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Struct,Struct]=true with clone", "script": [ "PUSH0", "NEWSTRUCT", "DUP", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "struct", "value": [] }, { "type": "struct", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Struct,Struct]=true without clone", "script": [ "PUSH0", "NEWSTRUCT", "PUSH0", "NEWSTRUCT", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "struct", "value": [] }, { "type": "struct", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Struct,Struct]=false", "script": [ "PUSH0", "NEWSTRUCT", "PUSH1", "NEWSTRUCT", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "struct", "value": [ { "type": "Null" } ] }, { "type": "struct", "value": [] } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Map,Map]=true", "script": [ "NEWMAP", "DUP", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "map", "value": {} } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Map,Map]=false", "script": [ "NEWMAP", "NEWMAP", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "map", "value": {} } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=true", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000123" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 39, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=false same length", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x11", "0x0000000000000000000000000000000124", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 39, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=false different length", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x10", "0x00000000000000000000000000000124", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 37, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "ByteString", "value": "0x00000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=false different length", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x10", "0x00000000000000000000000000000124", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 37, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "ByteString", "value": "0x00000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test with clone [Interop,Interop]=true", "script": [ "SYSCALL", "0x77777777", "DUP", "EQUAL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "DUP", "evaluationStack": [ { "type": "interop", "value": "Object" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "interop", "value": "Object" }, { "type": "interop", "value": "Object" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Interop,Interop]=false", "script": [ "SYSCALL", "0x77777777", "SYSCALL", "0x77777777", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "interop", "value": "Object" }, { "type": "interop", "value": "Object" } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Buffer,Buffer]=false", "script": [ "PUSHDATA1", "0x01AA", "CONVERT", "0x30", "PUSHDATA1", "0x01BB", "CONVERT", "0x30", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "Buffer", "value": "0xBB" }, { "type": "Buffer", "value": "0xAA" } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Buffer,Buffer]=false", "script": [ "PUSHDATA1", "0x01AA", "CONVERT", "0x30", "PUSHDATA1", "0x01AA", "CONVERT", "0x30", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "Buffer", "value": "0xAA" }, { "type": "Buffer", "value": "0xAA" } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Buffer,Buffer]=true", "script": [ "PUSHDATA1", "0x01AA", "CONVERT", "0x30", "DUP", "EQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "EQUAL", "evaluationStack": [ { "type": "Buffer", "value": "0xAA" }, { "type": "Buffer", "value": "0xAA" } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/BitwiseLogic/INVERT.json ================================================ { "category": "Bitwise Logic", "name": "INVERT", "tests": [ { "name": "Without two pushes", "script": [ "INVERT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With 0", "script": [ "PUSH0", "INVERT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "INVERT", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": -1 } ], "refs": 1 } } ] }, { "name": "Real test [true]=-2", "script": [ "PUSH0", "NOT", "INVERT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "INVERT", "evaluationStack": [ { "type": "boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": -2 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": -2 } ], "refs": 1 } } ] }, { "name": "Real test [false]=-1", "script": [ "PUSH0", "NOT", "NOT", "INVERT" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "INVERT", "evaluationStack": [ { "type": "boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": -1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": -1 } ], "refs": 1 } } ] }, { "name": "Real test [1]=-2", "script": [ "PUSH1", "INVERT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "INVERT", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": -2 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": -2 } ], "refs": 1 } } ] }, { "name": "Real test [2]=-3", "script": [ "PUSH2", "INVERT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "INVERT", "evaluationStack": [ { "type": "integer", "value": 2 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": -3 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": -3 } ], "refs": 1 } } ] }, { "name": "Real test [Array]=FAULT", "script": [ "PUSH0", "NEWARRAY", "INVERT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "INVERT", "evaluationStack": [ { "type": "array", "value": [] } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Struct]=FAULT", "script": [ "PUSH0", "NEWSTRUCT", "INVERT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "INVERT", "evaluationStack": [ { "type": "struct", "value": [] } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Map]=FAULT", "script": [ "NEWMAP", "INVERT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "INVERT", "evaluationStack": [ { "type": "map", "value": {} } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [ByteString]=-11911212070228631137091015067172167745537", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "INVERT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 19, "nextInstruction": "INVERT", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 20, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": "-11911212070228631137091015067172167745537" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": "-11911212070228631137091015067172167745537" } ], "refs": 1 } } ] }, { "name": "Real test [ByteString]=-12251494437149569600554389674603935956993", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000124", "INVERT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 19, "nextInstruction": "INVERT", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000124" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 20, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": "-12251494437149569600554389674603935956993" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": "-12251494437149569600554389674603935956993" } ], "refs": 1 } } ] }, { "name": "Real test with clone [Interop]=FAULT", "script": [ "SYSCALL", "0x77777777", "INVERT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "INVERT", "evaluationStack": [ { "type": "interop", "value": "Object" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Buffer,Buffer]=FAULT", "script": [ "PUSHDATA1", "0x01AA", "CONVERT", "0x30", "PUSHDATA1", "0x01BB", "CONVERT", "0x30", "INVERT" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "INVERT", "evaluationStack": [ { "type": "Buffer", "value": "0xBB" }, { "type": "Buffer", "value": "0xAA" } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/BitwiseLogic/NOTEQUAL.json ================================================ { "category": "Bitwise Logic", "name": "NOTEQUAL", "tests": [ { "name": "Without two pushes", "script": [ "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one push", "script": [ "PUSH0", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "StepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Integer,Integer]=false", "script": [ "PUSH1", "PUSH1", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Integer,Integer]=true", "script": [ "PUSH2", "PUSH1", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Array,Array]=false", "script": [ "PUSH0", "NEWARRAY", "DUP", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "array", "value": [] }, { "type": "array", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Array,Array]=true", "script": [ "PUSH0", "NEWARRAY", "PUSH0", "NEWARRAY", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "array", "value": [] }, { "type": "array", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Struct,Struct]=false with clone", "script": [ "PUSH0", "NEWSTRUCT", "DUP", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "struct", "value": [] }, { "type": "struct", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Struct,Struct]=false without clone", "script": [ "PUSH0", "NEWSTRUCT", "PUSH0", "NEWSTRUCT", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "struct", "value": [] }, { "type": "struct", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Struct,Struct]=true", "script": [ "PUSH0", "NEWSTRUCT", "PUSH1", "NEWSTRUCT", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "struct", "value": [ { "type": "Null" } ] }, { "type": "struct", "value": [] } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Map,Map]=false", "script": [ "NEWMAP", "DUP", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "map", "value": {} } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Map,Map]=true", "script": [ "NEWMAP", "NEWMAP", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "map", "value": {} } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=false", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000123" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 39, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=true same length", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x11", "0x0000000000000000000000000000000124", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 39, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=true different length", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x10", "0x00000000000000000000000000000124", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 37, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "ByteString", "value": "0x00000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=true different length", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x10", "0x00000000000000000000000000000124", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 37, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "ByteString", "value": "0x00000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test with clone [Interop,Interop]=false", "script": [ "SYSCALL", "0x77777777", "DUP", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "DUP", "evaluationStack": [ { "type": "interop", "value": "Object" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "interop", "value": "Object" }, { "type": "interop", "value": "Object" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Real test [Interop,Interop]=true", "script": [ "SYSCALL", "0x77777777", "SYSCALL", "0x77777777", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "interop", "value": "Object" }, { "type": "interop", "value": "Object" } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Buffer,Buffer]=true", "script": [ "PUSHDATA1", "0x01AA", "CONVERT", "0x30", "PUSHDATA1", "0x01BB", "CONVERT", "0x30", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "Buffer", "value": "0xBB" }, { "type": "Buffer", "value": "0xAA" } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Buffer,Buffer]=true", "script": [ "PUSHDATA1", "0x01AA", "CONVERT", "0x30", "PUSHDATA1", "0x01AA", "CONVERT", "0x30", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "Buffer", "value": "0xAA" }, { "type": "Buffer", "value": "0xAA" } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Real test [Buffer,Buffer]=false", "script": [ "PUSHDATA1", "0x01AA", "CONVERT", "0x30", "DUP", "NOTEQUAL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "NOTEQUAL", "evaluationStack": [ { "type": "Buffer", "value": "0xAA" }, { "type": "Buffer", "value": "0xAA" } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/BitwiseLogic/OR.json ================================================ { "category": "Bitwise Logic", "name": "OR", "tests": [ { "name": "Without two pushes", "script": [ "OR" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one push", "script": [ "PUSH0", "OR" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "OR", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [true,true]=1", "script": [ "PUSH0", "NOT", "PUSH0", "NOT", "OR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "OR", "evaluationStack": [ { "type": "boolean", "value": true }, { "type": "boolean", "value": true } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] }, { "name": "Real test [false,true]=1", "script": [ "PUSH0", "NOT", "PUSH0", "NOT", "NOT", "OR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "OR", "evaluationStack": [ { "type": "boolean", "value": false }, { "type": "boolean", "value": true } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] }, { "name": "Real test [1,1]=1", "script": [ "PUSH1", "PUSH1", "OR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "OR", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] }, { "name": "Real test [1,2]=3", "script": [ "PUSH2", "PUSH1", "OR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "OR", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 3 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 3 } ], "refs": 1 } } ] }, { "name": "Real test [Array,Array]=FAULT", "script": [ "PUSH0", "NEWARRAY", "DUP", "OR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "OR", "evaluationStack": [ { "type": "array", "value": [] }, { "type": "array", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Struct,Struct]=FAULT", "script": [ "PUSH0", "NEWSTRUCT", "DUP", "OR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "OR", "evaluationStack": [ { "type": "struct", "value": [] }, { "type": "struct", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Map,Map]=FAULT", "script": [ "NEWMAP", "DUP", "OR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "OR", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "map", "value": {} } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [ByteString,ByteString]=11911212070228631137091015067172167745536", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "OR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "OR", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000123" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 39, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": "11911212070228631137091015067172167745536" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": "11911212070228631137091015067172167745536" } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=13272341537912384990944513496899240591360", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x11", "0x0000000000000000000000000000000124", "OR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "OR", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 39, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": "13272341537912384990944513496899240591360" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": "13272341537912384990944513496899240591360" } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=11959069470373746643343180651838589370368", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x10", "0x00000000000000000000000000000124", "OR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 37, "nextInstruction": "OR", "evaluationStack": [ { "type": "ByteString", "value": "0x00000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": "11959069470373746643343180651838589370368" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": "11959069470373746643343180651838589370368" } ], "refs": 1 } } ] }, { "name": "Real test with clone [Interop,Interop]=FAULT", "script": [ "SYSCALL", "0x77777777", "DUP", "OR" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "DUP", "evaluationStack": [ { "type": "interop", "value": "Object" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "OR", "evaluationStack": [ { "type": "interop", "value": "Object" }, { "type": "interop", "value": "Object" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Buffer,Buffer]=FAULT", "script": [ "PUSHDATA1", "0x01AA", "CONVERT", "0x30", "PUSHDATA1", "0x01BB", "CONVERT", "0x30", "OR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "OR", "evaluationStack": [ { "type": "Buffer", "value": "0xBB" }, { "type": "Buffer", "value": "0xAA" } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/BitwiseLogic/XOR.json ================================================ { "category": "Bitwise Logic", "name": "XOR", "tests": [ { "name": "Without two pushes", "script": [ "XOR" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one push", "script": [ "PUSH0", "XOR" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "XOR", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [true,true]=0", "script": [ "PUSH0", "NOT", "PUSH0", "NOT", "XOR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "XOR", "evaluationStack": [ { "type": "boolean", "value": true }, { "type": "boolean", "value": true } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 0 } ], "refs": 1 } } ] }, { "name": "Real test [false,true]=1", "script": [ "PUSH0", "NOT", "PUSH0", "NOT", "NOT", "XOR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "XOR", "evaluationStack": [ { "type": "boolean", "value": false }, { "type": "boolean", "value": true } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] }, { "name": "Real test [1,1]=0", "script": [ "PUSH1", "PUSH1", "XOR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "XOR", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 0 } ], "refs": 1 } } ] }, { "name": "Real test [1,2]=3", "script": [ "PUSH2", "PUSH1", "XOR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "XOR", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 3 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 3 } ], "refs": 1 } } ] }, { "name": "Real test [Array,Array]=FAULT", "script": [ "PUSH0", "NEWARRAY", "DUP", "XOR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "XOR", "evaluationStack": [ { "type": "array", "value": [] }, { "type": "array", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Struct,Struct]=FAULT", "script": [ "PUSH0", "NEWSTRUCT", "DUP", "XOR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "XOR", "evaluationStack": [ { "type": "struct", "value": [] }, { "type": "struct", "value": [] } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Map,Map]=FAULT", "script": [ "NEWMAP", "DUP", "XOR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "XOR", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "map", "value": {} } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [ByteString,ByteString]=0", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "XOR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "XOR", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000123" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 39, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 0 } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=2381976568446569244243622252022377480192", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x11", "0x0000000000000000000000000000000124", "XOR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "XOR", "evaluationStack": [ { "type": "ByteString", "value": "0x0000000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 39, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": "2381976568446569244243622252022377480192" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": "2381976568446569244243622252022377480192" } ], "refs": 1 } } ] }, { "name": "Real test [ByteString,ByteString]=11959069470373746643343180651838589370368", "script": [ "PUSHDATA1", "0x11", "0x0000000000000000000000000000000123", "PUSHDATA1", "0x10", "0x00000000000000000000000000000124", "XOR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 37, "nextInstruction": "XOR", "evaluationStack": [ { "type": "ByteString", "value": "0x00000000000000000000000000000124" }, { "type": "ByteString", "value": "0x0000000000000000000000000000000123" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 38, "nextInstruction": "RET", "evaluationStack": [ { "type": "Integer", "value": "11959069470373746643343180651838589370368" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": "11959069470373746643343180651838589370368" } ], "refs": 1 } } ] }, { "name": "Real test with clone [Interop,Interop]=FAULT", "script": [ "SYSCALL", "0x77777777", "DUP", "XOR" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "DUP", "evaluationStack": [ { "type": "interop", "value": "Object" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "XOR", "evaluationStack": [ { "type": "interop", "value": "Object" }, { "type": "interop", "value": "Object" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Buffer,Buffer]=FAULT", "script": [ "PUSHDATA1", "0x01AA", "CONVERT", "0x30", "PUSHDATA1", "0x01BB", "CONVERT", "0x30", "XOR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "XOR", "evaluationStack": [ { "type": "Buffer", "value": "0xBB" }, { "type": "Buffer", "value": "0xAA" } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/ABORT.json ================================================ { "category": "Control", "name": "ABORT", "tests": [ { "name": "Basic Test", "script": [ "ABORT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/ABORTMSG.json ================================================ { "category": "Control", "name": "ABORTMSG", "tests": [ { "name": "Basic Test", "script": [ "PUSHDATA1", "0x03", "0x4e454f", "ABORTMSG" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT", "exceptionMessage": "ABORTMSG is executed. Reason: NEO" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/ASSERT.json ================================================ { "category": "Control", "name": "ASSERT", "tests": [ { "name": "Fault Test", "script": [ "PUSH0", "ASSERT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Halt Test", "script": [ "PUSH1", "ASSERT" ], "steps": [ { "actions": [ "stepInto", "execute" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/ASSERTMSG.json ================================================ { "category": "Control", "name": "ASSERTMSG", "tests": [ { "name": "Fault Test", "script": [ "PUSH0", "PUSHDATA1", "0x04", "0x4641494c", "ASSERTMSG" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT", "exceptionMessage": "ASSERTMSG is executed with false result. Reason: FAIL" } } ] }, { "name": "Halt Test", "script": [ "PUSH1", "PUSHDATA1", "0x04", "0x50415353", "ASSERTMSG" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/CALL.json ================================================ { "category": "Control", "name": "CALL", "tests": [ { "name": "Error negative", "script": [ "CALL", "0xFF00" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Error out of bounds", "script": [ "CALL", "0x0A" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "CALL", "0x03", "RET", "PUSH0", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "PUSH0" }, { "instructionPointer": 2, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 0 } ] }, { "instructionPointer": 2, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 0 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/CALLA.json ================================================ { "category": "Control", "name": "CALLA", "tests": [ { "name": "Wrong type", "script": [ "PUSH2", "CALLA" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "CALLA", "evaluationStack": [ { "type": "integer", "value": 2 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSHA", "0x07000000", "CALLA", "RET", "PUSH0", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "CALLA", "evaluationStack": [ { "type": "pointer", "value": 7 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "PUSH0" }, { "instructionPointer": 6, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 0 } ] }, { "instructionPointer": 6, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 0 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/CALL_L.json ================================================ { "category": "Control", "name": "CALL_L", "tests": [ { "name": "Error negative", "script": [ "CALL_L", "0x000000FF" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Error out of bounds", "script": [ "CALL_L", "0x0A000000" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "CALL_L", "0x06000000", "RET", "PUSH0", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "PUSH0" }, { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 0 } ] }, { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 0 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMP.json ================================================ { "category": "Control", "name": "JMP", "tests": [ { "name": "Out of range [<0]", "script": [ "JMP", "0xff", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Out of range [>length]", "script": [ "JMP", "0x7f", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "JMP", "0x02", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMPEQ.json ================================================ { "category": "Control", "name": "JMPEQ", "tests": [ { "name": "Without all items", "script": [ "JMPEQ", "0x00" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one", "script": [ "PUSH1", "JMPEQ", "0x00" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [>]", "script": [ "PUSH1", "PUSH0", "JMPEQ", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH0", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPEQ", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [==]", "script": [ "PUSH1", "PUSH1", "JMPEQ", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPEQ", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [<]", "script": [ "PUSH0", "PUSH1", "JMPEQ", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPEQ", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMPEQ_L.json ================================================ { "category": "Control", "name": "JMPEQ_L", "tests": [ { "name": "Without all items", "script": [ "JMPEQ_L", "0x00000000" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one", "script": [ "PUSH1", "JMPEQ_L", "0x00000000" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [>]", "script": [ "PUSH1", "PUSH0", "JMPEQ_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH0", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPEQ_L", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [==]", "script": [ "PUSH1", "PUSH1", "JMPEQ_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPEQ_L", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [<]", "script": [ "PUSH0", "PUSH1", "JMPEQ_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPEQ_L", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMPGE.json ================================================ { "category": "Control", "name": "JMPGE", "tests": [ { "name": "Without all items", "script": [ "JMPGE", "0x00" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one", "script": [ "PUSH1", "JMPGE", "0x00" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [>]", "script": [ "PUSH1", "PUSH0", "JMPGE", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH0", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPGE", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [==]", "script": [ "PUSH1", "PUSH1", "JMPGE", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPGE", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [<]", "script": [ "PUSH0", "PUSH1", "JMPGE", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPGE", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMPGE_L.json ================================================ { "category": "Control", "name": "JMPGE_L", "tests": [ { "name": "Without all items", "script": [ "JMPGE_L", "0x00000000" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one", "script": [ "PUSH1", "JMPGE_L", "0x00000000" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [>]", "script": [ "PUSH1", "PUSH0", "JMPGE_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH0", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPGE_L", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [==]", "script": [ "PUSH1", "PUSH1", "JMPGE_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPGE_L", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [<]", "script": [ "PUSH0", "PUSH1", "JMPGE_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPGE_L", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMPGT.json ================================================ { "category": "Control", "name": "JMPGT", "tests": [ { "name": "Without all items", "script": [ "JMPGT", "0x00" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one", "script": [ "PUSH1", "JMPGT", "0x00" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [>]", "script": [ "PUSH1", "PUSH0", "JMPGT", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH0", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPGT", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [==]", "script": [ "PUSH1", "PUSH1", "JMPGT", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPGT", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [<]", "script": [ "PUSH0", "PUSH1", "JMPGT", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPGT", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMPGT_L.json ================================================ { "category": "Control", "name": "JMPGT_L", "tests": [ { "name": "Without all items", "script": [ "JMPGT_L", "0x00000000" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one", "script": [ "PUSH1", "JMPGT_L", "0x00000000" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [>]", "script": [ "PUSH1", "PUSH0", "JMPGT_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH0", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPGT_L", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [==]", "script": [ "PUSH1", "PUSH1", "JMPGT_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPGT_L", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [<]", "script": [ "PUSH0", "PUSH1", "JMPGT_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPGT_L", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMPIF.json ================================================ { "category": "Control", "name": "JMPIF", "tests": [ { "name": "Without items", "script": [ "JMPIF", "0x00" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [1]", "script": [ "PUSH1", "JMPIF", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "JMPIF", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [0]", "script": [ "PUSH0", "JMPIF", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "JMPIF", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMPIFNOT.json ================================================ { "category": "Control", "name": "JMPIFNOT", "tests": [ { "name": "Without items", "script": [ "JMPIFNOT", "0x00" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [1]", "script": [ "PUSH1", "JMPIFNOT", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "JMPIFNOT", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [0]", "script": [ "PUSH0", "JMPIFNOT", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "JMPIFNOT", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMPIFNOT_L.json ================================================ { "category": "Control", "name": "JMPIFNOT_L", "tests": [ { "name": "Without items", "script": [ "JMPIFNOT_L", "0x00000000" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [1]", "script": [ "PUSH1", "JMPIFNOT_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "JMPIFNOT_L", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [0]", "script": [ "PUSH0", "JMPIFNOT_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "JMPIFNOT_L", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMPIF_L.json ================================================ { "category": "Control", "name": "JMPIF_L", "tests": [ { "name": "Without items", "script": [ "JMPIF_L", "0x00000000" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [1]", "script": [ "PUSH1", "JMPIF_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "JMPIF_L", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [0]", "script": [ "PUSH0", "JMPIF_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "JMPIF_L", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMPLE.json ================================================ { "category": "Control", "name": "JMPLE", "tests": [ { "name": "Without all items", "script": [ "JMPLE", "0x00" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one", "script": [ "PUSH1", "JMPLE", "0x00" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [>]", "script": [ "PUSH1", "PUSH0", "JMPLE", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH0", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPLE", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [==]", "script": [ "PUSH1", "PUSH1", "JMPLE", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPLE", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [<]", "script": [ "PUSH0", "PUSH1", "JMPLE", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPLE", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMPLE_L.json ================================================ { "category": "Control", "name": "JMPLE_L", "tests": [ { "name": "Without all items", "script": [ "JMPLE_L", "0x00000000" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one", "script": [ "PUSH1", "JMPLE_L", "0x00000000" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [>]", "script": [ "PUSH1", "PUSH0", "JMPLE_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH0", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPLE_L", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [==]", "script": [ "PUSH1", "PUSH1", "JMPLE_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPLE_L", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [<]", "script": [ "PUSH0", "PUSH1", "JMPLE_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPLE_L", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMPLT.json ================================================ { "category": "Control", "name": "JMPLT", "tests": [ { "name": "Without all items", "script": [ "JMPLT", "0x00" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one", "script": [ "PUSH1", "JMPLT", "0x00" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [>]", "script": [ "PUSH1", "PUSH0", "JMPLT", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH0", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPLT", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [==]", "script": [ "PUSH1", "PUSH1", "JMPLT", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPLT", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [<]", "script": [ "PUSH0", "PUSH1", "JMPLT", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPLT", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMPLT_L.json ================================================ { "category": "Control", "name": "JMPLT_L", "tests": [ { "name": "Without all items", "script": [ "JMPLT_L", "0x00000000" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one", "script": [ "PUSH1", "JMPLT_L", "0x00000000" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [>]", "script": [ "PUSH1", "PUSH0", "JMPLT_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH0", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPLT_L", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [==]", "script": [ "PUSH1", "PUSH1", "JMPLT_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPLT_L", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [<]", "script": [ "PUSH0", "PUSH1", "JMPLT_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPLT_L", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMPNE.json ================================================ { "category": "Control", "name": "JMPNE", "tests": [ { "name": "Without all items", "script": [ "JMPNE", "0x00" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one", "script": [ "PUSH1", "JMPNE", "0x00" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [>]", "script": [ "PUSH1", "PUSH0", "JMPNE", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH0", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPNE", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [==]", "script": [ "PUSH1", "PUSH1", "JMPNE", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPNE", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [<]", "script": [ "PUSH0", "PUSH1", "JMPNE", "0x03", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPNE", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMPNE_L.json ================================================ { "category": "Control", "name": "JMPNE_L", "tests": [ { "name": "Without all items", "script": [ "JMPNE_L", "0x00000000" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without one", "script": [ "PUSH1", "JMPNE_L", "0x00000000" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [>]", "script": [ "PUSH1", "PUSH0", "JMPNE_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH0", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPNE_L", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [==]", "script": [ "PUSH1", "PUSH1", "JMPNE_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPNE_L", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [<]", "script": [ "PUSH0", "PUSH1", "JMPNE_L", "0x06000000", "NOP", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "JMPNE_L", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/JMP_L.json ================================================ { "category": "Control", "name": "JMP_L", "tests": [ { "name": "Out of range [<0]", "script": [ "JMP_L", "0xffffffff", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Out of range [>length]", "script": [ "JMP_L", "0xffffff7f", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "JMP_L", "0x05000000", "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/NOP.json ================================================ { "category": "Control", "name": "NOP", "tests": [ { "name": "Real test", "script": [ "NOP", "NOP", "NOP", "NOP", "NOP" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "NOP" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/RET.json ================================================ { "category": "Control", "name": "RET", "tests": [ { "name": "Real test", "script": [ "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/SYSCALL.json ================================================ { "category": "Control", "name": "SYSCALL", "tests": [ { "name": "Syscall that does not exist", "script": [ "SYSCALL", "0x00" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong script", "script": [ "SYSCALL", "0x2a537973", "DEPTH", "CALL_L", "0x6d2e0000", "PUSHDATA1", "0x457865637574696f6e456e67696e652e476574536372697074436f6e7461696e6572" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [IMessageProvider]", "script": [ "SYSCALL", "0x77777777" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "interop", "value": "Object" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "interop", "value": "Object" } ], "refs": 1 } } ] }, { "name": "Wrong script", "script": [ "SYSCALL", "0xfdffff00" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong script", "script": [ "SYSCALL", "0xfeffffff", "0xff", "PUSH0" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong script", "script": [ "SYSCALL", "0xffffffff", "0xffffffffff", "PUSH0" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/THROW.json ================================================ { "category": "Control", "name": "THROW", "tests": [ { "name": "Fault Test", "script": [ "PUSH0", "THROW" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/TRY_CATCH.json ================================================ { "category": "Control", "name": "TRY_CATCH", "tests": [ { "name": "try catch with syscall exception", "script": [ "TRY", "0x0a00", "SYSCALL", "0xdeaddead", "ENDTRY", "0x05", "PUSH1", "ENDTRY", "0x02", "PUSH2" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 11, "nextInstruction": "ENDTRY", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "ByteString", "value": "0x6572726f72" } ] } ], "refs": 2 } }, { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 }, { "type": "ByteString", "value": "0x6572726f72" } ], "refs": 3 } } ] }, { "name": "try catch without exception", "script": [ "TRY", "0x0600", "PUSH0", "ENDTRY", "0x05", "PUSH3", "ENDTRY", "0x02", "RET" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 9, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } } ] }, { "name": "try catch with exception", "script": [ "TRY", "0x0700", "PUSH0", "THROW", "ENDTRY", "0x05", "PUSH1", "ENDTRY", "0x02", "PUSH2" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "PUSH2", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/TRY_CATCH_FINALLY.json ================================================ { "category": "Control", "name": "TRY_CATCH_FINALLY", "tests": [ { "name": "try catch finally without exception", "script": [ "TRY", "0x080a", "PUSH0", "ENDTRY", "0x08", "RET", "PUSH2", "ENDTRY", "0x04", "PUSH3", "ENDFINALLY", "PUSH4" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "PUSH3", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 12, "nextInstruction": "PUSH4", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/TRY_CATCH_FINALLY10.json ================================================ { "category": "Control", "name": "TRY_CATCH_FINALLY", "tests": [ { "name": "try + finally without ENDTRY", "script": [ "TRY", "0x0003", "ENDFINALLY" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/TRY_CATCH_FINALLY2.json ================================================ { "category": "Control", "name": "TRY_CATCH_FINALLY", "tests": [ { "name": "try catch finally with exception", "script": [ "TRY", "0x080C", "PUSH0", "THROW", "ENDTRY", "0x06", "RET", "PUSH1", "ENDTRY", "0x02", "RET", "PUSH2", "ENDFINALLY", "PUSH3" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 12, "nextInstruction": "PUSH2", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 11, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 3 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/TRY_CATCH_FINALLY3.json ================================================ { "category": "Control", "name": "TRY_CATCH_FINALLY", "tests": [ { "name": "try{ try{ throw }catch{ }}catch{ }finally{ }", "script": [ "TRY", "0x0e13", "TRY", "0x0700", "PUSH0", "THROW", "ENDTRY", "0x01", "PUSH1", "ENDTRY", "0x02", "ENDTRY", "0x02", "RET", "PUSH2", "ENDTRY", "0x04", "PUSH3", "ENDFINALLY", "PUSH4" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 13, "nextInstruction": "ENDTRY", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 15, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 3 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/TRY_CATCH_FINALLY4.json ================================================ { "category": "Control", "name": "TRY_CATCH_FINALLY", "tests": [ { "name": "try{ try{ throw }catch{ throw } }catch{ }finally{ }", "script": [ "TRY", "0x1014", "TRY", "0x0700", "PUSH0", "THROW", "ENDTRY", "0x01", "PUSH1", "THROW", "ENDTRY", "0x04", "ENDTRY", "0x01", "PUSH2", "ENDTRY", "0x02", "RET", "PUSH3", "ENDFINALLY", "PUSH4" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "PUSH1", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 16, "nextInstruction": "PUSH2", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 19, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 4 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/TRY_CATCH_FINALLY5.json ================================================ { "category": "Control", "name": "TRY_CATCH_FINALLY", "tests": [ { "name": "try{ assert false }catch{ push2 }finally{ push3 }", "script": [ "TRY", "0x0608", "PUSH0", "ASSERT", "ENDTRY", "0x01", "PUSH2", "ENDTRY", "0x01", "PUSH3", "ENDFINALLY", "RET" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/TRY_CATCH_FINALLY6.json ================================================ { "category": "Control", "name": "TRY_CATCH_FINALLY", "tests": [ { "name": "try{ abort }catch{ push2 }finally{ push3 }", "script": [ "TRY", "0x0507", "ABORT", "ENDTRY", "0x01", "PUSH2", "ENDTRY", "0x01", "PUSH3", "ENDFINALLY", "RET" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/TRY_CATCH_FINALLY7.json ================================================ { "category": "Control", "name": "TRY_CATCH_FINALLY", "tests": [ { "name": "try{ throw }catch{ abort }finally{ push3 }", "script": [ "TRY", "0x070a", "PUSH0", "THROW", "ENDTRY", "0x01", "ABORT", "ENDTRY", "0x01", "PUSH3", "ENDFINALLY", "RET" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "ABORT", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/TRY_CATCH_FINALLY8.json ================================================ { "category": "Control", "name": "TRY_CATCH_FINALLY", "tests": [ { "name": "try{ throw }catch{ throw }finally{ push3 }", "script": [ "TRY", "0x070b", "PUSH0", "THROW", "ENDTRY", "0x01", "PUSH2", "THROW", "ENDTRY", "0x01", "PUSH3", "ENDFINALLY", "RET" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "PUSH2", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 11, "nextInstruction": "PUSH3", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 12, "nextInstruction": "ENDFINALLY", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/TRY_CATCH_FINALLY9.json ================================================ { "category": "Control", "name": "TRY_CATCH_FINALLY", "tests": [ { "name": "try{ PUSH0, call A: PUSH1 { call B: PUSH2 throw an exception } }catch{ PUSH3 }", "script": [ "TRY", "0x0f00", "PUSH0", "CALL", "0x03", "RET", "PUSH1", "CALL", "0x02", "PUSH2", "THROW", "RET", "ENDTRY", "0x01", "PUSH3", "ENDTRY", "0x02", "RET" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 15, "nextInstruction": "PUSH3", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 3 } }, { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 18, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 4 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Control/TRY_FINALLY.json ================================================ { "category": "Control", "name": "TRY_FINALLY", "tests": [ { "name": "try finally with exception", "script": [ "TRY", "0x0009", "PUSH0", "THROW", "ENDTRY", "0x01", "JMP", "0x03", "PUSH1", "ENDFINALLY", "PUSH2" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 9, "nextInstruction": "PUSH1" } ], "refs": 0 } }, { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Push/PUSHA.json ================================================ { "category": "Push", "name": "PUSHA", "tests": [ { "name": "Out of range [-1]", "script": [ "PUSHA", "0xffffffff" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Out of range [>length]", "script": [ "PUSHA", "0xffffff7f" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSHA", "0x00000000" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "pointer", "value": 0 } ], "refs": 1 } } ] }, { "name": "Real test [=length]", "script": [ "PUSHA", "0x05000000" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "pointer", "value": 5 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Push/PUSHDATA1.json ================================================ { "category": "Push", "name": "PUSHDATA1", "tests": [ { "name": "Good definition", "script": [ "PUSHDATA1", "0x04", "0x01020304" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "ByteString", "value": "0x01020304" } ], "refs": 1 } } ] }, { "name": "Without enough length", "script": [ "PUSHDATA1", "0x0501020304" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Push/PUSHDATA2.json ================================================ { "category": "Push", "name": "PUSHDATA2", "tests": [ { "name": "Good definition", "script": [ "PUSHDATA2", "0x0400", "0x01020304" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "ByteString", "value": "0x01020304" } ], "refs": 1 } } ] }, { "name": "Without enough length", "script": [ "PUSHDATA2", "0x050001020304" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Push/PUSHDATA4.json ================================================ { "category": "Push", "name": "PUSHDATA4", "tests": [ { "name": "More length than script", "script": [ "PUSHDATA4", "0x00080000" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Negative length", "script": [ "PUSHDATA4", "0xffffffff" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Good definition", "script": [ "PUSHDATA4", "0x04000000", "0x01020304" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "ByteString", "value": "0x01020304" } ], "refs": 1 } } ] }, { "name": "Without enough length", "script": [ "PUSHDATA4", "0x0500000001020304" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Max length (Parse Instruction Error)", "script": [ "PUSHDATA4", "0x01001000", "0xFF" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Push/PUSHINT8_to_PUSHINT256.json ================================================ { "category": "Push", "name": "PUSHINT8 to PUSHINT256", "tests": [ { "name": "Basic Test", "script": [ "PUSHINT8", "0xff", "PUSHINT16", "0xfeff", "PUSHINT32", "0xfdffffff", "PUSHINT64", "0xfcffffffffffffff", "PUSHINT128", "0xfbffffffffffffffffffffffffffffff", "PUSHINT256", "0xfaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": -6 }, { "type": "integer", "value": -5 }, { "type": "integer", "value": -4 }, { "type": "integer", "value": -3 }, { "type": "integer", "value": -2 }, { "type": "integer", "value": -1 } ], "refs": 6 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Push/PUSHM1_to_PUSH16.json ================================================ { "category": "Push", "name": "From PUSHM1 to PUSH16 [-1 to 16]", "tests": [ { "name": "Basic Test", "script": [ "PUSHM1", "PUSH0", "PUSH1", "PUSH2", "PUSH3", "PUSH4", "PUSH5", "PUSH6", "PUSH7", "PUSH8", "PUSH9", "PUSH10", "PUSH11", "PUSH12", "PUSH13", "PUSH14", "PUSH15", "PUSH16", "RET" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 18, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 16 }, { "type": "integer", "value": 15 }, { "type": "integer", "value": 14 }, { "type": "integer", "value": 13 }, { "type": "integer", "value": 12 }, { "type": "integer", "value": 11 }, { "type": "integer", "value": 10 }, { "type": "integer", "value": 9 }, { "type": "integer", "value": 8 }, { "type": "integer", "value": 7 }, { "type": "integer", "value": 6 }, { "type": "integer", "value": 5 }, { "type": "integer", "value": 4 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 }, { "type": "integer", "value": -1 } ] } ], "refs": 18 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 16 }, { "type": "integer", "value": 15 }, { "type": "integer", "value": 14 }, { "type": "integer", "value": 13 }, { "type": "integer", "value": 12 }, { "type": "integer", "value": 11 }, { "type": "integer", "value": 10 }, { "type": "integer", "value": 9 }, { "type": "integer", "value": 8 }, { "type": "integer", "value": 7 }, { "type": "integer", "value": 6 }, { "type": "integer", "value": 5 }, { "type": "integer", "value": 4 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 }, { "type": "integer", "value": -1 } ], "refs": 18 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Push/PUSHNULL.json ================================================ { "category": "Push", "name": "PUSHNULL", "tests": [ { "name": "Good definition", "script": [ "PUSHNULL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "RET", "evaluationStack": [ { "type": "null" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "null" } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/INITSLOT.json ================================================ { "category": "Slot", "name": "INITSLOT", "tests": [ { "name": "Without enough items", "script": [ "INITSLOT", "0x0101" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without 0 items", "script": [ "INITSLOT", "0x0000" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [LocalVariables]", "script": [ "INITSLOT", "0x0100" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "localVariables": [ { "type": "Null" } ] } ], "refs": 1 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [Arguments]", "script": [ "PUSH1", "INITSLOT", "0x0001" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "arguments": [ { "type": "Integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Real test [LocalVariables + Arguments]", "script": [ "PUSH1", "INITSLOT", "0x0101" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "localVariables": [ { "type": "Null" } ], "arguments": [ { "type": "Integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Initialize twice", "script": [ "PUSH0", "INITSLOT", "0x0101", "PUSH0", "INITSLOT", "0x0101" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "PUSH0", "localVariables": [ { "type": "Null" } ], "arguments": [ { "type": "Integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/INITSSLOT.json ================================================ { "category": "Slot", "name": "INITSSLOT", "tests": [ { "name": "Without 0 items", "script": [ "INITSSLOT", "0x00" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x01" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET", "staticFields": [ { "type": "Null" } ] } ], "refs": 1 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Initialize twice", "script": [ "INITSSLOT", "0x01", "INITSSLOT", "0x02" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "INITSSLOT", "staticFields": [ { "type": "Null" } ] } ], "refs": 1 } }, { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDARG.json ================================================ { "category": "Slot", "name": "LDARG", "tests": [ { "name": "Without slot", "script": [ "LDARG", "0x00" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "PUSH1", "INITSLOT", "0x0001", "LDARG", "0x01" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH1", "INITSLOT", "0x0001", "LDARG", "0x00" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDARG0.json ================================================ { "category": "Slot", "name": "LDARG0", "tests": [ { "name": "Without slot", "script": [ "LDARG0" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH1", "INITSLOT", "0x0001", "LDARG0" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDARG1.json ================================================ { "category": "Slot", "name": "LDARG1", "tests": [ { "name": "Without slot", "script": [ "LDARG1" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "PUSH1", "INITSLOT", "0x0001", "LDARG1" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH1", "PUSH2", "INITSLOT", "0x0002", "LDARG1" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDARG2.json ================================================ { "category": "Slot", "name": "LDARG2", "tests": [ { "name": "Without slot", "script": [ "LDARG2" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "PUSH1", "INITSLOT", "0x0001", "LDARG2" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH1", "PUSH2", "PUSH3", "INITSLOT", "0x0003", "LDARG2" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDARG3.json ================================================ { "category": "Slot", "name": "LDARG3", "tests": [ { "name": "Without slot", "script": [ "LDARG3" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "PUSH1", "INITSLOT", "0x0001", "LDARG3" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH1", "PUSH2", "PUSH3", "PUSH4", "INITSLOT", "0x0004", "LDARG3" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDARG4.json ================================================ { "category": "Slot", "name": "LDARG4", "tests": [ { "name": "Without slot", "script": [ "LDARG4" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "PUSH1", "INITSLOT", "0x0001", "LDARG4" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH1", "PUSH2", "PUSH3", "PUSH4", "PUSH5", "INITSLOT", "0x0005", "LDARG4" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDARG5.json ================================================ { "category": "Slot", "name": "LDARG5", "tests": [ { "name": "Without slot", "script": [ "LDARG5" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "PUSH1", "INITSLOT", "0x0001", "LDARG5" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH1", "PUSH2", "PUSH3", "PUSH4", "PUSH5", "PUSH6", "INITSLOT", "0x0006", "LDARG5" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDARG6.json ================================================ { "category": "Slot", "name": "LDARG6", "tests": [ { "name": "Without slot", "script": [ "LDARG6" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "PUSH1", "INITSLOT", "0x0001", "LDARG6" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH1", "PUSH2", "PUSH3", "PUSH4", "PUSH5", "PUSH6", "PUSH7", "INITSLOT", "0x0007", "LDARG6" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDLOC.json ================================================ { "category": "Slot", "name": "LDLOC", "tests": [ { "name": "Without slot", "script": [ "LDLOC", "0x00" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSLOT", "0x0100", "LDLOC", "0x01" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSLOT", "0x0100", "PUSH1", "STLOC", "0x00", "LDLOC", "0x00" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDLOC0.json ================================================ { "category": "Slot", "name": "LDLOC0", "tests": [ { "name": "Without slot", "script": [ "LDLOC0" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSLOT", "0x0100", "PUSH1", "STLOC0", "LDLOC0" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDLOC1.json ================================================ { "category": "Slot", "name": "LDLOC1", "tests": [ { "name": "Without slot", "script": [ "LDLOC1" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSLOT", "0x0100", "LDLOC1" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSLOT", "0x0200", "PUSH1", "STLOC1", "LDLOC1" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDLOC2.json ================================================ { "category": "Slot", "name": "LDLOC2", "tests": [ { "name": "Without slot", "script": [ "LDLOC2" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSLOT", "0x0100", "LDLOC2" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSLOT", "0x0300", "PUSH1", "STLOC2", "LDLOC2" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDLOC3.json ================================================ { "category": "Slot", "name": "LDLOC3", "tests": [ { "name": "Without slot", "script": [ "LDLOC3" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSLOT", "0x0100", "LDLOC3" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSLOT", "0x0400", "PUSH1", "STLOC3", "LDLOC3" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDLOC4.json ================================================ { "category": "Slot", "name": "LDLOC4", "tests": [ { "name": "Without slot", "script": [ "LDLOC4" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSLOT", "0x0100", "LDLOC4" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSLOT", "0x0500", "PUSH1", "STLOC4", "LDLOC4" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDLOC5.json ================================================ { "category": "Slot", "name": "LDLOC5", "tests": [ { "name": "Without slot", "script": [ "LDLOC5" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSLOT", "0x0100", "LDLOC5" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSLOT", "0x0600", "PUSH1", "STLOC5", "LDLOC5" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDLOC6.json ================================================ { "category": "Slot", "name": "LDLOC6", "tests": [ { "name": "Without slot", "script": [ "LDLOC6" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSLOT", "0x0100", "LDLOC6" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSLOT", "0x0700", "PUSH1", "STLOC6", "LDLOC6" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDSFLD.json ================================================ { "category": "Slot", "name": "LDSFLD", "tests": [ { "name": "Without slot", "script": [ "LDSFLD", "0x00" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSSLOT", "0x01", "LDSFLD", "0x01" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x01", "PUSH1", "STSFLD", "0x00", "LDSFLD", "0x00" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDSFLD0.json ================================================ { "category": "Slot", "name": "LDSFLD0", "tests": [ { "name": "Without slot", "script": [ "LDSFLD0" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x01", "PUSH1", "STSFLD0", "LDSFLD0" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDSFLD1.json ================================================ { "category": "Slot", "name": "LDSFLD1", "tests": [ { "name": "Without slot", "script": [ "LDSFLD1" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSSLOT", "0x01", "LDSFLD1" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x02", "PUSH1", "STSFLD1", "LDSFLD1" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDSFLD2.json ================================================ { "category": "Slot", "name": "LDSFLD2", "tests": [ { "name": "Without slot", "script": [ "LDSFLD2" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSSLOT", "0x01", "LDSFLD2" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x03", "PUSH1", "STSFLD2", "LDSFLD2" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDSFLD3.json ================================================ { "category": "Slot", "name": "LDSFLD3", "tests": [ { "name": "Without slot", "script": [ "LDSFLD3" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSSLOT", "0x01", "LDSFLD3" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x04", "PUSH1", "STSFLD3", "LDSFLD3" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDSFLD4.json ================================================ { "category": "Slot", "name": "LDSFLD4", "tests": [ { "name": "Without slot", "script": [ "LDSFLD4" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSSLOT", "0x01", "LDSFLD4" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x05", "PUSH1", "STSFLD4", "LDSFLD4" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDSFLD5.json ================================================ { "category": "Slot", "name": "LDSFLD5", "tests": [ { "name": "Without slot", "script": [ "LDSFLD5" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSSLOT", "0x01", "LDSFLD5" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x06", "PUSH1", "STSFLD5", "LDSFLD5" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/LDSFLD6.json ================================================ { "category": "Slot", "name": "LDSFLD6", "tests": [ { "name": "Without slot", "script": [ "LDSFLD6" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSSLOT", "0x01", "LDSFLD6" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x07", "PUSH1", "STSFLD6", "LDSFLD6" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STARG.json ================================================ { "category": "Slot", "name": "STARG", "tests": [ { "name": "Without slot", "script": [ "PUSH1", "STARG", "0x00" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "PUSH0", "INITSLOT", "0x0001", "PUSH1", "STARG", "0x01" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH1", "INITSLOT", "0x0001", "PUSH0", "STARG", "0x00" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "arguments": [ { "type": "Integer", "value": 0 } ], "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STARG0.json ================================================ { "category": "Slot", "name": "STARG0", "tests": [ { "name": "Without slot", "script": [ "PUSH1", "STARG0" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH0", "INITSLOT", "0x0001", "PUSH1", "STARG0" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "arguments": [ { "type": "Integer", "value": 1 } ], "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STARG1.json ================================================ { "category": "Slot", "name": "STARG1", "tests": [ { "name": "Without slot", "script": [ "PUSH1", "STARG1" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "PUSH0", "INITSLOT", "0x0001", "PUSH1", "STARG1" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH1", "PUSH2", "INITSLOT", "0x0002", "PUSH0", "STARG1" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "arguments": [ { "type": "Integer", "value": 1 }, { "type": "Integer", "value": 0 } ], "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STARG2.json ================================================ { "category": "Slot", "name": "STARG2", "tests": [ { "name": "Without slot", "script": [ "PUSH1", "STARG2" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "PUSH0", "INITSLOT", "0x0001", "PUSH1", "STARG2" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH1", "PUSH2", "PUSH3", "INITSLOT", "0x0003", "PUSH0", "STARG2" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "arguments": [ { "type": "Integer", "value": 1 }, { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 0 } ], "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STARG3.json ================================================ { "category": "Slot", "name": "STARG3", "tests": [ { "name": "Without slot", "script": [ "PUSH1", "STARG3" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "PUSH0", "INITSLOT", "0x0001", "PUSH1", "STARG3" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH1", "PUSH2", "PUSH3", "PUSH4", "INITSLOT", "0x0004", "PUSH0", "STARG3" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "arguments": [ { "type": "Integer", "value": 1 }, { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 3 }, { "type": "Integer", "value": 0 } ], "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STARG4.json ================================================ { "category": "Slot", "name": "STARG4", "tests": [ { "name": "Without slot", "script": [ "PUSH1", "STARG4" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "PUSH0", "INITSLOT", "0x0001", "PUSH1", "STARG4" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH1", "PUSH2", "PUSH3", "PUSH4", "PUSH5", "INITSLOT", "0x0005", "PUSH0", "STARG4" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "arguments": [ { "type": "Integer", "value": 1 }, { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 3 }, { "type": "Integer", "value": 4 }, { "type": "Integer", "value": 0 } ], "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STARG5.json ================================================ { "category": "Slot", "name": "STARG5", "tests": [ { "name": "Without slot", "script": [ "PUSH1", "STARG5" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "PUSH0", "INITSLOT", "0x0001", "PUSH1", "STARG5" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH1", "PUSH2", "PUSH3", "PUSH4", "PUSH5", "PUSH6", "INITSLOT", "0x0006", "PUSH0", "STARG5" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "arguments": [ { "type": "Integer", "value": 1 }, { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 3 }, { "type": "Integer", "value": 4 }, { "type": "Integer", "value": 5 }, { "type": "Integer", "value": 0 } ], "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STARG6.json ================================================ { "category": "Slot", "name": "STARG6", "tests": [ { "name": "Without slot", "script": [ "PUSH1", "STARG6" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "PUSH0", "INITSLOT", "0x0001", "PUSH1", "STARG6" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH1", "PUSH2", "PUSH3", "PUSH4", "PUSH5", "PUSH6", "PUSH7", "INITSLOT", "0x0007", "PUSH0", "STARG6" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "arguments": [ { "type": "Integer", "value": 1 }, { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 3 }, { "type": "Integer", "value": 4 }, { "type": "Integer", "value": 5 }, { "type": "Integer", "value": 6 }, { "type": "Integer", "value": 0 } ], "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STLOC.json ================================================ { "category": "Slot", "name": "STLOC", "tests": [ { "name": "Without slot", "script": [ "STLOC", "0x00" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Without enough items", "script": [ "INITSLOT", "0x0100", "PUSH2", "STLOC", "0x01" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSLOT", "0x0100", "PUSH1", "STLOC", "0x00", "LDLOC", "0x00" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "LDLOC", "localVariables": [ { "type": "Integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 1 } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STSFLD.json ================================================ { "category": "Slot", "name": "STSFLD", "tests": [ { "name": "Without slot", "script": [ "STSFLD", "0x00" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSSLOT", "0x01", "STSFLD", "0x01" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x01", "PUSH1", "STSFLD", "0x00" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "staticFields": [ { "type": "Integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STSFLD0.json ================================================ { "category": "Slot", "name": "STSFLD0", "tests": [ { "name": "Without slot", "script": [ "STSFLD0" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x01", "PUSH1", "STSFLD0" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "staticFields": [ { "type": "Integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STSFLD1.json ================================================ { "category": "Slot", "name": "STSFLD1", "tests": [ { "name": "Without slot", "script": [ "STSFLD1" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSSLOT", "0x01", "STSFLD1" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x02", "PUSH1", "STSFLD1" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "staticFields": [ { "type": "Null" }, { "type": "Integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STSFLD2.json ================================================ { "category": "Slot", "name": "STSFLD2", "tests": [ { "name": "Without slot", "script": [ "STSFLD2" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSSLOT", "0x01", "STSFLD2" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x03", "PUSH1", "STSFLD2" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "staticFields": [ { "type": "Null" }, { "type": "Null" }, { "type": "Integer", "value": 1 } ] } ], "refs": 3 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STSFLD3.json ================================================ { "category": "Slot", "name": "STSFLD3", "tests": [ { "name": "Without slot", "script": [ "STSFLD3" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSSLOT", "0x01", "STSFLD3" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x04", "PUSH1", "STSFLD3" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "staticFields": [ { "type": "Null" }, { "type": "Null" }, { "type": "Null" }, { "type": "Integer", "value": 1 } ] } ], "refs": 4 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STSFLD4.json ================================================ { "category": "Slot", "name": "STSFLD4", "tests": [ { "name": "Without slot", "script": [ "STSFLD4" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSSLOT", "0x01", "STSFLD4" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x05", "PUSH1", "STSFLD4" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "staticFields": [ { "type": "Null" }, { "type": "Null" }, { "type": "Null" }, { "type": "Null" }, { "type": "Integer", "value": 1 } ] } ], "refs": 5 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STSFLD5.json ================================================ { "category": "Slot", "name": "STSFLD5", "tests": [ { "name": "Without slot", "script": [ "STSFLD5" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSSLOT", "0x01", "STSFLD5" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x06", "PUSH1", "STSFLD5" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "staticFields": [ { "type": "Null" }, { "type": "Null" }, { "type": "Null" }, { "type": "Null" }, { "type": "Null" }, { "type": "Integer", "value": 1 } ] } ], "refs": 6 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Slot/STSFLD6.json ================================================ { "category": "Slot", "name": "STSFLD6", "tests": [ { "name": "Without slot", "script": [ "STSFLD6" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index out of range", "script": [ "INITSSLOT", "0x01", "STSFLD6" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "INITSSLOT", "0x07", "PUSH1", "STSFLD6" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "staticFields": [ { "type": "Null" }, { "type": "Null" }, { "type": "Null" }, { "type": "Null" }, { "type": "Null" }, { "type": "Null" }, { "type": "Integer", "value": 1 } ] } ], "refs": 7 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Splice/CAT.json ================================================ { "category": "Splice", "name": "CAT", "tests": [ { "name": "Max Item Length", "script": [ "INITSLOT", "0x0200", "PUSHINT32", "0x00000100", "STLOC0", "PUSH1", "STLOC1", "PUSHDATA2", "0x1000", "0x000102030405060708090A0B0C0D0E0F", "PUSHDATA2", "0x1000", "0x000102030405060708090A0B0C0D0E0F", "CAT", "LDLOC1", "INC", "STLOC1", "LDLOC1", "LDLOC0", "LT", "JMPIF_L", "0xE6FFFFFF", "PUSHDATA1", "0x01", "0x00", "CAT" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type [Map,ByteString]", "script": [ "PUSH0", "NEWMAP", "CAT" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type [ByteString,Map]", "script": [ "NEWMAP", "PUSH0", "CAT" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong push", "script": [ "CAT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSHDATA1", "0x01", "0x01", "PUSHDATA1", "0x02", "0x0203", "CAT" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "RET", "evaluationStack": [ { "type": "Buffer", "value": "0x010203" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Buffer", "value": "0x010203" } ], "refs": 1 } } ] }, { "name": "CAT int(0) with empty ByteString", "script": [ "PUSH1", "DEC", "PUSH0", "CAT" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "CAT", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Buffer", "value": "" } ], "refs": 1 } } ] }, { "name": "CAT 0x01 with empty ByteString", "script": [ "PUSH1", "PUSH0", "CAT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "CAT", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Buffer", "value": "0x01" } ], "refs": 1 } } ] }, { "name": "CAT empty ByteString with 0x01", "script": [ "PUSH0", "PUSH1", "CAT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "CAT", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Buffer", "value": "0x01" } ], "refs": 1 } } ] }, { "name": "CAT Buffers", "script": [ "PUSHDATA1", "0x01AA", "CONVERT", "0x30", "PUSHDATA1", "0x01BB", "CONVERT", "0x30", "INITSLOT", "0x0002", "LDARG1", "LDARG0", "CAT" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 10, "nextInstruction": "INITSLOT", "evaluationStack": [ { "type": "Buffer", "value": "0xBB" }, { "type": "Buffer", "value": "0xAA" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 13, "nextInstruction": "LDARG1", "arguments": [ { "type": "Buffer", "value": "0xBB" }, { "type": "Buffer", "value": "0xAA" } ] } ], "refs": 2 } }, { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 15, "nextInstruction": "CAT", "evaluationStack": [ { "type": "Buffer", "value": "0xBB" }, { "type": "Buffer", "value": "0xAA" } ], "arguments": [ { "type": "Buffer", "value": "0xBB" }, { "type": "Buffer", "value": "0xAA" } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 16, "nextInstruction": "RET", "evaluationStack": [ { "type": "Buffer", "value": "0xAABB" } ], "arguments": [ { "type": "Buffer", "value": "0xBB" }, { "type": "Buffer", "value": "0xAA" } ] } ], "refs": 3 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Splice/LEFT.json ================================================ { "category": "Splice", "name": "LEFT", "tests": [ { "name": "Without push", "script": [ "PUSH11", "LEFT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type [Map]", "script": [ "PUSH4", "NEWMAP", "LEFT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "LEFT", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "integer", "value": 4 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Negative value", "script": [ "PUSHDATA1", "0x03", "0x010203", "PUSHM1", "LEFT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "LEFT", "evaluationStack": [ { "type": "integer", "value": -1 }, { "type": "ByteString", "value": "0x010203" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Overflow string", "script": [ "PUSHDATA1", "0x03", "0x010203", "PUSH4", "LEFT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "LEFT", "evaluationStack": [ { "type": "integer", "value": 4 }, { "type": "ByteString", "value": "0x010203" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSHDATA1", "0x03", "0x010203", "PUSH2", "LEFT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "LEFT", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "ByteString", "value": "0x010203" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "RET", "evaluationStack": [ { "type": "Buffer", "value": "0x0102" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Buffer", "value": "0x0102" } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Splice/MEMCPY.json ================================================ { "category": "Splice", "name": "MEMCPY", "tests": [ { "name": "Max Item Length", "script": [ "PUSH4", "NEWBUFFER", "PUSHINT32", "0x00001000", "PUSHDATA1", "0x02", "0x1111", "PUSH0", "PUSH2", "MEMCPY" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto", "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 13, "nextInstruction": "MEMCPY", "evaluationStack": [ { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 0 }, { "type": "ByteString", "value": "0x1111" }, { "type": "Integer", "value": 1048576 }, { "type": "Buffer", "value": "0x00000000" } ] } ], "refs": 5 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Negative di", "script": [ "PUSH4", "NEWBUFFER", "PUSHM1", "PUSHDATA1", "0x02", "0x1111", "PUSH0", "PUSH2", "MEMCPY" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto", "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 9, "nextInstruction": "MEMCPY", "evaluationStack": [ { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 0 }, { "type": "ByteString", "value": "0x1111" }, { "type": "Integer", "value": -1 }, { "type": "Buffer", "value": "0x00000000" } ] } ], "refs": 5 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Negative si", "script": [ "PUSH4", "NEWBUFFER", "PUSHINT32", "0x00001000", "PUSHDATA1", "0x02", "0x1111", "PUSHM1", "PUSH2", "MEMCPY" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto", "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 13, "nextInstruction": "MEMCPY", "evaluationStack": [ { "type": "Integer", "value": 2 }, { "type": "Integer", "value": -1 }, { "type": "ByteString", "value": "0x1111" }, { "type": "Integer", "value": 1048576 }, { "type": "Buffer", "value": "0x00000000" } ] } ], "refs": 5 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Negative n", "script": [ "PUSH4", "NEWBUFFER", "PUSHINT32", "0x00001000", "PUSHDATA1", "0x02", "0x1111", "PUSH0", "PUSHM1", "MEMCPY" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto", "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 13, "nextInstruction": "MEMCPY", "evaluationStack": [ { "type": "Integer", "value": -1 }, { "type": "Integer", "value": 0 }, { "type": "ByteString", "value": "0x1111" }, { "type": "Integer", "value": 1048576 }, { "type": "Buffer", "value": "0x00000000" } ] } ], "refs": 5 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type [Array]", "script": [ "PUSH0", "NEWARRAY", "PUSHINT32", "0x00001000", "PUSHDATA1", "0x02", "0x1111", "PUSH0", "PUSH2", "MEMCPY" ], "steps": [ { "actions": [ "StepInto", "StepInto", "StepInto", "StepInto", "StepInto", "StepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 13, "nextInstruction": "MEMCPY", "evaluationStack": [ { "type": "Integer", "value": 2 }, { "type": "Integer", "value": 0 }, { "type": "ByteString", "value": "0x1111" }, { "type": "Integer", "value": 1048576 }, { "type": "Array", "value": [] } ] } ], "refs": 5 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "No push", "script": [ "MEMCPY" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH4", "NEWBUFFER", "DUP", "PUSH1", "PUSHDATA1", "0x02", "0x1111", "PUSH0", "PUSH2", "MEMCPY" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Buffer", "value": "0x00111100" } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Splice/NEWBUFFER.json ================================================ { "category": "Splice", "name": "NEWBUFFER", "tests": [ { "name": "Max Item Length", "script": [ "PUSHINT256", "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f", "NEWBUFFER" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 33, "nextInstruction": "NEWBUFFER", "evaluationStack": [ { "type": "Integer", "value": "57896044618658097711785492504343953926634992332820282019728792003956564819967" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "-1 Length", "script": [ "PUSHM1", "NEWBUFFER" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "NEWBUFFER", "evaluationStack": [ { "type": "Integer", "value": -1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type [Array]", "script": [ "PUSH0", "NEWARRAY", "NEWBUFFER" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NEWBUFFER", "evaluationStack": [ { "type": "Array", "value": [] } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "No push", "script": [ "NEWBUFFER" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test [Integer]", "script": [ "PUSH10", "NEWBUFFER" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Buffer", "value": "0x00000000000000000000" } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Splice/RIGHT.json ================================================ { "category": "Splice", "name": "RIGHT", "tests": [ { "name": "Without push", "script": [ "PUSH11", "RIGHT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type [Map]", "script": [ "PUSH4", "NEWMAP", "RIGHT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RIGHT", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "integer", "value": 4 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Negative value", "script": [ "PUSHDATA1", "0x03", "0x010203", "PUSHM1", "RIGHT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RIGHT", "evaluationStack": [ { "type": "integer", "value": -1 }, { "type": "ByteString", "value": "0x010203" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Overflow string", "script": [ "PUSHDATA1", "0x03", "0x010203", "PUSH4", "RIGHT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RIGHT", "evaluationStack": [ { "type": "integer", "value": 4 }, { "type": "ByteString", "value": "0x010203" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSHDATA1", "0x03", "0x010203", "PUSH2", "RIGHT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RIGHT", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "ByteString", "value": "0x010203" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "RET", "evaluationStack": [ { "type": "Buffer", "value": "0x0203" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Buffer", "value": "0x0203" } ], "refs": 1 } } ] }, { "name": "Real test [whole input]", "script": [ "PUSHDATA1", "0x03", "0x010203", "PUSH3", "RIGHT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RIGHT", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "ByteString", "value": "0x010203" } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 7, "nextInstruction": "RET", "evaluationStack": [ { "type": "Buffer", "value": "0x010203" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Buffer", "value": "0x010203" } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Splice/SUBSTR.json ================================================ { "category": "Splice", "name": "SUBSTR", "tests": [ { "name": "Without 3 items", "script": [ "PUSH2", "PUSH3", "SUBSTR" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "SUBSTR", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With negative count", "script": [ "PUSH0", "PUSH0", "PUSHM1", "SUBSTR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "SUBSTR", "evaluationStack": [ { "type": "integer", "value": -1 }, { "type": "integer", "value": 0 }, { "type": "integer", "value": 0 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With map as string", "script": [ "NEWMAP", "PUSH0", "PUSH0", "SUBSTR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "SUBSTR", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 0 }, { "type": "map", "value": {} } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With map as count", "script": [ "PUSH0", "PUSH0", "NEWMAP", "SUBSTR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "SUBSTR", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "integer", "value": 0 }, { "type": "integer", "value": 0 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With map as index", "script": [ "PUSH0", "NEWMAP", "PUSH0", "SUBSTR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "SUBSTR", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "map", "value": {} }, { "type": "integer", "value": 0 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With negative index", "script": [ "PUSH0", "PUSHM1", "PUSH0", "SUBSTR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "SUBSTR", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": -1 }, { "type": "integer", "value": 0 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Overflow string index", "script": [ "PUSHDATA1", "0x02", "0x0001", "PUSH9", "PUSH2", "SUBSTR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "SUBSTR", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 9 }, { "type": "ByteString", "value": "0x0001" } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Overflow string count", "script": [ "PUSHDATA1", "0x0a", "0x00010203040506070809", "PUSH2", "PUSH9", "SUBSTR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 14, "nextInstruction": "SUBSTR", "evaluationStack": [ { "type": "integer", "value": 9 }, { "type": "integer", "value": 2 }, { "type": "ByteString", "value": "0x00010203040506070809" } ] } ], "refs": 3 } }, { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSHDATA1", "0x0a", "0x00010203040506070809", "PUSH2", "PUSH1", "SUBSTR" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 14, "nextInstruction": "SUBSTR", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 }, { "type": "ByteString", "value": "0x00010203040506070809" } ] } ], "refs": 3 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Buffer", "value": "0x02" } ], "refs": 1 } } ] }, { "name": "Integer overflow Test", "script": [ "PUSHDATA1", "0xff", "0x414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141", "PUSHDATA1", "0x04", "0xfd000000", "PUSHDATA1", "0x04", "0x03ffff7f", "SUBSTR" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Count Exceed Range Test", "script": [ "PUSHDATA1", "0x0a", "0x00010203040506070809", "PUSH2", "PUSHINT32", "0x7FFFFFFF", "SUBSTR" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Index Exceed Range Test", "script": [ "PUSHDATA1", "0x0a", "0x00010203040506070809", "PUSHINT32", "0x7FFFFFFF", "PUSH2", "SUBSTR" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Stack/CLEAR.json ================================================ { "category": "Stack", "name": "CLEAR", "tests": [ { "name": "Without push", "script": [ "CLEAR" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "With push", "script": [ "PUSH2", "CLEAR" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "CLEAR", "evaluationStack": [ { "type": "integer", "value": 2 } ] } ], "refs": 1 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Stack/DEPTH.json ================================================ { "category": "Stack", "name": "DEPTH", "tests": [ { "name": "Without push", "script": [ "DEPTH" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 0 } ], "refs": 1 } } ] }, { "name": "With push", "script": [ "PUSH2", "DEPTH" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "DEPTH", "evaluationStack": [ { "type": "integer", "value": 2 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 } ], "refs": 2 } } ] }, { "name": "3xDEPTH", "script": [ "DEPTH", "DEPTH", "DEPTH" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "DEPTH", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "DEPTH", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 0 } ], "refs": 3 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Stack/DROP.json ================================================ { "category": "Stack", "name": "DROP", "tests": [ { "name": "Without push", "script": [ "DROP" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without push", "script": [ "PUSH5", "DROP" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "DROP", "evaluationStack": [ { "type": "integer", "value": 5 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Stack/NIP.json ================================================ { "category": "Stack", "name": "NIP", "tests": [ { "name": "Without push", "script": [ "NIP" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without two stack items", "script": [ "PUSH5", "NIP" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "NIP", "evaluationStack": [ { "type": "integer", "value": 5 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH0", "PUSHDATA1", "0x09", "0x000000000000000000", "NOT", "NIP" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 13, "nextInstruction": "NIP", "evaluationStack": [ { "type": "Boolean", "value": true }, { "type": "integer", "value": 0 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 14, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Stack/OVER.json ================================================ { "category": "Stack", "name": "OVER", "tests": [ { "name": "Without push", "script": [ "OVER" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With one push", "script": [ "PUSH0", "OVER" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "OVER", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test with 2 items", "script": [ "PUSH1", "PUSH2", "OVER" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "OVER", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ], "refs": 3 } } ] }, { "name": "Real test with 3 items", "script": [ "PUSH1", "PUSH2", "PUSH3", "OVER" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "OVER", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ], "refs": 4 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Stack/PICK.json ================================================ { "category": "Stack", "name": "PICK", "tests": [ { "name": "Without push", "script": [ "PICK" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Pick outside", "script": [ "PUSH1", "PUSH2", "PUSH3", "PUSH4", "PICK" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "PICK", "evaluationStack": [ { "type": "integer", "value": 4 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Less than 0", "script": [ "PUSH1", "PUSH2", "PUSH3", "PUSHM1", "PICK" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "PICK", "evaluationStack": [ { "type": "integer", "value": -1 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong type", "script": [ "PUSH1", "PUSH2", "PUSH3", "NEWMAP", "PICK" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "PICK", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH3", "PUSH2", "PUSH1", "PUSH2", "PICK" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "PICK", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 } ], "refs": 4 } } ] }, { "name": "Real test with 0", "script": [ "PUSH3", "PUSH2", "PUSH1", "PUSH0", "PICK" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "PICK", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 } ], "refs": 4 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Stack/REVERSE3.json ================================================ { "category": "Stack", "name": "REVERSE3", "tests": [ { "name": "Without push", "script": [ "REVERSE3" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "With push", "script": [ "PUSH1", "PUSH2", "PUSH3", "REVERSE3" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "REVERSE3", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 3 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 } ], "refs": 3 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Stack/REVERSE4.json ================================================ { "category": "Stack", "name": "REVERSE4", "tests": [ { "name": "Without push", "script": [ "REVERSE4" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "With push", "script": [ "PUSH1", "PUSH2", "PUSH3", "PUSH4", "REVERSE4" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "REVERSE4", "evaluationStack": [ { "type": "integer", "value": 4 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 4 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 4 } ], "refs": 4 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Stack/REVERSEN.json ================================================ { "category": "Stack", "name": "REVERSEN", "tests": [ { "name": "Without push", "script": [ "REVERSEN" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "N = -1", "script": [ "PUSH1", "PUSHM1", "REVERSEN" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "N < DEPTH", "script": [ "PUSH1", "REVERSEN" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT", "resultStack": [ { "type": "integer", "value": 1 } ] } } ] }, { "name": "Reverse 0 item", "script": [ "PUSH1", "PUSH2", "PUSH3", "PUSH0", "REVERSEN" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "REVERSEN", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 4 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ], "refs": 3 } } ] }, { "name": "Reverse 3 items", "script": [ "PUSH1", "PUSH2", "PUSH3", "PUSH3", "REVERSEN" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "REVERSEN", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 4 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 } ], "refs": 3 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Stack/ROLL.json ================================================ { "category": "Stack", "name": "ROLL", "tests": [ { "name": "Without push", "script": [ "ROLL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With -1", "script": [ "PUSHM1", "ROLL" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Pick outside", "script": [ "PUSH1", "PUSH2", "PUSH3", "PUSH4", "ROLL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "ROLL", "evaluationStack": [ { "type": "integer", "value": 4 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Less than 0", "script": [ "PUSH1", "PUSH2", "PUSH3", "PUSHM1", "ROLL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "ROLL", "evaluationStack": [ { "type": "integer", "value": -1 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With 0", "script": [ "PUSH1", "PUSH2", "PUSH3", "PUSH0", "ROLL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "ROLL", "evaluationStack": [ { "type": "integer", "value": 0 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ], "refs": 3 } } ] }, { "name": "Wrong type", "script": [ "PUSH1", "PUSH2", "PUSH3", "NEWMAP", "ROLL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "ROLL", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH3", "PUSH2", "PUSH1", "PUSH2", "ROLL" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "ROLL", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 } ], "refs": 3 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Stack/ROT.json ================================================ { "category": "Stack", "name": "ROT", "tests": [ { "name": "Without push", "script": [ "ROT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With one push", "script": [ "PUSH0", "ROT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "ROT", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With 2 items", "script": [ "PUSH1", "PUSH2", "ROT" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "ROT", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test with 3 items", "script": [ "PUSH1", "PUSH2", "PUSH3", "ROT" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "ROT", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 } ], "refs": 3 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Stack/SWAP.json ================================================ { "category": "Stack", "name": "SWAP", "tests": [ { "name": "Without push", "script": [ "SWAP" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With one push", "script": [ "PUSH0", "SWAP" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "SWAP", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test with 2 items", "script": [ "PUSH1", "PUSH2", "SWAP" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "SWAP", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 } ] } ], "refs": 2 } } ] }, { "name": "Real test with 3 items", "script": [ "PUSH1", "PUSH2", "PUSH3", "SWAP" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "SWAP", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 1 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 1 } ], "refs": 3 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Stack/TUCK.json ================================================ { "category": "Stack", "name": "TUCK", "tests": [ { "name": "Without push", "script": [ "TUCK" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Outside", "script": [ "PUSH0", "TUCK" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "TUCK", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test - Last item", "script": [ "PUSH1", "PUSH2", "TUCK" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "TUCK", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 } ], "refs": 3 } } ] }, { "name": "Real test", "script": [ "PUSH1", "PUSH2", "PUSH3", "TUCK" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "TUCK", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 1 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 }, { "type": "integer", "value": 1 } ], "refs": 4 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Stack/XDROP.json ================================================ { "category": "Stack", "name": "XDROP", "tests": [ { "name": "Without push", "script": [ "XDROP" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "With -1", "script": [ "PUSHM1", "XDROP" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Overflow drop", "script": [ "PUSH3", "PUSH2", "PUSH1", "PUSH3", "XDROP" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "XDROP", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Wrong index type [Map]", "script": [ "PUSH3", "PUSH2", "PUSH1", "NEWMAP", "XDROP" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "XDROP", "evaluationStack": [ { "type": "map", "value": {} }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Real test", "script": [ "PUSH3", "PUSH2", "PUSH1", "PUSH1", "XDROP" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "XDROP", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 1 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 3 } ] } ], "refs": 4 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 3 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 1 }, { "type": "integer", "value": 3 } ], "refs": 2 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Types/CONVERT.json ================================================ { "category": "Types", "name": "CONVERT", "tests": [ { "name": "Null to Buffer", "script": [ "PUSHNULL", "CONVERT", "0x30" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "CONVERT", "evaluationStack": [ { "type": "null" } ] } ], "refs": 1 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "null" } ], "refs": 1 } } ] }, { "name": "Null to Boolean", "script": [ "PUSHNULL", "CONVERT", "0x20" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "CONVERT", "evaluationStack": [ { "type": "null" } ] } ], "refs": 1 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "null" } ], "refs": 1 } } ] }, { "name": "Struct to Array", "script": [ "PUSH1", "NEWSTRUCT", "DUP", "PUSH0", "PUSH5", "SETITEM", "CONVERT", "0x40" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "CONVERT", "evaluationStack": [ { "type": "struct", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "refs": 2 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 5 } ] } ], "refs": 2 } } ] }, { "name": "Struct to Boolean", "script": [ "PUSH0", "NEWSTRUCT", "CONVERT", "0x20" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "CONVERT", "evaluationStack": [ { "type": "struct", "value": [] } ] } ], "refs": 1 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Array to Boolean", "script": [ "PUSH0", "NEWARRAY", "CONVERT", "0x20" ], "steps": [ { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "CONVERT", "evaluationStack": [ { "type": "array", "value": [] } ] } ], "refs": 1 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Array to Struct", "script": [ "PUSH1", "NEWARRAY", "DUP", "PUSH0", "PUSH5", "SETITEM", "CONVERT", "0x41" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "CONVERT", "evaluationStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 5 } ] } ] } ], "refs": 2 } }, { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "struct", "value": [ { "type": "Integer", "value": 5 } ] } ], "refs": 2 } } ] }, { "name": "Array to Integer", "script": [ "PUSH1", "NEWARRAY", "DUP", "PUSH0", "PUSH4", "SETITEM", "CONVERT", "0x21" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "CONVERT", "evaluationStack": [ { "type": "array", "value": [ { "type": "Integer", "value": 4 } ] } ] } ], "refs": 2 } }, { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Integer to ByteString", "script": [ "PUSHINT8", "0x0A", "CONVERT", "0x28" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "ByteString", "value": "0x0A" } ], "refs": 1 } } ] }, { "name": "Integer to Boolean", "script": [ "PUSHINT8", "0x0A", "CONVERT", "0x20" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Integer to Boolean", "script": [ "PUSHINT8", "0x00", "CONVERT", "0x20" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Integer to Boolean", "script": [ "PUSHINT8", "0x01", "CONVERT", "0x20" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Integer to Buffer", "script": [ "PUSHINT8", "0x0A", "CONVERT", "0x30" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Buffer", "value": "0x0A" } ], "refs": 1 } } ] }, { "name": "ByteString to Buffer", "script": [ "PUSHDATA1", "0x0A", "0x00000000000000000000", "CONVERT", "0x30" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Buffer", "value": "0x00000000000000000000" } ], "refs": 1 } } ] }, { "name": "ByteString to Integer", "script": [ "PUSHDATA1", "0x02", "0x0A0B", "CONVERT", "0x21" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 2826 } ], "refs": 1 } } ] }, { "name": "ByteString to Boolean", "script": [ "PUSHDATA1", "0x02", "0x0A0B", "CONVERT", "0x20" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "ByteString to Boolean", "script": [ "PUSHDATA1", "0x02", "0x0000", "CONVERT", "0x20" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "ByteString to Boolean", "script": [ "PUSHDATA1", "0x02", "0x0001", "CONVERT", "0x20" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "ByteString to Boolean", "script": [ "PUSHDATA1", "0x01", "0x01", "CONVERT", "0x20" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Buffer to ByteString", "script": [ "PUSHDATA1", "0x0A", "0x00000000000000000000", "CONVERT", "0x30", "CONVERT", "0x28" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "ByteString", "value": "0x00000000000000000000" } ], "refs": 1 } } ] }, { "name": "Buffer to Boolean", "script": [ "PUSHDATA1", "0x01", "0x00", "CONVERT", "0x30", "CONVERT", "0x20" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Buffer to Boolean", "script": [ "PUSHDATA1", "0x01", "0x02", "CONVERT", "0x30", "CONVERT", "0x20" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Buffer to Integer", "script": [ "PUSHDATA1", "0x02", "0x0102", "CONVERT", "0x30", "CONVERT", "0x21" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Integer", "value": 513 } ], "refs": 1 } } ] }, { "name": "Buffer to Integer (Exceed)", "script": [ "PUSHDATA1", "0x21", "0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", "CONVERT", "0x30", "CONVERT", "0x21" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Buffer to Any", "script": [ "PUSHDATA1", "0x02", "0x0102", "CONVERT", "0x30", "CONVERT", "0x00" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Buffer to Interop", "script": [ "PUSHDATA1", "0x02", "0x0102", "CONVERT", "0x30", "CONVERT", "0x60" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "ByteString to non-defined", "script": [ "PUSHDATA1", "0x01", "0xAA", "CONVERT", "0xFF" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Array to non-defined", "script": [ "NEWARRAY0", "CONVERT", "0xFF" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Struct to non-defined", "script": [ "NEWSTRUCT0", "CONVERT", "0xFF" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] }, { "name": "Null to non-defined", "script": [ "PUSHNULL", "CONVERT", "0xFF" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Types/ISNULL.json ================================================ { "category": "Types", "name": "ISNULL", "tests": [ { "name": "Without push", "script": [ "ISNULL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Good definition", "script": [ "PUSHNULL", "ISNULL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "ISNULL", "evaluationStack": [ { "type": "null" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "With empty ByteString", "script": [ "PUSH0", "ISNULL" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "ISNULL", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "RET", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/OpCodes/Types/ISTYPE.json ================================================ { "category": "Types", "name": "ISTYPE", "tests": [ { "name": "Array", "script": [ "NEWARRAY0", "ISTYPE", "0x40" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Buffer", "script": [ "PUSH0", "NEWBUFFER", "ISTYPE", "0x30" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "ByteString", "script": [ "PUSHDATA1", "0x00", "ISTYPE", "0x28" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Integer", "script": [ "PUSH0", "ISTYPE", "0x21" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "InteropInterface", "script": [ "SYSCALL", "0x77777777", "ISTYPE", "0x60" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Map", "script": [ "NEWMAP", "ISTYPE", "0x48" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Null", "script": [ "PUSHNULL", "ISTYPE", "0x20" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": false } ], "refs": 1 } } ] }, { "name": "Pointer", "script": [ "PUSHA", "0x00000000", "ISTYPE", "0x10" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] }, { "name": "Struct", "script": [ "NEWSTRUCT0", "ISTYPE", "0x41" ], "steps": [ { "actions": [ "Execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "Boolean", "value": true } ], "refs": 1 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/Others/Debugger.json ================================================ { "category": "Others", "name": "Debugger", "tests": [ { "name": "Step Into", "script": [ "PUSH1", "CALL", "0x04", "PUSH3", "RET", "PUSH2", "RET" ], "steps": [ { "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 0, "nextInstruction": "PUSH1" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "CALL", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 5, "nextInstruction": "PUSH2", "evaluationStack": [ { "type": "integer", "value": 1 } ] }, { "instructionPointer": 3, "nextInstruction": "PUSH3", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 6, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] }, { "instructionPointer": 3, "nextInstruction": "PUSH3", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "PUSH3", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 3 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ], "refs": 3 } } ] }, { "name": "Step Out", "script": [ "PUSH1", "CALL", "0x04", "PUSH3", "RET", "PUSH2", "RET" ], "steps": [ { "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 0, "nextInstruction": "PUSH1" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "CALL", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepOut" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ], "refs": 3 } } ] }, { "name": "Step Over", "script": [ "PUSH1", "CALL", "0x04", "PUSH3", "RET", "PUSH2", "RET" ], "steps": [ { "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 0, "nextInstruction": "PUSH1" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "CALL", "evaluationStack": [ { "type": "integer", "value": 1 } ] } ], "refs": 1 } }, { "actions": [ "stepOver" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "PUSH3", "evaluationStack": [ { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 2 } }, { "actions": [ "stepOver" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET", "evaluationStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ] } ], "refs": 3 } }, { "actions": [ "stepOver" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ], "refs": 3 } } ] }, { "name": "Execute", "script": [ "PUSH1", "CALL", "0x04", "PUSH3", "RET", "PUSH2", "RET" ], "steps": [ { "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 0, "nextInstruction": "PUSH1" } ], "refs": 0 } }, { "actions": [ "execute" ], "result": { "state": "HALT", "resultStack": [ { "type": "integer", "value": 3 }, { "type": "integer", "value": 2 }, { "type": "integer", "value": 1 } ], "refs": 3 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/Others/Init.json ================================================ { "category": "Others", "name": "Init", "tests": [ { "name": "Init script", "script": [ "RET" ], "steps": [ { "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 0, "nextInstruction": "RET" } ], "refs": 0 } } ] }, { "name": "Init script", "script": [ "RET" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/Others/InvocationLimits.json ================================================ { "category": "Limits", "name": "Invocation limits", "tests": [ { "name": "More than 1024 ExecutionContext", "script": [ "INITSSLOT", "0x01", "PUSHDATA1", "0x02", "0x0004", "INC", "STSFLD0", "LDSFLD0", "DEC", "DUP", "STSFLD0", "JMPIFNOT", "0x04", "CALL", "0xfa", "RET" ], "steps": [ { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "LDSFLD0", "staticFields": [ { "type": "integer", "value": 1025 } ] } ], "refs": 1 } }, { "actions": [ "stepInto", "stepInto", "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 12, "nextInstruction": "JMPIFNOT", "evaluationStack": [ { "type": "integer", "value": 1024 } ], "staticFields": [ { "type": "integer", "value": 1024 } ] } ], "refs": 2 } }, { "actions": [ "stepInto", "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 8, "nextInstruction": "LDSFLD0", "staticFields": [ { "type": "integer", "value": 1024 } ] }, { "instructionPointer": 16, "nextInstruction": "RET", "staticFields": [ { "type": "integer", "value": 1024 } ] } ], "refs": 1 } }, { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/Others/OtherCases.json ================================================ { "category": "Limits", "name": "OtherCases", "tests": [ { "name": "Wrong script", "script": [ "0xff" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Without script", "script": [], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/Others/ScriptLogic.json ================================================ { "category": "Others", "name": "ScriptLogic", "tests": [ { "name": "Script logic", "script": [ "PUSH0", "NOT", "NOT", "DROP" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 1, "nextInstruction": "NOT", "evaluationStack": [ { "type": "integer", "value": 0 } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 2, "nextInstruction": "NOT", "evaluationStack": [ { "type": "Boolean", "value": true } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 3, "nextInstruction": "DROP", "evaluationStack": [ { "type": "Boolean", "value": false } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 4, "nextInstruction": "RET" } ], "refs": 0 } }, { "actions": [ "stepInto" ], "result": { "state": "HALT", "refs": 0 } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/Others/StackItemLimits.json ================================================ { "category": "Limits", "name": "Stack item limits [StackItemLimits] [StackItemLimits] [StackItemLimits]", "tests": [ { "name": "Max boolean ByteString", "script": [ "PUSHDATA1", "0x21", "0x000000000000000000000000000000000000000000000000000000000000000000", "NOT" ], "steps": [ { "actions": [ "stepInto" ], "result": { "state": "BREAK", "invocationStack": [ { "instructionPointer": 35, "nextInstruction": "NOT", "evaluationStack": [ { "type": "ByteString", "value": "0x000000000000000000000000000000000000000000000000000000000000000000" } ] } ], "refs": 1 } }, { "actions": [ "stepInto" ], "result": { "state": "FAULT" } } ] }, { "name": "Max items with PUSHDATA (2048+1)", "script": [ "PUSHINT16", "0x0004", "NEWARRAY", "UNPACK", "PUSHINT16", "0xfe03", "NEWARRAY", "UNPACK", "PUSHDATA1", "0x01", "0x01" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Tests/Others/StackLimits.json ================================================ { "category": "Limits", "name": "Stack limits [StackLimits] [StackLimits] [StackLimits]", "tests": [ { "name": "Good: 2048 PUSH1 + 2048 DROP", "script": [ "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP", "DROP" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "HALT", "refs": 0 } } ] }, { "name": "Bad: 2049 PUSH1", "script": [ "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1", "PUSH1" ], "steps": [ { "actions": [ "execute" ], "result": { "state": "FAULT" } } ] } ] } ================================================ FILE: tests/Neo.VM.Tests/Types/TestEngine.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // TestEngine.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.VM; using Neo.VM.Types; using System; namespace Neo.Test.Types; public class TestEngine : ExecutionEngine { public Exception FaultException { get; private set; } public TestEngine() : base(ComposeJumpTable()) { } public TestEngine(IReferenceCounter referenceCounter, ExecutionEngineLimits limits) : base(ComposeJumpTable(), referenceCounter, limits) { } private static JumpTable ComposeJumpTable() { var jumpTable = new JumpTable(); jumpTable[OpCode.SYSCALL] = OnSysCall; return jumpTable; } private static void OnSysCall(ExecutionEngine engine, Instruction instruction) { uint method = instruction.TokenU32; if (method == 0x77777777) { engine.CurrentContext.EvaluationStack.Push(StackItem.FromInterface(new object())); return; } if (method == 0xaddeadde) { engine.JumpTable.ExecuteThrow(engine, "error"); return; } throw new Exception(); } protected override void OnFault(Exception ex) { FaultException = ex; base.OnFault(ex); } } ================================================ FILE: tests/Neo.VM.Tests/Types/VMUT.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // VMUT.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Newtonsoft.Json; namespace Neo.Test.Types; public class VMUT { [JsonProperty] public string Category { get; set; } [JsonProperty] public string Name { get; set; } [JsonProperty] public VMUTEntry[] Tests { get; set; } } ================================================ FILE: tests/Neo.VM.Tests/Types/VMUTActionType.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // VMUTActionType.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. namespace Neo.Test.Types; public enum VMUTActionType { Execute, // Steps StepInto, StepOut, StepOver, } ================================================ FILE: tests/Neo.VM.Tests/Types/VMUTEntry.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // VMUTEntry.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.Test.Converters; using Newtonsoft.Json; namespace Neo.Test.Types; public class VMUTEntry { [JsonProperty(Order = 1)] public string Name { get; set; } [JsonProperty(Order = 2), JsonConverter(typeof(ScriptConverter))] public byte[] Script { get; set; } [JsonProperty(Order = 3)] public VMUTStep[] Steps { get; set; } } ================================================ FILE: tests/Neo.VM.Tests/Types/VMUTExecutionContextState.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // VMUTExecutionContextState.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.Test.Converters; using Neo.VM; using Newtonsoft.Json; namespace Neo.Test.Types; public class VMUTExecutionContextState { [JsonProperty] public int InstructionPointer { get; set; } [JsonProperty, JsonConverter(typeof(UppercaseEnum))] public OpCode NextInstruction { get; set; } // Stacks [JsonProperty] public VMUTStackItem[] EvaluationStack { get; set; } // Slots [JsonProperty] public VMUTStackItem[] StaticFields { get; set; } [JsonProperty] public VMUTStackItem[] Arguments { get; set; } [JsonProperty] public VMUTStackItem[] LocalVariables { get; set; } } ================================================ FILE: tests/Neo.VM.Tests/Types/VMUTExecutionEngineState.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // VMUTExecutionEngineState.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Neo.Test.Converters; using Neo.VM; using Newtonsoft.Json; namespace Neo.Test.Types; public class VMUTExecutionEngineState { [JsonProperty, JsonConverter(typeof(UppercaseEnum))] public VMState State { get; set; } [JsonProperty] public VMUTStackItem[] ResultStack { get; set; } [JsonProperty] public VMUTExecutionContextState[] InvocationStack { get; set; } [JsonProperty] public string ExceptionMessage { get; set; } [JsonProperty] public int? Refs { get; set; } } ================================================ FILE: tests/Neo.VM.Tests/Types/VMUTStackItem.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // VMUTStackItem.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Newtonsoft.Json; using Newtonsoft.Json.Linq; namespace Neo.Test.Types; public class VMUTStackItem { [JsonProperty] public VMUTStackItemType Type { get; set; } [JsonProperty] public JToken Value { get; set; } } ================================================ FILE: tests/Neo.VM.Tests/Types/VMUTStackItemType.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // VMUTStackItemType.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. namespace Neo.Test.Types; public enum VMUTStackItemType { /// /// Null /// Null, /// /// An address of function /// Pointer, /// /// Boolean (true,false) /// Boolean, /// /// ByteString /// ByteString, /// /// ByteString as UTF8 string /// String, /// /// Mutable byte array /// Buffer, /// /// InteropInterface /// Interop, /// /// BigInteger /// Integer, /// /// Array /// Array, /// /// Struct /// Struct, /// /// Map /// Map } ================================================ FILE: tests/Neo.VM.Tests/Types/VMUTStep.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // VMUTStep.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Newtonsoft.Json; namespace Neo.Test.Types; public class VMUTStep { [JsonProperty] public string Name { get; set; } [JsonProperty] public VMUTActionType[] Actions { get; set; } [JsonProperty] public VMUTExecutionEngineState Result { get; set; } } ================================================ FILE: tests/Neo.VM.Tests/UT_Debugger.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // UT_Debugger.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.VisualStudio.TestTools.UnitTesting; using Neo.VM; namespace Neo.Test; [TestClass] public class UT_Debugger { [TestMethod] public void TestBreakPoint() { using ExecutionEngine engine = new(); using ScriptBuilder script = new(); script.Emit(OpCode.NOP); script.Emit(OpCode.NOP); script.Emit(OpCode.NOP); script.Emit(OpCode.NOP); engine.LoadScript(script.ToArray()); Debugger debugger = new(engine); Assert.IsFalse(debugger.RemoveBreakPoint(engine.CurrentContext.Script, 3)); Assert.AreEqual(OpCode.NOP, engine.CurrentContext.NextInstruction.OpCode); debugger.AddBreakPoint(engine.CurrentContext.Script, 2); debugger.AddBreakPoint(engine.CurrentContext.Script, 3); debugger.Execute(); Assert.AreEqual(OpCode.NOP, engine.CurrentContext.NextInstruction.OpCode); Assert.AreEqual(2, engine.CurrentContext.InstructionPointer); Assert.AreEqual(VMState.BREAK, engine.State); Assert.IsTrue(debugger.RemoveBreakPoint(engine.CurrentContext.Script, 2)); Assert.IsFalse(debugger.RemoveBreakPoint(engine.CurrentContext.Script, 2)); Assert.IsTrue(debugger.RemoveBreakPoint(engine.CurrentContext.Script, 3)); Assert.IsFalse(debugger.RemoveBreakPoint(engine.CurrentContext.Script, 3)); debugger.Execute(); Assert.AreEqual(VMState.HALT, engine.State); } [TestMethod] public void TestWithoutBreakPoints() { using ExecutionEngine engine = new(); using ScriptBuilder script = new(); script.Emit(OpCode.NOP); script.Emit(OpCode.NOP); script.Emit(OpCode.NOP); script.Emit(OpCode.NOP); engine.LoadScript(script.ToArray()); Debugger debugger = new(engine); Assert.AreEqual(OpCode.NOP, engine.CurrentContext.NextInstruction.OpCode); debugger.Execute(); Assert.IsNull(engine.CurrentContext); Assert.AreEqual(VMState.HALT, engine.State); } [TestMethod] public void TestWithoutDebugger() { using ExecutionEngine engine = new(); using ScriptBuilder script = new(); script.Emit(OpCode.NOP); script.Emit(OpCode.NOP); script.Emit(OpCode.NOP); script.Emit(OpCode.NOP); engine.LoadScript(script.ToArray()); Assert.AreEqual(OpCode.NOP, engine.CurrentContext.NextInstruction.OpCode); engine.Execute(); Assert.IsNull(engine.CurrentContext); Assert.AreEqual(VMState.HALT, engine.State); } [TestMethod] public void TestStepOver() { using ExecutionEngine engine = new(); using ScriptBuilder script = new(); /* ┌ CALL │ ┌> NOT │ │ RET └> │ PUSH0 └─┘ RET */ script.EmitCall(4); script.Emit(OpCode.NOT); script.Emit(OpCode.RET); script.Emit(OpCode.PUSH0); script.Emit(OpCode.RET); engine.LoadScript(script.ToArray()); Debugger debugger = new(engine); Assert.AreEqual(OpCode.NOT, engine.CurrentContext.NextInstruction.OpCode); Assert.AreEqual(VMState.BREAK, debugger.StepOver()); Assert.AreEqual(2, engine.CurrentContext.InstructionPointer); Assert.AreEqual(VMState.BREAK, engine.State); Assert.AreEqual(OpCode.RET, engine.CurrentContext.NextInstruction.OpCode); debugger.Execute(); Assert.IsTrue(engine.ResultStack.Pop().GetBoolean()); Assert.AreEqual(VMState.HALT, engine.State); // Test step over again Assert.AreEqual(VMState.HALT, debugger.StepOver()); Assert.AreEqual(VMState.HALT, engine.State); } [TestMethod] public void TestStepInto() { using ExecutionEngine engine = new(); using ScriptBuilder script = new(); /* ┌ CALL │ ┌> NOT │ │ RET └> │ PUSH0 └─┘ RET */ script.EmitCall(4); script.Emit(OpCode.NOT); script.Emit(OpCode.RET); script.Emit(OpCode.PUSH0); script.Emit(OpCode.RET); engine.LoadScript(script.ToArray()); Debugger debugger = new(engine); var context = engine.CurrentContext; Assert.AreEqual(context, engine.CurrentContext); Assert.AreEqual(context, engine.EntryContext); Assert.AreEqual(OpCode.NOT, engine.CurrentContext.NextInstruction.OpCode); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreNotEqual(context, engine.CurrentContext); Assert.AreEqual(context, engine.EntryContext); Assert.AreEqual(OpCode.RET, engine.CurrentContext.NextInstruction.OpCode); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(context, engine.CurrentContext); Assert.AreEqual(context, engine.EntryContext); Assert.AreEqual(OpCode.RET, engine.CurrentContext.NextInstruction.OpCode); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(VMState.HALT, debugger.StepInto()); Assert.IsTrue(engine.ResultStack.Pop().GetBoolean()); Assert.AreEqual(VMState.HALT, engine.State); // Test step into again Assert.AreEqual(VMState.HALT, debugger.StepInto()); Assert.AreEqual(VMState.HALT, engine.State); } [TestMethod] public void TestBreakPointStepOver() { using ExecutionEngine engine = new(); using ScriptBuilder script = new(); /* ┌ CALL │ ┌> NOT │ │ RET └>X│ PUSH0 └┘ RET */ script.EmitCall(4); script.Emit(OpCode.NOT); script.Emit(OpCode.RET); script.Emit(OpCode.PUSH0); script.Emit(OpCode.RET); engine.LoadScript(script.ToArray()); Debugger debugger = new(engine); Assert.AreEqual(OpCode.NOT, engine.CurrentContext.NextInstruction.OpCode); debugger.AddBreakPoint(engine.CurrentContext.Script, 5); Assert.AreEqual(VMState.BREAK, debugger.StepOver()); Assert.IsNull(engine.CurrentContext.NextInstruction); Assert.AreEqual(5, engine.CurrentContext.InstructionPointer); Assert.AreEqual(VMState.BREAK, engine.State); debugger.Execute(); Assert.IsTrue(engine.ResultStack.Pop().GetBoolean()); Assert.AreEqual(VMState.HALT, engine.State); } } ================================================ FILE: tests/Neo.VM.Tests/UT_EvaluationStack.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // UT_EvaluationStack.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.VisualStudio.TestTools.UnitTesting; using Neo.Test.Extensions; using Neo.VM; using Neo.VM.Types; using System; using System.Collections; using System.Linq; namespace Neo.Test; [TestClass] public class UT_EvaluationStack { private static EvaluationStack CreateOrderedStack(int count) { var check = new Integer[count]; var stack = new EvaluationStack(new ReferenceCounter()); for (int x = 1; x <= count; x++) { stack.Push(x); check[x - 1] = x; } Assert.AreEqual(count, stack.Count); CollectionAssert.AreEqual(check, stack.ToArray()); return stack; } public static IEnumerable GetEnumerable(IEnumerator enumerator) { while (enumerator.MoveNext()) yield return enumerator.Current; } [TestMethod] public void TestClear() { var stack = CreateOrderedStack(3); stack.Clear(); Assert.AreEqual(0, stack.Count); } [TestMethod] public void TestCopyTo() { var stack = CreateOrderedStack(3); var copy = new EvaluationStack(new ReferenceCounter()); Assert.ThrowsExactly(() => stack.CopyTo(copy, -2)); Assert.ThrowsExactly(() => stack.CopyTo(copy, 4)); stack.CopyTo(copy, 0); Assert.AreEqual(3, stack.Count); Assert.AreEqual(0, copy.Count); CollectionAssert.AreEqual(new Integer[] { 1, 2, 3 }, stack.ToArray()); stack.CopyTo(copy, -1); Assert.AreEqual(3, stack.Count); Assert.AreEqual(3, copy.Count); CollectionAssert.AreEqual(new Integer[] { 1, 2, 3 }, stack.ToArray()); // Test IEnumerable var enumerable = (IEnumerable)copy; var enumerator = enumerable.GetEnumerator(); CollectionAssert.AreEqual(new Integer[] { 1, 2, 3 }, GetEnumerable(enumerator).Cast().ToArray()); copy.CopyTo(stack, 2); Assert.AreEqual(5, stack.Count); Assert.AreEqual(3, copy.Count); CollectionAssert.AreEqual(new Integer[] { 1, 2, 3, 2, 3 }, stack.ToArray()); CollectionAssert.AreEqual(new Integer[] { 1, 2, 3 }, copy.ToArray()); } [TestMethod] public void TestMoveTo() { var stack = CreateOrderedStack(3); var other = new EvaluationStack(new ReferenceCounter()); stack.MoveTo(other, 0); Assert.AreEqual(3, stack.Count); Assert.AreEqual(0, other.Count); CollectionAssert.AreEqual(new Integer[] { 1, 2, 3 }, stack.ToArray()); stack.MoveTo(other, -1); Assert.AreEqual(0, stack.Count); Assert.AreEqual(3, other.Count); CollectionAssert.AreEqual(new Integer[] { 1, 2, 3 }, other.ToArray()); // Test IEnumerable var enumerable = (IEnumerable)other; var enumerator = enumerable.GetEnumerator(); CollectionAssert.AreEqual(new Integer[] { 1, 2, 3 }, GetEnumerable(enumerator).Cast().ToArray()); other.MoveTo(stack, 2); Assert.AreEqual(2, stack.Count); Assert.AreEqual(1, other.Count); CollectionAssert.AreEqual(new Integer[] { 2, 3 }, stack.ToArray()); CollectionAssert.AreEqual(new Integer[] { 1 }, other.ToArray()); } [TestMethod] public void TestInsertPeek() { var stack = new EvaluationStack(new ReferenceCounter()); stack.Insert(0, 3); stack.Insert(1, 1); stack.Insert(1, 2); Assert.ThrowsExactly(() => stack.Insert(4, 2)); Assert.AreEqual(3, stack.Count); CollectionAssert.AreEqual(new Integer[] { 1, 2, 3 }, stack.ToArray()); Assert.AreEqual(3, stack.Peek(0)); Assert.AreEqual(2, stack.Peek(1)); Assert.AreEqual(1, stack.Peek(-1)); Assert.ThrowsExactly(() => _ = stack.Peek(-4)); } [TestMethod] public void TestPopPush() { var stack = CreateOrderedStack(3); Assert.AreEqual(3, stack.Pop()); Assert.AreEqual(2, stack.Pop()); Assert.AreEqual(1, stack.Pop()); Assert.ThrowsExactly(() => _ = stack.Pop()); stack = CreateOrderedStack(3); Assert.IsTrue(stack.Pop().Equals(3)); Assert.IsTrue(stack.Pop().Equals(2)); Assert.IsTrue(stack.Pop().Equals(1)); Assert.ThrowsExactly(() => _ = stack.Pop()); } [TestMethod] public void TestRemove() { var stack = CreateOrderedStack(3); Assert.IsTrue(stack.Remove(0).Equals(3)); Assert.IsTrue(stack.Remove(0).Equals(2)); Assert.IsTrue(stack.Remove(-1).Equals(1)); Assert.ThrowsExactly(() => _ = stack.Remove(0)); Assert.ThrowsExactly(() => _ = stack.Remove(-1)); } [TestMethod] public void TestReverse() { var stack = CreateOrderedStack(3); stack.Reverse(3); Assert.IsTrue(stack.Pop().Equals(1)); Assert.IsTrue(stack.Pop().Equals(2)); Assert.IsTrue(stack.Pop().Equals(3)); Assert.ThrowsExactly(() => _ = stack.Pop().Equals(0)); stack = CreateOrderedStack(3); Assert.ThrowsExactly(() => stack.Reverse(-1)); Assert.ThrowsExactly(() => stack.Reverse(4)); stack.Reverse(1); Assert.IsTrue(stack.Pop().Equals(3)); Assert.IsTrue(stack.Pop().Equals(2)); Assert.IsTrue(stack.Pop().Equals(1)); Assert.ThrowsExactly(() => _ = stack.Pop().Equals(0)); } [TestMethod] public void TestEvaluationStackPrint() { var stack = new EvaluationStack(new ReferenceCounter()); stack.Insert(0, 3); stack.Insert(1, 1); stack.Insert(2, "test"); stack.Insert(3, true); Assert.AreEqual("[Boolean(True), ByteString(\"test\"), Integer(1), Integer(3)]", stack.ToString()); } [TestMethod] public void TestPrintInvalidUTF8() { var stack = new EvaluationStack(new ReferenceCounter()); stack.Insert(0, "4CC95219999D421243C8161E3FC0F4290C067845".FromHexString()); Assert.AreEqual("[ByteString(\"Base64: TMlSGZmdQhJDyBYeP8D0KQwGeEU=\")]", stack.ToString()); } } ================================================ FILE: tests/Neo.VM.Tests/UT_ExecutionContext.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // UT_ExecutionContext.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.VisualStudio.TestTools.UnitTesting; using Neo.VM; using System; using System.Collections.Generic; namespace Neo.Test; [TestClass] public class UT_ExecutionContext { class TestState { public bool Flag = false; } [TestMethod] public void TestStateTest() { var context = new ExecutionContext(Array.Empty(), -1, new ReferenceCounter()); // Test factory var flag = context.GetState(() => new TestState() { Flag = true }); Assert.IsTrue(flag.Flag); flag.Flag = false; flag = context.GetState(() => new TestState() { Flag = true }); Assert.IsFalse(flag.Flag); // Test new var stack = context.GetState>(); Assert.IsEmpty(stack); stack.Push(100); stack = context.GetState>(); Assert.AreEqual(100, stack.Pop()); stack.Push(100); // Test clone var copy = context.Clone(); var copyStack = copy.GetState>(); Assert.HasCount(1, copyStack); copyStack.Push(200); copyStack = context.GetState>(); Assert.AreEqual(200, copyStack.Pop()); Assert.AreEqual(100, copyStack.Pop()); copyStack.Push(200); stack = context.GetState>(); Assert.AreEqual(200, stack.Pop()); } } ================================================ FILE: tests/Neo.VM.Tests/UT_ReferenceCounter.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // UT_ReferenceCounter.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.VisualStudio.TestTools.UnitTesting; using Neo.VM; using Neo.VM.Types; using System; using System.Collections.Generic; using System.Numerics; using Array = Neo.VM.Types.Array; namespace Neo.Test; [TestClass] public class UT_ReferenceCounter { [TestMethod] public void TestCircularReferences() { using ScriptBuilder sb = new(); sb.Emit(OpCode.INITSSLOT, new byte[] { 1 }); //{}|{null}:1 sb.EmitPush(0); //{0}|{null}:2 sb.Emit(OpCode.NEWARRAY); //{A[]}|{null}:2 sb.Emit(OpCode.DUP); //{A[],A[]}|{null}:3 sb.Emit(OpCode.DUP); //{A[],A[],A[]}|{null}:4 sb.Emit(OpCode.APPEND); //{A[A]}|{null}:3 sb.Emit(OpCode.DUP); //{A[A],A[A]}|{null}:4 sb.EmitPush(0); //{A[A],A[A],0}|{null}:5 sb.Emit(OpCode.NEWARRAY); //{A[A],A[A],B[]}|{null}:5 sb.Emit(OpCode.STSFLD0); //{A[A],A[A]}|{B[]}:4 sb.Emit(OpCode.LDSFLD0); //{A[A],A[A],B[]}|{B[]}:5 sb.Emit(OpCode.APPEND); //{A[A,B]}|{B[]}:4 sb.Emit(OpCode.LDSFLD0); //{A[A,B],B[]}|{B[]}:5 sb.EmitPush(0); //{A[A,B],B[],0}|{B[]}:6 sb.Emit(OpCode.NEWARRAY); //{A[A,B],B[],C[]}|{B[]}:6 sb.Emit(OpCode.TUCK); //{A[A,B],C[],B[],C[]}|{B[]}:7 sb.Emit(OpCode.APPEND); //{A[A,B],C[]}|{B[C]}:6 sb.EmitPush(0); //{A[A,B],C[],0}|{B[C]}:7 sb.Emit(OpCode.NEWARRAY); //{A[A,B],C[],D[]}|{B[C]}:7 sb.Emit(OpCode.TUCK); //{A[A,B],D[],C[],D[]}|{B[C]}:8 sb.Emit(OpCode.APPEND); //{A[A,B],D[]}|{B[C[D]]}:7 sb.Emit(OpCode.LDSFLD0); //{A[A,B],D[],B[C]}|{B[C[D]]}:8 sb.Emit(OpCode.APPEND); //{A[A,B]}|{B[C[D[B]]]}:7 sb.Emit(OpCode.PUSHNULL); //{A[A,B],null}|{B[C[D[B]]]}:8 sb.Emit(OpCode.STSFLD0); //{A[A,B[C[D[B]]]]}|{null}:7 sb.Emit(OpCode.DUP); //{A[A,B[C[D[B]]]],A[A,B]}|{null}:8 sb.EmitPush(1); //{A[A,B[C[D[B]]]],A[A,B],1}|{null}:9 sb.Emit(OpCode.REMOVE); //{A[A]}|{null}:3 sb.Emit(OpCode.STSFLD0); //{}|{A[A]}:2 sb.Emit(OpCode.RET); //{}:0 using ExecutionEngine engine = new(); Debugger debugger = new(engine); engine.LoadScript(sb.ToArray()); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(1, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(2, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(2, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(3, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(4, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(3, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(4, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(5, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(5, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(4, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(5, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(4, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(5, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(6, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(6, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(7, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(6, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(7, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(7, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(8, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(7, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(8, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(7, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(8, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(7, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(8, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(9, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(6, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(5, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, debugger.Execute()); Assert.AreEqual(4, engine.ReferenceCounter.Count); } [TestMethod] public void TestRemoveReferrer() { using ScriptBuilder sb = new(); sb.Emit(OpCode.INITSSLOT, new byte[] { 1 }); //{}|{null}:1 sb.EmitPush(0); //{0}|{null}:2 sb.Emit(OpCode.NEWARRAY); //{A[]}|{null}:2 sb.Emit(OpCode.DUP); //{A[],A[]}|{null}:3 sb.EmitPush(0); //{A[],A[],0}|{null}:4 sb.Emit(OpCode.NEWARRAY); //{A[],A[],B[]}|{null}:4 sb.Emit(OpCode.STSFLD0); //{A[],A[]}|{B[]}:3 sb.Emit(OpCode.LDSFLD0); //{A[],A[],B[]}|{B[]}:4 sb.Emit(OpCode.APPEND); //{A[B]}|{B[]}:3 sb.Emit(OpCode.DROP); //{}|{B[]}:1 sb.Emit(OpCode.RET); //{}:0 using ExecutionEngine engine = new(); Debugger debugger = new(engine); engine.LoadScript(sb.ToArray()); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(1, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(2, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(2, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(3, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(4, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(4, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(3, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(4, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(3, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.BREAK, debugger.StepInto()); Assert.AreEqual(1, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, debugger.Execute()); Assert.AreEqual(0, engine.ReferenceCounter.Count); } [TestMethod] public void TestCheckZeroReferredWithArray() { using ScriptBuilder sb = new(); sb.EmitPush(ExecutionEngineLimits.Default.MaxStackSize - 1); sb.Emit(OpCode.NEWARRAY); // Good with MaxStackSize using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual((int)ExecutionEngineLimits.Default.MaxStackSize, engine.ReferenceCounter.Count); } // Fault with MaxStackSize+1 sb.Emit(OpCode.PUSH1); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.FAULT, engine.Execute()); Assert.AreEqual((int)ExecutionEngineLimits.Default.MaxStackSize + 1, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred() { using ScriptBuilder sb = new(); for (int x = 0; x < ExecutionEngineLimits.Default.MaxStackSize; x++) sb.Emit(OpCode.PUSH1); // Good with MaxStackSize using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual((int)ExecutionEngineLimits.Default.MaxStackSize, engine.ReferenceCounter.Count); } // Fault with MaxStackSize+1 sb.Emit(OpCode.PUSH1); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.FAULT, engine.Execute()); Assert.AreEqual((int)ExecutionEngineLimits.Default.MaxStackSize + 1, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_PopItemArray() { using ScriptBuilder sb = new(); sb.Emit(OpCode.POPITEM); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Array(engine.ReferenceCounter, new StackItem[] { 42 })); Assert.AreEqual(2, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(1, engine.ResultStack.Count); Assert.AreEqual(1, engine.ReferenceCounter.Count); engine.ResultStack.Pop(); // pop Array from stack. Assert.AreEqual(0, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_Append() { using ScriptBuilder sb = new(); sb.Emit(OpCode.APPEND); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Array(engine.ReferenceCounter, new StackItem[] { })); engine.Push(new Integer(42)); Assert.AreEqual(2, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(0, engine.ResultStack.Count); Assert.AreEqual(0, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_DupAppend() { using ScriptBuilder sb = new(); sb.Emit(OpCode.DUP); sb.Emit(OpCode.PUSH0); sb.Emit(OpCode.APPEND); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Array(engine.ReferenceCounter, new StackItem[] { })); Assert.AreEqual(1, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(1, engine.ResultStack.Count); Assert.AreEqual(2, engine.ReferenceCounter.Count); engine.ResultStack.Pop(); // pop Array from stack. Assert.AreEqual(0, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_SetItemMap() { using ScriptBuilder sb = new(); sb.Emit(OpCode.SETITEM); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Map(engine.ReferenceCounter)); engine.Push(new Integer(0)); engine.Push(new Integer(100500)); Assert.AreEqual(3, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(0, engine.ResultStack.Count); Assert.AreEqual(0, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_DupSetItemMap() { using ScriptBuilder sb = new(); sb.Emit(OpCode.DUP); sb.Emit(OpCode.PUSH0); sb.Emit(OpCode.PUSH1); sb.Emit(OpCode.SETITEM); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Map(engine.ReferenceCounter)); Assert.AreEqual(1, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(1, engine.ResultStack.Count); Assert.AreEqual(3, engine.ReferenceCounter.Count); engine.ResultStack.Pop(); // pop Map from stack. Assert.AreEqual(0, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_SetItemArray() { using ScriptBuilder sb = new(); sb.Emit(OpCode.SETITEM); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Array(engine.ReferenceCounter, new StackItem[] { 42 })); engine.Push(new Integer(0)); engine.Push(new Array(engine.ReferenceCounter, new StackItem[] { 42 })); Assert.AreEqual(5, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(0, engine.ResultStack.Count); Assert.AreEqual(0, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_RemoveArray() { using ScriptBuilder sb = new(); sb.Emit(OpCode.REMOVE); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Array(engine.ReferenceCounter, new StackItem[] { 42 })); engine.Push(new Integer(0)); Assert.AreEqual(3, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(0, engine.ResultStack.Count); Assert.AreEqual(0, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_RemoveStruct() { using ScriptBuilder sb = new(); sb.Emit(OpCode.REMOVE); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Struct(engine.ReferenceCounter, new StackItem[] { 42 })); engine.Push(new Integer(0)); Assert.AreEqual(3, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(0, engine.ResultStack.Count); Assert.AreEqual(0, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_RemoveMap() { using ScriptBuilder sb = new(); sb.Emit(OpCode.REMOVE); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Map(engine.ReferenceCounter) { [new Integer(0)] = StackItem.True }); engine.Push(new Integer(0)); Assert.AreEqual(4, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(0, engine.ResultStack.Count); Assert.AreEqual(0, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_DupRemoveArray() { using ScriptBuilder sb = new(); sb.Emit(OpCode.DUP); sb.Emit(OpCode.PUSH0); sb.Emit(OpCode.REMOVE); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Array(engine.ReferenceCounter, new StackItem[] { 42 })); Assert.AreEqual(2, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(1, engine.ResultStack.Count); Assert.AreEqual(1, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_DupRemoveStruct() { using ScriptBuilder sb = new(); sb.Emit(OpCode.DUP); sb.Emit(OpCode.PUSH0); sb.Emit(OpCode.REMOVE); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Struct(engine.ReferenceCounter, new StackItem[] { 42 })); Assert.AreEqual(2, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(1, engine.ResultStack.Count); Assert.AreEqual(1, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_DupRemoveMap() { using ScriptBuilder sb = new(); sb.Emit(OpCode.DUP); sb.Emit(OpCode.PUSH0); sb.Emit(OpCode.REMOVE); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Map(engine.ReferenceCounter) { [new Integer(0)] = StackItem.True }); Assert.AreEqual(3, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(1, engine.ResultStack.Count); Assert.AreEqual(1, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_ClearItemsArray() { using ScriptBuilder sb = new(); sb.Emit(OpCode.CLEARITEMS); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Array(engine.ReferenceCounter, new StackItem[] { 42 })); Assert.AreEqual(2, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(0, engine.ResultStack.Count); Assert.AreEqual(0, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_ClearItemsStruct() { using ScriptBuilder sb = new(); sb.Emit(OpCode.CLEARITEMS); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Struct(engine.ReferenceCounter, new StackItem[] { 42 })); Assert.AreEqual(2, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(0, engine.ResultStack.Count); Assert.AreEqual(0, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_ClearItemsMap() { using ScriptBuilder sb = new(); sb.Emit(OpCode.CLEARITEMS); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Map(engine.ReferenceCounter) { [new Integer(0)] = StackItem.True }); Assert.AreEqual(3, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(0, engine.ResultStack.Count); Assert.AreEqual(0, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_DupClearItemsArray() { using ScriptBuilder sb = new(); sb.Emit(OpCode.DUP); sb.Emit(OpCode.CLEARITEMS); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Array(engine.ReferenceCounter, new StackItem[] { 42 })); Assert.AreEqual(2, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(1, engine.ResultStack.Count); Assert.AreEqual(1, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_DupClearItemsStruct() { using ScriptBuilder sb = new(); sb.Emit(OpCode.DUP); sb.Emit(OpCode.CLEARITEMS); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Struct(engine.ReferenceCounter, new StackItem[] { 42 })); Assert.AreEqual(2, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(1, engine.ResultStack.Count); Assert.AreEqual(1, engine.ReferenceCounter.Count); } } [TestMethod] public void TestCheckZeroReferred_DupClearItemsMap() { using ScriptBuilder sb = new(); sb.Emit(OpCode.DUP); sb.Emit(OpCode.CLEARITEMS); using (ExecutionEngine engine = new()) { engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); engine.Push(new Map(engine.ReferenceCounter) { [new Integer(0)] = StackItem.True }); Assert.AreEqual(3, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(1, engine.ResultStack.Count); Assert.AreEqual(1, engine.ReferenceCounter.Count); } } [TestMethod] public void TestArrayNoPush() { using ScriptBuilder sb = new(); sb.Emit(OpCode.RET); using ExecutionEngine engine = new(null, new ReferenceCounter(), ExecutionEngineLimits.Default); engine.LoadScript(sb.ToArray()); Assert.AreEqual(0, engine.ReferenceCounter.Count); Array array = new(engine.ReferenceCounter, new StackItem[] { 1, 2, 3, 4 }); Assert.AreEqual(array.Count, engine.ReferenceCounter.Count); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(array.Count, engine.ReferenceCounter.Count); } [TestMethod] public void TestInvalidReferenceStackItem() { var reference = new ReferenceCounter(); var arr = new Array(reference); var arr2 = new Array(); for (var i = 0; i < 10; i++) { arr2.Add(i); } Assert.ThrowsExactly(() => arr.Add(arr2)); } [TestMethod] public void TestCheckPostExecution() { foreach (var refCounter in new IReferenceCounter[] { new ReferenceCounter(), new ReferenceCounterV2() }) { for (int i = 0; i < ExecutionEngineLimits.Default.MaxStackSize; i++) { refCounter.AddStackReference(StackItem.Null); } refCounter.CheckPostExecution(); refCounter.AddStackReference(StackItem.Null); Assert.ThrowsExactly(() => refCounter.CheckPostExecution()); } } } ================================================ FILE: tests/Neo.VM.Tests/UT_ReferenceCounterComprehensive.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // UT_ReferenceCounterComprehensive.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.VisualStudio.TestTools.UnitTesting; using Neo.VM; using Neo.VM.Types; using Array = Neo.VM.Types.Array; using Buffer = Neo.VM.Types.Buffer; namespace Neo.Test; /// /// Comprehensive unit tests for ReferenceCounter to ensure behavioral consistency /// when switching to a new RC implementation. /// /// Test Categories: /// 1. Basic Stack Reference Operations /// 2. Object Reference Operations (CompoundType relationships) /// 3. Zero-Referred Item Management /// 4. Circular Reference Detection (Tarjan SCC) /// 5. Mixed Reference Scenarios /// 6. Edge Cases and Boundary Conditions /// 7. Type-Specific Tracking (Array, Map, Struct, Buffer) /// 8. Cache Invalidation Scenarios /// [TestClass] public class UT_ReferenceCounterComprehensive { #region 1. Basic Stack Reference Operations [TestMethod] public void TestAddStackReference_SingleItem_CountIncreases() { var rc = new ReferenceCounter(); var array = new Array(rc); Assert.AreEqual(0, rc.Count); rc.AddStackReference(array); Assert.AreEqual(1, rc.Count); } [TestMethod] public void TestAddStackReference_MultipleCount_CountIncreasesCorrectly() { var rc = new ReferenceCounter(); var array = new Array(rc); rc.AddStackReference(array, 5); Assert.AreEqual(5, rc.Count); } [TestMethod] public void TestRemoveStackReference_SingleItem_CountDecreases() { var rc = new ReferenceCounter(); var array = new Array(rc); rc.AddStackReference(array, 3); Assert.AreEqual(3, rc.Count); rc.RemoveStackReference(array); Assert.AreEqual(2, rc.Count); } [TestMethod] public void TestStackReference_NonTrackedType_CountStillChanges() { var rc = new ReferenceCounter(); StackItem intItem = 42; // Integer - not tracked rc.AddStackReference(intItem); Assert.AreEqual(1, rc.Count); rc.RemoveStackReference(intItem); Assert.AreEqual(0, rc.Count); } [TestMethod] public void TestStackReference_Buffer_IsTracked() { var rc = new ReferenceCounter(); var buffer = new Buffer(10); rc.AddStackReference(buffer); Assert.AreEqual(1, rc.Count); rc.AddStackReference(buffer); Assert.AreEqual(2, rc.Count); } #endregion #region 2. Object Reference Operations [TestMethod] public void TestAddReference_ParentChild_CountIncreases() { var rc = new ReferenceCounter(); var parent = new Array(rc); var child = new Array(rc); rc.AddStackReference(parent); Assert.AreEqual(1, rc.Count); rc.AddReference(child, parent); Assert.AreEqual(2, rc.Count); } [TestMethod] public void TestRemoveReference_ParentChild_CountDecreases() { var rc = new ReferenceCounter(); var parent = new Array(rc); var child = new Array(rc); rc.AddStackReference(parent); rc.AddReference(child, parent); Assert.AreEqual(2, rc.Count); rc.RemoveReference(child, parent); Assert.AreEqual(1, rc.Count); } [TestMethod] public void TestAddReference_MultipleParents_TracksCorrectly() { var rc = new ReferenceCounter(); var parent1 = new Array(rc); var parent2 = new Array(rc); var child = new Array(rc); rc.AddStackReference(parent1); rc.AddStackReference(parent2); rc.AddReference(child, parent1); rc.AddReference(child, parent2); Assert.AreEqual(4, rc.Count); } [TestMethod] public void TestAddReference_SameParentMultipleTimes_TracksCorrectly() { var rc = new ReferenceCounter(); var parent = new Array(rc); var child = new Array(rc); rc.AddStackReference(parent); rc.AddReference(child, parent); rc.AddReference(child, parent); rc.AddReference(child, parent); Assert.AreEqual(4, rc.Count); } [TestMethod] public void TestAddReference_NonTrackedChild_CountStillIncreases() { var rc = new ReferenceCounter(); var parent = new Array(rc); StackItem intChild = 42; rc.AddStackReference(parent); rc.AddReference(intChild, parent); Assert.AreEqual(2, rc.Count); } #endregion #region 3. Zero-Referred Item Management [TestMethod] public void TestAddZeroReferred_AddsToTracking() { var rc = new ReferenceCounter(); var array = new Array(rc); // Array constructor calls AddZeroReferred // CheckZeroReferred should clean it up since it has no references int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } [TestMethod] public void TestCheckZeroReferred_WithStackReference_NotCleaned() { var rc = new ReferenceCounter(); var array = new Array(rc); rc.AddStackReference(array); int count = rc.CheckZeroReferred(); Assert.AreEqual(1, count); } [TestMethod] public void TestCheckZeroReferred_NoZeroItems_ReturnsCurrentCount() { var rc = new ReferenceCounter(); var array = new Array(rc); rc.AddStackReference(array); rc.AddStackReference(array); int count = rc.CheckZeroReferred(); Assert.AreEqual(2, count); } [TestMethod] public void TestRemoveStackReference_ToZero_AddsToZeroReferred() { var rc = new ReferenceCounter(); var array = new Array(rc); rc.AddStackReference(array); Assert.AreEqual(1, rc.Count); rc.RemoveStackReference(array); // Item should be in zero-referred list now int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); // Cleaned up } #endregion #region 4. Circular Reference Detection [TestMethod] public void TestCircularReference_SelfReference_CleanedUp() { var rc = new ReferenceCounter(); var array = new Array(rc); rc.AddStackReference(array); array.Add(array); // Self-reference Assert.AreEqual(2, rc.Count); rc.RemoveStackReference(array); int count = rc.CheckZeroReferred(); // Self-referencing array should be cleaned up Assert.AreEqual(0, count); } [TestMethod] public void TestCircularReference_TwoItems_CleanedUp() { var rc = new ReferenceCounter(); var array1 = new Array(rc); var array2 = new Array(rc); rc.AddStackReference(array1); rc.AddStackReference(array2); array1.Add(array2); array2.Add(array1); Assert.AreEqual(4, rc.Count); rc.RemoveStackReference(array1); rc.RemoveStackReference(array2); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } [TestMethod] public void TestCircularReference_ThreeItems_CleanedUp() { var rc = new ReferenceCounter(); var a = new Array(rc); var b = new Array(rc); var c = new Array(rc); rc.AddStackReference(a); a.Add(b); b.Add(c); c.Add(a); // Creates cycle: a -> b -> c -> a rc.RemoveStackReference(a); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } [TestMethod] public void TestCircularReference_PartiallyReachable_NotCleanedUp() { var rc = new ReferenceCounter(); var root = new Array(rc); var a = new Array(rc); var b = new Array(rc); rc.AddStackReference(root); root.Add(a); a.Add(b); b.Add(a); // Cycle between a and b, but reachable from root int count = rc.CheckZeroReferred(); Assert.AreEqual(4, count); // root + a + b + reference from root to a } [TestMethod] public void TestCircularReference_ComplexGraph_CleanedUpCorrectly() { var rc = new ReferenceCounter(); var arrays = new Array[5]; for (int i = 0; i < 5; i++) { arrays[i] = new Array(rc); rc.AddStackReference(arrays[i]); } // Create complex graph: 0->1, 1->2, 2->3, 3->4, 4->0, 2->0 arrays[0].Add(arrays[1]); arrays[1].Add(arrays[2]); arrays[2].Add(arrays[3]); arrays[3].Add(arrays[4]); arrays[4].Add(arrays[0]); arrays[2].Add(arrays[0]); // Remove all stack references for (int i = 0; i < 5; i++) { rc.RemoveStackReference(arrays[i]); } int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } #endregion #region 5. Mixed Reference Scenarios [TestMethod] public void TestMixedReferences_StackAndObject() { var rc = new ReferenceCounter(); var parent = new Array(rc); var child = new Array(rc); rc.AddStackReference(parent); rc.AddStackReference(child); parent.Add(child); Assert.AreEqual(3, rc.Count); rc.RemoveStackReference(child); int count = rc.CheckZeroReferred(); // Child still reachable through parent Assert.AreEqual(2, count); } [TestMethod] public void TestMixedReferences_RemoveParentFirst() { var rc = new ReferenceCounter(); var parent = new Array(rc); var child = new Array(rc); rc.AddStackReference(parent); parent.Add(child); rc.RemoveStackReference(parent); int count = rc.CheckZeroReferred(); // Both should be cleaned up Assert.AreEqual(0, count); } [TestMethod] public void TestMixedReferences_NestedArrays() { var rc = new ReferenceCounter(); var level1 = new Array(rc); var level2 = new Array(rc); var level3 = new Array(rc); rc.AddStackReference(level1); level1.Add(level2); level2.Add(level3); Assert.AreEqual(3, rc.Count); rc.RemoveStackReference(level1); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } #endregion #region 6. Edge Cases and Boundary Conditions [TestMethod] public void TestEmptyReferenceCounter_CountIsZero() { var rc = new ReferenceCounter(); Assert.AreEqual(0, rc.Count); } [TestMethod] public void TestCheckZeroReferred_EmptyCounter_ReturnsZero() { var rc = new ReferenceCounter(); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } [TestMethod] public void TestCheckZeroReferred_CalledMultipleTimes_Idempotent() { var rc = new ReferenceCounter(); var array = new Array(rc); rc.AddStackReference(array); int count1 = rc.CheckZeroReferred(); int count2 = rc.CheckZeroReferred(); int count3 = rc.CheckZeroReferred(); Assert.AreEqual(count1, count2); Assert.AreEqual(count2, count3); } [TestMethod] public void TestLargeNumberOfItems() { var rc = new ReferenceCounter(); var arrays = new Array[100]; for (int i = 0; i < 100; i++) { arrays[i] = new Array(rc); rc.AddStackReference(arrays[i]); } Assert.AreEqual(100, rc.Count); for (int i = 0; i < 100; i++) { rc.RemoveStackReference(arrays[i]); } int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } [TestMethod] public void TestDeepNesting() { var rc = new ReferenceCounter(); var root = new Array(rc); rc.AddStackReference(root); var current = root; for (int i = 0; i < 50; i++) { var next = new Array(rc); current.Add(next); current = next; } Assert.AreEqual(51, rc.Count); // root + 50 nested rc.RemoveStackReference(root); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } #endregion #region 7. Type-Specific Tracking [TestMethod] public void TestArray_TrackedCorrectly() { var rc = new ReferenceCounter(); var array = new Array(rc); rc.AddStackReference(array); Assert.AreEqual(1, rc.Count); array.Add(1); array.Add(2); array.Add(3); Assert.AreEqual(4, rc.Count); } [TestMethod] public void TestMap_TrackedCorrectly() { var rc = new ReferenceCounter(); var map = new Map(rc); rc.AddStackReference(map); Assert.AreEqual(1, rc.Count); map[(ByteString)"key1"] = 1; map[(ByteString)"key2"] = 2; // Map tracks both keys and values Assert.AreEqual(5, rc.Count); // 1 (map) + 2 keys + 2 values } [TestMethod] public void TestStruct_TrackedCorrectly() { var rc = new ReferenceCounter(); var s = new Struct(rc); rc.AddStackReference(s); Assert.AreEqual(1, rc.Count); s.Add(1); s.Add(2); Assert.AreEqual(3, rc.Count); } [TestMethod] public void TestBuffer_TrackedCorrectly() { var rc = new ReferenceCounter(); var buffer = new Buffer(10); rc.AddStackReference(buffer); Assert.AreEqual(1, rc.Count); rc.RemoveStackReference(buffer); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } [TestMethod] public void TestNestedCompoundTypes() { var rc = new ReferenceCounter(); var array = new Array(rc); var map = new Map(rc); var s = new Struct(rc); rc.AddStackReference(array); array.Add(map); map[(ByteString)"struct"] = s; s.Add(42); // array(1) + map(1) + key(1) + struct(1) + int(1) = 5 Assert.AreEqual(5, rc.Count); } [TestMethod] public void TestArray_Clear_RemovesReferences() { var rc = new ReferenceCounter(); var array = new Array(rc); rc.AddStackReference(array); array.Add(1); array.Add(2); array.Add(3); Assert.AreEqual(4, rc.Count); array.Clear(); Assert.AreEqual(1, rc.Count); } [TestMethod] public void TestArray_RemoveAt_RemovesReference() { var rc = new ReferenceCounter(); var array = new Array(rc); rc.AddStackReference(array); array.Add(1); array.Add(2); array.Add(3); Assert.AreEqual(4, rc.Count); array.RemoveAt(1); Assert.AreEqual(3, rc.Count); } [TestMethod] public void TestArray_SetItem_UpdatesReferences() { var rc = new ReferenceCounter(); var array = new Array(rc); rc.AddStackReference(array); array.Add(1); Assert.AreEqual(2, rc.Count); array[0] = 2; // Replace item Assert.AreEqual(2, rc.Count); // Count should remain same } [TestMethod] public void TestMap_RemoveKey_RemovesReferences() { var rc = new ReferenceCounter(); var map = new Map(rc); rc.AddStackReference(map); map[(ByteString)"key"] = 42; Assert.AreEqual(3, rc.Count); // map + key + value map.Remove((ByteString)"key"); Assert.AreEqual(1, rc.Count); // only map } [TestMethod] public void TestMap_Clear_RemovesAllReferences() { var rc = new ReferenceCounter(); var map = new Map(rc); rc.AddStackReference(map); map[(ByteString)"key1"] = 1; map[(ByteString)"key2"] = 2; Assert.AreEqual(5, rc.Count); map.Clear(); Assert.AreEqual(1, rc.Count); } #endregion #region 8. Cache Invalidation Scenarios [TestMethod] public void TestCacheInvalidation_AddReference() { var rc = new ReferenceCounter(); var parent = new Array(rc); var child = new Array(rc); rc.AddStackReference(parent); rc.AddStackReference(child); // First check builds cache rc.CheckZeroReferred(); // Add reference should invalidate cache parent.Add(child); rc.RemoveStackReference(parent); rc.RemoveStackReference(child); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } [TestMethod] public void TestCacheInvalidation_RemoveReference() { var rc = new ReferenceCounter(); var parent = new Array(rc); var child = new Array(rc); rc.AddStackReference(parent); parent.Add(child); rc.CheckZeroReferred(); // Remove child from parent parent.RemoveAt(0); rc.RemoveStackReference(parent); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } #endregion #region 9. VM Integration Tests [TestMethod] public void TestVMIntegration_SimpleScript() { using ScriptBuilder sb = new(); sb.EmitPush(0); sb.Emit(OpCode.NEWARRAY); sb.Emit(OpCode.DROP); sb.Emit(OpCode.RET); using ExecutionEngine engine = new(); engine.LoadScript(sb.ToArray()); Assert.AreEqual(VMState.HALT, engine.Execute()); Assert.AreEqual(0, engine.ReferenceCounter.Count); } [TestMethod] public void TestVMIntegration_ArrayWithItems() { using ScriptBuilder sb = new(); sb.EmitPush(3); sb.Emit(OpCode.NEWARRAY); using ExecutionEngine engine = new(); engine.LoadScript(sb.ToArray()); Assert.AreEqual(VMState.HALT, engine.Execute()); // Array + 3 null items on stack Assert.AreEqual(4, engine.ReferenceCounter.Count); } [TestMethod] public void TestVMIntegration_NestedArrays() { using ScriptBuilder sb = new(); sb.EmitPush(1); sb.Emit(OpCode.NEWARRAY); // Create outer array sb.Emit(OpCode.DUP); sb.EmitPush(0); sb.EmitPush(0); sb.Emit(OpCode.NEWARRAY); // Create inner array sb.Emit(OpCode.SETITEM); // outer[0] = inner using ExecutionEngine engine = new(); engine.LoadScript(sb.ToArray()); Assert.AreEqual(VMState.HALT, engine.Execute()); // Outer array + inner array Assert.AreEqual(2, engine.ReferenceCounter.Count); } [TestMethod] public void TestVMIntegration_MapOperations() { using ScriptBuilder sb = new(); sb.Emit(OpCode.NEWMAP); sb.Emit(OpCode.DUP); sb.EmitPush("key"); sb.EmitPush(42); sb.Emit(OpCode.SETITEM); using ExecutionEngine engine = new(); engine.LoadScript(sb.ToArray()); Assert.AreEqual(VMState.HALT, engine.Execute()); // Map + key + value Assert.AreEqual(3, engine.ReferenceCounter.Count); } [TestMethod] public void TestVMIntegration_StructClone() { using ScriptBuilder sb = new(); sb.EmitPush(2); sb.Emit(OpCode.NEWSTRUCT); sb.Emit(OpCode.DUP); sb.EmitPush(0); sb.EmitPush(100); sb.Emit(OpCode.SETITEM); sb.Emit(OpCode.DUP); sb.EmitPush(1); sb.EmitPush(200); sb.Emit(OpCode.SETITEM); using ExecutionEngine engine = new(); engine.LoadScript(sb.ToArray()); Assert.AreEqual(VMState.HALT, engine.Execute()); // Struct + 2 values Assert.AreEqual(3, engine.ReferenceCounter.Count); } #endregion #region 10. Slot Integration Tests [TestMethod] public void TestSlot_InitializesWithNullReferences() { using ScriptBuilder sb = new(); sb.Emit(OpCode.INITSLOT, new byte[] { 3, 0 }); // 3 local variables using ExecutionEngine engine = new(); engine.LoadScript(sb.ToArray()); Assert.AreEqual(VMState.HALT, engine.Execute()); // Null is not tracked (not CompoundType or Buffer), so count is 0 // This verifies that non-tracked types don't affect the reference count Assert.AreEqual(0, engine.ReferenceCounter.Count); } [TestMethod] public void TestSlot_SetAndGet() { using ScriptBuilder sb = new(); sb.Emit(OpCode.INITSLOT, new byte[] { 1, 0 }); sb.EmitPush(0); sb.Emit(OpCode.NEWARRAY); sb.Emit(OpCode.STLOC0); sb.Emit(OpCode.LDLOC0); using ExecutionEngine engine = new(); engine.LoadScript(sb.ToArray()); Assert.AreEqual(VMState.HALT, engine.Execute()); // Array in slot (1 ref) + array on stack (1 ref) = 2 stack refs for same array // But the array itself is only counted once per stack reference // After execution: array is on stack (1 ref from stack) Assert.AreEqual(1, engine.ReferenceCounter.Count); } [TestMethod] public void TestStaticSlot_PersistsAcrossContexts() { using ScriptBuilder sb = new(); sb.Emit(OpCode.INITSSLOT, new byte[] { 1 }); sb.EmitPush(0); sb.Emit(OpCode.NEWARRAY); sb.Emit(OpCode.STSFLD0); sb.Emit(OpCode.LDSFLD0); using ExecutionEngine engine = new(); engine.LoadScript(sb.ToArray()); Assert.AreEqual(VMState.HALT, engine.Execute()); // Array on stack (1 ref) - static slot is cleared after execution Assert.AreEqual(1, engine.ReferenceCounter.Count); } #endregion #region 11. Stress Tests [TestMethod] public void TestStress_ManySmallArrays() { var rc = new ReferenceCounter(); var arrays = new Array[1000]; for (int i = 0; i < 1000; i++) { arrays[i] = new Array(rc); rc.AddStackReference(arrays[i]); } Assert.AreEqual(1000, rc.Count); for (int i = 0; i < 1000; i++) { rc.RemoveStackReference(arrays[i]); } int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } [TestMethod] public void TestStress_ComplexInterconnectedGraph() { var rc = new ReferenceCounter(); var arrays = new Array[20]; for (int i = 0; i < 20; i++) { arrays[i] = new Array(rc); rc.AddStackReference(arrays[i]); } // Create complex interconnections for (int i = 0; i < 20; i++) { arrays[i].Add(arrays[(i + 1) % 20]); arrays[i].Add(arrays[(i + 5) % 20]); } // Remove all stack references for (int i = 0; i < 20; i++) { rc.RemoveStackReference(arrays[i]); } int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } [TestMethod] public void TestStress_RepeatedCheckZeroReferred() { var rc = new ReferenceCounter(); var array = new Array(rc); rc.AddStackReference(array); for (int i = 0; i < 100; i++) { int count = rc.CheckZeroReferred(); Assert.AreEqual(1, count); } } #endregion #region 12. Behavioral Consistency Tests [TestMethod] public void TestBehavior_AddRemoveSymmetry() { var rc = new ReferenceCounter(); var array = new Array(rc); for (int i = 0; i < 10; i++) { rc.AddStackReference(array); } Assert.AreEqual(10, rc.Count); for (int i = 0; i < 10; i++) { rc.RemoveStackReference(array); } int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } [TestMethod] public void TestBehavior_ObjectReferenceSymmetry() { var rc = new ReferenceCounter(); var parent = new Array(rc); var child = new Array(rc); rc.AddStackReference(parent); for (int i = 0; i < 5; i++) { rc.AddReference(child, parent); } Assert.AreEqual(6, rc.Count); for (int i = 0; i < 5; i++) { rc.RemoveReference(child, parent); } rc.RemoveStackReference(parent); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } [TestMethod] public void TestBehavior_CountNeverNegative() { var rc = new ReferenceCounter(); // Even with no items, count should be 0 Assert.AreEqual(0, rc.Count); var array = new Array(rc); rc.AddStackReference(array); rc.RemoveStackReference(array); // After cleanup rc.CheckZeroReferred(); Assert.IsGreaterThanOrEqualTo(0, rc.Count); } [TestMethod] public void TestBehavior_DeterministicCleanup() { // Run the same scenario multiple times to ensure deterministic behavior for (int run = 0; run < 10; run++) { var rc = new ReferenceCounter(); var a = new Array(rc); var b = new Array(rc); var c = new Array(rc); rc.AddStackReference(a); a.Add(b); b.Add(c); c.Add(a); rc.RemoveStackReference(a); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count, $"Run {run} failed"); } } #endregion #region 13. Additional Code Path Coverage Tests /// /// Tests AddStackReference when item already exists in _trackedItems /// and _cachedComponents is not null (line 100-101) /// [TestMethod] public void TestAddStackReference_ExistingItem_CachedComponentsNotNull() { var rc = new ReferenceCounter(); var array = new Array(rc); rc.AddStackReference(array); // First CheckZeroReferred builds _cachedComponents rc.CheckZeroReferred(); // Add another stack reference to existing item - should not add to cached components again rc.AddStackReference(array); Assert.AreEqual(2, rc.Count); // Verify cleanup still works correctly rc.RemoveStackReference(array); rc.RemoveStackReference(array); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } /// /// Tests AddStackReference removing item from _zeroReferred (line 107) /// [TestMethod] public void TestAddStackReference_RemovesFromZeroReferred() { var rc = new ReferenceCounter(); var array = new Array(rc); // Array is in _zeroReferred after construction // Adding stack reference should remove it from _zeroReferred rc.AddStackReference(array); // Remove and check - should be added back to _zeroReferred rc.RemoveStackReference(array); // Add again - should remove from _zeroReferred again rc.AddStackReference(array); // Now cleanup should not remove the array int count = rc.CheckZeroReferred(); Assert.AreEqual(1, count); } /// /// Tests AddZeroReferred with non-tracked type (line 117) /// [TestMethod] public void TestAddZeroReferred_NonTrackedType() { var rc = new ReferenceCounter(); StackItem intItem = 42; // Directly call AddZeroReferred on non-tracked type rc.AddZeroReferred(intItem); // Should not affect count since it's not tracked int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } /// /// Tests AddZeroReferred when _cachedComponents exists (line 120) /// [TestMethod] public void TestAddZeroReferred_WithCachedComponents() { var rc = new ReferenceCounter(); var array1 = new Array(rc); rc.AddStackReference(array1); // Build cached components rc.CheckZeroReferred(); // Create new array - AddZeroReferred is called in constructor // This should add to _cachedComponents var array2 = new Array(rc); rc.AddStackReference(array2); // Both should be tracked Assert.AreEqual(2, rc.Count); rc.RemoveStackReference(array1); rc.RemoveStackReference(array2); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } /// /// Tests RemoveReference with non-tracked type (line 223) /// [TestMethod] public void TestRemoveReference_NonTrackedType() { var rc = new ReferenceCounter(); var parent = new Array(rc); StackItem intChild = 42; rc.AddStackReference(parent); rc.AddReference(intChild, parent); Assert.AreEqual(2, rc.Count); // Remove reference to non-tracked type rc.RemoveReference(intChild, parent); Assert.AreEqual(1, rc.Count); } /// /// Tests RemoveReference when item still has stack references (line 232-233) /// Item should NOT be added to _zeroReferred /// [TestMethod] public void TestRemoveReference_ItemStillHasStackReferences() { var rc = new ReferenceCounter(); var parent = new Array(rc); var child = new Array(rc); rc.AddStackReference(parent); rc.AddStackReference(child); // Child has stack reference rc.AddReference(child, parent); Assert.AreEqual(3, rc.Count); // Remove object reference - child still has stack reference rc.RemoveReference(child, parent); Assert.AreEqual(2, rc.Count); // Child should NOT be in _zeroReferred, so CheckZeroReferred should not clean it int count = rc.CheckZeroReferred(); Assert.AreEqual(2, count); // Both parent and child still exist } /// /// Tests RemoveStackReference when item still has references (line 246-247) /// Item should NOT be added to _zeroReferred /// [TestMethod] public void TestRemoveStackReference_ItemStillHasStackReferences() { var rc = new ReferenceCounter(); var array = new Array(rc); rc.AddStackReference(array, 3); // Add 3 stack references Assert.AreEqual(3, rc.Count); rc.RemoveStackReference(array); // Remove 1, still has 2 Assert.AreEqual(2, rc.Count); // Array should NOT be in _zeroReferred int count = rc.CheckZeroReferred(); Assert.AreEqual(2, count); // Array still exists with 2 refs } /// /// Tests CheckZeroReferred reusing existing _cachedComponents (line 142) /// [TestMethod] public void TestCheckZeroReferred_ReusesCachedComponents() { var rc = new ReferenceCounter(); var array = new Array(rc); rc.AddStackReference(array); // First call builds _cachedComponents rc.CheckZeroReferred(); // Add to _zeroReferred without invalidating cache // (RemoveStackReference to 0 adds to _zeroReferred but doesn't invalidate cache) rc.RemoveStackReference(array); // Second call should reuse _cachedComponents int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } /// /// Tests CheckZeroReferred with CompoundType containing non-tracked subitems (line 193) /// [TestMethod] public void TestCheckZeroReferred_CompoundTypeWithNonTrackedSubitems() { var rc = new ReferenceCounter(); var array = new Array(rc); rc.AddStackReference(array); array.Add(1); // Integer - not tracked array.Add(2); // Integer - not tracked array.Add(3); // Integer - not tracked Assert.AreEqual(4, rc.Count); rc.RemoveStackReference(array); int count = rc.CheckZeroReferred(); // All should be cleaned up, including non-tracked subitems Assert.AreEqual(0, count); } /// /// Tests Buffer cleanup (item.Cleanup() call at line 201) /// [TestMethod] public void TestCheckZeroReferred_BufferCleanup() { var rc = new ReferenceCounter(); var buffer = new Buffer(100); rc.AddStackReference(buffer); Assert.AreEqual(1, rc.Count); rc.RemoveStackReference(buffer); int count = rc.CheckZeroReferred(); // Buffer should be cleaned up (returned to ArrayPool) Assert.AreEqual(0, count); } /// /// Tests that subitems in same component are skipped during cleanup (line 192) /// [TestMethod] public void TestCheckZeroReferred_SubitemsInSameComponent() { var rc = new ReferenceCounter(); var a = new Array(rc); var b = new Array(rc); rc.AddStackReference(a); // Create mutual references - they will be in same SCC a.Add(b); b.Add(a); Assert.AreEqual(3, rc.Count); rc.RemoveStackReference(a); int count = rc.CheckZeroReferred(); // Both should be cleaned up together Assert.AreEqual(0, count); } /// /// Tests OnStack propagation through parent references (line 163) /// [TestMethod] public void TestCheckZeroReferred_OnStackPropagation() { var rc = new ReferenceCounter(); var root = new Array(rc); var child1 = new Array(rc); var child2 = new Array(rc); rc.AddStackReference(root); root.Add(child1); child1.Add(child2); child2.Add(child1); // Cycle between child1 and child2 // root -> child1 <-> child2 // child1 and child2 form a cycle, but are reachable from root int count = rc.CheckZeroReferred(); // All should remain because they're reachable from root Assert.AreEqual(4, count); } /// /// Tests multiple SCCs with different reachability /// [TestMethod] public void TestCheckZeroReferred_MultipleSCCs() { var rc = new ReferenceCounter(); // SCC 1: reachable from stack var root = new Array(rc); var a = new Array(rc); rc.AddStackReference(root); root.Add(a); a.Add(root); // Cycle // SCC 2: not reachable var b = new Array(rc); var c = new Array(rc); rc.AddStackReference(b); rc.AddStackReference(c); b.Add(c); c.Add(b); // Cycle // Remove stack refs from SCC 2 rc.RemoveStackReference(b); rc.RemoveStackReference(c); int count = rc.CheckZeroReferred(); // SCC 1 should remain: root(1 stack ref) + a(1 obj ref from root) + root(1 obj ref from a) = 3 // SCC 2 should be cleaned (0) Assert.AreEqual(3, count); } /// /// Tests Map with CompoundType values that need cleanup /// [TestMethod] public void TestCheckZeroReferred_MapWithCompoundValues() { var rc = new ReferenceCounter(); var map = new Map(rc); var innerArray = new Array(rc); rc.AddStackReference(map); map[(ByteString)"arr"] = innerArray; innerArray.Add(42); // map(1) + key(1) + innerArray(1) + int(1) = 4 Assert.AreEqual(4, rc.Count); rc.RemoveStackReference(map); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } /// /// Tests Struct with nested Struct /// [TestMethod] public void TestCheckZeroReferred_NestedStructs() { var rc = new ReferenceCounter(); var outer = new Struct(rc); var inner = new Struct(rc); rc.AddStackReference(outer); outer.Add(inner); inner.Add(100); inner.Add(200); // outer(1) + inner(1) + 100(1) + 200(1) = 4 Assert.AreEqual(4, rc.Count); rc.RemoveStackReference(outer); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } /// /// Tests that ObjectReferences dictionary is properly initialized /// [TestMethod] public void TestAddReference_InitializesObjectReferences() { var rc = new ReferenceCounter(); var parent = new Array(rc); var child = new Array(rc); rc.AddStackReference(parent); // First AddReference should initialize ObjectReferences rc.AddReference(child, parent); // Second AddReference to same parent should reuse existing entry rc.AddReference(child, parent); Assert.AreEqual(3, rc.Count); // Cleanup rc.RemoveReference(child, parent); rc.RemoveReference(child, parent); rc.RemoveStackReference(parent); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } /// /// Tests interleaved operations - verifies complex sequences work correctly /// [TestMethod] public void TestInterleavedOperations() { var rc = new ReferenceCounter(); // Create arrays with proper lifecycle management var a = new Array(rc); var b = new Array(rc); var c = new Array(rc); // Add stack references rc.AddStackReference(a); rc.AddStackReference(b); // a contains c a.Add(c); // Verify state Assert.AreEqual(3, rc.Count); // a(1) + b(1) + c(1) // Check doesn't change anything since all are reachable rc.CheckZeroReferred(); Assert.AreEqual(3, rc.Count); // Remove a's stack reference - but c is still referenced by a rc.RemoveStackReference(a); // a and c should be cleaned up since a has no stack ref int count = rc.CheckZeroReferred(); Assert.AreEqual(1, count); // Only b remains // Final cleanup rc.RemoveStackReference(b); count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } /// /// Tests that Reset() is called on all tracked items /// [TestMethod] public void TestCheckZeroReferred_ResetsAllItems() { var rc = new ReferenceCounter(); var a = new Array(rc); var b = new Array(rc); var c = new Array(rc); rc.AddStackReference(a); rc.AddStackReference(b); a.Add(c); // First check rc.CheckZeroReferred(); // Modify graph b.Add(c); // Second check - all items should be reset rc.CheckZeroReferred(); // Cleanup rc.RemoveStackReference(a); rc.RemoveStackReference(b); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } /// /// Removes a child referenced by multiple parents; cleanup should only happen after the last referrer is removed. /// [TestMethod] public void TestRemoveReference_LastParentTriggersCleanup() { var rc = new ReferenceCounter(); var parent1 = new Array(rc); var parent2 = new Array(rc); var child = new Array(rc); rc.AddStackReference(parent1); rc.AddStackReference(parent2); parent1.Add(child); parent2.Add(child); Assert.AreEqual(4, rc.Count); parent1.RemoveAt(0); parent2.RemoveAt(0); rc.RemoveStackReference(parent1); rc.RemoveStackReference(parent2); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } /// /// Multiple references from the same parent should keep the child alive until all references are removed. /// [TestMethod] public void TestMultipleReferencesFromSameParentRequireAllRemovals() { var rc = new ReferenceCounter(); var parent = new Array(rc); var child = new Array(rc); rc.AddStackReference(parent); parent.Add(child); parent.Add(child); Assert.AreEqual(3, rc.Count); parent.RemoveAt(0); Assert.AreEqual(2, rc.Count); // One reference remains from parent to child, so cleanup should not remove it yet. rc.CheckZeroReferred(); Assert.AreEqual(2, rc.Count); parent.RemoveAt(0); rc.RemoveStackReference(parent); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } /// /// Buffers tracked as map values should be cleaned with their parent container. /// [TestMethod] public void TestBufferUsedAsMapValueCleanup() { var rc = new ReferenceCounter(); var map = new Map(rc); var key = (ByteString)"key"; var value = new Buffer(8); rc.AddStackReference(map); map[key] = value; Assert.AreEqual(3, rc.Count); map.Remove(key); rc.RemoveStackReference(map); int count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } /// /// Slot indexer should replace references atomically, decrementing the old item and incrementing the new one. /// [TestMethod] public void TestSlotUpdateReplacesReferences() { var rc = new ReferenceCounter(); var slot = new Slot(1, rc); var first = new Array(rc); var second = new Array(rc); // Constructor adds a stack reference for Null Assert.AreEqual(1, rc.Count); slot[0] = first; Assert.AreEqual(1, rc.Count); slot[0] = second; Assert.AreEqual(1, rc.Count); int count = rc.CheckZeroReferred(); Assert.AreEqual(1, count); rc.RemoveStackReference(second); count = rc.CheckZeroReferred(); Assert.AreEqual(0, count); } #endregion } ================================================ FILE: tests/Neo.VM.Tests/UT_Script.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // UT_Script.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.VisualStudio.TestTools.UnitTesting; using Neo.VM; using System; using System.Text; namespace Neo.Test; [TestClass] public class UT_Script { [TestMethod] public void TestConversion() { byte[] rawScript; using (var builder = new ScriptBuilder()) { builder.Emit(OpCode.PUSH0); builder.Emit(OpCode.CALL, new byte[] { 0x00, 0x01 }); builder.EmitSysCall(123); rawScript = builder.ToArray(); } var script = new Script(rawScript); ReadOnlyMemory scriptConversion = script; Assert.AreEqual(rawScript, scriptConversion); } [TestMethod] public void TestStrictMode() { var rawScript = new byte[] { (byte)OpCode.PUSH0, 0xFF }; Assert.ThrowsExactly(() => _ = new Script(rawScript, true)); var script = new Script(rawScript, false); Assert.AreEqual(2, script.Length); rawScript = new byte[] { (byte)OpCode.PUSHDATA1 }; Assert.ThrowsExactly(() => _ = new Script(rawScript, true)); rawScript = new byte[] { (byte)OpCode.PUSHDATA2 }; Assert.ThrowsExactly(() => _ = new Script(rawScript, true)); rawScript = new byte[] { (byte)OpCode.PUSHDATA4 }; Assert.ThrowsExactly(() => _ = new Script(rawScript, true)); } [TestMethod] public void TestParse() { Script script; using (var builder = new ScriptBuilder()) { builder.Emit(OpCode.PUSH0); builder.Emit(OpCode.CALL_L, new byte[] { 0x00, 0x01, 0x00, 0x00 }); builder.EmitSysCall(123); script = new Script(builder.ToArray()); } Assert.AreEqual(11, script.Length); var ins = script.GetInstruction(0); Assert.AreEqual(OpCode.PUSH0, ins.OpCode); Assert.IsTrue(ins.Operand.IsEmpty); Assert.AreEqual(1, ins.Size); Assert.ThrowsExactly(() => { var x = ins.TokenI16; }); Assert.ThrowsExactly(() => { var x = ins.TokenU32; }); ins = script.GetInstruction(1); Assert.AreEqual(OpCode.CALL_L, ins.OpCode); CollectionAssert.AreEqual(new byte[] { 0x00, 0x01, 0x00, 0x00 }, ins.Operand.ToArray()); Assert.AreEqual(5, ins.Size); Assert.AreEqual(256, ins.TokenI32); Assert.AreEqual(Encoding.ASCII.GetString(new byte[] { 0x00, 0x01, 0x00, 0x00 }), ins.TokenString); ins = script.GetInstruction(6); Assert.AreEqual(OpCode.SYSCALL, ins.OpCode); CollectionAssert.AreEqual(new byte[] { 123, 0x00, 0x00, 0x00 }, ins.Operand.ToArray()); Assert.AreEqual(5, ins.Size); Assert.AreEqual(123, ins.TokenI16); Assert.AreEqual(Encoding.ASCII.GetString(new byte[] { 123, 0x00, 0x00, 0x00 }), ins.TokenString); Assert.AreEqual(123U, ins.TokenU32); Assert.ThrowsExactly(() => _ = script.GetInstruction(100)); } } ================================================ FILE: tests/Neo.VM.Tests/UT_ScriptBuilder.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // UT_ScriptBuilder.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.VisualStudio.TestTools.UnitTesting; using Neo.Test.Extensions; using Neo.Test.Helpers; using Neo.VM; using System; using System.Linq; using System.Numerics; using System.Text; namespace Neo.Test; [TestClass] public class UT_ScriptBuilder { [TestMethod] public void TestEmit() { using (ScriptBuilder script = new()) { Assert.AreEqual(0, script.Length); script.Emit(OpCode.NOP); Assert.AreEqual(1, script.Length); CollectionAssert.AreEqual(new byte[] { 0x21 }, script.ToArray()); } using (ScriptBuilder script = new()) { script.Emit(OpCode.NOP, new byte[] { 0x66 }); CollectionAssert.AreEqual(new byte[] { 0x21, 0x66 }, script.ToArray()); } } [TestMethod] public void TestNullAndEmpty() { using ScriptBuilder script = new(); ReadOnlySpan span = null; script.EmitPush(span); span = []; script.EmitPush(span); CollectionAssert.AreEqual(new byte[] { (byte)OpCode.PUSHDATA1, 0, (byte)OpCode.PUSHDATA1, 0 }, script.ToArray()); } [TestMethod] public void TestBigInteger() { using (ScriptBuilder script = new()) { Assert.AreEqual(0, script.Length); script.EmitPush(-100000); Assert.AreEqual(5, script.Length); CollectionAssert.AreEqual(new byte[] { 2, 96, 121, 254, 255 }, script.ToArray()); } using (ScriptBuilder script = new()) { Assert.AreEqual(0, script.Length); script.EmitPush(100000); Assert.AreEqual(5, script.Length); CollectionAssert.AreEqual(new byte[] { 2, 160, 134, 1, 0 }, script.ToArray()); } } [TestMethod] public void TestEmitSysCall() { using ScriptBuilder script = new(); script.EmitSysCall(0xE393C875); CollectionAssert.AreEqual(new byte[] { (byte)OpCode.SYSCALL, 0x75, 0xC8, 0x93, 0xE3 }.ToArray(), script.ToArray()); } [TestMethod] public void TestEmitCall() { using (ScriptBuilder script = new()) { script.EmitCall(0); CollectionAssert.AreEqual(new[] { (byte)OpCode.CALL, (byte)0 }, script.ToArray()); } using (ScriptBuilder script = new()) { script.EmitCall(12345); CollectionAssert.AreEqual(new[] { (byte)OpCode.CALL_L }.Concat(BitConverter.GetBytes(12345)).ToArray(), script.ToArray()); } using (ScriptBuilder script = new()) { script.EmitCall(-12345); CollectionAssert.AreEqual(new[] { (byte)OpCode.CALL_L }.Concat(BitConverter.GetBytes(-12345)).ToArray(), script.ToArray()); } } [TestMethod] public void TestEmitJump() { var offset_i8 = sbyte.MaxValue; var offset_i32 = int.MaxValue; foreach (OpCode op in Enum.GetValues()) { using ScriptBuilder script = new(); if (op < OpCode.JMP || op > OpCode.JMPLE_L) { Assert.ThrowsExactly(() => _ = script.EmitJump(op, offset_i8)); Assert.ThrowsExactly(() => _ = script.EmitJump(op, offset_i32)); } else { script.EmitJump(op, offset_i8); script.EmitJump(op, offset_i32); if ((int)op % 2 == 0) CollectionAssert.AreEqual(new[] { (byte)op, (byte)offset_i8, (byte)(op + 1) }.Concat(BitConverter.GetBytes(offset_i32)).ToArray(), script.ToArray()); else CollectionAssert.AreEqual(new[] { (byte)op }.Concat(BitConverter.GetBytes((int)offset_i8)).Concat(new[] { (byte)op }).Concat(BitConverter.GetBytes(offset_i32)).ToArray(), script.ToArray()); } } offset_i8 = sbyte.MinValue; offset_i32 = int.MinValue; foreach (OpCode op in Enum.GetValues()) { using ScriptBuilder script = new(); if (op < OpCode.JMP || op > OpCode.JMPLE_L) { Assert.ThrowsExactly(() => _ = script.EmitJump(op, offset_i8)); Assert.ThrowsExactly(() => _ = script.EmitJump(op, offset_i32)); } else { script.EmitJump(op, offset_i8); script.EmitJump(op, offset_i32); if ((int)op % 2 == 0) CollectionAssert.AreEqual(new[] { (byte)op, (byte)offset_i8, (byte)(op + 1) }.Concat(BitConverter.GetBytes(offset_i32)).ToArray(), script.ToArray()); else CollectionAssert.AreEqual(new[] { (byte)op }.Concat(BitConverter.GetBytes((int)offset_i8)).Concat(new[] { (byte)op }).Concat(BitConverter.GetBytes(offset_i32)).ToArray(), script.ToArray()); } } } [TestMethod] public void TestEmitPushBigInteger() { // Test small integers (-1 to 16) for (var i = -1; i <= 16; i++) { using ScriptBuilder script = new(); script.EmitPush(new BigInteger(i)); CollectionAssert.AreEqual(new[] { (byte)(OpCode.PUSH0 + (byte)i) }, script.ToArray()); } // Test -1 Assert.AreEqual("0x0f", new ScriptBuilder().EmitPush(BigInteger.MinusOne).ToArray().ToHexString()); // Test edge cases for different sizes // PUSHINT8 Assert.AreEqual("0x0080", new ScriptBuilder().EmitPush(sbyte.MinValue).ToArray().ToHexString()); Assert.AreEqual("0x007f", new ScriptBuilder().EmitPush(sbyte.MaxValue).ToArray().ToHexString()); // PUSHINT16 Assert.AreEqual("0x010080", new ScriptBuilder().EmitPush(short.MinValue).ToArray().ToHexString()); Assert.AreEqual("0x01ff7f", new ScriptBuilder().EmitPush(short.MaxValue).ToArray().ToHexString()); // PUSHINT32 Assert.AreEqual("0x0200000080", new ScriptBuilder().EmitPush(int.MinValue).ToArray().ToHexString()); Assert.AreEqual("0x02ffffff7f", new ScriptBuilder().EmitPush(int.MaxValue).ToArray().ToHexString()); // PUSHINT64 Assert.AreEqual("0x030000000000000080", new ScriptBuilder().EmitPush(long.MinValue).ToArray().ToHexString()); Assert.AreEqual("0x03ffffffffffffff7f", new ScriptBuilder().EmitPush(long.MaxValue).ToArray().ToHexString()); // PUSHINT128 Assert.AreEqual("0x04ffffffffffffffff0000000000000000", new ScriptBuilder().EmitPush(new BigInteger(ulong.MaxValue)).ToArray().ToHexString()); Assert.AreEqual("0x0400000000000000000100000000000000", new ScriptBuilder().EmitPush(new BigInteger(ulong.MaxValue) + 1).ToArray().ToHexString()); // PUSHINT256, case from https://en.wikipedia.org/wiki/256-bit_computing#:~:text=The%20range%20of%20a%20signed,%2C%E2%80%8B819%2C%E2%80%8B967. Assert.AreEqual("0x050000000000000000000000000000000000000000000000000000000000000080", new ScriptBuilder().EmitPush(BigInteger.Parse("-57896044618658097711785492504343953926634992332820282019728792003956564819968")).ToArray().ToHexString()); Assert.AreEqual("0x05ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f", new ScriptBuilder().EmitPush(BigInteger.Parse("57896044618658097711785492504343953926634992332820282019728792003956564819967")).ToArray().ToHexString()); // Test exceeding 256-bit value (2^256) Assert.ThrowsExactly(() => _ = new ScriptBuilder().EmitPush(BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639936"))); // Test negative numbers Assert.AreEqual("0x00fe", new ScriptBuilder().EmitPush(new BigInteger(-2)).ToArray().ToHexString()); Assert.AreEqual("0x0100ff", new ScriptBuilder().EmitPush(new BigInteger(-256)).ToArray().ToHexString()); // Test numbers that are exactly at the boundary Assert.AreEqual("0x04ffffffffffffffff0000000000000000", new ScriptBuilder().EmitPush(BigInteger.Parse("18446744073709551615")).ToArray().ToHexString()); Assert.AreEqual("0x0400000000000000000100000000000000", new ScriptBuilder().EmitPush(BigInteger.Parse("18446744073709551616")).ToArray().ToHexString()); // Test very large negative number Assert.AreEqual("0x040000000000000000ffffffffffffffff", new ScriptBuilder().EmitPush(BigInteger.Parse("-18446744073709551616")).ToArray().ToHexString()); // Test exception for too large BigInteger Assert.ThrowsExactly(() => _ = new ScriptBuilder().EmitPush( BigInteger.Parse("115792089237316195423570985008687907853269984665640564039457584007913129639937"))); } [TestMethod] public void TestEmitPushBool() { using (ScriptBuilder script = new()) { script.EmitPush(true); CollectionAssert.AreEqual(new byte[] { (byte)OpCode.PUSHT }, script.ToArray()); } using (ScriptBuilder script = new()) { script.EmitPush(false); CollectionAssert.AreEqual(new byte[] { (byte)OpCode.PUSHF }, script.ToArray()); } } [TestMethod] public void TestEmitPushReadOnlySpan() { using ScriptBuilder script = new(); var data = new byte[] { 0x01, 0x02 }; script.EmitPush(new ReadOnlySpan(data)); CollectionAssert.AreEqual(new byte[] { (byte)OpCode.PUSHDATA1, (byte)data.Length }.Concat(data).ToArray(), script.ToArray()); } [TestMethod] public void TestEmitPushByteArray() { using (ScriptBuilder script = new()) { script.EmitPush((byte[])null); CollectionAssert.AreEqual(new byte[] { (byte)OpCode.PUSHDATA1, 0 }, script.ToArray()); } using (ScriptBuilder script = new()) { var data = RandomHelper.RandBuffer(0x4C); script.EmitPush(data); CollectionAssert.AreEqual(new byte[] { (byte)OpCode.PUSHDATA1, (byte)data.Length }.Concat(data).ToArray(), script.ToArray()); } using (ScriptBuilder script = new()) { var data = RandomHelper.RandBuffer(0x100); script.EmitPush(data); CollectionAssert.AreEqual(new byte[] { (byte)OpCode.PUSHDATA2 }.Concat(BitConverter.GetBytes((short)data.Length)).Concat(data).ToArray(), script.ToArray()); } using (ScriptBuilder script = new()) { var data = RandomHelper.RandBuffer(0x10000); script.EmitPush(data); CollectionAssert.AreEqual(new byte[] { (byte)OpCode.PUSHDATA4 }.Concat(BitConverter.GetBytes(data.Length)).Concat(data).ToArray(), script.ToArray()); } } [TestMethod] public void TestEmitPushString() { using (ScriptBuilder script = new()) { Assert.ThrowsExactly(() => _ = script.EmitPush((string)null)); } using (ScriptBuilder script = new()) { var data = RandomHelper.RandString(0x4C); script.EmitPush(data); CollectionAssert.AreEqual(new byte[] { (byte)OpCode.PUSHDATA1, (byte)data.Length }.Concat(Encoding.UTF8.GetBytes(data)).ToArray(), script.ToArray()); } using (ScriptBuilder script = new()) { var data = RandomHelper.RandString(0x100); script.EmitPush(data); CollectionAssert.AreEqual(new byte[] { (byte)OpCode.PUSHDATA2 }.Concat(BitConverter.GetBytes((short)data.Length)).Concat(Encoding.UTF8.GetBytes(data)).ToArray(), script.ToArray()); } using (ScriptBuilder script = new()) { var data = RandomHelper.RandString(0x10000); script.EmitPush(data); CollectionAssert.AreEqual(new byte[] { (byte)OpCode.PUSHDATA4 }.Concat(BitConverter.GetBytes(data.Length)).Concat(Encoding.UTF8.GetBytes(data)).ToArray(), script.ToArray()); } } } ================================================ FILE: tests/Neo.VM.Tests/UT_Slot.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // UT_Slot.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.VisualStudio.TestTools.UnitTesting; using Neo.VM; using Neo.VM.Types; using System; using System.Collections; using System.Linq; using System.Numerics; using Array = System.Array; namespace Neo.Test; [TestClass] public class UT_Slot { private static Slot CreateOrderedSlot(int count) { var check = new Integer[count]; for (int x = 1; x <= count; x++) { check[x - 1] = x; } var slot = new Slot(check, new ReferenceCounter()); Assert.AreEqual(count, slot.Count); CollectionAssert.AreEqual(check, slot.ToArray()); return slot; } public static IEnumerable GetEnumerable(IEnumerator enumerator) { while (enumerator.MoveNext()) yield return enumerator.Current; } [TestMethod] public void TestGet() { var slot = CreateOrderedSlot(3); Assert.IsTrue(slot[0] is Integer item0 && item0.Equals(1)); Assert.IsTrue(slot[1] is Integer item1 && item1.Equals(2)); Assert.IsTrue(slot[2] is Integer item2 && item2.Equals(3)); Assert.ThrowsExactly(() => _ = slot[3] is Integer item3); } [TestMethod] public void TestEnumerable() { var slot = CreateOrderedSlot(3); BigInteger i = 1; foreach (var item in slot) { Assert.AreEqual(item.GetInteger(), i); i++; } CollectionAssert.AreEqual(new Integer[] { 1, 2, 3 }, slot.ToArray()); // Test IEnumerable var enumerable = (IEnumerable)slot; var enumerator = enumerable.GetEnumerator(); CollectionAssert.AreEqual(new Integer[] { 1, 2, 3 }, GetEnumerable(enumerator).Cast().ToArray()); Assert.AreEqual(3, slot.Count); CollectionAssert.AreEqual(new Integer[] { 1, 2, 3 }, slot.ToArray()); // Empty slot = CreateOrderedSlot(0); CollectionAssert.AreEqual(Array.Empty(), slot.ToArray()); // Test IEnumerable enumerable = slot; enumerator = enumerable.GetEnumerator(); CollectionAssert.AreEqual(Array.Empty(), GetEnumerable(enumerator).Cast().ToArray()); Assert.AreEqual(0, slot.Count); CollectionAssert.AreEqual(Array.Empty(), slot.ToArray()); } } ================================================ FILE: tests/Neo.VM.Tests/UT_StackItem.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // UT_StackItem.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.VisualStudio.TestTools.UnitTesting; using Neo.VM; using Neo.VM.Types; using System.Numerics; namespace Neo.Test; [TestClass] public class UT_StackItem { [TestMethod] public void TestCircularReference() { var itemA = new Struct { true, false }; var itemB = new Struct { true, false }; var itemC = new Struct { false, false }; itemA[1] = itemA; itemB[1] = itemB; itemC[1] = itemC; Assert.ThrowsExactly(() => itemA.Equals(itemB, ExecutionEngineLimits.Default)); Assert.ThrowsExactly(() => itemA.Equals(itemC, ExecutionEngineLimits.Default)); } [TestMethod] public void TestHashCode() { StackItem itemA = "NEO"; StackItem itemB = "NEO"; StackItem itemC = "SmartEconomy"; Assert.AreEqual(itemB.GetHashCode(), itemA.GetHashCode()); Assert.AreNotEqual(itemC.GetHashCode(), itemA.GetHashCode()); itemA = new Buffer(1); itemB = new Buffer(1); itemC = new Buffer(2); Assert.ThrowsExactly(() => itemA.GetHashCode()); Assert.ThrowsExactly(() => itemB.GetHashCode()); Assert.ThrowsExactly(() => itemC.GetHashCode()); itemA = new byte[] { 1, 2, 3 }; itemB = new byte[] { 1, 2, 3 }; itemC = new byte[] { 5, 6 }; Assert.AreEqual(itemB.GetHashCode(), itemA.GetHashCode()); Assert.AreNotEqual(itemC.GetHashCode(), itemA.GetHashCode()); itemA = true; itemB = true; itemC = false; Assert.AreEqual(itemB.GetHashCode(), itemA.GetHashCode()); Assert.AreNotEqual(itemC.GetHashCode(), itemA.GetHashCode()); itemA = 1; itemB = 1; itemC = 123; Assert.AreEqual(itemB.GetHashCode(), itemA.GetHashCode()); Assert.AreNotEqual(itemC.GetHashCode(), itemA.GetHashCode()); itemA = new Null(); itemB = new Null(); Assert.AreEqual(itemB.GetHashCode(), itemA.GetHashCode()); itemA = new Array { true, false, 0 }; itemB = new Array { true, false, 0 }; itemC = new Array { true, false, 1 }; Assert.ThrowsExactly(() => itemA.GetHashCode()); Assert.ThrowsExactly(() => itemB.GetHashCode()); Assert.ThrowsExactly(() => itemC.GetHashCode()); itemA = new Struct { true, false, 0 }; itemB = new Struct { true, false, 0 }; itemC = new Struct { true, false, 1 }; Assert.ThrowsExactly(() => itemA.GetHashCode()); Assert.ThrowsExactly(() => itemB.GetHashCode()); Assert.ThrowsExactly(() => itemC.GetHashCode()); itemA = new Map { [true] = false, [0] = 1 }; itemB = new Map { [true] = false, [0] = 1 }; itemC = new Map { [true] = false, [0] = 2 }; Assert.ThrowsExactly(() => itemA.GetHashCode()); Assert.ThrowsExactly(() => itemB.GetHashCode()); Assert.ThrowsExactly(() => itemC.GetHashCode()); // Test CompoundType GetHashCode for subitems var junk = new Array { true, false, 0 }; itemA = new Map { [true] = junk, [0] = junk }; itemB = new Map { [true] = junk, [0] = junk }; itemC = new Map { [true] = junk, [0] = 2 }; Assert.ThrowsExactly(() => itemA.GetHashCode()); Assert.ThrowsExactly(() => itemB.GetHashCode()); Assert.ThrowsExactly(() => itemC.GetHashCode()); itemA = new InteropInterface(123); itemB = new InteropInterface(123); itemC = new InteropInterface(124); Assert.AreEqual(itemB.GetHashCode(), itemA.GetHashCode()); Assert.AreNotEqual(itemC.GetHashCode(), itemA.GetHashCode()); var script = new Script(System.Array.Empty()); itemA = new Pointer(script, 123); itemB = new Pointer(script, 123); itemC = new Pointer(script, 1234); Assert.AreEqual(itemB.GetHashCode(), itemA.GetHashCode()); Assert.AreNotEqual(itemC.GetHashCode(), itemA.GetHashCode()); } [TestMethod] public void TestNull() { StackItem nullItem = System.Array.Empty(); Assert.AreNotEqual(StackItem.Null, nullItem); nullItem = new Null(); Assert.AreEqual(StackItem.Null, nullItem); } [TestMethod] public void TestEqual() { StackItem itemA = "NEO"; StackItem itemB = "NEO"; StackItem itemC = "SmartEconomy"; StackItem itemD = "Smarteconomy"; StackItem itemE = "smarteconomy"; Assert.IsTrue(itemA.Equals(itemB)); Assert.IsFalse(itemA.Equals(itemC)); Assert.IsFalse(itemC.Equals(itemD)); Assert.IsFalse(itemD.Equals(itemE)); Assert.IsFalse(itemA.Equals(new object())); } [TestMethod] public void TestCast() { // Signed byte StackItem item = sbyte.MaxValue; Assert.IsInstanceOfType(item); Assert.AreEqual(new BigInteger(sbyte.MaxValue), ((Integer)item).GetInteger()); // Unsigned byte item = byte.MaxValue; Assert.IsInstanceOfType(item); Assert.AreEqual(new BigInteger(byte.MaxValue), ((Integer)item).GetInteger()); // Signed short item = short.MaxValue; Assert.IsInstanceOfType(item); Assert.AreEqual(new BigInteger(short.MaxValue), ((Integer)item).GetInteger()); // Unsigned short item = ushort.MaxValue; Assert.IsInstanceOfType(item); Assert.AreEqual(new BigInteger(ushort.MaxValue), ((Integer)item).GetInteger()); // Signed integer item = int.MaxValue; Assert.IsInstanceOfType(item); Assert.AreEqual(new BigInteger(int.MaxValue), ((Integer)item).GetInteger()); // Unsigned integer item = uint.MaxValue; Assert.IsInstanceOfType(item); Assert.AreEqual(new BigInteger(uint.MaxValue), ((Integer)item).GetInteger()); // Signed long item = long.MaxValue; Assert.IsInstanceOfType(item); Assert.AreEqual(new BigInteger(long.MaxValue), ((Integer)item).GetInteger()); // Unsigned long item = ulong.MaxValue; Assert.IsInstanceOfType(item); Assert.AreEqual(new BigInteger(ulong.MaxValue), ((Integer)item).GetInteger()); // BigInteger item = BigInteger.MinusOne; Assert.IsInstanceOfType(item); Assert.AreEqual(new BigInteger(-1), ((Integer)item).GetInteger()); // Boolean item = true; Assert.IsInstanceOfType(item); Assert.IsTrue(item.GetBoolean()); // ByteString item = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 }; Assert.IsInstanceOfType(item); CollectionAssert.AreEqual(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09 }, item.GetSpan().ToArray()); } [TestMethod] public void TestDeepCopy() { Array a = new() { true, 1, new byte[] { 1 }, StackItem.Null, new Buffer(new byte[] { 1 }), new Map { [0] = 1, [2] = 3 }, new Struct { 1, 2, 3 } }; a.Add(a); Array aa = (Array)a.DeepCopy(); Assert.AreNotEqual(a, aa); Assert.AreSame(aa, aa[^1]); Assert.IsTrue(a[^2].Equals(aa[^2], ExecutionEngineLimits.Default)); Assert.AreNotSame(a[^2], aa[^2]); } [TestMethod] public void TestMapRemove() { var key = 1; var value = "test"; Map map = new() { [key] = value, }; var removed = map.Remove(key); Assert.AreEqual(value, removed); Assert.IsFalse(map.ContainsKey(key)); removed = map.Remove(key); Assert.IsNull(removed); var bigKey = new ByteString(new byte[65]); Assert.ThrowsExactly(() => map.Remove(bigKey)); var readonlyMap = (Map)map.DeepCopy(true); Assert.ThrowsExactly(() => readonlyMap.Remove(key)); } } ================================================ FILE: tests/Neo.VM.Tests/UT_Struct.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // UT_Struct.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.VisualStudio.TestTools.UnitTesting; using Neo.VM; using Neo.VM.Types; using System; namespace Neo.Test; [TestClass] public class UT_Struct { private readonly Struct @struct; public UT_Struct() { @struct = new Struct { 1 }; for (int i = 0; i < 20000; i++) @struct = new Struct { @struct }; } [TestMethod] public void TestClone() { Struct s1 = new() { 1, new Struct { 2 } }; Struct s2 = s1.Clone(ExecutionEngineLimits.Default); s1[0] = 3; Assert.AreEqual(1, s2[0]); ((Struct)s1[1])[0] = 3; Assert.AreEqual(2, ((Struct)s2[1])[0]); Assert.ThrowsExactly(() => _ = @struct.Clone(ExecutionEngineLimits.Default)); } [TestMethod] public void TestEquals() { Struct s1 = new() { 1, new Struct { 2 } }; Struct s2 = new() { 1, new Struct { 2 } }; Assert.IsTrue(s1.Equals(s2, ExecutionEngineLimits.Default)); Struct s3 = new() { 1, new Struct { 3 } }; Assert.IsFalse(s1.Equals(s3, ExecutionEngineLimits.Default)); Assert.ThrowsExactly(() => _ = @struct.Equals(@struct.Clone(ExecutionEngineLimits.Default), ExecutionEngineLimits.Default)); } [TestMethod] public void TestEqualsDos() { var payloadStr = new string('h', 65535); Struct s1 = new(); Struct s2 = new(); for (int i = 0; i < 2; i++) { s1.Add(payloadStr); s2.Add(payloadStr); } Assert.ThrowsExactly(() => _ = s1.Equals(s2, ExecutionEngineLimits.Default)); for (int i = 0; i < 1000; i++) { s1.Add(payloadStr); s2.Add(payloadStr); } Assert.ThrowsExactly(() => _ = s1.Equals(s2, ExecutionEngineLimits.Default)); } } ================================================ FILE: tests/Neo.VM.Tests/UT_Unsafe.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // UT_Unsafe.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.VisualStudio.TestTools.UnitTesting; using Neo.VM; namespace Neo.Test; [TestClass] public class UT_Unsafe { [TestMethod] public void NotZero() { Assert.IsFalse(Unsafe.NotZero(System.Array.Empty())); Assert.IsFalse(Unsafe.NotZero(new byte[4])); Assert.IsFalse(Unsafe.NotZero(new byte[8])); Assert.IsFalse(Unsafe.NotZero(new byte[11])); Assert.IsTrue(Unsafe.NotZero(new byte[4] { 0x00, 0x00, 0x00, 0x01 })); Assert.IsTrue(Unsafe.NotZero(new byte[8] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 })); Assert.IsTrue(Unsafe.NotZero(new byte[11] { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 })); } } ================================================ FILE: tests/Neo.VM.Tests/UT_Utility.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // UT_Utility.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.VisualStudio.TestTools.UnitTesting; using Neo.VM; using System; using System.Numerics; namespace Neo.Test; [TestClass] public class UT_Utility { [TestMethod] public void SqrtTest() { Assert.ThrowsExactly(() => BigInteger.MinusOne.Sqrt()); Assert.AreEqual(BigInteger.Zero, BigInteger.Zero.Sqrt()); Assert.AreEqual(new BigInteger(1), new BigInteger(1).Sqrt()); Assert.AreEqual(new BigInteger(1), new BigInteger(2).Sqrt()); Assert.AreEqual(new BigInteger(1), new BigInteger(3).Sqrt()); Assert.AreEqual(new BigInteger(2), new BigInteger(4).Sqrt()); Assert.AreEqual(new BigInteger(9), new BigInteger(81).Sqrt()); } [TestMethod] public void ModInverseTest() { Assert.ThrowsExactly(() => BigInteger.One.ModInverse(BigInteger.Zero)); Assert.ThrowsExactly(() => BigInteger.One.ModInverse(BigInteger.One)); Assert.ThrowsExactly(() => BigInteger.Zero.ModInverse(BigInteger.Zero)); Assert.ThrowsExactly(() => BigInteger.Zero.ModInverse(BigInteger.One)); Assert.ThrowsExactly(() => new BigInteger(ushort.MaxValue).ModInverse(byte.MaxValue)); Assert.AreEqual(new BigInteger(52), new BigInteger(19).ModInverse(141)); } } ================================================ FILE: tests/Neo.VM.Tests/UT_VMJson.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // UT_VMJson.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.VisualStudio.TestTools.UnitTesting; using Neo.Test.Extensions; using Neo.Test.Types; using System; using System.IO; using System.Text; namespace Neo.Test; [TestClass] public class UT_VMJson : VMJsonTestBase { [TestMethod] public void TestOthers() => TestJson("./Tests/Others"); [TestMethod] public void TestOpCodesArrays() => TestJson("./Tests/OpCodes/Arrays"); [TestMethod] public void TestOpCodesStack() => TestJson("./Tests/OpCodes/Stack"); [TestMethod] public void TestOpCodesSlot() => TestJson("./Tests/OpCodes/Slot"); [TestMethod] public void TestOpCodesSplice() => TestJson("./Tests/OpCodes/Splice"); [TestMethod] public void TestOpCodesControl() => TestJson("./Tests/OpCodes/Control"); [TestMethod] public void TestOpCodesPush() => TestJson("./Tests/OpCodes/Push"); [TestMethod] public void TestOpCodesArithmetic() => TestJson("./Tests/OpCodes/Arithmetic"); [TestMethod] public void TestOpCodesBitwiseLogic() => TestJson("./Tests/OpCodes/BitwiseLogic"); [TestMethod] public void TestOpCodesTypes() => TestJson("./Tests/OpCodes/Types"); private static void TestJson(string path) { foreach (var file in Directory.GetFiles(path, "*.json", SearchOption.AllDirectories)) { Console.WriteLine($"Processing file '{file}'"); var realFile = Path.GetFullPath(file); var json = File.ReadAllText(realFile, Encoding.UTF8); var ut = json.DeserializeJson(); Assert.IsFalse(string.IsNullOrEmpty(ut.Name), "Name is required"); if (json != ut.ToJson().Replace("\r\n", "\n")) { // Format json Console.WriteLine($"The file '{realFile}' was optimized"); //File.WriteAllText(realFile, ut.ToJson().Replace("\r\n", "\n"), Encoding.UTF8); } try { ExecuteTest(ut); } catch (Exception ex) { throw new AggregateException("Error in file: " + realFile, ex); } } } } ================================================ FILE: tests/Neo.VM.Tests/VMJsonTestBase.cs ================================================ // Copyright (C) 2015-2026 The Neo Project. // // VMJsonTestBase.cs file belongs to the neo project and is free // software distributed under the MIT software license, see the // accompanying file LICENSE in the main directory of the // repository or http://www.opensource.org/licenses/mit-license.php // for more details. // // Redistribution and use in source and binary forms with or without // modifications are permitted. using Microsoft.VisualStudio.TestTools.UnitTesting; using Neo.Test.Extensions; using Neo.Test.Types; using Neo.VM; using Neo.VM.Types; using Newtonsoft.Json; using Newtonsoft.Json.Linq; using System; using System.Collections.Generic; using System.Text; using Array = Neo.VM.Types.Array; using Boolean = Neo.VM.Types.Boolean; using Buffer = Neo.VM.Types.Buffer; namespace Neo.Test; public abstract class VMJsonTestBase { /// /// Execute this test /// /// Test public static void ExecuteTest(VMUT ut) { foreach (var test in ut.Tests) { Assert.IsFalse(string.IsNullOrEmpty(test.Name), "Name is required"); foreach (var refCounter in new IReferenceCounter[] { new ReferenceCounter(), new ReferenceCounterV2() }) { using TestEngine engine = new TestEngine(refCounter, ExecutionEngineLimits.Default); Debugger debugger = new(engine); if (test.Script.Length > 0) { engine.LoadScript(test.Script); } // Execute Steps if (test.Steps != null) { foreach (var step in test.Steps) { // Actions if (step.Actions != null) foreach (var run in step.Actions) { switch (run) { case VMUTActionType.Execute: debugger.Execute(); break; case VMUTActionType.StepInto: debugger.StepInto(); break; case VMUTActionType.StepOut: debugger.StepOut(); break; case VMUTActionType.StepOver: debugger.StepOver(); break; } } // Review results var add = string.IsNullOrEmpty(step.Name) ? "" : "-" + step.Name; AssertResult(step.Result, engine, $"{ut.Category}-{ut.Name}-{test.Name}{add}: "); } } } } } /// /// Assert result /// /// Engine /// Result /// Message private static void AssertResult(VMUTExecutionEngineState result, TestEngine engine, string message) { AssertAreEqual(result.State.ToString().ToLowerInvariant(), engine.State.ToString().ToLowerInvariant(), message + "State is different"); if (result.Refs != null && engine.ReferenceCounter.Version == RCVersion.V2) AssertAreEqual(result.Refs, engine.ReferenceCounter.Count, message + "Refs are different"); if (engine.State == VMState.FAULT) { if (result.ExceptionMessage != null) { AssertAreEqual(result.ExceptionMessage, engine.FaultException.Message, message + " [Exception]"); } return; } AssertResult(result.InvocationStack, engine.InvocationStack, message + " [Invocation stack]"); AssertResult(result.ResultStack, engine.ResultStack, message + " [Result stack] "); } /// /// Assert invocation stack /// /// Stack /// Result /// Message private static void AssertResult(VMUTExecutionContextState[] result, Stack stack, string message) { AssertAreEqual(result == null ? 0 : result.Length, stack.Count, message + "Stack is different"); int x = 0; foreach (var context in stack) { var opcode = context.InstructionPointer >= context.Script.Length ? OpCode.RET : context.Script[context.InstructionPointer]; AssertAreEqual(result[x].NextInstruction, opcode, message + "Next instruction is different"); AssertAreEqual(result[x].InstructionPointer, context.InstructionPointer, message + "Instruction pointer is different"); // Check stack AssertResult(result[x].EvaluationStack, context.EvaluationStack, message + " [EvaluationStack]"); // Check slots AssertResult(result[x].Arguments, context.Arguments, message + " [Arguments]"); AssertResult(result[x].LocalVariables, context.LocalVariables, message + " [LocalVariables]"); AssertResult(result[x].StaticFields, context.StaticFields, message + " [StaticFields]"); x++; } } /// /// Assert result stack /// /// Stack /// Result /// Message private static void AssertResult(VMUTStackItem[] result, EvaluationStack stack, string message) { AssertAreEqual(stack.Count, result == null ? 0 : result.Length, message + "Stack is different"); for (int x = 0, max = stack.Count; x < max; x++) { AssertAreEqual(ItemToJson(stack.Peek(x)).ToString(Formatting.None), PrepareJsonItem(result[x]).ToString(Formatting.None), message + "Stack item is different"); } } /// /// Assert result slot /// /// Slot /// Result /// Message private static void AssertResult(VMUTStackItem[] result, Slot slot, string message) { AssertAreEqual(slot == null ? 0 : slot.Count, result == null ? 0 : result.Length, message + "Slot is different"); for (int x = 0, max = slot == null ? 0 : slot.Count; x < max; x++) { AssertAreEqual(ItemToJson(slot[x]).ToString(Formatting.None), PrepareJsonItem(result[x]).ToString(Formatting.None), message + "Stack item is different"); } } private static JObject PrepareJsonItem(VMUTStackItem item) { var ret = new JObject { ["type"] = item.Type.ToString(), ["value"] = item.Value }; switch (item.Type) { case VMUTStackItemType.Null: { ret["type"] = VMUTStackItemType.Null.ToString(); ret.Remove("value"); break; } case VMUTStackItemType.Pointer: { ret["type"] = VMUTStackItemType.Pointer.ToString(); ret["value"] = item.Value.Value(); break; } case VMUTStackItemType.String: { // Easy access ret["type"] = VMUTStackItemType.ByteString.ToString(); ret["value"] = Encoding.UTF8.GetBytes(item.Value.Value()); break; } case VMUTStackItemType.ByteString: case VMUTStackItemType.Buffer: { var value = ret["value"].Value(); Assert.IsTrue(string.IsNullOrEmpty(value) || value.StartsWith("0x"), $"'0x' prefix required for value: '{value}'"); ret["value"] = value.FromHexString(); break; } case VMUTStackItemType.Integer: { // Ensure format ret["value"] = ret["value"].Value(); break; } case VMUTStackItemType.Struct: case VMUTStackItemType.Array: { var array = (JArray)ret["value"]; for (int x = 0, m = array.Count; x < m; x++) { array[x] = PrepareJsonItem(JsonConvert.DeserializeObject(array[x].ToString())); } ret["value"] = array; break; } case VMUTStackItemType.Map: { var obj = (JObject)ret["value"]; foreach (var prop in obj.Properties()) { obj[prop.Name] = PrepareJsonItem(JsonConvert.DeserializeObject(prop.Value.ToString())); } ret["value"] = obj; break; } } return ret; } private static JObject ItemToJson(StackItem item) { if (item == null) return null; JToken value; string type = item.GetType().Name; switch (item) { case Null _: { return new JObject { ["type"] = type, }; } case Pointer p: { return new JObject { ["type"] = type, ["value"] = p.Position }; } case Boolean v: value = new JValue(v.GetBoolean()); break; case Integer v: value = new JValue(v.GetInteger().ToString()); break; case ByteString v: value = new JValue(v.GetSpan().ToArray()); break; case Buffer v: value = new JValue(v.InnerBuffer.ToArray()); break; //case VM.Types.Struct v: case Array v: { var jarray = new JArray(); foreach (var entry in v) { jarray.Add(ItemToJson(entry)); } value = jarray; break; } case Map v: { var jdic = new JObject(); foreach (var entry in v) { jdic.Add(entry.Key.GetSpan().ToArray().ToHexString(), ItemToJson(entry.Value)); } value = jdic; break; } case InteropInterface v: { type = "Interop"; var obj = v.GetInterface(); value = obj.GetType().Name.ToString(); break; } default: throw new NotImplementedException(); } return new JObject { ["type"] = type, ["value"] = value }; } /// /// Assert with message /// /// A /// B /// Message private static void AssertAreEqual(object expected, object actual, string message) { if (expected is byte[] ba) expected = ba.ToHexString().ToUpperInvariant(); if (actual is byte[] bb) actual = bb.ToHexString().ToUpperInvariant(); if (expected.ToJson() != actual.ToJson()) { throw new Exception(message + $"{Environment.NewLine}Expected:{Environment.NewLine + expected.ToString() + Environment.NewLine}Actual:{Environment.NewLine + actual.ToString()}"); } } }