def test_entrypoints_kaiw9a(self):
ep_types = self.program.parameter.list_entrypoints()
self.assertEqual(
len(self.entrypoints['entrypoints']) + 1, len(ep_types))
for name, ep_type in ep_types.items():
if name not in ['default', 'root']:
expected_type = MichelsonType.match(
self.entrypoints['entrypoints'][name])
expected_type.assert_type_equal(ep_type)
def test_entrypoints_tezos_israel_and_madfish_solutions_workshop_certificate(
self):
ep_types = self.program.parameter.list_entrypoints()
self.assertEqual(
len(self.entrypoints['entrypoints']) + 1, len(ep_types))
for name, ep_type in ep_types.items():
if name not in ['default', 'root']:
expected_type = MichelsonType.match(
self.entrypoints['entrypoints'][name])
expected_type.assert_type_equal(ep_type)
def update_comb(self, idx: int, element: MichelsonType) -> 'PairType':
if idx % 2 == 1:
leaves = [element if 2 * i + 1 == idx else item for i, item in enumerate(self.iter_comb())]
else:
leaves = [item for i, item in enumerate(self.iter_comb()) if 2 * i + 1 < idx]
if isinstance(element, PairType):
leaves.extend(element.iter_comb())
else:
leaves.append(element)
return type(self).from_comb(leaves)
def test_map_order(self):
self.bake_block()
random_keys = [(i, get_random_key()) for i in range(100)]
payload = {key.public_key(): i for i, key in random_keys}
ty_expr = michelson_to_micheline('map key int')
ty = MichelsonType.match(ty_expr)
val_expr = ty.from_python_object(payload).to_micheline_value()
self.client.shell.head.helpers.scripts.typecheck_data.post(
dict(data=val_expr, type=ty_expr))
def __init__(self,
context: ExecutionContext,
name: str,
parameter: Optional[Dict[str, Any]],
return_type: Dict[str, Any],
code: List[Any]):
super(OffChainView, self).__init__(context=context)
self.name = name
self.param_expr = parameter or {'prim': 'unit'}
self.rtype_expr = return_type
self.code_expr = code
self.__doc__ = generate_pydoc(MichelsonType.match(self.param_expr), title=name)
def transaction(cls, source: str, destination: str, amount: int, entrypoint: str, parameter: MichelsonType) \
-> 'OperationType':
content = {
'kind': 'transaction',
'source': source,
'destination': destination,
'amount': str(amount),
'parameters': {
'entrypoint': entrypoint,
'value': parameter.to_micheline_value()
}
}
return cls(content, ty=type(parameter))
def get(self, key: MichelsonType, dup=True) -> Optional[MichelsonType]:
self.args[0].assert_type_equal(type(key))
val = next((v for k, v in self if k == key),
Undefined) # search in diff
if val is Undefined:
assert self.context, f'context is not attached'
key_hash = forge_script_expr(key.pack(legacy=True))
val_expr = self.context.get_big_map_value(self.ptr, key_hash)
if val_expr is None:
return None
else:
return self.args[1].from_micheline_value(val_expr)
else:
return val
def encode(self, py_obj) -> Dict[str, Any]:
""" Encode transaction parameters from the given Python object
:param py_obj: Python object
:return: {entrypoint, value}
"""
try:
view_param_ty = MichelsonType.match(self.param_expr)
view_param_expr = view_param_ty.from_python_object(py_obj).to_micheline_value()
storage_expr = self.shell.blocks[self.context.block_id].context.contracts[self.address].storage()
return {'entrypoint': 'default',
'value': {'prim': 'Pair', 'args': [view_param_expr, storage_expr]}}
except MichelsonRuntimeError as e:
logger.info(self.__doc__)
raise ValueError(f'Unexpected arguments: {pformat(py_obj)}', *e.args) from e
def origination(cls,
source: str,
script: Type[MichelineSequence],
storage: MichelsonType,
balance: int = 0,
delegate: Optional[str] = None) -> 'OperationType':
content = {
'kind': 'origination',
'source': source,
'script': {
'code': script.as_micheline_expr(),
'storage': storage.to_micheline_value()
},
'balance': str(balance)
}
if delegate is not None:
content['delegate'] = delegate
return cls(content, ty=type(storage))
def from_some(item: MichelsonType) -> 'OptionType':
cls = OptionType.create_type(args=[item.get_anon_type()])
return cls(item)
def create(ticketer: str, item: MichelsonType,
amount: int) -> 'TicketType':
cls = TicketType.create_type(args=[item.get_anon_type()])
return cls(ticketer, item, amount) # type: ignore
def test_get_key_hash(self, val_expr, type_expr, expected):
ty = MichelsonType.match(type_expr)
key = ty.from_micheline_value(val_expr).pack(legacy=True)
self.assertEqual(expected, forge_script_expr(key))
