An example of multisig contract in JsLIGO

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

  [@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

[@entry]
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 *)

[@entry]
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

[@entry]
let update_operators : 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
[@entry]
let update_operators : update_operators -> storage -> operation list * storage =
   fun (updates: update_operators) (s: storage) ->
   let () = failwith Errors.not_supported in
   ([]: operation list),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

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
};

const test_signer_creates_proposal_works = do {
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    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_exn(
            orig.addr,
            Create_proposal(create_proposal_params),
            0 as mutez
        );
    Test.log(gas_used);
    const end_storage = Test.get_storage(orig.addr);
    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 = do {
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    Test.set_source(unknown);
    const fail_tx =
        Test.transfer(
            orig.addr,
            Create_proposal(create_proposal_params),
            0 as tez
        );
    assert_error(fail_tx, Main.Conditions.Errors.only_signer);
    const curr_storage = Test.get_storage(orig.addr);
    assert(curr_storage == storage);
};

const test_signer_signs_proposal_works = do {
    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 orig =
        Test.originate(
            contract_of(Main),
            {
                ...storage,
                proposal_map: Big_map.literal(list([[1 as nat, init_proposal]]))
            },
            0 as tez
        );
    Test.set_source(bob);
    const _gas_used: nat =
        Test.transfer_exn(
            orig.addr,
            (Sign_proposal(1 as nat) as parameter_of Main),
            0 as tez
        );
    const curr_storage = Test.get_storage(orig.addr);
    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 = do {
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    Test.set_source(unknown);
    const fail_tx =
        Test.transfer(
            orig.addr,
            (Sign_proposal(1 as nat) as parameter_of Main),
            0 as tez
        );
    assert_error(fail_tx, Main.Conditions.Errors.only_signer);
    const curr_storage = Test.get_storage(orig.addr);
    assert(curr_storage == storage);
};

export const test_unknown_signs_unknown_proposal_fails = do {
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    Test.set_source(unknown);
    const fail_sign_tx =
        Test.transfer(
            orig.addr,
            (Sign_proposal(2 as nat) as parameter_of Main),
            0 as tez
        );
    assert_error(fail_sign_tx, Main.Conditions.Errors.only_signer);
};

const test_signer_signs_unknown_proposal_fails = do {
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    Test.set_source(alice);
    const fail_sign_tx =
        Test.transfer(
            orig.addr,
            (Sign_proposal(2 as nat) as parameter_of Main),
            0 as tez
        );
    assert_error(fail_sign_tx, Main.Conditions.Errors.no_proposal_exist);
};

const signer_creates_proposal_signers_sign_proposal_execute_works = do {
    Test.set_source(alice);
    const orig = Test.originate(contract_of(Main), storage, 0 as tez);
    const addr = Test.to_address (orig.addr);
    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 orig_fa2 = Test.originate(contract_of(FA2), storage_fa2, 0 as tez);
    const addr_fa2 = Test.to_address(orig_fa2.addr);
    const params: Main.Parameter.Types.proposal_params = {
        ...create_proposal_params, target_fa2: addr_fa2
    };
    let _gas_used: nat =
        Test.transfer_exn(
            orig.addr,
            Create_proposal(params),
            0 as mutez
        );
    Test.set_source(bob);
    _gas_used
    = Test.transfer_exn(
          orig.addr,
          (Sign_proposal(1 as nat)),
          0 as tez
      );
    Test.set_source(charly);
    _gas_used
    = Test.transfer_exn(
          orig.addr,
          (Sign_proposal(1 as nat)),
          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(orig.addr);
    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(orig_fa2.addr);
    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 = do {
    Test.set_source(alice);
    const storage_init = { ...storage, threshold: 1 as nat };
    const orig = Test.originate(contract_of(Main), storage_init, 0 as tez);
    const addr: address = Test.to_address (orig.addr);
    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 orig_fa2 = Test.originate(contract_of(FA2), storage_fa2, 0 as tez);
    const addr_fa2 = Test.to_address(orig_fa2.addr);
    const params: Main.Parameter.Types.proposal_params = {
        ...create_proposal_params, target_fa2: addr_fa2
    };
    let _gas_used: nat =
        Test.transfer_exn(
            orig.addr,
            Create_proposal(params),
            0 as mutez
        );
    Test.set_source(bob);
    _gas_used
    = Test.transfer_exn(
          orig.addr,
          (Sign_proposal(1n)),
          0 as tez
      );
    const expected_executed_signers =
        Set.add(alice, Set.add(bob, Set.empty as set<address>));
    const curr_storage = Test.get_storage(orig.addr);
    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(orig_fa2.addr);
    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);
};

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

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

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

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

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

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

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

const _ = mutation_tests();
*/


Multisig-Jsligov1.0

An example of multisig contract in JsLIGO

Use template

Readme

Multi signature

The multisig pattern

Content

Pre-requisites

Compiling / testing / deploying

Contract informations

sign_proposal

Arguments

Marigold