https://github.com/neo-project/neo/pull/1933

neo3/contracts/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 import hashlib
+from enum import IntEnum
 from .contracttypes import (TriggerType)
 from .descriptor import (ContractPermissionDescriptor)
 from .manifest import (ContractGroup,
@@ -18,7 +19,7 @@
 from .binaryserializer import BinarySerializer
 from .jsonserializer import (NEOJson, JSONSerializer)
 from .native import (CallFlags, NativeContract, PolicyContract, NeoToken, GasToken, OracleContract)
-from .applicationengine import ApplicationEngine
+from .applicationengine import ApplicationEngine, CheckReturnType
 
 
 def syscall_name_to_int(name: str) -> int:
@@ -38,4 +39,5 @@ def syscall_name_to_int(name: str) -> int:
  'CallFlags',
  'PolicyContract',
  'ApplicationEngine',
- 'syscall_name_to_int']
+ 'syscall_name_to_int',
+ 'CheckReturnType']

neo3/contracts/applicationengine.py

@@ -9,6 +9,12 @@
 from contextlib import suppress
 
 
+class CheckReturnType(enum.IntEnum):
+ NONE = 0
+ ENSURE_IS_EMPTY = 1
+ ENSURE_NOT_EMPTY = 2
+
+
 class ApplicationEngine(vm.ApplicationEngineCpp):
  _interop_calls: Dict[int, interop.InteropDescriptor] = {}
  _invocation_states: Dict[vm.ExecutionContext, InvocationState] = {}
@@ -27,7 +33,7 @@ class ApplicationEngine(vm.ApplicationEngineCpp):
  class InvocationState:
  return_type: type = None # type: ignore
  callback: Optional[Callable] = None
- check_return_value: bool = False
+ check_return_value: contracts.CheckReturnType = CheckReturnType.NONE
 
  def __init__(self,
  trigger: contracts.TriggerType,
@@ -303,7 +309,10 @@ def context_unloaded(self, context: vm.ExecutionContext):
  state = self._invocation_states.pop(self.current_context)
  except KeyError:
  return
- if state.check_return_value:
+ if state.check_return_value == contracts.CheckReturnType.ENSURE_IS_EMPTY:
+ if len(context.evaluation_stack) != 0:
+ raise ValueError("Evaluation expected to be empty, but was not")
+ elif state.check_return_value == contracts.CheckReturnType.ENSURE_NOT_EMPTY:
  eval_stack_len = len(context.evaluation_stack)
  if eval_stack_len == 0:
  self.push(vm.NullStackItem())
@@ -316,7 +325,8 @@ def context_unloaded(self, context: vm.ExecutionContext):
 
  def load_context(self, context: vm.ExecutionContext, check_return_value: bool = False):
  if check_return_value:
- self._get_invocation_state(self.current_context).check_return_value = True
+ self._get_invocation_state(self.current_context).check_return_value = \
+ contracts.CheckReturnType.ENSURE_NOT_EMPTY
  super(ApplicationEngine, self).load_context(context)
 
  def load_script_with_callflags(self, script, call_flags: contracts.native.CallFlags, initial_position=0):

neo3/contracts/interop/contract.py

@@ -7,7 +7,7 @@
 
 
 @register("System.Contract.Create", 0, contracts.native.CallFlags.ALLOW_MODIFIED_STATES, False, [bytes, bytes])
-def contract_create(engine: contracts.ApplicationEngine, script: bytes, manifest: bytes) -> storage.ContractState:
+def contract_create(engine: contracts.ApplicationEngine, script: bytes, manifest: bytes) -> None:
  script_len = len(script)
  manifest_len = len(manifest)
  if (script_len == 0
@@ -28,7 +28,17 @@ def contract_create(engine: contracts.ApplicationEngine, script: bytes, manifest
  raise ValueError("Error: manifest does not match with script")
 
  engine.snapshot.contracts.put(contract)
- return contract
+
+ engine.push(engine._native_to_stackitem(contract, storage.ContractState))
+ method_descriptor = contract.manifest.abi.get_method("_deploy")
+ if method_descriptor is not None:
+ contract_call_internal_ex(engine,
+ contract,
+ method_descriptor,
+ vm.ArrayStackItem(engine.reference_counter, vm.BooleanStackItem(False)),
+ contracts.native.CallFlags.ALL,
+ contracts.CheckReturnType.ENSURE_IS_EMPTY
+ )
 
 
 @register("System.Contract.Update", 0, contracts.native.CallFlags.ALLOW_MODIFIED_STATES, False, [bytes, bytes])
@@ -81,6 +91,17 @@ def contract_update(engine: contracts.ApplicationEngine, script: bytes, manifest
  and len(list(engine.snapshot.storages.find(contract.script_hash(), key_prefix=b''))) != 0):
  raise ValueError("Error: New contract does not support storage while old contract has existing storage")
 
+ if len(script) != 0:
+ method_descriptor = contract.manifest.abi.get_method("_deploy")
+ if method_descriptor is not None:
+ contract_call_internal_ex(engine,
+ contract,
+ method_descriptor,
+ vm.ArrayStackItem(engine.reference_counter, vm.BooleanStackItem(True)),
+ contracts.native.CallFlags.ALL,
+ contracts.CheckReturnType.ENSURE_IS_EMPTY
+ )
+
 
 @register("System.Contract.Destroy", 1000000, contracts.native.CallFlags.ALLOW_MODIFIED_STATES, False)
 def contract_destroy(engine: contracts.ApplicationEngine) -> None:
@@ -109,43 +130,53 @@ def contract_call_internal(engine: contracts.ApplicationEngine,
  if target_contract is None:
  raise ValueError("[System.Contract.Call] Can't find target contract")
 
+ method_descriptor = target_contract.manifest.abi.get_method(method)
+ if method_descriptor is None:
+ raise ValueError(f"[System.Contract.Call] Method '{method}' does not exist on target contract")
+
  current_contract = engine.snapshot.contracts.try_get(engine.current_scripthash, read_only=True)
  if current_contract and not current_contract.manifest.can_call(target_contract.manifest, method):
  raise ValueError(f"[System.Contract.Call] Not allowed to call target method '{method}' according to manifest")
 
- counter = engine._invocation_counter.get(target_contract.script_hash(), 0)
- engine._invocation_counter.update({target_contract.script_hash(): counter + 1})
+ contract_call_internal_ex(engine, target_contract, method_descriptor, args, flags,
+  contracts.CheckReturnType.ENSURE_NOT_EMPTY)
 
- engine._get_invocation_state(engine.current_context).check_return_value = True
+
+def contract_call_internal_ex(engine: contracts.ApplicationEngine,
+ contract: storage.ContractState,
+ contract_method_descriptor: contracts.ContractMethodDescriptor,
+ args: vm.ArrayStackItem,
+ flags: contracts.native.CallFlags,
+ check_return_value: contracts.CheckReturnType) -> None:
+ counter = engine._invocation_counter.get(contract.script_hash(), 0)
+ engine._invocation_counter.update({contract.script_hash(): counter + 1})
+
+ engine._get_invocation_state(engine.current_context).check_return_value = check_return_value
 
  state = engine.current_context
  calling_flags = state.call_flags
 
- contract_method_descriptor = target_contract.manifest.abi.get_method(method)
- if contract_method_descriptor is None:
- raise ValueError(f"[System.Contract.Call] requested target method '{method}' does not exist on target contract")
-
  arg_len = len(args)
  expected_len = len(contract_method_descriptor.parameters)
  if arg_len != expected_len:
  raise ValueError(
  f"[System.Contract.Call] Invalid number of contract arguments. Expected {expected_len} actual {arg_len}") # noqa
 
- context_new = engine.load_script(vm.Script(target_contract.script), contract_method_descriptor.offset)
+ context_new = engine.load_script(vm.Script(contract.script), contract_method_descriptor.offset)
  context_new.calling_script = state.script
  context_new.call_flags = flags & calling_flags
 
- if contracts.NativeContract.is_native(contract_hash):
+ if contracts.NativeContract.is_native(contract.script_hash()):
  context_new.evaluation_stack.push(args)
- context_new.evaluation_stack.push(vm.ByteStringStackItem(method.encode('utf-8')))
+ context_new.evaluation_stack.push(vm.ByteStringStackItem(contract_method_descriptor.name.encode('utf-8')))
  else:
  for item in reversed(args):
  context_new.evaluation_stack.push(item)
  context_new.ip = contract_method_descriptor.offset
 
- contract_method_descriptor = target_contract.manifest.abi.get_method("_initialize")
- if contract_method_descriptor is not None:
- engine.load_cloned_context(contract_method_descriptor.offset)
+ method_descriptor = contract.manifest.abi.get_method("_initialize")
+ if method_descriptor is not None:
+ engine.load_cloned_context(method_descriptor.offset)
 
 
 @register("System.Contract.Call", 1000000, contracts.native.CallFlags.ALLOW_CALL, False,

tests/contracts/interop/test_contract_interop.py

@@ -437,7 +437,7 @@ def test_contract_call_exceptions(self):
  engine.snapshot.contracts.put(new_current_contract)
  with self.assertRaises(ValueError) as context:
  contract_call_internal(engine, target_contract.script_hash(), "invalid_method", vm.ArrayStackItem(engine.reference_counter), contracts.native.CallFlags)
- self.assertEqual("[System.Contract.Call] Not allowed to call target method 'invalid_method' according to manifest", str(context.exception))
+ self.assertEqual("[System.Contract.Call] Method 'invalid_method' does not exist on target contract", str(context.exception))
 
  # restore current contract to its original form and try to call a non-existing contract
  current_contract = storage.ContractState(hello_world_nef.script, hello_world_manifest)
@@ -446,7 +446,7 @@ def test_contract_call_exceptions(self):
 
  with self.assertRaises(ValueError) as context:
  contract_call_internal(engine, target_contract.script_hash(), "invalid_method", vm.ArrayStackItem(engine.reference_counter), contracts.native.CallFlags)
- self.assertEqual("[System.Contract.Call] requested target method 'invalid_method' does not exist on target contract", str(context.exception))
+ self.assertEqual("[System.Contract.Call] Method 'invalid_method' does not exist on target contract", str(context.exception))
 
  # call the target method with invalid number of arguments
  array = vm.ArrayStackItem(engine.reference_counter)