def cmdline(self) -> str: """Generate command line for tezos-client.""" arg = micheline_to_michelson(self.parameters['value'], inline=True) source = self.key.public_key_hash() amount = format_tez(self.amount) entrypoint = self.parameters['entrypoint'] return f'transfer {amount} from {source} to {self.address} --entrypoint \'{entrypoint}\' --arg \'{arg}\''
def iter_lazy_diff(lazy_diff: List[dict]) -> Generator[List[str], None, None]: for item in lazy_diff: if item['kind'] == 'big_map': ptr = item['id'] diff = item['diff'] if diff['action'] == 'alloc': key_type = micheline_to_michelson(diff['key_type'], wrap=True) val_type = micheline_to_michelson(diff['value_type'], wrap=True) yield [ f'New map({ptr}) of type (big_map {key_type} {val_type})' ] for update in diff.get('updates', []): key = micheline_to_michelson(update['key'], wrap=True) if 'value' in update: val = micheline_to_michelson(update['value'], wrap=True) yield [f'Set map({ptr})[{key}] to {val}'] else: yield [f'Unset map({ptr})[{key}]']
def generate_pydoc(cls, definitions: List[Tuple[str, str]], inferred_name=None, comparable=False) -> str: super(TicketType, cls).generate_pydoc(definitions) param_expr = micheline_to_michelson(cls.args[0].as_micheline_expr()) if cls.args[0].args: name = cls.field_name or cls.type_name or inferred_name or f'{cls.prim}_{len(definitions)}' param_name = f'{name}_param' definitions.insert(0, (param_name, param_expr)) return f'ticket (${param_name})' else: return f'ticket ({param_expr})'
def generate_pydoc(cls, definitions: list, inferred_name=None, comparable=False): super(LambdaType, cls).generate_pydoc(definitions) name = cls.field_name or cls.type_name or inferred_name or f'{cls.prim}_{len(definitions)}' expr = {} for i, suffix in enumerate(['return', 'param']): arg_expr = micheline_to_michelson(cls.args[i].as_micheline_expr()) if cls.args[i].args: arg_name = f'{name}_{suffix}' definitions.insert(0, (arg_name, arg_expr)) expr[suffix] = f'${arg_name}' else: expr[suffix] = arg_expr return f'lambda ({expr["param"]} -> {expr["return"]})'
def micheline_value_to_python_object(val_expr): if isinstance(val_expr, dict): if len(val_expr) == 1: prim = next(iter(val_expr)) if prim == 'string': return val_expr[prim] elif prim == 'int': return int(val_expr[prim]) elif prim == 'bytes': return blind_unpack(bytes.fromhex(val_expr[prim])) elif prim == 'bool': return True if val_expr[prim] == 'True' else False elif val_expr.get('prim'): prim = val_expr['prim'] if prim == 'Pair': return tuple(micheline_value_to_python_object(x) for x in val_expr['args']) return micheline_to_michelson(val_expr)
def test_script_parsing_formatting(self): actual = michelson_to_micheline(micheline_to_michelson(self.script['code'])) self.assertEqual(self.script['code'], actual)
def to_michelson(self): """Get contract listing in formatted Michelson :return: string """ return micheline_to_michelson(self.to_micheline())
def to_python_object(self, try_unpack=False, lazy_diff=False, comparable=False): assert not comparable, f'{self.prim} is not comparable' return micheline_to_michelson(self.to_micheline_value())
def to_michelson(self, optimized=False): """Get as Michelson value :param optimized: use optimized data form for some domain types (timestamp, address, etc.) """ return micheline_to_michelson(self.to_micheline(optimized=optimized))