From 495f621c15558f906c107b2f2f3ac08ac62926c2 Mon Sep 17 00:00:00 2001 From: "Sandeep.C.R" Date: Thu, 23 Nov 2023 20:39:53 +0530 Subject: [PATCH 01/10] MIR: Add Ticket type --- contrib/mir/src/ast.rs | 7 ++++++- contrib/mir/src/typechecker/type_props.rs | 7 +++++++ 2 files changed, 13 insertions(+), 1 deletion(-) diff --git a/contrib/mir/src/ast.rs b/contrib/mir/src/ast.rs index 0b0a36fbc024..ba987762bd60 100644 --- a/contrib/mir/src/ast.rs +++ b/contrib/mir/src/ast.rs @@ -85,6 +85,7 @@ pub enum Type { Signature, KeyHash, Lambda(Rc<(Type, Type)>), + Ticket(Box), } impl Type { @@ -96,7 +97,7 @@ impl Type { Nat | Int | Bool | Mutez | String | Unit | Never | Operation | Address | ChainId | Bytes | Key | Signature | KeyHash => 1, Pair(p) | Or(p) | Map(p) | Lambda(p) => 1 + p.0.size_for_gas() + p.1.size_for_gas(), - Option(x) | List(x) | Set(x) | Contract(x) => 1 + x.size_for_gas(), + Option(x) | List(x) | Set(x) | Contract(x) | Ticket(x) => 1 + x.size_for_gas(), } } @@ -128,6 +129,10 @@ impl Type { Self::Contract(Rc::new(ty)) } + pub fn new_ticket(ty: Self) -> Self { + Self::Ticket(Box::new(ty)) + } + pub fn new_lambda(ty1: Self, ty2: Self) -> Self { Self::Lambda(Rc::new((ty1, ty2))) } diff --git a/contrib/mir/src/typechecker/type_props.rs b/contrib/mir/src/typechecker/type_props.rs index 46234b5e2da0..344daf941ea9 100644 --- a/contrib/mir/src/typechecker/type_props.rs +++ b/contrib/mir/src/typechecker/type_props.rs @@ -43,6 +43,13 @@ impl Type { match self { Nat | Int | Bool | Mutez | String | Unit | Never | Address | ChainId | Bytes | Key | Signature | KeyHash => (), + Ticket(_) => match prop { + TypeProperty::Comparable + | TypeProperty::Pushable + | TypeProperty::Duplicable + | TypeProperty::Packable => return invalid_type_prop(), + TypeProperty::Passable | TypeProperty::Storable | TypeProperty::BigMapValue => (), + }, Operation => match prop { TypeProperty::Comparable | TypeProperty::Passable -- GitLab From 353328c7136811afa39b2ae816cc8bd8b139adaf Mon Sep 17 00:00:00 2001 From: "Sandeep.C.R" Date: Thu, 23 Nov 2023 21:10:18 +0530 Subject: [PATCH 02/10] MIR: Add prim for ticket type --- contrib/mir/src/parser.rs | 7 ++++++- contrib/mir/src/typechecker.rs | 9 +++++++++ 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/contrib/mir/src/parser.rs b/contrib/mir/src/parser.rs index 6ee1d1154edf..0af7585bcbef 100644 --- a/contrib/mir/src/parser.rs +++ b/contrib/mir/src/parser.rs @@ -12,8 +12,8 @@ use crate::lexer::{LexerError, Tok}; use crate::syntax; use lalrpop_util::ParseError; use logos::Logos; -use typed_arena::Arena; use macros::MacroError; +use typed_arena::Arena; #[derive(Debug, PartialEq, thiserror::Error)] pub enum ParserError { @@ -99,6 +99,11 @@ mod tests { ); } + #[test] + fn types() { + assert_eq!(parse("ticket").unwrap(), app!(ticket)); + } + #[test] fn pair_type() { assert_eq!( diff --git a/contrib/mir/src/typechecker.rs b/contrib/mir/src/typechecker.rs index e4ddb2ea1893..cfa89216f11a 100644 --- a/contrib/mir/src/typechecker.rs +++ b/contrib/mir/src/typechecker.rs @@ -319,6 +319,15 @@ fn parse_ty_with_entrypoints( App(chain_id, [], _) => Type::ChainId, App(chain_id, ..) => unexpected()?, + App(ticket, [t], _) => { + let t = parse_ty(ctx, t)?; + // NB: The inner type of ticket only needs to be comparable. + // See https://tezos.gitlab.io/michelson-reference/#type-ticket + t.ensure_prop(&mut ctx.gas, TypeProperty::Comparable)?; + Type::new_ticket(t) + } + App(ticket, ..) => unexpected()?, + App(pair, [ty1, ty2, rest @ ..], _) => make_pair(ctx, (ty1, ty2, rest))?, App(pair, ..) => unexpected()?, -- GitLab From 0b0f70e2af5d9cbf56fd38f819d3a5bda66a300d Mon Sep 17 00:00:00 2001 From: "Sandeep.C.R" Date: Thu, 23 Nov 2023 21:23:35 +0530 Subject: [PATCH 03/10] MIR: Adding value variant for ticket --- contrib/mir/src/ast.rs | 33 ++++++++++++++++++++++++++-- contrib/mir/src/ast/comparable.rs | 5 ++++- contrib/mir/src/gas.rs | 1 + contrib/mir/src/typechecker.rs | 36 +++++++++++++++++++++++++++++++ 4 files changed, 72 insertions(+), 3 deletions(-) diff --git a/contrib/mir/src/ast.rs b/contrib/mir/src/ast.rs index ba987762bd60..ec5f91f42fbe 100644 --- a/contrib/mir/src/ast.rs +++ b/contrib/mir/src/ast.rs @@ -61,6 +61,13 @@ pub struct OperationInfo<'a> { pub counter: u128, } +#[derive(Debug, Clone, Eq, PartialEq)] +pub struct Ticket<'a> { + pub ticketer: AddressHash, + pub content: TypedValue<'a>, + pub amount: BigUint, +} + #[derive(Debug, Clone, Eq, PartialEq)] pub enum Type { Nat, @@ -85,7 +92,7 @@ pub enum Type { Signature, KeyHash, Lambda(Rc<(Type, Type)>), - Ticket(Box), + Ticket(Rc), } impl Type { @@ -130,7 +137,7 @@ impl Type { } pub fn new_ticket(ty: Self) -> Self { - Self::Ticket(Box::new(ty)) + Self::Ticket(Rc::new(ty)) } pub fn new_lambda(ty1: Self, ty2: Self) -> Self { @@ -190,6 +197,11 @@ impl<'a> IntoMicheline<'a> for &'_ Type { Prim::contract, x.into_micheline_optimized_legacy(arena), ), + Ticket(x) => Micheline::prim1( + arena, + Prim::ticket, + x.into_micheline_optimized_legacy(arena), + ), Pair(_) => Micheline::App( Prim::pair, @@ -243,6 +255,7 @@ pub enum TypedValue<'a> { Lambda(Closure<'a>), KeyHash(KeyHash), Operation(Box>), + Ticket(Box>), } impl<'a> IntoMicheline<'a> for TypedValue<'a> { @@ -303,10 +316,22 @@ impl<'a> IntoMicheline<'a> for TypedValue<'a> { annotations::NO_ANNS, ), }, + TV::Ticket(t) => go(unwrap_ticket(t.as_ref().clone())), } } } +pub(crate) fn unwrap_ticket(t: Ticket) -> TypedValue { + use TypedValue as TV; + TV::new_pair( + TV::Address(Address { + hash: t.ticketer, + entrypoint: Entrypoint::default(), + }), + TV::new_pair(t.content, TV::Nat(t.amount)), + ) +} + impl<'a> TypedValue<'a> { pub fn new_pair(l: Self, r: Self) -> Self { Self::Pair(Box::new((l, r))) @@ -338,6 +363,10 @@ impl<'a> TypedValue<'a> { pub fn nat(n: u32) -> Self { Self::Nat(n.into()) } + + pub fn new_ticket(t: Ticket<'a>) -> Self { + Self::Ticket(Box::new(t)) + } } #[derive(Debug, Eq, PartialEq, Clone)] diff --git a/contrib/mir/src/ast/comparable.rs b/contrib/mir/src/ast/comparable.rs index 7fe5736792b8..97fc68571a0e 100644 --- a/contrib/mir/src/ast/comparable.rs +++ b/contrib/mir/src/ast/comparable.rs @@ -50,7 +50,10 @@ impl PartialOrd for TypedValue<'_> { (KeyHash(..), _) => None, // non-comparable types - (List(..) | Set(..) | Map(..) | Contract(..) | Operation(_) | Lambda(..), _) => None, + ( + List(..) | Set(..) | Map(..) | Contract(..) | Operation(_) | Ticket(_) | Lambda(..), + _, + ) => None, } } } diff --git a/contrib/mir/src/gas.rs b/contrib/mir/src/gas.rs index fb7ce26130e2..bfa922df16ba 100644 --- a/contrib/mir/src/gas.rs +++ b/contrib/mir/src/gas.rs @@ -433,6 +433,7 @@ pub mod interpret_cost { | V::Map(..) | V::Contract(_) | V::Operation(_) + | V::Ticket(_) | V::Lambda(_), _, ) => incomparable(), diff --git a/contrib/mir/src/typechecker.rs b/contrib/mir/src/typechecker.rs index cfa89216f11a..80a8cdc2eaef 100644 --- a/contrib/mir/src/typechecker.rs +++ b/contrib/mir/src/typechecker.rs @@ -1445,6 +1445,24 @@ pub(crate) fn typecheck_value<'a>( matches!(raw, V::App(Prim::Lambda_rec, ..)), )?)) } + (T::Ticket(c), m) => { + match typecheck_value( + m, + ctx, + &Type::new_pair(Type::Address, Type::new_pair(c.as_ref().clone(), Type::Nat)), + ) { + Ok(TV::Pair(b)) => { + let address = irrefutable_match!(b.0; TV::Address); + let c = irrefutable_match!(b.1; TV::Pair); + TV::new_ticket(Ticket { + ticketer: address.hash, + content: c.0, + amount: irrefutable_match!(c.1; TV::Nat), + }) + } + _ => return Err(TcError::InvalidValueForType(format!("{v:?}"), t.clone())), + } + } (t, v) => return Err(TcError::InvalidValueForType(format!("{v:?}"), t.clone())), }) } @@ -4660,6 +4678,24 @@ mod typecheck_tests { ); } + #[test] + fn typecheck_forged_ticket() { + let mut ctx = Ctx::default(); + let ticket: super::Ticket = super::Ticket { + ticketer: AddressHash::try_from("tz1T1K14rZ46m1GT1kPVwZWkSHxNSDZgM71h").unwrap(), + content: TypedValue::Unit, + amount: 5u32.into(), + }; + assert_eq!( + typecheck_value( + &parse("Pair \"tz1T1K14rZ46m1GT1kPVwZWkSHxNSDZgM71h\" (Pair Unit 5)").unwrap(), + &mut ctx, + &Type::new_ticket(Type::Unit) + ), + Ok(TypedValue::new_ticket(ticket)) + ); + } + #[test] fn hash_key() { let stk = &mut tc_stk![Type::Key]; -- GitLab From 3edadefb4ad9b129a994fcfa607d3ec0c035bb41 Mon Sep 17 00:00:00 2001 From: "Sandeep.C.R" Date: Tue, 28 Nov 2023 00:03:55 +0530 Subject: [PATCH 04/10] MIR: Add TICKET instruction --- contrib/mir/src/ast.rs | 1 + contrib/mir/src/gas.rs | 1 + contrib/mir/src/interpreter.rs | 36 +++++++++++++++++++++++++++++++++ contrib/mir/src/typechecker.rs | 37 +++++++++++++++++++++++++++++++--- 4 files changed, 72 insertions(+), 3 deletions(-) diff --git a/contrib/mir/src/ast.rs b/contrib/mir/src/ast.rs index ec5f91f42fbe..01a2e41f17e7 100644 --- a/contrib/mir/src/ast.rs +++ b/contrib/mir/src/ast.rs @@ -424,6 +424,7 @@ pub enum Instruction<'a> { Right, Lambda(Lambda<'a>), Exec, + Ticket, HashKey, Apply { arg_ty: Type, diff --git a/contrib/mir/src/gas.rs b/contrib/mir/src/gas.rs index bfa922df16ba..8e15fba7d7d5 100644 --- a/contrib/mir/src/gas.rs +++ b/contrib/mir/src/gas.rs @@ -251,6 +251,7 @@ pub mod interpret_cost { // depending on whether a lambda is recursive; here this distinction doesn't // make a lot of sense. pub const APPLY: u32 = 140; + pub const TICKET: u32 = 10; pub const INTERPRET_RET: u32 = 15; // corresponds to KNil in the Tezos protocol pub const LOOP_ENTER: u32 = 10; // corresponds to KLoop_in in the Tezos protocol diff --git a/contrib/mir/src/interpreter.rs b/contrib/mir/src/interpreter.rs index bab31a72f8a4..80170116d3ba 100644 --- a/contrib/mir/src/interpreter.rs +++ b/contrib/mir/src/interpreter.rs @@ -777,6 +777,23 @@ fn interpret_one<'a>( let key = pop!(V::Key); stack.push(TypedValue::KeyHash(key.hash())) } + I::Ticket => { + let content = pop!(); + let amount = pop!(V::Nat); + ctx.gas.consume(interpret_cost::TICKET)?; + if amount.is_zero() { + // If the amount is zero, then we push a None value + // as per the specified instruction behavior. + stack.push(V::new_option(None)); + } else { + let ticket = Ticket { + ticketer: ctx.self_address.clone(), + content, + amount, + }; + stack.push(V::new_option(Some(V::new_ticket(ticket)))); + } + } I::Seq(nested) => interpret(nested, ctx, stack)?, } Ok(()) @@ -2543,6 +2560,25 @@ mod interpreter_tests { ); } + #[test] + fn ticket() { + let mut stack = stk![V::nat(100), TypedValue::Unit]; + let mut ctx = Ctx::default(); + let expected_ticket = V::new_ticket(crate::ast::Ticket { + ticketer: ctx.self_address.clone(), + amount: 100u32.into(), + content: V::Unit, + }); + + let start_milligas = ctx.gas.milligas(); + assert_eq!(interpret(&[Ticket], &mut ctx, &mut stack), Ok(())); + assert_eq!(stack, stk![V::new_option(Some(expected_ticket))]); + assert_eq!( + start_milligas - ctx.gas.milligas(), + interpret_cost::TICKET + interpret_cost::INTERPRET_RET + ); + } + #[test] fn exec() { let mut stack = stk![ diff --git a/contrib/mir/src/typechecker.rs b/contrib/mir/src/typechecker.rs index 80a8cdc2eaef..eb5aca1e6ac7 100644 --- a/contrib/mir/src/typechecker.rs +++ b/contrib/mir/src/typechecker.rs @@ -490,9 +490,9 @@ pub(crate) fn typecheck_instruction<'a>( macro_rules! pop { ($($args:tt)*) => { irrefutable_match!( - stack.pop().expect("pop from empty stack!"); - $($args)* - ) + stack.pop().expect("pop from empty stack!"); + $($args)* + ) }; } @@ -1253,6 +1253,14 @@ pub(crate) fn typecheck_instruction<'a>( (App(APPLY, [], _), [] | [_]) => no_overload!(APPLY, len 2), (App(APPLY, expect_args!(0), _), _) => unexpected_micheline!(), + (App(TICKET, [], _), [.., T::Nat, _]) => { + stack[0] = T::new_option(T::new_ticket(pop!())); + I::Ticket + } + (App(TICKET, [], _), [.., _, _]) => no_overload!(TICKET), + (App(TICKET, [], _), [] | [_]) => no_overload!(TICKET, len 2), + (App(TICKET, expect_args!(0), _), _) => unexpected_micheline!(), + (App(other, ..), _) => todo!("Unhandled instruction {other}"), (Seq(nested), _) => I::Seq(typecheck(nested, ctx, self_entrypoints, opt_stack)?), @@ -4696,6 +4704,29 @@ mod typecheck_tests { ); } + #[test] + fn ticket() { + let stk = &mut tc_stk![Type::Nat]; + assert_eq!( + typecheck_instruction(&parse("TICKET").unwrap(), &mut Ctx::default(), stk), + Err(TcError::NoMatchingOverload { + instr: Prim::TICKET, + stack: stk![Type::Nat], + reason: Some(NoMatchingOverloadReason::StackTooShort { expected: 2 }) + }) + ); + + let stk = &mut tc_stk![Type::Nat, Type::Unit]; + assert_eq!( + typecheck_instruction(&parse("TICKET").unwrap(), &mut Ctx::default(), stk), + Ok(Instruction::Ticket) + ); + assert_eq!( + stk, + &tc_stk![Type::new_option(Type::new_ticket(Type::Unit))] + ); + } + #[test] fn hash_key() { let stk = &mut tc_stk![Type::Key]; -- GitLab From 48cdb5a4c3fdccce2fc14255cedf4400d8ee4bd6 Mon Sep 17 00:00:00 2001 From: "Sandeep.C.R" Date: Fri, 24 Nov 2023 16:53:10 +0530 Subject: [PATCH 05/10] MIR: Add READ_TICKET --- contrib/mir/src/ast.rs | 1 + contrib/mir/src/gas.rs | 1 + contrib/mir/src/interpreter.rs | 38 +++++++++++++++++++++++++++++++++ contrib/mir/src/typechecker.rs | 39 ++++++++++++++++++++++++++++++++++ 4 files changed, 79 insertions(+) diff --git a/contrib/mir/src/ast.rs b/contrib/mir/src/ast.rs index 01a2e41f17e7..e07f63572657 100644 --- a/contrib/mir/src/ast.rs +++ b/contrib/mir/src/ast.rs @@ -429,6 +429,7 @@ pub enum Instruction<'a> { Apply { arg_ty: Type, }, + ReadTicket, } #[derive(Debug, Clone, PartialEq, Eq)] diff --git a/contrib/mir/src/gas.rs b/contrib/mir/src/gas.rs index 8e15fba7d7d5..ac1bc2c31aae 100644 --- a/contrib/mir/src/gas.rs +++ b/contrib/mir/src/gas.rs @@ -252,6 +252,7 @@ pub mod interpret_cost { // make a lot of sense. pub const APPLY: u32 = 140; pub const TICKET: u32 = 10; + pub const READ_TICKET: u32 = 10; pub const INTERPRET_RET: u32 = 15; // corresponds to KNil in the Tezos protocol pub const LOOP_ENTER: u32 = 10; // corresponds to KLoop_in in the Tezos protocol diff --git a/contrib/mir/src/interpreter.rs b/contrib/mir/src/interpreter.rs index 80170116d3ba..006c36012f2c 100644 --- a/contrib/mir/src/interpreter.rs +++ b/contrib/mir/src/interpreter.rs @@ -794,6 +794,12 @@ fn interpret_one<'a>( stack.push(V::new_option(Some(V::new_ticket(ticket)))); } } + I::ReadTicket => { + ctx.gas.consume(interpret_cost::READ_TICKET)?; + stack.push(unwrap_ticket( + irrefutable_match!(&stack[0]; V::Ticket).as_ref().clone(), + )); + } I::Seq(nested) => interpret(nested, ctx, stack)?, } Ok(()) @@ -2579,6 +2585,38 @@ mod interpreter_tests { ); } + #[test] + fn read_ticket() { + let mut ctx = Ctx::default(); + let ticket = crate::ast::Ticket { + ticketer: ctx.self_address.clone(), + amount: 100u32.into(), + content: V::Unit, + }; + let ticket_val = V::new_ticket(ticket.clone()); + let mut stack = stk![ticket_val.clone()]; + let start_milligas = ctx.gas.milligas(); + assert_eq!(interpret(&[ReadTicket], &mut ctx, &mut stack), Ok(())); + let ticketer_address = super::Address { + hash: ticket.ticketer, + entrypoint: Entrypoint::default(), + }; + assert_eq!( + stack, + stk![ + ticket_val, + V::new_pair( + V::Address(ticketer_address), + V::new_pair(V::Unit, V::nat(100)) + ), + ] + ); + assert_eq!( + start_milligas - ctx.gas.milligas(), + interpret_cost::READ_TICKET + interpret_cost::INTERPRET_RET + ); + } + #[test] fn exec() { let mut stack = stk![ diff --git a/contrib/mir/src/typechecker.rs b/contrib/mir/src/typechecker.rs index eb5aca1e6ac7..795fe2a0aaec 100644 --- a/contrib/mir/src/typechecker.rs +++ b/contrib/mir/src/typechecker.rs @@ -1261,6 +1261,17 @@ pub(crate) fn typecheck_instruction<'a>( (App(TICKET, [], _), [] | [_]) => no_overload!(TICKET, len 2), (App(TICKET, expect_args!(0), _), _) => unexpected_micheline!(), + (App(READ_TICKET, [], _), [.., T::Ticket(t)]) => { + stack.push(T::new_pair( + T::Address, + T::new_pair(t.as_ref().clone(), T::Nat), + )); + I::ReadTicket + } + (App(READ_TICKET, [], _), [.., _]) => no_overload!(READ_TICKET), + (App(READ_TICKET, [], _), []) => no_overload!(READ_TICKET, len 1), + (App(READ_TICKET, expect_args!(0), _), _) => unexpected_micheline!(), + (App(other, ..), _) => todo!("Unhandled instruction {other}"), (Seq(nested), _) => I::Seq(typecheck(nested, ctx, self_entrypoints, opt_stack)?), @@ -4727,6 +4738,34 @@ mod typecheck_tests { ); } + #[test] + fn read_ticket() { + let stk = &mut tc_stk![Type::Nat]; + assert_eq!( + typecheck_instruction(&parse("READ_TICKET").unwrap(), &mut Ctx::default(), stk), + Err(TcError::NoMatchingOverload { + instr: Prim::READ_TICKET, + stack: stk![Type::Nat], + reason: None + }) + ); + + let test_ticket = Type::new_ticket(Type::Int); + let stk = &mut tc_stk![test_ticket.clone()]; + let mut ctx = Ctx::default(); + assert_eq!( + typecheck_instruction(&parse("READ_TICKET").unwrap(), &mut ctx, stk), + Ok(ReadTicket) + ); + assert_eq!( + stk, + &tc_stk![ + test_ticket, + Type::new_pair(Type::Address, Type::new_pair(Type::Int, Type::Nat)), + ] + ); + } + #[test] fn hash_key() { let stk = &mut tc_stk![Type::Key]; -- GitLab From 82bc989116183109dc68a97ebb5ed3fd7d737122 Mon Sep 17 00:00:00 2001 From: "Sandeep.C.R" Date: Sat, 25 Nov 2023 01:09:20 +0530 Subject: [PATCH 06/10] MIR: Add SPLIT_TICKET --- contrib/mir/src/ast.rs | 1 + contrib/mir/src/gas.rs | 6 +++ contrib/mir/src/interpreter.rs | 82 ++++++++++++++++++++++++++++++++++ contrib/mir/src/typechecker.rs | 48 ++++++++++++++++++++ 4 files changed, 137 insertions(+) diff --git a/contrib/mir/src/ast.rs b/contrib/mir/src/ast.rs index e07f63572657..1295f300dfda 100644 --- a/contrib/mir/src/ast.rs +++ b/contrib/mir/src/ast.rs @@ -430,6 +430,7 @@ pub enum Instruction<'a> { arg_ty: Type, }, ReadTicket, + SplitTicket, } #[derive(Debug, Clone, PartialEq, Eq)] diff --git a/contrib/mir/src/gas.rs b/contrib/mir/src/gas.rs index ac1bc2c31aae..e88edbaa3b35 100644 --- a/contrib/mir/src/gas.rs +++ b/contrib/mir/src/gas.rs @@ -258,6 +258,12 @@ pub mod interpret_cost { pub const LOOP_ENTER: u32 = 10; // corresponds to KLoop_in in the Tezos protocol pub const LOOP_EXIT: u32 = 10; + pub fn split_ticket(amount1: &BigUint, amount2: &BigUint) -> Result { + use std::mem::size_of_val; + let sz = Checked::from(std::cmp::max(size_of_val(amount1), size_of_val(amount2))); + (40 + (sz >> 1)).as_gas_cost() + } + fn dropn(n: u16) -> Result { // Approximates 30 + 2.713108*n, copied from the Tezos protocol let n = Checked::from(n as u32); diff --git a/contrib/mir/src/interpreter.rs b/contrib/mir/src/interpreter.rs index 006c36012f2c..cf2a3d6d9e3d 100644 --- a/contrib/mir/src/interpreter.rs +++ b/contrib/mir/src/interpreter.rs @@ -5,6 +5,8 @@ /* */ /******************************************************************************/ +#![warn(clippy::redundant_clone)] + use checked::Checked; use num_bigint::{BigInt, BigUint}; use num_traits::{Signed, Zero}; @@ -800,6 +802,32 @@ fn interpret_one<'a>( irrefutable_match!(&stack[0]; V::Ticket).as_ref().clone(), )); } + I::SplitTicket => { + let ticket = *pop!(V::Ticket); + let amounts = pop!(V::Pair); + let amount_left = irrefutable_match!(amounts.0; V::Nat); + let amount_right = irrefutable_match!(amounts.1; V::Nat); + + ctx.gas + .consume(interpret_cost::split_ticket(&amount_left, &amount_right)?)?; + if amount_left.clone() + amount_right.clone() == ticket.amount + && amount_left.gt(&BigUint::zero()) + && amount_right.gt(&BigUint::zero()) + { + stack.push(V::new_option(Some(V::new_pair( + V::new_ticket(Ticket { + amount: amount_left, + ..ticket.clone() + }), + V::new_ticket(Ticket { + amount: amount_right, + ..ticket + }), + )))); + } else { + stack.push(V::new_option(None)); + } + } I::Seq(nested) => interpret(nested, ctx, stack)?, } Ok(()) @@ -2843,4 +2871,58 @@ mod interpreter_tests { ); assert_eq!(stack, stk![TypedValue::nat(5)]); } + + #[test] + fn split_ticket() { + let mut ctx = Ctx::default(); + let ticket = crate::ast::Ticket { + ticketer: ctx.self_address.clone(), + amount: 100u32.into(), + content: V::Unit, + }; + let ticket_val = V::new_ticket(ticket.clone()); + let mut stack = stk![V::new_pair(V::nat(20), V::nat(80)), ticket_val.clone(),]; + + let start_milligas = ctx.gas.milligas(); + assert_eq!(interpret(&[SplitTicket], &mut ctx, &mut stack), Ok(())); + + let ticket_exp_left = crate::ast::Ticket { + amount: 20u32.into(), + ..ticket.clone() + }; + + let ticket_exp_right = crate::ast::Ticket { + amount: 80u32.into(), + ..ticket + }; + assert_eq!( + stack, + stk![V::new_option(Some(V::new_pair( + V::new_ticket(ticket_exp_left.clone()), + V::new_ticket(ticket_exp_right.clone()), + ))),] + ); + assert_eq!( + start_milligas - ctx.gas.milligas(), + interpret_cost::split_ticket(&ticket_exp_left.amount, &ticket_exp_right.amount) + .unwrap() + + interpret_cost::INTERPRET_RET + ); + + // When one of the amounts is zero + let mut stack = stk![V::new_pair(V::nat(0), V::nat(100)), ticket_val.clone(),]; + assert_eq!(interpret_one(&SplitTicket, &mut ctx, &mut stack), Ok(())); + + assert_eq!(stack, stk![V::new_option(None),]); + + // When one of the amounts is zero + let mut stack = stk![V::new_pair(V::nat(100), V::nat(0)), ticket_val.clone(),]; + assert_eq!(interpret_one(&SplitTicket, &mut ctx, &mut stack), Ok(())); + + // When sum of the amounts is larger than original ticekt + let mut stack = stk![V::new_pair(V::nat(70), V::nat(80)), ticket_val]; + assert_eq!(interpret_one(&SplitTicket, &mut ctx, &mut stack), Ok(())); + + assert_eq!(stack, stk![V::new_option(None),]); + } } diff --git a/contrib/mir/src/typechecker.rs b/contrib/mir/src/typechecker.rs index 795fe2a0aaec..adaf7afa54c9 100644 --- a/contrib/mir/src/typechecker.rs +++ b/contrib/mir/src/typechecker.rs @@ -1272,6 +1272,17 @@ pub(crate) fn typecheck_instruction<'a>( (App(READ_TICKET, [], _), []) => no_overload!(READ_TICKET, len 1), (App(READ_TICKET, expect_args!(0), _), _) => unexpected_micheline!(), + (App(SPLIT_TICKET, [], _), [.., T::Pair(n), T::Ticket(_)]) + if matches!(n.as_ref(), (T::Nat, T::Nat)) => + { + let typ = pop!(); + stack[0] = Type::new_option(Type::new_pair(typ.clone(), typ)); + I::SplitTicket + } + (App(SPLIT_TICKET, [], _), [.., _, _]) => no_overload!(SPLIT_TICKET), + (App(SPLIT_TICKET, [], _), [] | [_]) => no_overload!(SPLIT_TICKET, len 2), + (App(SPLIT_TICKET, expect_args!(0), _), _) => unexpected_micheline!(), + (App(other, ..), _) => todo!("Unhandled instruction {other}"), (Seq(nested), _) => I::Seq(typecheck(nested, ctx, self_entrypoints, opt_stack)?), @@ -4766,6 +4777,43 @@ mod typecheck_tests { ); } + #[test] + fn split_ticket() { + let stk = &mut tc_stk![Type::Nat]; + assert_eq!( + typecheck_instruction(&parse("SPLIT_TICKET").unwrap(), &mut Ctx::default(), stk), + Err(TcError::NoMatchingOverload { + instr: Prim::SPLIT_TICKET, + stack: stk![Type::Nat], + reason: Some(NoMatchingOverloadReason::StackTooShort { expected: 2 }) + }) + ); + let stk = &mut tc_stk![Type::Nat, Type::Nat]; + assert_eq!( + typecheck_instruction(&parse("SPLIT_TICKET").unwrap(), &mut Ctx::default(), stk), + Err(TcError::NoMatchingOverload { + instr: Prim::SPLIT_TICKET, + stack: stk![Type::Nat, Type::Nat], + reason: None + }) + ); + let stk = &mut tc_stk![ + Type::new_pair(Type::Nat, Type::Nat), + Type::new_ticket(Type::Unit) + ]; + assert_eq!( + typecheck_instruction(&parse("SPLIT_TICKET").unwrap(), &mut Ctx::default(), stk), + Ok(SplitTicket) + ); + assert_eq!( + stk, + &tc_stk![Type::new_option(Type::new_pair( + Type::new_ticket(Type::Unit), + Type::new_ticket(Type::Unit) + ))] + ); + } + #[test] fn hash_key() { let stk = &mut tc_stk![Type::Key]; -- GitLab From 01583ed8e4af3afbcc434bd4866896f83cfbb8f9 Mon Sep 17 00:00:00 2001 From: "Sandeep.C.R" Date: Wed, 13 Dec 2023 06:36:47 +0530 Subject: [PATCH 07/10] MIR: Add JOIN_TICKETS --- contrib/mir/src/ast.rs | 1 + contrib/mir/src/gas.rs | 7 ++- contrib/mir/src/interpreter.rs | 101 +++++++++++++++++++++++++++++++-- contrib/mir/src/typechecker.rs | 60 ++++++++++++++++++++ 4 files changed, 163 insertions(+), 6 deletions(-) diff --git a/contrib/mir/src/ast.rs b/contrib/mir/src/ast.rs index 1295f300dfda..4c0ff0c49286 100644 --- a/contrib/mir/src/ast.rs +++ b/contrib/mir/src/ast.rs @@ -431,6 +431,7 @@ pub enum Instruction<'a> { }, ReadTicket, SplitTicket, + JoinTickets, } #[derive(Debug, Clone, PartialEq, Eq)] diff --git a/contrib/mir/src/gas.rs b/contrib/mir/src/gas.rs index e88edbaa3b35..f0cc30f597a8 100644 --- a/contrib/mir/src/gas.rs +++ b/contrib/mir/src/gas.rs @@ -201,7 +201,7 @@ pub mod interpret_cost { use num_bigint::BigUint; use super::{AsGasCost, BigIntByteSize, OutOfGas}; - use crate::ast::{Key, KeyHash, Micheline, Or, TypedValue}; + use crate::ast::{Key, KeyHash, Micheline, Or, Ticket, TypedValue}; pub const DIP: u32 = 10; pub const DROP: u32 = 10; @@ -258,6 +258,11 @@ pub mod interpret_cost { pub const LOOP_ENTER: u32 = 10; // corresponds to KLoop_in in the Tezos protocol pub const LOOP_EXIT: u32 = 10; + pub fn join_tickets(t1: &Ticket, t2: &Ticket) -> Result { + compare(&t1.content, &t2.content)?; + add_num(&t1.amount, &t2.amount) + } + pub fn split_ticket(amount1: &BigUint, amount2: &BigUint) -> Result { use std::mem::size_of_val; let sz = Checked::from(std::cmp::max(size_of_val(amount1), size_of_val(amount2))); diff --git a/contrib/mir/src/interpreter.rs b/contrib/mir/src/interpreter.rs index cf2a3d6d9e3d..0438da7488f4 100644 --- a/contrib/mir/src/interpreter.rs +++ b/contrib/mir/src/interpreter.rs @@ -828,6 +828,21 @@ fn interpret_one<'a>( stack.push(V::new_option(None)); } } + I::JoinTickets => { + let tickets = pop!(V::Pair); + let mut ticket_left = irrefutable_match!(tickets.0; V::Ticket); + let ticket_right = irrefutable_match!(tickets.1; V::Ticket); + ctx.gas + .consume(interpret_cost::join_tickets(&ticket_left, &ticket_right)?)?; + if ticket_left.content == ticket_right.content + && ticket_left.ticketer == ticket_right.ticketer + { + ticket_left.amount += ticket_right.amount; + stack.push(V::new_option(Some(TypedValue::Ticket(ticket_left)))); + } else { + stack.push(V::new_option(None)); + } + } I::Seq(nested) => interpret(nested, ctx, stack)?, } Ok(()) @@ -2615,8 +2630,10 @@ mod interpreter_tests { #[test] fn read_ticket() { + use crate::ast::Ticket; + let mut ctx = Ctx::default(); - let ticket = crate::ast::Ticket { + let ticket = Ticket { ticketer: ctx.self_address.clone(), amount: 100u32.into(), content: V::Unit, @@ -2874,8 +2891,11 @@ mod interpreter_tests { #[test] fn split_ticket() { + use crate::ast::Ticket; + + // Test successful execution let mut ctx = Ctx::default(); - let ticket = crate::ast::Ticket { + let ticket = Ticket { ticketer: ctx.self_address.clone(), amount: 100u32.into(), content: V::Unit, @@ -2886,12 +2906,12 @@ mod interpreter_tests { let start_milligas = ctx.gas.milligas(); assert_eq!(interpret(&[SplitTicket], &mut ctx, &mut stack), Ok(())); - let ticket_exp_left = crate::ast::Ticket { + let ticket_exp_left = Ticket { amount: 20u32.into(), ..ticket.clone() }; - let ticket_exp_right = crate::ast::Ticket { + let ticket_exp_right = Ticket { amount: 80u32.into(), ..ticket }; @@ -2912,17 +2932,88 @@ mod interpreter_tests { // When one of the amounts is zero let mut stack = stk![V::new_pair(V::nat(0), V::nat(100)), ticket_val.clone(),]; assert_eq!(interpret_one(&SplitTicket, &mut ctx, &mut stack), Ok(())); - assert_eq!(stack, stk![V::new_option(None),]); // When one of the amounts is zero let mut stack = stk![V::new_pair(V::nat(100), V::nat(0)), ticket_val.clone(),]; assert_eq!(interpret_one(&SplitTicket, &mut ctx, &mut stack), Ok(())); + assert_eq!(stack, stk![V::new_option(None),]); // When sum of the amounts is larger than original ticekt let mut stack = stk![V::new_pair(V::nat(70), V::nat(80)), ticket_val]; assert_eq!(interpret_one(&SplitTicket, &mut ctx, &mut stack), Ok(())); + assert_eq!(stack, stk![V::new_option(None),]); + } + #[test] + fn join_tickets() { + use crate::ast::Ticket; + + // Test successful execution + let mut ctx = Ctx::default(); + let ticket = Ticket { + ticketer: ctx.self_address.clone(), + amount: 100u32.into(), + content: V::nat(10), + }; + let ticket_left = V::new_ticket(ticket.clone()); + let ticket_right_ = Ticket { + amount: 20u32.into(), + ..ticket.clone() + }; + let ticket_right = V::new_ticket(ticket_right_.clone()); + let mut stack = stk![V::new_pair(ticket_left, ticket_right),]; + let start_milligas = ctx.gas.milligas(); + assert_eq!(interpret(&[JoinTickets], &mut ctx, &mut stack), Ok(())); + assert_eq!( + start_milligas - ctx.gas.milligas(), + interpret_cost::join_tickets(&ticket, &ticket_right_).unwrap() + + interpret_cost::INTERPRET_RET + ); + + let ticket_result = Ticket { + amount: 120u32.into(), + ..ticket + }; + + assert_eq!( + stack, + stk![V::new_option(Some(V::new_ticket(ticket_result))),] + ); + + // When content is different + let mut ctx = Ctx::default(); + let ticket = Ticket { + ticketer: ctx.self_address.clone(), + amount: 100u32.into(), + content: V::nat(10), + }; + let ticket_left = V::new_ticket(ticket.clone()); + let ticket_right = V::new_ticket(Ticket { + amount: 20u32.into(), + content: V::nat(20), + ..ticket + }); + let mut stack = stk![V::new_pair(ticket_left, ticket_right),]; + assert_eq!(interpret_one(&JoinTickets, &mut ctx, &mut stack), Ok(())); + assert_eq!(stack, stk![V::new_option(None),]); + + // When Ticketer is different + use crate::interpreter::AddressHash; + let mut ctx = Ctx::default(); + let ticket = Ticket { + ticketer: AddressHash::try_from("KT1BRd2ka5q2cPRdXALtXD1QZ38CPam2j1ye").unwrap(), + amount: 100u32.into(), + content: V::nat(10), + }; + let ticket_left = V::new_ticket(ticket.clone()); + let ticket_right = V::new_ticket(Ticket { + amount: 20u32.into(), + ticketer: AddressHash::try_from("KT18amZmM5W7qDWVt2pH6uj7sCEd3kbzLrHT").unwrap(), + ..ticket + }); + let mut stack = stk![V::new_pair(ticket_left, ticket_right),]; + assert_eq!(interpret_one(&JoinTickets, &mut ctx, &mut stack), Ok(())); assert_eq!(stack, stk![V::new_option(None),]); } } diff --git a/contrib/mir/src/typechecker.rs b/contrib/mir/src/typechecker.rs index adaf7afa54c9..a260dd8acad1 100644 --- a/contrib/mir/src/typechecker.rs +++ b/contrib/mir/src/typechecker.rs @@ -1283,6 +1283,20 @@ pub(crate) fn typecheck_instruction<'a>( (App(SPLIT_TICKET, [], _), [] | [_]) => no_overload!(SPLIT_TICKET, len 2), (App(SPLIT_TICKET, expect_args!(0), _), _) => unexpected_micheline!(), + (App(JOIN_TICKETS, [], _), [.., T::Pair(tickets)]) + if matches!(tickets.as_ref(), (Type::Ticket(_), Type::Ticket(_))) => + { + let lt = irrefutable_match!(&tickets.0; Type::Ticket); + let rt = irrefutable_match!(&tickets.1; Type::Ticket); + + ensure_ty_eq(ctx, lt, rt)?; + stack[0] = Type::new_option(tickets.0.clone()); + I::JoinTickets + } + (App(JOIN_TICKETS, [], _), [.., _]) => no_overload!(JOIN_TICKETS), + (App(JOIN_TICKETS, [], _), []) => no_overload!(JOIN_TICKETS, len 1), + (App(JOIN_TICKETS, expect_args!(0), _), _) => unexpected_micheline!(), + (App(other, ..), _) => todo!("Unhandled instruction {other}"), (Seq(nested), _) => I::Seq(typecheck(nested, ctx, self_entrypoints, opt_stack)?), @@ -4814,6 +4828,52 @@ mod typecheck_tests { ); } + #[test] + fn join_tickets() { + let stk = &mut tc_stk![Type::Nat]; + assert_eq!( + typecheck_instruction(&parse("JOIN_TICKETS").unwrap(), &mut Ctx::default(), stk), + Err(TcError::NoMatchingOverload { + instr: Prim::JOIN_TICKETS, + stack: stk![Type::Nat], + reason: None + }) + ); + + let stk = &mut tc_stk![]; + assert_eq!( + typecheck_instruction(&parse("JOIN_TICKETS").unwrap(), &mut Ctx::default(), stk), + Err(TcError::NoMatchingOverload { + instr: Prim::JOIN_TICKETS, + stack: stk![], + reason: Some(NoMatchingOverloadReason::StackTooShort { expected: 1 }) + }) + ); + + let stk = &mut tc_stk![Type::new_pair( + Type::new_ticket(Type::Int), + Type::new_ticket(Type::Unit) + )]; + assert_eq!( + typecheck_instruction(&parse("JOIN_TICKETS").unwrap(), &mut Ctx::default(), stk), + Err(TcError::TypesNotEqual(TypesNotEqual(Type::Int, Type::Unit))) + ); + + let stk = &mut tc_stk![Type::new_pair( + Type::new_ticket(Type::Unit), + Type::new_ticket(Type::Unit) + )]; + assert_eq!( + typecheck_instruction(&parse("JOIN_TICKETS").unwrap(), &mut Ctx::default(), stk), + Ok(JoinTickets) + ); + + assert_eq!( + stk, + &tc_stk![Type::new_option(Type::new_ticket(Type::Unit))] + ); + } + #[test] fn hash_key() { let stk = &mut tc_stk![Type::Key]; -- GitLab From 53e28ae17b096f004221606abc3f05adff628df0 Mon Sep 17 00:00:00 2001 From: "Sandeep.C.R" Date: Wed, 13 Dec 2023 06:37:02 +0530 Subject: [PATCH 08/10] MIR: Add integration tests --- contrib/mir/src/lib.rs | 140 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 140 insertions(+) diff --git a/contrib/mir/src/lib.rs b/contrib/mir/src/lib.rs index 9c786a7e2327..bd82f09ddecd 100644 --- a/contrib/mir/src/lib.rs +++ b/contrib/mir/src/lib.rs @@ -245,6 +245,146 @@ mod tests { }; } + use crate::stack::{FailingTypeStack, Stack, TypeStack}; + use crate::typechecker::typecheck_instruction; + + fn run_e2e_test<'a>( + instr: &'a str, + input_type_stack: TypeStack, + output_type_stack: TypeStack, + mut input_stack: Stack>, + output_stack: Stack>, + mut ctx: Ctx, + ) { + let ast = parse(instr).unwrap(); + let mut input_failing_type_stack = FailingTypeStack::Ok(input_type_stack); + let ast = + typecheck_instruction(&ast, &mut ctx, None, &mut input_failing_type_stack).unwrap(); + assert_eq!( + input_failing_type_stack, + FailingTypeStack::Ok(output_type_stack) + ); + assert!(ast.interpret(&mut ctx, &mut input_stack).is_ok()); + assert_eq!(input_stack, output_stack); + } + + #[test] + fn ticket_instr() { + let ctx = Ctx::default(); + run_e2e_test( + "TICKET", + stk![Type::Nat, Type::Int], + stk![Type::new_option(Type::new_ticket(Type::Int))], + stk![TypedValue::nat(10), TypedValue::int(20)], + stk![TypedValue::new_option(Some(TypedValue::new_ticket( + Ticket { + amount: 10u32.into(), + content: TypedValue::int(20), + ticketer: ctx.self_address + } + )))], + Ctx::default(), + ); + } + + #[test] + fn read_ticket() { + let ticketer_address_hash = + AddressHash::try_from("KT1BRd2ka5q2cPRdXALtXD1QZ38CPam2j1ye").unwrap(); + let ticketer_address = Address { + hash: ticketer_address_hash.clone(), + entrypoint: Entrypoint::default(), + }; + let ticket = Ticket { + ticketer: ticketer_address_hash, + amount: 100u32.into(), + content: TypedValue::int(20), + }; + run_e2e_test( + "READ_TICKET", + stk![Type::new_ticket(Type::Int)], + stk![ + Type::new_ticket(Type::Int), + Type::new_pair(Type::Address, Type::new_pair(Type::Int, Type::Nat)), + ], + stk![TypedValue::new_ticket(ticket.clone())], + stk![ + TypedValue::new_ticket(ticket), + TypedValue::new_pair( + TypedValue::Address(ticketer_address), + TypedValue::new_pair(TypedValue::int(20), TypedValue::nat(100)) + ), + ], + Ctx::default(), + ); + } + + #[test] + fn split_ticket() { + let ctx = Ctx::default(); + let ticket = Ticket { + ticketer: ctx.self_address, + amount: 100u32.into(), + content: TypedValue::int(20), + }; + run_e2e_test( + "SPLIT_TICKET", + stk![ + Type::new_pair(Type::Nat, Type::Nat), + Type::new_ticket(Type::Int) + ], + stk![Type::new_option(Type::new_pair( + Type::new_ticket(Type::Int), + Type::new_ticket(Type::Int) + )),], + stk![ + TypedValue::new_pair(TypedValue::nat(20), TypedValue::nat(80)), + TypedValue::new_ticket(ticket.clone()) + ], + stk![TypedValue::new_option(Some(TypedValue::new_pair( + TypedValue::new_ticket(Ticket { + amount: 20u32.into(), + ..ticket.clone() + }), + TypedValue::new_ticket(Ticket { + amount: 80u32.into(), + ..ticket + }) + ))),], + Ctx::default(), + ); + } + + #[test] + fn join_tickets() { + let ctx = Ctx::default(); + let ticket = Ticket { + ticketer: ctx.self_address, + amount: 100u32.into(), + content: TypedValue::int(20), + }; + run_e2e_test( + "JOIN_TICKETS", + stk![Type::new_pair( + Type::new_ticket(Type::Int), + Type::new_ticket(Type::Int) + )], + stk![Type::new_option(Type::new_ticket(Type::Int)),], + stk![TypedValue::new_pair( + TypedValue::new_ticket(Ticket { + amount: 20u32.into(), + ..ticket.clone() + }), + TypedValue::new_ticket(Ticket { + amount: 80u32.into(), + ..ticket.clone() + }) + )], + stk![TypedValue::new_option(Some(TypedValue::new_ticket(ticket))),], + Ctx::default(), + ); + } + const FIBONACCI_SRC: &str = "{ INT ; PUSH int 0 ; DUP 2 ; GT ; IF { DIP { PUSH int -1 ; ADD } ; PUSH int 1 ; -- GitLab From b8596e57152dd33d76f30d1b0849b1160ef625b3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Cauderlier?= Date: Fri, 15 Dec 2023 11:30:45 +0100 Subject: [PATCH 09/10] TZT/Tests: add tests for ticket instructions --- tzt_reference_test_suite/coverage.md | 18 ++++++++++++------ tzt_reference_test_suite/join_tickets_00.tzt | 16 ++++++++++++++++ tzt_reference_test_suite/join_tickets_01.tzt | 11 +++++++++++ tzt_reference_test_suite/join_tickets_02.tzt | 11 +++++++++++ tzt_reference_test_suite/join_tickets_03.tzt | 11 +++++++++++ tzt_reference_test_suite/read_ticket_00.tzt | 7 +++++++ tzt_reference_test_suite/split_ticket_00.tzt | 17 +++++++++++++++++ tzt_reference_test_suite/split_ticket_01.tzt | 7 +++++++ tzt_reference_test_suite/split_ticket_02.tzt | 7 +++++++ tzt_reference_test_suite/split_ticket_03.tzt | 7 +++++++ tzt_reference_test_suite/split_ticket_04.tzt | 7 +++++++ tzt_reference_test_suite/ticket_00.tzt | 9 +++++++++ tzt_reference_test_suite/ticket_01.tzt | 5 +++++ 13 files changed, 127 insertions(+), 6 deletions(-) create mode 100644 tzt_reference_test_suite/join_tickets_00.tzt create mode 100644 tzt_reference_test_suite/join_tickets_01.tzt create mode 100644 tzt_reference_test_suite/join_tickets_02.tzt create mode 100644 tzt_reference_test_suite/join_tickets_03.tzt create mode 100644 tzt_reference_test_suite/read_ticket_00.tzt create mode 100644 tzt_reference_test_suite/split_ticket_00.tzt create mode 100644 tzt_reference_test_suite/split_ticket_01.tzt create mode 100644 tzt_reference_test_suite/split_ticket_02.tzt create mode 100644 tzt_reference_test_suite/split_ticket_03.tzt create mode 100644 tzt_reference_test_suite/split_ticket_04.tzt create mode 100644 tzt_reference_test_suite/ticket_00.tzt create mode 100644 tzt_reference_test_suite/ticket_01.tzt diff --git a/tzt_reference_test_suite/coverage.md b/tzt_reference_test_suite/coverage.md index 5dda62ffaa9e..81cf16460469 100644 --- a/tzt_reference_test_suite/coverage.md +++ b/tzt_reference_test_suite/coverage.md @@ -1071,23 +1071,29 @@ Tested only with conjunction with `PACK` ## Ticket manipulation -Not covered - ### `JOIN_TICKETS` -***None*** +- [join_tickets_00.tzt](join_tickets_00.tzt) +- [join_tickets_01.tzt](join_tickets_01.tzt) +- [join_tickets_02.tzt](join_tickets_02.tzt) +- [join_tickets_03.tzt](join_tickets_03.tzt) ### `READ_TICKET` -***None*** +- [read_ticket_00.tzt](read_ticket_00.tzt) ### `SPLIT_TICKET` -***None*** +- [split_ticket_00.tzt](split_ticket_00.tzt) +- [split_ticket_01.tzt](split_ticket_01.tzt) +- [split_ticket_02.tzt](split_ticket_02.tzt) +- [split_ticket_03.tzt](split_ticket_03.tzt) +- [split_ticket_04.tzt](split_ticket_04.tzt) ### `TICKET` -***None*** +- [ticket_00.tzt](ticket_00.tzt) +- [ticket_01.tzt](ticket_01.tzt) ## Cryptographic operations diff --git a/tzt_reference_test_suite/join_tickets_00.tzt b/tzt_reference_test_suite/join_tickets_00.tzt new file mode 100644 index 000000000000..a6c98a8100ba --- /dev/null +++ b/tzt_reference_test_suite/join_tickets_00.tzt @@ -0,0 +1,16 @@ +code JOIN_TICKETS; +input + { + Stack_elt + (pair (ticket string) (ticket string)) + (Pair + (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 24) + (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 18) + ) + } ; +output + { + Stack_elt + (option (ticket string)) + (Some (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 42)) + } ; diff --git a/tzt_reference_test_suite/join_tickets_01.tzt b/tzt_reference_test_suite/join_tickets_01.tzt new file mode 100644 index 000000000000..3ccea223668e --- /dev/null +++ b/tzt_reference_test_suite/join_tickets_01.tzt @@ -0,0 +1,11 @@ +code JOIN_TICKETS; +input + { + Stack_elt + (pair (ticket string) (ticket string)) + (Pair + (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 24) + (Pair "KT1QuofAgnsWffHzLA7D78rxytJruGHDe7XG" "Blue" 18) + ) + } ; +output { Stack_elt (option (ticket string)) None } ; diff --git a/tzt_reference_test_suite/join_tickets_02.tzt b/tzt_reference_test_suite/join_tickets_02.tzt new file mode 100644 index 000000000000..d1d55d0a4d68 --- /dev/null +++ b/tzt_reference_test_suite/join_tickets_02.tzt @@ -0,0 +1,11 @@ +code JOIN_TICKETS; +input + { + Stack_elt + (pair (ticket string) (ticket string)) + (Pair + (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 24) + (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Red" 18) + ) + } ; +output { Stack_elt (option (ticket string)) None } ; diff --git a/tzt_reference_test_suite/join_tickets_03.tzt b/tzt_reference_test_suite/join_tickets_03.tzt new file mode 100644 index 000000000000..ca5a83b309de --- /dev/null +++ b/tzt_reference_test_suite/join_tickets_03.tzt @@ -0,0 +1,11 @@ +code JOIN_TICKETS; +input + { + Stack_elt + (pair (ticket string) (ticket string)) + (Pair + (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 24) + (Pair "KT1QuofAgnsWffHzLA7D78rxytJruGHDe7XG" "Red" 18) + ) + } ; +output { Stack_elt (option (ticket string)) None } ; diff --git a/tzt_reference_test_suite/read_ticket_00.tzt b/tzt_reference_test_suite/read_ticket_00.tzt new file mode 100644 index 000000000000..3b2907376f16 --- /dev/null +++ b/tzt_reference_test_suite/read_ticket_00.tzt @@ -0,0 +1,7 @@ +code READ_TICKET; +input { Stack_elt (ticket string) (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 42) } ; +output + { + Stack_elt (pair address string nat) (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 42) ; + Stack_elt (ticket string) (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 42) ; + } ; diff --git a/tzt_reference_test_suite/split_ticket_00.tzt b/tzt_reference_test_suite/split_ticket_00.tzt new file mode 100644 index 000000000000..079b7db7d479 --- /dev/null +++ b/tzt_reference_test_suite/split_ticket_00.tzt @@ -0,0 +1,17 @@ +code SPLIT_TICKET; +input + { + Stack_elt (ticket string) (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 42) ; + Stack_elt (pair nat nat) (Pair 24 18) ; + } ; +output + { + Stack_elt + (option (pair (ticket string) (ticket string))) + (Some + (Pair + (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 24) + (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 18) + ) + ) ; + } ; diff --git a/tzt_reference_test_suite/split_ticket_01.tzt b/tzt_reference_test_suite/split_ticket_01.tzt new file mode 100644 index 000000000000..53ca061f2406 --- /dev/null +++ b/tzt_reference_test_suite/split_ticket_01.tzt @@ -0,0 +1,7 @@ +code SPLIT_TICKET; +input + { + Stack_elt (ticket string) (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 42) ; + Stack_elt (pair nat nat) (Pair 42 0) ; + } ; +output { Stack_elt (option (pair (ticket string) (ticket string))) None } ; diff --git a/tzt_reference_test_suite/split_ticket_02.tzt b/tzt_reference_test_suite/split_ticket_02.tzt new file mode 100644 index 000000000000..c69cc47b0592 --- /dev/null +++ b/tzt_reference_test_suite/split_ticket_02.tzt @@ -0,0 +1,7 @@ +code SPLIT_TICKET; +input + { + Stack_elt (ticket string) (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 42) ; + Stack_elt (pair nat nat) (Pair 0 42) ; + } ; +output { Stack_elt (option (pair (ticket string) (ticket string))) None } ; diff --git a/tzt_reference_test_suite/split_ticket_03.tzt b/tzt_reference_test_suite/split_ticket_03.tzt new file mode 100644 index 000000000000..cb771c8aaef6 --- /dev/null +++ b/tzt_reference_test_suite/split_ticket_03.tzt @@ -0,0 +1,7 @@ +code SPLIT_TICKET; +input + { + Stack_elt (ticket string) (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 42) ; + Stack_elt (pair nat nat) (Pair 24 24) ; + } ; +output { Stack_elt (option (pair (ticket string) (ticket string))) None } ; diff --git a/tzt_reference_test_suite/split_ticket_04.tzt b/tzt_reference_test_suite/split_ticket_04.tzt new file mode 100644 index 000000000000..02440ccaa0f8 --- /dev/null +++ b/tzt_reference_test_suite/split_ticket_04.tzt @@ -0,0 +1,7 @@ +code SPLIT_TICKET; +input + { + Stack_elt (ticket string) (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 42) ; + Stack_elt (pair nat nat) (Pair 18 18) ; + } ; +output { Stack_elt (option (pair (ticket string) (ticket string))) None } ; diff --git a/tzt_reference_test_suite/ticket_00.tzt b/tzt_reference_test_suite/ticket_00.tzt new file mode 100644 index 000000000000..437ef3ce662b --- /dev/null +++ b/tzt_reference_test_suite/ticket_00.tzt @@ -0,0 +1,9 @@ +code TICKET; +self "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" ; +input { Stack_elt string "Blue"; Stack_elt nat 42 } ; +output + { Stack_elt + (option (ticket string)) + (Some (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 42)) + } ; + diff --git a/tzt_reference_test_suite/ticket_01.tzt b/tzt_reference_test_suite/ticket_01.tzt new file mode 100644 index 000000000000..c88d4ec28402 --- /dev/null +++ b/tzt_reference_test_suite/ticket_01.tzt @@ -0,0 +1,5 @@ +code TICKET; +self "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" ; +input { Stack_elt string "Blue"; Stack_elt nat 0 } ; +output { Stack_elt (option (ticket string)) None} ; + -- GitLab From 140f3e431f729637753867cba355585a21347a98 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Rapha=C3=ABl=20Cauderlier?= Date: Sat, 16 Dec 2023 14:35:12 +0100 Subject: [PATCH 10/10] Tezt/TZT: regenerate regression trace This commit was generated with the following command: dune exec tezt/tests/main.exe -- --file tzt_regression.ml --reset-regressions --- .../expected/tzt_regression.ml/Alpha- Run TZT.out | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/tezt/tests/expected/tzt_regression.ml/Alpha- Run TZT.out b/tezt/tests/expected/tzt_regression.ml/Alpha- Run TZT.out index 7b1429d438ad..79213ae1f2cc 100644 --- a/tezt/tests/expected/tzt_regression.ml/Alpha- Run TZT.out +++ b/tezt/tests/expected/tzt_regression.ml/Alpha- Run TZT.out @@ -1,5 +1,5 @@ -./octez-client --protocol ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK --mode mockup --no-base-dir-warnings run unit tests from tzt_reference_test_suite/abs_00.tzt tzt_reference_test_suite/abs_01.tzt tzt_reference_test_suite/abs_02.tzt tzt_reference_test_suite/add_00.tc.tzt tzt_reference_test_suite/add_01.tc.tzt tzt_reference_test_suite/add_int-int_00.tzt tzt_reference_test_suite/add_int-nat_00.tzt tzt_reference_test_suite/add_int-nat_01.tzt tzt_reference_test_suite/add_int-timestamp_00.tzt tzt_reference_test_suite/add_mutez-mutez_00.tzt tzt_reference_test_suite/add_mutez-mutez_01.tzt tzt_reference_test_suite/add_nat-int_00.tzt tzt_reference_test_suite/add_nat-nat_00.tzt tzt_reference_test_suite/add_timestamp-int_00.tzt tzt_reference_test_suite/add_timestamp-int_01.tzt tzt_reference_test_suite/add_timestamp-int_02.tzt tzt_reference_test_suite/add_timestamp-int_03.tzt tzt_reference_test_suite/address_00.tzt tzt_reference_test_suite/address_00.tc.tzt tzt_reference_test_suite/address_01.tzt tzt_reference_test_suite/address_02.tzt tzt_reference_test_suite/amount_00.tzt tzt_reference_test_suite/and_bool-bool_00.tzt tzt_reference_test_suite/and_bool-bool_01.tzt tzt_reference_test_suite/and_bool-bool_02.tzt tzt_reference_test_suite/and_bool-bool_03.tzt tzt_reference_test_suite/and_bytes-bytes_00.tzt tzt_reference_test_suite/and_bytes-bytes_01.tzt tzt_reference_test_suite/and_bytes-bytes_02.tzt tzt_reference_test_suite/and_bytes-bytes_03.tzt tzt_reference_test_suite/and_bytes-bytes_04.tzt tzt_reference_test_suite/and_bytes-bytes_05.tzt tzt_reference_test_suite/and_bytes-bytes_06.tzt tzt_reference_test_suite/and_int-nat_00.tzt tzt_reference_test_suite/and_int-nat_01.tzt tzt_reference_test_suite/and_int-nat_02.tzt tzt_reference_test_suite/and_int-nat_03.tzt tzt_reference_test_suite/and_int-nat_04.tzt tzt_reference_test_suite/and_int-nat_05.tzt tzt_reference_test_suite/and_int-nat_06.tzt tzt_reference_test_suite/and_nat-nat_00.tzt tzt_reference_test_suite/and_nat-nat_01.tzt tzt_reference_test_suite/and_nat-nat_02.tzt tzt_reference_test_suite/apply_00.tzt tzt_reference_test_suite/apply_01.tzt tzt_reference_test_suite/apply_02.tzt tzt_reference_test_suite/balance_00.tzt tzt_reference_test_suite/car_00.tzt tzt_reference_test_suite/car_00.tc.tzt tzt_reference_test_suite/car_01.tzt tzt_reference_test_suite/cdr_00.tzt tzt_reference_test_suite/cdr_00.tc.tzt tzt_reference_test_suite/cdr_01.tzt tzt_reference_test_suite/chain_id_00.tzt tzt_reference_test_suite/chain_id_01.tzt tzt_reference_test_suite/checksignature_00.tzt tzt_reference_test_suite/checksignature_00.tc.tzt tzt_reference_test_suite/checksignature_01.tzt tzt_reference_test_suite/compare_00.tc.tzt tzt_reference_test_suite/compare_01.tc.tzt tzt_reference_test_suite/compare_02.tc.tzt tzt_reference_test_suite/compare_bool_00.tzt tzt_reference_test_suite/compare_bool_01.tzt tzt_reference_test_suite/compare_bool_02.tzt tzt_reference_test_suite/compare_bool_03.tzt tzt_reference_test_suite/compare_bytes_00.tzt tzt_reference_test_suite/compare_bytes_01.tzt tzt_reference_test_suite/compare_bytes_02.tzt tzt_reference_test_suite/compare_bytes_03.tzt tzt_reference_test_suite/compare_bytes_04.tzt tzt_reference_test_suite/compare_int_00.tzt tzt_reference_test_suite/compare_int_01.tzt tzt_reference_test_suite/compare_int_02.tzt tzt_reference_test_suite/compare_int_03.tzt tzt_reference_test_suite/compare_int_04.tzt tzt_reference_test_suite/compare_keyhash_00.tzt tzt_reference_test_suite/compare_keyhash_01.tzt tzt_reference_test_suite/compare_keyhash_02.tzt tzt_reference_test_suite/compare_mutez_00.tzt tzt_reference_test_suite/compare_mutez_01.tzt tzt_reference_test_suite/compare_mutez_02.tzt tzt_reference_test_suite/compare_mutez_03.tzt tzt_reference_test_suite/compare_mutez_04.tzt tzt_reference_test_suite/compare_mutez_05.tzt tzt_reference_test_suite/compare_nat_00.tzt tzt_reference_test_suite/compare_nat_01.tzt tzt_reference_test_suite/compare_nat_02.tzt tzt_reference_test_suite/compare_nat_03.tzt tzt_reference_test_suite/compare_nat_04.tzt tzt_reference_test_suite/compare_nat_05.tzt tzt_reference_test_suite/compare_pairintint_00.tzt tzt_reference_test_suite/compare_pairintint_01.tzt tzt_reference_test_suite/compare_pairintint_02.tzt tzt_reference_test_suite/compare_pairintint_03.tzt tzt_reference_test_suite/compare_string_00.tzt tzt_reference_test_suite/compare_string_01.tzt tzt_reference_test_suite/compare_string_02.tzt tzt_reference_test_suite/compare_string_03.tzt tzt_reference_test_suite/compare_string_04.tzt tzt_reference_test_suite/compare_timestamp_00.tzt tzt_reference_test_suite/compare_timestamp_01.tzt tzt_reference_test_suite/compare_timestamp_02.tzt tzt_reference_test_suite/compare_timestamp_03.tzt tzt_reference_test_suite/compare_timestamp_04.tzt tzt_reference_test_suite/compare_timestamp_05.tzt tzt_reference_test_suite/concat_bytes_00.tzt tzt_reference_test_suite/concat_bytes_01.tzt tzt_reference_test_suite/concat_listbytes_00.tzt tzt_reference_test_suite/concat_listbytes_01.tzt tzt_reference_test_suite/concat_listbytes_02.tzt tzt_reference_test_suite/concat_liststring_00.tzt tzt_reference_test_suite/concat_liststring_01.tzt tzt_reference_test_suite/concat_liststring_02.tzt tzt_reference_test_suite/concat_liststring_03.tzt tzt_reference_test_suite/concat_liststring_04.tzt tzt_reference_test_suite/concat_string_00.tzt tzt_reference_test_suite/concat_string_01.tzt tzt_reference_test_suite/concat_string_02.tzt tzt_reference_test_suite/cons_int_00.tzt tzt_reference_test_suite/cons_int_01.tzt tzt_reference_test_suite/cons_int_02.tzt tzt_reference_test_suite/cons_lists_00.tc.tzt tzt_reference_test_suite/cons_string_00.tzt tzt_reference_test_suite/contract_00.tzt tzt_reference_test_suite/contract_01.tzt tzt_reference_test_suite/contract_02.tzt tzt_reference_test_suite/contract_03.tzt tzt_reference_test_suite/contract_04.tzt tzt_reference_test_suite/contract_05.tzt tzt_reference_test_suite/createcontract_00.tzt tzt_reference_test_suite/createcontract_01.tzt tzt_reference_test_suite/dig_00.tzt tzt_reference_test_suite/dig_01.tzt tzt_reference_test_suite/dig_02.tzt tzt_reference_test_suite/dig_03.tzt tzt_reference_test_suite/dig_04.tzt tzt_reference_test_suite/dip_00.tzt tzt_reference_test_suite/dip_00.tc.tzt tzt_reference_test_suite/dip_01.tzt tzt_reference_test_suite/dip_02.tzt tzt_reference_test_suite/dipn_00.tzt tzt_reference_test_suite/dipn_00.tc.tzt tzt_reference_test_suite/dipn_01.tzt tzt_reference_test_suite/dipn_01.tc.tzt tzt_reference_test_suite/dipn_02.tzt tzt_reference_test_suite/dipn_02.tc.tzt tzt_reference_test_suite/dipn_03.tzt tzt_reference_test_suite/drop_00.tzt tzt_reference_test_suite/drop_00.tc.tzt tzt_reference_test_suite/dropn_00.tzt tzt_reference_test_suite/dropn_00.tc.tzt tzt_reference_test_suite/dropn_01.tzt tzt_reference_test_suite/dropn_02.tzt tzt_reference_test_suite/dropn_03.tzt tzt_reference_test_suite/dugn_00.tzt tzt_reference_test_suite/dup_00.tzt tzt_reference_test_suite/dup_00.tc.tzt tzt_reference_test_suite/dupn_00.tzt tzt_reference_test_suite/dupn_00.tc.tzt tzt_reference_test_suite/dupn_01.tzt tzt_reference_test_suite/dupn_01.tc.tzt tzt_reference_test_suite/dupn_02.tzt tzt_reference_test_suite/dupn_03.tzt tzt_reference_test_suite/dupn_04.tzt tzt_reference_test_suite/ediv_int-int_00.tzt tzt_reference_test_suite/ediv_int-int_01.tzt tzt_reference_test_suite/ediv_int-int_02.tzt tzt_reference_test_suite/ediv_int-int_03.tzt tzt_reference_test_suite/ediv_mutez-mutez_00.tzt tzt_reference_test_suite/ediv_mutez-mutez_01.tzt tzt_reference_test_suite/ediv_mutez-mutez_02.tzt tzt_reference_test_suite/ediv_mutez-mutez_03.tzt tzt_reference_test_suite/ediv_mutez-nat_00.tzt tzt_reference_test_suite/ediv_mutez-nat_01.tzt tzt_reference_test_suite/ediv_mutez-nat_02.tzt tzt_reference_test_suite/ediv_mutez-nat_03.tzt tzt_reference_test_suite/ediv_mutez-nat_04.tzt tzt_reference_test_suite/ediv_mutez-nat_05.tzt tzt_reference_test_suite/ediv_mutez-nat_06.tzt tzt_reference_test_suite/emptybigmap_nat-nat_00.tzt tzt_reference_test_suite/emptymap_nat-nat_00.tzt tzt_reference_test_suite/emptymap_string-string_00.tzt tzt_reference_test_suite/emptyset_nat_00.tzt tzt_reference_test_suite/eq_00.tzt tzt_reference_test_suite/eq_01.tzt tzt_reference_test_suite/eq_02.tzt tzt_reference_test_suite/eq_03.tzt tzt_reference_test_suite/eq_04.tzt tzt_reference_test_suite/exec_00.tzt tzt_reference_test_suite/exec_01.tzt tzt_reference_test_suite/exec_02.tzt tzt_reference_test_suite/exec_03.tzt tzt_reference_test_suite/failwith_00.tzt tzt_reference_test_suite/failwith_00.tc.tzt tzt_reference_test_suite/gas_exhaustion.tzt tzt_reference_test_suite/ge_00.tzt tzt_reference_test_suite/ge_01.tzt tzt_reference_test_suite/ge_02.tzt tzt_reference_test_suite/ge_03.tzt tzt_reference_test_suite/ge_04.tzt tzt_reference_test_suite/get_00.tc.tzt tzt_reference_test_suite/get_bigmapstringstring_00.tzt tzt_reference_test_suite/get_bigmapstringstring_01.tzt tzt_reference_test_suite/get_bigmapstringstring_02.tzt tzt_reference_test_suite/get_map_00.tc.tzt tzt_reference_test_suite/get_mapintint_00.tzt tzt_reference_test_suite/get_mapintint_01.tzt tzt_reference_test_suite/get_mapstringstring_00.tzt tzt_reference_test_suite/get_mapstringstring_01.tzt tzt_reference_test_suite/get_mapstringstring_02.tzt tzt_reference_test_suite/gt_00.tzt tzt_reference_test_suite/gt_00.tc.tzt tzt_reference_test_suite/gt_01.tzt tzt_reference_test_suite/gt_02.tzt tzt_reference_test_suite/gt_03.tzt tzt_reference_test_suite/gt_04.tzt tzt_reference_test_suite/if_00.tzt tzt_reference_test_suite/if_00.tc.tzt tzt_reference_test_suite/if_01.tzt tzt_reference_test_suite/if_01.tc.tzt tzt_reference_test_suite/ifcons_00.tc.tzt tzt_reference_test_suite/ifcons_listint_00.tzt tzt_reference_test_suite/ifcons_listint_01.tzt tzt_reference_test_suite/ifcons_listnat_00.tzt tzt_reference_test_suite/ifcons_listnat_01.tzt tzt_reference_test_suite/ifleft_00.tc.tzt tzt_reference_test_suite/ifleft_orintstring_00.tzt tzt_reference_test_suite/ifleft_orstringint_00.tzt tzt_reference_test_suite/ifnone_00.tc.tzt tzt_reference_test_suite/ifnone_optionint_00.tzt tzt_reference_test_suite/ifnone_optionnat_00.tzt tzt_reference_test_suite/implicitaccount_00.tzt tzt_reference_test_suite/int_00.tc.tzt tzt_reference_test_suite/int_nat_00.tzt tzt_reference_test_suite/int_nat_01.tzt tzt_reference_test_suite/isnat_00.tzt tzt_reference_test_suite/isnat_01.tzt tzt_reference_test_suite/iter_00.tc.tzt tzt_reference_test_suite/iter_listint_00.tzt tzt_reference_test_suite/iter_listint_01.tzt tzt_reference_test_suite/iter_listint_02.tzt tzt_reference_test_suite/iter_listint_03.tzt tzt_reference_test_suite/iter_liststring_00.tzt tzt_reference_test_suite/iter_liststring_01.tzt tzt_reference_test_suite/iter_mapintint_00.tzt tzt_reference_test_suite/iter_mapintint_01.tzt tzt_reference_test_suite/iter_mapintint_02.tzt tzt_reference_test_suite/iter_mapintint_03.tzt tzt_reference_test_suite/iter_mapintint_04.tzt tzt_reference_test_suite/iter_mapstringstring_00.tzt tzt_reference_test_suite/iter_setint_00.tzt tzt_reference_test_suite/iter_setint_01.tzt tzt_reference_test_suite/iter_setint_02.tzt tzt_reference_test_suite/iter_setstring_00.tzt tzt_reference_test_suite/iter_setstring_01.tzt tzt_reference_test_suite/iter_setstring_02.tzt tzt_reference_test_suite/le_00.tzt tzt_reference_test_suite/le_01.tzt tzt_reference_test_suite/le_02.tzt tzt_reference_test_suite/le_03.tzt tzt_reference_test_suite/le_04.tzt tzt_reference_test_suite/left_int-nat_00.tzt tzt_reference_test_suite/loop_00.tzt tzt_reference_test_suite/loop_00.tc.tzt tzt_reference_test_suite/loop_01.tzt tzt_reference_test_suite/loop_01.tc.tzt tzt_reference_test_suite/loop_02.tzt tzt_reference_test_suite/loopleft_00.tzt tzt_reference_test_suite/loopleft_01.tzt tzt_reference_test_suite/loopleft_02.tzt tzt_reference_test_suite/loopleft_03.tzt tzt_reference_test_suite/loopleft_04.tzt tzt_reference_test_suite/lsl_00.tzt tzt_reference_test_suite/lsl_01.tzt tzt_reference_test_suite/lsl_02.tzt tzt_reference_test_suite/lsl_03.tzt tzt_reference_test_suite/lsl_04.tzt tzt_reference_test_suite/lsl_05.tzt tzt_reference_test_suite/lsl_06.tzt tzt_reference_test_suite/lsr_00.tzt tzt_reference_test_suite/lsr_01.tzt tzt_reference_test_suite/lsr_02.tzt tzt_reference_test_suite/lsr_03.tzt tzt_reference_test_suite/lsr_04.tzt tzt_reference_test_suite/lsr_05.tzt tzt_reference_test_suite/lt_00.tzt tzt_reference_test_suite/lt_01.tzt tzt_reference_test_suite/lt_02.tzt tzt_reference_test_suite/lt_03.tzt tzt_reference_test_suite/lt_04.tzt tzt_reference_test_suite/macro_pack/assert_00.tzt tzt_reference_test_suite/map_listint_00.tzt tzt_reference_test_suite/map_listint_01.tzt tzt_reference_test_suite/map_listint_02.tzt tzt_reference_test_suite/map_listint_03.tzt tzt_reference_test_suite/map_listint_04.tzt tzt_reference_test_suite/map_listint_05.tzt tzt_reference_test_suite/map_listint_06.tzt tzt_reference_test_suite/map_liststring_00.tzt tzt_reference_test_suite/map_liststring_01.tzt tzt_reference_test_suite/map_liststring_02.tzt tzt_reference_test_suite/map_liststring_04.tzt tzt_reference_test_suite/map_liststring_05.tzt tzt_reference_test_suite/map_liststring_06.tzt tzt_reference_test_suite/map_liststring_07.tzt tzt_reference_test_suite/map_liststring_08.tzt tzt_reference_test_suite/map_mapintint_00.tzt tzt_reference_test_suite/map_mapintint_01.tzt tzt_reference_test_suite/map_mapintstring_00.tzt tzt_reference_test_suite/map_mapintstring_01.tzt tzt_reference_test_suite/map_mapstringnat_00.tzt tzt_reference_test_suite/map_mapstringnat_01.tzt tzt_reference_test_suite/map_mapstringnat_02.tzt tzt_reference_test_suite/mem_bigmapnatnat_00.tzt tzt_reference_test_suite/mem_bigmapnatnat_01.tzt tzt_reference_test_suite/mem_bigmapnatnat_02.tzt tzt_reference_test_suite/mem_bigmapnatnat_03.tzt tzt_reference_test_suite/mem_bigmapnatnat_04.tzt tzt_reference_test_suite/mem_bigmapnatnat_05.tzt tzt_reference_test_suite/mem_bigmapstringnat_00.tzt tzt_reference_test_suite/mem_bigmapstringnat_01.tzt tzt_reference_test_suite/mem_bigmapstringnat_02.tzt tzt_reference_test_suite/mem_bigmapstringnat_03.tzt tzt_reference_test_suite/mem_bigmapstringnat_04.tzt tzt_reference_test_suite/mem_bigmapstringnat_05.tzt tzt_reference_test_suite/mem_mapintint_00.tzt tzt_reference_test_suite/mem_mapnatnat_00.tzt tzt_reference_test_suite/mem_mapnatnat_01.tzt tzt_reference_test_suite/mem_mapnatnat_02.tzt tzt_reference_test_suite/mem_mapnatnat_03.tzt tzt_reference_test_suite/mem_mapnatnat_04.tzt tzt_reference_test_suite/mem_mapnatnat_05.tzt tzt_reference_test_suite/mem_mapstringnat_00.tzt tzt_reference_test_suite/mem_mapstringnat_01.tzt tzt_reference_test_suite/mem_mapstringnat_02.tzt tzt_reference_test_suite/mem_mapstringnat_03.tzt tzt_reference_test_suite/mem_mapstringnat_04.tzt tzt_reference_test_suite/mem_mapstringnat_05.tzt tzt_reference_test_suite/mem_setint_00.tzt tzt_reference_test_suite/mem_setint_01.tzt tzt_reference_test_suite/mem_setstring_00.tzt tzt_reference_test_suite/mem_setstring_01.tzt tzt_reference_test_suite/mem_setstring_02.tzt tzt_reference_test_suite/mul_int-int_00.tzt tzt_reference_test_suite/mul_int-nat_00.tzt tzt_reference_test_suite/mul_mutez-nat_00.tzt tzt_reference_test_suite/mul_mutez-nat_01.tzt tzt_reference_test_suite/mul_nat-int_00.tzt tzt_reference_test_suite/mul_nat-mutez_00.tzt tzt_reference_test_suite/mul_nat-mutez_01.tzt tzt_reference_test_suite/mul_nat-nat_00.tzt tzt_reference_test_suite/neg_int_00.tzt tzt_reference_test_suite/neg_int_01.tzt tzt_reference_test_suite/neg_int_02.tzt tzt_reference_test_suite/neg_nat_00.tzt tzt_reference_test_suite/neg_nat_01.tzt tzt_reference_test_suite/neq_00.tzt tzt_reference_test_suite/neq_01.tzt tzt_reference_test_suite/neq_02.tzt tzt_reference_test_suite/neq_03.tzt tzt_reference_test_suite/neq_04.tzt tzt_reference_test_suite/nil_nat_00.tzt tzt_reference_test_suite/none_int_00.tzt tzt_reference_test_suite/none_pair-nat-string.tzt tzt_reference_test_suite/not_bool_00.tzt tzt_reference_test_suite/not_bool_01.tzt tzt_reference_test_suite/not_bytes_00.tzt tzt_reference_test_suite/not_bytes_01.tzt tzt_reference_test_suite/not_bytes_02.tzt tzt_reference_test_suite/not_bytes_03.tzt tzt_reference_test_suite/not_bytes_04.tzt tzt_reference_test_suite/not_bytes_05.tzt tzt_reference_test_suite/not_int_00.tzt tzt_reference_test_suite/not_nat_00.tzt tzt_reference_test_suite/not_nat_01.tzt tzt_reference_test_suite/not_nat_02.tzt tzt_reference_test_suite/not_nat_03.tzt tzt_reference_test_suite/not_nat_04.tzt tzt_reference_test_suite/not_nat_05.tzt tzt_reference_test_suite/not_nat_06.tzt tzt_reference_test_suite/not_nat_07.tzt tzt_reference_test_suite/now_00.tzt tzt_reference_test_suite/or_bool-bool_00.tzt tzt_reference_test_suite/or_bool-bool_01.tzt tzt_reference_test_suite/or_bool-bool_02.tzt tzt_reference_test_suite/or_bool-bool_03.tzt tzt_reference_test_suite/or_bytes-bytes_00.tzt tzt_reference_test_suite/or_bytes-bytes_01.tzt tzt_reference_test_suite/or_bytes-bytes_02.tzt tzt_reference_test_suite/or_bytes-bytes_03.tzt tzt_reference_test_suite/or_bytes-bytes_04.tzt tzt_reference_test_suite/or_bytes-bytes_05.tzt tzt_reference_test_suite/or_bytes-bytes_06.tzt tzt_reference_test_suite/or_nat-nat_00.tzt tzt_reference_test_suite/or_nat-nat_01.tzt tzt_reference_test_suite/or_nat-nat_02.tzt tzt_reference_test_suite/or_nat-nat_03.tzt tzt_reference_test_suite/or_nat-nat_04.tzt tzt_reference_test_suite/or_nat-nat_05.tzt tzt_reference_test_suite/or_nat-nat_06.tzt tzt_reference_test_suite/pack_address_00.tzt tzt_reference_test_suite/pack_address_01.tzt tzt_reference_test_suite/pack_address_02.tzt tzt_reference_test_suite/pack_address_03.tzt tzt_reference_test_suite/pack_address_04.tzt tzt_reference_test_suite/pack_address_05.tzt tzt_reference_test_suite/pack_bool_00.tzt tzt_reference_test_suite/pack_bool_01.tzt tzt_reference_test_suite/pack_bytes_00.tzt tzt_reference_test_suite/pack_bytes_01.tzt tzt_reference_test_suite/pack_bytes_02.tzt tzt_reference_test_suite/pack_chainid_00.tzt tzt_reference_test_suite/pack_contract_00.tzt tzt_reference_test_suite/pack_key_00.tzt tzt_reference_test_suite/pack_key_01.tzt tzt_reference_test_suite/pack_key_02.tzt tzt_reference_test_suite/pack_key_03.tzt tzt_reference_test_suite/pack_keyhash_01.tzt tzt_reference_test_suite/pack_keyhash_02.tzt tzt_reference_test_suite/pack_keyhash_03.tzt tzt_reference_test_suite/pack_keyhash_04.tzt tzt_reference_test_suite/pack_lambda_comb_pairs.tzt tzt_reference_test_suite/pack_list-bool_00.tzt tzt_reference_test_suite/pack_list-bool_01.tzt tzt_reference_test_suite/pack_list-list-bool.tzt tzt_reference_test_suite/pack_list_large_00.tzt tzt_reference_test_suite/pack_map-bool-unit_00.tzt tzt_reference_test_suite/pack_operation_00.tc.tzt tzt_reference_test_suite/pack_option-unit_00.tzt tzt_reference_test_suite/pack_option-unit_01.tzt tzt_reference_test_suite/pack_or-unit-bool_00.tzt tzt_reference_test_suite/pack_or-unit-bool_01.tzt tzt_reference_test_suite/pack_pair-bool-unit_00.tzt tzt_reference_test_suite/pack_signature_00.tzt tzt_reference_test_suite/pack_signature_01.tzt tzt_reference_test_suite/pack_signature_02.tzt tzt_reference_test_suite/pack_signature_03.tzt tzt_reference_test_suite/pack_string_00.tzt tzt_reference_test_suite/pack_string_01.tzt tzt_reference_test_suite/pack_string_02.tzt tzt_reference_test_suite/pack_string_03.tzt tzt_reference_test_suite/pack_unit_00.tzt tzt_reference_test_suite/packunpack_address_00.tzt tzt_reference_test_suite/packunpack_bool_00.tzt tzt_reference_test_suite/packunpack_bytes_00.tzt tzt_reference_test_suite/packunpack_int_00.tzt tzt_reference_test_suite/packunpack_keyhash_00.tzt tzt_reference_test_suite/packunpack_mutez_00.tzt tzt_reference_test_suite/packunpack_nat_00.tzt tzt_reference_test_suite/packunpack_string_00.tzt tzt_reference_test_suite/packunpack_timestamp_00.tzt tzt_reference_test_suite/pair_00.tc.tzt tzt_reference_test_suite/pair_int-int_00.tzt tzt_reference_test_suite/pair_nat-string_00.tzt tzt_reference_test_suite/pair_pair-nat-string-pair-string-nat_00.tzt tzt_reference_test_suite/push_00.tc.tzt tzt_reference_test_suite/push_int_00.tzt tzt_reference_test_suite/push_string_00.tzt tzt_reference_test_suite/right_nat-int_00.tzt tzt_reference_test_suite/self_00.tzt tzt_reference_test_suite/self_01.tzt tzt_reference_test_suite/self_in_lambda.tc.tzt tzt_reference_test_suite/sender_00.tzt tzt_reference_test_suite/setdelegate_00.tzt tzt_reference_test_suite/setdelegate_00.tc.tzt tzt_reference_test_suite/size_bytes_00.tzt tzt_reference_test_suite/size_listint_00.tzt tzt_reference_test_suite/size_listint_01.tzt tzt_reference_test_suite/size_listint_02.tzt tzt_reference_test_suite/size_listint_03.tzt tzt_reference_test_suite/size_mapintint_00.tzt tzt_reference_test_suite/size_mapstringnat_00.tzt tzt_reference_test_suite/size_mapstringnat_01.tzt tzt_reference_test_suite/size_mapstringnat_02.tzt tzt_reference_test_suite/size_mapstringnat_03.tzt tzt_reference_test_suite/size_setint_00.tzt tzt_reference_test_suite/size_setint_01.tzt tzt_reference_test_suite/size_setint_02.tzt tzt_reference_test_suite/size_setint_03.tzt tzt_reference_test_suite/size_setstring_00.tzt tzt_reference_test_suite/size_string_00.tzt tzt_reference_test_suite/slice_bytes_00.tzt tzt_reference_test_suite/slice_bytes_01.tzt tzt_reference_test_suite/slice_bytes_02.tzt tzt_reference_test_suite/slice_bytes_03.tzt tzt_reference_test_suite/slice_bytes_04.tzt tzt_reference_test_suite/slice_string_00.tzt tzt_reference_test_suite/slice_string_01.tzt tzt_reference_test_suite/slice_string_02.tzt tzt_reference_test_suite/slice_string_03.tzt tzt_reference_test_suite/slice_string_04.tzt tzt_reference_test_suite/slice_string_05.tzt tzt_reference_test_suite/some_00.tc.tzt tzt_reference_test_suite/some_int_00.tzt tzt_reference_test_suite/some_pairintint_00.tzt tzt_reference_test_suite/some_string_00.tzt tzt_reference_test_suite/source_00.tzt tzt_reference_test_suite/sub_int-int_00.tzt tzt_reference_test_suite/sub_int-int_01.tzt tzt_reference_test_suite/sub_mutez-mutez_00.tzt tzt_reference_test_suite/sub_mutez-mutez_01.tzt tzt_reference_test_suite/sub_timestamp-int_00.tzt tzt_reference_test_suite/sub_timestamp-int_01.tzt tzt_reference_test_suite/sub_timestamp-int_02.tzt tzt_reference_test_suite/sub_timestamp-int_03.tzt tzt_reference_test_suite/sub_timestamp-int_04.tzt tzt_reference_test_suite/sub_timestamp-timestamp_00.tzt tzt_reference_test_suite/sub_timestamp-timestamp_01.tzt tzt_reference_test_suite/sub_timestamp-timestamp_02.tzt tzt_reference_test_suite/sub_timestamp-timestamp_03.tzt tzt_reference_test_suite/swap_00.tzt tzt_reference_test_suite/swap_00.tc.tzt tzt_reference_test_suite/swap_01.tc.tzt tzt_reference_test_suite/transfertokens_00.tzt tzt_reference_test_suite/transfertokens_00.tc.tzt tzt_reference_test_suite/transfertokens_01.tzt tzt_reference_test_suite/unit_00.tzt tzt_reference_test_suite/unpair_00.tc.tzt tzt_reference_test_suite/unpair_pairstringstring_00.tzt tzt_reference_test_suite/update_00.tc.tzt tzt_reference_test_suite/update_bigmapstringstring_00.tzt tzt_reference_test_suite/update_bigmapstringstring_01.tzt tzt_reference_test_suite/update_bigmapstringstring_02.tzt tzt_reference_test_suite/update_bigmapstringstring_03.tzt tzt_reference_test_suite/update_bigmapstringstring_04.tzt tzt_reference_test_suite/update_bigmapstringstring_05.tzt tzt_reference_test_suite/update_bigmapstringstring_06.tzt tzt_reference_test_suite/update_bigmapstringstring_07.tzt tzt_reference_test_suite/update_mapintint_00.tzt tzt_reference_test_suite/update_mapintint_01.tzt tzt_reference_test_suite/update_setint_00.tzt tzt_reference_test_suite/update_setint_01.tzt tzt_reference_test_suite/update_setint_02.tzt tzt_reference_test_suite/xor_bool-bool_00.tzt tzt_reference_test_suite/xor_bool-bool_01.tzt tzt_reference_test_suite/xor_bool-bool_02.tzt tzt_reference_test_suite/xor_bool-bool_03.tzt tzt_reference_test_suite/xor_bytes-bytes_00.tzt tzt_reference_test_suite/xor_bytes-bytes_01.tzt tzt_reference_test_suite/xor_bytes-bytes_02.tzt tzt_reference_test_suite/xor_bytes-bytes_03.tzt tzt_reference_test_suite/xor_bytes-bytes_04.tzt tzt_reference_test_suite/xor_bytes-bytes_05.tzt tzt_reference_test_suite/xor_bytes-bytes_06.tzt tzt_reference_test_suite/xor_nat-nat_00.tzt tzt_reference_test_suite/xor_nat-nat_01.tzt tzt_reference_test_suite/xor_nat-nat_02.tzt tzt_reference_test_suite/xor_nat-nat_03.tzt tzt_reference_test_suite/xor_nat-nat_04.tzt tzt_reference_test_suite/xor_nat-nat_05.tzt tzt_reference_test_suite/xor_nat-nat_06.tzt +./octez-client --protocol ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK --mode mockup --no-base-dir-warnings run unit tests from tzt_reference_test_suite/abs_00.tzt tzt_reference_test_suite/abs_01.tzt tzt_reference_test_suite/abs_02.tzt tzt_reference_test_suite/add_00.tc.tzt tzt_reference_test_suite/add_01.tc.tzt tzt_reference_test_suite/add_int-int_00.tzt tzt_reference_test_suite/add_int-nat_00.tzt tzt_reference_test_suite/add_int-nat_01.tzt tzt_reference_test_suite/add_int-timestamp_00.tzt tzt_reference_test_suite/add_mutez-mutez_00.tzt tzt_reference_test_suite/add_mutez-mutez_01.tzt tzt_reference_test_suite/add_nat-int_00.tzt tzt_reference_test_suite/add_nat-nat_00.tzt tzt_reference_test_suite/add_timestamp-int_00.tzt tzt_reference_test_suite/add_timestamp-int_01.tzt tzt_reference_test_suite/add_timestamp-int_02.tzt tzt_reference_test_suite/add_timestamp-int_03.tzt tzt_reference_test_suite/address_00.tzt tzt_reference_test_suite/address_00.tc.tzt tzt_reference_test_suite/address_01.tzt tzt_reference_test_suite/address_02.tzt tzt_reference_test_suite/amount_00.tzt tzt_reference_test_suite/and_bool-bool_00.tzt tzt_reference_test_suite/and_bool-bool_01.tzt tzt_reference_test_suite/and_bool-bool_02.tzt tzt_reference_test_suite/and_bool-bool_03.tzt tzt_reference_test_suite/and_bytes-bytes_00.tzt tzt_reference_test_suite/and_bytes-bytes_01.tzt tzt_reference_test_suite/and_bytes-bytes_02.tzt tzt_reference_test_suite/and_bytes-bytes_03.tzt tzt_reference_test_suite/and_bytes-bytes_04.tzt tzt_reference_test_suite/and_bytes-bytes_05.tzt tzt_reference_test_suite/and_bytes-bytes_06.tzt tzt_reference_test_suite/and_int-nat_00.tzt tzt_reference_test_suite/and_int-nat_01.tzt tzt_reference_test_suite/and_int-nat_02.tzt tzt_reference_test_suite/and_int-nat_03.tzt tzt_reference_test_suite/and_int-nat_04.tzt tzt_reference_test_suite/and_int-nat_05.tzt tzt_reference_test_suite/and_int-nat_06.tzt tzt_reference_test_suite/and_nat-nat_00.tzt tzt_reference_test_suite/and_nat-nat_01.tzt tzt_reference_test_suite/and_nat-nat_02.tzt tzt_reference_test_suite/apply_00.tzt tzt_reference_test_suite/apply_01.tzt tzt_reference_test_suite/apply_02.tzt tzt_reference_test_suite/balance_00.tzt tzt_reference_test_suite/car_00.tzt tzt_reference_test_suite/car_00.tc.tzt tzt_reference_test_suite/car_01.tzt tzt_reference_test_suite/cdr_00.tzt tzt_reference_test_suite/cdr_00.tc.tzt tzt_reference_test_suite/cdr_01.tzt tzt_reference_test_suite/chain_id_00.tzt tzt_reference_test_suite/chain_id_01.tzt tzt_reference_test_suite/checksignature_00.tzt tzt_reference_test_suite/checksignature_00.tc.tzt tzt_reference_test_suite/checksignature_01.tzt tzt_reference_test_suite/compare_00.tc.tzt tzt_reference_test_suite/compare_01.tc.tzt tzt_reference_test_suite/compare_02.tc.tzt tzt_reference_test_suite/compare_bool_00.tzt tzt_reference_test_suite/compare_bool_01.tzt tzt_reference_test_suite/compare_bool_02.tzt tzt_reference_test_suite/compare_bool_03.tzt tzt_reference_test_suite/compare_bytes_00.tzt tzt_reference_test_suite/compare_bytes_01.tzt tzt_reference_test_suite/compare_bytes_02.tzt tzt_reference_test_suite/compare_bytes_03.tzt tzt_reference_test_suite/compare_bytes_04.tzt tzt_reference_test_suite/compare_int_00.tzt tzt_reference_test_suite/compare_int_01.tzt tzt_reference_test_suite/compare_int_02.tzt tzt_reference_test_suite/compare_int_03.tzt tzt_reference_test_suite/compare_int_04.tzt tzt_reference_test_suite/compare_keyhash_00.tzt tzt_reference_test_suite/compare_keyhash_01.tzt tzt_reference_test_suite/compare_keyhash_02.tzt tzt_reference_test_suite/compare_mutez_00.tzt tzt_reference_test_suite/compare_mutez_01.tzt tzt_reference_test_suite/compare_mutez_02.tzt tzt_reference_test_suite/compare_mutez_03.tzt tzt_reference_test_suite/compare_mutez_04.tzt tzt_reference_test_suite/compare_mutez_05.tzt tzt_reference_test_suite/compare_nat_00.tzt tzt_reference_test_suite/compare_nat_01.tzt tzt_reference_test_suite/compare_nat_02.tzt tzt_reference_test_suite/compare_nat_03.tzt tzt_reference_test_suite/compare_nat_04.tzt tzt_reference_test_suite/compare_nat_05.tzt tzt_reference_test_suite/compare_pairintint_00.tzt tzt_reference_test_suite/compare_pairintint_01.tzt tzt_reference_test_suite/compare_pairintint_02.tzt tzt_reference_test_suite/compare_pairintint_03.tzt tzt_reference_test_suite/compare_string_00.tzt tzt_reference_test_suite/compare_string_01.tzt tzt_reference_test_suite/compare_string_02.tzt tzt_reference_test_suite/compare_string_03.tzt tzt_reference_test_suite/compare_string_04.tzt tzt_reference_test_suite/compare_timestamp_00.tzt tzt_reference_test_suite/compare_timestamp_01.tzt tzt_reference_test_suite/compare_timestamp_02.tzt tzt_reference_test_suite/compare_timestamp_03.tzt tzt_reference_test_suite/compare_timestamp_04.tzt tzt_reference_test_suite/compare_timestamp_05.tzt tzt_reference_test_suite/concat_bytes_00.tzt tzt_reference_test_suite/concat_bytes_01.tzt tzt_reference_test_suite/concat_listbytes_00.tzt tzt_reference_test_suite/concat_listbytes_01.tzt tzt_reference_test_suite/concat_listbytes_02.tzt tzt_reference_test_suite/concat_liststring_00.tzt tzt_reference_test_suite/concat_liststring_01.tzt tzt_reference_test_suite/concat_liststring_02.tzt tzt_reference_test_suite/concat_liststring_03.tzt tzt_reference_test_suite/concat_liststring_04.tzt tzt_reference_test_suite/concat_string_00.tzt tzt_reference_test_suite/concat_string_01.tzt tzt_reference_test_suite/concat_string_02.tzt tzt_reference_test_suite/cons_int_00.tzt tzt_reference_test_suite/cons_int_01.tzt tzt_reference_test_suite/cons_int_02.tzt tzt_reference_test_suite/cons_lists_00.tc.tzt tzt_reference_test_suite/cons_string_00.tzt tzt_reference_test_suite/contract_00.tzt tzt_reference_test_suite/contract_01.tzt tzt_reference_test_suite/contract_02.tzt tzt_reference_test_suite/contract_03.tzt tzt_reference_test_suite/contract_04.tzt tzt_reference_test_suite/contract_05.tzt tzt_reference_test_suite/createcontract_00.tzt tzt_reference_test_suite/createcontract_01.tzt tzt_reference_test_suite/dig_00.tzt tzt_reference_test_suite/dig_01.tzt tzt_reference_test_suite/dig_02.tzt tzt_reference_test_suite/dig_03.tzt tzt_reference_test_suite/dig_04.tzt tzt_reference_test_suite/dip_00.tzt tzt_reference_test_suite/dip_00.tc.tzt tzt_reference_test_suite/dip_01.tzt tzt_reference_test_suite/dip_02.tzt tzt_reference_test_suite/dipn_00.tzt tzt_reference_test_suite/dipn_00.tc.tzt tzt_reference_test_suite/dipn_01.tzt tzt_reference_test_suite/dipn_01.tc.tzt tzt_reference_test_suite/dipn_02.tzt tzt_reference_test_suite/dipn_02.tc.tzt tzt_reference_test_suite/dipn_03.tzt tzt_reference_test_suite/drop_00.tzt tzt_reference_test_suite/drop_00.tc.tzt tzt_reference_test_suite/dropn_00.tzt tzt_reference_test_suite/dropn_00.tc.tzt tzt_reference_test_suite/dropn_01.tzt tzt_reference_test_suite/dropn_02.tzt tzt_reference_test_suite/dropn_03.tzt tzt_reference_test_suite/dugn_00.tzt tzt_reference_test_suite/dup_00.tzt tzt_reference_test_suite/dup_00.tc.tzt tzt_reference_test_suite/dupn_00.tzt tzt_reference_test_suite/dupn_00.tc.tzt tzt_reference_test_suite/dupn_01.tzt tzt_reference_test_suite/dupn_01.tc.tzt tzt_reference_test_suite/dupn_02.tzt tzt_reference_test_suite/dupn_03.tzt tzt_reference_test_suite/dupn_04.tzt tzt_reference_test_suite/ediv_int-int_00.tzt tzt_reference_test_suite/ediv_int-int_01.tzt tzt_reference_test_suite/ediv_int-int_02.tzt tzt_reference_test_suite/ediv_int-int_03.tzt tzt_reference_test_suite/ediv_mutez-mutez_00.tzt tzt_reference_test_suite/ediv_mutez-mutez_01.tzt tzt_reference_test_suite/ediv_mutez-mutez_02.tzt tzt_reference_test_suite/ediv_mutez-mutez_03.tzt tzt_reference_test_suite/ediv_mutez-nat_00.tzt tzt_reference_test_suite/ediv_mutez-nat_01.tzt tzt_reference_test_suite/ediv_mutez-nat_02.tzt tzt_reference_test_suite/ediv_mutez-nat_03.tzt tzt_reference_test_suite/ediv_mutez-nat_04.tzt tzt_reference_test_suite/ediv_mutez-nat_05.tzt tzt_reference_test_suite/ediv_mutez-nat_06.tzt tzt_reference_test_suite/emptybigmap_nat-nat_00.tzt tzt_reference_test_suite/emptymap_nat-nat_00.tzt tzt_reference_test_suite/emptymap_string-string_00.tzt tzt_reference_test_suite/emptyset_nat_00.tzt tzt_reference_test_suite/eq_00.tzt tzt_reference_test_suite/eq_01.tzt tzt_reference_test_suite/eq_02.tzt tzt_reference_test_suite/eq_03.tzt tzt_reference_test_suite/eq_04.tzt tzt_reference_test_suite/exec_00.tzt tzt_reference_test_suite/exec_01.tzt tzt_reference_test_suite/exec_02.tzt tzt_reference_test_suite/exec_03.tzt tzt_reference_test_suite/failwith_00.tzt tzt_reference_test_suite/failwith_00.tc.tzt tzt_reference_test_suite/gas_exhaustion.tzt tzt_reference_test_suite/ge_00.tzt tzt_reference_test_suite/ge_01.tzt tzt_reference_test_suite/ge_02.tzt tzt_reference_test_suite/ge_03.tzt tzt_reference_test_suite/ge_04.tzt tzt_reference_test_suite/get_00.tc.tzt tzt_reference_test_suite/get_bigmapstringstring_00.tzt tzt_reference_test_suite/get_bigmapstringstring_01.tzt tzt_reference_test_suite/get_bigmapstringstring_02.tzt tzt_reference_test_suite/get_map_00.tc.tzt tzt_reference_test_suite/get_mapintint_00.tzt tzt_reference_test_suite/get_mapintint_01.tzt tzt_reference_test_suite/get_mapstringstring_00.tzt tzt_reference_test_suite/get_mapstringstring_01.tzt tzt_reference_test_suite/get_mapstringstring_02.tzt tzt_reference_test_suite/gt_00.tzt tzt_reference_test_suite/gt_00.tc.tzt tzt_reference_test_suite/gt_01.tzt tzt_reference_test_suite/gt_02.tzt tzt_reference_test_suite/gt_03.tzt tzt_reference_test_suite/gt_04.tzt tzt_reference_test_suite/if_00.tzt tzt_reference_test_suite/if_00.tc.tzt tzt_reference_test_suite/if_01.tzt tzt_reference_test_suite/if_01.tc.tzt tzt_reference_test_suite/ifcons_00.tc.tzt tzt_reference_test_suite/ifcons_listint_00.tzt tzt_reference_test_suite/ifcons_listint_01.tzt tzt_reference_test_suite/ifcons_listnat_00.tzt tzt_reference_test_suite/ifcons_listnat_01.tzt tzt_reference_test_suite/ifleft_00.tc.tzt tzt_reference_test_suite/ifleft_orintstring_00.tzt tzt_reference_test_suite/ifleft_orstringint_00.tzt tzt_reference_test_suite/ifnone_00.tc.tzt tzt_reference_test_suite/ifnone_optionint_00.tzt tzt_reference_test_suite/ifnone_optionnat_00.tzt tzt_reference_test_suite/implicitaccount_00.tzt tzt_reference_test_suite/int_00.tc.tzt tzt_reference_test_suite/int_nat_00.tzt tzt_reference_test_suite/int_nat_01.tzt tzt_reference_test_suite/isnat_00.tzt tzt_reference_test_suite/isnat_01.tzt tzt_reference_test_suite/iter_00.tc.tzt tzt_reference_test_suite/iter_listint_00.tzt tzt_reference_test_suite/iter_listint_01.tzt tzt_reference_test_suite/iter_listint_02.tzt tzt_reference_test_suite/iter_listint_03.tzt tzt_reference_test_suite/iter_liststring_00.tzt tzt_reference_test_suite/iter_liststring_01.tzt tzt_reference_test_suite/iter_mapintint_00.tzt tzt_reference_test_suite/iter_mapintint_01.tzt tzt_reference_test_suite/iter_mapintint_02.tzt tzt_reference_test_suite/iter_mapintint_03.tzt tzt_reference_test_suite/iter_mapintint_04.tzt tzt_reference_test_suite/iter_mapstringstring_00.tzt tzt_reference_test_suite/iter_setint_00.tzt tzt_reference_test_suite/iter_setint_01.tzt tzt_reference_test_suite/iter_setint_02.tzt tzt_reference_test_suite/iter_setstring_00.tzt tzt_reference_test_suite/iter_setstring_01.tzt tzt_reference_test_suite/iter_setstring_02.tzt tzt_reference_test_suite/join_tickets_00.tzt tzt_reference_test_suite/join_tickets_01.tzt tzt_reference_test_suite/join_tickets_02.tzt tzt_reference_test_suite/join_tickets_03.tzt tzt_reference_test_suite/le_00.tzt tzt_reference_test_suite/le_01.tzt tzt_reference_test_suite/le_02.tzt tzt_reference_test_suite/le_03.tzt tzt_reference_test_suite/le_04.tzt tzt_reference_test_suite/left_int-nat_00.tzt tzt_reference_test_suite/loop_00.tzt tzt_reference_test_suite/loop_00.tc.tzt tzt_reference_test_suite/loop_01.tzt tzt_reference_test_suite/loop_01.tc.tzt tzt_reference_test_suite/loop_02.tzt tzt_reference_test_suite/loopleft_00.tzt tzt_reference_test_suite/loopleft_01.tzt tzt_reference_test_suite/loopleft_02.tzt tzt_reference_test_suite/loopleft_03.tzt tzt_reference_test_suite/loopleft_04.tzt tzt_reference_test_suite/lsl_00.tzt tzt_reference_test_suite/lsl_01.tzt tzt_reference_test_suite/lsl_02.tzt tzt_reference_test_suite/lsl_03.tzt tzt_reference_test_suite/lsl_04.tzt tzt_reference_test_suite/lsl_05.tzt tzt_reference_test_suite/lsl_06.tzt tzt_reference_test_suite/lsr_00.tzt tzt_reference_test_suite/lsr_01.tzt tzt_reference_test_suite/lsr_02.tzt tzt_reference_test_suite/lsr_03.tzt tzt_reference_test_suite/lsr_04.tzt tzt_reference_test_suite/lsr_05.tzt tzt_reference_test_suite/lt_00.tzt tzt_reference_test_suite/lt_01.tzt tzt_reference_test_suite/lt_02.tzt tzt_reference_test_suite/lt_03.tzt tzt_reference_test_suite/lt_04.tzt tzt_reference_test_suite/macro_pack/assert_00.tzt tzt_reference_test_suite/map_listint_00.tzt tzt_reference_test_suite/map_listint_01.tzt tzt_reference_test_suite/map_listint_02.tzt tzt_reference_test_suite/map_listint_03.tzt tzt_reference_test_suite/map_listint_04.tzt tzt_reference_test_suite/map_listint_05.tzt tzt_reference_test_suite/map_listint_06.tzt tzt_reference_test_suite/map_liststring_00.tzt tzt_reference_test_suite/map_liststring_01.tzt tzt_reference_test_suite/map_liststring_02.tzt tzt_reference_test_suite/map_liststring_04.tzt tzt_reference_test_suite/map_liststring_05.tzt tzt_reference_test_suite/map_liststring_06.tzt tzt_reference_test_suite/map_liststring_07.tzt tzt_reference_test_suite/map_liststring_08.tzt tzt_reference_test_suite/map_mapintint_00.tzt tzt_reference_test_suite/map_mapintint_01.tzt tzt_reference_test_suite/map_mapintstring_00.tzt tzt_reference_test_suite/map_mapintstring_01.tzt tzt_reference_test_suite/map_mapstringnat_00.tzt tzt_reference_test_suite/map_mapstringnat_01.tzt tzt_reference_test_suite/map_mapstringnat_02.tzt tzt_reference_test_suite/mem_bigmapnatnat_00.tzt tzt_reference_test_suite/mem_bigmapnatnat_01.tzt tzt_reference_test_suite/mem_bigmapnatnat_02.tzt tzt_reference_test_suite/mem_bigmapnatnat_03.tzt tzt_reference_test_suite/mem_bigmapnatnat_04.tzt tzt_reference_test_suite/mem_bigmapnatnat_05.tzt tzt_reference_test_suite/mem_bigmapstringnat_00.tzt tzt_reference_test_suite/mem_bigmapstringnat_01.tzt tzt_reference_test_suite/mem_bigmapstringnat_02.tzt tzt_reference_test_suite/mem_bigmapstringnat_03.tzt tzt_reference_test_suite/mem_bigmapstringnat_04.tzt tzt_reference_test_suite/mem_bigmapstringnat_05.tzt tzt_reference_test_suite/mem_mapintint_00.tzt tzt_reference_test_suite/mem_mapnatnat_00.tzt tzt_reference_test_suite/mem_mapnatnat_01.tzt tzt_reference_test_suite/mem_mapnatnat_02.tzt tzt_reference_test_suite/mem_mapnatnat_03.tzt tzt_reference_test_suite/mem_mapnatnat_04.tzt tzt_reference_test_suite/mem_mapnatnat_05.tzt tzt_reference_test_suite/mem_mapstringnat_00.tzt tzt_reference_test_suite/mem_mapstringnat_01.tzt tzt_reference_test_suite/mem_mapstringnat_02.tzt tzt_reference_test_suite/mem_mapstringnat_03.tzt tzt_reference_test_suite/mem_mapstringnat_04.tzt tzt_reference_test_suite/mem_mapstringnat_05.tzt tzt_reference_test_suite/mem_setint_00.tzt tzt_reference_test_suite/mem_setint_01.tzt tzt_reference_test_suite/mem_setstring_00.tzt tzt_reference_test_suite/mem_setstring_01.tzt tzt_reference_test_suite/mem_setstring_02.tzt tzt_reference_test_suite/mul_int-int_00.tzt tzt_reference_test_suite/mul_int-nat_00.tzt tzt_reference_test_suite/mul_mutez-nat_00.tzt tzt_reference_test_suite/mul_mutez-nat_01.tzt tzt_reference_test_suite/mul_nat-int_00.tzt tzt_reference_test_suite/mul_nat-mutez_00.tzt tzt_reference_test_suite/mul_nat-mutez_01.tzt tzt_reference_test_suite/mul_nat-nat_00.tzt tzt_reference_test_suite/neg_int_00.tzt tzt_reference_test_suite/neg_int_01.tzt tzt_reference_test_suite/neg_int_02.tzt tzt_reference_test_suite/neg_nat_00.tzt tzt_reference_test_suite/neg_nat_01.tzt tzt_reference_test_suite/neq_00.tzt tzt_reference_test_suite/neq_01.tzt tzt_reference_test_suite/neq_02.tzt tzt_reference_test_suite/neq_03.tzt tzt_reference_test_suite/neq_04.tzt tzt_reference_test_suite/nil_nat_00.tzt tzt_reference_test_suite/none_int_00.tzt tzt_reference_test_suite/none_pair-nat-string.tzt tzt_reference_test_suite/not_bool_00.tzt tzt_reference_test_suite/not_bool_01.tzt tzt_reference_test_suite/not_bytes_00.tzt tzt_reference_test_suite/not_bytes_01.tzt tzt_reference_test_suite/not_bytes_02.tzt tzt_reference_test_suite/not_bytes_03.tzt tzt_reference_test_suite/not_bytes_04.tzt tzt_reference_test_suite/not_bytes_05.tzt tzt_reference_test_suite/not_int_00.tzt tzt_reference_test_suite/not_nat_00.tzt tzt_reference_test_suite/not_nat_01.tzt tzt_reference_test_suite/not_nat_02.tzt tzt_reference_test_suite/not_nat_03.tzt tzt_reference_test_suite/not_nat_04.tzt tzt_reference_test_suite/not_nat_05.tzt tzt_reference_test_suite/not_nat_06.tzt tzt_reference_test_suite/not_nat_07.tzt tzt_reference_test_suite/now_00.tzt tzt_reference_test_suite/or_bool-bool_00.tzt tzt_reference_test_suite/or_bool-bool_01.tzt tzt_reference_test_suite/or_bool-bool_02.tzt tzt_reference_test_suite/or_bool-bool_03.tzt tzt_reference_test_suite/or_bytes-bytes_00.tzt tzt_reference_test_suite/or_bytes-bytes_01.tzt tzt_reference_test_suite/or_bytes-bytes_02.tzt tzt_reference_test_suite/or_bytes-bytes_03.tzt tzt_reference_test_suite/or_bytes-bytes_04.tzt tzt_reference_test_suite/or_bytes-bytes_05.tzt tzt_reference_test_suite/or_bytes-bytes_06.tzt tzt_reference_test_suite/or_nat-nat_00.tzt tzt_reference_test_suite/or_nat-nat_01.tzt tzt_reference_test_suite/or_nat-nat_02.tzt tzt_reference_test_suite/or_nat-nat_03.tzt tzt_reference_test_suite/or_nat-nat_04.tzt tzt_reference_test_suite/or_nat-nat_05.tzt tzt_reference_test_suite/or_nat-nat_06.tzt tzt_reference_test_suite/pack_address_00.tzt tzt_reference_test_suite/pack_address_01.tzt tzt_reference_test_suite/pack_address_02.tzt tzt_reference_test_suite/pack_address_03.tzt tzt_reference_test_suite/pack_address_04.tzt tzt_reference_test_suite/pack_address_05.tzt tzt_reference_test_suite/pack_bool_00.tzt tzt_reference_test_suite/pack_bool_01.tzt tzt_reference_test_suite/pack_bytes_00.tzt tzt_reference_test_suite/pack_bytes_01.tzt tzt_reference_test_suite/pack_bytes_02.tzt tzt_reference_test_suite/pack_chainid_00.tzt tzt_reference_test_suite/pack_contract_00.tzt tzt_reference_test_suite/pack_key_00.tzt tzt_reference_test_suite/pack_key_01.tzt tzt_reference_test_suite/pack_key_02.tzt tzt_reference_test_suite/pack_key_03.tzt tzt_reference_test_suite/pack_keyhash_01.tzt tzt_reference_test_suite/pack_keyhash_02.tzt tzt_reference_test_suite/pack_keyhash_03.tzt tzt_reference_test_suite/pack_keyhash_04.tzt tzt_reference_test_suite/pack_lambda_comb_pairs.tzt tzt_reference_test_suite/pack_list-bool_00.tzt tzt_reference_test_suite/pack_list-bool_01.tzt tzt_reference_test_suite/pack_list-list-bool.tzt tzt_reference_test_suite/pack_list_large_00.tzt tzt_reference_test_suite/pack_map-bool-unit_00.tzt tzt_reference_test_suite/pack_operation_00.tc.tzt tzt_reference_test_suite/pack_option-unit_00.tzt tzt_reference_test_suite/pack_option-unit_01.tzt tzt_reference_test_suite/pack_or-unit-bool_00.tzt tzt_reference_test_suite/pack_or-unit-bool_01.tzt tzt_reference_test_suite/pack_pair-bool-unit_00.tzt tzt_reference_test_suite/pack_signature_00.tzt tzt_reference_test_suite/pack_signature_01.tzt tzt_reference_test_suite/pack_signature_02.tzt tzt_reference_test_suite/pack_signature_03.tzt tzt_reference_test_suite/pack_string_00.tzt tzt_reference_test_suite/pack_string_01.tzt tzt_reference_test_suite/pack_string_02.tzt tzt_reference_test_suite/pack_string_03.tzt tzt_reference_test_suite/pack_unit_00.tzt tzt_reference_test_suite/packunpack_address_00.tzt tzt_reference_test_suite/packunpack_bool_00.tzt tzt_reference_test_suite/packunpack_bytes_00.tzt tzt_reference_test_suite/packunpack_int_00.tzt tzt_reference_test_suite/packunpack_keyhash_00.tzt tzt_reference_test_suite/packunpack_mutez_00.tzt tzt_reference_test_suite/packunpack_nat_00.tzt tzt_reference_test_suite/packunpack_string_00.tzt tzt_reference_test_suite/packunpack_timestamp_00.tzt tzt_reference_test_suite/pair_00.tc.tzt tzt_reference_test_suite/pair_int-int_00.tzt tzt_reference_test_suite/pair_nat-string_00.tzt tzt_reference_test_suite/pair_pair-nat-string-pair-string-nat_00.tzt tzt_reference_test_suite/push_00.tc.tzt tzt_reference_test_suite/push_int_00.tzt tzt_reference_test_suite/push_string_00.tzt tzt_reference_test_suite/read_ticket_00.tzt tzt_reference_test_suite/right_nat-int_00.tzt tzt_reference_test_suite/self_00.tzt tzt_reference_test_suite/self_01.tzt tzt_reference_test_suite/self_in_lambda.tc.tzt tzt_reference_test_suite/sender_00.tzt tzt_reference_test_suite/setdelegate_00.tzt tzt_reference_test_suite/setdelegate_00.tc.tzt tzt_reference_test_suite/size_bytes_00.tzt tzt_reference_test_suite/size_listint_00.tzt tzt_reference_test_suite/size_listint_01.tzt tzt_reference_test_suite/size_listint_02.tzt tzt_reference_test_suite/size_listint_03.tzt tzt_reference_test_suite/size_mapintint_00.tzt tzt_reference_test_suite/size_mapstringnat_00.tzt tzt_reference_test_suite/size_mapstringnat_01.tzt tzt_reference_test_suite/size_mapstringnat_02.tzt tzt_reference_test_suite/size_mapstringnat_03.tzt tzt_reference_test_suite/size_setint_00.tzt tzt_reference_test_suite/size_setint_01.tzt tzt_reference_test_suite/size_setint_02.tzt tzt_reference_test_suite/size_setint_03.tzt tzt_reference_test_suite/size_setstring_00.tzt tzt_reference_test_suite/size_string_00.tzt tzt_reference_test_suite/slice_bytes_00.tzt tzt_reference_test_suite/slice_bytes_01.tzt tzt_reference_test_suite/slice_bytes_02.tzt tzt_reference_test_suite/slice_bytes_03.tzt tzt_reference_test_suite/slice_bytes_04.tzt tzt_reference_test_suite/slice_string_00.tzt tzt_reference_test_suite/slice_string_01.tzt tzt_reference_test_suite/slice_string_02.tzt tzt_reference_test_suite/slice_string_03.tzt tzt_reference_test_suite/slice_string_04.tzt tzt_reference_test_suite/slice_string_05.tzt tzt_reference_test_suite/some_00.tc.tzt tzt_reference_test_suite/some_int_00.tzt tzt_reference_test_suite/some_pairintint_00.tzt tzt_reference_test_suite/some_string_00.tzt tzt_reference_test_suite/source_00.tzt tzt_reference_test_suite/split_ticket_00.tzt tzt_reference_test_suite/split_ticket_01.tzt tzt_reference_test_suite/split_ticket_02.tzt tzt_reference_test_suite/split_ticket_03.tzt tzt_reference_test_suite/split_ticket_04.tzt tzt_reference_test_suite/sub_int-int_00.tzt tzt_reference_test_suite/sub_int-int_01.tzt tzt_reference_test_suite/sub_mutez-mutez_00.tzt tzt_reference_test_suite/sub_mutez-mutez_01.tzt tzt_reference_test_suite/sub_timestamp-int_00.tzt tzt_reference_test_suite/sub_timestamp-int_01.tzt tzt_reference_test_suite/sub_timestamp-int_02.tzt tzt_reference_test_suite/sub_timestamp-int_03.tzt tzt_reference_test_suite/sub_timestamp-int_04.tzt tzt_reference_test_suite/sub_timestamp-timestamp_00.tzt tzt_reference_test_suite/sub_timestamp-timestamp_01.tzt tzt_reference_test_suite/sub_timestamp-timestamp_02.tzt tzt_reference_test_suite/sub_timestamp-timestamp_03.tzt tzt_reference_test_suite/swap_00.tzt tzt_reference_test_suite/swap_00.tc.tzt tzt_reference_test_suite/swap_01.tc.tzt tzt_reference_test_suite/ticket_00.tzt tzt_reference_test_suite/ticket_01.tzt tzt_reference_test_suite/transfertokens_00.tzt tzt_reference_test_suite/transfertokens_00.tc.tzt tzt_reference_test_suite/transfertokens_01.tzt tzt_reference_test_suite/unit_00.tzt tzt_reference_test_suite/unpair_00.tc.tzt tzt_reference_test_suite/unpair_pairstringstring_00.tzt tzt_reference_test_suite/update_00.tc.tzt tzt_reference_test_suite/update_bigmapstringstring_00.tzt tzt_reference_test_suite/update_bigmapstringstring_01.tzt tzt_reference_test_suite/update_bigmapstringstring_02.tzt tzt_reference_test_suite/update_bigmapstringstring_03.tzt tzt_reference_test_suite/update_bigmapstringstring_04.tzt tzt_reference_test_suite/update_bigmapstringstring_05.tzt tzt_reference_test_suite/update_bigmapstringstring_06.tzt tzt_reference_test_suite/update_bigmapstringstring_07.tzt tzt_reference_test_suite/update_mapintint_00.tzt tzt_reference_test_suite/update_mapintint_01.tzt tzt_reference_test_suite/update_setint_00.tzt tzt_reference_test_suite/update_setint_01.tzt tzt_reference_test_suite/update_setint_02.tzt tzt_reference_test_suite/xor_bool-bool_00.tzt tzt_reference_test_suite/xor_bool-bool_01.tzt tzt_reference_test_suite/xor_bool-bool_02.tzt tzt_reference_test_suite/xor_bool-bool_03.tzt tzt_reference_test_suite/xor_bytes-bytes_00.tzt tzt_reference_test_suite/xor_bytes-bytes_01.tzt tzt_reference_test_suite/xor_bytes-bytes_02.tzt tzt_reference_test_suite/xor_bytes-bytes_03.tzt tzt_reference_test_suite/xor_bytes-bytes_04.tzt tzt_reference_test_suite/xor_bytes-bytes_05.tzt tzt_reference_test_suite/xor_bytes-bytes_06.tzt tzt_reference_test_suite/xor_nat-nat_00.tzt tzt_reference_test_suite/xor_nat-nat_01.tzt tzt_reference_test_suite/xor_nat-nat_02.tzt tzt_reference_test_suite/xor_nat-nat_03.tzt tzt_reference_test_suite/xor_nat-nat_04.tzt tzt_reference_test_suite/xor_nat-nat_05.tzt tzt_reference_test_suite/xor_nat-nat_06.tzt tzt_reference_test_suite/transfertokens_01.tzt: Got output: { Stack_elt operation @@ -14,6 +14,16 @@ Expected: { Stack_elt operation (Transfer_tokens Unit 5 "tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" _) } +tzt_reference_test_suite/ticket_01.tzt: +Got output: StaticError "Error:\n Contract_storage.Failure \"get_balance\"\n" +Expected: { Stack_elt (option (ticket string)) None } + +tzt_reference_test_suite/ticket_00.tzt: +Got output: StaticError "Error:\n Contract_storage.Failure \"get_balance\"\n" +Expected: { Stack_elt + (option (ticket string)) + (Some (Pair "KT1Q36KWPSba7dHsH5E4ZsQHehrChc51e19d" "Blue" 42)) } + tzt_reference_test_suite/setdelegate_00.tzt: Got output: { Stack_elt operation @@ -54,6 +64,6 @@ Expected: { Stack_elt _) ; Stack_elt address _ } -Test results: Passed:546 Failed:5 Total:551 +Test results: Passed:556 Failed:7 Total:563 Fatal error: Some tests have failed -- GitLab