def interpret(
self,
storage=None,
source=None,
sender=None,
amount=None,
balance=None,
chain_id=None,
level=None,
now=None,
self_address=None,
) -> ContractCallResult:
"""Run code in the builtin REPL (WARNING! Not recommended for critical tasks).
:param storage: initial storage as Python object, leave None if you want to generate a dummy one
:param source: patch SOURCE
:param sender: patch SENDER
:param amount: patch AMOUNT
:param balance: patch BALANCE
:param chain_id: patch CHAIN_ID
:param level: patch LEVEL
:param now: patch NOW
:param self_address: patch SELF/SELF_ADDRESS
:rtype: pytezos.contract.result.ContractCallResult
"""
storage_ty = StorageSection.match(self.context.storage_expr)
if storage is None:
initial_storage = storage_ty.dummy(
self.context).to_micheline_value(lazy_diff=True)
else:
initial_storage = storage_ty.from_python_object(
storage).to_micheline_value(lazy_diff=True)
assert self.context.script
operations, storage, lazy_diff, stdout, error = Interpreter.run_code(
parameter=self.parameters['value'],
entrypoint=self.parameters['entrypoint'],
storage=initial_storage,
script=self.context.script['code'],
source=source,
sender=sender or source,
amount=amount or self.amount,
balance=balance,
chain_id=chain_id,
level=level,
now=now,
address=self_address,
)
if error:
logger.debug('\n'.join(stdout))
raise error
res = {
'operations': operations,
'storage': storage,
'lazy_diff': lazy_diff,
}
return ContractCallResult.from_run_code(
res,
parameters=self.parameters,
context=self.context,
)
def operation_result(self,
operation_group: dict) -> List[ContractCallResult]:
"""Get operation parameters, and resulting storage as Python objects.
Can locate operation inside operation groups with multiple contents and/or internal operations.
:param operation_group: {'branch', 'protocol', 'contents', 'signature'}
:rtype: ContractCallResult
"""
return ContractCallResult.from_run_operation(operation_group,
context=self.context)
def run_operation(self) -> ContractCallResult:
"""Simulate operation using real context.
:rtype: ContractCallResult
"""
opg_with_metadata = self.as_transaction().fill().run()
results = ContractCallResult.from_run_operation(opg_with_metadata,
context=self.context)
assert len(results) == 1
return results[0]
def run_code(
self,
storage=None,
source=None,
sender=None,
amount=None,
balance=None,
chain_id=None,
gas_limit=None,
) -> ContractCallResult:
"""Execute using RPC interpreter.
:param storage: initial storage as Python object, leave None if you want to generate a dummy one
:param source: patch SOURCE
:param sender: patch SENDER
:param amount: patch AMOUNT
:param balance: patch BALANCE
:param chain_id: patch CHAIN_ID
:param gas_limit: restrict max consumed gas
:rtype: ContractCallResult
"""
storage_ty = StorageSection.match(self.context.storage_expr)
if storage is None:
initial_storage = storage_ty.dummy(
self.context).to_micheline_value(lazy_diff=True)
else:
initial_storage = storage_ty.from_python_object(
storage).to_micheline_value(lazy_diff=True)
script = [
self.context.parameter_expr, self.context.storage_expr,
self.context.code_expr
]
query = skip_nones(
script=script,
storage=initial_storage,
entrypoint=self.parameters['entrypoint'],
input=self.parameters['value'],
amount=format_mutez(amount or self.amount),
chain_id=chain_id or self.context.get_chain_id(),
source=sender,
payer=source,
balance=str(balance or 0),
gas=str(gas_limit) if gas_limit is not None else None,
)
res = self.shell.blocks[self.block_id].helpers.scripts.run_code.post(
query)
return ContractCallResult.from_run_code(res,
parameters=self.parameters,
context=self.context)