def execute(cls, stack: MichelsonStack, stdout: List[str],
context: AbstractContext):
a, b = cast(
Tuple[Union[IntType, NatType, MutezType, TimestampType,
BLS12_381_G1Type, BLS12_381_G2Type, BLS12_381_FrType],
...], stack.pop2())
res_type, = dispatch_types(
type(a),
type(b),
mapping={
(NatType, NatType): (NatType, ),
(NatType, IntType): (IntType, ),
(IntType, NatType): (IntType, ),
(IntType, IntType): (IntType, ),
(TimestampType, IntType): (TimestampType, ),
(IntType, TimestampType): (TimestampType, ),
(MutezType, MutezType): (MutezType, ),
(BLS12_381_FrType, BLS12_381_FrType): (BLS12_381_FrType, ),
(BLS12_381_G1Type, BLS12_381_G1Type): (BLS12_381_G1Type, ),
(BLS12_381_G2Type, BLS12_381_G2Type): (BLS12_381_G2Type, )
})
res_type = cast(
Union[Type[IntType], Type[NatType], Type[TimestampType],
Type[MutezType], Type[BLS12_381_G1Type],
Type[BLS12_381_G2Type], Type[BLS12_381_FrType]], res_type)
if issubclass(res_type, IntType):
res = res_type.from_value(int(a) + int(b)) # type: ignore
else:
res = res_type.from_point(bls12_381.add(
a.to_point(), b.to_point())) # type: ignore
stack.push(res)
stdout.append(format_stdout(cls.prim, [a, b], [res])) # type: ignore
return cls(stack_items_added=1)
def execute(cls, stack: MichelsonStack, stdout: List[str], context: AbstractContext):
key, src = cast(Tuple[MichelsonType, Union[SetType, MapType, BigMapType]], stack.pop2())
src.assert_type_in(MapType, BigMapType, SetType)
res = BoolType.from_value(src.contains(key))
stack.push(res)
stdout.append(format_stdout(cls.prim, [key, src], [res]))
return cls()
def execute(cls, stack: MichelsonStack, stdout: List[str],
context: AbstractContext):
a, b = stack.pop2()
stack.push(a)
stack.push(b)
stdout.append(format_stdout(cls.prim, [a, b], [b, a]))
return cls()
def execute(cls, stack: MichelsonStack, stdout: List[str], context: AbstractContext):
elt, lst = cast(Tuple[MichelsonType, ListType], stack.pop2())
lst.assert_type_in(ListType)
res = lst.prepend(elt)
stack.push(res)
stdout.append(format_stdout(cls.prim, [elt, lst], [res]))
return cls()
def execute(cls, stack: MichelsonStack, stdout: List[str],
context: AbstractContext):
a, b = cast(
Tuple[Union[IntType, NatType, MutezType, TimestampType], ...],
stack.pop2())
q_type, r_type = dispatch_types(
type(a),
type(b),
mapping={ # type: ignore
(NatType, NatType): (NatType, NatType),
(NatType, IntType): (IntType, NatType),
(IntType, NatType): (IntType, NatType),
(IntType, IntType): (IntType, NatType),
(MutezType, NatType): (MutezType, MutezType),
(MutezType, MutezType): (NatType, MutezType)
}
) # type: Union[Type[IntType], Type[NatType], Type[TimestampType], Type[MutezType]]
if int(b) == 0:
res = OptionType.none(PairType.create_type(args=[q_type, r_type]))
else:
q, r = divmod(int(a), int(b))
if r < 0:
r += abs(int(b))
q += 1
items = [q_type.from_value(q), r_type.from_value(r)]
res = OptionType.from_some(PairType.from_comb(items))
stack.push(res)
stdout.append(format_stdout(cls.prim, [a, b], [res])) # type: ignore
return cls(stack_items_added=1)
def execute(cls, stack: MichelsonStack, stdout: List[str],
context: AbstractContext):
left, right = stack.pop2()
res = PairType.from_comb([left, right])
stack.push(res)
stdout.append(format_stdout(cls.prim, [left, right],
[res])) # type: ignore
return cls(stack_items_added=1)
def execute(cls, stack: MichelsonStack, stdout: List[str], context: AbstractContext):
element, pair = cast(Tuple[MichelsonType, PairType], stack.pop2())
pair.assert_type_in(PairType)
index = cls.args[0].get_int()
res = pair.update_comb(index, element)
stack.push(res)
stdout.append(format_stdout(cls.prim, [element, pair], [res], index))
return cls()
def execute(cls, stack: MichelsonStack, stdout: List[str], context: AbstractContext):
item, amount = cast(Tuple[MichelsonType, NatType], stack.pop2())
amount.assert_type_equal(NatType)
address = context.get_self_address()
res = TicketType.create(address, item, int(amount))
stack.push(res)
stdout.append(format_stdout(cls.prim, [item, amount], [res]))
return cls()
def execute(cls, stack: MichelsonStack, stdout: List[str],
context: AbstractContext):
a, b = stack.pop2()
a.assert_type_equal(type(b))
res = IntType.from_value(compare(a, b))
stack.push(res)
stdout.append(format_stdout(cls.prim, [a, b], [res])) # type: ignore
return cls(stack_items_added=1)
def execute_boolean_add(prim: str, stack: MichelsonStack, stdout: List[str], add: Callable):
a, b = cast(Tuple[Union[BoolType, NatType], ...], stack.pop2())
res_type, convert = dispatch_types(type(a), type(b), mapping={
(BoolType, BoolType): (BoolType, bool),
(NatType, NatType): (NatType, int)
})
val = add((convert(a), convert(b)))
res = res_type.from_value(val)
stack.push(res)
stdout.append(format_stdout(prim, [a, b], [res]))
def execute_shift(prim: str, stack: MichelsonStack, stdout: List[str],
shift: Callable[[Tuple[int, int]], int]):
a, b = cast(Tuple[NatType, NatType], stack.pop2())
a.assert_type_equal(NatType)
b.assert_type_equal(NatType)
assert int(b) < 257, f'shift overflow {int(b)}, should not exceed 256'
c = shift((int(a), int(b)))
res = NatType.from_value(c)
stack.push(res)
stdout.append(format_stdout(prim, [a, b], [res]))
def execute(cls, stack: MichelsonStack, stdout: List[str], context: AbstractContext):
key, src = cast(Tuple[MichelsonType, Union[MapType, BigMapType]], stack.pop2())
src.assert_type_in(MapType, BigMapType)
val = src.get(key, dup=True)
if val is None:
res = OptionType.none(src.args[0])
else:
res = OptionType.from_some(val)
stack.push(res)
stdout.append(format_stdout(cls.prim, [key, src], [res]))
return cls()
def execute(cls, stack: MichelsonStack, stdout: List[str], context: AbstractContext):
a, b = cast(Tuple[Union[BoolType, NatType, IntType], ...], stack.pop2())
res_type, convert = dispatch_types(type(a), type(b), mapping={
(BoolType, BoolType): (BoolType, bool),
(NatType, NatType): (NatType, int),
(NatType, IntType): (NatType, int),
(IntType, NatType): (NatType, int),
})
res = res_type.from_value(convert(a) & convert(b))
stack.push(res)
stdout.append(format_stdout(cls.prim, [a, b], [res])) # type: ignore
return cls(stack_items_added=1)
def execute(cls, stack: MichelsonStack, stdout: List[str], context: AbstractContext):
param, lambda_ = cast(Tuple[MichelsonType, LambdaType], stack.pop2())
assert isinstance(lambda_, LambdaType), f'expected lambda, got {lambda_.prim}'
param.assert_type_equal(lambda_.args[0])
stdout.append(format_stdout(cls.prim, [param, lambda_], [])) # type: ignore
lambda_stack = MichelsonStack.from_items([param])
lambda_body = cast(MichelsonInstruction, lambda_.value)
item = lambda_body.execute(lambda_stack, stdout, context=context)
res = lambda_stack.pop1()
res.assert_type_equal(lambda_.args[1])
assert len(lambda_stack) == 0, f'lambda stack is not empty {lambda_stack}'
stack.push(res)
return cls(item)
def execute(cls, stack: MichelsonStack, stdout: List[str], context: AbstractContext):
ticket, amounts = cast(Tuple[TicketType, PairType], stack.pop2())
ticket.assert_type_in(TicketType)
amounts.assert_type_in(PairType)
a, b = tuple(amounts) # type: NatType, NatType
a.assert_type_equal(NatType)
b.assert_type_equal(NatType)
res = ticket.split(int(a), int(b))
if res is None:
res = OptionType.none(PairType.create_type(args=[type(ticket), type(ticket)]))
else:
res = OptionType.from_some(PairType.from_comb(list(res)))
stack.push(res)
stdout.append(format_stdout(cls.prim, [ticket, amounts], [res]))
return cls()
def execute(cls, stack: MichelsonStack, stdout: List[str], context: AbstractContext):
left, lambda_ = cast(Tuple[MichelsonType, LambdaType], stack.pop2())
lambda_.assert_type_in(LambdaType)
lambda_.args[0].assert_type_in(PairType)
left_type, right_type = lambda_.args[0].args
left.assert_type_equal(left_type)
new_value = MichelineSequence.create_type(args=[
PushInstruction.create_type(args=[left_type, left.to_literal()]),
PairInstruction,
lambda_.value
])
res = LambdaType.create_type(args=[right_type, lambda_.args[1]])(new_value) # type: ignore
stack.push(res)
stdout.append(format_stdout(cls.prim, [left, lambda_], [res])) # type: ignore
return cls(stack_items_added=1)
def execute(cls, stack: MichelsonStack, stdout: List[str],
context: AbstractContext):
a, b = cast(
Tuple[Union[IntType, NatType, MutezType, TimestampType], ...],
stack.pop2())
res_type, = dispatch_types(
type(a),
type(b),
mapping={ # type: ignore
(NatType, NatType): (IntType, ),
(NatType, IntType): (IntType, ),
(IntType, NatType): (IntType, ),
(IntType, IntType): (IntType, ),
(TimestampType, IntType): (TimestampType, ),
(TimestampType, TimestampType): (IntType, ),
(MutezType, MutezType): (MutezType, )
}
) # type: Union[Type[IntType], Type[NatType], Type[TimestampType], Type[MutezType]]
res = res_type.from_value(int(a) - int(b))
stack.push(res)
stdout.append(format_stdout(cls.prim, [a, b], [res])) # type: ignore
return cls(stack_items_added=1)
