ligo_v1.6.0

Makefile

@@ -1,6 +1,6 @@
 SHELL := /bin/bash
 
-ligo_compiler?=docker run --rm -v "$(PWD)":"$(PWD)" -w "$(PWD)" ligolang/ligo:1.2.0
+ligo_compiler?=docker run --rm -v "$(PWD)":"$(PWD)" -w "$(PWD)" ligolang/ligo:1.6.0
 # ^ Override this variable when you run make command by make <COMMAND> ligo_compiler=<LIGO_EXECUTABLE>
 # ^ Otherwise use default one (you'll need docker)
 PROTOCOL_OPT?=
@@ -68,8 +68,7 @@ ifndef SUITE
 	@$(call test,fa2/multi_asset_jsligo.test.mligo)
 	@$(call test,fa2/nft/nft_jsligo.test.mligo)
 	@$(call test,fa2/nft/views.test.mligo)
-
-##  @$(call test,fa2/nft/e2e_mutation.test.mligo)
+	@$(call test,fa2/nft/e2e_mutation.test.mligo)
 else
 	@$(call test,$(SUITE).test.mligo)
 endif

lib/fa2.1/data/approvals.jsligo

@@ -41,7 +41,7 @@ export const decrease_approved_amount = (
   amount_: Amount.T
 ): T => {
   let balance_ = get_amount(approvals, from_, spender, token_id);
-  assert_with_error((balance_ >= amount_), Errors.ins_balance);
+  Assert.Error.assert((balance_ >= amount_), Errors.ins_balance);
   balance_ = abs(balance_ - amount_);
 
   return set_amount(approvals, from_, spender, token_id, balance_);

lib/fa2.1/data/ledger.jsligo

@@ -72,7 +72,7 @@ export namespace Common_Asset {
 
   export const sub_to_val = (amount_: Amount.T, old_value: option<Amount.T>): Amount.T => {
     const value = balance_of(old_value);
-    assert_with_error(value >= amount_, Errors.ins_balance);
+    Assert.Error.assert(value >= amount_, Errors.ins_balance);
 
     return abs(value - amount_);
   };

lib/fa2.1/data/operators.jsligo

@@ -29,7 +29,7 @@ export const assert_authorisation = (
 };
 
 const assert_update_permission = (owner: owner): unit => {
-   assert_with_error(owner == Tezos.get_sender(), Errors.only_sender_manage_operators);
+   Assert.Error.assert(owner == Tezos.get_sender(), Errors.only_sender_manage_operators);
 };
 
 export const add_operator = (

lib/fa2.1/entrypoints/approve.jsligo

@@ -35,8 +35,8 @@ type event_map_key = [address, address, Token.T];
 const _approve = (approve: approve, approvals: Approvals.T): Approvals.T => {
   const { owner, spender, token_id, old_value, new_value } = approve;
   const amount = Approvals.get_amount(approvals, owner, spender, token_id);
-  assert_with_error(amount == old_value, Errors.unsafe_approval);
-  assert_with_error(owner == Tezos.get_sender(), Errors.not_owner);
+  Assert.Error.assert(amount == old_value, Errors.unsafe_approval);
+  Assert.Error.assert(owner == Tezos.get_sender(), Errors.not_owner);
   return Approvals.set_amount(approvals, owner, spender, token_id, new_value);
 };
 

lib/fa2.1/entrypoints/balance_of.jsligo

@@ -46,7 +46,7 @@ export const balance_of = <A, L>(
    const { requests, callback } = balance;
 
    return [list([
-      Tezos.transaction(
+      Tezos.Next.Operation.transaction(
          List.map(
             (request) => get_balance_info(storage, ledgerModule, request),
             requests

lib/fa2.1/entrypoints/export_ticket.jsligo

@@ -97,9 +97,9 @@ const create_ticket = <A, L>(
    const newLedger = Ledger.decrease_token_amount_for_user(ledger, from_, token_id, amount);
    let newStorage = Storage.set_approvals(storage, authorizedApprovals);
    newStorage = Storage.set_ledger(newStorage, newLedger.data);
-   const ticket = Option.unopt_with_error(
-      Tezos.create_ticket([token_id, None()], amount),
-      Errors.cannot_create_ticket
+   const ticket = Option.value_with_error(
+      Errors.cannot_create_ticket,
+      Tezos.Next.Ticket.create([token_id, None()], amount)
    );
    return [operations, ticket, newLedger, newStorage];
 };
@@ -121,7 +121,7 @@ export const export_tickets = <A, L>(
          newLedger = updatedLedger;
          operations = list([...newOps, ...operations]);
          const ticketReceiver: contract<ExportedTicket> = Tezos.get_contract_with_error(request.to_, Errors.invalid_destination);
-         operations = list([Tezos.transaction(ticket, 0tez, ticketReceiver), ...operations]);
+         operations = list([Tezos.Next.Operation.transaction(ticket, 0tez, ticketReceiver), ...operations]);
          finalStorage = newStorage;
       }
    }
@@ -134,8 +134,8 @@ export const export_tickets = <A, L>(
             operations = list([...newOps, ...operations]);
             let ticketOps : list<ExportedTicket> = list([ticket]);
             let finalTicketOps : list<ExportTicketsTo> = list([{to_: request.to_, ticketsToExport: ticketOps}]);
-            const ticketReceiver: contract<list<ExportTicketsTo>> = Tezos.get_contract_with_error(Option.unopt(op.destination), Errors.invalid_destination);
-            operations = list([Tezos.transaction(finalTicketOps, 0tez, ticketReceiver), ...operations]);
+            const ticketReceiver: contract<list<ExportTicketsTo>> = Tezos.get_contract_with_error(Option.value_with_error("Option is None", op.destination), Errors.invalid_destination);
+            operations = list([Tezos.Next.Operation.transaction(finalTicketOps, 0tez, ticketReceiver), ...operations]);
             finalStorage = newStorage;
          }
       }

lib/fa2.1/entrypoints/import_ticket.jsligo

@@ -52,15 +52,15 @@ const make_transfer = (from_: option<address>, txs: list<transaction>): transfer
 
 // @inline
 const assert_ticketer_is_self_address = (ticketer : address) : unit =>
-    assert_with_error(Tezos.get_self_address() == ticketer, Errors.invalid_ticket);
+    Assert.Error.assert (Tezos.get_self_address() == ticketer, Errors.invalid_ticket);
 
 const import_ticket_to = <L>(
     to_ : address,
     imported_ticket : imported_ticket,
     [transactions, ledger, operations] : [list<transaction>, LedgerModule<L>, list<operation>]
 ) : [list<transaction>, LedgerModule<L>, list<operation>] => {
     let operationsEvent = operations;
-    const [[ticketer, [[token_id, _data], amount]], _] = Tezos.read_ticket(imported_ticket);
+    const [[ticketer, [[token_id, _data], amount]], _] = Tezos.Next.Ticket.read (imported_ticket);
     assert_ticketer_is_self_address(ticketer);
     const newLedger = Ledger.increase_token_amount_for_user(ledger, to_, token_id, amount);
     const transaction = make_transaction(Some(to_), token_id, amount);

lib/fa2.1/entrypoints/lambda_export.jsligo

@@ -98,9 +98,9 @@ const create_ticket = <A, L>(
    let newStorage = Storage.set_approvals(storage, authorizedApprovals);
    newStorage = Storage.set_ledger(newStorage, newLedger.data);
 
-   const ticket = Option.unopt_with_error(
-      Tezos.create_ticket([token_id, None()], amount),
-      Errors.cannot_create_ticket
+   const ticket = Option.value_with_error(
+      Errors.cannot_create_ticket,
+      Tezos.Next.Ticket.create([token_id, None()], amount)
    );
    return [operations, ticket, newLedger, newStorage];
 };
@@ -123,15 +123,15 @@ export const lambda_export = <A, L>(
       ticketsToExport
    );
 
-   const operation = Tezos.transaction(
+   const operation = Tezos.Next.Operation.transaction(
       {
          tickets,
          action: destination
       },
       Tezos.get_amount(),
-      Option.unopt_with_error(
-         Tezos.get_contract_opt(storage.proxy),
-         Errors.invalid_proxy
+      Option.value_with_error(
+         Errors.invalid_proxy,
+         Tezos.get_contract_opt(storage.proxy)
       )
    );
    finalOperations = list([operation, ...newOperations]);

lib/fa2.1/entrypoints/mint.jsligo

@@ -19,7 +19,7 @@ type total_supply_update_type =
 @layout("comb")
 {
   token_id: Token.T,
-  new_total_supply: nat,
+  new_total_supply: Amount.T,
   diff: int
 };
 

lib/fa2/asset/extendable_multi_asset.impl.jsligo

@@ -113,7 +113,7 @@ export const decrease_token_amount_for_user = (
    [ledger, from_, token_id, amount_]: [ledger, address, nat, nat]
 ): ledger => {
    let balance_ = get_for_user([ledger, from_, token_id]);
-   assert_with_error((balance_ >= amount_), Errors.ins_balance);
+   Assert.Error.assert((balance_ >= amount_), Errors.ins_balance);
    balance_ = abs(balance_ - amount_);
    return set_for_user([ledger, from_, token_id, balance_])
 };
@@ -167,7 +167,7 @@ export const balance_of = <T>(b: TZIP12.balance_of, s: storage<T>): ret<T> => {
       return ({ request: request, balance: balance_ })
    };
    const callback_param = List.map(get_balance_info, requests);
-   const operation = Tezos.transaction(Main(callback_param), 0mutez, callback);
+   const operation = Tezos.Next.Operation.transaction(Main(callback_param), 0mutez, callback);
    return [list([operation]), s]
 };
 

lib/fa2/asset/extendable_multi_asset.impl.mligo

@@ -102,7 +102,7 @@ let decrease_token_amount_for_user
   (amount_ : nat)
 : ledger =
   let balance_ = get_for_user ledger from_ token_id in
-  let () = assert_with_error (balance_ >= amount_) Errors.ins_balance in
+  let () = Assert.Error.assert (balance_ >= amount_) Errors.ins_balance in
   let balance_ = abs (balance_ - amount_) in
   let ledger = set_for_user ledger from_ token_id balance_ in
   ledger
@@ -121,9 +121,10 @@ let increase_token_amount_for_user
 // Storage
 let assert_token_exist (type a) (s : a storage) (token_id : nat) : unit =
   let _ =
-    Option.unopt_with_error
+    Option.value_with_error
+      Errors.undefined_token
       (Big_map.find_opt token_id s.token_metadata)
-      Errors.undefined_token in
+      in
   ()
 
 let set_ledger (type a) (s : a storage) (ledger : ledger) =
@@ -176,7 +177,7 @@ let balance_of (type a) (b : TZIP12.balance_of) (s : a storage) : a ret =
      balance = balance_
     } in
   let callback_param = List.map get_balance_info requests in
-  let operation = Tezos.transaction (Main callback_param) 0mutez callback in
+  let operation = Tezos.Next.Operation.transaction (Main callback_param) 0mutez callback in
   ([operation] : operation list), s
 
 let update_operators (type a)

lib/fa2/asset/extendable_single_asset.impl.jsligo

@@ -105,7 +105,7 @@ export const decrease_token_amount_for_user = (
    amount_: nat
 ): ledger => {
    let tokens = get_for_user(ledger, from_);
-   const _ = assert_with_error(tokens >= amount_, Errors.ins_balance);
+   const _ = Assert.Error.assert(tokens >= amount_, Errors.ins_balance);
    tokens = abs(tokens - amount_);
    return update_for_user(ledger, from_, tokens)
 };
@@ -164,7 +164,7 @@ export const balance_of = <T>(b: TZIP12.balance_of, s: storage<T>): ret<T> => {
       return { request: request, balance: balance_ }
    };
    const callback_param = List.map(get_balance_info, requests);
-   const operation = Tezos.transaction(Main(callback_param), 0mutez, callback);
+   const operation = Tezos.Next.Operation.transaction(Main(callback_param), 0mutez, callback);
    return [list([operation]), s]
 };
 

lib/fa2/asset/extendable_single_asset.impl.mligo

@@ -88,7 +88,7 @@ let decrease_token_amount_for_user
   (amount_ : nat)
 : ledger =
   let tokens = get_for_user ledger from_ in
-  let () = assert_with_error (tokens >= amount_) Errors.ins_balance in
+  let () = Assert.Error.assert (tokens >= amount_) Errors.ins_balance in
   let tokens = abs (tokens - amount_) in
   let ledger = update_for_user ledger from_ tokens in
   ledger
@@ -156,7 +156,7 @@ let balance_of (type a) (b : TZIP12.balance_of) (s : a storage) : a ret =
      balance = balance_
     } in
   let callback_param = List.map get_balance_info requests in
-  let operation = Tezos.transaction (Main callback_param) 0mutez callback in
+  let operation = Tezos.Next.Operation.transaction (Main callback_param) 0mutez callback in
   ([operation] : operation list), s
 
 (**

lib/fa2/common/assertions.jsligo

@@ -10,25 +10,25 @@
 */
 
 export const assert_update_permission = (owner: address): unit => {
-    return assert_with_error(
-        (owner == (Tezos.get_sender())),
+    return Assert.Error.assert(
+        (owner == Tezos.get_sender()),
         Errors.only_sender_manage_operators
     )
 }
 
 /**
 * Check if the token id is already defined
 * @param token_metadata : bigmap of token definitions
-* @param token_id : the token id to test 
+* @param token_id : the token id to test
 */
 
 export const assert_token_exist = (
     token_metadata: TZIP12Datatypes.tokenMetadata,
     token_id: nat
 ): unit => {
     const _ =
-        Option.unopt_with_error(
-            Big_map.find_opt(token_id, token_metadata),
-            Errors.undefined_token
+        Option.value_with_error(
+          Errors.undefined_token,
+          Big_map.find_opt(token_id, token_metadata)
         )
 };

lib/fa2/nft/extendable_nft.impl.jsligo

@@ -20,7 +20,7 @@ export type storage<T> = {
 
 type ret<T> = [list<operation>, storage<T>];
 
-const make_storage = (extension) =>
+const make_storage = <T>(extension: T) : storage<T> =>
    (
       {
          ledger: Big_map.empty,
@@ -57,7 +57,7 @@ export const assert_authorisation = (
 export const add_operator = (
    operators: operators,
    owner: address,
-   operator: address,
+   operator: operator,
    token_id: nat
 ): operators => {
    if (owner == operator) {
@@ -80,7 +80,7 @@ export const add_operator = (
 export const remove_operator = (
    operators: operators,
    owner: address,
-   operator: address,
+   operator: operator,
    token_id: nat
 ): operators => {
    if (owner == operator) {
@@ -108,12 +108,13 @@ export const remove_operator = (
 
 //  ledger
 export const is_owner_of = (ledger: ledger, token_id: nat, owner: address): bool => {
-   const current_owner = Option.unopt(Big_map.find_opt(token_id, ledger));
+   const current_owner = Option.value_with_error ("option is None", Big_map.find_opt(token_id, ledger));
    return (current_owner == owner)
 };
 
 export const assert_owner_of = (ledger: ledger, token_id: nat, owner: address): unit =>
-   assert_with_error(is_owner_of(ledger, token_id, owner), Errors.ins_balance);
+   Assert.Error.assert(is_owner_of(ledger, token_id, owner), Errors.ins_balance);
+
 
 export const transfer_token_from_user_to_user = (
    ledger: ledger,
@@ -171,7 +172,7 @@ export const balance_of = <T>(b: TZIP12.balance_of, s: storage<T>): ret<T> => {
       return ({ request: request, balance: balance_ })
    };
    const callback_param = List.map(get_balance_info, requests);
-   const operation = Tezos.transaction(Main(callback_param), 0mutez, callback);
+   const operation = Tezos.Next.Operation.transaction(Main(callback_param), 0mutez, callback);
    return [list([operation]), s]
 };
 

lib/fa2/nft/extendable_nft.impl.mligo

@@ -1,7 +1,6 @@
 [@public] #import "../common/assertions.jsligo" "Assertions"
 [@public] #import "../common/errors.mligo" "Errors"
 [@public] #import "../common/tzip12.datatypes.jsligo" "TZIP12"
-[@public] #import "../common/tzip12.interfaces.jsligo" "TZIP12Interface"
 [@public] #import "../common/tzip16.datatypes.jsligo" "TZIP16"
 
 type ledger = (nat, address) big_map
@@ -36,15 +35,14 @@ let assert_authorisation
   (from_ : address)
   (token_id : nat)
 : unit =
-  let sender_ = (Tezos.get_sender ()) in
-  if (sender_ = from_)
-  then ()
-  else
+  let sender_ = Tezos.get_sender () in
+  if sender_ <> from_
+  then
     let authorized =
       match Big_map.find_opt (from_, sender_) operators with
         Some (a) -> a
       | None -> Set.empty in
-    if Set.mem token_id authorized then () else failwith Errors.not_operator
+    if not (Set.mem token_id authorized) then failwith Errors.not_operator
 
 let is_operator
   (operators, owner, operator, token_id : (operators * address * address * nat))
@@ -96,11 +94,11 @@ let remove_operator
 
 //module Ledger = struct
 let is_owner_of (ledger : ledger) (token_id : nat) (owner : address) : bool =
-  let current_owner = Option.unopt (Big_map.find_opt token_id ledger) in
+  let current_owner: address = Option.value_with_error "Option is None" (Big_map.find_opt token_id ledger) in
   current_owner = owner
 
 let assert_owner_of (ledger : ledger) (token_id : nat) (owner : address) : unit =
-  assert_with_error (is_owner_of ledger token_id owner) Errors.ins_balance
+  Assert.Error.assert (is_owner_of ledger token_id owner) Errors.ins_balance
 
 let transfer_token_from_user_to_user
   (ledger : ledger)
@@ -176,7 +174,7 @@ let balance_of (type a) (b : TZIP12.balance_of) (s : a storage) : a ret =
      balance = balance_
     } in
   let callback_param = List.map get_balance_info requests in
-  let operation = Tezos.transaction (Main callback_param) 0mutez callback in
+  let operation = Tezos.Next.Operation.transaction (Main callback_param) 0mutez callback in
   ([operation] : operation list), s
 
 let update_operators (type a)

lib/fa2/nft/nft.impl.jsligo

@@ -1,7 +1,7 @@
-export #import "../common/assertions.jsligo" "Assertions"
+#import "../common/assertions.jsligo" "Assertions"
 export #import "../common/errors.mligo" "Errors"
 export #import "../common/tzip12.datatypes.jsligo" "TZIP12"
-export #import "../common/tzip16.datatypes.jsligo" "TZIP16"
+#import "../common/tzip16.datatypes.jsligo" "TZIP16"
 
 #import "./extendable_nft.impl.jsligo" "NFTExtendable"