def __init__(self,
password: str,
private_key: Optional[bytes] = None,
watch_only: bool = False,
address: Optional[str] = None,
label: Optional[str] = None,
lock: bool = False,
contract: Optional[contracts.Contract] = None,
extra: Optional[Dict[str, Any]] = None):
"""
Instantiate an account. This constructor should only be directly called when it's desired to create a new
account using just a password and a randomly generated private key, otherwise use the alternative constructors
"""
public_key: Optional[cryptography.ECPoint] = None
encrypted_key: Optional[bytes] = None
contract_script: Optional[bytes] = None
if watch_only:
if address is None:
raise ValueError(
"Creating a watch only account requires an address")
else:
self.validate_address(address)
else:
key_pair: cryptography.KeyPair
if private_key is None:
key_pair = cryptography.KeyPair.generate()
private_key = key_pair.private_key
else:
key_pair = cryptography.KeyPair(private_key)
encrypted_key = self.private_key_to_nep2(private_key, password)
contract_script = contracts.Contract.create_signature_redeemscript(
key_pair.public_key)
script_hash = to_script_hash(contract_script)
address = address if address else self.script_hash_to_address(
script_hash)
public_key = key_pair.public_key
self.label: Optional[str] = label
self.address: str = address
self.public_key = public_key
self.encrypted_key = encrypted_key
self.lock = lock
if not isinstance(contract, AccountContract):
if contract is not None:
contract = AccountContract.from_contract(contract)
elif contract_script is not None:
default_parameters_list = [
contracts.ContractParameterDefinition(
name='signature',
type=contracts.ContractParameterType.SIGNATURE)
]
contract = AccountContract(contract_script,
default_parameters_list)
self.contract: Optional[AccountContract] = contract
self.extra = extra if extra else {}
def init(self):
super(NonFungibleToken, self).init()
self.key_total_suppply = storage.StorageKey(self._id, b'\x0b')
self.key_token = storage.StorageKey(self._id, b'\x05')
self.key_account = storage.StorageKey(self._id, b'\x07')
self.manifest.abi.events = [
contracts.ContractEventDescriptor(
"Transfer",
parameters=[
contracts.ContractParameterDefinition("from", contracts.ContractParameterType.HASH160),
contracts.ContractParameterDefinition("to", contracts.ContractParameterType.HASH160),
contracts.ContractParameterDefinition("amount", contracts.ContractParameterType.INTEGER),
contracts.ContractParameterDefinition("tokenId", contracts.ContractParameterType.BYTEARRAY)
]
)
]
def init(self):
super(FungibleToken, self).init()
self.key_account = storage.StorageKey(self._id, b'\x14')
self.key_total_supply = storage.StorageKey(self._id, b'\x0B')
self.manifest.supported_standards = ["NEP-17"]
self.manifest.abi.events = [
contracts.ContractEventDescriptor(
"Transfer",
parameters=[
contracts.ContractParameterDefinition("from", contracts.ContractParameterType.HASH160),
contracts.ContractParameterDefinition("to", contracts.ContractParameterType.HASH160),
contracts.ContractParameterDefinition("amount", contracts.ContractParameterType.INTEGER)
]
)
]
self.factor = pow(vm.BigInteger(10), vm.BigInteger(self._decimals))
def from_contract(cls, contract: contracts.Contract) -> AccountContract:
if isinstance(contract, AccountContract):
return contract
parameters = [
contracts.ContractParameterDefinition(
f"arg{index}", contract.parameter_list[index])
for index in range(len(contract.parameter_list))
]
return cls(script=contract.script, parameter_list=parameters)
def init(self):
super(DesignationContract, self).init()
self.manifest.abi.events = [
contracts.ContractEventDescriptor(
"Designation",
parameters=[
contracts.ContractParameterDefinition(
"Role", contracts.ContractParameterType.INTEGER),
contracts.ContractParameterDefinition(
"BlockIndex", contracts.ContractParameterType.INTEGER),
]),
contracts.ContractEventDescriptor(
"OracleResponse",
parameters=[
contracts.ContractParameterDefinition(
"Id", contracts.ContractParameterType.INTEGER),
contracts.ContractParameterDefinition(
"OriginalTx", contracts.ContractParameterType.HASH160)
])
]
def setUpClass(cls) -> None:
cls.parameters = [
contracts.ContractParameterDefinition(
"param", contracts.ContractParameterType.STRING)
]
cls.expected = {
"name": "MainMethod",
"offset": 0,
"parameters": [cls.parameters[0].to_json()],
"returntype": "Boolean"
}
def setUpClass(cls) -> None:
cls.expected = {
"name": "MainEvent",
"parameters": [{
"name": "param",
"type": "String"
}]
}
cls.parameters = [
contracts.ContractParameterDefinition(
"param", contracts.ContractParameterType.STRING)
]
def init(self):
super(OracleContract, self).init()
self.manifest.abi.events = [
contracts.ContractEventDescriptor(
"OracleRequest",
parameters=[
contracts.ContractParameterDefinition(
"Id", contracts.ContractParameterType.INTEGER),
contracts.ContractParameterDefinition(
"RequestContract",
contracts.ContractParameterType.HASH160),
contracts.ContractParameterDefinition(
"Url", contracts.ContractParameterType.STRING),
contracts.ContractParameterDefinition(
"Filter", contracts.ContractParameterType.STRING)
]),
contracts.ContractEventDescriptor(
"OracleResponse",
parameters=[
contracts.ContractParameterDefinition(
"Id", contracts.ContractParameterType.INTEGER),
contracts.ContractParameterDefinition(
"OriginalTx", contracts.ContractParameterType.HASH160)
])
]
def init(self):
super(ManagementContract, self).init()
self.manifest.abi.events = [
contracts.ContractEventDescriptor(
"Deploy",
parameters=[
contracts.ContractParameterDefinition(
"Hash", contracts.ContractParameterType.HASH160)
]),
contracts.ContractEventDescriptor(
"Update",
parameters=[
contracts.ContractParameterDefinition(
"Hash", contracts.ContractParameterType.HASH160)
]),
contracts.ContractEventDescriptor(
"Destroy",
parameters=[
contracts.ContractParameterDefinition(
"Hash", contracts.ContractParameterType.HASH160)
]),
]
def __init__(self, func: Callable):
self.handler = func
self.name: str = func.name # type:ignore
self.cpu_price: int = func.cpu_price # type: ignore
self.storage_price: int = func.storage_price # type: ignore
self.required_flags: contracts.CallFlags = func.flags # type: ignore
self.add_engine = False
self.add_snapshot = False
self.return_type = None
parameter_types = []
parameter_names = []
for k, v in get_type_hints(func).items():
if k == 'return':
if v != type(None):
self.return_type = v
continue
if v == contracts.ApplicationEngine:
self.add_engine = True
continue
elif v == storage.Snapshot:
self.add_snapshot = True
continue
parameter_types.append(v)
parameter_names.append(k)
params = []
for t, n in zip(parameter_types, parameter_names):
params.append(
contracts.ContractParameterDefinition(
name=n, type=contracts.ContractParameterType.from_type(t)))
self.parameter_types = parameter_types
self.descriptor = contracts.ContractMethodDescriptor(
name=func.name, # type: ignore
offset=0,
return_type=contracts.ContractParameterType.from_type(
self.return_type),
parameters=params,
safe=(func.flags & ~contracts.CallFlags.READ_ONLY) ==
0 # type: ignore
)
def test_to_json(self):
cpd = contracts.ContractParameterDefinition(
"Main", contracts.ContractParameterType.STRING)
self.assertEqual(self.expected, cpd.to_json())