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))