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