#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();
*/


Explore governance

Marigold