balsoft/ligo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'rinderknecht@contracts' into 'dev'

Browse Source 
Refactoring of the test contracts

See merge request ligolang/ligo!465
This commit is contained in:
Pierre-Emmanuel Wulfman 2020-03-04 19:26:50 +00:00
commit adc31a6e01
174 changed files with 1475 additions and 1717 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

126
src/bin/expect_tests/contract_tests.ml
View File

@ -7,7 +7,7 @@ let bad_contract basename =
let%expect_test _ =
run_ligo_good [ "measure-contract" ; contract "coase.ligo" ; "main" ] ;
[%expect {| 1747 bytes |}] ;
[%expect {| 1870 bytes |}] ;
run_ligo_good [ "measure-contract" ; contract "multisig.ligo" ; "main" ] ;
[%expect {| 1324 bytes |}] ;
@ -16,7 +16,7 @@ let%expect_test _ =
[%expect {| 3231 bytes |}] ;
run_ligo_good [ "measure-contract" ; contract "vote.mligo" ; "main" ] ;
[%expect {| 642 bytes |}] ;
[%expect {| 589 bytes |}] ;
run_ligo_good [ "compile-parameter" ; contract "coase.ligo" ; "main" ; "Buy_single (record card_to_buy = 1n end)" ] ;
[%expect {| (Left (Left 1)) |}] ;
@ -86,7 +86,9 @@ let%expect_test _ =
SWAP ;
DIP { DUP ; CAR ; CAR } ;
GET ;
IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
IF_NONE
{ PUSH string "buy_single: No card pattern." ; FAILWITH }
{ DUP ; DIP { DROP } } ;
DUP ;
CAR ;
DIP { DUP ; CDR ; PUSH nat 1 ; ADD } ;
@ -159,7 +161,9 @@ let%expect_test _ =
SWAP ;
DIP { DUP ; CAR ; CDR } ;
GET ;
IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
IF_NONE
{ PUSH string "sell_single: No card." ; FAILWITH }
{ DUP ; DIP { DROP } } ;
DUP ;
CAR ;
SENDER ;
@ -173,7 +177,9 @@ let%expect_test _ =
CDR ;
DIP { DIP 2 { DUP } ; DIG 2 ; CAR ; CAR } ;
GET ;
IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
IF_NONE
{ PUSH string "sell_single: No card pattern." ; FAILWITH }
{ DUP ; DIP { DROP } } ;
DUP ;
DIP { DUP } ;
SWAP ;
@ -209,7 +215,9 @@ let%expect_test _ =
MUL ;
SENDER ;
CONTRACT unit ;
IF_NONE { PUSH string "bad address for get_contract" ; FAILWITH } {} ;
IF_NONE
{ PUSH string "sell_single: No contract." ; FAILWITH }
{ DUP ; DIP { DROP } } ;
DIP { DUP } ;
SWAP ;
DIP { DUP } ;
@ -246,7 +254,9 @@ let%expect_test _ =
CAR ;
DIP { DUP } ;
GET ;
IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
IF_NONE
{ PUSH string "transfer_single: No card." ; FAILWITH }
{ DUP ; DIP { DROP } } ;
DUP ;
CAR ;
SENDER ;
@ -938,39 +948,26 @@ let%expect_test _ =
run_ligo_good [ "compile-contract" ; contract "vote.mligo" ; "main" ] ;
[%expect {|
{ parameter
(or (pair %init
(pair (timestamp %beginning_time) (timestamp %finish_time))
(string %title))
(string %vote)) ;
(or (pair %reset (pair (timestamp %finish_time) (timestamp %start_time)) (string %title))
(or %vote (unit %nay) (unit %yea))) ;
storage
(pair (pair (pair (timestamp %beginning_time) (map %candidates string int))
(pair (timestamp %finish_time) (string %title)))
(set %voters address)) ;
(pair (pair (pair (timestamp %finish_time) (nat %nay))
(pair (timestamp %start_time) (string %title)))
(pair (set %voters address) (nat %yea))) ;
code { DUP ;
DUP ;
CAR ;
IF_LEFT
{ DUP ;
DIP { DIP { DUP } ; SWAP ; CDR } ;
PAIR ;
DUP ;
CAR ;
CAR ;
CAR ;
DIP { PUSH int 0 ;
SOME ;
DIP { PUSH int 0 ;
SOME ;
EMPTY_MAP string int ;
PUSH nat 0 ;
SWAP ;
PUSH string "Yes" ;
UPDATE } ;
PUSH string "No" ;
UPDATE } ;
PAIR ;
DIP { DUP ; CAR ; CAR ; CDR ; DIP { DUP ; CAR ; CDR } ; PAIR } ;
DIP { DUP ; CAR ; CDR ; DIP { DUP ; CDR } ; PAIR } ;
PAIR ;
EMPTY_SET address ;
SWAP ;
DIP { PUSH nat 0 ; EMPTY_SET address ; PAIR } ;
PAIR ;
NIL operation ;
PAIR ;
@ -979,41 +976,56 @@ let%expect_test _ =
DIP { DIP { DUP } ; SWAP ; CDR } ;
PAIR ;
DUP ;
CDR ;
DIP { DUP } ;
SWAP ;
CAR ;
DIP { DUP ; CDR ; CAR ; CAR ; CDR } ;
GET ;
IF_NONE { PUSH string "MAP FIND" ; FAILWITH } {} ;
IF_LEFT
{ DIP { DUP } ;
SWAP ;
DIP 2 { DUP } ;
DIG 2 ;
CAR ;
CAR ;
CDR ;
PUSH nat 1 ;
ADD ;
DIP { DUP ; CDR ; SWAP ; CAR ; DUP ; CDR ; SWAP ; CAR ; CAR } ;
SWAP ;
PAIR ;
PAIR ;
PAIR ;
DIP { DROP } }
{ DIP { DUP } ;
SWAP ;
DIP 2 { DUP } ;
DIG 2 ;
CDR ;
CDR ;
PUSH nat 1 ;
ADD ;
DIP { DUP ; CAR ; SWAP ; CDR ; CAR } ;
SWAP ;
PAIR ;
SWAP ;
PAIR ;
DIP { DROP } } ;
DUP ;
DIP { DUP } ;
SWAP ;
CDR ;
CAR ;
CAR ;
CAR ;
DIP { DIP { DUP } ;
SWAP ;
CAR ;
DIP { DUP ;
PUSH int 1 ;
ADD ;
SOME ;
DIP { DIP { DUP } ; SWAP ; CDR ; CAR ; CAR ; CDR } } ;
UPDATE } ;
PUSH bool True ;
SENDER ;
UPDATE ;
DIP { DUP ; CAR ; SWAP ; CDR ; CDR } ;
PAIR ;
DIP { DIP { DUP } ;
SWAP ;
CDR ;
CAR ;
CDR ;
CAR ;
DIP { DIP { DUP } ; SWAP ; CDR ; CAR ; CDR ; CDR } ;
PAIR } ;
PAIR ;
DIP { DIP { DUP } ; SWAP ; CDR ; CDR ; PUSH bool True ; SENDER ; UPDATE } ;
PAIR ;
NIL operation ;
PAIR ;
DIP { DROP 3 } } ;
DIP { DROP } } } |}]
DIP { DROP 4 } } ;
DIP { DROP 2 } } } |}]
let%expect_test _ =
run_ligo_good [ "compile-contract" ; contract "implicit.mligo" ; "main" ] ;
@ -1054,7 +1066,7 @@ let%expect_test _ =
let%expect_test _ =
run_ligo_bad [ "compile-contract" ; contract "bad_address_format.religo" ; "main" ] ;
[%expect {|
ligo: in file "bad_address_format.religo", line 2, characters 25-47. Badly formatted literal: @"KT1badaddr" {"location":"in file \"bad_address_format.religo\", line 2, characters 25-47"}
ligo: in file "bad_address_format.religo", line 2, characters 26-48. Badly formatted literal: @"KT1badaddr" {"location":"in file \"bad_address_format.religo\", line 2, characters 26-48"}
If you're not sure how to fix this error, you can
@ -1149,7 +1161,7 @@ let%expect_test _ =
let%expect_test _ =
run_ligo_bad [ "compile-contract" ; bad_contract "create_contract_toplevel.mligo" ; "main" ] ;
[%expect {|
ligo: in file "create_contract_toplevel.mligo", line 4, character 35 to line 8, character 8. No free variable allowed in this lambda: variable 'store' {"expression":"CREATE_CONTRACT(lambda (#P : ( nat * string ):Some(( nat * string ))) : None return let rhs#756 = #P in let p = rhs#756.0 in let s = rhs#756.1 in ( list[] : (TO_list(operation)) , store ) , NONE() : (TO_option(key_hash)) , 300000000mutez , \"un\")","location":"in file \"create_contract_toplevel.mligo\", line 4, character 35 to line 8, character 8"}
ligo: in file "create_contract_toplevel.mligo", line 4, character 35 to line 8, character 8. No free variable allowed in this lambda: variable 'store' {"expression":"CREATE_CONTRACT(lambda (#P : ( nat * string ):Some(( nat * string ))) : None return let rhs#808 = #P in let p = rhs#808.0 in let s = rhs#808.1 in ( list[] : (TO_list(operation)) , store ) , NONE() : (TO_option(key_hash)) , 300000000mutez , \"un\")","location":"in file \"create_contract_toplevel.mligo\", line 4, character 35 to line 8, character 8"}
If you're not sure how to fix this error, you can
@ -1162,7 +1174,7 @@ let%expect_test _ =
run_ligo_bad [ "compile-contract" ; bad_contract "create_contract_var.mligo" ; "main" ] ;
[%expect {|
ligo: in file "create_contract_var.mligo", line 6, character 35 to line 10, character 5. No free variable allowed in this lambda: variable 'a' {"expression":"CREATE_CONTRACT(lambda (#P : ( nat * int ):Some(( nat * int ))) : None return let rhs#759 = #P in let p = rhs#759.0 in let s = rhs#759.1 in ( list[] : (TO_list(operation)) , a ) , NONE() : (TO_option(key_hash)) , 300000000mutez , 1)","location":"in file \"create_contract_var.mligo\", line 6, character 35 to line 10, character 5"}
ligo: in file "create_contract_var.mligo", line 6, character 35 to line 10, character 5. No free variable allowed in this lambda: variable 'a' {"expression":"CREATE_CONTRACT(lambda (#P : ( nat * int ):Some(( nat * int ))) : None return let rhs#811 = #P in let p = rhs#811.0 in let s = rhs#811.1 in ( list[] : (TO_list(operation)) , a ) , NONE() : (TO_option(key_hash)) , 300000000mutez , 1)","location":"in file \"create_contract_var.mligo\", line 6, character 35 to line 10, character 5"}
If you're not sure how to fix this error, you can

13
src/passes/operators/operators.ml
View File

@ -89,7 +89,6 @@ module Simplify = struct
| "Tezos.failwith" -> ok C_FAILWITH
| "failwith" -> ok C_FAILWITH
| "Tezos.create_contract" -> ok C_CREATE_CONTRACT
| "Tezos.transaction" -> ok C_CALL
| "transaction" -> ok C_CALL (* Deprecated *)
| "Tezos.set_delegate" -> ok C_SET_DELEGATE
@ -145,7 +144,7 @@ module Simplify = struct
| "Bytes.unpack" -> ok C_BYTES_UNPACK
| "bytes_unpack" -> ok C_BYTES_UNPACK (* Deprecated *)
| "Bytes.length" -> ok C_SIZE
| "Bytes.size" -> ok C_SIZE
| "Bytes.size" -> ok C_SIZE (* Deprecated *)
| "bytes_concat" -> ok C_CONCAT (* Deprecated *)
| "Bytes.concat" -> ok C_CONCAT
| "Bytes.slice" -> ok C_SLICE
@ -166,7 +165,8 @@ module Simplify = struct
(* Set module *)
| "Set.size" -> ok C_SIZE
| "Set.cardinal" -> ok C_SIZE
| "Set.size" -> ok C_SIZE (* Deprecated *)
| "set_size" -> ok C_SIZE (* Deprecated *)
| "set_empty" -> ok C_SET_EMPTY (* Deprecated *)
| "Set.mem" -> ok C_SET_MEM
@ -326,9 +326,9 @@ module Simplify = struct
| "Bytes.pack" -> ok C_BYTES_PACK
| "Bytes.unpack" -> ok C_BYTES_UNPACK
| "Bytes.length" -> ok C_SIZE
| "Bytes.size" -> ok C_SIZE
| "Bytes.size" -> ok C_SIZE (* Deprecated *)
| "Bytes.concat" -> ok C_CONCAT
| "Bytes.slice" -> ok C_SLICE
| "Bytes.slice" -> ok C_SLICE (* Deprecated *)
| "Bytes.sub" -> ok C_SLICE
(* List module *)
@ -348,7 +348,8 @@ module Simplify = struct
| "Set.add" -> ok C_SET_ADD
| "Set.remove" -> ok C_SET_REMOVE
| "Set.fold" -> ok C_SET_FOLD
| "Set.size" -> ok C_SIZE
| "Set.size" -> ok C_SIZE (* Deprecated *)
| "Set.cardinal" -> ok C_SIZE
(* Map module *)

6
src/test/contracts/address.ligo
View File

@ -1,5 +1,3 @@
// function main (const c : contract (unit)) : address is address (c)
function main (const p : key_hash) : address is block {
const c : contract (unit) = implicit_account (p);
} with address (c)
const c : contract (unit) = Tezos.implicit_account (p);
} with Tezos.address (c)

4
src/test/contracts/address.mligo
View File

@ -1,3 +1,3 @@
let main (p : key_hash) =
let c : unit contract = Current.implicit_account p in
Current.address c
let c : unit contract = Tezos.implicit_account p
in Tezos.address c

4
src/test/contracts/address.religo
View File

@ -1,4 +1,4 @@
let main = (p : key_hash) : address => {
let c : contract(unit) = Current.implicit_account(p) ;
Current.address(c) ;
let c : contract (unit) = Tezos.implicit_account (p);
Tezos.address(c);
};

9
src/test/contracts/amount.ligo
View File

@ -1,8 +1,5 @@
function check (const p : unit) : int is
begin
block {
var result : int := 0;
if amount = 100tz then
result := 42
else
result := 0
end with result
if amount = 100tez then result := 42 else result := 0
} with result

2
src/test/contracts/amount.mligo
View File

@ -1 +1 @@
let check_ (p: unit) : int = if Current.amount = 100tz then 42 else 0
let check_ (p : unit) : int = if Tezos.amount = 100tez then 42 else 0

7
src/test/contracts/amount.religo
View File

@ -1,7 +1,2 @@
let check_ = (p : unit) : int =>
if (Current.amount == 100tz) {
42;
}
else {
0;
};
if (Tezos.amount == 100tez) { 42; } else { 0; };

8
src/test/contracts/arithmetic.ligo
View File

@ -1,15 +1,7 @@
// Test PascaLIGO arithmetic operators
function mod_op (const n : int) : nat is n mod 42
function plus_op (const n : int) : int is n + 42
function minus_op (const n : int) : int is n - 42
function times_op (const n : int) : int is n * 42
function div_op (const n : int) : int is n / 2
function int_op (const n : nat) : int is int (n)
function neg_op (const n : int) : int is -n

34
src/test/contracts/arithmetic.mligo
View File

@ -1,30 +1,8 @@
// Test CameLIGO arithmetic operators
let mod_op (n : int) : nat =
n mod 42
let plus_op (n : int) : int =
n + 42
let minus_op (n : int) : int =
n - 42
let times_op (n : int) : int =
n * 42
let div_op (n : int) : int =
n / 2
(* TODO (?): Support conversion from nat to int and back
let int_op (n : nat) : int =
Int n
*)
let neg_op (n : int) : int =
-n
let mod_op (n : int) : nat = n mod 42
let plus_op (n : int) : int = n + 42
let minus_op (n : int) : int = n - 42
let times_op (n : int) : int = n * 42
let div_op (n : int) : int = n / 2
let neg_op (n : int) : int = -n
let foo (n : int) : int = n + 10
let neg_op_2 (b : int) : int = -(foo b)

14
src/test/contracts/arithmetic.religo
View File

@ -1,24 +1,10 @@
/* Test ReasonLIGO arithmetic operators */
let mod_op = (n : int) : nat => n mod 42;
let plus_op = (n : int) : int => n + 42;
let minus_op = (n : int) : int => n - 42;
let times_op = (n : int) : int => n * 42;
let div_op = (n : int) : int => n / 2;
/* TODO (?): Support conversion from nat to int and back
let int_op (n : nat) : int =
Int n
*/
let neg_op = (n : int): int => - n;
let foo = (n : int): int => n + 10;
let neg_op_2 = (b : int): int => -foo(b);

2
src/test/contracts/assert.religo
View File

@ -1,4 +1,4 @@
let main = (p: bool, s: unit) => {
let main = (p, s : bool, unit) => {
let u : unit = assert (p);
([]: list (operation), s);
};

5
src/test/contracts/assign.ligo
View File

@ -1,4 +1 @@
function main (const i : int) : int is
block {
i := i + 1
} with i
function main (const i : int) : int is block {i := i + 1} with i

3
src/test/contracts/attributes.mligo
View File

@ -1,10 +1,7 @@
let x = 1 [@@inline]
let foo (a : int): int =
(let test = 2 + a [@@inline] in test) [@@inline]
let y = 1 [@@inline][@@other]
let bar (b : int): int =
let test = fun (z : int) -> 2 + b + z [@@inline][@@foo][@@bar]
in test b

3
src/test/contracts/bad_address_format.religo
View File

@ -1,3 +1,2 @@
let main = (parameter: int, storage: address) => {
let main = (parameter : int, storage : address) =>
([] : list (operation), "KT1badaddr" : address);
};

2
src/test/contracts/balance_constant.ligo
View File

@ -9,4 +9,4 @@ type storage is tez
type return is list (operation) * storage
function main (const param : parameter; const store: storage) : return is
((nil : list (operation)), balance)
((nil : list (operation)), Tezos.balance)

17
src/test/contracts/balance_constant.mligo
View File

@ -1,17 +1,18 @@
(**
(*
This test makes sure that the balance is accessible in CameLIGO.
It's there to detect a regression of: https://gitlab.com/ligolang/ligo/issues/61
Which results in this error when you attempt to compile this contract:
It is there to detect a regression of:
https://gitlab.com/ligolang/ligo/issues/61
which results in this error when you attempt to compile this contract:
generated. unrecognized constant: {"constant":"BALANCE","location":"generated"}
*)
type parameter = unit
type storage = tez
type return = operation list * storage
let main (p, s : unit * storage) =
([] : operation list), balance
let main (p, s : parameter * storage) : return =
([] : operation list), Tezos.balance

3
src/test/contracts/balance_constant.religo
View File

@ -12,6 +12,7 @@ generated. unrecognized constant: {"constant":"BALANCE","location":"generated"}
type storage = tez;
let main2 = (p: unit, s: storage) => ([]: list(operation), balance);
let main2 = (p : unit, storage) =>
([]: list (operation), Tezos.balance);
let main = (x : (unit, storage)) => main2 (x[0], x[1]);

2
src/test/contracts/big_map.ligo
View File

@ -22,8 +22,6 @@ function rm (var m : foo) : foo is block {
remove 42 from map m
} with m
function gf (const m : foo) : int is get_force (23, m)
function get (const m : foo) : option (int) is m[42]
const empty_big_map : big_map (int,int) = big_map []

13
src/test/contracts/big_map.mligo
View File

@ -1,23 +1,18 @@
type foo = (int, int) big_map
let set_ (n, m: int * foo) : foo = Big_map.update 23 (Some n) m
let add (n, m : int * foo) : foo = Big_map.add 23 n m
let rm (m : foo) : foo = Big_map.remove 42 m
let gf (m : foo) : int = Big_map.find 23 m
let get (m : foo): int option = Big_map.find_opt 42 m
let empty_map : foo = Big_map.empty
let map1 : foo = Big_map.literal
[ (23 , 0) ; (42, 0) ]
let map1 : foo = Big_map.literal
[ (23 , 0) ; (42, 0) ]
let map1 : foo = Big_map.literal [(23,0); (42,0)]
let map1 : foo = Big_map.literal [(23,0); (42,0)]
let mutimaps (m : foo) (n : foo) : foo =
let bar : foo = Big_map.update 42 (Some 0) m in
Big_map.update 42 (get bar) n
let bar : foo = Big_map.update 42 (Some 0) m
in Big_map.update 42 (get bar) n

2
src/test/contracts/big_map.religo
View File

@ -16,8 +16,6 @@ let empty_map: foo = Big_map.empty;
let map1 : foo = Big_map.literal ([(23,0), (42,0)]);
let map1: foo = Big_map.literal([(23, 0), (42, 0)]);
let mutimaps = (m: foo, n: foo): foo => {
let bar : foo = Big_map.update (42, Some (0), m);
Big_map.update (42, get (bar), n);

6
src/test/contracts/boolean_operators.ligo
View File

@ -1,11 +1,5 @@
// Test PascaLIGO boolean operators
function or_true (const b : bool) : bool is b or True
function or_false (const b : bool) : bool is b or False
function and_true (const b : bool) : bool is b and True
function and_false (const b : bool) : bool is b and False
function not_bool (const b : bool) : bool is not b

19
src/test/contracts/boolean_operators.mligo
View File

@ -1,16 +1,7 @@
// Test CameLIGO boolean operators
let or_true (b : bool) : bool =
b || true
let or_false (b : bool) : bool =
b || false
let and_true (b : bool) : bool =
b && true
let and_false (b : bool) : bool =
b && false
let not_bool (b: bool) : bool =
not b
let or_true (b : bool) : bool = b || true
let or_false (b : bool) : bool = b || false
let and_true (b : bool) : bool = b && true
let and_false (b : bool) : bool = b && false
let not_bool (b : bool) : bool = not b

4
src/test/contracts/boolean_operators.religo
View File

@ -1,11 +1,7 @@
// Test ReasonLIGO boolean operators
let or_true = (b : bool) : bool => b || true;
let or_false = (b : bool) : bool => b || false;
let and_true = (b : bool) : bool => b && true;
let and_false = (b : bool) : bool => b && false;
let not_bool = (b : bool) : bool => !b;

8
src/test/contracts/bytes_arithmetic.ligo
View File

@ -1,5 +1,3 @@
function concat_op (const s : bytes) : bytes is bytes_concat (s, 0x7070)
function slice_op (const s : bytes) : bytes is bytes_slice (1n, 2n, s)
function hasherman (const s : bytes) : bytes is sha_256 (s)
function concat_op (const s : bytes) : bytes is Bytes.concat (s, 0x7070)
function slice_op (const s : bytes) : bytes is Bytes.sub (1n, 2n, s)
function hasherman (const s : bytes) : bytes is Crypto.sha256 (s)

11
src/test/contracts/bytes_arithmetic.mligo
View File

@ -1,8 +1,3 @@
let concat_op (s : bytes) : bytes =
Bytes.concat s 0x7070
let slice_op (s : bytes) : bytes =
Bytes.slice 1n 2n s
let hasherman (s : bytes) : bytes =
Crypto.sha256 s
let concat_op (s : bytes) : bytes = Bytes.concat s 0x7070
let slice_op (s : bytes) : bytes = Bytes.sub 1n 2n s
let hasherman (s : bytes) : bytes = Crypto.sha256 s

12
src/test/contracts/bytes_unpack.ligo
View File

@ -1,11 +1,11 @@
function id_string (const p : string) : option (string) is block {
const packed : bytes = bytes_pack (p)
} with (bytes_unpack (packed) : option (string))
const packed : bytes = Bytes.pack (p)
} with (Bytes.unpack (packed) : option (string))
function id_int (const p : int) : option (int) is block {
const packed : bytes = bytes_pack (p)
} with (bytes_unpack (packed) : option (int))
const packed : bytes = Bytes.pack (p)
} with (Bytes.unpack (packed) : option (int))
function id_address (const p : address) : option (address) is block {
const packed : bytes = bytes_pack (p)
} with (bytes_unpack (packed) : option (address))
const packed : bytes = Bytes.pack (p)
} with (Bytes.unpack (packed) : option (address))

6
src/test/contracts/bytes_unpack.mligo
View File

@ -1,11 +1,11 @@
let id_string (p : string) : string option =
let packed : bytes = Bytes.pack p in
((Bytes.unpack packed): string option)
(Bytes.unpack packed : string option)
let id_int (p : int) : int option =
let packed : bytes = Bytes.pack p in
((Bytes.unpack packed): int option)
(Bytes.unpack packed : int option)
let id_address (p : address) : address option =
let packed : bytes = Bytes.pack p in
((Bytes.unpack packed): address option)
(Bytes.unpack packed : address option)

2
src/test/contracts/chain_id.ligo
View File

@ -1 +1 @@
function chain_id (const tt : chain_id) : chain_id is get_chain_id
function chain_id (const tt : chain_id) : chain_id is Tezos.chain_id

2
src/test/contracts/check_signature.ligo
View File

@ -1,4 +1,4 @@
function check_signature (const pk : key;
const signed : signature;
const msg : bytes) : bool
is crypto_check (pk, signed, msg)
is Crypto.check (pk, signed, msg)

10
src/test/contracts/closure.mligo
View File

@ -1,9 +1,7 @@
(* Test whether closures retain values in CameLIGO *)
(* Test whether closures capture variables in CameLIGO *)
let test (k : int) : int =
let j : int = k + 5 in
let close: (int -> int) =
fun (i: int) -> i + j
in
let j: int = 20 in (* Shadow original variable to see if value close'd *)
close 20
let close : int -> int = fun (i : int) -> i + j in
let j : int = 20 (* Shadow original variable *)
in close 20

2
src/test/contracts/closure.religo
View File

@ -4,6 +4,6 @@ let test = (k: int): int => {
let j : int = k + 5;
let close : (int => int) = (i : int) => i + j;
let j: int = 20; /* Shadow original variable to see if value close'd */
let j : int = 20; /* Shadow original variable */
close (20);
};

42
src/test/contracts/coase.ligo
View File

@ -45,27 +45,38 @@ type parameter is
| Transfer_single of action_transfer_single
function transfer_single (const action : action_transfer_single;
const s : storage) : return is block {
const s : storage) : return is
block {
const cards : cards = s.cards;
const card : card = get_force (action.card_to_transfer, cards);
const card : card =
case cards[action.card_to_transfer] of
Some (card) -> card
| None -> (failwith ("transfer_single: No card.") : card)
end;
if card.card_owner =/= sender then
failwith ("This card doesn't belong to you")
else skip;
card.card_owner := action.destination;
cards[action.card_to_transfer] := card;
s.cards := cards;
const operations : list (operation) = nil
} with (operations, s)
s.cards := cards
} with ((nil : list (operation)), s)
function sell_single (const action : action_sell_single;
const s : storage) : return is
block {
const card : card = get_force (action.card_to_sell, s.cards);
const card : card =
case s.cards[action.card_to_sell] of
Some (card) -> card
| None -> (failwith ("sell_single: No card.") : card)
end;
if card.card_owner =/= sender
then failwith ("This card doesn't belong to you")
else skip;
const card_pattern : card_pattern =
get_force (card.card_pattern, s.card_patterns);
case s.card_patterns[card.card_pattern] of
Some (pattern) -> pattern
| None -> (failwith ("sell_single: No card pattern.") : card_pattern)
end;
card_pattern.quantity := abs (card_pattern.quantity - 1n);
const card_patterns : card_patterns = s.card_patterns;
card_patterns[card.card_pattern] := card_pattern;
@ -74,8 +85,12 @@ function sell_single (const action : action_sell_single;
remove action.card_to_sell from map cards;
s.cards := cards;
const price : tez = card_pattern.coefficient * card_pattern.quantity;
const receiver : contract (unit) = get_contract (sender);
const op : operation = transaction (unit, price, receiver);
const receiver : contract (unit) =
case (Tezos.get_contract_opt (Tezos.sender) : option (contract (unit))) of
Some (contract) -> contract
| None -> (failwith ("sell_single: No contract.") : contract (unit))
end;
const op : operation = Tezos.transaction (unit, price, receiver);
const operations : list (operation) = list [op]
} with (operations, s)
@ -84,12 +99,13 @@ function buy_single (const action : action_buy_single;
block {
// Check funds
const card_pattern : card_pattern =
get_force (action.card_to_buy, s.card_patterns);
case s.card_patterns[action.card_to_buy] of
Some (pattern) -> pattern
| None -> (failwith ("buy_single: No card pattern.") : card_pattern)
end;
const price : tez =
card_pattern.coefficient * (card_pattern.quantity + 1n);
if price > amount then failwith ("Not enough money") else skip;
// Administrative procedure
const operations : list(operation) = nil;
// Increase quantity
card_pattern.quantity := card_pattern.quantity + 1n;
const card_patterns : card_patterns = s.card_patterns;
@ -103,7 +119,7 @@ function buy_single (const action : action_buy_single;
];
s.cards := cards;
s.next_id := s.next_id + 1n
} with (operations, s)
} with ((nil : list (operation)), s)
function main (const action : parameter; const s : storage) : return is
case action of

4
src/test/contracts/condition-annot.mligo
View File

@ -1,2 +1,4 @@
type integer = int
let main (i : int) =
if (i=2 : bool) then (42: int) else (0: int)
if (i = 2 : bool) then (42 : int) else (0 : integer)

6
src/test/contracts/condition-annot.religo
View File

@ -1,6 +1,2 @@
let main = (i : int) =>
if (((i == 2): bool)) {
(42: int);
} else {
(0: int);
};
if (((i == 2) : bool)) { (42 : int); } else { (0 : int); };

9
src/test/contracts/condition-shadowing.mligo
View File

@ -1,8 +1,5 @@
(* TODO : make a test using mutation, not shadowing *)
let main (i : int) =
let result = 0 in
if i = 2 then
let result = 42 in result
else
let result = 0 in result
if i = 2
then let result = 42 in result
else let result = 0 in result

7
src/test/contracts/condition.religo
View File

@ -1,8 +1,3 @@
/* Test conditional in ReasonLIGO */
let main = (i: int) =>
if (i == 2) {
42;
} else {
0;
};
let main = (i : int) => if (i == 2) { 42; } else { 0; };

3
src/test/contracts/counter.mligo
View File

@ -1,4 +1,3 @@
type storage = int
let main (ps: int * storage) =
(([] : operation list) , ps.0 + ps.1)
let main (p, s : int * storage) = ([] : operation list), p + s

6
src/test/contracts/counter.religo
View File

@ -1,6 +1,4 @@
type storage = int;
let main2 = (p: int, s: storage): string => ([]: list(operation), p + s);
let main = (x: (int, storage)) : string => main2(x[0],x[1]);
let main = ((p, s) : (int, storage)) : (list (operation), storage) =>
([] : list (operation), p + s);

5
src/test/contracts/crypto.ligo
View File

@ -1,3 +1,2 @@
function hasherman512 (const s: bytes) : bytes is sha_512 (s)
function hasherman_blake (const s: bytes) : bytes is blake2b (s)
function hasherman512 (const s : bytes) : bytes is Crypto.sha512 (s)
function hasherman_blake (const s : bytes) : bytes is Crypto.blake2b (s)

8
src/test/contracts/curry.mligo
View File

@ -1,9 +1,5 @@
let conv_test (j : int) (k : int) = j + k
let main (i : int) : int = conv_test i 10
let partial (a : int) (b : int) : int = a + b
let mk_partial (j: int) : (int -> int) = partial j
let partial_apply (i: int) : int = (mk_partial 10) i
let mk_partial (j : int) : int -> int = partial j
let partial_apply (i : int) : int = mk_partial 10 i

2
src/test/contracts/declarations.ligo
View File

@ -1,5 +1,3 @@
// Test PascaLIGO top-level declarations
const foo : int = 42
function main (const i : int) : int is i + foo

5
src/test/contracts/deep_access.ligo
View File

@ -26,4 +26,7 @@ type nested_record_t is
function nested_record (var nee : nested_record_t) : string is
block {
nee.nesty.mymap[1] := "one"
} with get_force (1, nee.nesty.mymap)
} with case nee.nesty.mymap[1] of
Some (s) -> s
| None -> (failwith ("Should not happen.") : string)
end

1
src/test/contracts/dispatch-counter.ligo
View File

@ -7,7 +7,6 @@ type storage is int
type return is list (operation) * storage
function increment (const i : int; const n : int) : int is i+n
function decrement (const i : int; const n : int) : int is i-n
const nop : list (operation) = nil

4
src/test/contracts/empty_case.mligo
View File

@ -1,8 +1,8 @@
type foo =
| Bar of int
Bar of int
| Baz
let main (f : foo) : int =
match f with
| Bar i -> i
Bar i -> i
| Baz -> -1

7
src/test/contracts/entrypoints.ligo
View File

@ -5,8 +5,7 @@ type return is list (operation) * storage
function cb (const a : address; const s : storage) : return is
block {
const c : contract (unit) = get_entrypoint ("%cb", a)
}
with (list [transaction (unit, 0mutez, c)], s)
} with (list [Tezos.transaction (unit, 0tez, c)], s)
function cbo (const a : address; const s : storage) : return is
@ -14,6 +13,6 @@ function cbo (const a : address; const s : storage) : return is
const c : contract (unit) =
case (get_entrypoint_opt ("%cbo", a) : option (contract (unit))) of
Some (c) -> c
| None -> (failwith ("entrypoint not found") : contract (unit))
| None -> (failwith ("cbo: Entrypoint not found.") : contract (unit))
end
} with (list [transaction(unit, 0mutez, c)], s)
} with (list [Tezos.transaction (unit, 0tez, c)], s)

6
src/test/contracts/eq_bool.religo
View File

@ -1,8 +1,4 @@
/* Test boolean comparison in ReasonLIGO */
let main = ((a, b) : (bool, bool)) =>
if (a == b) {
999;
} else {
1;
};
if (a == b) { 999; } else { 1; };

4
src/test/contracts/failwith.mligo
View File

@ -1,4 +1,4 @@
type storage = unit
let main (p: unit) (s:storage) =
if true then failwith "This contract always fails" else ()
let main (p, store : unit * storage) : operation list * storage =
(failwith "This contract always fails" : operation list * storage)

6
src/test/contracts/failwith.religo
View File

@ -1,8 +1,4 @@
type storage = unit;
let main = (p: unit, storage) =>
if (true) {
failwith("This contract always fails");
} else {
();
};
if (true) { failwith("This contract always fails"); };

6
src/test/contracts/fibo.mligo
View File

@ -1,7 +1,9 @@
type storage = unit
let main (p: unit) storage =
(fun (f: (int * int) -> int) (x: int) (y: int) -> f (y,x))
let main (p, store : unit * storage) : operation list * storage =
let n =
(fun (f : int * int -> int) (x : int) (y : int) -> f (y,x))
(fun (x : int) (y : int) -> x + y)
0
1
in ([] : operation list), store

6
src/test/contracts/fibo2.mligo
View File

@ -1,7 +1,9 @@
type storage = unit
let main (p: unit) storage =
(fun (f: int -> int) (_: int) (y: int) -> f y)
let main (p : unit; store : storage) : operation list * storage =
let n =
(fun (f : int -> int) (z : int) (y : int) -> f y)
(fun (x : int) -> x)
0
1
in ([] : operation list), store

4
src/test/contracts/fibo3.mligo
View File

@ -1,7 +1,9 @@
type storage = unit
let main (p: unit) storage =
let main (p, s : unit * storage) : operation list * storage =
let n =
(fun (f : int -> int -> int) (x : int) (y : int) -> f y (x+y))
(fun (x : int) (y : int) -> x + y)
0
1
in ([] : operation list), store

2
src/test/contracts/fibo4.mligo
View File

@ -1,6 +1,6 @@
type storage = unit
let main (p: unit) storage =
let main (p, s : unit * storage) =
(fun (f : int -> int) (x : int) -> f x)
(fun (x : int) -> x)
1

4
src/test/contracts/function-shared.mligo
View File

@ -1,7 +1,5 @@
(* Test use of multiple subroutines in a CameLIGO function *)
let foo (i : int) : int = i + 20
let bar (i : int) : int = i + 50
let foobar (i: int) : int = (foo i) + (bar i)
let foobar (i : int) : int = foo i + bar i

2
src/test/contracts/function-shared.religo
View File

@ -1,7 +1,5 @@
/* Test use of multiple subroutines in a ReasonLIGO function */
let foo = (i : int) : int => i + 20;
let bar = (i : int) : int => i + 50;
let foobar = (i : int) : int => foo (i) + bar (i);

15
src/test/contracts/get_contract.ligo
View File

@ -1,19 +1,16 @@
type storage is unit
type return is list (operation) * storage
function cb (const s : storage) : return is
block {
const c : contract(unit) = get_contract(sender)
}
with (list [transaction(unit, 0mutez, c)], s)
function cb (const s : storage) : return is block {
const c : contract (unit) = get_contract (Tezos.sender)
} with (list [Tezos.transaction (unit, 0tez, c)], s)
function cbo (const s : unit) : return is
block {
const c : contract (unit) =
case (get_contract_opt(sender) : option(contract(unit))) of
Some (c) -> c
case (Tezos.get_contract_opt (Tezos.sender) : option (contract (unit))) of
Some (contract) -> contract
| None -> (failwith ("contract not found") : contract (unit))
end
}
with (list [transaction(unit, 0mutez, c)], s)
} with (list [Tezos.transaction (unit, 0tez, c)], s)

24
src/test/contracts/guess_string.mligo
View File

@ -1,20 +1,22 @@
type storage = {
challenge : string;
challenge : string
}
type param = {
new_challenge : string;
attempt : string;
attempt : string
}
let attempt (p: param) storage =
(* if p.attempt <> storage.challenge then failwith "Failed challenge" else *)
type return = operation list * storage
let attempt (p, store : param * storage) : return =
(* if p.attempt <> store.challenge then failwith "Failed challenge" else *)
let contract : unit contract =
Operation.get_contract sender in
match (Tezos.get_contract_opt Tezos.sender : unit contract option) with
Some contract -> contract
| None -> (failwith "No contract" : unit contract)
in
let transfer : operation =
Operation.transaction (unit , contract , 10.00tz) in
(* TODO: no syntax for functional updates yet *)
(* let storage : storage = { storage with challenge = p.new_challenge } in *)
(* for now, rebuild the record by hand. *)
let storage : storage = { challenge = p.new_challenge }
in ([] : operation list), storage
Tezos.transaction (unit, contract, 10.00tez) in
let store : storage = {challenge = p.new_challenge}
in ([] : operation list), store

63
src/test/contracts/hashlock.mligo
View File

@ -8,49 +8,60 @@ type commit_set = (address, commit) big_map
type storage = {
hashed : bytes;
unused : bool;
commits: commit_set;
commits : commit_set
}
type reveal = {
hashable : bytes;
message: unit -> operation list;
message : unit -> operation list
}
type parameter =
| Commit of bytes
Commit of bytes
| Reveal of reveal
(* We use hash-commit so that a baker can't steal *)
let commit ((p,s): bytes * storage) : operation list * storage =
let commit: commit = {date = Current.time + 86400; salted_hash = p;} in
let updated_map: commit_set = Big_map.update sender (Some commit) s.commits in
let s = {hashed = s.hashed; unused = s.unused; commits = updated_map} in
(([]: operation list), s)
type return = operation list * storage
let reveal ((p,s): reveal * storage) : operation list * storage =
(* We use hash-commit so that a baker can not steal *)
let commit (p, s : bytes * storage) : return =
let commit : commit =
{date = Tezos.now + 86_400; salted_hash = p} in
let updated_map: commit_set =
Big_map.update Tezos.sender (Some commit) s.commits in
let s = {s with commits = updated_map}
in ([] : operation list), s
let reveal (p, s : reveal * storage) : return =
if not s.unused
then (failwith "This contract has already been used.": operation list * storage)
then
(failwith "This contract has already been used." : return)
else
let commit : commit =
match (Big_map.find_opt sender s.commits) with
match Big_map.find_opt sender s.commits with
| Some c -> c
| None -> (failwith "You haven't made a commitment to hash against yet.": commit)
| None ->
(failwith "You have not made a commitment to hash against yet."
: commit)
in
if Current.time < commit.date
then (failwith "It hasn't been 24 hours since your commit yet.": operation list * storage)
else
let salted = Crypto.sha256 (Bytes.concat p.hashable (Bytes.pack sender)) in
if (salted <> commit.salted_hash)
then (failwith "This reveal doesn't match your commitment.": operation list * storage)
else
if (s.hashed = Crypto.sha256 p.hashable)
if Tezos.now < commit.date
then
let s: storage = {hashed = s.hashed; unused = false; commits = s.commits} in
((p.message ()), s)
else (failwith "Your commitment did not match the storage hash.":
operation list * storage)
(failwith "It has not been 24 hours since your commit yet.": return)
else
let salted =
Crypto.sha256 (Bytes.concat p.hashable (Bytes.pack sender)) in
if salted <> commit.salted_hash
then
(failwith "This reveal does not match your commitment.": return)
else
if s.hashed = Crypto.sha256 p.hashable
then
let s : storage = {s with unused = false}
in p.message (), s
else (failwith "Your commitment did not match the storage hash."
: return)
let main ((p,s): parameter * storage) : operation list * storage =
let main (p, s : parameter * storage) : return =
match p with
| Commit c -> commit (c,s)
| Reveal r -> reveal (r,s)

16
src/test/contracts/heap.ligo
View File

@ -10,8 +10,12 @@ function get_top (const h : heap) : heap_elt is get_force (1n, h)
function pop_switch (const h : heap) : heap is
block {
const result : heap_elt = get_top (h);
const s : nat = size (h);
const last : heap_elt = get_force (s, h);
const s : nat = Map.size (h);
const last : heap_elt =
case h[s] of
Some (e) -> e
| None -> (failwith ("No element.") : heap_elt)
end;
remove 1n from map h;
h[1n] := last
} with h
@ -19,8 +23,12 @@ function pop_switch (const h : heap) : heap is
function pop_ (const h : heap) : nat is
block {
const result : heap_elt = get_top (h);
const s : nat = size (h);
var current : heap_elt := get_force (s, h);
const s : nat = Map.size (h);
var current : heap_elt :=
case h[s] of
Some (e) -> e
| None -> (failwith ("No element.") : heap_elt)
end;
const i : nat = 1n;
const left : nat = 2n * i;
const right : nat = left + 1n;

34
src/test/contracts/high-order.mligo
View File

@ -1,30 +1,24 @@
(* Test a function which takes another function as an argument *)
let foobar (i : int) : int =
let foo: (int -> int) =
fun (i : int) -> i
in
let bar: ((int -> int) -> int) =
fun (f : int -> int) -> f i
in
bar foo
let foo: (int -> int) = fun (i : int) -> i in
let bar: ((int -> int) -> int) = fun (f : int -> int) -> f i
in bar foo
(* higher order function with more than one argument *)
let higher2 (i : int) (f : int -> int): int =
let ii: int = f i in ii
let foobar2 (i : int) : int =
let foo2: (int -> int) =
fun (i : int) -> i
in
higher2 i foo2
let foo2 : (int -> int) = fun (i : int) -> i
in higher2 i foo2
let a : int = 0
let foobar3 (i : int) : int =
let foo2: (int -> int) =
fun (i : int) -> a + i
in
higher2 i foo2
let foo2 : (int -> int) = fun (i : int) -> a + i
in higher2 i foo2
let f (i : int) : int = i
@ -37,10 +31,6 @@ let higher3 (i: int) (f: int -> int) (g: int -> int) : int =
let foobar5 (i : int) : int =
let a : int = 0 in
let foo: (int -> int) =
fun (i : int) -> a + i
in
let goo: (int -> int) =
fun (i : int) -> foo i
in
higher3 i foo goo
let foo : (int -> int) = fun (i : int) -> a + i in
let goo : (int -> int) = fun (i : int) -> foo i
in higher3 i foo goo

8
src/test/contracts/high-order.religo
View File

@ -1,13 +1,13 @@
/* Test a function which takes another function as an argument */
let foobar = (i : int): int => {
let foo: int => int = (i: int) => i;
let bar: ((int => int) => int) = (f : (int => int)) => f (i);
bar (foo);
};
/* higher order function with more than one argument */
let higher2 = (i : int, f : (int => int)) : int => {
let ii : int = f (i);
ii;
@ -15,7 +15,6 @@ let higher2 = (i: int, f: (int => int)): int => {
let foobar2 = (i : int) : int => {
let foo2 : int => int = (i : int) => i;
higher2 (i, foo2);
};
@ -23,7 +22,6 @@ let a: int = 0;
let foobar3 = (i : int) : int => {
let foo2: int => int = (i : int) => a + i;
higher2 (i, foo2);
};
@ -41,8 +39,6 @@ let higher3 = (i: int, f: (int => int), g: (int => int)): int => {
let foobar5 = (i : int) : int => {
let a : int = 0;
let foo : int => int = (i : int) => a + i;
let goo : int => int = (i : int) => foo (i);
higher3 (i, foo, goo);
};

116
src/test/contracts/id.mligo
View File

@ -3,7 +3,7 @@ type id = int
type id_details = {
owner: address;
controller: address;
profile: bytes;
profile: bytes
}
type buy = bytes * address option
@ -14,126 +14,118 @@ type action =
| Buy of buy
| Update_owner of update_owner
| Update_details of update_details
| Skip of unit
| Skip
(* The prices kept in storage can be changed by bakers, though they
should only be adjusted down over time, not up. *)
(* The prices kept in storage can be changed by bakers, though they should only be
adjusted down over time, not up. *)
type storage = (id, id_details) big_map * int * (tez * tez)
(** Preliminary thoughts on ids:
type return = operation list * storage
I very much like the simplicity of http://gurno.com/adam/mne/.
5 three letter words means you have a 15 character identity, not actually more
annoying than an IP address and a lot more memorable than the raw digits. This
can be stored as a single integer which is then translated into the corresponding
series of 5 words.
(* Preliminary thoughts on ids:
I in general like the idea of having a 'skip' mechanism, but it does need to cost
something so people don't eat up the address space. 256 ^ 5 means you have a lot
of address space, but if people troll by skipping a lot that could be eaten up.
Should probably do some napkin calculations for how expensive skipping needs to
be to deter people from doing it just to chew up address space.
*)
I very much like the simplicity of http://gurno.com/adam/mne/. 5 three
letter words means you have a 15 character identity, not actually more
annoying than an IP address and a lot more memorable than the raw
digits. This can be stored as a single integer which is then
translated into the corresponding series of 5 words.
I in general like the idea of having a 'skip' mechanism, but it does
need to cost something so people don't eat up the address space. 256^5
means you have a lot of address space, but if people troll by skipping
a lot that could be eaten up. Should probably do some napkin
calculations for how expensive skipping needs to be to deter people
from doing it just to chew up address space. *)
let buy (parameter, storage: (bytes * address option) * storage) =
let void : unit =
if amount = storage.2.0
then ()
else (failwith "Incorrect amount paid.": unit)
in
if Tezos.amount <> storage.2.0
then (failwith "Incorrect amount paid.": unit) in
let profile, initial_controller = parameter in
let identities, new_id, prices = storage in
let controller : address =
match initial_controller with
| Some addr -> addr
| None -> sender
in
| None -> sender in
let new_id_details: id_details = {
owner = sender;
controller = controller;
profile = profile ;
}
in
profile = profile} in
let updated_identities : (id, id_details) big_map =
Big_map.update new_id (Some new_id_details) identities
in
([]: operation list), (updated_identities, new_id + 1, prices)
in ([]: operation list), (updated_identities, new_id + 1, prices)
let update_owner (parameter, storage : (id * address) * storage) =
if (amount <> 0mutez)
then (failwith "Updating owner doesn't cost anything.": (operation list) * storage)
if amount <> 0tez
then (failwith "Updating owner doesn't cost anything.": return)
else
let id, new_owner = parameter in
let identities, last_id, prices = storage in
let current_id_details : id_details =
match Big_map.find_opt id identities with
| Some id_details -> id_details
| None -> (failwith "This ID does not exist.": id_details)
in
| None -> (failwith "This ID does not exist." : id_details) in
let is_allowed : bool =
if sender = current_id_details.owner
if Tezos.sender = current_id_details.owner
then true
else (failwith "You are not the owner of this ID.": bool)
in
else (failwith "You are not the owner of this ID." : bool) in
let updated_id_details : id_details = {
owner = new_owner;
controller = current_id_details.controller;
profile = current_id_details.profile;
}
in
let updated_identities = Big_map.update id (Some updated_id_details) identities in
([]: operation list), (updated_identities, last_id, prices)
profile = current_id_details.profile} in
let updated_identities =
Big_map.update id (Some updated_id_details) identities
in ([]: operation list), (updated_identities, last_id, prices)
let update_details (parameter, storage: (id * bytes option * address option) * storage) =
if (amount <> 0mutez)
then (failwith "Updating details doesn't cost anything.": (operation list) * storage)
if Tezos.amount <> 0tez
then
(failwith "Updating details doesn't cost anything." : return)
else
let id, new_profile, new_controller = parameter in
let identities, last_id, prices = storage in
let current_id_details: id_details =
match Big_map.find_opt id identities with
| Some id_details -> id_details
| None -> (failwith "This ID does not exist.": id_details)
in
| None -> (failwith "This ID does not exist.": id_details) in
let is_allowed : bool =
if (sender = current_id_details.controller) || (sender = current_id_details.owner)
if Tezos.sender = current_id_details.controller
|| Tezos.sender = current_id_details.owner
then true
else (failwith ("You are not the owner or controller of this ID."): bool)
in
else
(failwith ("You are not the owner or controller of this ID.")
: bool) in
let owner : address = current_id_details.owner in
let profile : bytes =
match new_profile with
| None -> (* Default *) current_id_details.profile
| Some new_profile -> new_profile
in
| Some new_profile -> new_profile in
let controller : address =
match new_controller with
| None -> (* Default *) current_id_details.controller
| Some new_controller -> new_controller
in
| Some new_controller -> new_controller in
let updated_id_details: id_details = {
owner = owner;
controller = controller;
profile = profile;
}
in
profile = profile} in
let updated_identities: (id, id_details) big_map =
Big_map.update id (Some updated_id_details) identities in
([]: operation list), (updated_identities, last_id, prices)
Big_map.update id (Some updated_id_details) identities
in ([]: operation list), (updated_identities, last_id, prices)
(* Let someone skip the next identity so nobody has to take one that's
undesirable *)
(* Let someone skip the next identity so nobody has to take one that's undesirable *)
let skip (p, storage: unit * storage) =
let void : unit =
if amount = storage.2.1
then ()
else (failwith "Incorrect amount paid.": unit)
in
if Tezos.amount <> storage.2.1
then (failwith "Incorrect amount paid." : unit) in
let identities, last_id, prices = storage in
([]: operation list), (identities, last_id + 1, prices)
let main (action, storage: action * storage) : operation list * storage =
let main (action, storage : action * storage) : return =
match action with
| Buy b -> buy (b, storage)
| Update_owner uo -> update_owner (uo, storage)
| Update_details ud -> update_details (ud, storage)
| Skip s -> skip ((), storage)
| Skip -> skip ((), storage)

6
src/test/contracts/implicit.mligo
View File

@ -1,5 +1,5 @@
let main2 (p : key_hash) (s : unit) =
let c : unit contract = Current.implicit_account p in
(([] : operation list), unit)
let c : unit contract = Tezos.implicit_account p
in ([] : operation list), unit
let main (t: key_hash * unit) = main2 t.0 t.1
let main (p,s : key_hash * unit) = main2 p s

3
src/test/contracts/implicit_account.ligo
View File

@ -1 +1,2 @@
function main (const kh: key_hash) : contract (unit) is implicit_account (kh)
function main (const kh: key_hash) : contract (unit) is
Tezos.implicit_account (kh)

2
src/test/contracts/implicit_account.mligo
View File

@ -1 +1 @@
let main (kh: key_hash) : unit contract = Current.implicit_account kh
let main (kh : key_hash) : unit contract = Tezos.implicit_account kh

3
src/test/contracts/implicit_account.religo
View File

@ -1 +1,2 @@
let main = (kh: key_hash): contract(unit) => Current.implicit_account(kh);
let main = (kh : key_hash) : contract (unit) =>
Tezos.implicit_account (kh);

16
src/test/contracts/incr_decr.mligo
View File

@ -1,19 +1,17 @@
type storage = int
(* variant defining pseudo multi-entrypoint actions *)
type action =
type parameter =
Increment of int
| Decrement of int
type return = operation list * storage
let add (a : int) (b : int) : int = a + b
let sub (a : int) (b : int) : int = a - b
(* real entrypoint that re-routes the flow based on the action provided *)
let main (p: action) storage =
let storage =
match p with
let main (action, store : parameter * storage) : return =
let store =
match action with
Increment n -> add s n
| Decrement n -> sub s n
in ([] : operation list), storage
in ([] : operation list), store

170
src/test/contracts/interpret_test.mligo
View File

@ -1,14 +1,13 @@
let lambda_call =
let a = 3 in
let foo = fun (i : int) -> i * i in
foo (a + 1)
let foo = fun (i : int) -> i * i
in foo (a + 1)
let higher_order1 =
let a = 2 in
let foo = fun (i:int) (j:int) (k:int) ->
a + i + j + 0 in
let bar = (foo 1 2) in
bar 3
let foo = fun (i : int) (j : int) (k : int) -> a + i + j + 0 in
let bar = (foo 1 2)
in bar 3
let higher_order2 =
let a = 2 in
@ -20,68 +19,69 @@ let higher_order2 =
let higher_order3 =
let foo = fun (i : int) -> i + 1 in
let bar = fun (f:int->int) (i:int) -> (f i) + 1 in
let baz : (int -> int ) = bar foo in
baz 3
let bar = fun (f : int -> int) (i : int) -> f i + 1 in
let baz : int -> int = bar foo
in baz 3
let higher_order4 =
let a = 3 in
let foo = fun (i : int) -> a + i in
let bar: (int -> int) = fun (i : int) -> foo i in
bar 2
let bar : int -> int = fun (i : int) -> foo i
in bar 2
let concats =
0x70 ^ 0x70
let concats = 0x70 ^ 0x70
type foo_record = {
a : string;
b : string ;
b : string
}
let record_concat =
let ab : foo_record = { a = "a" ; b = "b" } in
ab.a ^ ab.b
let ab : foo_record = {a="a"; b="b"}
in ab.a ^ ab.b
let record_patch =
let ab : foo_record = { a = "a" ; b = "b" } in
{ab with b = "c"}
let ab : foo_record = {a="a"; b="b"}
in {ab with b = "c"}
type bar_record = {
f : int -> int;
arg : int ;
arg : int
}
let record_lambda =
let a = 1 in
let foo : (int -> int) = fun (i:int) -> a+(i*2) in
let farg : bar_record = { f = foo ; arg = 2 } in
farg.f farg.arg
let foo : int -> int = fun (i : int) -> a + i*2 in
let farg : bar_record = {f = foo; arg = 2}
in farg.f farg.arg
type foo_variant =
| Foo
| Bar of int
| Baz of string
let variant_exp =
(Foo, Bar 1, Baz "b")
let variant_exp = Foo, Bar 1, Baz "b"
let variant_match =
let a = Bar 1 in
match a with
| Foo -> 1
| Bar(i) -> 2
| Baz(s) -> 3
| Bar i -> 2
| Baz s -> 3
/* UNSUPPORTED
(* UNSUPPORTED: No deep patterns yet.
type bar_variant =
| Baz
| Buz of int * int
| Biz of int * int * string
let long_variant_match =
let a = Biz (1,2,"Biz") in
match a with
| Baz -> "Baz"
| Buz (a,b) -> "Buz"
| Biz (a,b,c) -> c
*/
*)
let bool_match =
let b = true in
@ -96,69 +96,64 @@ let list_match =
| [] -> a
let tuple_proj =
let (a,b) = (true,false) in
a or b
let a, b = true, false
in a or b
let list_const =
let a = [1 ; 2 ; 3 ; 4] in
0 :: a
let a = [1; 2; 3; 4]
in 0::a
type foobar = int option
let options_match_some =
let a = Some 0 in
match a with
| Some(i) -> i
| Some i -> i
| None -> 1
let options_match_none =
let a : foobar = None in
match a with
| Some(i) -> i
| Some i -> i
| None -> 0
let is_nat_nat =
let i : int = 1 in
let j : int = -1 in
(Michelson.is_nat i, Michelson.is_nat j)
let j : int = -1
in is_nat i, is_nat j
let abs_int = abs (-5)
let nat_int = int (5n)
let nat_int = int 5n
let map_list =
let a = [1; 2; 3; 4] in
let add_one: (int -> int) = fun (i : int) -> i + 1 in
List.map add_one a
let add_one : (int -> int) = fun (i : int) -> i + 1
in List.map add_one a
let fail_alone = failwith "you failed"
let iter_list_fail =
let a = [1; 2; 3; 4] in
let check_something: (int -> unit) = fun (i : int) ->
let check_something : int -> unit =
fun (i : int) ->
if i = 2 then failwith "you failed"
else ()
in
List.iter check_something a
in List.iter check_something a
let fold_list =
let a = [1; 2; 3; 4] in
let acc : (int * int -> int) =
fun (prev, el : int * int) -> prev + el in
List.fold acc a 0
let acc : int * int -> int =
fun (prev, el : int * int) -> prev + el
in List.fold acc a 0
let comparison_int =
(1 > 2, 2 > 1, 1 >=2 , 2 >= 1)
let comparison_int = 1 > 2, 2 > 1, 1 >=2, 2 >= 1
let comparison_string =
("foo" = "bar", "baz" = "baz")
let comparison_string = "foo"="bar", "baz"="baz"
let divs : (int * nat * tez * nat) =
(1/2 , 1n/2n , 1tz/2n , 1tz/2tz)
let divs : int * nat * tez * nat = 1/2, 1n/2n, 1tez/2n, 1tez/2tez
let var_neg =
let a = 2 in
-a
let a = 2 in -a
let sizes =
let a = [1; 2; 3; 4; 5] in
@ -166,30 +161,33 @@ let sizes =
let c = Set.literal [1; 2; 3; 4; 5] in
let d = Map.literal [(1,1); (2,2); (3,3)] in
let e = 0xFFFF in
(List.size a, String.size b, Set.size c, Map.size d, Bytes.size e)
List.length a,
String.length b,
Set.cardinal c,
Map.size d,
Bytes.length e
let modi = 3 mod 2
let fold_while =
let aux : int -> bool * int = fun (i:int) ->
if i < 10 then continue (i + 1) else stop i in
(Loop.fold_while aux 20, Loop.fold_while aux 0)
let aux : int -> bool * int =
fun (i : int) ->
if i < 10 then Loop.resume (i + 1) else Loop.stop i
in (Loop.fold_while aux 20, Loop.fold_while aux 0)
let assertion_pass =
assert (1=1)
let assertion_pass = assert (1=1)
let assertion_fail =
assert (1=2)
let assertion_fail = assert (1=2)
let lit_address = ("KT1ThEdxfUcWUwqsdergy3QnbCWGHSUHeHJq" : address)
let map_finds =
let m = Map.literal [ ("one" , 1) ; ("two" , 2) ; ("three" , 3) ] in
Map.find_opt "two" m
let m = Map.literal [("one", 1); ("two", 2); ("three", 3)]
in Map.find_opt "two" m
let map_finds_fail =
let m = Map.literal [ ("one" , 1) ; ("two" , 2) ; ("three" , 3) ] in
Map.find "four" m
let m = Map.literal [("one", 1); ("two", 2); ("three", 3)]
in Map.find "four" m
let map_empty =
((Map.empty : (int, int) map), (Map.literal [] : (int, int) map))
@ -197,42 +195,40 @@ let map_empty =
let m = Map.literal [("one", 1); ("two", 2); ("three", 3)]
let map_fold =
let aux = fun (i: int * (string * int)) -> i.0 + i.1.1 in
Map.fold aux m (-2)
let aux = fun (i : int * (string * int)) -> i.0 + i.1.1
in Map.fold aux m (-2)
let map_iter =
let aux = fun (i: string * int) -> if (i.1=12) then failwith "never" else () in
Map.iter aux m
let aux =
fun (i : string * int) -> if i.1 = 12 then failwith "never"
in Map.iter aux m
let map_map =
let aux = fun (i: string * int) -> i.1 + (String.size i.0) in
Map.map aux m
let aux = fun (i : string * int) -> i.1 + String.length i.0
in Map.map aux m
let map_mem = (Map.mem "one" m , Map.mem "four" m)
let map_mem = Map.mem "one" m, Map.mem "four" m
let map_remove = (Map.remove "one" m, Map.remove "four" m)
let map_remove = Map.remove "one" m, Map.remove "four" m
let map_update = (
Map.update "one" (Some(1)) (Map.literal [ "one", 2 ]),
let map_update =
Map.update "one" (Some 1) (Map.literal ["one", 2]),
Map.update "one" (None : int option) (Map.literal ["one", 1]),
Map.update "one" (None : int option) (Map.literal []:(string,int) map),
Map.update "one" (Some(1)) (Map.literal []:(string,int) map)
)
Map.update "one" (None : int option) (Map.empty : (string, int) map),
Map.update "one" (Some 1) (Map.literal [] : (string, int) map)
let s = Set.literal [1; 2; 3]
let set_add = (
let set_add =
Set.add 1 s,
Set.add 4 s,
Set.add 1 (Set.literal [] : int set)
)
Set.add 1 (Set.empty : int set)
let set_iter_fail =
let aux = fun (i:int) -> if i = 1 then failwith "set_iter_fail" else () in
Set.iter aux (Set.literal [1 ; 2 ; 3])
let aux = fun (i : int) -> if i = 1 then failwith "set_iter_fail"
in Set.iter aux (Set.literal [1; 2; 3])
let set_mem = (
let set_mem =
Set.mem 1 s,
Set.mem 4 s,
Set.mem 1 (Set.literal [] : int set)
)
Set.mem 1 (Set.empty : int set)

2
src/test/contracts/isnat.mligo
View File

@ -1 +1 @@
let main (i: int) : nat option = Michelson.is_nat i
let main (i : int) : nat option = is_nat i

2
src/test/contracts/isnat.religo
View File

@ -1 +1 @@
let main = (i: int): option(nat) => Michelson.is_nat(i);
let main = (i : int): option (nat) => is_nat (i);

6
src/test/contracts/key_hash.ligo
View File

@ -1,7 +1,5 @@
function check_hash_key (const kh1 : key_hash;
const k2 : key) : bool * key_hash is
block {
var ret : bool := False;
var kh2 : key_hash := crypto_hash_key (k2);
if kh1 = kh2 then ret := True else skip
} with (ret, kh2)
var kh2 : key_hash := Crypto.hash_key (k2);
} with ((kh1 = kh2), kh2)

6
src/test/contracts/key_hash.mligo
View File

@ -1,5 +1,3 @@
let check_hash_key (kh1, k2 : key_hash * key) : bool * key_hash =
let kh2 : key_hash = Crypto.hash_key k2 in
if kh1 = kh2
then (true, kh2)
else (false, kh2)
let kh2 : key_hash = Crypto.hash_key k2
in kh1 = kh2, kh2

7
src/test/contracts/key_hash.religo
View File

@ -1,10 +1,5 @@
let check_hash_key = (kh1_k2 : (key_hash, key)) : (bool, key_hash) => {
let kh1, k2 = kh1_k2;
let kh2 : key_hash = Crypto.hash_key (k2);
if (kh1 == kh2) {
(true, kh2);
}
else {
(false, kh2);
}
((kh1 == kh2), kh2)
};

9
src/test/contracts/key_hash_comparable.ligo
View File

@ -1,8 +1,9 @@
type storage is record
type storage is record [
one : map (key_hash, nat);
two: big_map(key_hash, bool);
end
two : big_map (key_hash, bool)
]
type return is list (operation) * storage
function main (const a : int; const store : storage) : return is ((nil: list(operation)), store)
function main (const a : int; const store : storage) : return is
((nil : list (operation)), store)

5
src/test/contracts/lambda.mligo
View File

@ -1,8 +1,7 @@
type storage = unit
(* not supported yet
let main (p:unit) storage =
(fun x -> ()) ()
let main (p, s : unit * storage) = (fun x -> ()) ()
*)
let main (ps: unit * storage) = (fun (_: unit) -> ()) ()
let main (p, s : unit * storage) = (fun (_ : unit) -> ()) ()

5
src/test/contracts/lambda.religo
View File

@ -5,6 +5,5 @@ type storage = unit;
(fun x -> ()) ()
*/
let main2 = ((p: unit), s: storage) => (((xxx: unit)) => ())();
let main = (x: (unit, storage)) => main2(x[0], x[1]);
let main = ((p,s) : (unit, storage)) : unit =>
(((useless : unit)) => ()) ();

4
src/test/contracts/lambda2.mligo
View File

@ -1,8 +1,8 @@
type storage = unit
(* Not supported yet:
let main (p:unit) storage = (fun x -> ()) ()
let main (a, s : unit * storage) = (fun x -> ()) ()
*)
let main (_: unit * storage) =
let main (a, s : unit * storage) =
(fun (f : unit -> unit) -> f ()) (fun (_ : unit) -> unit)

6
src/test/contracts/lambda2.religo
View File

@ -4,7 +4,5 @@ type storage = unit;
let main (p:unit) storage = (fun x -> ()) ()
*/
let main2 = (z: unit, s: storage) =>
((f: (unit => unit)) => f())((z: unit) => unit);
let main = (x: (unit, storage)) => main2(x[0],x[1]);
let main = ((a, s) : (unit, storage)) : unit =>
((f : (unit => unit)) => f ()) ((useless : unit) => unit);

10
src/test/contracts/let_multiple.mligo
View File

@ -13,15 +13,13 @@ let (foo : int) , (bar : int) = foobar
(* Here to prevent a regression of https://gitlab.com/ligolang/ligo/issues/63#note_254106580 *)
let correct_values_bound (p: unit) : int * int =
foo, bar
let correct_values_bound (p : unit) : int * int = foo, bar
let non_tuple_rhs (p: unit) : int =
bar - foo
let non_tuple_rhs (p : unit) : int = bar - foo
(* Here to prevent a regression of https://gitlab.com/ligolang/ligo/issues/63#note_254106580 *)
let big_tuple : (int * int * int * int * int) = (10, 20, 30, 40, 50)
let big_tuple : int * int * int * int * int = 10, 20, 30, 40, 50
let (a: int), (b: int), (c: int), (d: int), (e: int) = big_tuple
@ -30,7 +28,7 @@ let correct_values_big_tuple (p: unit) : int * int * int * int * int =
(* Here to prevent a regression of https://gitlab.com/ligolang/ligo/issues/63#note_254106580 *)
let different_types: (int * string) = 10, "hello"
let different_types : int * string = 10, "hello"
let (greet_num : int), (greeting : string) = different_types

1
src/test/contracts/let_multiple.religo
View File

@ -9,6 +9,7 @@ let ((x: int), (y: int)) = (3, 3);
let main_paren = (p : unit): int => x + y;
let foobar : (int, int) = (23, 42);
let ((foo : int), (bar : int)) = foobar;
let non_tuple_rhs = (p : unit) : int => foo + bar;

2
src/test/contracts/letin.mligo
View File

@ -1,6 +1,6 @@
type storage = int * int
let main (n: int * storage) =
let main (n : int * storage) : operation list * storage =
let x : int * int =
let x : int = 7
in x + n.0, n.1.0 + n.1.1

6
src/test/contracts/letin.religo
View File

@ -1,11 +1,9 @@
type storage = (int, int);
let main2 = ((n : int), s: storage) => {
let main = (n : (int, storage)) : (list (operation), storage) => {
let x : (int, int) = {
let x : int = 7;
(x + n, s[0] + s[1]);
(x + n[0], n[1][0] + n[1][1]);
};
([]: list (operation), x);
};
let main = (x: (int, storage)) => main2(x[0],x[1]);

6
src/test/contracts/list.ligo
View File

@ -17,17 +17,17 @@ const bl : foobar = list [144; 51; 42; 120; 421]
function fold_op (const s : list (int)) : int is
block {
function aggregate (const prec: int; const cur: int) : int is prec+cur
} with list_fold (aggregate, s, 10)
} with List.fold (aggregate, s, 10)
function iter_op (const s : list (int)) : int is
block {
var r : int := 0;
function aggregate (const i : int) : unit is
block { r := r + i } with unit;
list_iter (aggregate, s)
List.iter (aggregate, s)
} with r
function map_op (const s : list (int)) : list (int) is
block {
function increment (const i : int) : int is i+1
} with list_map (increment, s)
} with List.map (increment, s)

8
src/test/contracts/list.mligo
View File

@ -1,19 +1,21 @@
type storage = int * int list
type param = int list
type parameter = int list
type return = operation list * storage
let x : int list = []
let y : int list = [3; 4; 5]
let z : int list = 2::y
let main (p, s: param * storage) =
let main (p, s: parameter * storage) : return =
let storage =
match p with
[] -> s
| hd::tl -> s.0 + hd, tl
in ([] : operation list), storage
let size_ (s: int list) : nat = List.size s
let size_ (s : int list) : nat = List.length s
let fold_op (s : int list) : int =
let aggregate = fun (t : int * int) -> t.0 + t.1

20
src/test/contracts/list.religo
View File

@ -1,26 +1,26 @@
type storage = (int, list (int));
type param = list(int);
type parameter = list (int);
type return = (list (operation), storage);
let x : list (int) = [];
let y : list (int) = [3, 4, 5];
let z : list (int) = [2, ...y];
let main2 = (p: param, storage : storage) => {
let main = ((action, s) : (parameter, storage)) : return => {
let storage =
switch (p) {
| [] => storage
| [hd, ...tl] => (storage[0] + hd, tl)
switch (action) {
| [] => s
| [hd, ...tl] => (s[0] + hd, tl)
};
([]: list(operation), storage);
};
let main = (x: (param, storage)) => main2(x[0],x[1]);
let size_ = (s: list(int)): nat => List.size(s);
let size_ = (s : list (int)) : nat => List.length (s);
let fold_op = (s : list (int)) : int => {
let aggregate = (prec_cur: (int, int)) => prec_cur[0] + prec_cur[1];
let aggregate = (t: (int, int)) => t[0] + t[1];
List.fold (aggregate, s, 10);
};
@ -28,6 +28,6 @@ let map_op = (s: list(int)): list(int) =>
List.map ((cur : int) => cur + 1, s);
let iter_op = (s : list (int)) : unit => {
let do_nothing = (z: int) => unit;
let do_nothing = (useless : int) => unit;
List.iter (do_nothing, s);
};

24
src/test/contracts/loop.mligo
View File

@ -1,31 +1,35 @@
(* Test loops in CameLIGO *)
(* Test functional iterators in CameLIGO *)
let aux_simple (i : int) : bool * int =
if i < 100 then continue (i + 1) else stop i
if i < 100 then Loop.resume (i + 1) else Loop.stop i
let counter_simple (n : int) : int =
Loop.fold_while aux_simple n
type sum_aggregator = {
counter : int;
sum : int ;
sum : int
}
let counter (n : int) : int =
let initial : sum_aggregator = {counter=0; sum=0} in
let out : sum_aggregator = Loop.fold_while (fun (prev: sum_aggregator) ->
let aggregate = fun (prev : sum_aggregator) ->
if prev.counter <= n then
continue ({ counter = prev.counter + 1 ; sum = prev.counter + prev.sum })
Loop.resume {counter = prev.counter + 1;
sum = prev.counter + prev.sum}
else
stop ({ counter = prev.counter ; sum = prev.sum }) )
initial in out.sum
Loop.stop {counter = prev.counter; sum = prev.sum} in
let out : sum_aggregator =
Loop.fold_while aggregate initial
in out.sum
let aux_nest (prev : sum_aggregator) : bool * sum_aggregator =
if prev.counter < 100 then
continue ({ counter = prev.counter + 1 ;
sum = prev.sum + Loop.fold_while aux_simple prev.counter})
let sum : int =
prev.sum + Loop.fold_while aux_simple prev.counter
in Loop.resume {counter = prev.counter + 1; sum = sum}
else
stop ({ counter = prev.counter ; sum = prev.sum })
Loop.stop {counter = prev.counter; sum = prev.sum}
let counter_nest (n : int) : int =
let initial : sum_aggregator = {counter=0; sum=0} in

31
src/test/contracts/loop.religo
View File

@ -1,11 +1,7 @@
/* Test loops in ReasonLIGO */
let aux_simple = (i : int) : (bool, int) =>
if (i < 100) {
continue(i + 1);
} else {
stop(i);
};
if (i < 100) { Loop.resume (i + 1); } else { Loop.stop (i); };
let counter_simple = (n : int) : int => Loop.fold_while (aux_simple, n);
@ -16,27 +12,26 @@ type sum_aggregator = {
let counter = (n : int) : int => {
let initial : sum_aggregator = {counter: 0, sum: 0};
let out: sum_aggregator =
Loop.fold_while(
(prev: sum_aggregator) =>
let aggregate = (prev : sum_aggregator) =>
if (prev.counter <= n) {
continue({counter: prev.counter + 1, sum: prev.counter + prev.sum});
Loop.resume ({counter : prev.counter + 1,
sum : prev.counter + prev.sum});
} else {
stop({counter: prev.counter, sum: prev.sum});
},
initial
);
Loop.stop ({counter: prev.counter, sum: prev.sum});
};
let out : sum_aggregator =
Loop.fold_while (aggregate, initial);
out.sum;
};
let aux_nest = (prev : sum_aggregator) : (bool, sum_aggregator) =>
if (prev.counter < 100) {
continue({
counter: prev.counter + 1,
sum: prev.sum + Loop.fold_while(aux_simple, prev.counter),
});
let sum : int =
prev.sum + Loop.fold_while (aux_simple, prev.counter);
Loop.resume ({counter: prev.counter + 1,
sum: sum});
} else {
stop({counter: prev.counter, sum: prev.sum});
Loop.stop ({counter: prev.counter, sum: prev.sum});
};
let counter_nest = (n : int) : int => {

4
src/test/contracts/loop_bugs.ligo
View File

@ -1,6 +1,6 @@
function shadowing_in_body (var nee : unit) : string is block {
var st : string := "";
var list1 : list(string) := list "to"; "to" end;
var list1 : list (string) := list ["to"; "to"];
for x in list list1 block {
const x : string = "ta";
st := st ^ x;
@ -10,7 +10,7 @@ function shadowing_in_body (var nee : unit) : string is block {
function shadowing_assigned_in_body (var nee : unit) : string is block {
var st : string := "";
var list1 : list(string) := list "to"; "to" end;
var list1 : list (string) := list ["to"; "to"];
for x in list list1 block {
st := st ^ x;
var st : string := "ta";

14
src/test/contracts/map.ligo
View File

@ -30,32 +30,28 @@ function patch_ (var m : foobar) : foobar is block {
function patch_deep (var m : foobar * nat) : foobar * nat is
block { patch m.0 with map [1 -> 9] } with m
function size_ (const m : foobar) : nat is size (m)
function gf (const m : foobar) : int is get_force (23, m)
function size_ (const m : foobar) : nat is Map.size (m)
function get (const m : foobar) : option (int) is m[42]
function get_ (const m : foobar) : option (int) is map_get (42, m)
function mem (const k: int; const m: foobar) : bool is map_mem (k, m)
function mem (const k: int; const m: foobar) : bool is Map.mem (k, m)
function iter_op (const m : foobar) : unit is
block {
function aggregate (const i : int; const j : int) : unit is block
{ if i=j then skip else failwith ("fail") } with unit
} with map_iter (aggregate, m)
} with Map.iter (aggregate, m)
function map_op (const m : foobar) : foobar is
block {
function increment (const i : int; const j : int) : int is j+1
} with map_map (increment, m)
} with Map.map (increment, m)
function fold_op (const m : foobar) : int is
block {
function aggregate (const i : int; const j : int * int) : int is
i + j.0 + j.1
} with map_fold(aggregate, m, 10)
} with Map.fold (aggregate, m, 10)
function deep_op (var m : foobar) : foobar is
block {

7
src/test/contracts/map.mligo
View File

@ -16,26 +16,27 @@ let add (n,m: int * foobar) : foobar = Map.add 23 n m
let rm (m : foobar) : foobar = Map.remove 42 m
(* Dummy test so that we can add the same test for PascaLIGO *)
let patch_ (m : foobar) : foobar = Map.literal [(0,5); (1,6); (2,7)]
(* Second dummy test, see above *)
let patch_empty (m : foobar) : foobar = Map.literal [(0,0); (1,1); (2,2)]
(* Third dummy test, see above *)
let patch_deep (m : foobar * nat) : foobar * nat =
Map.literal [(0,0); (1,9); (2,2)], 10n
let size_ (m : foobar) : nat = Map.size m
let gf (m: foobar) : int = Map.find 23 m
let get (m : foobar) : int option = Map.find_opt 42 m
let get_ (m : foobar) : int option = Map.find_opt 42 m
let mem (k,m : int * foobar) : bool = Map.mem k m
let iter_op (m : foobar) : unit =
let assert_eq = fun (i: int * int) -> assert (i.0 = i.1)
let assert_eq = fun (a, b : int * int) -> assert (a = b)
in Map.iter assert_eq m
let map_op (m : foobar) : foobar =

9
src/test/contracts/map.religo
View File

@ -1,4 +1,3 @@
type foobar = map (int, int);
let empty_map: foobar = Map.empty;
@ -15,13 +14,17 @@ let add = (n: int, m: foobar) : foobar => Map.add(23, n, m);
let rm = (m: foobar) : foobar => Map.remove (42, m);
/* Dummy test so that we can add the same test for PascaLIGO */
let patch_ = (m: foobar): foobar => Map.literal([(0, 5), (1, 6), (2, 7)]);
let patch_ = (m : foobar) : foobar =>
Map.literal ([(0, 5), (1, 6), (2, 7)]);
/* Second dummy test, see above */
let patch_empty = (m : foobar) : foobar =>
Map.literal ([(0, 0), (1, 1), (2, 2)]);
/* Third dummy test, see above */
let patch_deep = (m : (foobar, nat)) : (foobar, nat) => (
Map.literal([(0, 0), (1, 9), (2, 2)]),
10n
@ -29,8 +32,6 @@ let patch_deep = (m: (foobar, nat)): (foobar, nat) => (
let size_ = (m : foobar) : nat => Map.size (m);
let gf = (m: foobar): int => Map.find(23, m);
let get = (m: foobar): option(int) => Map.find_opt (42, m);
let get_ = (m: foobar): option(int) => Map.find_opt(42, m);

16
src/test/contracts/match.mligo
View File

@ -1,16 +1,18 @@
type storage = int
type param =
type parameter =
Add of int
| Sub of int
let main (p, s: param * storage) =
let storage =
s +
(match p with
type return = operation list * storage
let main (action, store : parameter * storage) =
let store =
store +
(match action with
Add n -> n
| Sub n -> 0-n)
in ([] : operation list), storage
| Sub n -> -n)
in ([] : operation list), store
let match_bool (b : bool) : int =
match b with

24
src/test/contracts/match.religo
View File

@ -1,19 +1,17 @@
type storage = int;
type param =
type parameter =
| Add (int)
| Sub (int);
let main2 = ((p: param), s: storage) => {
let storage =
s
+ (
switch (p) {
| Add(n) => n
| Sub(n) => 0 - n
}
);
(([]: list(operation)), storage);
};
type return = (list (operation), storage);
let main = (x: (param, storage)) => main2(x[0],x[1]);
let main = ((action, store): (parameter, storage)) => {
let store =
store +
(switch (action) {
| Add (n) => n
| Sub (n) => -n
});
(([]: list (operation)), store);
};

20
src/test/contracts/match_bis.mligo
View File

@ -1,19 +1,17 @@
type storage = int
(* variant defining pseudo multi-entrypoint actions *)
type action =
type parameter =
Increment of int
| Decrement of int
type return = operation list * storage
let add (a : int) (b : int) : int = a + b
let sub (a : int) (b : int) : int = a - b
(* real entrypoint that re-routes the flow based on the action provided *)
let main (p, s: action * storage) =
let storage =
match p with
Increment n -> add s n
| Decrement n -> sub s n
in ([] : operation list), storage
let main (action, store : parameter * storage) : return =
let store =
match action with
Increment n -> add store n
| Decrement n -> sub store n
in ([] : operation list), store

23
src/test/contracts/match_bis.religo
View File

@ -1,24 +1,17 @@
type storage = int;
/* variant defining pseudo multi-entrypoint actions */
type action =
type parameter =
Increment (int)
| Decrement (int);
let add = ((a: int), (b: int)) => a + b;
let sub = ((a: int), (b: int)) => a - b;
let subtract = ((a: int), (b: int)) => a - b;
/* real entrypoint that re-routes the flow based on the action provided */
let main2 = ((p: action), storage : storage) => {
let storage =
switch (p) {
| Increment(n) => add(storage, n)
| Decrement(n) => subtract(storage, n)
let main = ((action, store) : (parameter, storage)) => {
let store =
switch (action) {
| Increment (n) => add (store, n)
| Decrement (n) => sub (store, n)
};
(([]: list(operation)), storage);
(([] : list (operation)), store);
};
let main = (x: (action, storage)) => main2(x[0],x[1]);

2
src/test/contracts/multiple-parameters.mligo
View File

@ -1,7 +1,7 @@
(* Test function with several parameters *)
let abcde_curried (a : int) (b : int) (c : int) (d : int) (e : int) : int =
(c + e + 3)
c + e + 3
let abcde (x : int * int * int * int * int) : int =
abcde_curried x.0 x.1 x.2 x.3 x.4

7
src/test/contracts/multiple-parameters.religo
View File

@ -1,6 +1,7 @@
/* Test function with several parameters */
let abcde_curried = (a: int, b: int, c: int, d: int, e: int): int => c + e + 3;
let abcde = (x: (int , int , int , int , int)): int => abcde_curried(x[0], x[1], x[2], x[3], x[4]);
let abcde_curried =
(a: int, b: int, c: int, d: int, e: int): int => c + e + 3;
let abcde = (x: (int , int , int , int , int)) : int =>
abcde_curried (x[0], x[1], x[2], x[3], x[4]);

43
src/test/contracts/multisig-v2.ligo
View File

@ -37,22 +37,22 @@ function send (const param : send_pt; const s : storage) : return is
block {
// check sender against the authorized addresses
if not set_mem (sender, s.authorized_addresses)
if not Set.mem (Tezos.sender, s.authorized_addresses)
then failwith("Unauthorized address")
else skip;
// check message size against the stored limit
var message : message := param;
const packed_msg : bytes = bytes_pack (message);
if size (packed_msg) > s.max_message_size
const packed_msg : bytes = Bytes.pack (message);
if Bytes.length (packed_msg) > s.max_message_size
then failwith ("Message size exceed maximum limit")
else skip;
(* compute the new set of addresses associated with the message and
update counters *)
var new_store : addr_set := set_empty;
var new_store : addr_set := set [];
case map_get (packed_msg, s.message_store) of
Some (voters) ->
@ -60,26 +60,25 @@ function send (const param : send_pt; const s : storage) : return is
(* The message is already stored.
Increment the counter only if the sender is not already
associated with the message. *)
if set_mem (sender, voters)
if Set.mem (Tezos.sender, voters)
then skip
else s.proposal_counters[sender] :=
get_force (sender, s.proposal_counters) + 1n;
new_store := set_add(sender,voters)
else s.proposal_counters[Tezos.sender] :=
get_force (Tezos.sender, s.proposal_counters) + 1n;
new_store := Set.add (Tezos.sender,voters)
}
| None ->
block {
// the message has never been received before
s.proposal_counters[sender] :=
get_force (sender, s.proposal_counters) + 1n;
new_store := set [sender]
get_force (Tezos.sender, s.proposal_counters) + 1n;
new_store := set [Tezos.sender]
}
end;
// check sender counters against the maximum number of proposal
var sender_proposal_counter : nat :=
get_force (sender, s.proposal_counters);
get_force (Tezos.sender, s.proposal_counters);
if sender_proposal_counter > s.max_proposal
then failwith ("Maximum number of proposal reached")
@ -89,14 +88,14 @@ function send (const param : send_pt; const s : storage) : return is
var ret_ops : list (operation) := nil;
if size (new_store) >= s.threshold then {
if Set.cardinal (new_store) >= s.threshold then {
remove packed_msg from map s.message_store;
ret_ops := message (s.state_hash);
// update the state hash
s.state_hash := sha_256 (bytes_concat (s.state_hash, packed_msg));
s.state_hash := Crypto.sha256 (Bytes.concat (s.state_hash, packed_msg));
// decrement the counters
for addr -> ctr in map s.proposal_counters block {
if set_mem(addr,new_store) then
if Set.mem (addr, new_store) then
s.proposal_counters[addr] := abs (ctr - 1n)
else skip
}
@ -106,26 +105,26 @@ function send (const param : send_pt; const s : storage) : return is
function withdraw (const param : withdraw_pt; const s : storage) : return is
block {
var message : message := param;
const packed_msg : bytes = bytes_pack (message);
const packed_msg : bytes = Bytes.pack (message);
case map_get(packed_msg, s.message_store) of
case s.message_store[packed_msg] of
Some (voters) ->
block {
// The message is stored
const new_set : addr_set = set_remove (sender, voters);
const new_set : addr_set = Set.remove (Tezos.sender, voters);
(* Decrement the counter only if the sender was already
associated with the message *)
if size (voters) =/= size (new_set)
then s.proposal_counters[sender] :=
abs (get_force (sender, s.proposal_counters) - 1n)
if Set.cardinal (voters) =/= Set.cardinal (new_set)
then s.proposal_counters[Tezos.sender] :=
abs (get_force (Tezos.sender, s.proposal_counters) - 1n)
else skip;
(* If the message is left without any associated addresses,
remove the corresponding message_store field *)
if size (new_set) = 0n
if Set.cardinal (new_set) = 0n
then remove packed_msg from map s.message_store
else s.message_store[packed_msg] := new_set
}

6
src/test/contracts/multisig.ligo
View File

@ -38,7 +38,7 @@ function check_message (const param : check_message_pt;
failwith ("Counters does not match")
else {
const packed_payload : bytes =
bytes_pack ((message, param.counter, s.id, get_chain_id));
Bytes.pack ((message, param.counter, s.id, Tezos.chain_id));
var valid : nat := 0n;
var keys : authorized_keys := s.auth;
@ -47,8 +47,8 @@ function check_message (const param : check_message_pt;
nil -> skip
| key # tl -> block {
keys := tl;
if pkh_sig.0 = crypto_hash_key (key) then
if crypto_check (key, pkh_sig.1, packed_payload)
if pkh_sig.0 = Crypto.hash_key (key) then
if Crypto.check (key, pkh_sig.1, packed_payload)
then valid := valid + 1n
else failwith ("Invalid signature")
else skip

64
src/test/contracts/multisig.mligo
View File

@ -2,7 +2,7 @@
type counter = nat
type threshold = nat
type authorized_keys = (key) list
type authorized_keys = key list
type id = string
type storage = {
@ -14,53 +14,51 @@ type storage = {
// I/O types
type message = unit -> (operation) list
type message = unit -> operation list
type signatures = (key_hash * signature) list
type check_message_pt = {
counter : counter;
message : message;
signatures : signatures
}
type return = (operation) list * storage
type return = operation list * storage
type parameter = CheckMessage of check_message_pt
let check_message (param, s : check_message_pt * storage) : return =
let message : message = param.message in
let s =
if (param.counter <> s.counter) then
let coco = failwith ("Counters does not match") in s
else (
let packed_payload : bytes = Bytes.pack ((message, param.counter, s.id, chain_id)) in
if param.counter <> s.counter then
(failwith "Counters does not match" : storage)
else
let packed_payload : bytes =
Bytes.pack (message, param.counter, s.id, chain_id) in
let valid : nat = 0n in
let keys : authorized_keys = s.auth in
let aux = fun (vk, pkh_sig: (nat* authorized_keys) * (key_hash*signature)) ->
let (valid,keys) = vk in
match (keys) with
| [] -> (valid,keys)
| key::tl -> (
let keys = tl in
if (pkh_sig.0 = Crypto.hash_key (key)) then
let aux =
fun (vk, pkh_sig: (nat * authorized_keys)*(key_hash * signature)) ->
let valid, keys = vk in
match keys with
| [] -> vk
| key::keys ->
if pkh_sig.0 = Crypto.hash_key key
then
let valid =
if (Crypto.check key pkh_sig.1 packed_payload) then valid + 1n
else let coco = failwith ("Invalid signature") in valid
in
(valid,keys)
else (valid,keys)
)
in
let (valid,keys) = List.fold aux param.signatures (valid,keys) in
if (valid < s.threshold) then
let coco = failwith ("Not enough signatures passed the check") in
s
else
{s with counter = s.counter + 1n}
)
in
(message(unit),s)
if Crypto.check key pkh_sig.1 packed_payload
then valid + 1n
else (failwith "Invalid signature" : nat)
in valid, keys
else valid, keys in
let valid, keys =
List.fold aux param.signatures (valid, keys) in
if valid < s.threshold then
(failwith ("Not enough signatures passed the check") : storage)
else {s with counter = s.counter + 1n}
in message unit, s
let main (param, s: parameter * storage) : return =
match (param) with
| CheckMessage (p) -> check_message (p,s)
let main (action, store : parameter * storage) : return =
match action with
CheckMessage (p) -> check_message (p, store)

Some files were not shown because too many files have changed in this diff Show More