An example of a shifumi game contract in JsLIGO

gameStatus

newRound

reveal

sessionId

roundId

player_key

player_secret

revealPlay

action

play

stopSession

total_rounds

players

createSession

metadata

next_session

sessions

board

#import "errors.jsligo" "Errors"
#import "session.jsligo" "Session"
#import "listUtils.jsligo" "ListUtils"



export const check_player_authorized = (player : Session.player, allowed_players : list<Session.player>, error_message : string) : unit => {
    assert_with_error( (ListUtils.find_opt(( (a : address) => a == player), allowed_players) != (None() as option<Session.player>))  , error_message);
};

export const check_session_end = (result : Session.result, expected : Session.result) : unit => {
    assert_with_error( (result == expected), Errors.session_finished);
};

export const check_asleep = (current_session : Session.t) : unit => {
    assert_with_error( ((Tezos.get_now ()) > current_session.asleep), Errors.must_wait_10_min);
};

export const must_wait_10_min : string = "Must wait at least 600 seconds before claiming Victory (in case opponent is not playing)";
export const unknown_session : string = "Unknown session";
export const user_not_allowed_to_stop_session : string = "Not allowed to stop this session";
export const user_not_allowed_to_play_in_session : string = "Not allowed to play this session";
export const user_not_allowed_to_reveal_in_session : string = "Not allowed to reveal this session";
export const session_finished : string = "this session is finished";
export const wrong_current_round : string = "Wrong current round parameter";
export const user_already_played : string = "You already have played for this round";
export const missing_player_bytes : string = "a player has not played";
export const missing_all_bytes : string = "no actions registered";
export const missing_all_decoded_bytes : string = "no decoded actions registered";
export const missing_sender_bytes : string = "user has not played";
export const failed_to_open_bytes : string = "Failed to check bytes";
export const user_already_revealed : string = "You already have revealed your play for this round";
export const failed_to_unpack_payload : string = "Failed to unpack the payload";
export const no_winner : string = "No players have played in the current round, thus cannot deduce troller";
export const player_needs_to_pay_to_play = "Player needs to pay 1 Tez to play a round";
export const player_contract_address_not_found = "Cannot find the contract from player address";

//redefining find_opt function
export const find_opt = <T>(f : (x : T) => bool, xs : list<T>) : option<T> =>
  match (xs) {
    when([] : list<T>): None();
    when([x,... xs] : list<T>): do {
      if(f(x)) { return Some(x); } else {return find_opt(f, xs); }
    }
  };

//redefining reverse
export const reverse = <T>(xs : list<T>) : list<T> => {
        let f = ([ys, x] : [list<T>, T]) : list<T> => list([x, ...ys]);
        return List.fold_left(f, list([]) as list<T>, xs);
    };

//redefining concat
export const concat = <T>(xs : list<T>, ys : list<T>) : list<T> => {
   let f = ([x,ys] : [T,list<T>]) : list<T> => list([x,...ys]);
   return List.fold_right(f ,xs ,ys)
  };

export const remove = <T>(f : (x : T) => bool, xs : list<T>, acc : list<T>) : list<T> =>
  match(xs) {
    when([] : list<T>): reverse(acc);
    when([x,... xs] : list<T>): do {
      if(f(x)) { return concat(reverse(acc),xs); } else {return remove(f, xs, list([x,...acc])); }
    }
  };

#import "storage.jsligo" "Storage"
#import "parameter.jsligo" "Parameter"
#import "views.jsligo" "Views"
#import "errors.jsligo" "Errors"
#import "session.jsligo" "Session"
#import "conditions.jsligo" "Conditions"
#import "listUtils.jsligo" "ListUtils"

export type storage = Storage.t;
export type parameter = Parameter.t;
export type return_ = [list<operation>, storage];

// Anyone can create a session (must specify players and number of rounds)
@entry
const createSession = (param : Parameter.createsession_param, store : Storage.t) : return_ => {
    let new_session : Session.t = Session.new(param.total_rounds, param.players);
    let new_storage : Storage.t = { ...store,
        next_session: store.next_session + 1n,
        sessions: Map.add(store.next_session, new_session, store.sessions)
    };
    return [list([]) as list<operation>, new_storage];
};


// search for a non troller in the session
const find_me_a_name = (sessionId : nat, missing_players : list<Session.player>, current_session : Session.t, store : Storage.t) : return_ => {

    assert_with_error( List.size(missing_players) == 1n, Errors.no_winner);

    const loser = Option.unopt(List.head_opt(missing_players));
    let winners_list : list<address> = ListUtils.remove(( (a : address) => a == loser), current_session.players, (list([]) as list<address>));
    let winner : address = Option.unopt(List.head_opt(winners_list));
    let new_current_session : Session.t = {...current_session, result:Winner(winner) };
    let new_storage : Storage.t = Storage.update_sessions(store, sessionId, new_current_session);
    let opToRedeem : operation = Tezos.transaction(unit,(new_current_session.pool as tez),Tezos.get_contract_with_error(winner,Errors.player_contract_address_not_found));
    return [list([opToRedeem , Tezos.emit("%gameStatus",sessionId) ]) as list<operation>, new_storage];
};

//declare a draw if game is blocked because people don't reveal
const declare_a_draw = (sessionId : nat, current_session : Session.t, store: Storage.t) : return_ => {
    let new_current_session : Session.t = {...current_session, result:Draw() };
    let new_storage : Storage.t = Storage.update_sessions(store, sessionId, new_current_session);
    let player1ToRedeemOp : operation = Tezos.transaction(unit,(new_current_session.pool / 2tez) * 1tez ,Tezos.get_contract_with_error(Option.unopt(List.head_opt(new_current_session.players)),Errors.player_contract_address_not_found));
    let player2ToRedeemOp : operation = Tezos.transaction(unit,(new_current_session.pool / 2tez) * 1tez,Tezos.get_contract_with_error(Option.unopt(List.head_opt(Option.unopt(List.tail_opt(new_current_session.players)))),Errors.player_contract_address_not_found));
    return [list([player1ToRedeemOp,player2ToRedeemOp,Tezos.emit("%gameStatus",sessionId)]) as list<operation>, new_storage];
};

const is_none = <T>(x : option<T>) : bool =>
   match(x) {
     when(Some(_)): false;
     when(None()): true
     };

// allow players to claim victory if opponent is a troller (refuse to play)
@entry
const stopSession = (param : Parameter.stopsession_param, store : Storage.t) : return_ => {
    let current_session : Session.t = Storage.getSession(param.sessionId, store);
    let _check_players : unit = Conditions.check_player_authorized((Tezos.get_sender ()), current_session.players, Errors.user_not_allowed_to_stop_session);
    let _check_session_end : unit = Conditions.check_session_end(current_session.result, Inplay());
    let _check_asleep : unit = Conditions.check_asleep(current_session);
    let current_round = match (Map.find_opt(current_session.current_round, current_session.rounds)) {
        when(None()): (list([]) as Session.player_actions);
        when(Some(rnd)): rnd;
    };
    let missing_players = Session.find_missing(current_round, current_session.players);
    if (List.size(missing_players) > 0n) {
        return find_me_a_name (param.sessionId, missing_players, current_session, store);
    } else {

        let current_decoded_round_opt = Map.find_opt(current_session.current_round, current_session.decoded_rounds);

        if( is_none(current_decoded_round_opt)) {
            return declare_a_draw (param.sessionId, current_session, store);
            }
        else {
            let current_decoded_round = Option.unopt(current_decoded_round_opt);
            let missing_players_for_reveal = Session.find_missing(current_decoded_round, current_session.players);
            if (List.size(missing_players_for_reveal) > 0n) {
                return find_me_a_name (param.sessionId, missing_players_for_reveal, current_session, store);
            } else {
                return [list([]) as list<operation>, store]
            }
        }
    }
};

// the player create a bytes with the chosen action (Stone | Paper | Cisor) in backend
// once the bytes is created, the player send its bytes to the smart contract
@entry
const play = (param : Parameter.play_param, store : Storage.t) : return_ => {
    let current_session : Session.t = Storage.getSession(param.sessionId, store);
    let _check_players : unit = Conditions.check_player_authorized((Tezos.get_sender ()), current_session.players, Errors.user_not_allowed_to_play_in_session);
    let _check_session_end : unit = Conditions.check_session_end(current_session.result, Inplay());
    let _check_round : unit = assert_with_error( (current_session.current_round == param.roundId), Errors.wrong_current_round);


    // you can play only once per round, so we take money for every round
    if(Tezos.get_amount() < 1tez) return failwith(Errors.player_needs_to_pay_to_play);

    // register action
    let new_rounds = Session.add_in_rounds(current_session.current_round, current_session, (Tezos.get_sender ()), param.action);
    let new_session : Session.t = Session.update_rounds({...current_session,pool:(current_session.pool + 1tez)}, new_rounds);
    let new_storage : Storage.t = Storage.update_sessions(store, param.sessionId, new_session);

    return match (Map.find_opt(new_session.current_round,new_session.rounds)) {
        when(None()): [list([]) as list<operation>, new_storage];
        when(Some(current_round)): do {
            if( List.size( current_round  ) != 2n ){ return [list([]) as list<operation>, new_storage]}
            else { return  [list([ Tezos.emit("%reveal",param.sessionId)  ]) as list<operation>, new_storage]}
        };
    };
};

// Once all players have committed their bytes, they must reveal the content of their bytes
@entry
const revealPlay = (param : Parameter.reveal_param, store : Storage.t) : return_ => {
    // players can reveal only if all players have sent their bytes
    let current_session : Session.t = Storage.getSession(param.sessionId, store);
    let _check_players : unit = Conditions.check_player_authorized((Tezos.get_sender ()), current_session.players, Errors.user_not_allowed_to_reveal_in_session);
    let _check_session_end : unit = Conditions.check_session_end(current_session.result, Inplay());
    let _check_round : unit = assert_with_error( (current_session.current_round == param.roundId), Errors.wrong_current_round);
    let current_round_actions : Session.player_actions = Session.get_round_actions(current_session.current_round, current_session);
    let numberOfPlayers : nat = List.size(current_session.players);
    let listsize = ([acc, _elt]: [nat, Session.player_action]) : nat => acc + 1n;
    let numberOfActions : nat = List.fold(listsize, current_round_actions, 0n);
    let _check_all_players_have_played : unit = assert_with_error( (numberOfPlayers == numberOfActions), Errors.missing_player_bytes);
    // retrieve user bytes (fails if not found)
    let user_bytes : bytes = Session.get_bytes_exn((Tezos.get_sender ()), (Some(current_round_actions)));
    // decode action
    let decoded_action : Session.action = Session.decode_bytes_exn(param.player_key, user_bytes, param.player_secret);
    let new_decoded_rounds = Session.add_in_decoded_rounds(current_session.current_round, current_session, (Tezos.get_sender ()), decoded_action);
    let new_current_session : Session.t = Session.update_decoded_rounds(current_session, new_decoded_rounds);

    // compute board if all players have revealed
    let modified_new_current_session : Session.t = Session.finalize_current_round(new_current_session);

    // if session is finished, we can compute the result winner
    let final_current_session = Session.finalize_session(modified_new_current_session);

    let new_storage : Storage.t = Storage.update_sessions(store, param.sessionId, final_current_session);
    return match(final_current_session.result) {
        when(Inplay()): do { if(final_current_session.current_round == current_session.current_round) {return [list([]) as list<operation>, new_storage]}
                         else {return [list([Tezos.emit("%newRound",param.sessionId)]) as list<operation>, new_storage]}};
        when(Draw()): do {
            let player1ToRedeemOp : operation = Tezos.transaction(unit,(new_current_session.pool / 2tez) * 1tez ,Tezos.get_contract_with_error(Option.unopt(List.head_opt(new_current_session.players)),Errors.player_contract_address_not_found));
            let player2ToRedeemOp : operation = Tezos.transaction(unit,(new_current_session.pool / 2tez) * 1tez,Tezos.get_contract_with_error(Option.unopt(List.head_opt(Option.unopt(List.tail_opt(new_current_session.players)))),Errors.player_contract_address_not_found));
            return [list([player1ToRedeemOp, player2ToRedeemOp, Tezos.emit("%gameStatus",param.sessionId)  ]) as list<operation>, new_storage]};
        when(Winner(winner)): do {
            let opToRedeem : operation = Tezos.transaction(unit,(new_current_session.pool as tez),Tezos.get_contract_with_error(winner,Errors.player_contract_address_not_found));
            return [list([ opToRedeem , Tezos.emit("%gameStatus",param.sessionId)  ]) as list<operation>, new_storage]
            }
    };
};


@view
const board = (sessionId: nat, store: storage): Views.sessionBoard => {
    return match (Map.find_opt(sessionId, store.sessions)) {
        when(Some(sess)): Views.retrieve_board(sess);
        when(None()): (failwith("Unknown session") as Views.sessionBoard)
    };
};


export type createsession_param = {
    total_rounds : nat,
    players : list<address>
};

export type stopsession_param = {
    sessionId : nat
};

export type play_param = {
    sessionId : nat,
    roundId : nat,
    action : bytes
};

export type reveal_param = {
    sessionId : nat,
    roundId : nat,
    player_key : bytes,
    player_secret : nat
};

export type t = ["CreateSession", createsession_param] | ["Play", play_param] | ["RevealPlay", reveal_param] | ["StopSession", stopsession_param];


#import "errors.jsligo" "Errors"
#import "listUtils.jsligo" "ListUtils"

export type player = address;
export type round = nat;
export type action = ["Stone"] | ["Paper"] | ["Cisor"];
export type result = ["Inplay"] | ["Draw"] | ["Winner", address];

type an_action<a> = {
    player : player,
    action : a
};

export type player_action = an_action<bytes>;
export type decoded_player_action = an_action<action>;

export type player_actions = list<player_action>;
export type decoded_player_actions = list<decoded_player_action>;

export type rounds<a> = map<round, list<an_action<a>> >;

type board = map<round, option<player> >;

export type t = {
    total_rounds : nat,
    players : list<player>,
    current_round : nat,
    rounds : rounds<bytes>,
    decoded_rounds : rounds<action>,
    board : board,
    result : result,
    asleep : timestamp,
    pool : tez     //bet pool in tez. 1 tez / round play movement
};

export const new = (total_rounds : nat, players : list<player>): t => {
    return {
      asleep:(Tezos.get_now ()) + 600,
      total_rounds:total_rounds,
      players:players,
      current_round:1n,
      rounds:(Map.empty as rounds<bytes>),
      decoded_rounds:(Map.empty as rounds<action>),
      board:(Map.empty as board),
      result: Inplay(),
      pool : 0 as tez
    };
};

export const get_round_actions = (roundId : nat, session : t) : player_actions => {
    return match (Map.find_opt(roundId, session.rounds)) {
        when(None): failwith(Errors.missing_all_bytes);
        when(Some(round_actions)): round_actions;
    };
};

// @inline
const get_decoded_round_actions = (roundId : nat, session : t) : decoded_player_actions => {
    return match (Map.find_opt(roundId, session.decoded_rounds)) {
        when(None): failwith(Errors.missing_all_decoded_bytes);
        when(Some(decoded_round_actions)): decoded_round_actions;
    };
};

export const update_rounds = (session : t, rounds :  map<round, player_actions>): t => {
    return { ...session, asleep:(Tezos.get_now ()) + 600, rounds:rounds }
};

export const update_decoded_rounds = (session : t, decoded_rounds : map<round, decoded_player_actions>): t => {
    return { ...session, asleep:(Tezos.get_now ()) + 600, decoded_rounds:decoded_rounds };
};


export const find_missing = <_a>(pactions : list<an_action<_a>>, all_players : list<player>) => {
    let addIfNotParticipant = ([acc, elt] : [list<player>, player]) : list<player> =>
        match(ListUtils.find_opt( ((paction : an_action<_a>) => paction.player == elt), pactions )) {
            when(None): list([elt,...acc]);
            when(Some(_an)): acc;
        };
    return List.fold(addIfNotParticipant, all_players, list([]) as list<player>);
};

// @inline
const has_played = <_a>(pactions : list<an_action<_a>>, player : player) : bool => {
    let check_contains = ([acc, elt] : [bool, an_action<_a>]) : bool => { if (acc) { return acc } else { return (elt.player == player) } };
    return List.fold(check_contains, pactions, false);
};

// @inline
const has_played_round = <_a>(rounds : rounds<_a>, roundId : round, player : player) : bool => {
    return match (Map.find_opt(roundId, rounds)) {
        when(Some(acts)): has_played(acts, player);
        when(None): false ;
    };
};

export const add_in_decoded_rounds = (roundId : nat, session : t, user : address, decoded_action : action) : rounds<action> => {
    return match (Map.find_opt(roundId, session.decoded_rounds)) {
        when(None()): Map.add(roundId, list([{ player:user, action:decoded_action }]), session.decoded_rounds);
        when(Some(decodedPlayerActions)): do {
            let _check_player_has_revealed_this_round = assert_with_error( (has_played_round(session.decoded_rounds, roundId, user) == false), Errors.user_already_revealed);
            return Map.update(roundId, (Some( list([ {player:user, action:decoded_action}, ...decodedPlayerActions]))), session.decoded_rounds);
        };
    };
};

export const add_in_rounds = (roundId : nat, session : t, user : address, action : bytes) : rounds<bytes> => {
    return match (Map.find_opt(roundId, session.rounds)) {
        when(None()): Map.add(roundId, list([{player:user, action:action}]), session.rounds);
        when(Some(playerActions)): do {
            let _check_player_has_played_this_round = assert_with_error( (has_played_round(session.rounds, roundId, user) == false), Errors.user_already_played);
            return Map.update(roundId, (Some( list([ {player:user, action:action},  ...playerActions]))), session.rounds);
        };
    };
};

export const get_bytes_exn = (user : address, actions_opt : option<player_actions>) : bytes => {
    let find_bytes = (addr : address, lst_opt : option<player_actions>) : option<bytes> => {
        return match (lst_opt) {
            when(None()): (None() as option<bytes>);
            when(Some(lst)): match (List.head_opt(lst)) {
                when(None()): (None() as option<bytes>);
                when(Some(elt)): do {
                        if (elt.player == addr) {
                            return (Some(elt.action) as option<bytes>)
                        } else {
                            return find_bytes(addr, List.tail_opt(lst));
                        }
                    };
                };
        };
    };
    return match (find_bytes(user, actions_opt)) {
        when(None()): (failwith(Errors.missing_sender_bytes) as bytes);
        when(Some(ch)): ch;
    };
};

export const decode_bytes_exn = (player_bytes : bytes, user_bytes : bytes, player_secret : nat): action => {
    let hashed = Crypto.sha512(Bytes.pack([player_bytes, player_secret]));
    if (hashed == user_bytes) {
        return match ((Bytes.unpack(player_bytes) as option<action>)) {
            when(None()): failwith(Errors.failed_to_unpack_payload);
            when(Some(x)): x;
        };
    } else {
        return failwith(Errors.failed_to_open_bytes);
    }
};

// @inline
const resolve = (first : decoded_player_action, second : decoded_player_action) : option<player> => {
    let result : option<player> = match (first.action) {
        when(Stone()): match (second.action) {
            when(Stone()): None();
            when(Paper()): Some(second.player);
            when(Cisor()): Some(first.player);
        };
        when(Paper()): match (second.action) {
            when(Stone()): Some(first.player);
            when(Paper()): None();
            when(Cisor()): Some(second.player);
        };
        when(Cisor()): match (second.action) {
            when(Stone()): Some(second.player);
            when(Paper()): Some(first.player);
            when(Cisor()): None();
        };
    };
    return result;
};

// TODO , this implementation can handle only 2 players :(
const update_board = (sess : t, current_round : round) : board => {
    // process actions for current_round
    let pactions : decoded_player_actions = match (Map.find_opt(current_round, sess.decoded_rounds)) {
        when(None()): (failwith("Missing actions for current_round") as decoded_player_actions);
        when(Some(pacts)): pacts;
    };
    let first : decoded_player_action = match (List.head_opt(pactions)) {
        when(None()): (failwith("Missing actions for first player") as decoded_player_action);
        when(Some(act)): act;
    };
    let next_players_opt : option<list<decoded_player_action>> = List.tail_opt(pactions);
    let next_players : list<decoded_player_action> = match (next_players_opt) {
        when(None()): (failwith("Missing actions for second player") as list<decoded_player_action>);
        when(Some(tl)): tl;
    };
    let second : decoded_player_action = match (List.head_opt(next_players)) {
        when(None()): (failwith("Missing actions for second player") as decoded_player_action);
        when(Some(act)): act;
    };
    let result : option<player> = resolve(first, second);
    return match (result) {
        when(None()): Map.update(current_round, (None() as option<option<player>>), sess.board);
        when(Some(r)): Map.update(current_round, (Some(Some(r))), sess.board);
    };
};

export const finalize_current_round = (session: t) : t => {
    // retrieve decoded_player_actions of given roundId
    let performed_actions : decoded_player_actions = match (Map.find_opt(session.current_round, session.decoded_rounds)) {
        when(None()): (list([]) as decoded_player_actions);
        when(Some(pacts)): pacts;
    };
    // verify all players have revealed
    let all_player_have_revealed = ([accAndList, elt] : [[bool, decoded_player_actions], player]) : [bool, decoded_player_actions] => {
        let [acc, pactions] = accAndList;
        return [acc && has_played(pactions, elt), pactions];
    };
    let [check_all_players_have_revealed, _all_decoded_actions] : [bool, decoded_player_actions] = List.fold(all_player_have_revealed, session.players, [true, performed_actions]);
    // all players have given their actions, now the board can be updated and session goes to next round
    if (check_all_players_have_revealed == true) {
        return { ...session, current_round:session.current_round+1n, board:update_board(session, session.current_round) };
    } else {
        return session;
    }
};

const compute_result = (sess: t) : result => {
    // parse board and compute who won
    let compute_points = ([acc, elt] : [map<address, nat> , [round, option<player>]]) : map<address, nat> => {
        return match (elt[1]) {
            when(None()): acc;
            when(Some(winner_round)): match (Map.find_opt(winner_round, acc)) {
                when(None()): Map.add(winner_round, 1n, acc);
                when(Some(old_value)): Map.update(winner_round, (Some(old_value + 1n)), acc);
            };
        };
    };
    let final_scores = Map.fold(compute_points, sess.board, (Map.empty as map<address, nat>));
    let [winner_addr, winner_points, multiple_winners] : [option<address>, nat, bool] = [(None() as option<address>), 0n, false];
    let leader_score = ([acc, elt] : [[option<address>, nat, bool], [address, nat]]) : [option<address>, nat, bool] => {
        let [win_addr, win_points, multiple] = acc;
        return match (win_addr) {
            when(None()): [Some(elt[0]), elt[1], false];
            when(Some(_temp_win_addr)): do {
                if (elt[1] > win_points) {
                    return [Some(elt[0]), elt[1], false]
                } else {
                    if (elt[1] == win_points) {
                        return [win_addr, win_points, true]
                    } else {
                        return [win_addr, win_points, multiple]
                    }
                }
            };
        };
    };
    let [final_winner_addr, _final_winner_points, final_multiple] = Map.fold(leader_score, final_scores, [winner_addr, winner_points, multiple_winners]);
    if (final_multiple) {
        return Draw()
    } else {
        return match (final_winner_addr) {
            when(None()): Draw();
            when(Some(x)): Winner(x);
        }
    }
};

export const finalize_session = (session: t) : t => {
    if (session.current_round > session.total_rounds) {
        return { ...session, result: compute_result(session) };
    } else  {
        return session;
    }
};


#import "errors.jsligo" "Errors"
#import "parameter.jsligo" "Parameter"
#import "session.jsligo" "Session"
#import "conditions.jsligo" "Conditions"

export type t = {
    metadata : big_map<string, bytes>,
    next_session : nat,
    sessions : map<nat, Session.t>
};

export const update_sessions = (storage : t, sessionId : nat, new_session : Session.t): t => {
    return { ...storage, sessions: Map.update(sessionId, (Some(new_session)), storage.sessions)}
};

export const getSession = (sessionId : nat, store : t) : Session.t => {
    return match (Map.find_opt(sessionId, store.sessions)) {
        when(None()): (failwith(Errors.unknown_session) as Session.t);
        when(Some(sess)): sess;
    };
};


#import "session.jsligo" "Session"


export type sessionBoard = {
    points : map<address, nat>
};

export const retrieve_board = (sess : Session.t) : sessionBoard => {
    let scores : map<address, nat> = (Map.empty as map<address, nat>);
    let myfunc = ([acc, elt] : [map<address, nat>, [Session.round, option<address>]]) : map<address, nat> =>
        match (elt[1]) {
            when(None()): acc;
            when(Some(winner_round)): match (Map.find_opt(winner_round, acc)) {
                when(None()): Map.add(winner_round, 1n, acc);
                when(Some(old_value)): Map.update(winner_round, (Some(old_value + 1n)), acc)
            };
        };
    let final_scores = Map.fold(myfunc, sess.board, scores);
    return { points:final_scores }
};

Shifumi-Jsligov1.0

An example of a shifumi game contract in JsLIGO

Use template

Readme

Contract Shifumi

Makefile usage

Compile Shifumi contract

Test Shifumi contract

Test Shifumi contract

Contract informations

revealPlay

Arguments

Marigold