ligo-extendable-fa2

ligo-breathalyzer

checker

ligo_fa1.2

dex-v3

ligo-fa1.2

An example of NFT factory contract written in cameligo

nft-factory-cameligo

A FA2 contract with nft, single asset & multi asset contracts

@ligo/fa

A math library for LIGO with support for Float & Rational numbers

@ligo/math-lib

An example of permit contract (TZIP-17) written in cameligo

@ligo/permit

An exemple of a shifumi game contract in JsLIGO

@ligo/shifumi-jsligo

#import "../src/lambda.mligo" "Lambda"

(* 
    Sample lambda code for an empty list of operations
    Notice that a type from the Lambda module is used
    See Makefile compile-lambda target for usage with ligo CLI
*)

let lambda_ : Lambda.operation_list =
  fun () -> ([] : operation list)


#import "../src/lambda.mligo" "Lambda"
#import "@ligo/fa/lib/fa2/asset/single_asset.mligo" "SingleAsset"

(* Sample lambda that calls an FA2 transfer entrypoint *)

let lambda_ : Lambda.operation_list =
  fun () ->
    match (Tezos.get_entrypoint_opt
             "%transfer"
             ("KT1QAShr81NcaFZyJR4srfYGuvPyD8ibbMtT"
              : address)
           : SingleAsset.transfer contract option)
    with
      None -> failwith ("TOKEN_CONTRACT_NOT_FOUND")
    | Some (c) ->
        let transfer_requests =
          ([({from_ =
                ("KT1BWSmjEhEknnBWSYrrSdhH217osBbwdVos"
                 : address);
              tx =
                ([{to_ =
                     ("tz1burnburnburnburnburnburnburjAYjjX"
                      : address);
                   amount = 4000n}]
                 : SingleAsset.atomic_trans list)})]
           : SingleAsset.transfer) in
        let op =
          Tezos.transaction transfer_requests 0mutez c in
        [op]


#import "../src/lambda.mligo" "Lambda"

(* 
    A parameter change lambda is just a new record of type Config.t, 
    the storage will be updated with the differences when the lambda is 
    executed
*)

let lambda_ : Lambda.parameter_change =
  fun () ->
    {deposit_amount = 400n;
     refund_threshold = 32n;
     quorum_threshold = 67n;
     super_majority = 80n;
     start_delay = 86400n;
     voting_period = 604800n;
     timelock_delay = 86400n;
     timelock_period = 259200n;
     burn_address =
       ("tz1burnburnburnburnburnburnburjAYjjX" : address)}


(*
    quorum_threshold, refund_threshold and super_majority
    are represented with scale = 2, ex. 80 = .80 = 80%

    x_delay and x_period are represented by time units in seconds
*)
type t =
    [@layout:comb]
    {
        deposit_amount: nat;
        (* ^ The amount of tokens required to be deposited when creating a proposal *)

        refund_threshold: nat;
        (* ^ The minimal amount of participating tokens required for the deposit to be refunded *)

        quorum_threshold: nat;
        (* ^ The minimal participation percentage needed for a proposal to pass *)

        super_majority: nat;
        (* ^ The percentage needed for a super majority ("yes" votes) *)

        start_delay: nat;
        (* ^ The delay for the vote to start *)

        voting_period: nat;
        (* ^ The period during which voting is live *)

        timelock_delay: nat;
        (* ^ Delay before an approved proposal can be executed *)

        timelock_period: nat;
        (* ^ The period during which a timelock can be executed *)

        burn_address: address;
        (* ^ The burn address for unrefunded deposits *)
    }


let proposal_already_exists = "PROPOSAL_ALREADY_EXISTS"
let voting_period = "VOTING_PERIOD"
let not_voting_period = "NOT_VOTING_PERIOD"
let no_proposal = "NO_PROPOSAL"
let not_creator = "NOT_CREATOR"
let timelock_not_found = "TIMELOCK_NOT_FOUND"
let timelock_locked = "TIMELOCK_LOCKED"
let timelock_unlocked = "TIMELOCK_UNLOCKED"
let not_zero_amount = "NOT_ZERO_AMOUNT"
let no_locked_tokens = "NO_LOCKED_TOKENS"
let not_enough_balance = "NOT_ENOUGH_BALANCE"
let receiver_not_found = "RECEIVER_NOT_FOUND"
let fa2_total_supply_not_found = "FA2_TOTAL_SUPPLY_NOT_FOUND"
let outcome_not_found = "OUTCOME_NOT_FOUND"
let already_executed = "ALREADY_EXECUTED"
let not_executable = "NOT_EXECUTABLE"
let hash_not_found = "HASH_NOT_FOUND"
let hash_not_match = "HASH_NOT_MATCH"
let unpack_mismatch = "UNPACK_MISMATCH"
let nothing_to_cancel = "NOTHING_TO_CANCEL"


#import "./config.mligo" "Config"
#import "./errors.mligo" "Errors"

type parameter_change = (unit -> Config.t)
type operation_list = (unit -> operation list)

type t =
    ParameterChange of parameter_change
    | OperationList of operation_list

let unpack (hash_opt, packed : bytes option * bytes) =
    match hash_opt with
        None -> (failwith Errors.hash_not_found : t)
      | Some hash_ -> let _check_hash =
        assert_with_error
          (hash_ = Crypto.sha256 packed)
          Errors.hash_not_match
      in (match (Bytes.unpack packed : t option) with
        None -> failwith(Errors.unpack_mismatch)
        | Some lambda_ -> lambda_)


#import "./constants.mligo" "Constants"
#import "./errors.mligo" "Errors"
#import "./lambda.mligo" "Lambda"
#import "./outcome.mligo" "Outcome"
#import "./proposal.mligo" "Proposal"
#import "./storage.mligo" "Storage"
#import "./vote.mligo" "Vote"
#import "./token.mligo" "Token"
#import "./vault.mligo" "Vault"
#import "./timelock.mligo" "Timelock"

type parameter =
    [@layout:comb]
    | Propose of Proposal.make_params
    | Cancel of nat option
    | Lock of Vault.amount_
    | Release of Vault.amount_
    | Execute of Outcome.execute_params
    | Vote of Vote.choice
    | End_vote

type storage = Storage.t
type result = operation list * storage

let execute (outcome_key, packed, s: nat * bytes * storage) : result =
    let proposal = (match Big_map.find_opt outcome_key s.outcomes with
        None -> failwith Errors.outcome_not_found
        | Some(o) -> Outcome.get_executable_proposal(o)) in

    let () = Timelock._check_unlocked(proposal.timelock) in
    let lambda_ = Lambda.unpack(proposal.hash, packed) in

    match lambda_ with
        OperationList f ->
            f(),
            Storage.update_outcome(outcome_key, (proposal, Executed), s)
        | ParameterChange f ->
            Constants.no_operation,
            Storage.update_outcome(
                outcome_key,
                (proposal, Executed),
                Storage.update_config(f,s)
            )

let propose (p, s : Proposal.make_params * storage) : result =
    match s.proposal with
        Some(_) -> failwith Errors.proposal_already_exists
        | None -> [
            Token.transfer(
                s.governance_token,
                Tezos.get_sender(),
                Tezos.get_self_address(),
                s.config.deposit_amount
        )], Storage.create_proposal(
                Proposal.make(p, s.config.start_delay, s.config.voting_period),
                s)

let cancel (outcome_key_opt, s : nat option * storage) : result =
   [Token.transfer(
        s.governance_token,
        Tezos.get_self_address(),
        s.config.burn_address,
        s.config.deposit_amount)
   ], (match outcome_key_opt with
        None -> (match s.proposal with
            None -> failwith Errors.nothing_to_cancel
            | Some(p) -> let () = Proposal._check_not_voting_period(p) in
                let _check_sender_is_creator = assert_with_error
                    (p.creator = Tezos.get_sender())
                    Errors.not_creator in
                Storage.add_outcome((p, Canceled), s))
        | Some(outcome_key) -> (match Big_map.find_opt outcome_key s.outcomes with
            None -> failwith Errors.outcome_not_found
            | Some(o) -> let (p, state) = o in
            let _check_sender_is_creator = assert_with_error
                (p.creator = Tezos.get_sender())
                Errors.not_creator in
            let _check_not_executed = assert_with_error
                (state <> (Executed : Outcome.state))
                Errors.already_executed in
            let () = Timelock._check_locked(p.timelock) in
            Storage.update_outcome(outcome_key, (p, Canceled), s)))

let lock (amount_, s : nat * storage) : result =
    let () = Proposal._check_no_vote_ongoing(s.proposal) in
    let current_amount = Vault.get_for_user(s.vault, Tezos.get_sender()) in

    [Token.transfer(
        s.governance_token,
        Tezos.get_sender(),
        Tezos.get_self_address(), amount_)
    ], Storage.update_vault(Vault.update_for_user(
        s.vault,
        Tezos.get_sender(),
        current_amount + amount_), s)

let release (amount_, s : nat * storage) : result =
    let () = Proposal._check_no_vote_ongoing(s.proposal) in
    let current_amount = Vault.get_for_user_exn(s.vault, Tezos.get_sender()) in
    let _check_balance = assert_with_error
        (current_amount >= amount_)
        Errors.not_enough_balance in

    [Token.transfer(s.governance_token, Tezos.get_self_address(), Tezos.get_sender(), amount_)],
    Storage.update_vault(Vault.update_for_user(
        s.vault,
        Tezos.get_sender(),
        abs(current_amount - amount_)), s)

let vote (choice, s : bool * storage) : storage =
    match s.proposal with
        None -> failwith Errors.no_proposal
        | Some(p) -> let () = Proposal._check_is_voting_period(p) in
            let amount_ = Vault.get_for_user_exn(s.vault, Tezos.get_sender()) in
            Storage.update_votes(p, (choice, amount_), s)

let end_vote (s : storage) : result =
    match s.proposal with
        None -> failwith Errors.no_proposal
        | Some(p) -> let () = Proposal._check_voting_period_ended(p) in
            let total_supply = (match Token.get_total_supply(s.governance_token) with
                None -> failwith Errors.fa2_total_supply_not_found
                | Some n -> n) in
            let outcome = Outcome.make(
                    p,
                    total_supply,
                    s.config.refund_threshold,
                    s.config.quorum_threshold,
                    s.config.super_majority
                ) in
            let (_, state) = outcome in
            let transfer_to_addr = match state with
                Rejected_(WithoutRefund) -> s.config.burn_address
                | _ -> p.creator
            in
            ([Token.transfer(
                s.governance_token,
                Tezos.get_self_address(),
                transfer_to_addr,
                s.config.deposit_amount)]
            ), Storage.add_outcome(outcome, s)

let main (action : parameter) (store : storage) : result =
    let _check_amount_is_zero = assert_with_error
        (Tezos.get_amount() = 0tez)
        Errors.not_zero_amount
    in match action with
        Propose p -> propose(p, store)
        | Cancel n_opt -> cancel(n_opt, store)
        | Lock n -> lock(n, store)
        | Release n -> release(n, store)
        | Execute p -> execute(p.outcome_key, p.packed, store)
        | Vote v -> Constants.no_operation, vote(v, store)
        | End_vote -> end_vote(store)


(* tzip-16 https://tzip.tezosagora.org/proposal/tzip-16/ *)
type t = (string, bytes) big_map


#import "./proposal.mligo" "Proposal"
#import "./vote.mligo" "Vote"
#import "./errors.mligo" "Errors"
// #import "./outcome.mligo" "Outcome"

type rejected_state_extra = WithRefund | WithoutRefund
type state = Accepted | Rejected_ of rejected_state_extra | Executed | Canceled

type t = (Proposal.t * state)

type execute_params =
    [@layout:comb]
    {
        outcome_key: nat;
        packed: bytes;
        // ^ the packed Lambda.t
    }

let make (
    p,
    total_supply,
    refund_threshold,
    quorum_threshold,
    super_majority
    : Proposal.t * nat * nat * nat * nat
) : t =
    let (total, for_, against) = Vote.count(p.votes) in
    let state = (if ((total / total_supply * 100n) < refund_threshold)
        then Rejected_(WithoutRefund)
        else if ((for_ / total * 100n) < super_majority)
            || ((total / total_supply * 100n) < quorum_threshold)
        then Rejected_(WithRefund)
        else if for_ > against then (Accepted : state) else Rejected_(WithRefund)) in
    (p, state)

let get_executable_proposal(outcome : t) : Proposal.t =
    match outcome with
        (proposal, Accepted) -> proposal
        | (_,_) -> (failwith Errors.not_executable : Proposal.t)


#import "./errors.mligo" "Errors"
#import "./vote.mligo" "Vote"
#import "./timelock.mligo" "Timelock"

type t =
    [@layout:comb]
    {
        description_link: string;
        hash: bytes option;
        start_at: timestamp;
        end_at: timestamp;
        votes: Vote.votes;
        creator: address;
        timelock: Timelock.t option;
    }

type make_params =
    [@layout:comb]
    {
        description_link: string;
        hash: bytes option;
    }

let make (p, start_delay, voting_period : make_params * nat * nat) : t =
    let start_at = Tezos.get_now() + int(start_delay) in
    {
        description_link = p.description_link;
        hash = p.hash;
        start_at = start_at;
        end_at = start_at + int(voting_period);
        votes = (Map.empty: Vote.votes);
        creator = Tezos.get_sender();
        timelock = (None : Timelock.t option);
    }

let is_voting_period (p : t) =
    ((Tezos.get_now() >= p.start_at) && (Tezos.get_now() < p.end_at))

let _check_not_voting_period (p : t) =
    assert_with_error
        (not is_voting_period(p))
        Errors.voting_period

let _check_is_voting_period (p : t) =
    assert_with_error
        (is_voting_period(p))
        Errors.not_voting_period

let _check_no_vote_ongoing (p_opt : t option) =
    match p_opt with
        Some(p) -> _check_not_voting_period(p)
        | None -> ()

let _check_voting_period_ended (p : t) =
    assert_with_error
        (Tezos.get_now() > p.end_at)
        Errors.voting_period


#import "./config.mligo" "Config"
#import "./lambda.mligo" "Lambda"
#import "./metadata.mligo" "Metadata"
#import "./outcome.mligo" "Outcome"
#import "./proposal.mligo" "Proposal"
#import "./timelock.mligo" "Timelock"
#import "./token.mligo" "Token"
#import "./vault.mligo" "Vault"
#import "./vote.mligo" "Vote"

type outcomes = (nat, Outcome.t) big_map

type t =
    [@layout:comb]
    {
        metadata: Metadata.t;
        governance_token: Token.t;
        config: Config.t;
        vault: Vault.t;
        proposal: Proposal.t option;
        outcomes: outcomes;
        next_outcome_id: nat;
    }

let create_proposal (p, s : Proposal.t * t) : t =
    { s with proposal = Some(p) }

let update_config (f, s : Lambda.parameter_change * t) : t =
    { s with config = f() }

let update_vault (v, s : Vault.t * t) : t =
    { s with vault = v }

let update_votes (p, v, s : Proposal.t * Vote.t * t) : t =
    let new_votes = Map.update (Tezos.get_sender()) (Some(v)) p.votes in
    let new_proposal = { p with votes = new_votes } in
    { s with proposal = Some(new_proposal) }

let update_outcome (k, o, s : nat * Outcome.t * t) : t =
    { s with outcomes = Big_map.update k (Some(o)) s.outcomes }

let add_outcome (o, s : Outcome.t * t) : t =
    let (proposal, status) = o in
    let proposal = (match status with
        (* If proposal is accepted, also create timelock *)
        Accepted -> let unlock_at = Tezos.get_now() + int(s.config.timelock_delay) in
            { proposal with timelock = Some(Timelock.make(
                unlock_at,
                s.config.timelock_period)
            )}
        | _ -> proposal)
    in
    { s with
        proposal = (None : Proposal.t option);
        outcomes = Big_map.update s.next_outcome_id (Some(proposal, status)) s.outcomes;
        next_outcome_id = s.next_outcome_id + 1n
    }


#import "./errors.mligo" "Errors"

type t =
    [@layout:comb]
    {
        unlock_at: timestamp;
        (* ^ timestamp for the unlock to happen *)

        relock_at: timestamp;
        (* ^ timestamp for the relock to happen *)
    }

let make (unlock_at, timelock_period : timestamp * nat) : t =
    {
       unlock_at = unlock_at;
       relock_at = unlock_at + int(timelock_period);
    }

let is_locked (t : t) = ((Tezos.get_now() < t.unlock_at) || (Tezos.get_now() >= t.relock_at))

let _check_unlocked (t_opt : t option) =
    match t_opt with
        None -> failwith Errors.timelock_not_found
        | Some(t) -> assert_with_error
            (not is_locked(t))
            Errors.timelock_locked

let _check_locked (t_opt : t option) =
    match t_opt with
        None -> failwith Errors.timelock_not_found
        | Some(t) -> assert_with_error
            (is_locked(t))
            Errors.timelock_unlocked


#import "@ligo/fa/lib/fa2/asset/single_asset.mligo" "FA2"
#import "./errors.mligo" "Errors"

type t = address

let get_transfer_entrypoint (addr : address) : FA2.transfer contract =
    match (Tezos.get_entrypoint_opt "%transfer" addr : FA2.transfer contract option) with
        None -> failwith Errors.receiver_not_found
        | Some c -> c

let transfer (token_addr, from_, to_, amount_: t * address * address * nat) : operation =
    let dest = get_transfer_entrypoint (token_addr) in
    let transfer_requests = ([
      ({from_=from_; txs=([{to_;amount=amount_;token_id=0n}] : FA2.atomic_trans list)});
    ] : FA2.transfer) in
    Tezos.transaction transfer_requests 0mutez dest

let get_total_supply (token_addr : t) : nat option = Tezos.call_view "total_supply" unit token_addr


#import "./errors.mligo" "Errors"

type owner = address
type amount_ = nat
type t = (owner, amount_) big_map

let get_for_user (vault, owner: t * owner) : amount_ =
    match Big_map.find_opt owner vault with
        Some (tokens) -> tokens
        | None -> 0n

let get_for_user_exn (vault, owner: t * owner) : amount_ =
    let amount_ = get_for_user(vault, owner) in
    if (amount_ = 0n)
        then failwith Errors.no_locked_tokens
        else amount_

let update_for_user (vault, owner, amount_ : t * owner * nat) : t =
    Big_map.update owner (Some amount_) vault


type choice = bool
type t = (choice * nat)
type votes = (address, t) map

(**
    [count (votes)] is the count of [votes].
    Returns a triple of:
        - total votes (for + against),
        - sum of votes for,
        - sum of votes against.
*)
let count (votes : votes) : (nat * nat * nat) =
  let sum =
    fun ((for_, against), (_, (choice, nb)) : (nat * nat) * (address * (t))) ->
      if choice
      then (for_ + nb, against)
      else (for_, against + nb) in
  let (for_, against) = Map.fold sum votes (0n, 0n) in
  (for_ + against, for_, against)


#import "@ligo/fa/test/helpers/list.mligo" "List_helper"
#import "../helpers/token.mligo" "Token_helper"
#import "../helpers/dao.mligo" "DAO_helper"
#import "../../src/main.mligo" "DAO"

(*
    Boostrapping of the test environment,
    init_tok_amount is the amount of token allocated to every
    bootstrapped accounts
*)
let boot (init_tok_amount, init_dao_storage : nat * DAO.storage) =
    (* Originate the token contract and the contract under test *)
    let tok = Token_helper.originate(init_tok_amount) in
    (* Override governance token with test token *)
    let init_dao_storage = { init_dao_storage with governance_token = tok.addr } in
    let dao = DAO_helper.originate(init_dao_storage) in

    (* Add the dao as operator for all the FA2 owner addresses
        TODO: ... in the real world, remove operator? *)
    let () = List.iter (fun (owner: address) ->
        let () = Test.set_source owner in
        Token_helper.add_operators(
            [{ owner = owner; operator = dao.addr; token_id = 0n } ],
            tok.contr
        )) tok.owners in

    (* Set a token owner as sender in the Test framework *)
    let sender_ = List_helper.nth_exn 1 tok.owners in
    let () = Test.set_source sender_ in

    (* Set the baker to 5th account *)
    let baker = Test.nth_bootstrap_account 5 in
    let () = Test.set_baker baker in

    (tok, dao, sender_)


#include "@ligo/fa/lib/fa2/asset/single_asset.mligo"

(* Extension of FA2 to be used as governance token of the DAO *)

[@view] let total_supply (_, _s : unit * storage) : nat =
    30n


#import "@ligo/fa/test/helpers/list.mligo" "List_helper"
#import "./helpers/dao.mligo" "DAO_helper"
#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/suite.mligo" "Suite_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "DAO"

let () = Log.describe("[Cancel] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 33n
let bootstrap (init_dao_storage : DAO.storage) =
    Bootstrap.boot(init_tok_amount, init_dao_storage)
let empty_nat_option = (None: nat option)
let base_config = DAO_helper.base_config
let base_storage = DAO_helper.base_storage


(* Successful cancel of current proposal *)
let test_success_current_proposal =
    let config = { base_config with start_delay = 86400n } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, sender_) = bootstrap(dao_storage) in

    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in
    let () = DAO_helper.cancel_success(empty_nat_option, dao.contr) in
    let dao_storage = Test.get_storage dao.taddr in
    let () = DAO_helper.assert_proposal_state(dao_storage.outcomes, 1n, Canceled) in
    Token_helper.assert_balance_amount(
        tok.taddr,
        sender_,
        abs(init_tok_amount - dao_storage.config.deposit_amount)
    )

(* Succesful cancel of accepted proposal, before timelock is unlocked *)
let test_success_accepted_proposal =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 360n;
        timelock_delay = 3000n } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let hash_ = Some(DAO_helper.dummy_hash) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in
    let () = DAO_helper.cancel_success(Some(1n), dao.contr) in
    let dao_storage = Test.get_storage dao.taddr in
    DAO_helper.assert_proposal_state(dao_storage.outcomes, 1n, Canceled)

(* Failing cancel because there is nothing to cancel *)
let test_failure_nothing_to_cancel =
    let (_, dao, _) = bootstrap(base_storage) in

    let r = DAO_helper.cancel(empty_nat_option, dao.contr) in
    Assert.string_failure r DAO.Errors.nothing_to_cancel

(* Failing cancel because the outcome was not found *)
let test_failure_outcome_not_found =
    let (_, dao, _) = bootstrap(base_storage) in

    let r = DAO_helper.cancel(Some(23n), dao.contr) in
    Assert.string_failure r DAO.Errors.outcome_not_found

(* Failing cancel proposal because not creator *)
let test_failure_not_creator =
    let config = { base_config with start_delay = 1200n } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in
    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in

    let sender_ = List_helper.nth_exn 2 tok.owners in
    let () = Test.set_source sender_ in
    let r = DAO_helper.cancel(empty_nat_option, dao.contr) in
    Assert.string_failure r DAO.Errors.not_creator

(* Failing cancel proposal because timelock is unlocked *)
let test_failure_timelock_unlocked =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 360n; } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let hash_ = Some(DAO_helper.dummy_hash) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in

    let r = DAO_helper.cancel(Some(1n), dao.contr) in
    Assert.string_failure r DAO.Errors.timelock_unlocked

(* Failing cancel proposal because it was already executed *)
let test_failure_already_executed =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 360n; } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let hash_ = Some(DAO_helper.dummy_hash) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in
    let () = DAO_helper.execute_success(1n, DAO_helper.dummy_packed, dao.contr) in

    let r = DAO_helper.cancel(Some(1n), dao.contr) in
    Assert.string_failure r DAO.Errors.already_executed


#import "@ligo/fa/test/helpers/list.mligo" "List_helper"
#import "./helpers/dao.mligo" "DAO_helper"
#import "./helpers/suite.mligo" "Suite_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "DAO"

let () = Log.describe("[End_vote] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 33n
let bootstrap () =
    let base_config = DAO_helper.base_config in
    let base_storage = DAO_helper.base_storage in
    let config = { base_config with
        start_delay = 10n;
        voting_period = 360n;
    } in
    let dao_storage = { base_storage with config = config } in
    Bootstrap.boot(init_tok_amount, dao_storage)

(* Successful end_vote with proposal accepted *)
let test_success_prop_accepted =
    let (tok, dao, _) = bootstrap() in

    let hash_ = Some(DAO_helper.dummy_hash) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in
    let dao_storage = Test.get_storage dao.taddr in
    let () = assert (dao_storage.proposal = (None: DAO.Proposal.t option)) in
    DAO_helper.assert_proposal_state(dao_storage.outcomes, 1n, Accepted)

(* Successful end_vote with proposal rejected because quorum was not reached *)
let test_success_prop_rejected_quorum_not_reached =
    let (tok, dao, _) = bootstrap() in

    let hash_ = Some(DAO_helper.dummy_hash) in
    let votes = [(0, 5n, true); (1, 5n, true); (2, 5n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in

    let dao_storage = Test.get_storage dao.taddr in
    DAO_helper.assert_proposal_state(dao_storage.outcomes, 1n, Rejected_(WithoutRefund))

(* Successful end_vote with proposal rejected because super_majority was not reached *)
let test_success_prop_rejected_super_maj_not_reached =
    let (tok, dao, _) = bootstrap() in

    let hash_ = Some(DAO_helper.dummy_hash) in
    let votes = [(0, 15n, true); (1, 15n, true); (2, 15n, false)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in
    let dao_storage = Test.get_storage dao.taddr in
    DAO_helper.assert_proposal_state(dao_storage.outcomes, 1n, Rejected_(WithRefund))

(* Failing end_vote because proposal voting period ongoing *)
let test_failure_voting_period =
    let (_, dao, _) = bootstrap() in

    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in

    let r = DAO_helper.end_vote(dao.contr) in
    Assert.string_failure r DAO.Errors.voting_period

(* TODO: test for total_supply_not_found error *)


#import "@ligo/fa/test/helpers/list.mligo" "List_helper"
#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/dao.mligo" "DAO_helper"
#import "./helpers/suite.mligo" "Suite_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "DAO"

let () = Log.describe("[Execute] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 33n
let bootstrap (init_dao_storage : DAO.storage) =
    Bootstrap.boot(init_tok_amount, init_dao_storage)
let base_config = DAO_helper.base_config
let base_storage = DAO_helper.base_storage

(* Successful timelock execution of an operation list *)
let test_success =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 360n; } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(
        tok,
        dao,
        Some(DAO_helper.dummy_hash),
        votes
    ) in

    let () = DAO_helper.execute_success(1n, DAO_helper.dummy_packed, dao.contr) in
    DAO_helper.assert_executed(dao.taddr, 1n)

(* Successful execution of a parameter change *)
let test_success_parameter_changed =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 360n; } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let base_config = DAO_helper.base_config in
    let packed = Bytes.pack (ParameterChange(
        fun() -> { base_config with quorum_threshold = 51n }
    ) : DAO.Lambda.t) in
    let hash_ = Some(Crypto.sha256 packed) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in

    let () = DAO_helper.execute_success(1n, packed, dao.contr) in
    let () = DAO_helper.assert_executed(dao.taddr, 1n) in
    let dao_storage = Test.get_storage dao.taddr in

    (* Assert that the config has been updated *)
    assert(dao_storage.config.quorum_threshold = 51n)

(* Successful execution of an operation list *)
let test_success_operation_list =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 360n; } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in
    let owner2 = List_helper.nth_exn 2 tok.owners in
    let owner2_initial_balance = Token_helper.get_balance_for(tok.taddr, owner2) in

    (* Pack an operation that will send 2 tokens from DAO to owner2 *)
    let owner2_amount_to_receive = 2n in
    let op_list = Token_helper.create_transfer_callable (
            tok.addr, dao.addr, owner2, owner2_amount_to_receive
    ) in
    let packed = Bytes.pack(OperationList(op_list) : DAO.Lambda.t) in

    let owner2_amount_locked = 25n in
    let hash_ = Some(Crypto.sha256 packed) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, owner2_amount_locked, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in

    let () = DAO_helper.execute_success(1n, packed, dao.contr) in
    let () = DAO_helper.assert_executed(dao.taddr, 1n) in

    let owner2_expected_balance : nat = abs(
        owner2_initial_balance
        - owner2_amount_locked
        + owner2_amount_to_receive)
    in
    Token_helper.assert_balance_amount(tok.taddr, owner2, owner2_expected_balance)

(* Failing because no outcome *)
let test_failure_no_outcome =
    let (_, dao, _) = bootstrap(base_storage) in

    let r = DAO_helper.execute(1n, DAO_helper.dummy_packed, dao.contr) in
    Assert.string_failure r DAO.Errors.outcome_not_found

(* Failing because timelock delay not elapsed *)
let test_failure_timelock_delay_not_elapsed =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 360n;
        timelock_delay = 1800n } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let hash_ = Some(DAO_helper.dummy_hash) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in

    let r = DAO_helper.execute(1n, DAO_helper.dummy_packed, dao.contr) in
    Assert.string_failure r DAO.Errors.timelock_locked

(* Failing because timelock has been relocked *)
let test_failure_timelock_relocked =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 360n;
        timelock_period = 5n } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let hash_ = Some(DAO_helper.dummy_hash) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in

    let r = DAO_helper.execute(1n, DAO_helper.dummy_packed, dao.contr) in
    Assert.string_failure r DAO.Errors.timelock_locked

(* Failing because the packed data is not matching expected type *)
let test_failure_unpack_mismatch =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 360n } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let packed = Bytes.pack("") in
    let hash_ = Some(Crypto.sha256(packed)) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in

    let r = DAO_helper.execute(1n, packed, dao.contr) in
    Assert.string_failure r DAO.Errors.unpack_mismatch

(* Failing because the hash doesn't match the packed bytes *)
let test_failure_hash_not_match =
    let config = { base_config with
        start_delay = 10n;
        voting_period = 360n } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, _) = bootstrap(dao_storage) in

    let hash_ = Some(0x01) in
    let votes = [(0, 25n, true); (1, 25n, true); (2, 25n, true)] in
    let () = Suite_helper.create_and_vote_proposal(tok, dao, hash_, votes) in

    let r = DAO_helper.execute(1n, DAO_helper.dummy_packed, dao.contr) in
    Assert.string_failure r DAO.Errors.hash_not_match


(* Assert contract call results in failwith with given string *)
let string_failure (res : test_exec_result) (expected : string) : unit =
    let expected = Test.eval expected in
    match res with
        | Fail (Rejected (actual,_)) -> assert (actual = expected)
        | Fail (Balance_too_low _) -> Test.failwith "contract failed: balance too low"
        | Fail (Other s) -> Test.failwith s
        | Success _ -> Test.failwith "Transaction should fail"

(* Assert contract result is successful *)
let tx_success (res: test_exec_result) : unit =
    match res with
        | Success(_) -> ()
        | Fail (Rejected (error,_)) -> let () = Test.log(error) in Test.failwith "Transaction should not fail"
        | Fail _ -> Test.failwith "Transaction should not fail"


#import "../../src/main.mligo" "DAO"
#import "./assert.mligo" "Assert"

(* Some types for readability *)
type taddr = (DAO.parameter, DAO.storage) typed_address
type contr = DAO.parameter contract
type originated = {
    addr: address;
    taddr: taddr;
    contr: contr;
}

(* Some dummy values intended to be used as placeholders *)
let dummy_packed = Bytes.pack (OperationList(fun () -> ([] : operation list)) : DAO.Lambda.t)
let dummy_hash = Crypto.sha256 dummy_packed

let dummy_proposal : DAO.Proposal.make_params = {
    description_link = "ipfs://QmbKq7QriWWU74NSq35sDSgUf24bYWTgpBq3Lea7A3d7jU";
    hash = Some(dummy_hash)
}
let dummy_governance_token = ("KT1VqarPDicMFn1ejmQqqshUkUXTCTXwmkCN": address)

(* Some default values *)
let default_votes = (Map.empty : DAO.Vote.votes)
let default_timelock = (None : DAO.Timelock.t option)

let base_config : DAO.Storage.Config.t = {
    deposit_amount = 4n;
    refund_threshold = 32n;
    quorum_threshold = 67n;
    super_majority = 80n;
    start_delay = 360n;
    voting_period = 1440n;
    timelock_delay = 180n;
    timelock_period = 720n;
    burn_address = ("tz1burnburnburnburnburnburnburjAYjjX": address);
}

let base_storage : DAO.storage = {
    metadata = Big_map.literal [
        ("", Bytes.pack("tezos-storage:contents"));
        ("contents", ("": bytes))
    ];
    governance_token = dummy_governance_token;
    vault = (Big_map.empty : DAO.Storage.Vault.t);
    proposal = (None : DAO.Proposal.t option);
    config = base_config;
    next_outcome_id = 1n;
    outcomes = (Big_map.empty : DAO.Storage.outcomes);
}

(* Originate a DAO contract with given init_storage storage *)
let originate (init_storage: DAO.storage) =
    let (taddr, _, _) = Test.originate DAO.main init_storage 0tez in
    let contr = Test.to_contract taddr in
    let addr = Tezos.address contr in
    { addr = addr; taddr = taddr; contr = contr }

(* Call entry point of DAO contr contract *)
let call (p, contr : DAO.parameter * contr) =
    Test.transfer_to_contract contr p 0mutez

(* Entry points call helpers *)
let cancel (outcome_key_opt, contr : nat option * contr) = call(Cancel(outcome_key_opt), contr)

let end_vote (contr : contr) = call(End_vote, contr)

let execute (k, packed, contr : nat * bytes * contr) =
    call(Execute({ outcome_key = k; packed = packed; }), contr)

let lock (amount_, contr: nat * contr) = call(Lock(amount_), contr)

let propose (proposal, contr : DAO.Proposal.make_params * contr) =
    call(Propose(proposal), contr)

let release (amount_, contr: nat * contr) = call(Release(amount_), contr)

let vote (choice, contr: bool * contr) = call(Vote(choice), contr)

(* Asserter helper for successful entry point calls *)
let cancel_success (outcome_key_opt, contr : nat option * contr) =
    Assert.tx_success (cancel(outcome_key_opt, contr))

let end_vote_success (contr : contr) =
    Assert.tx_success (end_vote(contr))

let execute_success (k, packed, contr : nat * bytes * contr) =
    Assert.tx_success (execute(k, packed, contr))

let lock_success (amount_, contr: nat * contr) =
    Assert.tx_success (lock(amount_, contr))

let propose_success (proposal, contr : DAO.Proposal.make_params * contr) =
    Assert.tx_success (propose(proposal, contr))

let release_success (amount_, contr: nat * contr) =
    Assert.tx_success (release(amount_, contr))

let vote_success (choice, contr: DAO.Vote.choice * contr) =
    Assert.tx_success (vote(choice, contr))


(* Batch call of lock entry point, WARNING: changes Test framework source *)
let batch_lock (addr_lst, amount_, contr : address list * nat * contr) =
    let lock = fun (addr : address) ->
        let () = Test.set_source addr in lock_success(amount_, contr)
    in List.iter lock addr_lst

(* Batch call of vote entry point, WARNING: changes Test framework source *)
let batch_vote (addr_lst, choice, contr : address list * DAO.Vote.choice * contr) =
    let vote = fun (addr : address) ->
        let () = Test.set_source addr in vote_success(choice, contr)
    in List.iter vote addr_lst

(* Assert DAO contract at [taddr] has [owner] [amount_] of tokens locked *)
let assert_locked (taddr, owner, amount_ : taddr * DAO.Storage.Vault.owner *  nat) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt owner s.vault with
        Some tokens -> assert(tokens = amount_)
        | None -> Test.failwith("Big_map key should not be missing")

(* Assert DAO contract at [taddr] have registered [voter] [choice] with [amount_] votes *)
let assert_voted (taddr, voter, choice, amount_ : taddr * address * bool * nat) =
    let s = Test.get_storage taddr in
    let p = Option.unopt(s.proposal) in
    match Map.find_opt voter p.votes with
        Some vote -> assert(vote.0 = choice && vote.1 = amount_)
        | None -> Test.failwith("Map key should not be missing")

(* Assert DAO contract at [taddr] have an outcome occuring for [n] key in Executed state *)
let assert_executed (taddr, n : taddr * nat) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt n s.outcomes with
        None -> Test.failwith "The outcome should exists"
        | Some(_, state) -> assert(state = (Executed : DAO.Outcome.state))

(* Assert outcomes [bm] big map have an entry for key [k] and has given [s] state *)
let assert_proposal_state (bm, k, s : DAO.Storage.outcomes * nat * DAO.Outcome.state) =
    match Big_map.find_opt k bm with
        Some(outcome) -> let (proposal, state) = outcome in
            (* just checking timelock existence *)
            let _check_timelock = proposal.timelock in
            (* check that the proposal have been accepted *)
            assert(state = s)
        | None -> Test.failwith("outcome not found")



(* Return str repeated n times *)
let repeat (str, n : string * nat) : string =
    let rec loop (n, acc: nat * string) : string = 
        if n = 0n then acc else loop (abs(n - 1n), acc ^ str)
    in loop(n, "")

(* 
    Log boxed lbl

    "+-----------+"
    "| My string |"
    "+-----------+"
*)
let describe (lbl : string) =
    let hr = "+" ^ repeat("-", String.length(lbl) + 2n) ^ "+" in 
    let () = Test.log hr in
    let () = Test.log ("| " ^ lbl ^ " |") in
    Test.log hr


#import "./token.mligo" "Token_helper"
#import "./dao.mligo" "DAO_helper"
#import "@ligo/fa/test/helpers/list.mligo" "List_helper"

(*
    Creates a proposal on [dao] with [tok] as governance_token,
    using given [hash_] for the proposal lambda.
    The proposal creator is the first token owner registered in
    the given [tok] token contract owners list.
    Every token owner locks [amount_] of tokens in the DAO,
    and votes "yes" to the created proposal,
    eventually, the end_vote entry point is called.
    Can lead to either accepted or rejected proposal, according to
    the given [amount_] of tokens.
    Requires appropriate config of various periods and delays
*)
let create_and_vote_proposal (
    tok, dao, hash_, votes : Token_helper.originated *
    DAO_helper.originated * bytes option * (int * nat * bool)
    list
) =
    (* set up the sender for propose and end_vote entry points *)
    let sender_ = List_helper.nth_exn 1 tok.owners in

    (* impersonate token owners and call lock entry point *)
    let do_lock (nth_account, amount_, _ : int * nat * bool) =
        let () = Test.set_source (List_helper.nth_exn nth_account tok.owners) in
        DAO_helper.lock_success(amount_, dao.contr)
    in
    let () = List.iter do_lock votes in

    (* create proposal *)
    let () = Test.set_source sender_ in
    let proposal = DAO_helper.dummy_proposal in
    let proposal = { proposal with hash = hash_ } in
    let () = DAO_helper.propose_success(proposal, dao.contr) in

    (* impersonate token owners and call vote entry point *)
    let do_vote (nth_account, _, choice : int * nat * bool) =
        let () = Test.set_source (List_helper.nth_exn nth_account tok.owners) in
        DAO_helper.vote_success(choice, dao.contr)
    in
    let () = List.iter do_vote votes in

    let () = Test.set_source sender_ in
    DAO_helper.end_vote_success(dao.contr)


#import "@ligo/fa/lib/fa2/asset/single_asset.mligo" "SingleAsset"
#import "@ligo/fa/test/fa2/single_asset.test.mligo" "SingleAsset_helper"
#import "./assert.mligo" "Assert"

(* Some types for readability *)
type taddr = (SingleAsset.parameter, SingleAsset.storage) typed_address
type contr = SingleAsset.parameter contract
type originated = {
    addr: address;
    taddr: taddr;
    owners: address list;
    ops: address list;
    contr: contr;
}

let originate (tok_amount : nat) =
    let f = "../bootstrap/single_asset.mligo" in
    let init_storage, owners, ops = SingleAsset_helper.get_initial_storage(
        tok_amount, tok_amount, tok_amount
    ) in
    let v_mich = Test.run (fun (x:SingleAsset.Storage.t) -> x) init_storage in
    let (addr, _, _) = Test.originate_from_file f "main" (["total_supply"]: string list) v_mich 0tez in
    let taddr : taddr = Test.cast_address addr in
    let contr = Test.to_contract taddr in
    {
        addr = addr;
        taddr = taddr;
        owners = owners;
        ops = ops;
        contr = contr;
    }

type single_asset_transfer_param = {
    contr: contr;
    source: address;
    from: address;
    to: address;
    amount: nat;
}

(* Transfer token in [contr] between [from_] and [to_] addresses with [amount_] tokens,
 WARNING: changes Test framework source  *)
let transfer (contr, from_, to_, amount_ : contr * address * address * nat) =
    let () = Test.set_source from_ in
    let transfer_requests = ([
      ({from_=from_; txs=([{to_;amount=amount_;token_id=0n}] : SingleAsset.atomic_trans list)});
    ] : SingleAsset.transfer) in
    Test.transfer_to_contract_exn contr (Transfer transfer_requests) 0tez

(* Batch add [operators] to [contr] contract *)
let add_operators (operators, contr : SingleAsset.operator list * SingleAsset.parameter contract) =
    let f (ys,x : (SingleAsset.unit_update list * SingleAsset.operator)) : SingleAsset.unit_update list = (Add_operator(x) : SingleAsset.unit_update) :: ys in
    let add_operator = List.fold_left f ([] : SingleAsset.unit_update list) operators in
    let r = Test.transfer_to_contract contr (Update_operators(add_operator)) 0mutez in
    Assert.tx_success r

(* assert for FA2 insuffiscient balance string failure *)
let assert_ins_balance_failure (r : test_exec_result) =
    Assert.string_failure r SingleAsset.Errors.ins_balance

(* assert FA2 contract at [taddr] have [owner] address with [amount_] tokens in its ledger *)
let assert_balance_amount (taddr, owner, amount_ : taddr * SingleAsset.Ledger.owner * nat) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt owner s.ledger with
        Some tokens -> assert(tokens = amount_)
        | None -> Test.failwith("Big_map key should not be missing")

(* get balance in [taddr] contract for [owner] address *)
let get_balance_for (taddr, owner : taddr * SingleAsset.Ledger.owner) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt owner s.ledger with
        Some amount_ -> amount_
        | None -> 0n

(**
    Create a lambda of type (operation list) that would call the "transfer"
    entrypoint of a FA2 contract residing at [addr], making a token transfer between
    [from_] and [to_] addresses with [amount_] tokens.
*)
let create_transfer_callable (addr, from_, to_, amount_ : address * address * address * nat) =
    fun() -> match (Tezos.get_entrypoint_opt "%transfer" addr : SingleAsset.transfer contract option) with
        Some(c) ->
            let transfer_requests = ([
              ({from_=from_; txs=([{to_;amount=amount_;token_id=0n}] : SingleAsset.atomic_trans list)});
            ] : SingleAsset.transfer) in
            let op = Tezos.transaction transfer_requests 0mutez c in [op]
        | None -> failwith("TOKEN_CONTRACT_NOT_FOUND")


#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/dao.mligo" "DAO_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "DAO"

let () = Log.describe("[Lock] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n
let bootstrap (init_dao_storage : DAO.storage) =
    Bootstrap.boot(init_tok_amount, init_dao_storage)
let base_config = DAO_helper.base_config
let base_storage = DAO_helper.base_storage


(* Succesful lock *)
let test_success =
    let (tok, dao, sender_) = bootstrap(base_storage) in

    let amount_ = 3n in
    let r = DAO_helper.lock(amount_, dao.contr) in
    let () = Assert.tx_success r in

    let () = DAO_helper.assert_locked(dao.taddr, sender_, amount_) in
    Token_helper.assert_balance_amount(
        tok.taddr,
        sender_,
        abs(init_tok_amount - amount_))

(* Succesful lock before voting starts *)
let test_success_before_voting_starts =
    (* Add suffiscient start_delay *)
    let config = { base_config with start_delay = 86400n } in
    let dao_storage = { base_storage with config = config } in
    let (tok, dao, sender_) = bootstrap(dao_storage) in
    let dao_storage = Test.get_storage dao.taddr in

    let amount_ = 3n in
    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in
    let () = DAO_helper.lock_success(amount_, dao.contr) in

    let () = DAO_helper.assert_locked(dao.taddr, sender_, amount_) in
    Token_helper.assert_balance_amount(
        tok.taddr,
        sender_,
        abs(init_tok_amount - amount_ - dao_storage.config.deposit_amount)
    )

(* Failing lock because sender has insuffiscient balance *)
let test_failure_ins_balance =
    let (_, dao, _) = bootstrap(base_storage) in
    let r = DAO_helper.lock(30n, dao.contr) in
    Token_helper.assert_ins_balance_failure(r)

(* Failing lock because voting is underway *)
let test_failure_voting_period =
    (* Really short start_delay *)
    let config = { base_config with start_delay = 10n } in
    let dao_storage = { base_storage with config = config } in
    let (_, dao, _) = bootstrap(dao_storage) in

    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in
    let r = DAO_helper.lock(3n, dao.contr) in

    Assert.string_failure r DAO.Errors.voting_period


#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/dao.mligo" "DAO_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "DAO"

let () = Log.describe("[Propose] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n
let bootstrap () = Bootstrap.boot(init_tok_amount, DAO_helper.base_storage)

(* Successful proposal creation *)
let test_success =
    let (tok, dao, sender_) = bootstrap() in

    let r = DAO_helper.propose(DAO_helper.dummy_proposal, dao.contr) in
    let () = Assert.tx_success r in

    let dao_storage = Test.get_storage dao.taddr in
    let proposal = Option.unopt(dao_storage.proposal) in
    let () = assert(proposal.creator = sender_) in
    let () = assert(proposal.description_link = "ipfs://QmbKq7QriWWU74NSq35sDSgUf24bYWTgpBq3Lea7A3d7jU") in
    let () = assert(proposal.hash = Some(DAO_helper.dummy_hash)) in

    let () = Token_helper.assert_balance_amount(tok.taddr, dao.addr, dao_storage.config.deposit_amount) in
    Token_helper.assert_balance_amount(
        tok.taddr,
        sender_,
        abs(init_tok_amount - dao_storage.config.deposit_amount)
    )

(* Failing proposal creation because there is already a proposal *)
let test_failure_proposal_exists =
    let (_, dao, _) = bootstrap() in

    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in
    let r = DAO_helper.propose(DAO_helper.dummy_proposal, dao.contr) in

    Assert.string_failure r DAO.Errors.proposal_already_exists

(* Failing because the proposing account doesn't have sufiscient balance for the deposit amount *)
let test_failure_insufiscient_balance =
    let (tok, dao, sender_) = bootstrap() in

    (* Burn all the sender tokens *)
    let burn_addr = ("tz1ZZZZZZZZZZZZZZZZZZZZZZZZZZZZNkiRg": address) in
    let _ = Token_helper.transfer(tok.contr, sender_, burn_addr, init_tok_amount) in
    let r = DAO_helper.propose(DAO_helper.dummy_proposal, dao.contr) in

    Token_helper.assert_ins_balance_failure(r)


#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/dao.mligo" "DAO_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "DAO"

let () = Log.describe("[Release] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n
let bootstrap (init_dao_storage : DAO.storage) =
    Bootstrap.boot(init_tok_amount, init_dao_storage)
let base_config = DAO_helper.base_config
let base_storage = DAO_helper.base_storage

(* Successful release *)
let test_success =
    let (tok, dao, sender_) = bootstrap(base_storage) in

    let () = DAO_helper.lock_success(3n, dao.contr) in
    let () = DAO_helper.release_success(3n, dao.contr) in

    let () = DAO_helper.assert_locked(dao.taddr, sender_, 0n) in
    Token_helper.assert_balance_amount(
        tok.taddr,
        sender_,
        init_tok_amount
    )

(* Failing release because no locked tokens *)
let test_failure_no_locked_tokens =
    let (_, dao, _) = bootstrap(base_storage) in
    let r = DAO_helper.release(3n, dao.contr) in
    Assert.string_failure r DAO.Errors.no_locked_tokens

(* Failing release because insuffiscient balance *)
let test_failure_ins_balance =
    let (_, dao, _) = bootstrap(base_storage) in
    let () = DAO_helper.lock_success(2n, dao.contr) in
    let r = DAO_helper.release(3n, dao.contr) in
    Assert.string_failure r DAO.Errors.not_enough_balance

(* Failing release because voting is underway *)
let test_failure_voting_period =
    (* Really short start_delay *)
    let config = { base_config with start_delay = 10n } in
    let dao_storage = { base_storage with config = config } in
    let (_, dao, _) = bootstrap(dao_storage) in

    let () = DAO_helper.lock_success(3n, dao.contr) in
    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in

    let r = DAO_helper.release(3n, dao.contr) in

    Assert.string_failure r DAO.Errors.voting_period


#import "./helpers/dao.mligo" "DAO_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "DAO"

let () = Log.describe("[Vote] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n
let bootstrap (init_dao_storage : DAO.storage) =
    Bootstrap.boot(init_tok_amount, init_dao_storage)
let base_config = DAO_helper.base_config
let base_storage = DAO_helper.base_storage

(* Successful vote *)
let test_success =
    let config = { base_config with start_delay = 10n } in
    let dao_storage = { base_storage with config = config } in
    let (_, dao, sender_) = bootstrap(dao_storage) in

    let amount_ = 3n in
    let () = DAO_helper.lock_success(amount_, dao.contr) in
    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in

    let choice = true in
    let () = DAO_helper.vote_success(choice, dao.contr) in
    DAO_helper.assert_voted(dao.taddr, sender_, choice, amount_)

(* Failing vote because no proposal *)
let test_failure_no_proposal =
    let (_, dao, _) = bootstrap(base_storage) in

    let r = DAO_helper.vote(true, dao.contr) in
    Assert.string_failure r DAO.Errors.no_proposal

(* Failing vote because proposal is not in voting period *)
let test_failure_not_voting_period =
    let (_, dao, _) = bootstrap(base_storage) in

    let amount_ = 3n in
    let () = DAO_helper.lock_success(amount_, dao.contr) in
    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in

    let r = DAO_helper.vote(true, dao.contr) in
    Assert.string_failure r DAO.Errors.not_voting_period

(* Failing because no locked tokens in vault *)
let test_failure_no_locked_tokens =
    (* Really short start_delay *)
    let config = { base_config with start_delay = 10n } in
    let dao_storage = { base_storage with config = config } in
    let (_, dao, _) = bootstrap(dao_storage) in

    let () = DAO_helper.propose_success(DAO_helper.dummy_proposal, dao.contr) in

    let r = DAO_helper.vote(true, dao.contr) in
    Assert.string_failure r DAO.Errors.no_locked_tokens


DAO-Cameligo

#import "../src/lambda.jsligo" "Lambda"

// Sample lambda code for an empty list of operations
// Notice that a type from the Lambda module is used
// See Makefile compile-lambda target for usage with ligo CLI

const lambda_ : Lambda.operationList = () => list([]) as list<operation>;


#import "../src/lambda.jsligo" "Lambda"
#import "@ligo/fa/lib/fa2/asset/single_asset.mligo" "SingleAsset"

// Sample lambda that calls an FA2 transfer entrypoint

const lambda_ : Lambda.operationList = () => {
    const addr = "KT1QAShr81NcaFZyJR4srfYGuvPyD8ibbMtT" as address;
    const transferOpt: option<contract<SingleAsset.transfer>> =
        Tezos.get_entrypoint_opt("%transfer", addr);

    match (transferOpt, {
        None: () => failwith ("TOKEN_CONTRACT_NOT_FOUND"),
        Some: (c: contract<SingleAsset.transfer>) => {
            const transfer_requests: SingleAsset.transfer =
                list([({
                    from_: "KT1BWSmjEhEknnBWSYrrSdhH217osBbwdVos" as address,
                    txs: list([{
                        to_: "tz1burnburnburnburnburnburnburjAYjjX" as address,
                        amount: 4000 as nat
                    }]) as list<SingleAsset.atomic_trans>
                })]);

            const op = Tezos.transaction (transfer_requests, 0 as tez, c);
            list([op]);
        }
    });
};


#import "../src/lambda.jsligo" "Lambda"

// A parameter change lambda is just a new record of type Config.t,
// the storage will be updated with the differences when the lambda is
// executed

const lambda_ : Lambda.parameterChange = () => ({
    depositAmount: 400 as nat,
    refundThreshold: 32 as nat,
    quorumThreshold: 67 as nat,
    superMajority: 80 as nat,
    startDelay: 86400 as nat,
    votingPeriod: 604800 as nat,
    timelockDelay: 86400 as nat,
    timelockPeriod: 259200 as nat,
    burnAddress: "tz1burnburnburnburnburnburnburjAYjjX" as address
});


// quorum_threshold, refund_threshold and super_majority
// are represented with scale = 2, ex. 80 = .80 = 80%
// x_delay and x_period are represented by time units in seconds
export type t =
    // @layout:comb
    {
        depositAmount: nat,
        // ^ The amount of tokens required to be deposited when creating a proposal

        refundThreshold: nat,
        // ^ The minimal amount of participating tokens required for the deposit to be refunded

        quorumThreshold: nat,
        // ^ The minimal participation percentage needed for a proposal to pass

        superMajority: nat,
        // ^ The percentage needed for a super majority ("yes" votes)

        startDelay: nat,
        // ^ The delay for the vote to start

        votingPeriod: nat,
        // ^ The period during which voting is live

        timelockDelay: nat,
        // ^ Delay before an approved proposal can be executed

        timelockPeriod: nat,
        // ^ The period during which a timelock can be executed

        burnAddress: address,
        // ^ The burn address for unrefunded deposits
    }


const noOperation : list<operation> = list([])


const proposalAlreadyExists = "PROPOSAL_ALREADY_EXISTS"
const votingPeriod = "VOTING_PERIOD"
const notVotingPeriod = "NOT_VOTING_PERIOD"
const noProposal = "NO_PROPOSAL"
const notCreator = "NOT_CREATOR"
const canceled = "CANCELED"
const timelockNotFound = "TIMELOCK_NOT_FOUND"
const timelockLocked = "TIMELOCK_LOCKED"
const timelockUnlocked = "TIMELOCK_UNLOCKED"
const notZeroAmount = "NOT_ZERO_AMOUNT"
const noLockedTokens = "NO_LOCKED_TOKENS"
const notEnoughBalance = "NOT_ENOUGH_BALANCE"
const receiverNotFound = "RECEIVER_NOT_FOUND"
const fa2TotalSupplyNotFound = "FA2_TOTAL_SUPPLY_NOT_FOUND"
const outcomeNotFound = "OUTCOME_NOT_FOUND"
const alreadyExecuted = "ALREADY_EXECUTED"
const notExecutable = "NOT_EXECUTABLE"
const hashNotFound = "HASH_NOT_FOUND"
const hashNotMatch = "HASH_NOT_MATCH"
const unpackMismatch = "UNPACK_MISMATCH"
const nothingToCancel = "NOTHING_TO_CANCEL"


#import "./config.jsligo" "Config"
#import "./errors.jsligo" "Errors"

export type parameterChange = (n: unit) => Config.t
export type operationList = (n: unit) => list<operation>;

export type t =
    | ["ParameterChange", parameterChange]
    | ["OperationList", operationList];

const unpack = (hashOpt: option<bytes>, packed: bytes): t => {
    return match(hashOpt, {
        None: () => failwith(Errors.hashNotFound),
        Some: (hash_: bytes) => {
            assert_with_error(
                hash_ == Crypto.sha256(packed),
                Errors.hashNotMatch
            );

            return match((Bytes.unpack(packed) as option<t>), {
                None: () => failwith(Errors.unpackMismatch),
                Some: (lambda_: t) => lambda_
            });
        }
    });
};


#import "./constants.jsligo" "Constants"
#import "./errors.jsligo" "Errors"
#import "./lambda.jsligo" "Lambda"
#import "./outcome.jsligo" "Outcome"
#import "./proposal.jsligo" "Proposal"
#import "./storage.jsligo" "Storage"
#import "./vote.jsligo" "Vote"
#import "./token.jsligo" "Token"
#import "./vault.jsligo" "Vault"
#import "./timelock.jsligo" "Timelock"

export type parameter =
    // @layout:comb
    | ["Propose", Proposal.makeParams]
    | ["Cancel", option<nat>]
    | ["Lock", Vault.amount_]
    | ["Release", Vault.amount_]
    | ["Execute", Outcome.executeParams]
    | ["Vote", Vote.choice]
    | ["EndVote"]
;

export type storage = Storage.t;
type result = [list<operation>, storage];

const execute = (outcomeKey: nat, packed: bytes, s: storage) : result => {
    const proposal = match(Big_map.find_opt(outcomeKey, s.outcomes), {
        None: () => failwith(Errors.outcomeNotFound),
        Some: (o: Outcome.t) => Outcome.getExecutableProposal(o)
    });

    Timelock._checkUnlocked(proposal.timelock);
    const lambda_ : Lambda.t = Lambda.unpack(proposal.hash, packed);

    return match(lambda_, {
        OperationList: (f: Lambda.operationList) => [
            f(),
            Storage.updateOutcome(outcomeKey, [proposal, Executed()], s)
        ],
        ParameterChange: (f: Lambda.parameterChange) => [
            Constants.noOperation,
            Storage.updateOutcome(
                outcomeKey,
                [proposal, Executed()],
                Storage.updateConfig(f,s)
            )]
    });
};

const propose = (p: Proposal.makeParams, s: storage) : result =>
    match(s.proposal, {
        Some: (_: Proposal.t) => failwith(Errors.proposalAlreadyExists),
        None: () => [
            list([Token.transfer(
                [s.governanceToken,
                Tezos.get_sender(),
                Tezos.get_self_address(),
                s.config.depositAmount]
            )]), Storage.createProposal(
                Proposal.make(p, s.config.startDelay, s.config.votingPeriod),
                s)
        ]
    });

const cancel = (outcomeKeyOpt: option<nat>, s: storage) : result =>
   [list([Token.transfer(
        [s.governanceToken,
        Tezos.get_self_address(),
        s.config.burnAddress,
        s.config.depositAmount])
   ]), match(outcomeKeyOpt, {
        None: () => match(s.proposal, {
            None: () => failwith(Errors.nothingToCancel),
            Some: (p: Proposal.t) => {
                Proposal._checkNotVotingPeriod(p);
                assert_with_error(
                    p.creator == Tezos.get_sender(),
                    Errors.notCreator
                );

                return Storage.addOutcome([p, Canceled()], s);
            }}),
        Some: (outcomeKey: nat) => match(Big_map.find_opt(outcomeKey, s.outcomes), {
            None: () => failwith(Errors.outcomeNotFound),
            Some: (o: Outcome.t) => {
                const [p, state] = o;
                assert_with_error(
                    p.creator == Tezos.get_sender(),
                    Errors.notCreator
                );
                assert_with_error(
                    state != (Executed() as Outcome.state),
                    Errors.alreadyExecuted
                );
                Timelock._checkLocked(p.timelock);

                return Storage.updateOutcome(outcomeKey, [p, Canceled()], s)
            }})
        })
   ];

const lock = (amount_: nat, s: storage) : result => {
    Proposal._checkNoVoteOngoing(s.proposal);
    const currentAmount = Vault.getForUser([s.vault, Tezos.get_sender()]);

    return [
        list([Token.transfer(
            [s.governanceToken,
            Tezos.get_sender(),
            Tezos.get_self_address(), amount_])]),
        Storage.updateVault(Vault.updateForUser(
            [s.vault,
            Tezos.get_sender(),
            currentAmount + amount_]), s)
    ];
};

const release = (amount_: nat, s: storage) : result => {
    Proposal._checkNoVoteOngoing(s.proposal);
    const currentAmount = Vault.getForUserExn([s.vault, Tezos.get_sender()]);
    assert_with_error( (currentAmount >= amount_), Errors.notEnoughBalance);

    return [
        list([Token.transfer(
            [s.governanceToken,
            Tezos.get_self_address(),
            Tezos.get_sender(), amount_])]),
        Storage.updateVault(Vault.updateForUser(
            [s.vault,
            Tezos.get_sender(),
            abs(currentAmount - amount_)]), s)
    ];
};

const vote = (choice: bool, s: storage) : storage =>
    match(s.proposal, {
        None: () => failwith(Errors.noProposal),
        Some: (p: Proposal.t) => {
            Proposal._checkIsVotingPeriod(p);
            const amount_ = Vault.getForUserExn([s.vault, Tezos.get_sender()]);
            return Storage.updateVotes(p, [choice, amount_], s);
        }});

const endVote = (s: storage) : result =>
    match(s.proposal,{
        None: () => failwith(Errors.noProposal),
        Some: (p: Proposal.t) => {
            Proposal._checkVotingPeriodEnded(p);
            const totalSupply = match(Token.getTotalSupply(s.governanceToken),{
                None: () => failwith(Errors.fa2TotalSupplyNotFound),
                Some: (n: nat) => n
            });
            const outcome = Outcome.make(
                    p,
                    totalSupply,
                    s.config.refundThreshold,
                    s.config.quorumThreshold,
                    s.config.superMajority
                );
            const [_, state] = outcome;

            let transferToAddr = p.creator;
            if (Rejected_(WithoutRefund()) == state) {
                transferToAddr = s.config.burnAddress;
            }
            return [
                list([Token.transfer(
                    [s.governanceToken,
                    Tezos.get_self_address(),
                    transferToAddr,
                    s.config.depositAmount])])
                , Storage.addOutcome(outcome, s)
            ];
        }});

const main = (action: parameter, store: storage) : result => {
    assert_with_error(Tezos.get_amount() == (0 as tez), Errors.notZeroAmount);
    return match(action, {
        Propose: (p: Proposal.makeParams) => propose(p, store),
        Cancel: (nOpt: option<nat>) => cancel(nOpt, store),
        Lock: (n: nat) => lock(n, store),
        Release: (n: nat) => release(n, store),
        Execute: (p: Outcome.executeParams) => execute(p.outcomeKey, p.packed, store),
        Vote: (v: Vote.choice) => [Constants.noOperation, vote(v, store)],
        EndVote: () => endVote(store)
    });
};


// tzip-16 https://tzip.tezosagora.org/proposal/tzip-16/
export type t = big_map<string, bytes>;


#import "./proposal.jsligo" "Proposal"
#import "./vote.jsligo" "Vote"
#import "./errors.jsligo" "Errors"

export type rejectedStateExtra =
    | ["WithRefund"]
    | ["WithoutRefund"];

export type state =
    | ["Accepted"]
    | ["Rejected_", rejectedStateExtra]
    | ["Executed"]
    | ["Canceled"];

export type t = [Proposal.t, state];

export type executeParams =
    // @layout:comb
    {
        outcomeKey: nat,
        packed: bytes
        // ^ the packed Lambda.t
    }

const makeState = (
    [total, for_, against]: [nat, nat, nat],
    totalSupply: nat,
    refundThreshold: nat,
    quorumThreshold: nat,
    superMajority: nat
): state => {
    if ((total / totalSupply * (100 as nat)) < refundThreshold) {
        return Rejected_(WithoutRefund());
    } else if ((for_ / total * (100 as nat)) < superMajority
        || ((total / totalSupply * (100 as nat)) < quorumThreshold)) {
        return Rejected_(WithRefund())
    } else if (for_ > against) {
        return Accepted()
    } else {
        return Rejected_(WithRefund())
    }
}

const make = (p: Proposal.t,
    totalSupply: nat,
    refundThreshold: nat,
    quorumThreshold: nat,
    superMajority: nat
) : t => [
    p,
    makeState(
        Vote.count(p.votes),
        totalSupply,
        refundThreshold,
        quorumThreshold,
        superMajority
    )
];

const getExecutableProposal = (outcome: t) : Proposal.t => {
    const [p, state] = outcome;

    if ((Accepted() as state) == state) {
        return p;
    }

    return failwith(Errors.notExecutable);
};


#import "./errors.jsligo" "Errors"
#import "./vote.jsligo" "Vote"
#import "./timelock.jsligo" "Timelock"

export type t =
    // @layout:comb
    {
        descriptionLink: string,
        hash: option<bytes>,
        startAt: timestamp,
        endAt: timestamp,
        votes: Vote.votes,
        creator: address,
        timelock: option<Timelock.t>
    }

export type makeParams =
    // @layout:comb
    {
        descriptionLink: string,
        hash: option<bytes>
    }

const make = (p: makeParams, startDelay: nat, votingPeriod: nat) : t => {
    const startAt = Tezos.get_now() + int(startDelay);

    return {
        descriptionLink: p.descriptionLink,
        hash: p.hash,
        startAt: startAt,
        endAt: startAt + int(votingPeriod),
        votes: Map.empty as Vote.votes,
        creator: Tezos.get_sender(),
        timelock: (None() as option<Timelock.t>)
    };
};

const isVotingPeriod = (p: t) : bool =>
    ((Tezos.get_now() >= p.startAt) && (Tezos.get_now() < p.endAt));

const _checkNotVotingPeriod = (p: t) : unit =>
    assert_with_error(!isVotingPeriod(p), Errors.votingPeriod);

const _checkIsVotingPeriod = (p: t) : unit =>
    assert_with_error(isVotingPeriod(p), Errors.notVotingPeriod);

const _checkNoVoteOngoing = (p_opt: option<t>) : unit =>
    match(p_opt, {
        Some: (p: t) => _checkNotVotingPeriod(p),
        None: () => unit
    });

const _checkVotingPeriodEnded = (p: t) : unit =>
    assert_with_error(Tezos.get_now() > p.endAt, Errors.votingPeriod);


#import "./config.jsligo" "Config"
#import "./lambda.jsligo" "Lambda"
#import "./metadata.jsligo" "Metadata"
#import "./outcome.jsligo" "Outcome"
#import "./proposal.jsligo" "Proposal"
#import "./timelock.jsligo" "Timelock"
#import "./token.jsligo" "Token"
#import "./vault.jsligo" "Vault"
#import "./vote.jsligo" "Vote"

export type outcomes = big_map<nat, Outcome.t>

export type t =
    // @layout:comb
    {
        metadata: Metadata.t,
        governanceToken: Token.t,
        config: Config.t,
        vault: Vault.t,
        proposal: option<Proposal.t>,
        outcomes: outcomes,
        nextOutcomeId: nat
    }

const createProposal = (p: Proposal.t, s: t) : t =>
    ({ ...s, proposal: Some(p) })

const updateConfig = (f: Lambda.parameterChange, s: t) : t =>
    ({ ...s, config: f() })

const updateVault = (v: Vault.t, s: t) : t =>
    ({ ...s, vault: v })

const updateVotes = (p: Proposal.t, v: Vote.t, s: t) : t => {
    const newVotes = Map.update(Tezos.get_sender(), Some(v), p.votes);
    const newProposal = { ...p, votes: newVotes };
    return { ...s, proposal: Some(newProposal) }
}

const updateOutcome = (k: nat, o: Outcome.t, s: t) : t =>
    ({ ...s, outcomes: Big_map.update(k, Some(o), s.outcomes) })

const addOutcome = (o: Outcome.t, s: t) : t => {
    let [proposal, status] = o;

    // If proposal is accepted, also create timelock
    if ((Accepted() as Outcome.state) == status) {
        const unlockAt = Tezos.get_now() + int(s.config.timelockDelay);
        proposal = ({ ...proposal, timelock: Some(Timelock.make(
            unlockAt,
            s.config.timelockPeriod))})
    }

    return { ...s,
        proposal: None() as option<Proposal.t>,
        outcomes: Big_map.update(
            s.nextOutcomeId,
            Some([proposal, status]),
            s.outcomes),
        nextOutcomeId: s.nextOutcomeId + (1 as nat)
    }
};


#import "./errors.jsligo" "Errors"

export type t =
    // @layout:comb
    {
        unlock_at: timestamp,
        // ^ timestamp for the unlock to happen

        relock_at: timestamp
        // ^ timestamp for the relock to happen
    };

const make = (unlock_at: timestamp, timelock_period: nat) : t => ({
   unlock_at: unlock_at,
   relock_at: unlock_at + int(timelock_period as nat)
});

const isLocked = (t : t) : bool =>
    ((Tezos.get_now() < t.unlock_at) || (Tezos.get_now() >= t.relock_at));

const _checkUnlocked = (t_opt : option<t>) : unit =>
    match(t_opt, {
        None: () => failwith(Errors.timelockNotFound),
        Some: (t: t) => assert_with_error(!isLocked(t), Errors.timelockLocked)
    });

const _checkLocked = (t_opt: option<t>) : unit =>
    match(t_opt, {
        None: () => failwith(Errors.timelockNotFound),
        Some: (t: t) => assert_with_error(isLocked(t), Errors.timelockUnlocked)
    });


#import "@ligo/fa/lib/fa2/asset/single_asset.mligo" "FA2"
#import "./errors.jsligo" "Errors"

export type t = address;
export type fa2TransferContract = contract<FA2.transfer>;

const getTransferEntrypoint = (addr: address) : fa2TransferContract => {
    const transferOption: option<fa2TransferContract> = Tezos.get_entrypoint_opt("%transfer", addr);
    return match(transferOption, {
        None: () => failwith(Errors.receiverNotFound),
        Some: (c: fa2TransferContract) => c
    });
};

const transfer = ([token_addr, from_, to_, amount_]: [t, address, address, nat]) : operation => {
    const dest = getTransferEntrypoint(token_addr);
    const transfer_requests : FA2.transfer = list([
      {from_: from_, txs: list([{to_: to_, amount: amount_, token_id: 0 as nat}])}
    ]);

    return Tezos.transaction(transfer_requests, (0 as tez), dest)
};

const getTotalSupply = (token_addr: t) : option<nat> =>
    Tezos.call_view("total_supply", unit, token_addr)


#import "./errors.jsligo" "Errors"

export type owner = address;
export type amount_ = nat;
export type t = big_map<owner, amount_>;

const getForUser = ([vault, owner]: [t, owner]) : amount_ =>
    match(Big_map.find_opt(owner, vault), {
        Some: (tokens: nat) => tokens,
        None: () => 0 as nat
    });

const getForUserExn = ([vault, owner]: [t, owner]) : amount_ => {
    const amount_ = getForUser([vault, owner]);
    if (amount_ == (0 as nat)) {
        return failwith(Errors.noLockedTokens)
    }

    return amount_
}

const updateForUser = ([vault, owner, amount_]: [t, owner, nat]) : t =>
    Big_map.update(owner, Some(amount_ as nat), vault)


export type choice = bool;
export type t = [choice, nat];
export type votes = map<address, t>;

//    [count (votes)] is the count of [votes].
//    Returns a triple of:
//        - total votes (for + against),
//        - sum of votes for,
//        - sum of votes against.
const count = (votes : votes) : [nat, nat, nat] => {
    const sum = ([acc, vote]: [[nat,nat], [address, t]]): [nat, nat] => {
        const [for_, against] = acc;
        const [_, [choice, nb]] = vote;

        if (choice) {
            return [for_ + nb, against];
        }

        return [for_, against + nb];
    };

    const [for_, against] = Map.fold(sum, votes, [0 as nat, 0 as nat]);

    return [for_ + against, for_, against];
};


#import "@ligo/fa/test/helpers/list.mligo" "List_helper"
#import "../helpers/token.jsligo" "Token_helper"
#import "../helpers/dao.jsligo" "DAO_helper"
#import "../../src/main.jsligo" "DAO"

// Boostrapping of the test environment,
// initTokAmount is the amount of token allocated to every
// bootstrapped accounts
const boot = (initTokAmount: nat, initStorage : DAO.storage)
: [Token_helper.originated, DAO_helper.originated, address] => {
    // Originate the token contract and the contract under test
    const tok = Token_helper.originate(initTokAmount);
    // Override governance token with test token
    const initDAOStorage = { ...initStorage, governanceToken: tok.addr };
    const dao = DAO_helper.originate(initDAOStorage);

    // Add the dao as operator for all the FA2 owner addresses
    //    TODO: ... in the real world, remove operator?
    List.iter((owner: address) => {
        Test.set_source(owner);
        return Token_helper.add_operators(list([
                { owner: owner, operator: dao.addr, token_id: (0 as nat) }
            ]), tok.contr);
        }, tok.owners);

    // Set a token owner as sender in the Test framework
    const sender_ = List_helper.nth_exn(1)(tok.owners);
    Test.set_source(sender_);

    // Set the baker to 5th account
    const baker = Test.nth_bootstrap_account(5);
    Test.set_baker(baker);

    return [tok, dao, sender_];
};


#import "@ligo/fa/test/helpers/list.mligo" "List_helper"
#import "./helpers/dao.jsligo" "DAO_helper"
#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/suite.jsligo" "Suite_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "DAO"

const _ = Log.describe("[Cancel] test suite");

// Boostrapping of the test environment
const initTokAmount = 33 as nat;
const bootstrap = (initDAOStorage : DAO.storage) : [
    Token_helper.originated,
    DAO_helper.originated,
    address] => Bootstrap.boot(initTokAmount, initDAOStorage);
const empty_nat_option = None() as option<nat>
const baseConfig = DAO_helper.baseConfig;
const baseStorage = DAO_helper.baseStorage;

// Successful cancel of current proposal
const testSuccessCurrentProposal = (() : unit => {
    // Add suffiscient start_delay
    const config = { ...baseConfig, startDelay: 86400 as nat };
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, sender_] = bootstrap(daoStorage);
    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);
    DAO_helper.cancelSuccess(empty_nat_option, dao.contr);
    const daoStorageContr = Test.get_storage (dao.taddr);
    DAO_helper.assertProposalState(daoStorageContr.outcomes, 1 as nat, Canceled());
    Token_helper.assertBalanceAmount(
        tok.taddr,
        sender_,
        abs(initTokAmount - daoStorage.config.depositAmount)
    );
})();

// Succesful cancel of accepted proposal, before timelock is unlocked
const testSuccessAcceptedProposal = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat,
        votingPeriod: 360 as nat,
        timelockDelay: 3000 as nat };
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const hash_ = Some(DAO_helper.dummyHash);
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);
    DAO_helper.cancelSuccess(Some(1 as nat), dao.contr);
    const daoStorageContr = Test.get_storage (dao.taddr);
    DAO_helper.assertProposalState(daoStorageContr.outcomes, 1 as nat, Canceled());
})();

// Failing cancel because there is nothing to cancel
const testFailureNothingToCancel = (() : unit => {
    const [_, dao, _] = bootstrap(baseStorage);

    const r = DAO_helper.cancel(empty_nat_option, dao.contr);
    Assert.stringFailure(r, DAO.Errors.nothingToCancel);
})();

// Failing cancel because the outcome was not found
const testFailureOutcomeNotFound = (() : unit => {
    const [_, dao, _] = bootstrap(baseStorage);

    const r = DAO_helper.cancel(Some(23 as nat), dao.contr);
    Assert.stringFailure(r, DAO.Errors.outcomeNotFound);
})();

// Failing cancel proposal because not creator
const testFailureNotCreator = (() : unit => {
    const config = { ...baseConfig, startDelay: 1200 as nat };
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);

    const sender_ = List_helper.nth_exn (2)(tok.owners);
    Test.set_source (sender_);
    const r = DAO_helper.cancel(empty_nat_option, dao.contr);
    Assert.stringFailure(r, DAO.Errors.notCreator);
})();

// Failing cancel proposal because timelock is unlocked
const testFailureTimelockUnlocked = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 360 as nat  };
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const hash_ = Some(DAO_helper.dummyHash);
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);

    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);

    const r = DAO_helper.cancel(Some(1 as nat), dao.contr);
    Assert.stringFailure(r, DAO.Errors.timelockUnlocked);
})();

// Failing cancel proposal because it was already executed
const testFailureAlreadyExecuted = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 360 as nat  };
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const hash_ = Some(DAO_helper.dummyHash);
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);
    DAO_helper.executeSuccess(1 as nat, DAO_helper.dummyPacked, dao.contr);

    const r = DAO_helper.cancel(Some(1 as nat), dao.contr);
    Assert.stringFailure(r, DAO.Errors.alreadyExecuted);
})();


#import "@ligo/fa/test/helpers/list.mligo" "List_helper"
#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/dao.jsligo" "DAO_helper"
#import "./helpers/suite.jsligo" "Suite_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "DAO"

const _ = Log.describe("[End_vote] test suite");

// Boostrapping of the test environment
const initTokAmount = 33 as nat;
const bootstrap = () : [
    Token_helper.originated,
    DAO_helper.originated,
    address] => {
    const baseConfig = DAO_helper.baseConfig;
    const baseStorage = DAO_helper.baseStorage;
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 360 as nat};
    const daoStorage = { ...baseStorage, config: config };
    return Bootstrap.boot(initTokAmount, daoStorage);
};

// Successful end_vote with proposal accepted
const testSuccessPropAccepted = (() : unit => {
    const [tok, dao, _] = bootstrap();

    const hash_ = Some(DAO_helper.dummyHash);
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);
    const daoStorage = Test.get_storage (dao.taddr);
    assert (daoStorage.proposal == (None() as option<DAO.Proposal.t>));
    DAO_helper.assertProposalState(daoStorage.outcomes, 1 as nat, Accepted());
})();

// Successful end_vote with proposal rejected because quorum was not reached
const testSuccessPropRejectedQuorumNotReached = (() : unit => {
    const [tok, dao, _] = bootstrap();

    const hash_ = Some(DAO_helper.dummyHash);
    const votes = list([
        [0, 5 as nat, true], [1, 5 as nat, true], [2, 5 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);

    const daoStorage = Test.get_storage (dao.taddr);
    DAO_helper.assertProposalState(
        daoStorage.outcomes, 1 as nat,
        Rejected_(WithoutRefund())
    );
})();

// Successful end_vote with proposal rejected because super_majority was not reached
const testSuccessPropRejectedSuperMajNotReached = (() : unit => {
    const [tok, dao, _] = bootstrap();

    const hash_ = Some(DAO_helper.dummyHash);
    const votes = list([
        [0, 15 as nat, true], [1, 15 as nat, true], [2, 15 as nat, false]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);
    const daoStorage = Test.get_storage (dao.taddr);
    DAO_helper.assertProposalState(
        daoStorage.outcomes, 1 as nat,
        Rejected_(WithRefund())
    );
})();

// Failing end_vote because proposal voting period ongoing
const testFailureVotingPeriod = (() : unit => {
    const [_, dao, _] = bootstrap();

    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);

    const r = DAO_helper.endVote(dao.contr);
    Assert.stringFailure(r, DAO.Errors.votingPeriod);
})();

// TODO: test for total_supply_not_found error


#import "@ligo/fa/test/helpers/list.mligo" "List_helper"
#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/dao.jsligo" "DAO_helper"
#import "./helpers/suite.jsligo" "Suite_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "DAO"

import Lambda = DAO.Lambda;

const _ = Log.describe("[Execute] test suite");

// Boostrapping of the test environment
const initTokAmount = 33 as nat;
const bootstrap = (initDAOStorage : DAO.storage) : [
    Token_helper.originated,
    DAO_helper.originated,
    address] => Bootstrap.boot(initTokAmount, initDAOStorage);
const baseConfig = DAO_helper.baseConfig;
const baseStorage = DAO_helper.baseStorage;

// Successful timelock execution of an operation list
const testSuccess = ((): unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 360 as nat  };
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(
        tok,
        dao,
        Some(DAO_helper.dummyHash),
        votes
    );

    DAO_helper.executeSuccess(1 as nat, DAO_helper.dummyPacked, dao.contr);
    DAO_helper.assertExecuted(dao.taddr, 1 as nat);
})();

// Successful execution of a parameter change
const testSuccessParameterChanged = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 360 as nat  };
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const baseConfig = DAO_helper.baseConfig;
    const packed = Bytes.pack (ParameterChange(
        () => ({ ...baseConfig, quorumThreshold: 51 as nat })
    ) as Lambda.t);
    const hash_ = Some(Crypto.sha256 (packed));
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);

    DAO_helper.executeSuccess(1 as nat, packed, dao.contr);
    DAO_helper.assertExecuted(dao.taddr, 1 as nat);
    const daoStorageContr = Test.get_storage (dao.taddr);

    // Assert that the config has been updated
    assert(daoStorageContr.config.quorumThreshold == (51 as nat));
})();

// Successful execution of an operation list
const testSuccessOperationList = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 360 as nat  };
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const owner2 = List_helper.nth_exn (2)(tok.owners);
    const owner2InitialBalance = Token_helper.get_balance_for(
        tok.taddr,
        owner2
    );

    // Pack an operation that will send 2 tokens from DAO to owner2
    const owner2AmountToReceive = 2 as nat;
    const opList = Token_helper.createTransferCallable(
        tok.addr, dao.addr, owner2, owner2AmountToReceive
    );
    const packed = Bytes.pack(OperationList(opList) as Lambda.t);

    const owner2AmountLocked = 25 as nat;
    const hash_ = Some(Crypto.sha256 (packed));
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);

    DAO_helper.executeSuccess(1 as nat, packed, dao.contr);
    DAO_helper.assertExecuted(dao.taddr, 1 as nat);

    const owner2_expected_balance : nat = abs(
        owner2InitialBalance
        - owner2AmountLocked
        + owner2AmountToReceive);

    Token_helper.assertBalanceAmount(
        tok.taddr,
        owner2,
        owner2_expected_balance
    );
})();

// Failing because no outcome
const testFailureNoOutcome = (() : unit => {
    const [_, dao, _] = bootstrap(baseStorage);

    const r = DAO_helper.execute(1 as nat, DAO_helper.dummyPacked, dao.contr);
    Assert.stringFailure(r, DAO.Errors.outcomeNotFound);
})();

// Failing because timelock delay not elapsed
const testFailureTimelockDelayNotElapsed = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 360 as nat,
        timelockDelay: 1800 as nat};
    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const hash_ = Some(DAO_helper.dummyHash);
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);

    const r = DAO_helper.execute(1 as nat, DAO_helper.dummyPacked, dao.contr);
    Assert.stringFailure(r, DAO.Errors.timelockLocked);
})();

// Failing because timelock has been relocked
const testFailureTimelockRelocked = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 360 as nat,
        timelockDelay: 10 as nat, timelockPeriod: 160 as nat};

    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const hash_ = Some(DAO_helper.dummyHash);
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);

    const r = DAO_helper.execute(1 as nat, DAO_helper.dummyPacked, dao.contr);
    Assert.stringFailure(r, DAO.Errors.timelockLocked);
})();

// Failing because the packed data is not matching expected type
const testFailureUnpackMismatch = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 360 as nat };

    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const packed = Bytes.pack("");
    const hash_ = Some(Crypto.sha256(packed));
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);

    const r = DAO_helper.execute(1 as nat, packed, dao.contr);
    Assert.stringFailure(r, DAO.Errors.unpackMismatch);
})();

// Failing because the hash doesn't match the packed bytes
const testFailureHashNotMatch = (() : unit => {
    const config = { ...baseConfig,
        startDelay: 10 as nat, votingPeriod: 360 as nat };

    const daoStorage = { ...baseStorage, config: config };
    const [tok, dao, _] = bootstrap(daoStorage);

    const hash_ = Some(0x01);
    const votes = list([
        [0, 25 as nat, true], [1, 25 as nat, true], [2, 25 as nat, true]
    ]);
    Suite_helper.createAndVoteProposal(tok, dao, hash_, votes);

    const r = DAO_helper.execute(1 as nat, DAO_helper.dummyPacked, dao.contr);
    Assert.stringFailure(r, DAO.Errors.hashNotMatch);
})();


// Assert contract call results in failwith with given string
const stringFailure = (res: test_exec_result,expected: string) : unit => {
  let expected_bis = Test.eval (expected) ;
  match (res, {
    Fail: (x: test_exec_error) => (
      match (x, {
        Rejected: (x:[michelson_program,address]) => assert (Test.michelson_equal (x[0], expected_bis)),
        Balance_too_low: (_: { contract_too_low : address , contract_balance : tez , spend_request : tez }) => Test.failwith ("contract failed for an unknown reason"),
        Other: (_:string) => Test.failwith ("contract failed for an unknown reason")
      })),
    Success: (_:nat) => Test.failwith ("bad price check")
  } );
} ;

// Assert contract result is successful
const txSuccess = (res: test_exec_result) : unit =>
  match (res, {
    Fail: (_: test_exec_error) => Test.failwith("Transaction should not fail"),
    Success: (_:nat) => unit
  } );


#import "../../src/main.jsligo" "DAO"
#import "./assert.jsligo" "Assert"

import Lambda = DAO.Lambda;
import Outcome = DAO.Outcome;

// Some types for readability
type taddr = typed_address<DAO.parameter, DAO.storage>;
type contr = contract<DAO.parameter>;
export type originated = {
    addr: address,
    taddr: taddr,
    contr: contr,
};

// Some dummy values intended to be used as placeholders
const dummyPacked = Bytes.pack (OperationList((() => list([]) as list<operation>)) as Lambda.t);
const dummyHash = Crypto.sha256 (dummyPacked);

const dummyProposal : DAO.Proposal.makeParams = {
    descriptionLink: "ipfs://QmbKq7QriWWU74NSq35sDSgUf24bYWTgpBq3Lea7A3d7jU",
    hash: Some(dummyHash)
};
const dummyGovernanceToken = "KT1VqarPDicMFn1ejmQqqshUkUXTCTXwmkCN" as address;

// Some default values
const emptyVault: DAO.Storage.Vault.t = Big_map.empty;
const emptyOutcomes: DAO.Storage.outcomes = Big_map.empty;

const baseConfig : DAO.Storage.Config.t = {
    depositAmount: 4 as nat,
    refundThreshold: 32 as nat,
    quorumThreshold: 67 as nat,
    superMajority: 80 as nat,
    startDelay: 360 as nat,
    votingPeriod: 1440 as nat,
    timelockDelay: 180 as nat,
    timelockPeriod: 720 as nat,
    burnAddress: "tz1burnburnburnburnburnburnburjAYjjX" as address
};

const baseStorage : DAO.storage = {
    metadata: Big_map.literal (list([
        ["", Bytes.pack("tezos-storage:contents")],
        ["contents", "" as bytes]
    ])),
    governanceToken: dummyGovernanceToken,
    vault: emptyVault,
    proposal: None() as option<DAO.Proposal.t>,
    config: baseConfig,
    nextOutcomeId: 1 as nat,
    outcomes: emptyOutcomes
};

// Originate a DAO contract with given init_storage storage
const originate = (init_storage: DAO.storage) : originated => {
    const [taddr, _, _] = Test.originate (DAO.main, init_storage, 0 as tez);
    const contr = Test.to_contract (taddr);
    const addr = Tezos.address (contr);
    return { addr: addr, taddr: taddr, contr: contr };
};

// Call entry point of DAO contr contract
const call = (p: DAO.parameter, contr: contr): test_exec_result =>
    Test.transfer_to_contract (contr, p, 0 as tez);

// Entry points call helpers
const cancel = (outcome_key_opt: option<nat>, contr: contr): test_exec_result =>
    call(Cancel(outcome_key_opt), contr);

const endVote = (contr: contr): test_exec_result => call(EndVote(), contr);

const execute = (k: nat, packed: bytes, contr: contr): test_exec_result =>
    call(Execute({ outcomeKey: k, packed: packed }), contr);

const lock = (amount_: nat, contr: contr): test_exec_result => call(Lock(amount_), contr);

const propose = (proposal: DAO.Proposal.makeParams, contr: contr): test_exec_result =>
    call(Propose(proposal), contr);

const release = (amount_: nat, contr: contr): test_exec_result =>
    call(Release(amount_), contr);

const vote = (choice: bool, contr: contr): test_exec_result => call(Vote(choice), contr);

// Asserter helper for successful entry point calls
const cancelSuccess = (outcome_key_opt: option<nat>, contr: contr): unit =>
    Assert.txSuccess(cancel(outcome_key_opt, contr));

const endVoteSuccess = (contr : contr): unit =>
    Assert.txSuccess(endVote(contr));

const executeSuccess = (k: nat, packed: bytes, contr: contr): unit =>
    Assert.txSuccess(execute(k, packed, contr));

const lockSuccess = (amount_: nat, contr: contr): unit =>
    Assert.txSuccess (lock(amount_, contr));

const proposeSuccess = (proposal: DAO.Proposal.makeParams, contr: contr): unit =>
    Assert.txSuccess(propose(proposal, contr));

const releaseSuccess = (amount_: nat, contr: contr): unit =>
    Assert.txSuccess(release(amount_, contr));

const voteSuccess = (choice: DAO.Vote.choice, contr: contr): unit =>
    Assert.txSuccess(vote(choice, contr));

// Batch call of lock entry point, WARNING: changes Test framework source
const batchLock = (addr_lst: list<address>, amount_: nat, contr: contr) : unit => {
    const lock = (addr: address) : unit => {
        Test.set_source (addr);
        lockSuccess(amount_, contr);
    };
    List.iter(lock, addr_lst);
};

// Batch call of vote entry point, WARNING: changes Test framework source
const batchVote = (addr_lst: list<address>, choice: DAO.Vote.choice, contr: contr) : unit => {
    const vote = (addr: address) : unit => {
        Test.set_source (addr);
        voteSuccess(choice, contr);
    };
    List.iter(vote, addr_lst);
};

// Assert DAO contract at [taddr] has [owner] [amount_] of tokens locked
const assertLocked = (taddr: taddr, owner: DAO.Storage.Vault.owner, amount_: nat) : unit => {
    const s = Test.get_storage(taddr);
    match (Big_map.find_opt(owner, s.vault), {
        Some: (tokens: nat) => assert(tokens == amount_),
        None: () => Test.failwith("Big_map key should not be missing")
    });
};

// Assert DAO contract at [taddr] have registered [voter] [choice] with [amount_] votes
const assertVoted = (taddr: taddr, voter: address, choice: bool, amount_: nat)
: unit => {
    const s = Test.get_storage (taddr);
    const p = Option.unopt(s.proposal);
    match (Map.find_opt(voter, p.votes), {
        Some: (vote: DAO.Vote.t) => assert(vote[0] == choice && vote[1] == amount_),
        None: () => Test.failwith("Map key should not be missing")
    });
};

// Assert DAO contract at [taddr] have an outcome occuring for [n] key in Executed state
const assertExecuted = (taddr: taddr, n: nat) : unit => {
    const s = Test.get_storage (taddr);
    match (Big_map.find_opt(n, s.outcomes), {
        None: () => Test.failwith("The outcome should exists"),
        Some: (o: Outcome.t) => {
            const [_, state] = o;
            assert(state == (Executed() as Outcome.state))
        }
    });
};

// Assert outcomes [bm] big map have an entry for key [k] and has given [s] state
const assertProposalState =
    (bm: DAO.Storage.outcomes, k: nat, s: DAO.Outcome.state) : unit =>
    match(Big_map.find_opt(k, bm), {
        Some: (outcome: DAO.Outcome.t) => {
            const [proposal, state] = outcome;
            // just checking timelock existence
            const _checkTimelock = proposal.timelock;
            // check that the proposal have been accepted
            assert(state == s)
        },
        None: () => Test.failwith("outcome not found")
    });


// Return str repeated n times
const repeat = (str: string, n: nat) : string => {
    const loop = (n: nat, acc: string) : string => {
        if (n == (0 as nat)) {
            return acc;
        } else {
            return loop(abs(n - (1 as nat)), acc + str);
        };
    };

    return loop(n, "");
};

// Log boxed lbl
//
// "+-----------+"
// "| My string |"
// "+-----------+"
const describe = (lbl : string) : unit => {
    const hr = "+" + repeat("-", String.length(lbl) + (2 as nat)) +  "+";
    Test.log(hr);
    Test.log("| " + lbl + " |");
    Test.log(hr);
};


#import "./token.jsligo" "Token_helper"
#import "./dao.jsligo" "DAO_helper"
#import "@ligo/fa/test/helpers/list.mligo" "List_helper"

// Creates a proposal on [dao] with [tok] as governance_token,
// using given [hash_] for the proposal lambda.
// The proposal creator is the first token owner registered in
// the given [tok] token contract owners list.
// Every token owner locks [amount_] of tokens in the DAO,
// and votes "yes" to the created proposal,
// eventually, the end_vote entry point is called.
// Can lead to either accepted or rejected proposal, according to
// the given [amount_] of tokens.
// Requires appropriate config of various periods and delays
const createAndVoteProposal = (
    tok: Token_helper.originated, 
    dao: DAO_helper.originated, 
    hash_: option<bytes>, 
    votes: list<[int, nat, bool]>
) : unit => {
    // set up the sender for propose and end_vote entry points
    const sender_ = List_helper.nth_exn(1)(tok.owners);

    // impersonate token owners and call lock entry point
    const callLock = ([nthAccount, amount_, _] : [int, nat, bool]) : unit => {
        Test.set_source (List_helper.nth_exn(nthAccount)(tok.owners));
        DAO_helper.lockSuccess(amount_, dao.contr);
    };
    List.iter (callLock, votes);

    // create proposal
    Test.set_source (sender_);
    const proposal = { ...DAO_helper.dummyProposal, hash: hash_ };
    DAO_helper.proposeSuccess(proposal, dao.contr);

    // impersonate token owners and call vote entry point
    const callVote = ([nthAccount, _, choice] : [int, nat, bool]) : unit => {
        Test.set_source (List_helper.nth_exn(nthAccount)(tok.owners));
        DAO_helper.voteSuccess(choice, dao.contr);
    };
    List.iter (callVote, votes);

    Test.set_source (sender_);
    DAO_helper.endVoteSuccess(dao.contr);
}


#import "@ligo/fa/lib/fa2/asset/single_asset.mligo" "SingleAsset"
#import "@ligo/fa/test/fa2/single_asset.test.mligo" "SingleAsset_helper"
#import "./assert.jsligo" "Assert"
#import "../../src/main.jsligo" "DAO"

// Some types for readability
type taddr = typed_address<SingleAsset.parameter, SingleAsset.storage>;
type contr = contract<SingleAsset.parameter>;
export type originated = {
    addr: address,
    taddr: taddr,
    owners: list<address>,
    ops: list<address>,
    contr: contr
};

const originate = (tok_amount : nat) : originated => {
    const f = "../bootstrap/single_asset.mligo";
    const [init_storage, owners, ops] = SingleAsset_helper.get_initial_storage(
        [tok_amount, tok_amount, tok_amount]
    );
    const v_mich = Test.run(((x:SingleAsset.Storage.t) => x), init_storage);
    const [addr, _, _] = Test.originate_from_file(f, "main", list(["total_supply"]), v_mich, 0 as tez);
    const taddr : taddr = Test.cast_address (addr);
    const contr = Test.to_contract (taddr);
    return {
        addr: addr,
        taddr: taddr,
        owners: owners,
        ops: ops,
        contr: contr
    };
};

type single_asset_transfer_param = {
    contr: contr,
    source: address,
    from_: address,
    to: address,
    amount: nat
};

// Transfer token in [contr] between [from_] and [to_] addresses with [amount_] tokens,
//  WARNING: changes Test framework source
const transfer = (contr: contr, from_: address, to_: address, amount_: nat)
: nat => {
    Test.set_source (from_);
    const transfer_requests : SingleAsset.transfer = list([
      {from_: from_, txs: list([{to_:to_, amount: amount_, token_id: 0 as nat}])}
    ]);
    return Test.transfer_to_contract_exn (contr, (Transfer(transfer_requests)), 0 as tez);
};

// Batch add [operators] to [contr] contract
const add_operators = (operators: list<SingleAsset.operator>, contr: contract<SingleAsset.parameter>) : unit => {
    const f = ([ys, x] : [list<SingleAsset.unit_update>, SingleAsset.operator])
    : list<SingleAsset.unit_update> => list([(Add_operator(x) as SingleAsset.unit_update), ...ys]);
    const add_operator = List.fold_left (f, (list([]) as list<SingleAsset.unit_update>), operators);
    let r = Test.transfer_to_contract(contr, (Update_operators(add_operator)), 0 as tez);
    Assert.txSuccess(r);
};

// assert for FA2 insuffiscient balance string failure
const assertInsBalanceFailure = (r : test_exec_result) : unit =>
    Assert.stringFailure(r, SingleAsset.Errors.ins_balance);

// assert FA2 contract at [taddr] have [owner] address with [amount_] tokens in its ledger
const assertBalanceAmount = (taddr: taddr, owner: SingleAsset.Ledger.owner, amount_: nat) : unit => {
    const s = Test.get_storage (taddr);
    return match (Big_map.find_opt(owner, s.ledger), {
        Some: (tokens: nat) => assert(tokens == amount_),
        None: () => Test.failwith("Big_map key should not be missing")
    });
};

// get balance in [taddr] contract for [owner] address
const get_balance_for = (taddr: taddr, owner: SingleAsset.Ledger.owner) :
nat => {
    const s = Test.get_storage (taddr);
    return match (Big_map.find_opt(owner, s.ledger), {
        Some: (amount_: nat) => amount_,
        None: () => 0 as nat
    });
};

// Create a lambda of type (list<operation>) that would call the "transfer"
// entrypoint of a FA2 contract residing at [addr], making a token transfer between
// [from_] and [to_] addresses with [amount_] tokens.
const createTransferCallable = (addr: address, from_: address, to_: address, amount_: nat)
: DAO.Lambda.operationList => {
    return () : list<operation> => {
        const transferOpt: option<contract<SingleAsset.transfer>> =
            Tezos.get_entrypoint_opt("%transfer", addr);

        return match (transferOpt, {
            Some: (c: contract<SingleAsset.transfer>) => {
                const transfer_requests: SingleAsset.transfer = list([
                  {from_: from_, txs: list([{to_: to_, amount: amount_, token_id: 0 as nat}]) as
                  list<SingleAsset.atomic_trans> }
                ]);
                const op = Tezos.transaction(transfer_requests, 0 as tez, c);
                return list([op]);
            },
            None: () => failwith("TOKEN_CONTRACT_NOT_FOUND")
        });
    }
};


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/dao.jsligo" "DAO_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "DAO"

const _ = Log.describe("[Lock] test suite");

// Boostrapping of the test environment
const initTokAmount = 10 as nat;
const bootstrap = (initDAOStorage : DAO.storage) : [
    Token_helper.originated,
    DAO_helper.originated,
    address] => Bootstrap.boot(initTokAmount, initDAOStorage);
const baseConfig = DAO_helper.baseConfig;
const baseStorage = DAO_helper.baseStorage;

// Succesful lock
const testSuccess = (() : unit => {
    const [tok, dao, sender_] = bootstrap(baseStorage);

    const amount_ = 3 as nat;
    const r = DAO_helper.lock(amount_, dao.contr);
    Assert.txSuccess(r);

    DAO_helper.assertLocked(dao.taddr, sender_, amount_);
    Token_helper.assertBalanceAmount(
        tok.taddr,
        sender_,
        abs(initTokAmount - amount_));
})();

// Succesful lock before voting starts
const testSuccessBeforeVotingStarts = (() : unit => {
    // Add suffiscient start_delay
    const config = { ...baseConfig, startDelay: 86400 as nat };
    let daoStorage = { ...baseStorage, config: config };
    const [tok, dao, sender_] = bootstrap(daoStorage);
    daoStorage = Test.get_storage (dao.taddr);

    const amount_ = 3 as nat;
    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);
    DAO_helper.lockSuccess(amount_, dao.contr);

    DAO_helper.assertLocked(dao.taddr, sender_, amount_);
    Token_helper.assertBalanceAmount(
        tok.taddr,
        sender_,
        abs(initTokAmount - amount_ - daoStorage.config.depositAmount)
    );
})();

// Failing lock because sender has insuffiscient balance
const testFailureInsBalance = (() : unit => {
    const [_, dao, _] = bootstrap(baseStorage);
    const r = DAO_helper.lock(30 as nat, dao.contr);
    Token_helper.assertInsBalanceFailure(r);
})();

// Failing lock because voting is underway
const testFailureVotingPeriod = (() : unit => {
    // Really short start_delay
    const config = { ...baseConfig, startDelay: 10 as nat };
    const daoStorage = { ...baseStorage, config: config };
    const [_, dao, _] = bootstrap(daoStorage);

    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);
    const r = DAO_helper.lock(3 as nat, dao.contr);

    Assert.stringFailure(r, DAO.Errors.votingPeriod);
})();


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/dao.jsligo" "DAO_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "DAO"

const _ = Log.describe("[Propose] test suite");

// Boostrapping of the test environment
const initTokAmount = 10 as nat;
const bootstrap = () : [
    Token_helper.originated,
    DAO_helper.originated,
    address] => Bootstrap.boot(initTokAmount, DAO_helper.baseStorage);

// Successful proposal creation
const testSuccess = (() : unit => {
    const [tok, dao, sender_] = bootstrap();

    const r = DAO_helper.propose(DAO_helper.dummyProposal, dao.contr);
    Assert.txSuccess(r);

    const daoStorage = Test.get_storage(dao.taddr);
    const proposal = Option.unopt(daoStorage.proposal);
    assert(proposal.creator == sender_);
    assert(proposal.descriptionLink ==
        "ipfs://QmbKq7QriWWU74NSq35sDSgUf24bYWTgpBq3Lea7A3d7jU");
    assert(proposal.hash == Some(DAO_helper.dummyHash));

    Token_helper.assertBalanceAmount(
        tok.taddr,
        dao.addr,
        daoStorage.config.depositAmount
    );

    Token_helper.assertBalanceAmount(
        tok.taddr,
        sender_,
        abs(initTokAmount - daoStorage.config.depositAmount)
    );
})();

// Failing proposal creation because there is already a proposal
const testFailureProposalExists = (() : unit => {
    const [_, dao, _] = bootstrap();

    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);
    const r = DAO_helper.propose(DAO_helper.dummyProposal, dao.contr);

    Assert.stringFailure(r, DAO.Errors.proposalAlreadyExists);
})();

// Failing because the proposing account doesn't have sufiscient balance for the deposit amount
const testFailureInsufiscientBalance = (() : unit => {
    const [tok, dao, sender_] = bootstrap();

    // Burn all the sender tokens
    const burn_addr = "tz1ZZZZZZZZZZZZZZZZZZZZZZZZZZZZNkiRg" as address;
    const _ = Token_helper.transfer(tok.contr, sender_, burn_addr, initTokAmount);
    const r = DAO_helper.propose(DAO_helper.dummyProposal, dao.contr);

    Token_helper.assertInsBalanceFailure(r);
})();


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/dao.jsligo" "DAO_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "DAO"

const _ = Log.describe("[Release] test suite");

// Boostrapping of the test environment
const initTokAmount = 10 as nat;
const bootstrap = (initDAOStorage : DAO.storage) : [
    Token_helper.originated,
    DAO_helper.originated,
    address] => Bootstrap.boot(initTokAmount, initDAOStorage);
const baseConfig = DAO_helper.baseConfig;
const baseStorage = DAO_helper.baseStorage;

// Successful release
const testSuccess = (() : unit => {
    const [tok, dao, sender_] = bootstrap(baseStorage);

    DAO_helper.lockSuccess(3 as nat, dao.contr);
    DAO_helper.releaseSuccess(3 as nat, dao.contr);

    DAO_helper.assertLocked(dao.taddr, sender_, 0 as nat);
    Token_helper.assertBalanceAmount(
        tok.taddr,
        sender_,
        initTokAmount
    );
})();

// Failing release because no locked tokens
const testFailureNoLockedTokens = (() : unit => {
    const [_, dao, _] = bootstrap(baseStorage);

    const r = DAO_helper.release(3 as nat, dao.contr);
    Assert.stringFailure(r, DAO.Errors.noLockedTokens);
})();

// Failing release because insuffiscient balance
const testFailureInsBalance = (() : unit => {
    const [_, dao, _] = bootstrap(baseStorage);
    DAO_helper.lockSuccess(2 as nat, dao.contr);
    const r = DAO_helper.release(3 as nat, dao.contr);
    Assert.stringFailure(r, DAO.Errors.notEnoughBalance);
})();

// Failing release because voting is underway
const testFailureVotingPeriod = (() : unit => {
    // Really short start_delay
    const config = { ...baseConfig, startDelay: 10 as nat };
    const daoStorage = { ...baseStorage, config: config };
    const [_, dao, _] = bootstrap(daoStorage);

    DAO_helper.lockSuccess(3 as nat, dao.contr);
    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);

    const r = DAO_helper.release(3 as nat, dao.contr);

    Assert.stringFailure(r, DAO.Errors.votingPeriod);
})();


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/dao.jsligo" "DAO_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "DAO"

const _ = Log.describe("[Vote] test suite");

// Boostrapping of the test environment
const initTokAmount = 10 as nat;
const bootstrap = (initDAOStorage : DAO.storage) : [
    Token_helper.originated,
    DAO_helper.originated,
    address] => Bootstrap.boot(initTokAmount, initDAOStorage);
const baseConfig = DAO_helper.baseConfig;
const baseStorage = DAO_helper.baseStorage;

// Successful vote
const testSuccess = (() : unit => {
    // Really short start_delay
    const config = { ...baseConfig, startDelay: 10 as nat };
    const daoStorage = { ...baseStorage, config: config };
    const [_, dao, sender_] = bootstrap(daoStorage);

    const amount_ = 3 as nat;
    DAO_helper.lockSuccess(amount_, dao.contr);
    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);

    const choice = true;
    DAO_helper.voteSuccess(choice, dao.contr);
    DAO_helper.assertVoted(dao.taddr, sender_, choice, amount_);
})();

// Failing vote because no proposal
const testFailureNoProposal = (() : unit => {
    const [_, dao, _] = bootstrap(baseStorage);

    const r = DAO_helper.vote(true, dao.contr);
    Assert.stringFailure(r, DAO.Errors.noProposal);
})();

// Failing vote because proposal is not in voting period
const testFailureNotVotingPeriod = (() : unit => {
    const [_, dao, _] = bootstrap(baseStorage);

    const amount_ = 3 as nat;
    DAO_helper.lockSuccess(amount_, dao.contr);
    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);

    const r = DAO_helper.vote(true, dao.contr);
    Assert.stringFailure(r, DAO.Errors.notVotingPeriod);
})();

// Failing because no locked tokens in vault
const testFailureNoLockedTokens = (() : unit => {
    // Really short start_delay
    const config = { ...baseConfig, startDelay: 10 as nat };
    const daoStorage = { ...baseStorage, config: config };
    const [_, dao, _] = bootstrap(daoStorage);

    DAO_helper.proposeSuccess(DAO_helper.dummyProposal, dao.contr);

    const r = DAO_helper.vote(true, dao.contr);
    Assert.stringFailure(r, DAO.Errors.noLockedTokens);
})();


DAO-Jsligo

An exemple of multisig contract in CameLIGO

sign_proposal

target_fa2

transfers

create_proposal

proposal_counter

proposal_map

signers

threshold

metadata

[@no_mutation] let only_signer = "Only one of the contract signer can create an proposal"
[@no_mutation] let amount_must_be_zero_tez = "You must not send Tezos to the smart contract"
[@no_mutation] let no_proposal_exist = "No proposal exists for this counter"
[@no_mutation] let has_already_signed = "You have already signed this proposal"
[@no_mutation] let unknown_contract_entrypoint = "Cannot connect to the target transfer token entrypoint"

[@no_mutation] let undefined_token = "FA2_TOKEN_UNDEFINED"
[@no_mutation] let ins_balance     = "FA2_INSUFFICIENT_BALANCE"
[@no_mutation] let no_transfer     = "FA2_TX_DENIED"
[@no_mutation] let not_owner       = "FA2_NOT_OWNER"
[@no_mutation] let not_operator    = "FA2_NOT_OPERATOR"
[@no_mutation] let not_supported   = "FA2_OPERATORS_UNSUPPORTED"
[@no_mutation] let rec_hook_fail   = "FA2_RECEIVER_HOOK_FAILED"
[@no_mutation] let send_hook_fail  = "FA2_SENDER_HOOK_FAILED"
[@no_mutation] let rec_hook_undef  = "FA2_RECEIVER_HOOK_UNDEFINED"
[@no_mutation] let send_hook_under = "FA2_SENDER_HOOK_UNDEFINED"


(**
   This file implement the TZIP-12 protocol (a.k.a FA2) for NFT on Tezos
   copyright Wulfman Corporation 2021
*)

#import "errors.mligo" "Errors"

module Operators = struct
   type owner    = address
   type operator = address
   type token_id = nat
   type t = ((owner * operator), token_id set) big_map

(** if transfer policy is Owner_or_operator_transfer *)
   let assert_authorisation (operators : t) (from_ : address) (token_id : nat) : unit =
      let sender_ = (Tezos.get_sender ()) in
      if (sender_ = from_) then ()
      else
      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 transfer policy is Owner_transfer
   let assert_authorisation (operators : t) (from_ : address) : unit =
      let sender_ = (Tezos.get_sender ()) in
      if (sender_ = from_) then ()
      else failwith Errors.not_owner
*)

(** if transfer policy is No_transfer
   let assert_authorisation (operators : t) (from_ : address) : unit =
      failwith Errors.no_owner
*)

   [@no_mutation] let assert_update_permission (owner : owner) : unit =
      assert_with_error (owner = (Tezos.get_sender ())) "The sender can only manage operators for his own token"
   (** For an administator
      let admin = tz1.... in
      assert_with_error ((Tezos.get_sender ()) = admiin) "Only administrator can manage operators"
   *)

   let add_operator (operators : t) (owner : owner) (operator : operator) (token_id : token_id) : t =
      if owner = operator then operators (* assert_authorisation always allow the owner so this case is not relevant *)
      else
         let () = assert_update_permission owner in
         let auth_tokens = match Big_map.find_opt (owner,operator) operators with
            Some (ts) -> ts | None -> Set.empty in
         let auth_tokens  = Set.add token_id auth_tokens in
         Big_map.update (owner,operator) (Some auth_tokens) operators

   let remove_operator (operators : t) (owner : owner) (operator : operator) (token_id : token_id) : t =
      if owner = operator then operators (* assert_authorisation always allow the owner so this case is not relevant *)
      else
         let () = assert_update_permission owner in
         let auth_tokens = match Big_map.find_opt (owner,operator) operators with
         None -> None | Some (ts) ->
            let ts = Set.remove token_id ts in
            [@no_mutation] let ts = if (Set.cardinal ts = 0n) then None else Some (ts) in
            ts
         in
         Big_map.update (owner,operator) auth_tokens operators
end

module Ledger = struct
   type token_id = nat
   type owner = address
   type t = (token_id,owner) big_map

   let is_owner_of (ledger:t) (token_id : token_id) (owner: address) : bool =
      (** We already sanitized token_id, a failwith here indicated a patological storage *)
      let current_owner = Option.unopt (Big_map.find_opt token_id ledger) in
      current_owner=owner

   let assert_owner_of (ledger:t) (token_id : token_id) (owner: address) : unit =
      assert_with_error (is_owner_of ledger token_id owner) Errors.ins_balance

   let transfer_token_from_user_to_user (ledger : t) (token_id : token_id) (from_ : owner) (to_ : owner) : t =
      let () = assert_owner_of ledger token_id from_ in
      let ledger = Big_map.update token_id (Some to_) ledger in
      ledger
end

module TokenMetadata = struct
   (**
      This should be initialized at origination, conforming to either
      TZIP-12 : https://gitlab.com/tezos/tzip/-/blob/master/proposals/tzip-12/tzip-12.md#token-metadata
      or TZIP-16 : https://gitlab.com/tezos/tzip/-/blob/master/proposals/tzip-12/tzip-12.md#contract-metadata-tzip-016
   *)
   type data = {token_id:nat;token_info:(string,bytes)map}
   type t = (nat, data) big_map
end

module Storage = struct
   type token_id = nat
   type t = {
      ledger : Ledger.t;
      token_metadata : TokenMetadata.t;
      operators : Operators.t;
   }

   let is_owner_of (s:t) (owner : address) (token_id : token_id) : bool =
      Ledger.is_owner_of s.ledger token_id owner

   let assert_token_exist (s:t) (token_id : nat) : unit  =
      let _ = Option.unopt_with_error (Big_map.find_opt token_id s.token_metadata)
         Errors.undefined_token in
      ()

   let set_ledger (s:t) (ledger:Ledger.t) = {s with ledger = ledger}

   let get_operators (s:t) = s.operators
   let set_operators (s:t) (operators:Operators.t) = {s with operators = operators}
end


type storage = Storage.t

(** Transfer entrypoint *)
type atomic_trans = [@layout:comb] {
   to_      : address;
   token_id : nat;
}

type transfer_from = {
   from_ : address;
   tx    : atomic_trans list
}
type transfer = transfer_from list

let transfer : transfer -> storage -> operation list * storage =
   fun (t:transfer) (s:storage) ->
   (* This function process the "tx" list. Since all transfer share the same "from_" address, we use a se *)
   let process_atomic_transfer (from_:address) (ledger, t:Ledger.t * atomic_trans) =
      let {to_;token_id} = t in
      let ()     = Storage.assert_token_exist s token_id in
      let ()     = Operators.assert_authorisation s.operators from_ token_id in
      let ledger = Ledger.transfer_token_from_user_to_user ledger token_id from_ to_ in
      ledger
   in
   let process_single_transfer (ledger, t:Ledger.t * transfer_from ) =
      let {from_;tx} = t in
      let ledger     = List.fold_left (process_atomic_transfer from_) ledger tx in
      ledger
   in
   let ledger = List.fold_left process_single_transfer s.ledger t in
   let s = Storage.set_ledger s ledger in
   ([]: operation list),s

type request = {
   owner    : address;
   token_id : nat;
}

type callback = [@layout:comb] {
   request : request;
   balance : nat;
}

type balance_of = [@layout:comb] {
   requests : request list;
   callback : callback list contract;
}

(** Balance_of entrypoint *)
let balance_of : balance_of -> storage -> operation list * storage =
   fun (b: balance_of) (s: storage) ->
   let {requests;callback} = b in
   let get_balance_info (request : request) : callback =
      let {owner;token_id} = request in
      let ()       = Storage.assert_token_exist  s token_id in
      [@no_mutation] let balance_ = if Storage.is_owner_of s owner token_id then 1n else 0n in
      {request=request;balance=balance_}
   in
   let callback_param = List.map get_balance_info requests in
   [@no_mutation] let operation = Tezos.transaction callback_param 0tez callback in
   ([operation]: operation list),s

(** Update_operators entrypoint *)
type operator = [@layout:comb] {
   owner    : address;
   operator : address;
   token_id : nat;
}
type unit_update      = Add_operator of operator | Remove_operator of operator
type update_operators = unit_update list

let update_ops : update_operators -> storage -> operation list * storage =
   fun (updates: update_operators) (s: storage) ->
   let update_operator (operators,update : Operators.t * unit_update) = match update with
      Add_operator    {owner=owner;operator=operator;token_id=token_id} -> Operators.add_operator    operators owner operator token_id
   |  Remove_operator {owner=owner;operator=operator;token_id=token_id} -> Operators.remove_operator operators owner operator token_id
   in
   let operators = Storage.get_operators s in
   let operators = List.fold_left update_operator operators updates in
   let s = Storage.set_operators s operators in
   ([]: operation list),s

(** If transfer_policy is  No_transfer or Owner_transfer
let update_ops : update_operators -> storage -> operation list * storage =
   fun (updates: update_operators) (s: storage) ->
   let () = failwith Errors.not_supported in
   ([]: operation list),s
*)


type parameter = [@layout:comb] | Transfer of transfer | Balance_of of balance_of | Update_operators of update_operators
let main (p : parameter) (s : storage) = match p with
   Transfer         p -> transfer   p s
|  Balance_of       p -> balance_of p s
|  Update_operators p -> update_ops p s


#import "../common/errors.mligo" "Errors"
#import "storage.mligo" "Storage"

[@inline]
let only_signer (storage : Storage.Types.t) : unit = 
    assert_with_error (Set.mem (Tezos.get_sender ()) storage.signers) Errors.only_signer

[@inline]
let amount_must_be_zero_tez (an_amout : tez) : unit =
    assert_with_error (an_amout = 0tez) Errors.amount_must_be_zero_tez

[@inline]
let not_yet_signer (proposal : Storage.Types.proposal) : unit = 
    assert_with_error (not Set.mem (Tezos.get_sender ()) proposal.approved_signers) Errors.has_already_signed



#import "../common/constants.mligo" "Constants"
#import "parameter.mligo" "Parameter"
#import "storage.mligo" "Storage"
#import "conditions.mligo" "Conditions"
#import "contracts/fa2.mligo" "FA2"

// ===============================================================================================

module Preamble = struct
    [@inline]
    let prepare_new_proposal (params, storage: Parameter.Types.proposal_params * Storage.Types.t) : Storage.Types.proposal =
        let () = Conditions.only_signer storage in
        let () = Conditions.amount_must_be_zero_tez (Tezos.get_amount ()) in
        Storage.Utils.create_proposal params

    [@inline]
    let retrieve_a_proposal (proposal_number, storage: Parameter.Types.proposal_number * Storage.Types.t) : Storage.Types.proposal =
        let () = Conditions.only_signer storage in
        let target_proposal = Storage.Utils.retrieve_proposal(proposal_number, storage) in
        let () = Conditions.not_yet_signer target_proposal in
        target_proposal
end

// ===============================================================================================

type result = operation list * Storage.Types.t

(**
 * Proposal creation
 *)
[@entry]
let create_proposal params (storage : Storage.Types.t) : result =
    let proposal = Preamble.prepare_new_proposal(params, storage) in
    let storage = Storage.Utils.register_proposal(proposal, storage) in
    (Constants.no_operation, storage)

(**
 * Proposal signature
 *)

[@entry]
let sign_proposal proposal_number (storage : Storage.Types.t) : result =
    let proposal = Preamble.retrieve_a_proposal(proposal_number, storage) in

    let proposal = Storage.Utils.add_signer_to_proposal(proposal, (Tezos.get_sender ()), storage.threshold) in
    let storage = Storage.Utils.update_proposal(proposal_number, proposal, storage) in

    let operations = FA2.perform_operations proposal in

    (operations, storage)

// ===============================================================================================

// This function is now only used for tests, and will be removed once tests are rewritten
let main (action: Parameter.Types.t) (storage: Storage.Types.t) : result =
    match action with
    | Create_proposal(proposal_params) ->
        create_proposal proposal_params storage
    | Sign_proposal(proposal_number) ->
        sign_proposal proposal_number storage


#import "../../common/errors.mligo" "Errors"
#import "../../common/constants.mligo" "Constants"
#import "../storage.mligo" "Storage"
#import "../../fa2/fa2.mligo" "FA2"

let send (transfers : FA2.transfer) (target_fa2_address : address) : operation = 
    [@no_mutation] let fa2_contract_opt : FA2.transfer contract option = Tezos.get_entrypoint_opt "%transfer" target_fa2_address in
    match fa2_contract_opt with
    | Some contr -> Tezos.transaction (transfers) 0mutez contr
    | None -> (failwith Errors.unknown_contract_entrypoint : operation)

let perform_operations (proposal: Storage.Types.proposal) : operation list =
    if proposal.executed
    then [ send proposal.transfers proposal.target_fa2 ]
    else Constants.no_operation

(*
#import "../lib/fa12/parameter.mligo" "FA12_Parameter"
#import "../lib/fa12/storage.mligo" "FA12_Storage"
#import "../lib/fa12/contract.mligo" "FA12"

#import "../lib/multisig/parameter.mligo" "Parameter"
#import "../lib/multisig/storage.mligo" "Storage"
#import "../lib/multisig/contract.mligo" "Multisign"

// ===== SIGNERS =====
let _create_accounts = Test.reset_state 6n ([] : tez list)
let alice   = Test.nth_bootstrap_account 0
let bob     = Test.nth_bootstrap_account 1
let charly  = Test.nth_bootstrap_account 2
let delta   = Test.nth_bootstrap_account 3
let echo    = Test.nth_bootstrap_account 4
let unknown = Test.nth_bootstrap_account 5

// ===== FAILWITH HELPER =======
let assert_string_failure (res : test_exec_result) (expected : string) : unit =
    let expected = Test.eval expected in
    match res with
    | Fail (Rejected (actual,_)) -> assert (Test.michelson_equal actual expected)
    | Fail (Other) -> failwith "Contract have failed"
    | Success -> failwith "Test should have failed"

// ========== DEPLOY CONTRACT HELPER ============
let originate (type s p) (storage: s) (main: (p * s) -> operation list * s) : (p,s) typed_address * p contract =
    let (typed_address, _, _) = Test.originate main storage 0tez in
    typed_address, Test.to_contract typed_address

// ===================================
// ========== BEGIN TESTS ============
// ===================================
let test_originate_contract_with_correct_storage_should_work =
    // Prepare data for initial storage
    let empty_bigmap : (nat, Storage.Types.proposal) big_map = Big_map.empty in 
    let initial_storage_multisig : Storage.Types.t = {
        proposal_counter = 0n;
        proposal_map = empty_bigmap;
        signers = (Set.add alice (Set.add bob (Set.add charly (Set.add delta (Set.empty : address set)))));
        threshold = 3n;
    } in
    // Originate contract
    let (typed_address_multi,_) = originate initial_storage_multisig Multisign.main in
    let storage_multi : Storage.Types.t = Test.get_storage typed_address_multi in
    // Assert that the storage is correct
    let () = assert (storage_multi.proposal_counter = initial_storage_multisig.proposal_counter ) in
    let () = assert (storage_multi.proposal_map = initial_storage_multisig.proposal_map ) in
    let () = assert (storage_multi.signers = initial_storage_multisig.signers ) in
    let () = assert (storage_multi.threshold = initial_storage_multisig.threshold ) in
    "✓"

let test_create_multisig_proposal_without_being_signer_should_fail =
    // Prepare data for initial storage
    let empty_bigmap : (nat, Storage.Types.proposal) big_map = Big_map.empty in 
    let initial_storage_multisig : Storage.Types.t = {
        proposal_counter = 0n;
        proposal_map = empty_bigmap;
        signers = (Set.add alice (Set.add bob (Set.add charly (Set.add delta (Set.empty : address set)))));
        threshold = 3n;
    } in
    // Originate contract multisig 
    let (_,contract_multisig) = originate initial_storage_multisig Multisign.main in
    // Create the initial fa12 storage
    let empty_bigmap : (FA12_Parameter.Types.allowance_key, nat) big_map = Big_map.empty in 
    let initial_storage_fa12 = {
        tokens = Big_map.add alice 1000n Big_map.empty;
        allowances = empty_bigmap;
        total_supply = 1000n;
    } in
    // Originate contract fa12 
    let (typed_address_fa12,contract_fa12) = originate initial_storage_fa12 FA12.main in
    // Create a new proposal
    let new_proposal : Parameter.Types.proposal_params = {
        target_fa12 = Tezos.address contract_fa12;
        target_to = echo;
        token_amount = 100n;
    } in
    // Send a new proposal without being a signer should fail
    let () = Test.set_source echo in
    let fail_tx : test_exec_result = Test.transfer_to_contract contract_multisig (Create_proposal(new_proposal)) 0mutez in
    let () = assert_string_failure (fail_tx: test_exec_result) ("Only one of the contract signer can create an proposal":string) in
    "✓"

let test_create_multisig_proposal_with_a_signer_should_work =
    // Prepare data for initial storage
    let empty_bigmap : (nat, Storage.Types.proposal) big_map = Big_map.empty in 
    // Create the initial multisig storage with specific values
    let initial_storage_multisig : Storage.Types.t = {
        proposal_counter = 0n;
        proposal_map = empty_bigmap;
        signers = (Set.add alice (Set.add bob (Set.add charly (Set.empty : address set))));
        threshold = 2n;
    } in
    // Originate contract multisig and cast a typed address to get the contract artefact
    let (typed_address_multi,contract_multisig) = originate initial_storage_multisig Multisign.main in
    // Create the initial fa12 storage
    let empty_bigmap : (FA12_Parameter.Types.allowance_key, nat) big_map = Big_map.empty in 
    let initial_storage_fa12 : FA12_Storage.Types.t = {
        tokens = Big_map.add alice 1000n Big_map.empty;
        allowances = empty_bigmap;
        total_supply = 1000n;
    } in
    // Originate contract fa12 and cast a typed address to get the contract artefact
    let (typed_address_fa,contract_fa12) = originate initial_storage_fa12 FA12.main in
    // Create a new proposal
    let new_proposal : Parameter.Types.proposal_params = {
        target_fa12 = Tezos.address contract_fa12;
        target_to = echo;
        token_amount = 100n;
    } in
    // Send a new proposal with a signer should work
    let () = Test.set_source alice in
    let tx : test_exec_result = Test.transfer_to_contract contract_multisig (Create_proposal(new_proposal)) 0mutez in
    let () = Test.log(tx) in
    let new_storage : Storage.Types.t = Test.get_storage typed_address_multi in
    let proposal : Storage.Types.proposal = match Map.find_opt 1n new_storage.proposal_map with
        Some value -> value
      | None -> failwith "f"
    in
    let () = assert ( proposal.approved_signers = (Set.add alice (Set.empty : address set)) ) in
    let () = assert ( proposal.executed = false) in
    let () = assert ( proposal.number_of_signer = 1n) in
    let () = assert ( proposal.target_fa12 = new_proposal.target_fa12) in
    let () = assert ( proposal.target_to = echo) in
    //let () = assert ( proposal.timestamp = (Tezos.now : timestamp)) in
    let () = assert ( proposal.token_amount = 100n) in
    "✓"

let test_sign_a_multisig_proposal_should_work =
    // Prepare data for initial storage
    let empty_bigmap : (nat, Storage.Types.proposal) big_map = Big_map.empty in 
    let address_1 : address = alice in
    let address_2 : address = bob in
    let address_3 : address = charly in
    // Create the initial multisig storage with specific values
    let initial_storage_multisig : Storage.Types.t = {
        proposal_counter = 0n;
        proposal_map = empty_bigmap;
        signers = (Set.add address_1 (Set.add address_2 (Set.add address_3 (Set.empty : address set))));
        threshold = 2n;
    } in
    // Originate contract multisig and cast a typed address to get the contract artefact
    let (typed_address_multi,contract_multisig) = originate initial_storage_multisig Multisign.main in
    // Create the initial fa12 storage
    let empty_bigmap : (FA12_Parameter.Types.allowance_key, nat) big_map = Big_map.empty in 
    let initial_storage_fa12 : FA12_Storage.Types.t = {
        tokens = Big_map.add alice 1000n Big_map.empty;
        allowances = empty_bigmap;
        total_supply = 1000n;
    } in
    // Originate contract fa12 and cast a typed address to get the contract artefact
    let (typed_address_fa,contract_fa12) = originate initial_storage_fa12 FA12.main in
    // Create a new proposal
    let new_proposal : Parameter.Types.proposal_params = {
        target_fa12 = Tezos.address contract_fa12;
        target_to = echo;
        token_amount = 100n;
    } in
    // Send a new proposal with a signer should work
    let () = Test.set_source alice in
    let tx : test_exec_result = Test.transfer_to_contract contract_multisig (Create_proposal(new_proposal)) 0mutez in
    let () = Test.set_source bob in
    let tx2 : test_exec_result = Test.transfer_to_contract contract_multisig (Sign_proposal(1n)) 0mutez in
 
    let new_storage : Storage.Types.t = Test.get_storage typed_address_multi in
    let proposal : Storage.Types.proposal = match Map.find_opt 1n new_storage.proposal_map with
        Some value -> value
      | None -> failwith "f"
    in

    //let () = assert ( proposal.approved_signers = (Set.add bob (Set.add alice (Set.empty : address set)))) in
    //let () = assert ( proposal.executed = true) in
    //let () = assert ( proposal.number_of_signer = 2n) in
    let () = assert ( proposal.target_fa12 = new_proposal.target_fa12) in
    let () = assert ( proposal.target_to = echo) in
    //let () = assert ( proposal.timestamp = (Tezos.now : timestamp)) in
    let () = assert ( proposal.token_amount = 100n) in
    "✓"
*)


    

#import "../fa2/fa2.mligo" "FA2"

module Types = struct
    type proposal_params = 
    [@layout:comb]
    {
        target_fa2 : address;
        transfers  : FA2.transfer;
    }

    type proposal_number = nat

    type t =
    | Create_proposal of (proposal_params)
    | Sign_proposal of (nat)
end


#import "parameter.mligo" "Parameter"
#import "../common/errors.mligo" "Errors"
#import "../fa2/fa2.mligo" "FA2"


module Types = struct
    type proposal =
    [@layout:comb]
    {
        approved_signers: address set;
        executed: bool;
        number_of_signer: nat;
        target_fa2: address;
        transfers: FA2.transfer;
        timestamp: timestamp;
    }

    type t =
    [@layout:comb]
    {
        proposal_counter: nat;
        proposal_map    : (nat, proposal) big_map;
        signers         : address set;
        threshold       : nat;
        metadata        : (string, bytes) big_map;
    }
end

module Utils = struct
    [@inline]
    let new_storage (signers, threshold: address set * nat) : Types.t =
        [@no_mutation] let proposal_counter = 0n in
        {
            proposal_counter ;
            proposal_map     = (Big_map.empty : (nat, Types.proposal) big_map);
            signers          = signers;
            threshold        = threshold;
            metadata         = (Big_map.empty: (string, bytes) big_map);
        }

    [@inline]
    let create_proposal (params: Parameter.Types.proposal_params) : Types.proposal =
        [@no_mutation] let number_of_signer = 1n in
        {
            approved_signers = Set.literal [(Tezos.get_sender ())];
            executed         = false;
            number_of_signer ;
            target_fa2       = params.target_fa2;
            timestamp        = (Tezos.get_now ());
            transfers        = params.transfers;
        }

    [@inline]
    let register_proposal (proposal, storage: Types.proposal * Types.t) : Types.t =
        [@no_mutation] let proposal_counter = storage.proposal_counter + 1n in
        let proposal_map = Big_map.add proposal_counter proposal storage.proposal_map in
        {
            storage with
            proposal_map     = proposal_map;
            proposal_counter = proposal_counter
        }

    [@inline]
    let retrieve_proposal (proposal_number, storage : nat * Types.t) : Types.proposal =
        match Big_map.find_opt proposal_number storage.proposal_map with
        | None -> failwith Errors.no_proposal_exist
        | Some(proposal) -> proposal


    [@inline]
    let add_signer_to_proposal (proposal, signer, threshold: Types.proposal * address * nat) : Types.proposal =
        let approved_signers : address set = Set.add signer proposal.approved_signers in
        let executed = Set.cardinal approved_signers >= threshold || proposal.executed in
        [@no_mutation] let number_of_signer = proposal.number_of_signer + 1n in
        {
            proposal with
            approved_signers = approved_signers;
            number_of_signer ;
            executed         = executed
        }

    [@inline]
    let update_proposal (proposal_number, proposal, storage: Parameter.Types.proposal_number * Types.proposal * Types.t) : Types.t =
        let proposal_map = Big_map.update proposal_number (Some proposal) storage.proposal_map in
        {
            storage with
            proposal_map = proposal_map
        }
end


#import "../fa2/fa2.mligo" "FA2"
#import "../src/contract.mligo" "Main"
#import "../src/parameter.mligo" "P"

import Types = P.Types

export type func_main = (p: Main.Parameter.Types.t, s: Main.Storage.Types.t) =>  Main.result;
export type func_mainfa2 = (p: FA2.parameter, s: FA2.storage) =>  [list<operation>, FA2.storage];


const assert_error = (res: test_exec_result, expected_error: string): unit => {
    const expected_error2 = Test.eval(expected_error);
    match(res) {
        when(Fail(x)):do{
        match (x) {
            when(Rejected(x)): assert(Test.michelson_equal(x[0], expected_error2));
            when(Balance_too_low(_)):failwith("contract failed: balance too low");
            when(Other(s)): failwith(s);
        }};
        when(Success(_)): failwith("Expected to fail but passed");
    };
};

const x = Test.reset_state (7 as nat, list([30000000 as tez]) as list <tez>);
const alice: address = Test.nth_bootstrap_account(1);
const bob: address = Test.nth_bootstrap_account(2);
const charly: address = Test.nth_bootstrap_account(3);
const delta: address = Test.nth_bootstrap_account(4);
const echo: address = Test.nth_bootstrap_account(5);
const unknown = Test.nth_bootstrap_account(6);
const signers: set<address> = Set.add(
    alice,
    Set.add(
        bob,
        Set.add(
            charly,
            Set.add(
                delta,
                Set.add(
                    echo,
                    Set.empty as set<address>
                )
            )
        )
    )
);
const threshold: nat = 3 as nat;
const proposal_map: big_map<nat, Main.Storage.Types.proposal> = Big_map.empty;
const proposal_counter: nat = 0 as nat;
const metadata_initial: big_map<string, bytes> = Big_map.empty;

const storage: Main.Storage.Types.t = ({
    signers: signers,
    threshold: threshold,
    proposal_map: proposal_map,
    proposal_counter: proposal_counter,
    metadata: metadata_initial
});

const atomic: FA2.atomic_trans = {
        to_: bob,
        token_id: 1 as nat
    };

const transfer_from: FA2.transfer_from = {
    from_: alice,
    tx: list([atomic]) as list<FA2.atomic_trans>
};

const transfers: FA2.transfer = list([transfer_from]) as FA2.transfer;

const create_proposal_params: Main.Parameter.Types.proposal_params = {
    target_fa2: bob as address,
    transfers: transfers
};
//_ = Test.log("here");


const _test_signer_creates_proposal_works = (mainf: func_main): unit => {
    const [taddr, _1, _2] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(alice);

    const expected_proposal: Main.Storage.Types.proposal = {
        approved_signers: Set.add(alice, Set.empty as set<address>),
        executed: false,
        number_of_signer: 1 as nat,
        target_fa2: bob as address,
        transfers:transfers,
        timestamp: 0 as timestamp
    };
    const _gas_used: nat = Test.transfer_to_contract_exn(contr, Create_proposal(create_proposal_params), 0 as mutez);
    Test.log(_gas_used);
    const end_storage = Test.get_storage(taddr);
    const end_proposal: Main.Storage.Types.proposal = match(Big_map.find_opt(1 as nat, end_storage.proposal_map)) {
        when(Some(op)): op;
        when(None): failwith(Main.Conditions.Errors.no_proposal_exist);
    };
    const final_proposal: Main.Storage.Types.proposal = {
        ...end_proposal,
        timestamp: (0 as timestamp)
    };
    assert(final_proposal == expected_proposal);
};

const _test_unknown_creates_proposal_fails = (mainf: func_main): unit => {
    const [taddr, _1, _2] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(unknown);
    const fail_tx = Test.transfer_to_contract(contr, Create_proposal(create_proposal_params), 0 as tez);
    assert_error(fail_tx, Main.Conditions.Errors.only_signer);
    const curr_storage = Test.get_storage(taddr);
    assert(curr_storage == storage);
};



const _test_signer_signs_proposal_works = (mainf: func_main): unit => {
    const init_proposal: Main.Storage.Types.proposal = {
        approved_signers: Set.add(alice, Set.empty as set<address>),
        executed: false,
        number_of_signer: 1 as nat,
        target_fa2: bob as address,
        transfers: transfers,
        timestamp: 5 as timestamp,
    };

    const [taddr, _1, _2] = Test.originate(mainf, {
        ...storage, proposal_map: Big_map.literal(list([
        [1 as nat, init_proposal]
    ]))}
    , 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(bob);
    const _gas_used: nat = Test.transfer_to_contract_exn(contr, (Sign_proposal(1 as nat) as Types.t), 0 as tez);
    const curr_storage = Test.get_storage(taddr);
    const end_signed_proposal = match(Big_map.find_opt(1 as nat, curr_storage.proposal_map)) {
        when(Some(op)): op;
        when(None): failwith(Main.Conditions.Errors.no_proposal_exist);
    };
    const expected_signer: set<address> = Set.add(
        bob,
        Set.add(
            alice,
            Set.empty as set<address>
        )
    );
    assert(end_signed_proposal.approved_signers == expected_signer);
};


const _test_unknown_signs_proposal_fails = (mainf: func_main): unit => {
    const [taddr, _1, _2] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(unknown);
    const fail_tx = Test.transfer_to_contract(contr, (Sign_proposal(1 as nat) as Types.t), 0 as tez);
    assert_error(fail_tx, Main.Conditions.Errors.only_signer);
    const curr_storage = Test.get_storage(taddr);
    assert(curr_storage == storage);
};



const _test_unknown_signs_unknown_proposal_fails = (mainf : func_main): unit => {
    const [taddr, _1, _2] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(unknown);
    const fail_sign_tx = Test.transfer_to_contract(contr, (Sign_proposal(2 as nat) as Types.t), 0 as tez);
    assert_error(fail_sign_tx, Main.Conditions.Errors.only_signer);
};


const _test_signer_signs_unknown_proposal_fails = (mainf: func_main): unit => {
    const [taddr, _1, _2] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(alice);
    const fail_sign_tx = Test.transfer_to_contract(contr, (Sign_proposal(2 as nat) as Types.t), 0 as tez);
    assert_error(fail_sign_tx, Main.Conditions.Errors.no_proposal_exist);
};



const _signer_creates_proposal_signers_sign_proposal_execute_works = (mainf: func_main, mainfa2: func_mainfa2): unit => {
    Test.set_source(alice);
    const [taddr, _1, _2] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    const addr: address = Tezos.address(contr);

    const ledger: FA2.Ledger.t = Big_map.literal(list([
        [1 as nat, alice],
        [2 as nat, bob],
        [3 as nat, charly]
    ]));

    const token_info = Map.empty as map<string, bytes>;
    const token_metadata = Big_map.literal(list([
        [1 as nat, {token_id:1 as nat, token_info: token_info}],
        [3 as nat, {token_id:3 as nat, token_info: token_info}],
        [2 as nat, {token_id:2 as nat, token_info: token_info}]
    ])) as FA2.TokenMetadata.t;

    const operators: FA2.Operators.t = Big_map.literal(list([
        [[alice, addr], Set.add(1 as nat, Set.empty as set<nat>)]
    ])) as FA2.Operators.t;

    const storage_fa2 = {
        ledger         : ledger,
        token_metadata : token_metadata,
        operators      : operators
    };

    const [taddr_fa2, _3, _4] = Test.originate(mainfa2, storage_fa2, 0 as tez);
    const contr_fa2 = Test.to_contract(taddr_fa2);
    const addr_fa2 = Tezos.address(contr_fa2);
    const params: Main.Parameter.Types.proposal_params = {...create_proposal_params, target_fa2: addr_fa2};
    let _gas_used: nat = Test.transfer_to_contract_exn(contr, Create_proposal(params), 0 as mutez);



    Test.set_source(bob);
    _gas_used = Test.transfer_to_contract_exn(contr, (Sign_proposal(1 as nat) as Types.t), 0 as tez);
    Test.set_source(charly);
    _gas_used = Test.transfer_to_contract_exn(contr, (Sign_proposal(1 as nat) as Types.t), 0 as tez);

    const expected_executed_signers = Set.add(
        alice,
        Set.add(
            bob,
            Set.add(
                charly,
                Set.empty as set<address>
            )
        )
    );

    const curr_storage = Test.get_storage(taddr);
    const end_executed_proposal = match(Big_map.find_opt(1 as nat, curr_storage.proposal_map)) {
        when(Some(op)): op;
        when(None): failwith(Main.Conditions.Errors.no_proposal_exist);
    };

    assert(end_executed_proposal.executed);
    assert(end_executed_proposal.approved_signers == expected_executed_signers);
    const curr_fa2_storage: FA2.storage = Test.get_storage(taddr_fa2);
    const owner: address = match(Big_map.find_opt(1 as nat, curr_fa2_storage.ledger)) {
        when(Some(val)): val;
        when(None): failwith(FA2.Errors.undefined_token);
    };
    assert(owner == bob);
};


const _signer_creates_proposal_signers_sign_proposal_execute_over_threshold_works = (mainf: func_main, mainfa2: func_mainfa2): unit => {
    Test.set_source(alice);
    const storage_init = {...storage, threshold: 1 as nat};
    const [taddr, _1, _2] = Test.originate(mainf, storage_init, 0 as tez);
    const contr = Test.to_contract(taddr);
    const addr: address = Tezos.address(contr);

    const ledger: FA2.Ledger.t = Big_map.literal(list([
        [1 as nat, alice],
        [2 as nat, bob],
        [3 as nat, charly]
    ]));

    const token_info = Map.empty as map<string, bytes>;
    const token_metadata = Big_map.literal(list([
        [1 as nat, {token_id:1 as nat, token_info: token_info}],
        [2 as nat, {token_id:2 as nat, token_info: token_info}],
        [3 as nat, {token_id:3 as nat, token_info: token_info}]
    ])) as FA2.TokenMetadata.t;

    const operators: FA2.Operators.t = Big_map.literal(list([
        [[alice, addr], Set.add(1 as nat, Set.empty as set<nat>)]
    ])) as FA2.Operators.t;

    const storage_fa2 = {
        ledger         : ledger,
        token_metadata : token_metadata,
        operators      : operators
    };

    const [taddr_fa2, _3, _4] = Test.originate(mainfa2, storage_fa2, 0 as tez);
    const contr_fa2 = Test.to_contract(taddr_fa2);
    const addr_fa2 = Tezos.address(contr_fa2);
    const params: Main.Parameter.Types.proposal_params = {...create_proposal_params, target_fa2: addr_fa2};
    let _gas_used: nat = Test.transfer_to_contract_exn(contr, Create_proposal(params), 0 as mutez);



    Test.set_source(bob);
    _gas_used = Test.transfer_to_contract_exn(contr, (Sign_proposal(1 as nat) as Types.t), 0 as tez);

    const expected_executed_signers = Set.add(
        alice,
        Set.add(
            bob,
            Set.empty as set<address>
        )
    );

    const curr_storage = Test.get_storage(taddr);
    Test.log(curr_storage);
    const end_executed_proposal = match(Big_map.find_opt(1 as nat, curr_storage.proposal_map)) {
        when(Some(op)): op;
        when(None): failwith(Main.Conditions.Errors.no_proposal_exist);
    };

    assert(end_executed_proposal.executed);
    assert(end_executed_proposal.approved_signers == expected_executed_signers);
    const curr_fa2_storage: FA2.storage = Test.get_storage(taddr_fa2);
    const owner: address = match(Big_map.find_opt(1 as nat, curr_fa2_storage.ledger)) {
        when(Some(val)): val;
        when(None): failwith(FA2.Errors.undefined_token);
    };
    assert(owner == bob);
};

const test_1 = _test_signer_creates_proposal_works(Main.main);
const test_2 = _test_unknown_creates_proposal_fails(Main.main);
const test_3 = _test_signer_signs_proposal_works(Main.main);
const test_4 = _test_unknown_signs_proposal_fails(Main.main);
const test_5 = _test_unknown_signs_unknown_proposal_fails(Main.main);
const test_6 = _test_signer_signs_unknown_proposal_fails(Main.main);
const test_7 = _signer_creates_proposal_signers_sign_proposal_execute_works(Main.main, FA2.main);
const test_8 = _signer_creates_proposal_signers_sign_proposal_execute_over_threshold_works(Main.main, FA2.main);


#import "multisig.test.jsligo" "Test_Multisig"
/*
type main_tuple = (main_multisig: Test_Multisig.func_main, main_fa2: Test_Multisig.func_mainfa2) => unit;

const _test_mutation_complex = (func: main_tuple): unit => {
    match(Test.mutation_test([Test_Multisig.Main.main, Test_Multisig.FA2.main], ([a, b]) => func(a, b)), {
    None: () => unit,
    Some: pmutation => { 
        Test.log(pmutation[1]);
    }
    })
};


const _test_mutation_func = (func: (mainf: Test_Multisig.func_main) => unit): unit => {
    match(Test.mutation_test(Test_Multisig.Main.main, func), {
        None: () => unit,
        Some: pmutation => { 
            const _mut: option<string> = Test.save_mutation("mutations", pmutation[1]);
        }
    });
}
const _tests = list([
    Test_Multisig._test_signer_creates_proposal_works, Test_Multisig._test_unknown_creates_proposal_fails,
    Test_Multisig._test_signer_signs_proposal_works, Test_Multisig._test_unknown_signs_proposal_fails,
    Test_Multisig._test_unknown_signs_unknown_proposal_fails,
    Test_Multisig._test_signer_signs_unknown_proposal_fails
]);
const _tests_complex = list([
    Test_Multisig._signer_creates_proposal_signers_sign_proposal_execute_works,
    Test_Multisig._signer_creates_proposal_signers_sign_proposal_execute_over_threshold_works
]);
const mutation_tests = (): unit => {
    List.iter(_test_mutation_func, _tests);
    List.iter(_test_mutation_complex, _tests_complex);
};  

const _ = mutation_tests();
*/

Multisig-Cameligo

An exemple of multisig contract in JsLIGO

[@no_mutation]
let only_signer = "Only one of the contract signer can create an proposal"

[@no_mutation]
let amount_must_be_zero_tez = "You must not send Tezos to the smart contract"

[@no_mutation]
let no_proposal_exist = "No proposal exists for this counter"

[@no_mutation]
let has_already_signed = "You have already signed this proposal"

[@no_mutation]
let unknown_contract_entrypoint =
  "Cannot connect to the target transfer token entrypoint"


[@no_mutation]
let undefined_token = "FA2_TOKEN_UNDEFINED"

[@no_mutation]
let ins_balance = "FA2_INSUFFICIENT_BALANCE"

[@no_mutation]
let no_transfer = "FA2_TX_DENIED"

[@no_mutation]
let not_owner = "FA2_NOT_OWNER"

[@no_mutation]
let not_operator = "FA2_NOT_OPERATOR"

[@no_mutation]
let not_supported = "FA2_OPERATORS_UNSUPPORTED"

[@no_mutation]
let rec_hook_fail = "FA2_RECEIVER_HOOK_FAILED"

[@no_mutation]
let send_hook_fail = "FA2_SENDER_HOOK_FAILED"

[@no_mutation]
let rec_hook_undef = "FA2_RECEIVER_HOOK_UNDEFINED"

[@no_mutation]
let send_hook_under = "FA2_SENDER_HOOK_UNDEFINED"


(**
   This file implement the TZIP-12 protocol (a.k.a FA2) for NFT on Tezos
   copyright Wulfman Corporation 2021
*)

#import "errors.mligo" "Errors"
module Operators = struct
  type owner = address

  type operator = address

  type token_id = nat

  type t = ((owner * operator), token_id set) big_map

  (** if transfer policy is Owner_or_operator_transfer *)

  let assert_authorisation (operators : t) (from_ : address) (token_id : nat)
  : unit =
    let sender_ = (Tezos.get_sender ()) in
    if (sender_ = from_)
    then ()
    else
      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 transfer policy is Owner_transfer
   let assert_authorisation (operators : t) (from_ : address) : unit =
      let sender_ = (Tezos.get_sender ()) in
      if (sender_ = from_) then ()
      else failwith Errors.not_owner
*)
  (** if transfer policy is No_transfer
   let assert_authorisation (operators : t) (from_ : address) : unit =
      failwith Errors.no_owner
*)

  [@no_mutation]
  let assert_update_permission (owner : owner) : unit =
    assert_with_error
      (owner = (Tezos.get_sender ()))
      "The sender can only manage operators for his own token"

  (** For an administator
      let admin = tz1.... in
      assert_with_error ((Tezos.get_sender ()) = admiin) "Only administrator can manage operators"
   *)

  let add_operator
    (operators : t)
    (owner : owner)
    (operator : operator)
    (token_id : token_id)
  : t =
    if owner = operator
    then operators
    (* assert_authorisation always allow the owner so this case is not relevant *)

    else
      let () = assert_update_permission owner in
      let auth_tokens =
        match Big_map.find_opt (owner, operator) operators with
          Some (ts) -> ts
        | None -> Set.empty in
      let auth_tokens = Set.add token_id auth_tokens in
      Big_map.update (owner, operator) (Some auth_tokens) operators

  [@no_mutation]
  let remove_operator
    (operators : t)
    (owner : owner)
    (operator : operator)
    (token_id : token_id)
  : t =
    if owner = operator
    then operators
    (* assert_authorisation always allow the owner so this case is not relevant *)

    else
      let () = assert_update_permission owner in
      let auth_tokens =
        match Big_map.find_opt (owner, operator) operators with
          None -> None
        | Some (ts) ->
            let ts = Set.remove token_id ts in
            if (Set.cardinal ts = 0n) then None else Some (ts) in
      Big_map.update (owner, operator) auth_tokens operators

end

module Ledger = struct
  type token_id = nat

  type owner = address

  type t = (token_id, owner) big_map

  let is_owner_of (ledger : t) (token_id : token_id) (owner : address) : bool =
    (** We already sanitized token_id, a failwith here indicated a patological storage *)

    let current_owner = Option.unopt (Big_map.find_opt token_id ledger) in
    current_owner = owner

  let assert_owner_of (ledger : t) (token_id : token_id) (owner : address)
  : unit =
    assert_with_error (is_owner_of ledger token_id owner) Errors.ins_balance

  let transfer_token_from_user_to_user
    (ledger : t)
    (token_id : token_id)
    (from_ : owner)
    (to_ : owner)
  : t =
    let () = assert_owner_of ledger token_id from_ in
    let ledger = Big_map.update token_id (Some to_) ledger in
    ledger

end

module TokenMetadata = struct
  (**
      This should be initialized at origination, conforming to either
      TZIP-12 : https://gitlab.com/tezos/tzip/-/blob/master/proposals/tzip-12/tzip-12.md#token-metadata
      or TZIP-16 : https://gitlab.com/tezos/tzip/-/blob/master/proposals/tzip-12/tzip-12.md#contract-metadata-tzip-016
   *)

  type data =
    {
     token_id : nat;
     token_info : (string, bytes) map
    }

  type t = (nat, data) big_map

end

module Storage = struct
  type token_id = nat

  type t =
    {
     ledger : Ledger.t;
     token_metadata : TokenMetadata.t;
     operators : Operators.t
    }

  let is_owner_of (s : t) (owner : address) (token_id : token_id) : bool =
    Ledger.is_owner_of s.ledger token_id owner

  let assert_token_exist (s : t) (token_id : nat) : unit =
    let _ =
      Option.unopt_with_error
        (Big_map.find_opt token_id s.token_metadata)
        Errors.undefined_token in
    ()

  let set_ledger (s : t) (ledger : Ledger.t) = {s with ledger = ledger}

  let get_operators (s : t) = s.operators

  let set_operators (s : t) (operators : Operators.t) =
    {s with operators = operators}

end

type storage = Storage.t

(** Transfer entrypoint *)

type atomic_trans =
  [@layout comb]
  {
   to_ : address;
   token_id : nat
  }

type transfer_from =
  {
   from_ : address;
   tx : atomic_trans list
  }

type transfer = transfer_from list

let transfer : transfer -> storage -> operation list * storage =
  fun (t : transfer)
    (s : storage) -> (* This function process the "tx" list. Since all transfer share the same "from_" address, we use a se *)

    let process_atomic_transfer
      (from_ : address)
      (ledger, t : Ledger.t * atomic_trans) =
      let {
       to_;
       token_id
      } = t in
      let () = Storage.assert_token_exist s token_id in
      let () = Operators.assert_authorisation s.operators from_ token_id in
      let ledger =
        Ledger.transfer_token_from_user_to_user ledger token_id from_ to_ in
      ledger in
    let process_single_transfer (ledger, t : Ledger.t * transfer_from) =
      let {
       from_;
       tx
      } = t in
      let ledger = List.fold_left (process_atomic_transfer from_) ledger tx in
      ledger in
    let ledger = List.fold_left process_single_transfer s.ledger t in
    let s = Storage.set_ledger s ledger in
    ([] : operation list), s

type request =
  {
   owner : address;
   token_id : nat
  }

type callback =
  [@layout comb]
  {
   request : request;
   balance : nat
  }

type balance_of =
  [@layout comb]
  {
   requests : request list;
   callback : callback list contract
  }

(** Balance_of entrypoint *)

let balance_of : balance_of -> storage -> operation list * storage =
  fun (b : balance_of)
    (s : storage) -> let {
     requests;
     callback
    } = b in
    let get_balance_info (request : request) : callback =
      let {
       owner;
       token_id
      } = request in
      let () = Storage.assert_token_exist s token_id in
      [@no_mutation]
      let balance_ = if Storage.is_owner_of s owner token_id then 1n else 0n in
      {
       request = request;
       balance = balance_
      } in
    let callback_param = List.map get_balance_info requests in
    [@no_mutation]
    let operation = Tezos.transaction callback_param 0mutez callback in
    ([operation] : operation list), s

(** Update_operators entrypoint *)

type operator =
  [@layout comb]
  {
   owner : address;
   operator : address;
   token_id : nat
  }

type unit_update =
| Add_operator of operator
| Remove_operator of operator

type update_operators = unit_update list

let update_ops : update_operators -> storage -> operation list * storage =
  fun (updates : update_operators)
    (s : storage) -> let update_operator
      (operators, update : Operators.t * unit_update) =
      match update with
        Add_operator
          {
           owner = owner;
           operator = operator;
           token_id = token_id
          } -> Operators.add_operator operators owner operator token_id
      | Remove_operator
          {
           owner = owner;
           operator = operator;
           token_id = token_id
          } -> Operators.remove_operator operators owner operator token_id in
    let operators = Storage.get_operators s in
    let operators = List.fold_left update_operator operators updates in
    let s = Storage.set_operators s operators in
    ([] : operation list), s

(** If transfer_policy is  No_transfer or Owner_transfer
let update_ops : update_operators -> storage -> operation list * storage =
   fun (updates: update_operators) (s: storage) ->
   let () = failwith Errors.not_supported in
   ([]: operation list),s
*)

type parameter =
  [@layout comb]
  | Transfer of transfer
  | Balance_of of balance_of
  | Update_operators of update_operators

let main (p : parameter) (s : storage) =
  match p with
    Transfer p -> transfer p s
  | Balance_of p -> balance_of p s
  | Update_operators p -> update_ops p s


#import "../common/errors.mligo" "Errors"

#import "storage.jsligo" "Storage"

@inline
export const only_signer = (storage: Storage.Types.t): unit =>
    assert_with_error(
        Set.mem((Tezos.get_sender()), storage.signers),
        Errors.only_signer
    );

@inline
export const amount_must_be_zero_tez = (an_amout: tez): unit =>
    assert_with_error(an_amout == (0 as tez), Errors.amount_must_be_zero_tez);

@inline
export const not_yet_signer = (proposal: Storage.Types.proposal): unit =>
    assert_with_error(
        ! Set.mem((Tezos.get_sender()), proposal.approved_signers),
        Errors.has_already_signed
    );


#import "../common/constants.mligo" "Constants"

#import "parameter.jsligo" "Parameter"

#import "storage.jsligo" "Storage"

#import "conditions.jsligo" "Conditions"

#import "contracts/fa2.jsligo" "FA2"

// ===============================================================================================

namespace Preamble {
    export const prepare_new_proposal = (
        params: Parameter.Types.proposal_params,
        storage: Storage.Types.t
    ): Storage.Types.proposal => {
        Conditions.only_signer(storage);
        Conditions.amount_must_be_zero_tez((Tezos.get_amount()));
        return Storage.Utils.create_proposal(params);
    };
    export const retrieve_a_proposal = (
        proposal_number: nat,
        storage: Storage.Types.t
    ): Storage.Types.proposal => {
        Conditions.only_signer(storage);
        const target_proposal: Storage.Types.proposal =
            Storage.Utils.retrieve_proposal(proposal_number, storage);
        Conditions.not_yet_signer(target_proposal);
        return target_proposal;
    };
};

// ===============================================================================================

type request = [Parameter.Types.t, Storage.Types.t];

export type result = [list<operation>, Storage.Types.t];

@entry
export const create_proposal = (
    params: Parameter.Types.proposal_params,
    storage: Storage.Types.t
): result => {
    const proposal = Preamble.prepare_new_proposal(params, storage);
    const final_storage = Storage.Utils.register_proposal(proposal, storage);
    return [Constants.no_operation, final_storage];
};

@entry
export const sign_proposal = (proposal_number: nat, storage: Storage.Types.t): result => {
    let proposal = Preamble.retrieve_a_proposal(proposal_number, storage);
    proposal
    = Storage.Utils.add_signer_to_proposal(
          proposal,
          (Tezos.get_sender()),
          storage.threshold
      );
    const final_storage =
        Storage.Utils.update_proposal(proposal_number, proposal, storage);
    const operations = FA2.perform_operations(proposal);
    return [operations, final_storage];
};

// ===============================================================================================
// This function is now only used for tests, and will be removed once tests are rewritten

export const main = (action: Parameter.Types.t, store: Storage.Types.t): result =>
    match(action) {
        when (Create_proposal(p)):
            create_proposal(p, store)
        when (Sign_proposal(p)):
            sign_proposal(p, store)
    }


#import "../../common/errors.mligo" "Errors"

#import "../../common/constants.mligo" "Constants"

#import "../storage.jsligo" "Storage"

#import "../../fa2/fa2.mligo" "FA2"

export const send = (transfers: FA2.transfer, target_fa2_address: address): operation => {
    @no_mutation
    const fa2_contract_opt: option<contract<FA2.transfer>> =
        Tezos.get_entrypoint_opt("%transfer", target_fa2_address);
    return match(fa2_contract_opt) {
        when (Some(contr)):
            Tezos.transaction(transfers, 0 as tez, contr)
        when (None()):
            failwith(Errors.unknown_contract_entrypoint)
    };
}

export const perform_operations = (proposal: Storage.Types.proposal): list<
    operation
> => {
    if (proposal.executed) {
        return list([send(proposal.transfers, proposal.target_fa2)]) as
            list<operation>;
    } else return Constants.no_operation;
}


#import "../fa2/fa2.mligo" "FA2"

export namespace Types {
    export type proposal_params = {
        target_fa2: address,
        transfers: FA2.transfer
    };
    export type proposal_number = nat;
    export type t =
        | ["Create_proposal", proposal_params]
        | ["Sign_proposal", proposal_number];
};


#import "parameter.jsligo" "Parameter"

#import "../common/errors.mligo" "Errors"

#import "../fa2/fa2.mligo" "FA2"

export namespace Types {
    export type proposal = {
        approved_signers: set<address>,
        executed: bool,
        number_of_signer: nat,
        target_fa2: address,
        transfers: FA2.transfer,
        timestamp: timestamp
    };
    export type t = {
        proposal_counter: nat,
        proposal_map: big_map<nat, proposal>,
        signers: set<address>,
        threshold: nat,
        metadata: big_map<string, bytes>
    };
};

export namespace Utils {
    @inline
    const new_storage = ([signers, threshold]: [set<address>, nat]): Types.t =>
        (
            {
                proposal_counter: 0 as nat,
                proposal_map: Big_map.empty as big_map<nat, Types.proposal>,
                signers: signers,
                threshold: threshold,
                metadata: (Big_map.empty as big_map<string, bytes>)
            }
        );
    @inline
    export const create_proposal = (params: Parameter.Types.proposal_params): Types.
    proposal => {
        @no_mutation
        let number_of_signer = 1 as nat;
        return {
            approved_signers: Set.literal(list([(Tezos.get_sender())])),
            executed: false,
            number_of_signer,
            target_fa2: params.target_fa2,
            timestamp: (Tezos.get_now()),
            transfers: params.transfers
        }
    };
    @inline
    export const register_proposal = (
        proposal: Types.proposal,
        storage: Types.t
    ): Types.t => {
        @no_mutation
        const proposal_counter = storage.proposal_counter + (1 as nat);
        const proposal_map =
            Big_map.add(proposal_counter, proposal, storage.proposal_map);
        return {
            ...storage,
            proposal_map: proposal_map,
            proposal_counter: proposal_counter
        };
    };
    @inline
    export const retrieve_proposal = (proposal_number: nat, storage: Types.t): Types.
    proposal =>
        match(Big_map.find_opt(proposal_number, storage.proposal_map)) {
            when (None()):
                failwith(Errors.no_proposal_exist)
            when (Some(proposal)):
                proposal
        };
    @inline
    export const add_signer_to_proposal = (
        proposal: Types.proposal,
        signer: address,
        threshold: nat
    ): Types.proposal => {
        const approved_signers: set<address> =
            Set.add(signer, proposal.approved_signers);
        const executed: bool =
            Set.cardinal(approved_signers) >= threshold || proposal.executed;
        @no_mutation
        const number_of_signer = proposal.number_of_signer + (1 as nat);
        return {
            ...proposal,
            approved_signers: approved_signers,
            number_of_signer,
            executed: executed
        };
    };
    @inline
    export const update_proposal = (
        proposal_number: Parameter.Types.proposal_number,
        proposal: Types.proposal,
        storage: Types.t
    ): Types.t => {
        const proposal_map =
            Big_map.update(
                proposal_number,
                Some(proposal),
                storage.proposal_map
            );
        return { ...storage, proposal_map: proposal_map }
    };
}


#import "../fa2/fa2.mligo" "FA2"

#import "../src/contract.jsligo" "Main"

#import "../src/parameter.jsligo" "P"

import Types = P.Types

export type func_main =
    (p: Main.Parameter.Types.t, s: Main.Storage.Types.t) => Main.result;

export type func_mainfa2 =
    (p: FA2.parameter, s: FA2.storage) => [list<operation>, FA2.storage];

const assert_error = (res: test_exec_result, expected_error: string): unit => {
    const expected_error2 = Test.eval(expected_error);
    match(res) {
        when (Fail(x)):
            do {
                match(x) {
                    when (Rejected(x)):
                        assert(Test.michelson_equal(x[0], expected_error2))
                    when (Balance_too_low(_r)):
                        failwith("contract failed: balance too low")
                    when (Other(s)):
                        failwith(s)
                }
            }
        when (Success(_n)):
            failwith("Expected to fail but passed")
    };
};

const x = Test.reset_state(7 as nat, list([30000000 as tez]) as list<tez>);

const alice: address = Test.nth_bootstrap_account(1);

const bob: address = Test.nth_bootstrap_account(2);

const charly: address = Test.nth_bootstrap_account(3);

const delta: address = Test.nth_bootstrap_account(4);

const echo: address = Test.nth_bootstrap_account(5);

const unknown = Test.nth_bootstrap_account(6);

const signers: set<address> =
    Set.add(
        alice,
        Set.add(
            bob,
            Set.add(
                charly,
                Set.add(delta, Set.add(echo, Set.empty as set<address>))
            )
        )
    );

const threshold: nat = 3 as nat;

const proposal_map: big_map<nat, Main.Storage.Types.proposal> = Big_map.empty;

const proposal_counter: nat = 0 as nat;

const metadata_initial: big_map<string, bytes> = Big_map.empty;

const storage: Main.Storage.Types.t = (
    {
        signers: signers,
        threshold: threshold,
        proposal_map: proposal_map,
        proposal_counter: proposal_counter,
        metadata: metadata_initial
    }
);

const atomic: FA2.atomic_trans = { to_: bob, token_id: 1 as nat };

const transfer_from: FA2.transfer_from = {
    from_: alice,
    tx: list([atomic]) as list<FA2.atomic_trans>
};

const transfers: FA2.transfer = list([transfer_from]) as FA2.transfer;

const create_proposal_params: Main.Parameter.Types.proposal_params = {
    target_fa2: bob as address,
    transfers: transfers
};

export const _test_signer_creates_proposal_works = (mainf: func_main): unit => {
    const [taddr, _1, _2] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(alice);
    const expected_proposal: Main.Storage.Types.proposal = {
        approved_signers: Set.add(alice, Set.empty as set<address>),
        executed: false,
        number_of_signer: 1 as nat,
        target_fa2: bob as address,
        transfers: transfers,
        timestamp: 0 as timestamp
    };
    const gas_used: nat =
        Test.transfer_to_contract_exn(
            contr,
            Create_proposal(create_proposal_params),
            0 as mutez
        );
    Test.log(gas_used);
    const end_storage = Test.get_storage(taddr);
    const end_proposal: Main.Storage.Types.proposal =
        match(Big_map.find_opt(1 as nat, end_storage.proposal_map)) {
            when (Some(op)):
                op
            when (None()):
                failwith(Main.Conditions.Errors.no_proposal_exist)
        };
    const final_proposal: Main.Storage.Types.proposal = {
        ...end_proposal, timestamp: (0 as timestamp)
    };
    assert(final_proposal == expected_proposal);
};

export const _test_unknown_creates_proposal_fails = (mainf: func_main): unit => {
    const [taddr, _1, _2] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(unknown);
    const fail_tx =
        Test.transfer_to_contract(
            contr,
            Create_proposal(create_proposal_params),
            0 as tez
        );
    assert_error(fail_tx, Main.Conditions.Errors.only_signer);
    const curr_storage = Test.get_storage(taddr);
    assert(curr_storage == storage);
};

export const _test_signer_signs_proposal_works = (mainf: func_main): unit => {
    const init_proposal: Main.Storage.Types.proposal = {
        approved_signers: Set.add(alice, Set.empty as set<address>),
        executed: false,
        number_of_signer: 1 as nat,
        target_fa2: bob as address,
        transfers: transfers,
        timestamp: 5 as timestamp,
    };
    const [taddr, _1, _2] =
        Test.originate(
            mainf,
            {
                ...storage,
                proposal_map: Big_map.literal(list([[1 as nat, init_proposal]]))
            },
            0 as tez
        );
    const contr = Test.to_contract(taddr);
    Test.set_source(bob);
    const _gas_used: nat =
        Test.transfer_to_contract_exn(
            contr,
            (Sign_proposal(1 as nat) as Types.t),
            0 as tez
        );
    const curr_storage = Test.get_storage(taddr);
    const end_signed_proposal =
        match(Big_map.find_opt(1 as nat, curr_storage.proposal_map)) {
            when (Some(op)):
                op
            when (None()):
                failwith(Main.Conditions.Errors.no_proposal_exist)
        };
    const expected_signer: set<address> =
        Set.add(bob, Set.add(alice, Set.empty as set<address>));
    assert(end_signed_proposal.approved_signers == expected_signer);
};

export const _test_unknown_signs_proposal_fails = (mainf: func_main): unit => {
    const [taddr, _1, _2] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(unknown);
    const fail_tx =
        Test.transfer_to_contract(
            contr,
            (Sign_proposal(1 as nat) as Types.t),
            0 as tez
        );
    assert_error(fail_tx, Main.Conditions.Errors.only_signer);
    const curr_storage = Test.get_storage(taddr);
    assert(curr_storage == storage);
};

export const _test_unknown_signs_unknown_proposal_fails = (mainf: func_main): unit => {
    const [taddr, _1, _2] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(unknown);
    const fail_sign_tx =
        Test.transfer_to_contract(
            contr,
            (Sign_proposal(2 as nat) as Types.t),
            0 as tez
        );
    assert_error(fail_sign_tx, Main.Conditions.Errors.only_signer);
};

export const _test_signer_signs_unknown_proposal_fails = (mainf: func_main): unit => {
    const [taddr, _1, _2] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    Test.set_source(alice);
    const fail_sign_tx =
        Test.transfer_to_contract(
            contr,
            (Sign_proposal(2 as nat) as Types.t),
            0 as tez
        );
    assert_error(fail_sign_tx, Main.Conditions.Errors.no_proposal_exist);
};

export const _signer_creates_proposal_signers_sign_proposal_execute_works = (
    mainf: func_main,
    mainfa2: func_mainfa2
): unit => {
    Test.set_source(alice);
    const [taddr, _1, _2] = Test.originate(mainf, storage, 0 as tez);
    const contr = Test.to_contract(taddr);
    const addr: address = Tezos.address(contr);
    const ledger: FA2.Ledger.t =
        Big_map.literal(
            list([[1 as nat, alice], [2 as nat, bob], [3 as nat, charly]])
        );
    const _token_info = Map.empty as map<string, bytes>;
    const token_metadata =
        Big_map.literal(
            list(
                [
                    [
                        1 as nat,
                        {
                            token_id: 1 as nat,
                            token_info: Map.empty as map<string, bytes>
                        }
                    ],
                    [
                        2 as nat,
                        {
                            token_id: 2 as nat,
                            token_info: Map.empty as map<string, bytes>
                        }
                    ],
                    [
                        3 as nat,
                        {
                            token_id: 3 as nat,
                            token_info: Map.empty as map<string, bytes>
                        }
                    ]
                ]
            )
        ) as FA2.TokenMetadata.t;
    const operators: FA2.Operators.t =
        Big_map.literal(list([[[alice, addr], Set.literal(list([1 as nat]))]])) as
            FA2.Operators.t;
    const storage_fa2 = {
        ledger: ledger,
        token_metadata: token_metadata,
        operators: operators
    };
    const [taddr_fa2, _3, _4] = Test.originate(mainfa2, storage_fa2, 0 as tez);
    const contr_fa2 = Test.to_contract(taddr_fa2);
    const addr_fa2 = Tezos.address(contr_fa2);
    const params: Main.Parameter.Types.proposal_params = {
        ...create_proposal_params, target_fa2: addr_fa2
    };
    let _gas_used: nat =
        Test.transfer_to_contract_exn(
            contr,
            Create_proposal(params),
            0 as mutez
        );
    Test.set_source(bob);
    _gas_used
    = Test.transfer_to_contract_exn(
          contr,
          (Sign_proposal(1 as nat) as Types.t),
          0 as tez
      );
    Test.set_source(charly);
    _gas_used
    = Test.transfer_to_contract_exn(
          contr,
          (Sign_proposal(1 as nat) as Types.t),
          0 as tez
      );
    const expected_executed_signers =
        Set.add(alice, Set.add(bob, Set.add(charly, Set.empty as set<address>)));
    const curr_storage = Test.get_storage(taddr);
    const end_executed_proposal =
        match(Big_map.find_opt(1 as nat, curr_storage.proposal_map)) {
            when (Some(op)):
                op
            when (None()):
                failwith(Main.Conditions.Errors.no_proposal_exist)
        };
    assert(end_executed_proposal.executed);
    assert(end_executed_proposal.approved_signers == expected_executed_signers);
    const curr_fa2_storage: FA2.storage = Test.get_storage(taddr_fa2);
    const owner: address =
        match(Big_map.find_opt(1 as nat, curr_fa2_storage.ledger)) {
            when (Some(val)):
                val
            when (None()):
                failwith(FA2.Errors.undefined_token)
        };
    assert(owner == bob);
};

export const _signer_creates_proposal_signers_sign_proposal_execute_over_threshold_works = (
    mainf: func_main,
    mainfa2: func_mainfa2
): unit => {
    Test.set_source(alice);
    const storage_init = { ...storage, threshold: 1 as nat };
    const [taddr, _1, _2] = Test.originate(mainf, storage_init, 0 as tez);
    const contr = Test.to_contract(taddr);
    const addr: address = Tezos.address(contr);
    const ledger: FA2.Ledger.t =
        Big_map.literal(
            list([[1 as nat, alice], [2 as nat, bob], [3 as nat, charly]])
        );
    const _token_info = Map.empty as map<string, bytes>;
    const token_metadata =
        Big_map.literal(
            list(
                [
                    [
                        1 as nat,
                        {
                            token_id: 1 as nat,
                            token_info: Map.empty as map<string, bytes>
                        }
                    ],
                    [
                        2 as nat,
                        {
                            token_id: 2 as nat,
                            token_info: Map.empty as map<string, bytes>
                        }
                    ],
                    [
                        3 as nat,
                        {
                            token_id: 3 as nat,
                            token_info: Map.empty as map<string, bytes>
                        }
                    ]
                ]
            )
        ) as FA2.TokenMetadata.t;
    const operators: FA2.Operators.t =
        Big_map.literal(list([[[alice, addr], Set.literal(list([1 as nat]))]])) as
            FA2.Operators.t;
    const storage_fa2 = {
        ledger: ledger,
        token_metadata: token_metadata,
        operators: operators
    };
    const [taddr_fa2, _3, _4] = Test.originate(mainfa2, storage_fa2, 0 as tez);
    const contr_fa2 = Test.to_contract(taddr_fa2);
    const addr_fa2 = Tezos.address(contr_fa2);
    const params: Main.Parameter.Types.proposal_params = {
        ...create_proposal_params, target_fa2: addr_fa2
    };
    let _gas_used: nat =
        Test.transfer_to_contract_exn(
            contr,
            Create_proposal(params),
            0 as mutez
        );
    Test.set_source(bob);
    _gas_used
    = Test.transfer_to_contract_exn(
          contr,
          (Sign_proposal(1 as nat) as Types.t),
          0 as tez
      );
    const expected_executed_signers =
        Set.add(alice, Set.add(bob, Set.empty as set<address>));
    const curr_storage = Test.get_storage(taddr);
    Test.log(curr_storage);
    const end_executed_proposal =
        match(Big_map.find_opt(1 as nat, curr_storage.proposal_map)) {
            when (Some(op)):
                op
            when (None()):
                failwith(Main.Conditions.Errors.no_proposal_exist)
        };
    assert(end_executed_proposal.executed);
    assert(end_executed_proposal.approved_signers == expected_executed_signers);
    const curr_fa2_storage: FA2.storage = Test.get_storage(taddr_fa2);
    const owner: address =
        match(Big_map.find_opt(1 as nat, curr_fa2_storage.ledger)) {
            when (Some(val)):
                val
            when (None()):
                failwith(FA2.Errors.undefined_token)
        };
    assert(owner == bob);
};

const test_1 = _test_signer_creates_proposal_works(Main.main);

const test_2 = _test_unknown_creates_proposal_fails(Main.main);

const test_3 = _test_signer_signs_proposal_works(Main.main);

const test_4 = _test_unknown_signs_proposal_fails(Main.main);

const test_5 = _test_unknown_signs_unknown_proposal_fails(Main.main);

const test_6 = _test_signer_signs_unknown_proposal_fails(Main.main);

const test_7 =
    _signer_creates_proposal_signers_sign_proposal_execute_works(
        Main.main,
        FA2.main
    );

const test_8 =
    _signer_creates_proposal_signers_sign_proposal_execute_over_threshold_works(
        Main.main,
        FA2.main
    );


#import "multisig.test.jsligo" "Test_Multisig"

/*
type main_tuple =
    (
        main_multisig: Test_Multisig.func_main,
        main_fa2: Test_Multisig.func_mainfa2
    ) => unit;

const _test_mutation_complex = (func: main_tuple): unit => {
    match(
        Test.mutation_test(
            [Test_Multisig.Main.main, Test_Multisig.FA2.main],
            ([a, b]) => func(a, b)
        )
    ) {
        when (None()):
            []
        when (Some(pmutation)):
            do { Test.log(pmutation[1]); }
    }
};

const _test_mutation_func = (func: (mainf: Test_Multisig.func_main) => unit): unit => {
    match(Test.mutation_test(Test_Multisig.Main.main, func)) {
        when (None()):
            []
        when (Some(pmutation)):
            do {
                const _mut: option<string> =
                    Test.save_mutation("mutations", pmutation[1]);
            }
    };
}

const _tests =
    list(
        [
            Test_Multisig._test_signer_creates_proposal_works,
            Test_Multisig._test_unknown_creates_proposal_fails,
            Test_Multisig._test_signer_signs_proposal_works,
            Test_Multisig._test_unknown_signs_proposal_fails,
            Test_Multisig._test_unknown_signs_unknown_proposal_fails,
            Test_Multisig._test_signer_signs_unknown_proposal_fails
        ]
    );

const _tests_complex =
    list(
        [
            Test_Multisig.
            _signer_creates_proposal_signers_sign_proposal_execute_works,
            Test_Multisig.
            _signer_creates_proposal_signers_sign_proposal_execute_over_threshold_works
        ]
    );

const mutation_tests = (): unit => {
    List.iter(_test_mutation_func, _tests);
    List.iter(_test_mutation_complex, _tests_complex);
};

const _ = mutation_tests();
*/


Multisig-Jsligo

update_operators

requests

callback

balance_of

set_admin

transfer

setExpiry

permit

burn_token

mint_token

create_token

ledger

token_metadata

operators

admin

counter

default_expiry

max_expiry

permits

user_expiries

permit_expiries

extension

let requires_admin  = "NOT_AN_ADMIN"
let token_exist     = "TOKEN_ID_ALREADY_PRESENT"

(* TZIP-17 *)
let dup_permit      = "DUP_PERMIT"
let missigned       = "MISSIGNED"

let max_seconds_exceeded = "MAX_SECONDS_EXCEEDED"
let forbidden_expiry_update = "FORBIDDEN_EXPIRY_UPDATE"

let missing_expiry = "NO_EXPIRY_FOUND"


#import "./errors.mligo" "Errors"

type seconds = nat
type permit_key = (address * bytes)
type permits = (permit_key, timestamp) big_map
type user_expiries = (address, seconds option) big_map
type permit_expiries = (permit_key, seconds option) big_map

type 'a t = {
    admin: address;
    counter: nat;
    default_expiry: seconds;
    max_expiry: seconds;
    permits: permits;
    user_expiries: user_expiries;
    permit_expiries: permit_expiries;
    extension : 'a;
}

let get_user_defined_expiry (type a) (from_: address) (ext: a t) : seconds option =
    match Big_map.find_opt from_ ext.user_expiries with
    | None -> (Some ext.default_expiry)
    | Some exp -> exp

let get_expiry (type a) (ext: a t) ((user, param_hash): permit_key) : seconds =
    match Big_map.find_opt (user, param_hash) ext.permit_expiries with
    | None ->
        begin
            match get_user_defined_expiry user ext with
            | None -> ext.default_expiry
            | Some exp -> exp
        end
    | Some (None) -> ext.default_expiry
    | Some (Some exp) -> exp

let assert_admin (type a)  (ext : a t) =
    assert_with_error (Tezos.get_sender() = ext.admin) Errors.requires_admin

let set_admin (type a)  (ext : a t) (admin:address) =
    let () = assert_admin(ext) in
    { ext with admin = admin }


let set_extension (type a) (ext : a t) (extension : a) =
    { ext with extension = extension }


let add_permit (type a)  (ext : a t) (permit_key: permit_key) =
    let now = Tezos.get_now() in
    { ext with
        permits = Big_map.add permit_key now ext.permits;
        counter = ext.counter + 1n
    }

let update_permit (type a) (ext : a t) (permit_key: permit_key) =
    let now = Tezos.get_now() in
    { ext with
        permits = Big_map.update permit_key (Some(now)) ext.permits;
        counter = ext.counter + 1n
    }

let _check_not_expired (type a) (ext : a t) (submission_timestamp: timestamp) (permit_key: permit_key) =
    let effective_expiry: seconds = get_expiry ext permit_key in
    if abs (Tezos.get_now() - submission_timestamp) < effective_expiry
    then failwith Errors.dup_permit

let transfer_presigned (type a) (ext : a t) (param_permit_key: permit_key): bool * a t =
    let permit_submit_time: timestamp =
        match Big_map.find_opt param_permit_key ext.permits with
        | None -> (0: timestamp)
        | Some exp -> exp
    in
    if permit_submit_time = (0: timestamp)
    then
        (false, ext)
    else
        let effective_expiry =
            match Big_map.find_opt param_permit_key ext.permit_expiries with
            | None ->
                begin
                    let user_address = param_permit_key.0 in 
                    match Big_map.find_opt user_address ext.user_expiries with
                    | None -> (Some ext.default_expiry)
                    | Some exp -> exp
                end
            | Some exp -> exp
        in
        match effective_expiry with
        | None -> (failwith Errors.missing_expiry: (bool * a t))
        | Some effective_exp ->
            let permits = Big_map.remove param_permit_key ext.permits in
            let is_authorised = abs ((Tezos.get_now()) - permit_submit_time) < effective_exp in
            (is_authorised, { ext with permits = permits })


#import "ligo-extendable-fa2/lib/multi_asset/fa2.mligo" "FA2"
#import "./constants.mligo" "Constants"
#import "./storage.mligo" "Storage"
#import "./extension.mligo" "Extension"
#import "./errors.mligo" "Errors"
#import "./token_total_supply.mligo" "TokenTotalSupply"

type token_total_supply = TokenTotalSupply.t
type gen_storage = Storage.t
type storage = token_total_supply gen_storage
type result = operation list * storage
type gen_extension = Extension.t
type extension = token_total_supply gen_extension

type mint_or_burn = [@layout:comb] {
   owner    : address;
   token_id : nat;
   amount_  : nat;
}

type permit_params = (key * (signature * bytes))
type expiry_params = (address * (nat * (bytes option)))

[@entry] let create_token (metadata,owner,amount : FA2.TokenMetadata.data * address * nat) (s : storage) =
    let () = Extension.assert_admin s.extension in
    let md = Storage.add_new_token s.token_metadata metadata.token_id metadata in
    let s = Storage.set_token_metadata s md in
    let ledger = FA2.Ledger.increase_token_amount_for_user s.ledger owner metadata.token_id amount in
    let s = FA2.Storage.set_ledger s ledger in
    let supply = TokenTotalSupply.create_supply s.extension.extension metadata.token_id amount in
    Constants.no_operation, {
      s with extension = Extension.set_extension s.extension supply
    }

[@entry] let mint_token (lst : mint_or_burn list) (s : storage) =
   let () = Extension.assert_admin s.extension in
   let process_one ((ledger,supply), {owner;token_id;amount_} : (FA2.Ledger.t * TokenTotalSupply.t) * mint_or_burn) =
      let () = FA2.Storage.assert_token_exist  s token_id in
      FA2.Ledger.increase_token_amount_for_user ledger owner token_id amount_,
      TokenTotalSupply.increase_supply supply token_id amount_
   in
   let (ledger, supply) = List.fold_left process_one (s.ledger, s.extension.extension) lst in
   let s = FA2.Storage.set_ledger s ledger in
   Constants.no_operation, {
      s with extension = Extension.set_extension s.extension supply
    }

[@entry] let burn_token (lst : mint_or_burn list) (s : storage) =
   let () = Extension.assert_admin s.extension in
   let process_one ((ledger,supply), {owner;token_id;amount_} : (FA2.Ledger.t * TokenTotalSupply.t) * mint_or_burn) =
      FA2.Ledger.decrease_token_amount_for_user ledger owner token_id amount_,
      TokenTotalSupply.decrease_supply supply token_id amount_
   in
   let (ledger, supply) = List.fold_left process_one (s.ledger, s.extension.extension) lst in
   let s = FA2.Storage.set_ledger s ledger in
   Constants.no_operation,{
      s with extension = Extension.set_extension s.extension supply
    }

(* TZIP-17 *)
[@entry] let permit (permits : (permit_params list)) (s : storage) =
    let process_permit (ext, permit : extension * permit_params) =
        let (pub_key, (sig_, hash_)) = permit in
        let packed = Bytes.pack (((Tezos.get_chain_id()), Tezos.get_self_address()), (ext.counter, hash_)) in
        if Crypto.check pub_key sig_ packed
        then
            let sender_ = Tezos.address (Tezos.implicit_account (Crypto.hash_key pub_key)) in
            let permit_key = sender_, hash_ in
            match Big_map.find_opt permit_key ext.permits with
            | None -> Extension.add_permit ext permit_key
            | Some submission_timestamp ->
                let () = Extension._check_not_expired s.extension submission_timestamp permit_key in
                Extension.update_permit ext permit_key
        else ([%Michelson ({| { FAILWITH } |} : string * bytes -> extension)]) (Errors.missigned, packed)
    in
    let extension = List.fold_left process_permit s.extension permits in
    Constants.no_operation, { s with extension = extension }

(* TZIP-17 *)
[@entry] let setExpiry (p : expiry_params) (s : storage) =
    let (user_address, (seconds, permit_hash_opt)) = p in
    let new_storage =
        if seconds > s.extension.max_expiry
        then (failwith Errors.max_seconds_exceeded : storage)
        else if Tezos.get_sender() <> user_address
        then (failwith Errors.forbidden_expiry_update : storage)
        else
                match permit_hash_opt with
                | None ->
                    {
                        s with extension.user_expiries = Big_map.add
                            user_address
                            (Some seconds)
                            s.extension.user_expiries
                    }
                | Some permit_hash ->
                    {
                        s with extension.permit_expiries = Big_map.add
                            (user_address, permit_hash)
                            (Some seconds)
                            s.extension.permit_expiries
                    }
    in Constants.no_operation, new_storage

(* TZIP-17 implementation of TZIP-12 Transfer *)
[@entry] let transfer (transfer:FA2.transfer) (s: storage) =
    let make_transfer (acc, transfer_from : (FA2.Ledger.t * extension) * FA2.transfer_from) =
        let (ledger, ext) = acc in
        let transfer_from_hash = Crypto.blake2b (Bytes.pack transfer_from) in
        let permit_key : Extension.permit_key = (transfer_from.from_, transfer_from_hash) in
        let (is_transfer_authorized, ext) = Extension.transfer_presigned ext permit_key in
        let {from_; txs} = transfer_from in
        let ledger = List.fold
          (fun (ledger, dst : FA2.Ledger.t * FA2.atomic_trans) ->
            let {token_id; amount; to_} = dst in
            let () = FA2.Storage.assert_token_exist s token_id in
            let () = if not is_transfer_authorized then
                FA2.Operators.assert_authorisation s.operators from_ token_id
            in
            let ledger = FA2.Ledger.decrease_token_amount_for_user ledger from_ token_id amount in
            let ledger = FA2.Ledger.increase_token_amount_for_user ledger to_ token_id amount in
            ledger
          ) txs ledger in
          (ledger, ext)
        in
    let (new_ledger, new_ext) = List.fold make_transfer transfer (s.ledger, s.extension)
    in Constants.no_operation, { s with ledger = new_ledger; extension = new_ext }

[@entry] let set_admin (addr: address) (s: storage) =
    Constants.no_operation, { s with extension = Extension.set_admin s.extension addr }

[@entry] let balance_of (p : FA2.balance_of) (s : storage) =
    FA2.balance_of p s

[@entry] let update_operators (p : FA2.update_operators) (s : storage) =
    FA2.update_ops p s

(*
    Off-chain views required by TZIP-17

    Command to run to get the micheline expressions to put in the metadata:

    ligo compile expression cameligo '_get_counter' \
        --init-file src/main.mligo \
        --project-root . \
        --michelson-format json
*)
let _get_default_expiry ((_,s):(unit * storage)) : nat =
    s.extension.default_expiry

let _get_counter ((_,s):(unit * storage)) : nat =
    s.extension.counter



#import "ligo-extendable-fa2/lib/multi_asset/fa2.mligo" "FA2"
#import "./errors.mligo" "Errors"
#import "./extension.mligo" "Extension"

type storage = FA2.storage
type extension = Extension.t
type 'a t = 'a extension storage

let get_token_metadata (type a) (s:a t) = s.token_metadata
let set_token_metadata (type a) (s:a t) (token_metadata:FA2.TokenMetadata.t) =
    {s with token_metadata = token_metadata}

let add_new_token (md:FA2.TokenMetadata.t) (token_id : nat) (data:FA2.TokenMetadata.data) =
    let () = assert_with_error (not (Big_map.mem token_id md)) Errors.token_exist in
    let md = Big_map.add token_id data md in
    md


#import "ligo-extendable-fa2/lib/multi_asset/fa2.mligo" "FA2"

(* token_id -> total_supply *)
type t = (FA2.Ledger.token_id, nat) big_map

let get_supply (supply : t) (token_id : FA2.Ledger.token_id) =
   match Big_map.find_opt token_id supply with 
    Some (a) -> a 
    | None -> failwith FA2.Errors.undefined_token
    
let create_supply (supply : t) (new_token_id : FA2.Ledger.token_id) (amount_ : nat) = 
    Big_map.add new_token_id amount_ supply

let increase_supply (supply : t) (token_id : FA2.Ledger.token_id) (amount_ : nat) =
    let cur_amount = get_supply supply token_id in
    let new_amount = cur_amount + amount_ in
    Big_map.update token_id (Some(new_amount)) supply

let decrease_supply (supply : t) (token_id : FA2.Ledger.token_id) (amount_ : nat) =
    let cur_amount = get_supply supply token_id in
    let new_supply = abs(cur_amount - amount_) in
    Big_map.update token_id (Some(new_supply)) supply
 

#import "../helpers/token.mligo" "Token_helper"
#import "../helpers/fa2.mligo" "FA2_helper"
#import "../../src/main.mligo" "Token"

(* Some dummy value when they don't matter for a given test *)
let dummy_genesis_ts = ("2000-01-01t10:10:10Z" : timestamp)

(*
    Boostrapping of the test environment,
    init_ts is the initial timestamp of the genesis block
*)
let boot_state (init_ts : timestamp) =
    let () = Test.reset_state_at init_ts 7n ([10000000tez] : tez list) in

    (* don't use 0 because it the baking account and may run out of tez *)
    let admin = Test.nth_bootstrap_account 6 in

    let owners =
        Test.nth_bootstrap_account 0,
        Test.nth_bootstrap_account 1,
        Test.nth_bootstrap_account 2
    in

    let owners_with_keys =
        Test.get_bootstrap_account 0n,
        Test.get_bootstrap_account 1n,
        Test.get_bootstrap_account 2n
    in

    let ops =
        Test.nth_bootstrap_account 3,
        Test.nth_bootstrap_account 4,
        Test.nth_bootstrap_account 5
    in

    (admin, owners, owners_with_keys, ops)

(*
    Bootstrapping of the contract under test,
    init_tok_amount is the amount of token allocated to every
    bootstrapped accounts
*)

let boot_token (owners, ops, init_tok_amount, init_extended_storage
: (address * address * address) * (address * address * address) * nat * Token.extension) =
    let initial_fa2_storage = FA2_helper.get_initial_storage(
        owners, ops, init_tok_amount
    ) in

    (* supply matching initial ledger *)
    let supply = (Big_map.literal [
       (1n, init_tok_amount); 
       (2n, (init_tok_amount * 2n)); 
       (3n, init_tok_amount); 
    ] : Token.TokenTotalSupply.t) in

    let init_storage = {
        metadata = Big_map.literal [
            ("", Bytes.pack("tezos-storage:contents"));
            ("contents", ("": bytes))
        ];
        ledger         = initial_fa2_storage.ledger;
        token_metadata = initial_fa2_storage.token_metadata;
        operators      = initial_fa2_storage.operators;
        extension      = { init_extended_storage with extension = supply };
    } in

    Token_helper.originate(init_storage)


#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/fa2.mligo" "FA2_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "Token"

let () = Log.describe("[Burn_token] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n

let bootstrap () =
    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts) in
    let base_extended_storage = Token_helper.get_initial_extended_storage(
        admin, Token_helper.dummy_default_expiry, Token_helper.dummy_max_expiry) in
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage) in
    (tok, admin, owners_with_keys)

(* Successful token mint *)
let test_success =
    let (tok, admin, owners) = bootstrap() in
    let ((owner1_addr, _, _), _, _) = owners in
    let () = Test.set_source admin in
    let token_id = 1n in
    let amount_ = 6n in
    let () = Token_helper.burn_token_success([{
       owner=owner1_addr;
       token_id=token_id;
       amount_=amount_;
    }], tok.contr) in
    let new_amount =  abs(init_tok_amount - amount_) in
    let () = Token_helper.assert_balance(tok.taddr, owner1_addr, token_id, new_amount) in
    Token_helper.assert_supply(tok.taddr, token_id, new_amount)

(* Failure because sender is not current admin *)
let test_failure_not_admin =
    let (tok, _, owners) = bootstrap() in
    let ((owner1_addr, _, _), _, _) = owners in
    let () = Test.set_source owner1_addr in
    let r = Token_helper.burn_token([{
       owner=owner1_addr;
       token_id=1n;
       amount_=1n;
    }], tok.contr) in
    Assert.string_failure r Token.Errors.requires_admin


#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/fa2.mligo" "FA2_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "Token"

let () = Log.describe("[Create_token] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n

let bootstrap () =
    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts) in
    let base_extended_storage = Token_helper.get_initial_extended_storage(
      admin, Token_helper.dummy_default_expiry, Token_helper.dummy_max_expiry) in
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage) in
    (tok, admin, owners_with_keys)

(* Successful token creation *)
let test_success =
    let (tok, admin, owners) = bootstrap() in
    let ((owner1_addr, _, _), _, _) = owners in
    let () = Test.set_source admin in
    let token_id = 42n in
    let amount_ = 12n in
    let () = Token_helper.create_token_success
      (FA2_helper.get_dummy_token_data (token_id),
       owner1_addr, amount_, tok.contr) in
    let () = Token_helper.assert_balance(tok.taddr, owner1_addr, token_id, amount_) in
    Token_helper.assert_supply(tok.taddr, token_id, amount_)

(* Failure because token id already present *)
let test_failure_token_exist =
    let (tok, admin, owners) = bootstrap() in
    let ((owner1_addr, _, _), _, _) = owners in
    let () = Test.set_source admin in
    let r = Token_helper.create_token
      (FA2_helper.get_dummy_token_data (1n),
       owner1_addr, 12n, tok.contr) in
    Assert.string_failure r Token.Errors.token_exist

(* Failure because sender is not current admin *)
let test_failure_not_admin =
    let (tok, _, owners) = bootstrap() in
    let ((owner1_addr, _, _), _, _) = owners in
    let () = Test.set_source owner1_addr in
    let r = Token_helper.create_token
      (FA2_helper.get_dummy_token_data (42n),
       owner1_addr, 12n, tok.contr) in
    Assert.string_failure r Token.Errors.requires_admin


#import "../../src/main.mligo" "Token"

let dummy_token_info = (Map.empty : (string, bytes) map)

let get_dummy_token_data (token_id : nat) : Token.FA2.TokenMetadata.data =
   {token_id=token_id;token_info=dummy_token_info}

(*
    Get the initial storage of FA2
    init_tok_amount is the amount of token allocated to every owner account
*)
let get_initial_storage (owners, ops, init_tok_amount
: (address * address * address) * (address * address * address) * nat) =
let (owner1, owner2, owner3) = owners in
    let (op1, _op2, op3) = ops in

    let ledger = Big_map.literal ([
        ((owner1, 1n), init_tok_amount);
        ((owner2, 2n), init_tok_amount);
        ((owner3, 3n), init_tok_amount);
        ((owner1, 2n), init_tok_amount);
    ]) in

    let operators  = Big_map.literal ([
        ((owner1, op1), Set.literal [1n; 2n]);
        ((owner2, op1), Set.literal [2n]);
        ((owner3, op1), Set.literal [3n]);
        ((op1   , op3), Set.literal [2n]);
    ]) in

    let token_metadata = (Big_map.literal [
        (1n, get_dummy_token_data(1n));
        (2n, get_dummy_token_data(2n));
        (3n, get_dummy_token_data(3n));
    ] : Token.FA2.TokenMetadata.t) in

    {
        ledger         = ledger;
        token_metadata = token_metadata;
        operators      = operators;
    }


#import "../../src/main.mligo" "Token"
#import "./assert.mligo" "Assert"

(* Some types for readability *)
type taddr = (Token parameter_of, Token.storage) typed_address
type contr = Token parameter_of contract
type originated = {
    addr: address;
    taddr: taddr;
    owners: address list;
    contr: contr;
}

(* Some dummy values when they don't matter for a given test *)
let dummy_default_expiry = 0n
let dummy_max_expiry = 0n

let get_initial_extended_storage (admin, default_expiry, max_expiry: address * nat * nat) =
{
    admin = admin;
    counter = 0n;
    default_expiry = default_expiry;
    max_expiry = max_expiry;
    permits = (Big_map.empty : Token.Extension.permits);
    user_expiries = (Big_map.empty : Token.Extension.user_expiries);
    permit_expiries = (Big_map.empty : Token.Extension.permit_expiries);
    extension = (Big_map.empty : Token.TokenTotalSupply.t)
}

(* Originate a Token contract with given init_storage storage *)
let originate (init_storage: Token.storage) =
    let (taddr, _, _) = Test.originate_module (contract_of Token) init_storage 0tez in
    let contr = Test.to_contract taddr in
    let addr = Tezos.address contr in
    { addr = addr; taddr = taddr; contr = contr }

(*
    Make a permit with given packed params and secret key
    The chain_id is equal to 0x00000000 in the test framework
*)
let make_permit (hash_, account, token_addr, counter : bytes * (address * key * string) * address * nat) : Token.permit_params =
    let (_, pub_key, secret_key) = account in
    let packed = Bytes.pack ((0x00000000, token_addr), (counter, hash_)) in
    let sig_ = Test.sign secret_key packed in
    (pub_key, (sig_, hash_))

(* Call entry point of Token contr contract *)
let call (p, contr : Token parameter_of * contr) =
    Test.transfer_to_contract contr p 0mutez

let permit (p, contr : Token.permit_params list * contr) =
    call(Permit(p), contr)

let set_expiry (p, contr : Token.expiry_params * contr) =
    call(SetExpiry(p), contr)

let set_admin (p, contr : address * contr) =
    call(Set_admin(p), contr)

let transfer (p, contr : Token.FA2.transfer * contr) =
    let p : Token parameter_of = Transfer(p) in
    call(p, contr)

let create_token (md, owner, amount, contr : Token.FA2.TokenMetadata.data * address * nat * contr) =
    call(Create_token(md, owner, amount), contr)

let mint_token (p, contr : Token.mint_or_burn list * contr) =
    call(Mint_token(p), contr)

let burn_token (p, contr : Token.mint_or_burn list * contr) =
    call(Burn_token(p), contr)

let permit_success (p, contr : Token.permit_params list * contr) =
    Assert.tx_success (permit(p, contr))

let set_expiry_success (p, contr : Token.expiry_params * contr) =
    Assert.tx_success (set_expiry(p, contr))

let set_admin_success (p, contr : address * contr) =
    Assert.tx_success (set_admin(p, contr))

let transfer_success (p, contr : Token.FA2.transfer * contr) =
    Assert.tx_success (transfer(p, contr))

let create_token_success (md, owner, amount, contr : Token.FA2.TokenMetadata.data * address * nat * contr) =
    Assert.tx_success (create_token(md, owner, amount, contr))

let mint_token_success (p, contr : Token.mint_or_burn list * contr) =
    Assert.tx_success (mint_token(p, contr))

let burn_token_success (p, contr : Token.mint_or_burn list * contr) =
    Assert.tx_success (burn_token(p, contr))

(* Assert Token contract at [taddr] has permit with [address, hash] key *)
let assert_has_permit (taddr, permit_key : taddr * Token.Extension.permit_key) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt permit_key s.extension.permits with
        Some _ -> ()
        | None -> Test.failwith("Permits Big_map key should not be missing")

(* Assert Token contract at [taddr] has no permit with [address, hash] key *)
let assert_no_permit (taddr, permit_key : taddr * Token.Extension.permit_key) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt permit_key s.extension.permits with
        Some _ -> Test.failwith("Permits Big_map key should be None")
        | None -> ()

(* Assert Token contract at [taddr] has counter equals to [counter] *)
let assert_counter (taddr, counter : taddr * nat) =
    let s = Test.get_storage taddr in
    assert_with_error
        (s.extension.counter = counter)
        "Counter does not have expected value"

(* Assert Token contract at [taddr] has user expiry for [user_addr] equal to [seconds] *)
let assert_user_expiry (taddr, user_addr, seconds : taddr * address * nat option) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt user_addr s.extension.user_expiries with
        Some s -> assert (s = seconds)
        | None -> Test.failwith("User epiries Big_map key should not be missing")

(* Assert Token contract at [taddr] has user permit expiry for [user_addr] and
hash [hash_] equal to [seconds] *)
let assert_permit_expiry (taddr, user_addr, hash_, seconds : taddr * address * bytes * nat option) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt (user_addr, hash_) s.extension.permit_expiries with
        Some s -> assert (s = seconds)
        | None -> Test.failwith("Permit epiries Big_map key should not be missing")

(* assert Token contract at [taddr] have [owner] address with [amount_] tokens in its ledger *)
let assert_balance (taddr, owner, token_id, amount_ : taddr * address * nat * nat) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt (owner, token_id) s.ledger with
        Some tokens -> assert(tokens = amount_)
        | None -> Test.failwith("Big_map key should not be missing")

(* assert Token contract at [taddr] have token_total_supply for [token_id] matching [amount_] *)
let assert_supply (taddr, token_id, amount_ : taddr * Token.FA2.Ledger.token_id * nat) =
    let s = Test.get_storage taddr in
    match Big_map.find_opt token_id s.extension.extension with
        Some tokens -> assert(tokens = amount_)
        | None -> Test.failwith("Big_map key should not be missing")


#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/fa2.mligo" "FA2_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "Token"

let () = Log.describe("[Mint_token] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n

let bootstrap () =
    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts) in
    let base_extended_storage = Token_helper.get_initial_extended_storage(
      admin, Token_helper.dummy_default_expiry, Token_helper.dummy_max_expiry) in
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage) in
    (tok, admin, owners_with_keys)

(* Successful token mint *)
let test_success =
    let (tok, admin, owners) = bootstrap() in
    let ((owner1_addr, _, _), _, _) = owners in
    let () = Test.set_source admin in
    let token_id = 1n in
    let amount_ = 56n in
    let () = Token_helper.mint_token_success([{
       owner=owner1_addr;
       token_id=token_id;
       amount_=amount_;
    }], tok.contr) in
    let new_amount =  init_tok_amount + amount_ in
    let () = Token_helper.assert_balance(tok.taddr, owner1_addr, token_id, new_amount) in
    Token_helper.assert_supply(tok.taddr, token_id, new_amount)

(* Failure because sender is not current admin *)
let test_failure_not_admin =
    let (tok, _, owners) = bootstrap() in
    let ((owner1_addr, _, _), _, _) = owners in
    let () = Test.set_source owner1_addr in
    let r = Token_helper.mint_token([{
       owner=owner1_addr;
       token_id=1n;
       amount_=1n;
    }], tok.contr) in
    Assert.string_failure r Token.Errors.requires_admin


#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "Token"

let () = Log.describe("[Permit] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n
let bootstrap (init_ts, init_default_expiry, init_max_expiry : timestamp * nat * nat) =
    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(init_ts) in
    let base_extended_storage = Token_helper.get_initial_extended_storage(admin, init_default_expiry, init_max_expiry) in
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage) in
    (tok, admin, owners_with_keys)

(* Successful permit creation *)
let test_success_add_permit_one =
    let (tok, _, owners) = bootstrap(("2000-01-01t10:10:10Z" : timestamp), 3600n, 7200n) in
    let (owner1, owner2, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in
    let transfer_requests = ([
        ({from_=owner1_addr; txs=([{to_=owner2_addr;amount=2n;token_id=1n}] : Token.FA2.atomic_trans list)});
    ] : Token.FA2.transfer) in
    let hash_ = Crypto.blake2b (Bytes.pack transfer_requests) in
    let permit = Token_helper.make_permit(hash_, owner1, tok.addr, 0n) in
    let () = Token_helper.permit_success([permit], tok.contr) in
    let () = Token_helper.assert_has_permit(tok.taddr, (owner1_addr, hash_)) in
    Token_helper.assert_counter(tok.taddr, 1n)

(* Successful successive permit creation *)
let test_success_add_permit_list =
    let (tok, _, owners) = bootstrap(("2000-01-01t10:10:10Z" : timestamp), 3600n, 7200n) in
    let (owner1, owner2, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in
    let transfer_requests = ([
        ({from_=owner1_addr; txs=([{to_=owner2_addr;amount=2n;token_id=1n}] : Token.FA2.atomic_trans list)});
    ] : Token.FA2.transfer) in
    let hash_ = Crypto.blake2b (Bytes.pack transfer_requests) in
    let permit1 = Token_helper.make_permit(hash_, owner1, tok.addr, 0n) in
    let transfer_requests = ([
        ({from_=owner2_addr; txs=([{to_=owner1_addr;amount=2n;token_id=1n}] : Token.FA2.atomic_trans list)});
    ] : Token.FA2.transfer) in
    let hash_ = Crypto.blake2b (Bytes.pack transfer_requests) in
    let permit2 = Token_helper.make_permit(hash_, owner2, tok.addr, 1n) in
    let () = Token_helper.permit_success([permit1; permit2], tok.contr) in
    let () = Token_helper.assert_has_permit(tok.taddr, (owner2_addr, hash_)) in
    Token_helper.assert_counter(tok.taddr, 2n)

(* Successful permit update *)
let test_success_update_permit =
    let init_default_expiry = 86_400n in
    let init_max_expiry = 259_200n in
    let now = ("2000-01-03t10:10:10Z" : timestamp) in
    let expired = ("2000-01-01t10:10:10Z" : timestamp) in

    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(now) in
    let (owner1, owner2, _) = owners_with_keys in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in

    let transfer_requests = ([
        ({from_=owner1_addr; txs=([{to_=owner2_addr;amount=2n;token_id=1n}] : Token.FA2.atomic_trans list)});
    ] : Token.FA2.transfer) in
    let hash_ = Crypto.blake2b (Bytes.pack transfer_requests) in

    let extended_storage = Token_helper.get_initial_extended_storage(admin, init_default_expiry, init_max_expiry) in
    let extended_storage = { extended_storage with
        permits = Big_map.literal [((owner1_addr, hash_), expired)];
        counter = 1n;
    } in

    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, extended_storage) in
    let permit = Token_helper.make_permit(hash_, owner1, tok.addr, 1n) in
    let () = Token_helper.permit_success([permit], tok.contr) in
    Token_helper.assert_has_permit(tok.taddr, (owner1_addr, hash_))

(* Failing permit update because it alredy exists and has not expired *)
let test_success_update_permit =
    let (tok, _, owners) = bootstrap(("2000-01-01t10:10:10Z" : timestamp), 3600n, 7200n) in
    let (owner1, owner2, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in
    let transfer_requests = ([
        ({from_=owner1_addr; txs=([{to_=owner2_addr;amount=2n;token_id=1n}] : Token.FA2.atomic_trans list)});
    ] : Token.FA2.transfer) in
    let hash_ = Crypto.blake2b (Bytes.pack transfer_requests) in
    let permit = Token_helper.make_permit(hash_, owner1, tok.addr, 0n) in
    let () = Token_helper.permit_success([permit], tok.contr) in
    let permit = Token_helper.make_permit(hash_, owner1, tok.addr, 1n) in
    let r = Token_helper.permit([permit], tok.contr) in
    Assert.string_failure r Token.Errors.dup_permit


#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "Token"

let () = Log.describe("[Set_admin] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n

let bootstrap () =
    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts) in
    let base_extended_storage = Token_helper.get_initial_extended_storage(
      admin, Token_helper.dummy_default_expiry, Token_helper.dummy_max_expiry) in
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage) in
    (tok, admin, owners_with_keys)

(* Successful setting of admin *)
let test_success_set_admin =
    let (tok, admin, owners) = bootstrap() in
    let (owner1, _, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let () = Test.set_source admin in
    let () = Token_helper.set_admin_success(owner1_addr, tok.contr) in
    let s = Test.get_storage tok.taddr in
    assert (s.extension.admin = owner1_addr)

(* Failure because sender is not current admin *)
let test_failure_not_admin =
    let (tok,_, owners) = bootstrap() in
    let (owner1, _, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let r = Token_helper.set_admin(owner1_addr, tok.contr) in
    Assert.string_failure r Token.Errors.requires_admin


#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "Token"

let () = Log.describe("[SetExpiry] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n
let bootstrap (init_ts, init_default_expiry, init_max_expiry : timestamp * nat * nat) =
    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(init_ts) in
    let base_extended_storage = Token_helper.get_initial_extended_storage(admin, init_default_expiry, init_max_expiry) in
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage) in
    (tok, admin, owners_with_keys)

(* Successful setting of user expiry *)
let test_success_set_user_expiry =
    let (tok, _, owners) = bootstrap(("2000-01-01t10:10:10Z" : timestamp), 3600n, 7200n) in
    let (owner1, _, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let () = Test.set_source owner1_addr in
    let expiry_params : Token.expiry_params = (owner1_addr, (5400n, (None: bytes option))) in
    let () = Token_helper.set_expiry_success(expiry_params, tok.contr) in
    Token_helper.assert_user_expiry(tok.taddr, owner1_addr, Some(5400n))

(* Successful setting of permit expiry *)
let test_success_set_permit_expiry =
    let (tok, _, owners) = bootstrap(("2000-01-01t10:10:10Z" : timestamp), 3600n, 7200n) in
    let (owner1, _, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let () = Test.set_source owner1_addr in
    let hash_ = 0x01 in
    let expiry_params : Token.expiry_params = (owner1_addr, (5400n, (Some(hash_)))) in
    let () = Token_helper.set_expiry_success(expiry_params, tok.contr) in
    Token_helper.assert_permit_expiry(tok.taddr, owner1_addr, hash_, Some(5400n))

(* Failure because sender is not the updated user expiry *)
let test_failure_forbidden =
    let (tok, _, owners) = bootstrap(("2000-01-01t10:10:10Z" : timestamp), 3600n, 7200n) in
    let (owner1, owner2, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in
    let () = Test.set_source owner2_addr in
    let expiry_params : Token.expiry_params = (owner1_addr, (5400n, (None: bytes option))) in
    let r = Token_helper.set_expiry(expiry_params, tok.contr) in
    Assert.string_failure r Token.Errors.forbidden_expiry_update

(* Failure because tried to set value exceeding max_expiry *)
let test_failure_max_seconds_exceeded =
    let (tok, _, owners) = bootstrap(("2000-01-01t10:10:10Z" : timestamp), 3600n, 7200n) in
    let (owner1, owner2, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in
    let () = Test.set_source owner2_addr in
    let expiry_params : Token.expiry_params = (owner1_addr, (14_400n, (None: bytes option))) in
    let r = Token_helper.set_expiry(expiry_params, tok.contr) in
    Assert.string_failure r Token.Errors.max_seconds_exceeded




#import "./helpers/token.mligo" "Token_helper"
#import "./helpers/log.mligo" "Log"
#import "./helpers/assert.mligo" "Assert"
#import "./bootstrap/bootstrap.mligo" "Bootstrap"
#import "../src/main.mligo" "Token"

let () = Log.describe("[Transfer] test suite")

(* Boostrapping of the test environment, *)
let init_tok_amount = 10n
let bootstrap (init_ts, init_default_expiry, init_max_expiry : timestamp * nat * nat) =
    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(init_ts) in
    let base_extended_storage = Token_helper.get_initial_extended_storage(admin, init_default_expiry, init_max_expiry) in
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage) in
    (tok, admin, owners_with_keys)

(* Successful transfer with permit *)
let test_success =
    let (tok, _, owners) = bootstrap(("2000-01-01t10:10:10Z" : timestamp), 3600n, 7200n) in
    let (owner1, owner2, _) = owners in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in
    let transfer_request = ({
        from_=owner1_addr;
        txs=([{to_=owner2_addr;amount=2n;token_id=1n}] : Token.FA2.atomic_trans list)
    }) in
    let hash_ = Crypto.blake2b (Bytes.pack transfer_request) in
    let permit = Token_helper.make_permit(hash_, owner1, tok.addr, 0n) in
    let () = Token_helper.permit_success([permit], tok.contr) in
    let transfer_requests = ([transfer_request] : Token.FA2.transfer) in
    let () = Test.set_source owner2_addr in
    let () = Token_helper.transfer_success(transfer_requests, tok.contr) in
    let () = Token_helper.assert_balance(tok.taddr, owner1_addr, 1n, 8n) in
    let () = Token_helper.assert_balance(tok.taddr, owner2_addr, 1n, 2n) in
    Token_helper.assert_no_permit(tok.taddr, (owner1_addr, hash_))

(* Successful with permit expired but sender is operator *)
let test_success_by_operator_with_expired_permit =
    let init_default_expiry = 86_400n in
    let init_max_expiry = 259_200n in
    let now = ("2000-01-03t10:10:10Z" : timestamp) in
    let expired = ("2000-01-01t10:10:10Z" : timestamp) in

    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(now) in
    let (owner1, owner2, _) = owners_with_keys in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in
    let (op1, _, _) = ops in

    let transfer_request = ({
        from_=owner1_addr;
        txs=([{to_=owner2_addr;amount=2n;token_id=1n}] : Token.FA2.atomic_trans list)
    }) in
    let hash_ = Crypto.blake2b (Bytes.pack transfer_request) in

    let extended_storage = Token_helper.get_initial_extended_storage(admin, init_default_expiry, init_max_expiry) in
    let extended_storage = { extended_storage with
        permits = Big_map.literal [((owner1_addr, hash_), expired)];
        counter = 1n;
    } in

    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, extended_storage) in
    let () = Test.set_source op1 in
    let transfer_requests = ([transfer_request] : Token.FA2.transfer) in
    let () = Token_helper.transfer_success(transfer_requests, tok.contr) in
    let () = Token_helper.assert_balance(tok.taddr, owner1_addr, 1n, 8n) in
    Token_helper.assert_balance(tok.taddr, owner2_addr, 1n, 2n)

(* Failing because the permit has expired *)
let test_failure_expired_permit =
    let init_default_expiry = 86_400n in
    let init_max_expiry = 259_200n in
    let now = ("2000-01-03t10:10:10Z" : timestamp) in
    let expired = ("2000-01-01t10:10:10Z" : timestamp) in

    let (admin, owners, owners_with_keys, ops) = Bootstrap.boot_state(now) in
    let (owner1, owner2, _) = owners_with_keys in
    let (owner1_addr, _, _) = owner1 in
    let (owner2_addr, _, _) = owner2 in

    let transfer_request = ({
        from_=owner1_addr;
        txs=([{to_=owner2_addr;amount=2n;token_id=1n}] : Token.FA2.atomic_trans list)
    }) in
    let hash_ = Crypto.blake2b (Bytes.pack transfer_request) in

    let extended_storage = Token_helper.get_initial_extended_storage(admin, init_default_expiry, init_max_expiry) in
    let extended_storage = { extended_storage with
        permits = Big_map.literal [((owner1_addr, hash_), expired)];
        counter = 1n;
    } in

    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, extended_storage) in
    let () = Test.set_source owner2_addr in
    let r = Token_helper.transfer([transfer_request], tok.contr) in
    Assert.string_failure r Token.FA2.Errors.not_operator


Permit-Cameligo

Exemple of a permit contract in JsLIGO Resources

setAdmin

defaultExpiry

maxExpiry

userExpiries

permitExpiries

An example of permit contract (TZIP-17) written in jsligo

export const noOperation : list<operation> = list([])


export const requiresAdmin  = "NOT_AN_ADMIN";
export const tokenExist     = "TOKEN_ID_ALREADY_PRESENT";

// TZIP-17
export const dupPermit      = "DUP_PERMIT";
export const missigned       = "MISSIGNED";

export const maxSecondsExceeded = "MAX_SECONDS_EXCEEDED";
export const forbiddenExpiryUpdate = "FORBIDDEN_EXPIRY_UPDATE";

export const missingExpiry = "NO_EXPIRY_FOUND"

#import "./errors.jsligo" "Errors"
#import "./token_total_supply.jsligo" "TokenTotalSupply"

type seconds = nat;
export type permitKey = [address, bytes];
export type permits = big_map<permitKey, timestamp>;
export type userExpiries = big_map<address, option<seconds>>;
export type permitExpiries = big_map<permitKey, option<seconds>>;

export type t<a> = {
    admin: address,
    counter: nat,
    defaultExpiry: seconds,
    maxExpiry: seconds,
    permits: permits,
    userExpiries: userExpiries,
    permitExpiries: permitExpiries,
    extension : a
};

const get_user_defined_expiry =
<T>(from_: address, ext: t<T>): option<seconds> => {
    return match (Big_map.find_opt(from_, ext.userExpiries)) {
        when(None()): (Some(ext.defaultExpiry));
        when(Some(exp)): exp;
    };
};

const getExpiry =
<T>(ext: t<T>, paramPermitKey: permitKey): seconds => {
    return match ((Big_map.find_opt([paramPermitKey[0], paramPermitKey[1]], ext.permitExpiries) as option<option<seconds>>)) {
        when(None()): match ((Big_map.find_opt(paramPermitKey[0], ext.userExpiries) as option<option<seconds>>)) {
                    when(None()): ext.defaultExpiry;
                    when(Some(exp)): match (exp) {
                            when(None()): ext.defaultExpiry;
                            when(Some(t)): t;
                    };
        };
        when(Some(p)): match (p) {
                    when(None()): ext.defaultExpiry;
                    when(Some(exp)): exp;
            };
    }
};


export const assertAdmin =
<T>(ext : t<T>) =>
    assert_with_error((Tezos.get_sender() == ext.admin), Errors.requiresAdmin);

export const setAdmin =
<T>(ext: t<T>, admin: address): t<T> => {
    assertAdmin(ext);
    return { ...ext, admin : admin };
};

export const setExtension =
<T>(ext: t<T>, extension: T): t<T> => {
    return { ...ext, extension : extension };
};

export const addPermit =
<T>(ext: t<T>, paramPermitKey: permitKey): t<T> => {
    return { ...ext,
        permits : Big_map.add(paramPermitKey, Tezos.get_now(), ext.permits),
        counter : ext.counter + 1n
    }
};

export const updatePermit =
<T>(ext: t<T>, paramPermitKey: permitKey): t<T> => {
    return { ...ext,
        permits : Big_map.update(paramPermitKey, (Some(Tezos.get_now())), ext.permits),
        counter : ext.counter + 1n
    }
};

export const _checkNotExpired =
<T>(ext: t<T>, submissionTimestamp: timestamp, paramPermitKey: permitKey): unit => {
    const effectiveExpiry: seconds = getExpiry(ext, paramPermitKey);
    assert_with_error((abs (Tezos.get_now() - submissionTimestamp) >= effectiveExpiry), Errors.dupPermit);
};

export const transferPresigned =
<T>(ext: t<T>, paramPermitKey: permitKey): [bool, t<T>] => {
    let permitSubmitTime: timestamp =
        match (Big_map.find_opt(paramPermitKey, ext.permits)) {
            when(None()): (0 as timestamp);
            when(Some(exp)): exp
        };
    if (permitSubmitTime == (0 as timestamp)) {
        return [false, ext]
    } else {
        let effectiveExpiry =
            match (Big_map.find_opt(paramPermitKey, ext.permitExpiries)) {
                when(None()): match (Big_map.find_opt(paramPermitKey[0], ext.userExpiries)) {
                        when(None()): (Some(ext.defaultExpiry));
                        when(Some(exp)): exp;
                };
                when(Some(exp)): exp;
            };
        return match (effectiveExpiry) {
            when(None()): failwith(Errors.missingExpiry);
            when(Some(effective_exp)): do {
                let permits = Big_map.remove(paramPermitKey, ext.permits);
                let isAuthorised = abs ((Tezos.get_now()) - permitSubmitTime) < effective_exp;
                return [isAuthorised, { ...ext, permits : permits }]
            }
        };
    }
};


#import "ligo-extendable-fa2/lib/multi_asset/fa2.mligo" "FA2"
#import "./constants.jsligo" "Constants"
#import "./storage.jsligo" "Storage"
#import "./extension.jsligo" "Extension"
#import "./errors.jsligo" "Errors"
#import "./token_total_supply.jsligo" "TokenTotalSupply"

type gen_storage = Storage.t
type token_total_supply = TokenTotalSupply.t
export type storage = gen_storage<token_total_supply>

type result = [list<operation>, storage]

type gen_extension = Extension.t
export type extension = gen_extension<token_total_supply>

export type mintOrBurn =
// @layout:comb
{
   owner    : address,
   tokenId : nat,
   amount_  : nat,
};

export type permitParams = [key, [signature, bytes]];
export type expiryParams = [address, [nat, option<bytes>]];

@entry const create_token = (paramCreate: [FA2.TokenMetadata.data, address, nat], s: storage) : result => {
    let [metadata,owner,amount] = paramCreate;
    Extension.assertAdmin(s.extension);
    let md = Storage.addNewToken(s.token_metadata, metadata.token_id, metadata);
    let store = Storage.setTokenMetadata(s, md);
    let ledger = FA2.Ledger.increase_token_amount_for_user(s.ledger)(owner)(metadata.token_id)(amount);
    let newStore = FA2.Storage.set_ledger(store)(ledger);
    let supply = TokenTotalSupply.createSupply(newStore.extension.extension, metadata.token_id, amount);
    return [Constants.noOperation, { ...newStore, extension : Extension.setExtension(s.extension, supply) }]
};

@entry const mint_token = (lst: list<mintOrBurn>, s: storage) : result => {
    Extension.assertAdmin(s.extension);
    let processOne = ([ledgerAndSupply, paramMint] : [[FA2.Ledger.t, TokenTotalSupply.t], mintOrBurn]) : [FA2.Ledger.t, TokenTotalSupply.t] => {
        let [ledger,supply] = ledgerAndSupply;
        let {owner,tokenId,amount_} = paramMint;
        FA2.Storage.assert_token_exist(s)(tokenId);
        return [
            FA2.Ledger.increase_token_amount_for_user(ledger)(owner)(tokenId)(amount_),
            Extension.TokenTotalSupply.increaseSupply(supply, tokenId, amount_)
        ]
    };
    let [ledger, supply] = List.fold_left(processOne, [s.ledger, s.extension.extension], lst);
    let store = FA2.Storage.set_ledger(s)(ledger);
    return [Constants.noOperation, { ...store, extension : Extension.setExtension(s.extension, supply) }]
};

@entry const burn_token = (lst: list<mintOrBurn>, s: storage) : result => {
   Extension.assertAdmin(s.extension);
   let processOne = ([ledgerAndSupply, paramBurn] : [[FA2.Ledger.t, Extension.TokenTotalSupply.t], mintOrBurn]) : [FA2.Ledger.t, Extension.TokenTotalSupply.t] => {
      let [ledger,supply] = ledgerAndSupply;
      let {owner,tokenId,amount_} = paramBurn;
      return [
        FA2.Ledger.decrease_token_amount_for_user(ledger)(owner)(tokenId)(amount_),
        Extension.TokenTotalSupply.decreaseSupply(supply, tokenId, amount_)
      ]
    };
   let [ledger, supply] = List.fold_left(processOne, [s.ledger, s.extension.extension], lst);
   let store = FA2.Storage.set_ledger(s)(ledger);
   return [Constants.noOperation,{ ...store, extension : Extension.setExtension(s.extension, supply) }]
};

// TZIP-17
@entry const permit = (permits: list<permitParams>, s: storage) : result => {
    let processPermit = ([ext, permit] : [extension, permitParams]) : extension => {
        let [pub_key, [sig, hash_]] = permit;
        let packed = Bytes.pack ([[(Tezos.get_chain_id()), Tezos.get_self_address()], [ext.counter, hash_]]);
        if (Crypto.check(pub_key, sig, packed)) {
            let sender_ = Tezos.address (Tezos.implicit_account (Crypto.hash_key(pub_key)));
            let paramPermitKey = [sender_, hash_];
            let extModified = match (Big_map.find_opt(paramPermitKey, ext.permits)) {
                when(None()): Extension.addPermit(ext, paramPermitKey);
                when(Some(submission_timestamp)): do {
                    Extension._checkNotExpired(s.extension, submission_timestamp, paramPermitKey);
                    return Extension.updatePermit(ext, paramPermitKey)
                };
            };
            return extModified;
        } else {
            return (Michelson `{FAILWITH}` as ((n: [string, bytes]) => extension)) ([Errors.missigned, packed])
        }
    };
    let extension = List.fold_left(processPermit, s.extension, permits);
    return [Constants.noOperation, { ...s, extension : extension }]
};

// TZIP-17
@entry const setExpiry = (p: expiryParams, s: storage) : result => {
    let [userAddress, [seconds, permitHashOpt]] = p;
    let _checkMaxExpiry : unit = assert_with_error((seconds <= s.extension.maxExpiry), Errors.maxSecondsExceeded);
    let _checkSender : unit = assert_with_error((Tezos.get_sender() == userAddress), Errors.forbiddenExpiryUpdate);
    return match (permitHashOpt) {
        when(None()): [
                Constants.noOperation,
                {...s, extension : { ...s.extension,
                    userExpiries : Big_map.add(userAddress, (Some(seconds)), s.extension.userExpiries) }}
            ];
        when(Some(permit_hash)):[
                Constants.noOperation,
                { ...s, extension : {...s.extension, permitExpiries : Big_map.add(
                    [userAddress, permit_hash],
                    (Some(seconds)),
                    s.extension.permitExpiries)
                }}
            ];
    };
};

// TZIP-17 implementation of TZIP-12 Transfer
@entry const transfer = (transfer: FA2.transfer, s: storage) : result => {
     let makeTransfer = ([acc, transferFrom] : [[FA2.Ledger.t, extension], FA2.transfer_from]) : [FA2.Ledger.t, extension] => {
        let [ledger, extension] = acc;
        let transferFromHash = Crypto.blake2b(Bytes.pack(transferFrom));
        let permitKey : Extension.permitKey = [transferFrom.from_, transferFromHash];
        const [isTransferAuthorized, ext] = Extension.transferPresigned(extension, permitKey);
        const {from_, txs} = transferFrom;
        let applyTransfer = ([ledger, dst] : [FA2.Ledger.t, FA2.atomic_trans]) : FA2.Ledger.t => {
            let {token_id, amount, to_} = dst;
            FA2.Storage.assert_token_exist(s)(token_id);
            if (!isTransferAuthorized) {
                FA2.Operators.assert_authorisation(s.operators)(from_)(token_id);
                let ledgerModified = FA2.Ledger.decrease_token_amount_for_user(ledger)(from_)(token_id)(amount);
                let ledgerFinal = FA2.Ledger.increase_token_amount_for_user(ledgerModified)(to_)(token_id)(amount);
                return ledgerFinal
            } else {
                let ledgerModified = FA2.Ledger.decrease_token_amount_for_user(ledger)(from_)(token_id)(amount);
                let ledgerFinal = FA2.Ledger.increase_token_amount_for_user(ledgerModified)(to_)(token_id)(amount);
                return ledgerFinal
            }
        };
        let l = List.fold(applyTransfer, txs, ledger);
        return [l, ext]
    };
    let [newLedger, newExt] = List.fold(makeTransfer, transfer, [s.ledger, s.extension]);
    return [Constants.noOperation, { ...s, ledger : newLedger, extension : newExt }]
};

@entry const setAdmin = (addr: address, s: storage) : result => {
    return [Constants.noOperation, { ...s, extension : Extension.setAdmin(s.extension, addr) }]
};

@entry const balance_of = (p : FA2.balance_of, s : storage): result => FA2.balance_of(p)(s);
@entry const update_operators = (p : FA2.update_operators, s : storage): result => FA2.update_ops(p)(s);

//     Off-chain views required by TZIP-17
//     Command to run to get the micheline expressions to put in the metadata:
//     ligo compile expression cameligo '_get_counter' \
//         --init-file src/main.mligo \
//         --project-root . \
//         --michelson-format json

const getDefaultExpiry = ([_,s]: [unit, storage]) : nat => {
    return s.extension.defaultExpiry
};

const getCounter = ([_,s]: [unit, storage]) : nat => {
    return s.extension.counter
};


#import "ligo-extendable-fa2/lib/multi_asset/fa2.mligo" "FA2"
#import "./errors.jsligo" "Errors"
#import "./extension.jsligo" "Extension"

type storage = FA2.storage;
type extension = Extension.t;
export type t<a> = storage<extension<a>>;

const getTokenMetadata = <T>(s: t<T>): FA2.TokenMetadata.t => {
    return s.token_metadata
};

export const setTokenMetadata = 
<T>(s: t<T>, token_metadata: FA2.TokenMetadata.t): t<T> => {
    return {...s, token_metadata : token_metadata }
};

export const addNewToken = (md: FA2.TokenMetadata.t, tokenId: nat, data: FA2.TokenMetadata.data) : FA2.TokenMetadata.t => {
    assert_with_error((! (Big_map.mem(tokenId, md))), Errors.tokenExist);
    return Big_map.add(tokenId, data, md);
};


#import "ligo-extendable-fa2/lib/multi_asset/fa2.mligo" "FA2"

export type t = big_map<FA2.Ledger.token_id, nat>;

const getSupply = (supply: t, tokenId: FA2.Ledger.token_id) : nat =>
    match (Big_map.find_opt(tokenId, supply)) {
        when(Some(a)): a;
        when(None()): (failwith(FA2.Errors.undefined_token) as nat);
   }

export const createSupply = (supply: t, newTokenId: FA2.Ledger.token_id, amount_: nat) : t => {
    return Big_map.add(newTokenId, amount_, supply)
};

export const increaseSupply = (supply: t, tokenId: FA2.Ledger.token_id, amount_: nat) : t => {
    let curAmount = getSupply(supply, tokenId);
    let newAmount = curAmount + amount_;
    return Big_map.update(tokenId, (Some(newAmount)), supply)
};

export const decreaseSupply = (supply: t, tokenId: FA2.Ledger.token_id, amount_: nat) : t => {
    let curAmount = getSupply(supply, tokenId);
    let newSupply = abs(curAmount - amount_);
    return Big_map.update(tokenId, (Some(newSupply)), supply);
};


#import "../helpers/token.jsligo" "Token_helper"
#import "../helpers/fa2.jsligo" "FA2_helper"
#import "../../src/main.jsligo" "Token"

// Some dummy value when they don't matter for a given test
export const dummy_genesis_ts = ("2000-01-01t10:10:10Z" as timestamp);


// Boostrapping of the test environment,
// init_ts is the initial timestamp of the genesis block
export const boot_state = (init_ts : timestamp) :
    [address,
    [address, address, address],
    [[address, key, string], [address, key, string], [address, key, string]],
    [address, address, address]] => {
    Test.reset_state_at(init_ts, 7n, (list([10000000tez]) as list<tez>));

    // don't use 0 because it the baking account and may run out of tez
    let admin = Test.nth_bootstrap_account(6);

    let owners =
        [Test.nth_bootstrap_account(0),
        Test.nth_bootstrap_account(1),
        Test.nth_bootstrap_account(2)];

    let owners_with_keys =
        [Test.get_bootstrap_account(0n),
        Test.get_bootstrap_account(1n),
        Test.get_bootstrap_account(2n)];

    let ops =
        [Test.nth_bootstrap_account(3),
        Test.nth_bootstrap_account(4),
        Test.nth_bootstrap_account(5)];

    return [admin, owners, owners_with_keys, ops]
};

// Bootstrapping of the contract under test,
// init_tok_amount is the amount of token allocated to every
// bootstrapped accounts
export const boot_token =
(owners: [address, address, address],
 ops: [address, address, address],
 init_tok_amount: nat,
 init_extended_storage: Token.extension) : Token_helper.originated => {
    let initial_fa2_storage = FA2_helper.get_initial_storage(
        owners, ops, init_tok_amount
    );

    // supply matching initial ledger
    let supply : Token.TokenTotalSupply.t = Big_map.literal( list([
       [1n, init_tok_amount],
       [2n, (init_tok_amount * 2n)],
       [3n, init_tok_amount]
    ]));

    let init_storage = {
        metadata : Big_map.literal( list([
            ["", Bytes.pack("tezos-storage:contents")],
            ["contents", ("" as bytes)]
        ])),
        ledger         : initial_fa2_storage.ledger,
        token_metadata : initial_fa2_storage.token_metadata,
        operators      : initial_fa2_storage.operators,
        extension      : { ...init_extended_storage, extension : supply }
    };

    return Token_helper.originateFromFile(init_storage);
};


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/fa2.jsligo" "FA2_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "Token"

const _ = Log.describe("[Burn_token] test suite");

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = () : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(
      admin, Token_helper.dummyDefaultExpiry, Token_helper.dummyMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful token mint
const _test_success = () : unit => {
    let [tok, admin, owners] = bootstrap();
    let [[owner1_addr, _owner1_1, _owner1_2], _owner2, _owner3] = owners;
    Test.set_source (admin);
    let token_id = 1n;
    let amount_ = 6n;
    Token_helper.burnTokenSuccess(list([{
       owner:owner1_addr,
       tokenId:token_id,
       amount_:amount_
    }]), tok.contr);
    let new_amount =  abs(init_tok_amount - amount_);
    Token_helper.assertBalance(tok.taddr, owner1_addr, token_id, new_amount);
    Token_helper.assertSupply(tok.taddr, token_id, new_amount)
};

// Failure because sender is not current admin
const _test_failure_not_admin = () : unit => {
    let [tok, _, owners] = bootstrap();
    let [[owner1_addr, _owner1_1, _owner1_2], _owner2, _owner3] = owners;
    Test.set_source (owner1_addr);
    let r = Token_helper.burnToken(list([{
       owner:owner1_addr,
       tokenId:1n,
       amount_:1n
    }]), tok.contr);
    Assert.string_failure(r, Token.Errors.requiresAdmin)
};

const test_success : unit = _test_success();
const test_failure_not_admin : unit = _test_failure_not_admin();


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/fa2.jsligo" "FA2_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "Token"

const _ = Log.describe("[Create_token] test suite");

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = () : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(
      admin, Token_helper.dummyDefaultExpiry, Token_helper.dummyMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful token creation
const _test_success = () : unit => {
    let [tok, admin, owners] = bootstrap();
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source(admin);
    let token_id = 42n;
    let amount_ = 12n;
    Token_helper.createTokenSuccess
      (FA2_helper.get_dummy_token_data (token_id),
       owner1_addr, amount_, tok.contr);
    Token_helper.assertBalance(tok.taddr, owner1_addr, token_id, amount_);
    Token_helper.assertSupply(tok.taddr, token_id, amount_)
};

// Failure because token id already present
const _test_failure_token_exist = () : unit => {
    let [tok, admin, owners] = bootstrap();
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source (admin);
    let r = Token_helper.createToken
      (FA2_helper.get_dummy_token_data(1n),
       owner1_addr, 12n, tok.contr);
    Assert.string_failure(r, Token.Errors.tokenExist)
};

// Failure because sender is not current admin
const _test_failure_not_admin = () : unit => {
    let [tok, _, owners] = bootstrap();
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source (owner1_addr);
    let r = Token_helper.createToken
      (FA2_helper.get_dummy_token_data(42n),
       owner1_addr, 12n, tok.contr);
    Assert.string_failure(r, Token.Errors.requiresAdmin)
};

const test_success : unit = _test_success();
const test_failure_token_exist : unit = _test_failure_token_exist();
const test_failure_not_admin : unit = _test_failure_not_admin();


// Assert contract call results in failwith with given string
export const string_failure = (res: test_exec_result, expected: string) : unit => {
    let expect = Test.eval(expected);
    return match (res) {
        when(Fail(x)):
            match (x) {
                when(Rejected(x)): assert (Test.michelson_equal (x[0], expect));
                when(Balance_too_low(_)): Test.failwith("contract failed: balance too low");
                when(Other(s)): Test.failwith (s);
            };
        when(Success(_)): Test.failwith("Transaction should fail");
    };
};

// Assert contract result is successful
export const tx_success = (res: test_exec_result) : unit => {
    return match (res) {
        when(Success(_)): unit;
        when(Fail(x)):
            match (x) {
                when(Rejected(x)): do {
                    Test.log(x[0]);
                    return Test.failwith("Transaction should not fail")
                };
                when(Balance_too_low(_)): Test.failwith("Transaction should not fail");
                when(Other(_)): Test.failwith("Transaction should not fail");
            };
    }
}


#import "../../src/main.jsligo" "Token"

type common_storage = {
    ledger : Token.FA2.Ledger.t,
    token_metadata : Token.FA2.TokenMetadata.t,
    operators : Token.FA2.Operators.t
}

const dummy_token_info = (Map.empty as map<string, bytes>);

export const get_dummy_token_data = (token_id : nat) : Token.FA2.TokenMetadata.data => {
   return { token_id: token_id, token_info: dummy_token_info};
};


// Get the initial storage of FA2
// init_tok_amount is the amount of token allocated to every owner account
export const get_initial_storage =
(owners: [address, address,  address], ops: [address, address, address], init_tok_amount: nat): common_storage => {
    let [owner1, owner2, owner3] = owners;
    let [op1, _op2, op3] = ops;

    let ledger = Big_map.literal( list([
        [[owner1, 1n], init_tok_amount],
        [[owner2, 2n], init_tok_amount],
        [[owner3, 3n], init_tok_amount],
        [[owner1, 2n], init_tok_amount]
    ]));

    let operators  = Big_map.literal( list([
        [[owner1, op1], Set.literal(list([1n, 2n]))],
        [[owner2, op1], Set.literal(list([2n]))],
        [[owner3, op1], Set.literal(list([3n]))],
        [[op1   , op3], Set.literal(list([2n]))]
    ]));

    let token_metadata : Token.FA2.TokenMetadata.t = Big_map.literal( list([
        [1n, get_dummy_token_data(1n)],
        [2n, get_dummy_token_data(2n)],
        [3n, get_dummy_token_data(3n)]
    ]));

    return {
        ledger         : ledger,
        token_metadata : token_metadata,
        operators      : operators
    }
};


// Return str repeated n times
const repeat = (str: string, n: nat) : string => {
    let loop = (n: nat, acc: string) : string => {
        if (n == 0n) {
            return acc;
        } else {
            return loop (abs(n - 1n), acc + str)
        }
    };
    return loop(n, "")
};
 
    // Log boxed lbl

    // "+-----------+"
    // "| My string |"
    // "+-----------+"

export const describe = (lbl : string) : unit => {
    let hr = "+" + repeat("-", String.length(lbl) + 2n) + "+"; 
    Test.log (hr);
    Test.log ("| " + lbl + " |");
    Test.log (hr);
}


#import "../../src/main.jsligo" "Token"
#import "./assert.jsligo" "Assert"

// Some types for readability
type taddr = typed_address<parameter_of Token, Token.storage>;
type contr = contract<parameter_of Token>;
export type originated = {
    addr: address,
    taddr: taddr,
    //owners: address list;
    contr: contr
};

type initial_extended_storage = {
    admin : address,
    counter : nat,
    defaultExpiry : nat,
    maxExpiry : nat,
    permits : Token.Extension.permits,
    userExpiries : Token.Extension.userExpiries,
    permitExpiries : Token.Extension.permitExpiries,
    extension : Token.Extension.TokenTotalSupply.t
};

// Some dummy values when they don't matter for a given test
export const dummyDefaultExpiry = 0n;
export const dummyMaxExpiry = 0n;

export const getInitialExtendedStorage = (admin: address, initDefaultExpiry: nat, initMaxExpiry: nat) : initial_extended_storage => {
    return {
        admin : admin,
        counter : 0n,
        defaultExpiry : initDefaultExpiry,
        maxExpiry : initMaxExpiry,
        permits : (Big_map.empty as Token.Extension.permits),
        userExpiries : (Big_map.empty as Token.Extension.userExpiries),
        permitExpiries : (Big_map.empty as Token.Extension.permitExpiries),
        extension : (Big_map.empty as Token.TokenTotalSupply.t)
    };
};

// Originate a Token contract with given init_storage storage
export const originate = (init_storage: Token.storage) : originated => {
    let [taddr, _c, _n] = Test.originate_module(contract_of(Token), init_storage, 0tez);
    let contr = Test.to_contract (taddr);
    let addr = Tezos.address (contr);
    return { addr : addr, taddr : taddr, contr : contr };
};

export const originateFromFile = (init_storage : Token.storage) : originated => {
    let f = "../../src/main.jsligo";
    let v_mich = Test.run( ((x: Token.storage) => x), init_storage);
    let [addr, _c, _n] = Test.originate_from_file(f, v_mich, 0tez);
    let taddr : taddr = Test.cast_address (addr);
    let contr = Test.to_contract (taddr);
    return {addr : addr, taddr : taddr, contr : contr}
};


// Make a permit with given packed params and secret key
// The chain_id is equal to 0x00000000 in the test framework
export const makePermit = (hash_: bytes, account: [address, key, string], token_addr: address, counter: nat) : Token.permitParams => {
    let [_, pubKey, secretKey] = account;
    let packed = Bytes.pack ([[0x00000000, token_addr], [counter, hash_]]);
    let sig = Test.sign(secretKey, packed);
    return [pubKey, [sig, hash_]]
};

// Call entry point of Token contr contract
const call = (p: parameter_of Token, contr: contr) : test_exec_result =>
    Test.transfer_to_contract(contr, p, 0mutez)

export const permit = (p: list<Token.permitParams>, contr: contr) : test_exec_result =>
    call(Permit(p), contr)

export const setExpiry = (p: Token.expiryParams, contr: contr) : test_exec_result =>
    call(SetExpiry(p), contr)

export const setAdmin = (p: address, contr: contr) : test_exec_result =>
    call(SetAdmin(p), contr)

export const transfer = (p: Token.FA2.transfer, contr: contr) : test_exec_result => {
    let param : parameter_of Token = Transfer(p);
    return call(param, contr)
};

export const createToken = (md: Token.FA2.TokenMetadata.data, owner: address, amount: nat, contr: contr) : test_exec_result =>
    call(Create_token([md, owner, amount]), contr);

export const mintToken = (p: list<Token.mintOrBurn>, contr: contr) : test_exec_result =>
    call(Mint_token(p), contr)

export const burnToken = (p: list<Token.mintOrBurn>, contr: contr) : test_exec_result =>
    call(Burn_token(p), contr)

export const permitSuccess = (p: list<Token.permitParams>, contr: contr) : unit =>
    Assert.tx_success (permit(p, contr))

export const setExpirySuccess = (p: Token.expiryParams, contr: contr) : unit =>
    Assert.tx_success (setExpiry(p, contr))

export const setAdminSuccess = (p: address, contr: contr) : unit =>
    Assert.tx_success (setAdmin(p, contr))

export const transferSuccess = (p: Token.FA2.transfer, contr: contr) : unit =>
    Assert.tx_success (transfer(p, contr))

export const createTokenSuccess = (md: Token.FA2.TokenMetadata.data, owner: address, amount: nat, contr: contr) : unit =>
    Assert.tx_success (createToken(md, owner, amount, contr))

export const mintTokenSuccess = (p: list<Token.mintOrBurn>, contr: contr) : unit =>
    Assert.tx_success (mintToken(p, contr))

export const burnTokenSuccess = (p: list<Token.mintOrBurn>, contr: contr) : unit => {
    Assert.tx_success (burnToken(p, contr));
};

// Assert Token contract at [taddr] has permit with [address, hash] key
export const assertHasPermit = (taddr: taddr, paramPermitKey: Token.Extension.permitKey) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt(paramPermitKey, s.extension.permits)) {
        when(Some(_)): unit;
        when(None()): Test.failwith("Permits Big_map key should not be missing");
    }
};

// Assert Token contract at [taddr] has no permit with [address, hash] key
export const assertNoPermit = (taddr: taddr, paramPermitKey: Token.Extension.permitKey) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt(paramPermitKey, s.extension.permits)) {
        when(Some(_)): Test.failwith("Permits Big_map key should be None");
        when(None()): unit;
    }
};

// Assert Token contract at [taddr] has counter equals to [counter]
export const assertCounter = (taddr: taddr, counter: nat) : unit => {
    let s = Test.get_storage (taddr);
    assert_with_error( (s.extension.counter == counter), "Counter does not have expected value");
};

// Assert Token contract at [taddr] has user expiry for [userAddr] equal to [seconds]
export const assertUserExpiry = (taddr: taddr, userAddr: address, seconds: option<nat>) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt(userAddr, s.extension.userExpiries)) {
        when(Some(s)): assert (s == seconds);
        when(None()): Test.failwith("User epiries Big_map key should not be missing");
    }
};

// Assert Token contract at [taddr] has user permit expiry for [userAddr] and
// hash [hash_] equal to [seconds]
export const assertPermitExpiry = (taddr: taddr, userAddr: address, hash_: bytes, seconds: option<nat>) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt([userAddr, hash_], s.extension.permitExpiries)) {
        when(Some(s)): assert (s == seconds);
        when(None()): Test.failwith("Permit epiries Big_map key should not be missing");
    }
};

// assert Token contract at [taddr] have [owner] address with [amount_] tokens in its ledger
export const assertBalance = (taddr: taddr, owner: address, tokenId: nat, amount_: nat) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt([owner, tokenId], s.ledger)) {
        when(Some(tokens)): assert(tokens == amount_);
        when(None()): Test.failwith("Big_map key should not be missing");
    }
};

// assert Token contract at [taddr] have tokenTotalSupply for [tokenId] matching [amount_]
export const assertSupply = (taddr: taddr, tokenId: Token.FA2.Ledger.token_id, amount_: nat) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt(tokenId, s.extension.extension)) {
        when(Some(tokens)): assert(tokens == amount_);
        when(None()): Test.failwith("Big_map key should not be missing");
    }
};


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/fa2.jsligo" "FA2_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "Token"

const _ = Log.describe("[Mint_token] test suite");

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = () : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(
      admin, Token_helper.dummyDefaultExpiry, Token_helper.dummyMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful token mint
const _test_success = () : unit => {
    let [tok, admin, owners] = bootstrap();
    let [[owner1_addr, _owner1_1, _owner1_2], _owner2, _owner3] = owners;
    Test.set_source (admin);
    let token_id = 1n;
    let amount_ = 56n;
    Token_helper.mintTokenSuccess(list([{
       owner: owner1_addr,
       tokenId: token_id,
       amount_: amount_
    }]), tok.contr);
    let new_amount =  init_tok_amount + amount_;
    Token_helper.assertBalance(tok.taddr, owner1_addr, token_id, new_amount);
    Token_helper.assertSupply(tok.taddr, token_id, new_amount);
};

// Failure because sender is not current admin
const _test_failure_not_admin = () : unit => {
    let [tok, _, owners] = bootstrap();
    let [[owner1_addr, _owner1_1, _owner1_2], _owner2, _owner3] = owners;
    Test.set_source (owner1_addr);
    let r = Token_helper.mintToken(list([{
       owner: owner1_addr,
       tokenId: 1n,
       amount_: 1n,
    }]), tok.contr);
    Assert.string_failure(r, Token.Errors.requiresAdmin)
}

const test_success : unit = _test_success();
const test_failure_not_admin : unit = _test_failure_not_admin();


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "Token"

const _ = Log.describe("[Permit] test suite");

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = (init_ts: timestamp, initDefaultExpiry: nat, initMaxExpiry: nat) : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(init_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful permit creation
const _test_success_add_permit_one = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    let transfer_requests : Token.FA2.transfer = list([{
                from_:owner1_addr,
                txs: (list([{
                    to_:owner2_addr,
                    amount:2n,
                    token_id:1n}]) as list<Token.FA2.atomic_trans>)
            }]);
    let hash_ = Crypto.blake2b (Bytes.pack(transfer_requests));
    let permit = Token_helper.makePermit(hash_, owner1, tok.addr, 0n);
    Token_helper.permitSuccess(list([permit]), tok.contr);
    Token_helper.assertHasPermit(tok.taddr, [owner1_addr, hash_]);
    Token_helper.assertCounter(tok.taddr, 1n)
};

// Successful successive permit creation
const _test_success_add_permit_list = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n,7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    let transfer_requests : Token.FA2.transfer = list([
        {
            from_: owner1_addr,
            txs: list([
                {to_:owner2_addr, amount:2n, token_id:1n}
            ])
        }
    ]);
    let hash_ = Crypto.blake2b (Bytes.pack(transfer_requests));
    let permit1 = Token_helper.makePermit(hash_, owner1, tok.addr,0n);
    let transfer_requests2 : Token.FA2.transfer = list([
        {
            from_:owner2_addr,
            txs: list([
                { to_:owner1_addr, amount:2n, token_id:1n}
            ])
        }
    ]);
    let hash_2 = Crypto.blake2b (Bytes.pack (transfer_requests2));
    let permit2 = Token_helper.makePermit(hash_2, owner2, tok.addr,1n);
    Token_helper.permitSuccess(list([permit1, permit2]), tok.contr);
    Token_helper.assertHasPermit(tok.taddr, [owner2_addr, hash_2]);
    Token_helper.assertCounter(tok.taddr,2n)
};

// Successful permit update
const _test_success_update_permit = () : unit => {
    let initDefaultExpiry = 86_400n;
    let initMaxExpiry = 259_200n;
    let now = ("2000-01-03t10:10:10Z" as timestamp);
    let expired = ("2000-01-01t10:10:10Z" as timestamp);

    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(now);
    let [owner1, owner2, _owner3] = owners_with_keys;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;

    let transfer_requests : Token.FA2.transfer = list([
        ({from_: owner1_addr, txs: list([{to_:owner2_addr, amount:2n, token_id:1n}])})
    ]);
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_requests));

    let extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let extended_storage_modified = { ...extended_storage,
        permits : Big_map.literal (list([[
            [owner1_addr, hash_], expired
            ]])),
        counter : 1n
    };

    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, extended_storage_modified);
    let permit = Token_helper.makePermit(hash_, owner1, tok.addr,1n);
    Token_helper.permitSuccess(list([permit]), tok.contr);
    Token_helper.assertHasPermit(tok.taddr, [owner1_addr, hash_])
};

// Failing permit update because it alredy exists and has not expired
const _test_success_update_permit_already_exist = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp),3600n,7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    let transfer_requests : Token.FA2.transfer = list([
        ({from_:owner1_addr, txs: list([{to_:owner2_addr, amount:2n, token_id:1n}])})
    ]);
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_requests));
    let permit = Token_helper.makePermit(hash_, owner1, tok.addr,0n);
    Token_helper.permitSuccess(list([permit]), tok.contr);
    let permit2 = Token_helper.makePermit(hash_, owner1, tok.addr,1n);
    let r = Token_helper.permit(list([permit2]), tok.contr);
    Assert.string_failure(r, Token.Errors.dupPermit)
};

const test_success_add_permit_one : unit = _test_success_add_permit_one();
const test_success_add_permit_list : unit = _test_success_add_permit_list();
const test_success_update_permit : unit = _test_success_update_permit();
const test_success_update_permit_already_exist : unit = _test_success_update_permit_already_exist();


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "Token"

const _ = Log.describe("[Set_admin] test suite");

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = () : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(
      admin, Token_helper.dummyDefaultExpiry, Token_helper.dummyMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful setting of admin
const _test_success_set_admin = (_: unit) : unit => {
    let [tok, admin, owners] = bootstrap();
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source(admin);
    Token_helper.setAdminSuccess(owner1_addr, tok.contr);
    let s = Test.get_storage(tok.taddr);
    assert (s.extension.admin == owner1_addr)
};

// Failure because sender is not current admin
const _test_failure_not_admin = (_: unit) : unit => {
    let [tok,_admin, owners] = bootstrap();
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let r = Token_helper.setAdmin(owner1_addr, tok.contr);
    Assert.string_failure(r, Token.Errors.requiresAdmin)
};

const test_success_set_admin : unit = _test_success_set_admin();
const test_failure_not_admin : unit = _test_failure_not_admin();


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "Token"

const _ = Log.describe("[SetExpiry] test suite");

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = (init_ts: timestamp, initDefaultExpiry: nat, initMaxExpiry: nat) : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(init_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful setting of user expiry
const _test_success_set_user_expiry = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source (owner1_addr);
    let expiryParams : Token.expiryParams = [owner1_addr, [5400n, (None() as option<bytes>)]];
    Token_helper.setExpirySuccess(expiryParams, tok.contr);
    Token_helper.assertUserExpiry(tok.taddr, owner1_addr, Some(5400n))
};

// Successful setting of permit expiry
const _test_success_set_permit_expiry = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source (owner1_addr);
    let hash_ = 0x01;
    let expiryParams : Token.expiryParams = [owner1_addr, [5400n, (Some(hash_))]];
    Token_helper.setExpirySuccess(expiryParams, tok.contr);
    Token_helper.assertPermitExpiry(tok.taddr, owner1_addr, hash_, Some(5400n));
};

// Failure because sender is not the updated user expiry
const _test_failure_forbidden = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    Test.set_source (owner2_addr);
    let expiryParams : Token.expiryParams = [owner1_addr, [5400n, (None() as option<bytes>)]];
    let r = Token_helper.setExpiry(expiryParams, tok.contr);
    Assert.string_failure(r, Token.Errors.forbiddenExpiryUpdate)
};

// Failure because tried to set value exceeding maxExpiry
const _test_failure_max_seconds_exceeded = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    Test.set_source (owner2_addr);
    let expiryParams : Token.expiryParams = [owner1_addr, [14_400n, (None() as option<bytes>)]];
    let r = Token_helper.setExpiry(expiryParams, tok.contr);
    Assert.string_failure(r, Token.Errors.maxSecondsExceeded)
};

const test_success_set_user_expiry : unit = _test_success_set_user_expiry();
const test_success_set_permit_expiry : unit = _test_success_set_permit_expiry();
const test_failure_forbidden : unit = _test_failure_forbidden();
const test_failure_max_seconds_exceeded : unit = _test_failure_max_seconds_exceeded();


#import "./helpers/token.jsligo" "Token_helper"
#import "./helpers/log.jsligo" "Log"
#import "./helpers/assert.jsligo" "Assert"
#import "./bootstrap/bootstrap.jsligo" "Bootstrap"
#import "../src/main.jsligo" "Token"

const _ = Log.describe("[Transfer] test suite");

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = (init_ts: timestamp, initDefaultExpiry: nat, initMaxExpiry: nat) : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(init_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful transfer with permit
const _test_success = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    let transfer_request : Token.FA2.transfer_from = {
        from_:owner1_addr,
        txs:list([{to_:owner2_addr, amount:2n, token_id:1n}])
    };
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_request));
    let permit = Token_helper.makePermit(hash_, owner1, tok.addr, 0n);
    Token_helper.permitSuccess(list([permit]), tok.contr);
    let transfer_requests  : Token.FA2.transfer = list([transfer_request]);
    Test.set_source (owner2_addr);
    Token_helper.transferSuccess(transfer_requests, tok.contr);
    Token_helper.assertBalance(tok.taddr, owner1_addr, 1n, 8n);
    Token_helper.assertBalance(tok.taddr, owner2_addr, 1n, 2n);
    Token_helper.assertNoPermit(tok.taddr, [owner1_addr, hash_])
};

// Successful with permit expired but sender is operator
const _test_success_by_operator_with_expired_permit = () : unit => {
    let initDefaultExpiry = 86_400n;
    let initMaxExpiry = 259_200n;
    let now = ("2000-01-03t10:10:10Z" as timestamp);
    let expired = ("2000-01-01t10:10:10Z" as timestamp);

    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(now);
    let [owner1, owner2, _owner3] = owners_with_keys;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    let [op1, _op2, _op3] = ops;

    let transfer_request : Token.FA2.transfer_from = {
        from_:owner1_addr,
        txs:list([{to_:owner2_addr, amount:2n, token_id:1n}])
    };
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_request));

    let extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let extended_storage_modified = { ...extended_storage,
        permits : Big_map.literal(list([ [[owner1_addr, hash_], expired] ])),
        counter : 1n
    };

    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, extended_storage_modified);
    Test.set_source (op1);
    let transfer_requests : Token.FA2.transfer = list([transfer_request]);
    Token_helper.transferSuccess(transfer_requests, tok.contr);
    Token_helper.assertBalance(tok.taddr, owner1_addr, 1n, 8n);
    Token_helper.assertBalance(tok.taddr, owner2_addr, 1n, 2n);
};

// Failing because the permit has expired
const _test_failure_expired_permit = () : unit => {
    let initDefaultExpiry = 86_400n;
    let initMaxExpiry = 259_200n;
    let now = ("2000-01-03t10:10:10Z" as timestamp);
    let expired = ("2000-01-01t10:10:10Z" as timestamp);

    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(now);
    let [owner1, owner2, _owner3] = owners_with_keys;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;

    let transfer_request = ({
        from_:owner1_addr,
        txs:list([{to_:owner2_addr, amount:2n, token_id:1n}])
    });
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_request));

    let extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let extended_storage_modified = { ...extended_storage,
        permits : Big_map.literal(list([
            [[owner1_addr, hash_], expired]
        ])),
        counter : 1n
    };

    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, extended_storage_modified);
    Test.set_source (owner2_addr);
    let r = Token_helper.transfer(list([transfer_request]), tok.contr);
    Assert.string_failure(r, Token.FA2.Errors.not_operator)
};

const test_success : unit = _test_success();
const test_success_by_operator_with_expired_permit : unit = _test_success_by_operator_with_expired_permit();
const test_failure_expired_permit : unit = _test_failure_expired_permit();


Permit-JsLIGO

Exemple of a NFT Factory contract in CameLIGO

name

token_ids

token_metas

generateCollection

nothing

all_collections

owned_collections

(** 
   This file implement the TZIP-12 protocol (a.k.a FA2) for NFT on Tezos
   copyright Wulfman Corporation 2021
*)

#import "errors.mligo" "Errors"
#import "address.mligo" "Address"
#import "operators.mligo" "Operators"
#import "tokenMetadata.mligo" "TokenMetadata"
#import "ledger.mligo" "Ledger"
#import "storage.mligo" "Storage"

type storage = Storage.t

(** Transfer entrypoint *)
type atomic_trans = [@layout:comb] {
   to_      : Address.t;
   token_id : nat;
}

type transfer_from = {
   from_ : Address.t;
   tx    : atomic_trans list
}
type transfer = transfer_from list

let transfer (type a) (t:transfer) (s:a storage) : operation list * a storage = 
   (* This function process the "tx" list. Since all transfer share the same "from_" address, we use a se *)
   let process_atomic_transfer (from_:Address.t) (ledger, t:Ledger.t * atomic_trans) =
      let {to_;token_id} = t in
      let ()     = Storage.assert_token_exist s token_id in
      let ()     = Operators.assert_authorisation s.operators from_ token_id in
      let ledger = Ledger.transfer_token_from_user_to_user ledger token_id from_ to_ in
      ledger
   in
   let process_single_transfer (ledger, t:Ledger.t * transfer_from ) =
      let {from_;tx} = t in
      let ledger     = List.fold_left (process_atomic_transfer from_) ledger tx in
      ledger
   in
   let ledger = List.fold_left process_single_transfer s.ledger t in
   let s = Storage.set_ledger s ledger in
   ([] : operation list), s
   
type request = {
   owner    : Address.t;
   token_id : nat;
}

type callback = [@layout:comb] {
   request : request;
   balance : nat;
}

type balance_of = [@layout:comb] {
   requests : request list;
   callback : callback list contract;
}

(** Balance_of entrypoint *)
let balance_of (type a) (b: balance_of) (s: a storage) : operation list * a storage =
   let {requests;callback} = b in
   let get_balance_info (request : request) : callback =
      let {owner;token_id} = request in
      let balance_ = Storage.get_balance s owner token_id in
      {request=request;balance=balance_}
   in
   let callback_param = List.map get_balance_info requests in
   let operation = Tezos.transaction callback_param 0tez callback in
   ([operation]: operation list),s

(** Update_operators entrypoint *)
type operator = [@layout:comb] {
   owner    : Address.t;
   operator : Address.t;
   token_id : nat; 
}
type unit_update      = Add_operator of operator | Remove_operator of operator
type update_operators = unit_update list

let update_ops (type a) (updates: update_operators) (s: a storage) : operation list * a storage =
   let update_operator (operators,update : Operators.t * unit_update) = match update with 
      Add_operator    {owner=owner;operator=operator;token_id=token_id} -> Operators.add_operator    operators owner operator token_id
   |  Remove_operator {owner=owner;operator=operator;token_id=token_id} -> Operators.remove_operator operators owner operator token_id
   in
   let operators = Storage.get_operators s in
   let operators = List.fold_left update_operator operators updates in
   let s = Storage.set_operators s operators in
   ([]: operation list),s

[@view] let get_balance (type a) (p, s : (Address.t * nat) * a storage) : nat = 
      let (owner, token_id) = p in
      let balance_ = Storage.get_balance s owner token_id in
      balance_

[@view] let total_supply (type a) ((token_id, s) : (nat * a storage)):  nat =
      let () = Storage.assert_token_exist s token_id in
      1n

[@view] let all_tokens (type a) ((_, s) : (unit * a storage)): nat list =
   s.token_ids
   
[@view] let is_operator (type a) ((op, s) : (operator * a storage)): bool =
      Operators.is_operator (s.operators, op.owner, op.operator, op.token_id)

[@view] let token_metadata (type a) ((p, s) : (nat * a storage)): TokenMetadata.data = 
      TokenMetadata.get_token_metadata p s.token_metadata

(** 
   This file implement the TZIP-12 protocol (a.k.a FA2) for NFT on Tezos
   copyright Wulfman Corporation 2021
*)

type t = address

[@no_mutation] let equal (a : t) (b : t) = a = b

type t = string

let undefined_token = "FA2_TOKEN_UNDEFINED"
let ins_balance     = "FA2_INSUFFICIENT_BALANCE"
let no_transfer     = "FA2_TX_DENIED"
let not_owner       = "FA2_NOT_OWNER"
let not_operator    = "FA2_NOT_OPERATOR"
let not_supported   = "FA2_OPERATORS_UNSUPPORTED"
let rec_hook_fail   = "FA2_RECEIVER_HOOK_FAILED"
let send_hook_fail  = "FA2_SENDER_HOOK_FAILED"
let rec_hook_undef  = "FA2_RECEIVER_HOOK_UNDEFINED"
let send_hook_under = "FA2_SENDER_HOOK_UNDEFINED"

let only_sender_manage_operators = "The sender can only manage operators for his own token"
let only_admin = "FA2_NOT_ADMIN"

(** 
   This file implement the TZIP-12 protocol (a.k.a FA2) for NFT on Tezos
   copyright Wulfman Corporation 2021
*)

#import "errors.mligo" "Errors"
#import "address.mligo" "Address"

type token_id = nat
type owner = Address.t
type t = (token_id,owner) big_map

let is_owner_of (ledger:t) (token_id : token_id) (owner: Address.t) : bool =
   (** We already sanitized token_id, a failwith here indicated a patological storage *)
   let current_owner = Option.unopt (Big_map.find_opt token_id ledger) in
   Address.equal current_owner owner

let assert_owner_of (ledger:t) (token_id : token_id) (owner: Address.t) : unit =
   assert_with_error (is_owner_of ledger token_id owner) Errors.ins_balance

let transfer_token_from_user_to_user (ledger : t) (token_id : token_id) (from_ : owner) (to_ : owner) : t = 
   let () = assert_owner_of ledger token_id from_ in
   let ledger = Big_map.update token_id (Some to_) ledger in
   ledger 

(** 
This file implement the TZIP-12 protocol (a.k.a FA2) for NFT on Tezos
copyright Wulfman Corporation 2021
*)

#import "errors.mligo" "Errors"
#import "address.mligo" "Address"

type owner    = Address.t
type operator = Address.t
type token_id = nat
type t = ((owner * operator), token_id set) big_map

(** if transfer policy is Owner_or_operator_transfer *)
let assert_authorisation (operators : t) (from_ : Address.t) (token_id : nat) : unit = 
   let sender_ = Tezos.get_sender () in
   if (Address.equal sender_ from_) then ()
   else 
   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 transfer policy is Owner_transfer
let assert_authorisation (operators : t) (from_ : Address.t) : unit = 
   let sender_ = Tezos.get_sender () in
   if (sender_ = from_) then ()
   else failwith Errors.not_owner
*)

(** if transfer policy is No_transfer
let assert_authorisation (operators : t) (from_ : Address.t) : unit = 
   failwith Errors.no_owner
*)

let is_operator (operators, owner, operator, token_id : (t * Address.t * Address.t * nat)) : bool =
   let authorized = match Big_map.find_opt (owner,operator) operators with
      Some (a) -> a | None -> Set.empty in
   (owner = operator || Set.mem token_id authorized)

let assert_update_permission (owner : owner) : unit =
   assert_with_error (Address.equal owner (Tezos.get_sender ())) Errors.only_sender_manage_operators

let add_operator (operators : t) (owner : owner) (operator : operator) (token_id : token_id) : t =
   if owner = operator then operators (* assert_authorisation always allow the owner so this case is not relevant *)
   else
      let () = assert_update_permission owner in
      let auth_tokens = match Big_map.find_opt (owner,operator) operators with
         Some (ts) -> ts | None -> Set.empty in
      let auth_tokens  = Set.add token_id auth_tokens in
      Big_map.update (owner,operator) (Some auth_tokens) operators
      
let remove_operator (operators : t) (owner : owner) (operator : operator) (token_id : token_id) : t =
   if owner = operator then operators (* assert_authorisation always allow the owner so this case is not relevant *)
   else
      let () = assert_update_permission owner in
      let auth_tokens = match Big_map.find_opt (owner,operator) operators with
      None -> None | Some (ts) ->
         let ts = Set.remove token_id ts in
         [@no_mutation] let is_empty = Set.cardinal ts = 0n in 
         if is_empty then None else Some (ts)
      in
      Big_map.update (owner,operator) auth_tokens operators

(** 
   This file implement the TZIP-12 protocol (a.k.a FA2) for NFT on Tezos
   copyright Wulfman Corporation 2021
*)

#import "errors.mligo" "Errors"
#import "address.mligo" "Address"
#import "operators.mligo" "Operators"
#import "tokenMetadata.mligo" "TokenMetadata"
#import "ledger.mligo" "Ledger"

type token_id = nat
type 'a t = {
   ledger : Ledger.t;
   token_metadata : TokenMetadata.t;
   operators : Operators.t;
   token_ids : token_id list;
   extension : 'a;
}

let is_owner_of (type a) (s:a t) (owner : Address.t) (token_id : token_id) : bool = 
   Ledger.is_owner_of s.ledger token_id owner

let assert_token_exist (type a) (s:a t) (token_id : nat) : unit  = 
   let _ = Option.unopt_with_error (Big_map.find_opt token_id s.token_metadata)
      Errors.undefined_token in
   ()

let set_ledger (type a) (s:a t) (ledger:Ledger.t) = {s with ledger = ledger}

let get_operators (type a) (s:a t) = s.operators
let set_operators (type a) (s:a t) (operators:Operators.t) = {s with operators = operators}

let get_balance (type a) (s:a t) (owner : Address.t) (token_id : nat) : nat =
   let ()       = assert_token_exist s token_id in 
   if is_owner_of s owner token_id then 1n else 0n

(** 
   This file implement the TZIP-12 protocol (a.k.a FA2) for NFT on Tezos
   copyright Wulfman Corporation 2021
*)

#import "errors.mligo" "Errors"

(**
   This should be initialized at origination, conforming to either 
   TZIP-12 : https://gitlab.com/tezos/tzip/-/blob/master/proposals/tzip-12/tzip-12.md#token-metadata
   or TZIP-16 : https://gitlab.com/tezos/tzip/-/blob/master/proposals/tzip-12/tzip-12.md#contract-metadata-tzip-016 
*)
type data = {token_id:nat;token_info:(string,bytes)map}
type t = (nat, data) big_map 

let get_token_metadata (token_id : nat) (tm : t) =
   match Big_map.find_opt token_id tm with
      Some data -> data
   | None -> failwith Errors.undefined_token

let helper_add_global_metadata(acc , elt : (t * (string, bytes)map) * nat) : (t * (string, bytes)map) = 
   let current_metadata = match Big_map.find_opt elt acc.0 with
   | None -> (failwith(Errors.undefined_token) : data)
   | Some c -> c
   in
   let add_field(infos, field: (string, bytes)map * (string * bytes)) : (string, bytes)map = 
         match Map.find_opt field.0 infos with
         | None -> Map.add field.0 field.1 infos
         | Some _old -> infos 
   in
   let modified_current_token_info = Map.fold add_field acc.1 current_metadata.token_info in
   let modified_current_metadata : data = { current_metadata with token_info=modified_current_token_info } in
   (Big_map.update elt (Some(modified_current_metadata)) acc.0, acc.1)

let add_global_metadata (token_ids : nat list) (metadatas : t) (global_metadatas : (string, bytes) map) : t =
   let result, _gl_metas = List.fold helper_add_global_metadata token_ids (metadatas, global_metadatas) in
   result


#import "../common/errors.mligo" "Errors"
#import "../common/address.mligo" "Address"
#import "../common/storage.mligo" "Storage"
#import "../common/ledger.mligo" "Ledger"
#import "../common/tokenMetadata.mligo" "TokenMetadata"
#import "../common/NFT.mligo" "NFT"

(*
   Specialization corner
*)

module TokenUsage = struct 
   type token_id = nat
   type t = (token_id, nat) big_map

   let update_usage_token (usage : t) (token_id : token_id) : t = 
      match Big_map.find_opt token_id usage with
      | None -> (failwith("This token is not initialized in usage map") : t)
      | Some old -> Big_map.update token_id (Some (old + 1n)) usage 

   let get_token_usage (token_id : nat) (tu : t) =
      match Big_map.find_opt token_id tu with
         Some data -> data
      | None -> failwith Errors.undefined_token
end

type extension = {
   admin : Address.t;
   token_usage : TokenUsage.t;
}

type storage = Storage.t

let set_usage (s:extension storage) (usage:TokenUsage.t) =
   let e = s.extension in
   let e = { e with token_usage = usage } in
   {s with extension =e }

let get_usage_of (s:extension storage) (token_id : Storage.token_id) : nat =
   match (Big_map.find_opt token_id s.extension.token_usage) with
   | None -> (failwith(Errors.undefined_token) : nat)
   | Some nb_trsfr -> nb_trsfr

let authorize_extension (s:extension storage): unit =
   assert_with_error (Tezos.get_sender () = s.extension.admin) Errors.only_admin

let transfer_extension (t: NFT.transfer) (s:extension storage): operation list * extension storage =
   let process_atomic_usage (usage, t:TokenUsage.t * NFT.atomic_trans) = TokenUsage.update_usage_token usage t.token_id in
   let update_usage_single_transfer (usage, t:TokenUsage.t * NFT.transfer_from ) = List.fold process_atomic_usage t.tx usage in
   let usage = List.fold update_usage_single_transfer t s.extension.token_usage in
   let s = set_usage s usage in
   ([]: operation list),s


type mint_param = [@layout:comb] {
   ids : Storage.token_id list;
   metas : (Storage.token_id, (string, bytes) map) big_map
}

let mint (param: mint_param) (s: extension storage) : operation list * extension storage =
   // update token_ids
   let add_id(acc, id : nat list * nat) : nat list = id :: acc in
   let new_token_ids : nat list = List.fold add_id param.ids s.token_ids in
   
   // update ledger
   let set_token_owner (acc, elt : Ledger.t * Storage.token_id) : Ledger.t = Big_map.add elt (Tezos.get_sender ()) acc in
   let new_ledger : Ledger.t = List.fold set_token_owner param.ids s.ledger in
   
   // update token_metadata
   let add_token (acc, elt : (TokenMetadata.t * (Storage.token_id, (string, bytes) map) big_map) * Storage.token_id) : (TokenMetadata.t * (Storage.token_id, (string, bytes) map) big_map) =
      let current_token_info : (string, bytes) map = match Big_map.find_opt elt acc.1 with
      | None -> (failwith("Missing token_info") :(string, bytes) map)
      | Some ti -> ti
      in
      let current_metadata : TokenMetadata.data = { token_id=elt; token_info=current_token_info } in
      (Big_map.add elt current_metadata acc.0, acc.1)
   in
   let new_token_metadata, _ = List.fold add_token param.ids (s.token_metadata, param.metas) in
   ([]: operation list), { s with token_ids=new_token_ids; ledger=new_ledger; token_metadata=new_token_metadata }



type parameter = [@layout:comb] 
| Transfer of NFT.transfer
| Balance_of of NFT.balance_of 
| Update_operators of NFT.update_operators 
| Mint of mint_param

[@entry]
[@inline]
let main (p :parameter) (s : extension storage) : operation list * extension storage = 
match p with
   Transfer         p -> let o1, s = NFT.transfer p s in
                         let o2, s = transfer_extension p s in
                         let o = List.fold_left (fun ((a,x):operation list * operation) -> x :: a) o2 o1 in
                         o, s
|  Balance_of       p -> NFT.balance_of p s
|  Update_operators p -> NFT.update_ops p s
|  Mint             p -> let _ = authorize_extension s in 
                         mint p s

[@view] let token_usage (p : nat) (s : extension storage): nat =
      TokenUsage.get_token_usage p s.extension.token_usage

[@view] let get_balance (p : Address.t * nat) (s : extension storage) : nat = 
      let (owner, token_id) = p in
      let balance_ = NFT.Storage.get_balance s owner token_id in
      balance_

[@view] let total_supply (token_id : nat) (s : extension storage) :  nat =
      let () = NFT.Storage.assert_token_exist s token_id in
      1n

[@view] let all_tokens (_ : unit) (s : extension storage) : nat list =
   s.token_ids
   
[@view] let is_operator (op : NFT.operator) (s : extension storage) : bool =
      NFT.Operators.is_operator (s.operators, op.owner, op.operator, op.token_id)

[@view] let token_metadata (p : nat) (s : extension storage) : NFT.TokenMetadata.data = 
      NFT.TokenMetadata.get_token_metadata p s.token_metadata

#import "storage.mligo" "Storage"
#import "parameter.mligo" "Parameter"
#import "generic_fa2/core/instance/NFT.mligo" "NFT_FA2"

type storage = Storage.t
type parameter = Parameter.t
type return = operation list * storage

type store = NFT_FA2.Storage.t
type ext = NFT_FA2.extension
type ext_storage = ext store

let generateCollection(param, store : Parameter.generate_collection_param * Storage.t) : return = 
    // create new collection
    let token_ids = param.token_ids in
    let sender = Tezos.get_sender () in
    let ledger = (Big_map.empty : NFT_FA2.Storage.Ledger.t) in
    let myfunc(acc, elt : NFT_FA2.Storage.Ledger.t * nat) : NFT_FA2.Storage.Ledger.t = Big_map.add elt sender acc in
    let new_ledger : NFT_FA2.Storage.Ledger.t = List.fold myfunc token_ids ledger in

    let token_usage = (Big_map.empty : NFT_FA2.TokenUsage.t) in
    let initial_usage(acc, elt : NFT_FA2.TokenUsage.t * nat) : NFT_FA2.TokenUsage.t = Big_map.add elt 0n acc in
    let new_token_usage = List.fold initial_usage token_ids token_usage in

    let token_metadata = param.token_metas in
    let operators = (Big_map.empty : NFT_FA2.Storage.Operators.t) in
    

    let initial_storage : ext_storage = {
        ledger=new_ledger;
        operators=operators;
        token_ids=token_ids;
        token_metadata=token_metadata;
        extension = {
          admin=sender;
          token_usage=new_token_usage;
        }
    }  in 

    let initial_delegate : key_hash option = (None: key_hash option) in
    let initial_amount : tez = 1tez in
    let create_my_contract = [%create_contract_of_file "generic_fa2/compiled/fa2_nft.tz"] in
    let originate : operation * address = create_my_contract initial_delegate initial_amount initial_storage in
    // insert into collections
    let new_all_collections = Big_map.add originate.1 sender store.all_collections in
    // insert into owned_collections
    let new_owned_collections = match Big_map.find_opt sender store.owned_collections with
    | None -> Big_map.add sender ([originate.1]: address list) store.owned_collections
    | Some addr_lst -> Big_map.update sender (Some(originate.1 :: addr_lst)) store.owned_collections
    in
    ([originate.0], { store with all_collections=new_all_collections; owned_collections=new_owned_collections})

[@entry]
let main (ep : parameter) (store : storage) : return =
    match ep with 
    | GenerateCollection(p) -> generateCollection(p, store)
    | Nothing -> (([] : operation list), store)


let unknownViewGetBalance : string = "unknown view get_balance."
let unknownViewTokenUsage : string = "unknown view token_usage."
let not_owner : string = "Not owner of this token"
let unknown_fa2_contract : string = "Unknown FA2 contract"
let unknown_proposal : string = "Unknown proposal"
let proposal_not_active : string = "Already sold"
let wrong_amount : string = "You did not transfer enough tez for this nft"

#import "storage.mligo" "Storage"
#import "errors.mligo" "Errors"
#import "parameter.mligo" "Parameter"
#import "../generic_fa2/core/instance/NFT.mligo" "NFT_FA2"

type storage = Storage.t
type parameter = Parameter.t
type return = operation list * storage

let create_sell_proposal(param, store : Parameter.sell_proposal_param * Storage.t) : return = 
    // check if sender is the owner of the nft token
    let balanceOpt : nat option = Tezos.call_view "get_balance" (Tezos.get_sender (), param.token_id) param.collectionContract in
    let balanceVal : nat = match balanceOpt with
    | None -> (failwith(Errors.unknownViewGetBalance) : nat)
    | Some (v) -> v
    in
    let usageOpt : nat option = Tezos.call_view "token_usage" param.token_id param.collectionContract in
    let usageVal : nat = match usageOpt with
    | None -> (failwith(Errors.unknownViewTokenUsage) : nat)
    | Some (v) -> v
    in
    let _check_owner : unit = assert_with_error (balanceVal = 1n) Errors.not_owner in
    // Add new proposal
    let new_proposals = Big_map.add store.next_sell_id { owner=Tezos.get_sender (); token_id=param.token_id; collectionContract=param.collectionContract; active=true; price=param.price; hasard_level=usageVal } store.sell_proposals in
    let new_next_sell_id : nat = store.next_sell_id + 1n in 
    let new_active_proposals : nat set = Set.add store.next_sell_id store.active_proposals in 

    (([] : operation list), { store with next_sell_id=new_next_sell_id; sell_proposals=new_proposals; active_proposals=new_active_proposals })


let accept_proposal(param, store : Parameter.buy_param * Storage.t) : return =
    let _check_among_active_proposals : unit = assert_with_error (Set.mem param.proposal_id store.active_proposals) Errors.proposal_not_active in 
    let propal : Storage.sell_proposal = match Big_map.find_opt param.proposal_id store.sell_proposals with
    | None -> (failwith(Errors.unknown_proposal) : Storage.sell_proposal)
    | Some pr -> pr
    in
    let _check_status : unit = assert_with_error(propal.active) Errors.proposal_not_active in
    let _check_amount : unit = assert_with_error(propal.price = (Tezos.get_amount ())) Errors.wrong_amount in
    
    let new_propal = { propal with active=false } in
    let new_active_proposals : nat set = Set.remove param.proposal_id store.active_proposals in
    let new_proposals = Big_map.update param.proposal_id (Some(new_propal)) store.sell_proposals in

    // transfer Tez to owner
    let dest_opt : unit contract option = Tezos.get_contract_opt propal.owner in
    let destination : unit contract = match dest_opt with
    | None -> (failwith("Unknwon owner"): unit contract) 
    | Some c -> c
    in
    let op : operation = Tezos.transaction unit (Tezos.get_amount ()) destination in
    
    // transfer Nft to new_owner
    let collection_transfer_dest_opt : NFT_FA2.NFT.transfer contract option = Tezos.get_entrypoint_opt "%transfer" propal.collectionContract in
    let collection_transfer_dest : NFT_FA2.NFT.transfer contract = match collection_transfer_dest_opt with
    | None -> (failwith(Errors.unknown_fa2_contract): NFT_FA2.NFT.transfer contract) 
    | Some ct -> ct
    in
    let nft_transfer : NFT_FA2.NFT.transfer = [{from_=propal.owner; tx=[{to_=Tezos.get_sender (); token_id=propal.token_id}]}] in
    let op2 : operation = Tezos.transaction nft_transfer 0mutez collection_transfer_dest in
    
    ([op; op2;], { store with sell_proposals=new_proposals; active_proposals=new_active_proposals })

[@entry]
let main (ep : parameter) (store : storage) : return =
    match ep with 
    | Sell p -> create_sell_proposal(p, store)
    | Buy p -> accept_proposal(p, store)

[@view] let get_proposal (p : nat) (s : storage) : Storage.sell_proposal = 
      match Big_map.find_opt p s.sell_proposals with 
      | None -> (failwith("") : Storage.sell_proposal)
      | Some prop -> prop 

[@view] let active_proposals (_ : unit) (s : storage) : nat list = 
        Set.fold (fun(acc, i : nat list * nat) -> i :: acc) s.active_proposals ([] : nat list)
          



type sell_proposal_param = {
    token_id : nat;
    collectionContract : address;
    price : tez;
}

type buy_param = {
    proposal_id : nat
}

type t = Sell of sell_proposal_param | Buy of buy_param

type collectionContract = address
type collectionOwner = address

type sell_proposal = {
    owner : address;
    token_id : nat;
    collectionContract : collectionContract;
    active : bool;
    price : tez;
    hasard_level : nat;
} 

type t = {
    next_sell_id : nat;
    active_proposals : nat set;
    sell_proposals : (nat, sell_proposal) big_map
}



#import "generic_fa2/core/instance/NFT.mligo" "NFT_FA2"

type generate_collection_param = {
    name : string;
    token_ids : nat list;
    token_metas : NFT_FA2.NFT.TokenMetadata.t
}

type t = GenerateCollection of generate_collection_param | Nothing of unit

type collectionContract = address
type collectionOwner = address

type t = {
    all_collections : (collectionContract, collectionOwner) big_map;
    owned_collections : (collectionOwner, collectionContract list) big_map;
    metadata: (string, bytes) big_map;
}

let initial_storage () = {
    all_collections = (Big_map.empty : (collectionContract, collectionOwner) big_map);
    owned_collections = (Big_map.empty : (collectionOwner, collectionContract list) big_map);
    metadata = (Big_map.empty : (string, bytes) big_map);
}



#import "../src/main.mligo" "Factory"

type fa2_storage = Factory.NFT_FA2.Storage.t
type ext = Factory.NFT_FA2.extension
type ext_fa2_storage = ext fa2_storage

let assert_string_failure (res : test_exec_result) (expected : string) : unit =
  let expected = Test.eval expected in
  match res with
  | Fail (Rejected (actual,_)) -> assert (Test.michelson_equal actual expected)
  | Fail (Balance_too_low _) -> failwith "contract failed: balance too low"
  | Fail (Other s) -> failwith s
  | Success _gas -> failwith "contract did not failed but was expected to fail"

let test =
    // setup 4 accounts 
    let () = Test.reset_state 4n ([] : tez list) in
    let alice: address = Test.nth_bootstrap_account 0 in
    let bob: address = Test.nth_bootstrap_account 1 in
    let steven: address = Test.nth_bootstrap_account 2 in
    let _frank: address = Test.nth_bootstrap_account 3 in

    // originate Factory smart contract
    let init_storage : Factory.Storage.t = { 
        all_collections=(Big_map.empty : (Factory.Storage.collectionContract, Factory.Storage.collectionOwner) big_map);
        owned_collections=(Big_map.empty : (Factory.Storage.collectionOwner, Factory.Storage.collectionContract list) big_map);
        metadata=(Big_map.empty: (string, bytes) big_map);
    } in
    let (addr,_,_) = Test.originate Factory.main init_storage 0tez in

    let _generates_collection_1_should_works = 
        let () = Test.log("_generates_collection_1_should_works") in

        let x : Factory.parameter contract = Test.to_contract addr in

        // prepare arguments for generating a new collection
        let token_ids : nat list = [1n] in
        let token_info_1 = (Map.literal[
            ("QRcode", 0x623d82eff132);
        ] : (string, bytes) map) in
        let token_metadata = (Big_map.literal [
            (1n, ({token_id=1n;token_info=token_info_1;} : Factory.NFT_FA2.NFT.TokenMetadata.data));
        ] : Factory.NFT_FA2.NFT.TokenMetadata.t) in

        // call GenerateCollection entrypoint
        let () = Test.set_source alice in
        let gencol_args : Factory.Parameter.generate_collection_param = {name="alice_collection_1"; token_ids=token_ids; token_metas=token_metadata} in
        let _ = Test.transfer_to_contract_exn x (GenerateCollection(gencol_args)) 1000000mutez in

        // verify FA2 has been created
        let s : Factory.storage = Test.get_storage addr in
        let colls : address list = match Big_map.find_opt alice s.owned_collections with
        | None -> ([] : address list)
        | Some x -> x
        in
        let owned_coll_size = List.fold (fun(acc, _elt : nat * address) : nat -> acc + 1n) colls 0n in
        //let owned_coll_size : nat = Set.size colls in 
        assert (owned_coll_size = 1n)
    in
    let _mint_token2_collection_1_should_works = 
        let () = Test.log("_mint_token2_collection_1_should_works") in
        //let x : Factory.parameter contract = Test.to_contract addr in

        // Retrieve address of collection 1
        let s_before : Factory.storage = Test.get_storage addr in
        let colls_before : address list = match Big_map.find_opt alice s_before.owned_collections with
        | None -> ([] : address list)
        | Some oc -> oc
        in
        //let colls_before_list : address list = Set.fold (fun(acc, i : address list * address) -> i :: acc) colls_before ([] : address list) in
        let address1 : address = Option.unopt (List.head_opt colls_before) in

        // prepare mint arguments
        //let () = Test.log("alice mint token 2 in collection 1") in
        let extra_token_id : nat = 2n in
        let extra_token_ids : nat list = [extra_token_id] in
        let extra_token_info = (Map.literal[ ("QRcode", 0x6269c0f1a821); ] : (string, bytes) map) in
        let extra_token_metadata = (Big_map.literal [ (extra_token_id, extra_token_info); ] : (nat, (string, bytes) map) big_map) in

        // call MINT
        let () = Test.set_source alice in
        let taddr1 = (Test.cast_address address1 : (Factory.NFT_FA2.parameter, ext_fa2_storage) typed_address) in
        let fa2_1 : Factory.NFT_FA2.parameter contract = Test.to_contract taddr1 in
        let mint_args : Factory.NFT_FA2.mint_param = { ids=extra_token_ids; metas=extra_token_metadata } in
        let _ = Test.transfer_to_contract_exn fa2_1 (Mint(mint_args)) 0mutez in

        // verify token2 is created and owned by alice
        //let () = Test.log("check new token 2") in
        let fa2_1_s : ext_fa2_storage = Test.get_storage taddr1 in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_1_s alice 2n) in
        "OK"
    in
    let _mint_token3_collection_1_should_fail = 
        let () = Test.log("_mint_token3_collection_1_should_fail") in

        let _x : Factory.parameter contract = Test.to_contract addr in

        // Retrieve address of collection 1
        let s_before : Factory.storage = Test.get_storage addr in
        let colls_before : address list = match Big_map.find_opt alice s_before.owned_collections with
        | None -> ([] : address list)
        | Some oc -> oc
        in
        //let colls_before_list : address list = Set.fold (fun(acc, i : address list * address) -> i :: acc) colls_before ([] : address list) in
        let address1 : address = Option.unopt (List.head_opt colls_before) in

        // prepare mint arguments
        //let () = Test.log("alice mint token 3 in collection 1") in
        let extra_token_id : nat = 3n in
        let extra_token_qrcode : bytes = 0x92a77bf1a4c5 in
        let extra_token_ids : nat list = [extra_token_id] in
        let extra_token_info = (Map.literal[ ("QRcode", extra_token_qrcode); ] : (string, bytes) map) in
        let extra_token_metadata = (Big_map.literal [ (extra_token_id, extra_token_info); ] : (nat, (string, bytes) map) big_map) in

        // call MINT
        let () = Test.set_source bob in
        let taddr1 = (Test.cast_address address1 : (Factory.NFT_FA2.parameter, ext_fa2_storage) typed_address) in
        let fa2_1 : Factory.NFT_FA2.parameter contract = Test.to_contract taddr1 in
        let mint_args : Factory.NFT_FA2.mint_param = { ids=extra_token_ids; metas=extra_token_metadata } in
        let fail_mint_token3 = Test.transfer_to_contract fa2_1 (Mint(mint_args)) 0mutez in
        assert_string_failure fail_mint_token3 Factory.NFT_FA2.Errors.only_admin
    in
    let _generates_collection_2_with_5_tokens_should_works = 
        let () = Test.log("_generates_collection_2_with_5_tokens_should_works") in
        // check existing collections
        let s_before : Factory.storage = Test.get_storage addr in
        let colls_before : address list = match Big_map.find_opt alice s_before.owned_collections with
        | None -> ([] : address list)
        | Some x -> x
        in
        //let colls_before_list : address list = Set.fold (fun(acc, i : address list * address) -> i :: acc) colls_before ([] : address list) in
        let address1 : address = Option.unopt (List.head_opt colls_before) in

        let x : Factory.parameter contract = Test.to_contract addr in

        //let () = Test.log("alice generates a collection 2") in
        let () = Test.set_source alice in
 
        // set new collection 2
        let token_ids : nat list = [1n; 2n; 3n ;4n; 5n] in

        // add specific metadata for each token
        let token_info_1 = (Map.literal[ ("QRcode", 0x623d82eff132); ] : (string, bytes) map) in
        let token_info_2 = (Map.literal[ ("QRcode", 0x49aa82eff132); ] : (string, bytes) map) in
        let token_info_3 = (Map.literal[ ("QRcode", 0xab3442eff132); ] : (string, bytes) map) in
        let token_info_4 = (Map.literal[ ("QRcode", 0xdeadbeefdead); ] : (string, bytes) map) in
        let token_info_5 = (Map.literal[ ("QRcode", 0xdeadbeefbeef); ] : (string, bytes) map) in

        let token_metadata = (Big_map.literal [
            (1n, ({token_id=1n;token_info=token_info_1;} : Factory.NFT_FA2.NFT.TokenMetadata.data));
            (2n, ({token_id=2n;token_info=token_info_2;} : Factory.NFT_FA2.NFT.TokenMetadata.data));
            (3n, ({token_id=3n;token_info=token_info_3;} : Factory.NFT_FA2.NFT.TokenMetadata.data));
            (4n, ({token_id=4n;token_info=token_info_4;} : Factory.NFT_FA2.NFT.TokenMetadata.data));
            (5n, ({token_id=5n;token_info=token_info_5;} : Factory.NFT_FA2.NFT.TokenMetadata.data));
        ] : Factory.NFT_FA2.NFT.TokenMetadata.t) in

        // add global metadatas to all tokens
        let collection_name_bytes : bytes = Bytes.pack "Pietrus 2022" in
        let global_metadatas : (string, bytes) map = (Map.literal[ ("collection", collection_name_bytes)] : (string, bytes) map) in 
        let new_token_metadata = Factory.NFT_FA2.NFT.TokenMetadata.add_global_metadata token_ids token_metadata global_metadatas in

        // generate collection
        let gencol_args : Factory.Parameter.generate_collection_param = {name="alice_collection_1"; token_ids=token_ids; token_metas=new_token_metadata} in
        let _ = Test.transfer_to_contract_exn x (GenerateCollection(gencol_args)) 1000000mutez in

        let s : Factory.storage = Test.get_storage addr in
        // verify number of collections
        let colls : address list = match Big_map.find_opt alice s.owned_collections with
        | None -> ([] : address list)
        | Some x -> x
        in
        //let owned_coll_size : nat = Set.size colls in 
        let owned_coll_size = List.fold (fun(acc, _elt : nat * address) : nat -> acc + 1n) colls 0n in
        let () = assert (owned_coll_size = 2n) in

        let parse_metas(acc, elt : (address, (nat list * Factory.NFT_FA2.NFT.TokenMetadata.t))big_map * address) : (address, (nat list * Factory.NFT_FA2.NFT.TokenMetadata.t))big_map = 
            let taddr = (Test.cast_address elt : (Factory.NFT_FA2.parameter, ext_fa2_storage) typed_address) in
            let fa2_store : ext_fa2_storage = Test.get_storage taddr in
            Big_map.add elt (fa2_store.token_ids, fa2_store.token_metadata) acc
        in
        let all_tokens : (address, (nat list * Factory.NFT_FA2.NFT.TokenMetadata.t))big_map = List.fold parse_metas colls (Big_map.empty : (address, (nat list * Factory.NFT_FA2.NFT.TokenMetadata.t) )big_map) in 
        
        // Retrieve collection 2 address
        //let colls_list : address list = Set.fold (fun(acc, i : address list * address) -> i :: acc) colls ([] : address list) in
        // find address of collection 2
        let get_next_address(lst, blacklist : address list * address list) : address =
            let filter(acc, elt : (address list * address list) * address) : (address list * address list) = 
                let is_in_list(res, i : (bool * address) * address) : (bool * address) = if res.0 then res else (i = res.1, res.1) in
                let is_blacklisted, _ = List.fold is_in_list acc.1 (false, elt) in
                if is_blacklisted then acc else (elt :: acc.0, acc.1) 
            in
            let filtered_list, _ = List.fold filter lst (([] : address list), blacklist) in
            Option.unopt (List.head_opt filtered_list) 
        in
        let address2 : address = get_next_address(colls, colls_before) in

        // verify token_ids of collection 1
        let collection1_info : nat list * Factory.NFT_FA2.NFT.TokenMetadata.t = match Big_map.find_opt address1 all_tokens with
        | None -> (failwith("No metadata for collection 1") : nat list * Factory.NFT_FA2.NFT.TokenMetadata.t)
        | Some info -> info
        in
        //let () = Test.log(collection1_info.0) in
        let () = assert(collection1_info.0 = [2n; 1n]) in
        // verify token_ids of collection 2 
        let collection2_info : nat list * Factory.NFT_FA2.NFT.TokenMetadata.t = match Big_map.find_opt address2 all_tokens with
        | None -> (failwith("No metadata for collection 2") : nat list * Factory.NFT_FA2.NFT.TokenMetadata.t)
        | Some info -> info
        in
        let () = assert(collection2_info.0 = [1n; 2n; 3n; 4n; 5n]) in 
        // verify metadata of token 3 of collection 2
        let collection2_metas : Factory.NFT_FA2.NFT.TokenMetadata.t = collection2_info.1 in
        let collection2_metas_tok3 : Factory.NFT_FA2.NFT.TokenMetadata.data = match Big_map.find_opt 3n collection2_metas with
        | None -> (failwith("No token 3 in this collection") : Factory.NFT_FA2.NFT.TokenMetadata.data)
        | Some info -> info
        in
        let () = assert(collection2_metas_tok3.token_info = (Map.literal[ ("QRcode", 0xab3442eff132); ("collection", collection_name_bytes)] : (string, bytes) map)) in
        // verify metadata of token 4 of collection 2
        let collection2_metas_tok4 : Factory.NFT_FA2.NFT.TokenMetadata.data = match Big_map.find_opt 4n collection2_metas with
        | None -> (failwith("No token 4 in this collection") : Factory.NFT_FA2.NFT.TokenMetadata.data)
        | Some info -> info
        in
        let () = assert(collection2_metas_tok4.token_info = (Map.literal[ ("QRcode", 0xdeadbeefdead); ("collection", collection_name_bytes)] : (string, bytes) map)) in
        "OK" 
    in
    let _transfer_token1_collection_2_should_works = 
        let () = Test.log("_transfer_token1_collection_2_should_works") in
        // retrieve address collection 2
        let s_before : Factory.storage = Test.get_storage addr in
        let colls_before : address list = match Big_map.find_opt alice s_before.owned_collections with
        | None -> ([] : address list)
        | Some x -> x
        in
        let address2 : address = Option.unopt (List.head_opt colls_before) in

        let () = Test.log("alice transfer tok 1 to bob") in 
        let () = Test.set_source alice in
        let taddr2 = (Test.cast_address address2 : (Factory.NFT_FA2.parameter, ext_fa2_storage) typed_address) in
        let fa2_2 : Factory.NFT_FA2.parameter contract = Test.to_contract taddr2 in
        let transfer1_args : Factory.NFT_FA2.NFT.transfer = [{ from_=alice; tx=[{to_=bob;token_id=1n}] }] in
        let _ = Test.transfer_to_contract_exn fa2_2 (Transfer(transfer1_args)) 0mutez in

        let fa2_2_s : ext_fa2_storage = Test.get_storage taddr2 in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_2_s bob 1n) in
        let () = assert(Factory.NFT_FA2.get_usage_of fa2_2_s 1n = 1n) in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_2_s alice 2n) in 
        let () = assert(Factory.NFT_FA2.get_usage_of fa2_2_s 2n = 0n) in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_2_s alice 3n) in
        let () = assert(Factory.NFT_FA2.get_usage_of fa2_2_s 3n = 0n) in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_2_s alice 4n) in
        let () = assert(Factory.NFT_FA2.get_usage_of fa2_2_s 4n = 0n) in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_2_s alice 5n) in
        let () = assert(Factory.NFT_FA2.get_usage_of fa2_2_s 5n = 0n) in

        let () = Test.log("bob transfer tok 1 to steven") in 
        let () = Test.set_source bob in
        let fa2_2 : Factory.NFT_FA2.parameter contract = Test.to_contract taddr2 in
        let transfer1_args : Factory.NFT_FA2.NFT.transfer = [{ from_=bob; tx=[{to_=steven;token_id=1n}] }] in
        let _ = Test.transfer_to_contract_exn fa2_2 (Transfer(transfer1_args)) 0mutez in

        let fa2_2_s : ext_fa2_storage = Test.get_storage taddr2 in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_2_s steven 1n) in
        let () = assert(Factory.NFT_FA2.get_usage_of fa2_2_s 1n = 2n) in
        "OK" 
    in
    ()


#import "../src/main.mligo" "Factory"
#import "../src/marketplace/main.mligo" "Marketplace"

type fa2_storage = Factory.NFT_FA2.Storage.t
type ext = Factory.NFT_FA2.extension
type ext_fa2_storage = ext fa2_storage

let assert_string_failure (res : test_exec_result) (expected : string) : unit =
  let expected = Test.eval expected in
  match res with
  | Fail (Rejected (actual,_)) -> assert (Test.michelson_equal actual expected)
  | Fail (Balance_too_low _) -> failwith "contract failed: balance too low"
  | Fail (Other s) -> failwith s
  | Success _gas -> failwith "contract did not failed but was expected to fail"

let test =
    // setup 4 accounts 
    let () = Test.reset_state 4n ([] : tez list) in
    let alice: address = Test.nth_bootstrap_account 0 in
    let bob: address = Test.nth_bootstrap_account 1 in
    let _steven: address = Test.nth_bootstrap_account 2 in
    let _frank: address = Test.nth_bootstrap_account 3 in

    // originate Factory smart contract
    let init_storage : Factory.Storage.t = { 
        all_collections=(Big_map.empty : (Factory.Storage.collectionContract, Factory.Storage.collectionOwner) big_map);
        owned_collections=(Big_map.empty : (Factory.Storage.collectionOwner, Factory.Storage.collectionContract list) big_map);
        metadata=(Big_map.empty: (string, bytes) big_map);
    } in
    let (addr,_,_) = Test.originate Factory.main init_storage 0tez in

    // originate Marketplace smart contract
    let marketplace_init_storage : Marketplace.Storage.t = { 
        next_sell_id=0n;
        active_proposals=(Set.empty : nat set);
        sell_proposals=(Big_map.empty : (nat, Marketplace.Storage.sell_proposal) big_map);
    } in
    let (marketplace_taddr,_,_) = Test.originate Marketplace.main marketplace_init_storage 0tez in


    let _generates_collection_1_should_works = 
        let () = Test.log("_generates_collection_1_should_works") in

        let x : Factory.parameter contract = Test.to_contract addr in

        // prepare arguments for generating a new collection
        let token_ids : nat list = [1n] in
        let token_info_1 = (Map.literal[
            ("QRcode", 0x623d82eff132);
        ] : (string, bytes) map) in
        let token_metadata = (Big_map.literal [
            (1n, ({token_id=1n;token_info=token_info_1;} : Factory.NFT_FA2.Storage.TokenMetadata.data));
        ] : Factory.NFT_FA2.Storage.TokenMetadata.t) in

        // call GenerateCollection entrypoint
        let () = Test.set_source alice in
        let gencol_args : Factory.Parameter.generate_collection_param = {name="alice_collection_1"; token_ids=token_ids; token_metas=token_metadata} in
        let _ = Test.transfer_to_contract_exn x (GenerateCollection(gencol_args)) 1000000mutez in

        // verify FA2 has been created
        let s : Factory.storage = Test.get_storage addr in
        let colls : address list = match Big_map.find_opt alice s.owned_collections with
        | None -> ([] : address list)
        | Some x -> x
        in
        let owned_coll_size = List.fold (fun(acc, _elt : nat * address) : nat -> acc + 1n) colls 0n in
        let () = assert (owned_coll_size = 1n) in


        let () = Test.log("_marketplace_sell_token1_should_works") in
        // retrieve address collection
        let s_before : Factory.storage = Test.get_storage addr in
        let colls_before : address list = match Big_map.find_opt alice s_before.owned_collections with
        | None -> ([] : address list)
        | Some x -> x
        in
        let fa2_address : address = Option.unopt (List.head_opt colls_before) in
        let taddr_fa2_address = (Test.cast_address fa2_address : (Factory.NFT_FA2.parameter, ext_fa2_storage) typed_address) in
        let fa2_store : ext_fa2_storage = Test.get_storage taddr_fa2_address in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_store alice 1n) in

        // APPROVE marketplace to transfer token 1
        let () = Test.set_source alice in
        let marketplace_contract : Marketplace.parameter contract = Test.to_contract marketplace_taddr in
        let marketplace_addr  = Tezos.address marketplace_contract in 
        let fa2_contract : Factory.NFT_FA2.parameter contract = Test.to_contract taddr_fa2_address in
        let update_op = [(Add_operator({owner=alice; operator=marketplace_addr; token_id=1n}) : Factory.NFT_FA2.NFT.unit_update)] in
        let _ = Test.transfer_to_contract_exn fa2_contract (Update_operators(update_op)) 0mutez in

        // alice Sell token1
        let sell_args : Marketplace.Parameter.sell_proposal_param = { 
            token_id=1n;
            collectionContract=fa2_address;
            price=1tez;
        } in
        let () = Test.set_source alice in
        let _ = Test.transfer_to_contract_exn marketplace_contract (Sell(sell_args)) 0mutez in

        // bob Buy token1
        let buy_args : Marketplace.Parameter.buy_param = { 
            proposal_id=0n;
        } in
        let () = Test.set_source bob in
        let _ = Test.transfer_to_contract_exn marketplace_contract (Buy(buy_args)) 1000000mutez in

        let fa2_store_after : ext_fa2_storage = Test.get_storage taddr_fa2_address in
        let () = assert(Factory.NFT_FA2.Storage.is_owner_of fa2_store_after bob 1n) in
        "OK"
    in
    ()

NFT-Factory-Cameligo

Exemple of a NFT Factory contract in JsLIGO Resources

Packages

Most downloaded

Contracts

Featured contract templates

Marigold