forked from TrueCloudLab/frostfs-testlib
358 lines
13 KiB
Python
358 lines
13 KiB
Python
from typing import Optional
|
|
|
|
from cli.cli_command import NeofsCliCommand
|
|
from shell import CommandResult
|
|
|
|
|
|
class NeoGoContract(NeofsCliCommand):
|
|
def compile(
|
|
self,
|
|
input_file: str,
|
|
out: str,
|
|
manifest: str,
|
|
config: str,
|
|
no_standards: bool = False,
|
|
no_events: bool = False,
|
|
no_permissions: bool = False,
|
|
bindings: Optional[str] = None,
|
|
) -> CommandResult:
|
|
"""compile a smart contract to a .nef file
|
|
|
|
Args:
|
|
input_file (str): Input file for the smart contract to be compiled
|
|
out (str): Output of the compiled contract
|
|
manifest (str): Emit contract manifest (*.manifest.json) file into separate
|
|
file using configuration input file (*.yml)
|
|
config (str): Configuration input file (*.yml)
|
|
no_standards (bool): do not check compliance with supported standards
|
|
no_events (bool): do not check emitted events with the manifest
|
|
no_permissions (bool): do not check if invoked contracts are allowed in manifest
|
|
bindings (str): output file for smart-contract bindings configuration
|
|
|
|
Returns:
|
|
str: Command string
|
|
|
|
"""
|
|
return self._execute(
|
|
"contract compile",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def deploy(
|
|
self,
|
|
address: str,
|
|
input_file: str,
|
|
sysgas: float,
|
|
manifest: str,
|
|
rpc_endpoint: str,
|
|
wallet: Optional[str] = None,
|
|
wallet_config: Optional[str] = None,
|
|
gas: Optional[float] = None,
|
|
out: Optional[str] = None,
|
|
force: bool = False,
|
|
timeout: int = 10,
|
|
|
|
) -> CommandResult:
|
|
"""deploy a smart contract (.nef with description)
|
|
|
|
Args:
|
|
wallet (str): wallet to use to get the key for transaction signing;
|
|
conflicts with wallet_config
|
|
wallet_config (str): path to wallet config to use to get the key for transaction
|
|
signing; conflicts with wallet
|
|
address (str): address to use as transaction signee (and gas source)
|
|
gas (float): network fee to add to the transaction (prioritizing it)
|
|
sysgas (float): system fee to add to transaction (compensating for execution)
|
|
out (str): file to put JSON transaction to
|
|
force (bool): Do not ask for a confirmation
|
|
rpc_endpoint (str): RPC node address
|
|
timeout (int): Timeout for the operation (default: 10s)
|
|
input_file (str): Input file for the smart contract (*.nef)
|
|
manifest (str): Emit contract manifest (*.manifest.json) file into separate
|
|
file using configuration input file (*.yml)
|
|
|
|
Returns:
|
|
str: Command string
|
|
|
|
"""
|
|
assert bool(wallet) ^ bool(wallet_config), self.WALLET_SOURCE_ERROR_MSG
|
|
|
|
return self._execute(
|
|
"contract deploy",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def generate_wrapper(
|
|
self,
|
|
out: str,
|
|
hash: str,
|
|
config: Optional[str] = None,
|
|
manifest: Optional[str] = None,
|
|
) -> CommandResult:
|
|
"""generate wrapper to use in other contracts
|
|
|
|
Args:
|
|
config (str): Configuration file to use
|
|
manifest (str): Read contract manifest (*.manifest.json) file
|
|
out (str): Output of the compiled contract
|
|
hash (str): Smart-contract hash
|
|
|
|
Returns:
|
|
str: Command string
|
|
|
|
"""
|
|
return self._execute(
|
|
"contract generate-wrapper",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def invokefunction(
|
|
self,
|
|
address: str,
|
|
scripthash: str,
|
|
wallet: Optional[str] = None,
|
|
method: Optional[str] = None,
|
|
arguments: Optional[str] = None,
|
|
multisig_hash: Optional[str] = None,
|
|
wallet_config: Optional[str] = None,
|
|
gas: Optional[float] = None,
|
|
sysgas: Optional[float] = None,
|
|
out: Optional[str] = None,
|
|
force: bool = False,
|
|
rpc_endpoint: Optional[str] = None,
|
|
timeout: int = 10,
|
|
) -> CommandResult:
|
|
"""Executes given (as a script hash) deployed script with the given method,
|
|
arguments and signers. Sender is included in the list of signers by default
|
|
with None witness scope. If you'd like to change default sender's scope,
|
|
specify it via signers parameter. See testinvokefunction documentation for
|
|
the details about parameters. It differs from testinvokefunction in that this
|
|
command sends an invocation transaction to the network.
|
|
|
|
Args:
|
|
scripthash (str): Function hash
|
|
method (str): Call method
|
|
arguments (str): Method arguments
|
|
multisig_hash (str): Multisig hash
|
|
wallet (str): wallet to use to get the key for transaction signing;
|
|
conflicts with wallet_config
|
|
wallet_config (str): path to wallet config to use to get the key for transaction
|
|
signing; conflicts with wallet
|
|
address (str): address to use as transaction signee (and gas source)
|
|
gas (float): network fee to add to the transaction (prioritizing it)
|
|
sysgas (float): system fee to add to transaction (compensating for execution)
|
|
out (str): file to put JSON transaction to
|
|
force (bool): force-push the transaction in case of bad VM state after
|
|
test script invocation
|
|
rpc_endpoint (str): RPC node address
|
|
timeout (int): Timeout for the operation (default: 10s)
|
|
|
|
Returns:
|
|
str: Command string
|
|
|
|
"""
|
|
multisig_hash = f"-- {multisig_hash}" or ""
|
|
return self._execute(
|
|
"contract invokefunction "
|
|
f"{scripthash} {method or ''} {arguments or ''} {multisig_hash}",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self", "scripthash", "method", "arguments", "multisig_hash"]
|
|
},
|
|
)
|
|
|
|
def testinvokefunction(
|
|
self,
|
|
scripthash: str,
|
|
wallet: Optional[str] = None,
|
|
method: Optional[str] = None,
|
|
arguments: Optional[str] = None,
|
|
multisig_hash: Optional[str] = None,
|
|
rpc_endpoint: Optional[str] = None,
|
|
timeout: int = 10,
|
|
) -> CommandResult:
|
|
"""Executes given (as a script hash) deployed script with the given method,
|
|
arguments and signers (sender is not included by default). If no method is given
|
|
"" is passed to the script, if no arguments are given, an empty array is
|
|
passed, if no signers are given no array is passed. If signers are specified,
|
|
the first one of them is treated as a sender. All of the given arguments are
|
|
encapsulated into array before invoking the script. The script thus should
|
|
follow the regular convention of smart contract arguments (method string and
|
|
an array of other arguments).
|
|
|
|
See more information and samples in `neo-go contract testinvokefunction --help`
|
|
|
|
Args:
|
|
scripthash (str): Function hash
|
|
method (str): Call method
|
|
arguments (str): Method arguments
|
|
multisig_hash (str): Multisig hash
|
|
rpc_endpoint (str): RPC node address
|
|
timeout (int): Timeout for the operation (default: 10s)
|
|
|
|
Returns:
|
|
str: Command string
|
|
|
|
"""
|
|
multisig_hash = f"-- {multisig_hash}" or ""
|
|
return self._execute(
|
|
"contract testinvokefunction "
|
|
f"{scripthash} {method or ''} {arguments or ''} {multisig_hash}",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self", "scripthash", "method", "arguments", "multisig_hash"]
|
|
},
|
|
)
|
|
|
|
def testinvokescript(
|
|
self,
|
|
input_file: str,
|
|
rpc_endpoint: Optional[str] = None,
|
|
timeout: int = 10,
|
|
) -> CommandResult:
|
|
"""Executes given compiled AVM instructions in NEF format with the given set of
|
|
signers not included sender by default. See testinvokefunction documentation
|
|
for the details about parameters.
|
|
|
|
|
|
Args:
|
|
input_file (str): Input location of the .nef file that needs to be invoked
|
|
conflicts with wallet_config
|
|
rpc_endpoint (str): RPC node address
|
|
timeout (int): Timeout for the operation (default: 10s)
|
|
|
|
Returns:
|
|
str: Command string
|
|
|
|
"""
|
|
return self._execute(
|
|
f"contract testinvokescript",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def init(
|
|
self,
|
|
name: str,
|
|
skip_details: bool = False,
|
|
) -> CommandResult:
|
|
"""initialize a new smart-contract in a directory with boiler plate code
|
|
|
|
Args:
|
|
name (str): name of the smart-contract to be initialized
|
|
skip_details (bool): skip filling in the projects and contract details
|
|
|
|
Returns:
|
|
str: Command string
|
|
|
|
"""
|
|
return self._execute(
|
|
"contract init",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def inspect(
|
|
self,
|
|
input_file: Optional[str] = None,
|
|
compile: Optional[str] = None,
|
|
) -> CommandResult:
|
|
"""creates a user readable dump of the program instructions
|
|
|
|
Args:
|
|
input_file (str): input file of the program (either .go or .nef)
|
|
compile (str): compile input file (it should be go code then)
|
|
|
|
Returns:
|
|
str: Command string
|
|
|
|
"""
|
|
return self._execute(
|
|
"contract inspect",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def calc_hash(
|
|
self,
|
|
input_file: str,
|
|
manifest: str,
|
|
sender: Optional[str] = None,
|
|
) -> CommandResult:
|
|
"""calculates hash of a contract after deployment
|
|
|
|
Args:
|
|
input_file (str): path to NEF file
|
|
sender (str): sender script hash or address
|
|
manifest (str): path to manifest file
|
|
|
|
Returns:
|
|
str: Command string
|
|
|
|
"""
|
|
return self._execute(
|
|
"contract calc-hash",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|
|
|
|
def add_group(
|
|
self,
|
|
manifest: str,
|
|
address: str,
|
|
wallet: Optional[str] = None,
|
|
wallet_config: Optional[str] = None,
|
|
sender: Optional[str] = None,
|
|
nef: Optional[str] = None,
|
|
) -> CommandResult:
|
|
"""adds group to the manifest
|
|
|
|
Args:
|
|
wallet (str): wallet to use to get the key for transaction signing;
|
|
conflicts with wallet_config
|
|
wallet_config (str): path to wallet config to use to get the key for transaction
|
|
signing; conflicts with wallet
|
|
sender (str): deploy transaction sender
|
|
address (str): account to sign group with
|
|
nef (str): path to the NEF file
|
|
manifest (str): path to the manifest
|
|
|
|
|
|
Returns:
|
|
str: Command string
|
|
|
|
"""
|
|
return self._execute(
|
|
"contract manifest add-group",
|
|
**{
|
|
param: param_value
|
|
for param, param_value in locals().items()
|
|
if param not in ["self"]
|
|
},
|
|
)
|