example of a permit contract in JsLIGO Resources

update_operators

requests

callback

balance_of

setAdmin

transfer

setExpiry

permit

burn_token

mint_token

create_token

metadata

ledger

token_metadata

operators

admin

counter

defaultExpiry

maxExpiry

permits

userExpiries

permitExpiries

extension

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

@ligo/permit

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


export const requiresAdmin  = "NOT_AN_ADMIN";
export const tokenExist     = "TOKEN_ID_ALREADY_PRESENT";

// TZIP-17
export const dupPermit      = "DUP_PERMIT";
export const missigned       = "MISSIGNED";

export const maxSecondsExceeded = "MAX_SECONDS_EXCEEDED";
export const forbiddenExpiryUpdate = "FORBIDDEN_EXPIRY_UPDATE";

export const missingExpiry = "NO_EXPIRY_FOUND"

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

type seconds = nat;
export type permitKey = [address, bytes];
export type permits = big_map<permitKey, timestamp>;
export type userExpiries = big_map<address, option<seconds>>;
export type permitExpiries = big_map<permitKey, option<seconds>>;

export type t<a> = {
    admin: address,
    counter: nat,
    defaultExpiry: seconds,
    maxExpiry: seconds,
    permits: permits,
    userExpiries: userExpiries,
    permitExpiries: permitExpiries,
    extension : a
};

const get_user_defined_expiry =
<T>(from_: address, ext: t<T>): option<seconds> => {
    return match (Big_map.find_opt(from_, ext.userExpiries)) {
        when(None()): (Some(ext.defaultExpiry));
        when(Some(exp)): exp;
    };
};

const getExpiry =
<T>(ext: t<T>, paramPermitKey: permitKey): seconds => {
    return match ((Big_map.find_opt([paramPermitKey[0], paramPermitKey[1]], ext.permitExpiries) as option<option<seconds>>)) {
        when(None()): match ((Big_map.find_opt(paramPermitKey[0], ext.userExpiries) as option<option<seconds>>)) {
                    when(None()): ext.defaultExpiry;
                    when(Some(exp)): match (exp) {
                            when(None()): ext.defaultExpiry;
                            when(Some(t)): t;
                    };
        };
        when(Some(p)): match (p) {
                    when(None()): ext.defaultExpiry;
                    when(Some(exp)): exp;
            };
    }
};


export const assertAdmin =
<T>(ext : t<T>) =>
    assert_with_error((Tezos.get_sender() == ext.admin), Errors.requiresAdmin);

export const setAdmin =
<T>(ext: t<T>, admin: address): t<T> => {
    assertAdmin(ext);
    return { ...ext, admin : admin };
};

export const setExtension =
<T>(ext: t<T>, extension: T): t<T> => {
    return { ...ext, extension : extension };
};

export const addPermit =
<T>(ext: t<T>, paramPermitKey: permitKey): t<T> => {
    return { ...ext,
        permits : Big_map.add(paramPermitKey, Tezos.get_now(), ext.permits),
        counter : ext.counter + 1n
    }
};

export const updatePermit =
<T>(ext: t<T>, paramPermitKey: permitKey): t<T> => {
    return { ...ext,
        permits : Big_map.update(paramPermitKey, (Some(Tezos.get_now())), ext.permits),
        counter : ext.counter + 1n
    }
};

export const _checkNotExpired =
<T>(ext: t<T>, submissionTimestamp: timestamp, paramPermitKey: permitKey): unit => {
    const effectiveExpiry: seconds = getExpiry(ext, paramPermitKey);
    assert_with_error((abs (Tezos.get_now() - submissionTimestamp) >= effectiveExpiry), Errors.dupPermit);
};

export const transferPresigned =
<T>(ext: t<T>, paramPermitKey: permitKey): [bool, t<T>] => {
    let permitSubmitTime: timestamp =
        match (Big_map.find_opt(paramPermitKey, ext.permits)) {
            when(None()): (0 as timestamp);
            when(Some(exp)): exp
        };
    if (permitSubmitTime == (0 as timestamp)) {
        return [false, ext]
    } else {
        let effectiveExpiry =
            match (Big_map.find_opt(paramPermitKey, ext.permitExpiries)) {
                when(None()): match (Big_map.find_opt(paramPermitKey[0], ext.userExpiries)) {
                        when(None()): (Some(ext.defaultExpiry));
                        when(Some(exp)): exp;
                };
                when(Some(exp)): exp;
            };
        return match (effectiveExpiry) {
            when(None()): failwith(Errors.missingExpiry);
            when(Some(effective_exp)): do {
                let permits = Big_map.remove(paramPermitKey, ext.permits);
                let isAuthorised = abs ((Tezos.get_now()) - permitSubmitTime) < effective_exp;
                return [isAuthorised, { ...ext, permits : permits }]
            }
        };
    }
};


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

type gen_storage = Storage.t
type token_total_supply = TokenTotalSupply.t
export type storage = gen_storage<token_total_supply>

type result = [list<operation>, storage]

type gen_extension = Extension.t
export type extension = gen_extension<token_total_supply>

export type mintOrBurn =
// @layout:comb
{
   owner    : address,
   tokenId : nat,
   amount_  : nat,
};

export type permitParams = [key, [signature, bytes]];
export type expiryParams = [address, [nat, option<bytes>]];

@entry const create_token = (paramCreate: [FA2.TokenMetadata.data, address, nat], s: storage) : result => {
    let [metadata,owner,amount] = paramCreate;
    Extension.assertAdmin(s.extension);
    let md = Storage.addNewToken(s.token_metadata, metadata.token_id, metadata);
    let store = Storage.setTokenMetadata(s, md);
    let ledger = FA2.Ledger.increase_token_amount_for_user(s.ledger)(owner)(metadata.token_id)(amount);
    let newStore = FA2.Storage.set_ledger(store)(ledger);
    let supply = TokenTotalSupply.createSupply(newStore.extension.extension, metadata.token_id, amount);
    return [Constants.noOperation, { ...newStore, extension : Extension.setExtension(s.extension, supply) }]
};

@entry const mint_token = (lst: list<mintOrBurn>, s: storage) : result => {
    Extension.assertAdmin(s.extension);
    let processOne = ([ledgerAndSupply, paramMint] : [[FA2.Ledger.t, TokenTotalSupply.t], mintOrBurn]) : [FA2.Ledger.t, TokenTotalSupply.t] => {
        let [ledger,supply] = ledgerAndSupply;
        let {owner,tokenId,amount_} = paramMint;
        FA2.Storage.assert_token_exist(s)(tokenId);
        return [
            FA2.Ledger.increase_token_amount_for_user(ledger)(owner)(tokenId)(amount_),
            Extension.TokenTotalSupply.increaseSupply(supply, tokenId, amount_)
        ]
    };
    let [ledger, supply] = List.fold_left(processOne, [s.ledger, s.extension.extension], lst);
    let store = FA2.Storage.set_ledger(s)(ledger);
    return [Constants.noOperation, { ...store, extension : Extension.setExtension(s.extension, supply) }]
};

@entry const burn_token = (lst: list<mintOrBurn>, s: storage) : result => {
   Extension.assertAdmin(s.extension);
   let processOne = ([ledgerAndSupply, paramBurn] : [[FA2.Ledger.t, Extension.TokenTotalSupply.t], mintOrBurn]) : [FA2.Ledger.t, Extension.TokenTotalSupply.t] => {
      let [ledger,supply] = ledgerAndSupply;
      let {owner,tokenId,amount_} = paramBurn;
      return [
        FA2.Ledger.decrease_token_amount_for_user(ledger)(owner)(tokenId)(amount_),
        Extension.TokenTotalSupply.decreaseSupply(supply, tokenId, amount_)
      ]
    };
   let [ledger, supply] = List.fold_left(processOne, [s.ledger, s.extension.extension], lst);
   let store = FA2.Storage.set_ledger(s)(ledger);
   return [Constants.noOperation,{ ...store, extension : Extension.setExtension(s.extension, supply) }]
};

// TZIP-17
@entry const permit = (permits: list<permitParams>, s: storage) : result => {
    let processPermit = ([ext, permit] : [extension, permitParams]) : extension => {
        let [pub_key, [sig, hash_]] = permit;
        let packed = Bytes.pack ([[(Tezos.get_chain_id()), Tezos.get_self_address()], [ext.counter, hash_]]);
        if (Crypto.check(pub_key, sig, packed)) {
            let sender_ = Tezos.address (Tezos.implicit_account (Crypto.hash_key(pub_key)));
            let paramPermitKey = [sender_, hash_];
            let extModified = match (Big_map.find_opt(paramPermitKey, ext.permits)) {
                when(None()): Extension.addPermit(ext, paramPermitKey);
                when(Some(submission_timestamp)): do {
                    Extension._checkNotExpired(s.extension, submission_timestamp, paramPermitKey);
                    return Extension.updatePermit(ext, paramPermitKey)
                };
            };
            return extModified;
        } else {
            return (Michelson `{FAILWITH}` as ((n: [string, bytes]) => extension)) ([Errors.missigned, packed])
        }
    };
    let extension = List.fold_left(processPermit, s.extension, permits);
    return [Constants.noOperation, { ...s, extension : extension }]
};

// TZIP-17
@entry const setExpiry = (p: expiryParams, s: storage) : result => {
    let [userAddress, [seconds, permitHashOpt]] = p;
    let _checkMaxExpiry : unit = assert_with_error((seconds <= s.extension.maxExpiry), Errors.maxSecondsExceeded);
    let _checkSender : unit = assert_with_error((Tezos.get_sender() == userAddress), Errors.forbiddenExpiryUpdate);
    return match (permitHashOpt) {
        when(None()): [
                Constants.noOperation,
                {...s, extension : { ...s.extension,
                    userExpiries : Big_map.add(userAddress, (Some(seconds)), s.extension.userExpiries) }}
            ];
        when(Some(permit_hash)):[
                Constants.noOperation,
                { ...s, extension : {...s.extension, permitExpiries : Big_map.add(
                    [userAddress, permit_hash],
                    (Some(seconds)),
                    s.extension.permitExpiries)
                }}
            ];
    };
};

// TZIP-17 implementation of TZIP-12 Transfer
@entry const transfer = (transfer: FA2.transfer, s: storage) : result => {
     let makeTransfer = ([acc, transferFrom] : [[FA2.Ledger.t, extension], FA2.transfer_from]) : [FA2.Ledger.t, extension] => {
        let [ledger, extension] = acc;
        let transferFromHash = Crypto.blake2b(Bytes.pack(transferFrom));
        let permitKey : Extension.permitKey = [transferFrom.from_, transferFromHash];
        const [isTransferAuthorized, ext] = Extension.transferPresigned(extension, permitKey);
        const {from_, txs} = transferFrom;
        let applyTransfer = ([ledger, dst] : [FA2.Ledger.t, FA2.atomic_trans]) : FA2.Ledger.t => {
            let {token_id, amount, to_} = dst;
            FA2.Storage.assert_token_exist(s)(token_id);
            if (!isTransferAuthorized) {
                FA2.Operators.assert_authorisation(s.operators)(from_)(token_id);
                let ledgerModified = FA2.Ledger.decrease_token_amount_for_user(ledger)(from_)(token_id)(amount);
                let ledgerFinal = FA2.Ledger.increase_token_amount_for_user(ledgerModified)(to_)(token_id)(amount);
                return ledgerFinal
            } else {
                let ledgerModified = FA2.Ledger.decrease_token_amount_for_user(ledger)(from_)(token_id)(amount);
                let ledgerFinal = FA2.Ledger.increase_token_amount_for_user(ledgerModified)(to_)(token_id)(amount);
                return ledgerFinal
            }
        };
        let l = List.fold(applyTransfer, txs, ledger);
        return [l, ext]
    };
    let [newLedger, newExt] = List.fold(makeTransfer, transfer, [s.ledger, s.extension]);
    return [Constants.noOperation, { ...s, ledger : newLedger, extension : newExt }]
};

@entry const setAdmin = (addr: address, s: storage) : result => {
    return [Constants.noOperation, { ...s, extension : Extension.setAdmin(s.extension, addr) }]
};

@entry const balance_of = (p : FA2.balance_of, s : storage): result => FA2.balance_of(p)(s);
@entry const update_operators = (p : FA2.update_operators, s : storage): result => FA2.update_ops(p)(s);

//     Off-chain views required by TZIP-17
//     Command to run to get the micheline expressions to put in the metadata:
//     ligo compile expression cameligo '_get_counter' \
//         --init-file src/main.mligo \
//         --project-root . \
//         --michelson-format json

const getDefaultExpiry = ([_,s]: [unit, storage]) : nat => {
    return s.extension.defaultExpiry
};

const getCounter = ([_,s]: [unit, storage]) : nat => {
    return s.extension.counter
};


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

type storage = FA2.storage;
type extension = Extension.t;
export type t<a> = storage<extension<a>>;

const getTokenMetadata = <T>(s: t<T>): FA2.TokenMetadata.t => {
    return s.token_metadata
};

export const setTokenMetadata = 
<T>(s: t<T>, token_metadata: FA2.TokenMetadata.t): t<T> => {
    return {...s, token_metadata : token_metadata }
};

export const addNewToken = (md: FA2.TokenMetadata.t, tokenId: nat, data: FA2.TokenMetadata.data) : FA2.TokenMetadata.t => {
    assert_with_error((! (Big_map.mem(tokenId, md))), Errors.tokenExist);
    return Big_map.add(tokenId, data, md);
};


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

export type t = big_map<FA2.Ledger.token_id, nat>;

const getSupply = (supply: t, tokenId: FA2.Ledger.token_id) : nat =>
    match (Big_map.find_opt(tokenId, supply)) {
        when(Some(a)): a;
        when(None()): (failwith(FA2.Errors.undefined_token) as nat);
   }

export const createSupply = (supply: t, newTokenId: FA2.Ledger.token_id, amount_: nat) : t => {
    return Big_map.add(newTokenId, amount_, supply)
};

export const increaseSupply = (supply: t, tokenId: FA2.Ledger.token_id, amount_: nat) : t => {
    let curAmount = getSupply(supply, tokenId);
    let newAmount = curAmount + amount_;
    return Big_map.update(tokenId, (Some(newAmount)), supply)
};

export const decreaseSupply = (supply: t, tokenId: FA2.Ledger.token_id, amount_: nat) : t => {
    let curAmount = getSupply(supply, tokenId);
    let newSupply = abs(curAmount - amount_);
    return Big_map.update(tokenId, (Some(newSupply)), supply);
};


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

// Some dummy value when they don't matter for a given test
export const dummy_genesis_ts = ("2000-01-01t10:10:10Z" as timestamp);


// Boostrapping of the test environment,
// init_ts is the initial timestamp of the genesis block
export const boot_state = (init_ts : timestamp) :
    [address,
    [address, address, address],
    [[address, key, string], [address, key, string], [address, key, string]],
    [address, address, address]] => {
    Test.reset_state_at(init_ts, 7n, (list([10000000tez]) as list<tez>));

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

    let owners =
        [Test.nth_bootstrap_account(0),
        Test.nth_bootstrap_account(1),
        Test.nth_bootstrap_account(2)];

    let owners_with_keys =
        [Test.get_bootstrap_account(0n),
        Test.get_bootstrap_account(1n),
        Test.get_bootstrap_account(2n)];

    let ops =
        [Test.nth_bootstrap_account(3),
        Test.nth_bootstrap_account(4),
        Test.nth_bootstrap_account(5)];

    return [admin, owners, owners_with_keys, ops]
};

// Bootstrapping of the contract under test,
// init_tok_amount is the amount of token allocated to every
// bootstrapped accounts
export const boot_token =
(owners: [address, address, address],
 ops: [address, address, address],
 init_tok_amount: nat,
 init_extended_storage: Token.extension) : Token_helper.originated => {
    let initial_fa2_storage = FA2_helper.get_initial_storage(
        owners, ops, init_tok_amount
    );

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

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

    return Token_helper.originateFromFile(init_storage);
};


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

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

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = () : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(
      admin, Token_helper.dummyDefaultExpiry, Token_helper.dummyMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful token mint
const _test_success = () : unit => {
    let [tok, admin, owners] = bootstrap();
    let [[owner1_addr, _owner1_1, _owner1_2], _owner2, _owner3] = owners;
    Test.set_source (admin);
    let token_id = 1n;
    let amount_ = 6n;
    Token_helper.burnTokenSuccess(list([{
       owner:owner1_addr,
       tokenId:token_id,
       amount_:amount_
    }]), tok.contr);
    let new_amount =  abs(init_tok_amount - amount_);
    Token_helper.assertBalance(tok.taddr, owner1_addr, token_id, new_amount);
    Token_helper.assertSupply(tok.taddr, token_id, new_amount)
};

// Failure because sender is not current admin
const _test_failure_not_admin = () : unit => {
    let [tok, _, owners] = bootstrap();
    let [[owner1_addr, _owner1_1, _owner1_2], _owner2, _owner3] = owners;
    Test.set_source (owner1_addr);
    let r = Token_helper.burnToken(list([{
       owner:owner1_addr,
       tokenId:1n,
       amount_:1n
    }]), tok.contr);
    Assert.string_failure(r, Token.Errors.requiresAdmin)
};

const test_success : unit = _test_success();
const test_failure_not_admin : unit = _test_failure_not_admin();


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

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

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = () : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(
      admin, Token_helper.dummyDefaultExpiry, Token_helper.dummyMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful token creation
const _test_success = () : unit => {
    let [tok, admin, owners] = bootstrap();
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source(admin);
    let token_id = 42n;
    let amount_ = 12n;
    Token_helper.createTokenSuccess
      (FA2_helper.get_dummy_token_data (token_id),
       owner1_addr, amount_, tok.contr);
    Token_helper.assertBalance(tok.taddr, owner1_addr, token_id, amount_);
    Token_helper.assertSupply(tok.taddr, token_id, amount_)
};

// Failure because token id already present
const _test_failure_token_exist = () : unit => {
    let [tok, admin, owners] = bootstrap();
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source (admin);
    let r = Token_helper.createToken
      (FA2_helper.get_dummy_token_data(1n),
       owner1_addr, 12n, tok.contr);
    Assert.string_failure(r, Token.Errors.tokenExist)
};

// Failure because sender is not current admin
const _test_failure_not_admin = () : unit => {
    let [tok, _, owners] = bootstrap();
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source (owner1_addr);
    let r = Token_helper.createToken
      (FA2_helper.get_dummy_token_data(42n),
       owner1_addr, 12n, tok.contr);
    Assert.string_failure(r, Token.Errors.requiresAdmin)
};

const test_success : unit = _test_success();
const test_failure_token_exist : unit = _test_failure_token_exist();
const test_failure_not_admin : unit = _test_failure_not_admin();


// Assert contract call results in failwith with given string
export const string_failure = (res: test_exec_result, expected: string) : unit => {
    let expect = Test.eval(expected);
    return match (res) {
        when(Fail(x)):
            match (x) {
                when(Rejected(x)): assert (Test.michelson_equal (x[0], expect));
                when(Balance_too_low(_)): Test.failwith("contract failed: balance too low");
                when(Other(s)): Test.failwith (s);
            };
        when(Success(_)): Test.failwith("Transaction should fail");
    };
};

// Assert contract result is successful
export const tx_success = (res: test_exec_result) : unit => {
    return match (res) {
        when(Success(_)): unit;
        when(Fail(x)):
            match (x) {
                when(Rejected(x)): do {
                    Test.log(x[0]);
                    return Test.failwith("Transaction should not fail")
                };
                when(Balance_too_low(_)): Test.failwith("Transaction should not fail");
                when(Other(_)): Test.failwith("Transaction should not fail");
            };
    }
}


#import "../../src/main.jsligo" "Token"

type common_storage = {
    ledger : Token.FA2.Ledger.t,
    token_metadata : Token.FA2.TokenMetadata.t,
    operators : Token.FA2.Operators.t
}

const dummy_token_info = (Map.empty as map<string, bytes>);

export const get_dummy_token_data = (token_id : nat) : Token.FA2.TokenMetadata.data => {
   return { token_id: token_id, token_info: dummy_token_info};
};


// Get the initial storage of FA2
// init_tok_amount is the amount of token allocated to every owner account
export const get_initial_storage =
(owners: [address, address,  address], ops: [address, address, address], init_tok_amount: nat): common_storage => {
    let [owner1, owner2, owner3] = owners;
    let [op1, _op2, op3] = ops;

    let ledger = Big_map.literal( list([
        [[owner1, 1n], init_tok_amount],
        [[owner2, 2n], init_tok_amount],
        [[owner3, 3n], init_tok_amount],
        [[owner1, 2n], init_tok_amount]
    ]));

    let operators  = Big_map.literal( list([
        [[owner1, op1], Set.literal(list([1n, 2n]))],
        [[owner2, op1], Set.literal(list([2n]))],
        [[owner3, op1], Set.literal(list([3n]))],
        [[op1   , op3], Set.literal(list([2n]))]
    ]));

    let token_metadata : Token.FA2.TokenMetadata.t = Big_map.literal( list([
        [1n, get_dummy_token_data(1n)],
        [2n, get_dummy_token_data(2n)],
        [3n, get_dummy_token_data(3n)]
    ]));

    return {
        ledger         : ledger,
        token_metadata : token_metadata,
        operators      : operators
    }
};


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

    // "+-----------+"
    // "| My string |"
    // "+-----------+"

export const describe = (lbl : string) : unit => {
    let hr = "+" + repeat("-", String.length(lbl) + 2n) + "+"; 
    Test.log (hr);
    Test.log ("| " + lbl + " |");
    Test.log (hr);
}


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

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

type initial_extended_storage = {
    admin : address,
    counter : nat,
    defaultExpiry : nat,
    maxExpiry : nat,
    permits : Token.Extension.permits,
    userExpiries : Token.Extension.userExpiries,
    permitExpiries : Token.Extension.permitExpiries,
    extension : Token.Extension.TokenTotalSupply.t
};

// Some dummy values when they don't matter for a given test
export const dummyDefaultExpiry = 0n;
export const dummyMaxExpiry = 0n;

export const getInitialExtendedStorage = (admin: address, initDefaultExpiry: nat, initMaxExpiry: nat) : initial_extended_storage => {
    return {
        admin : admin,
        counter : 0n,
        defaultExpiry : initDefaultExpiry,
        maxExpiry : initMaxExpiry,
        permits : (Big_map.empty as Token.Extension.permits),
        userExpiries : (Big_map.empty as Token.Extension.userExpiries),
        permitExpiries : (Big_map.empty as Token.Extension.permitExpiries),
        extension : (Big_map.empty as Token.TokenTotalSupply.t)
    };
};

// Originate a Token contract with given init_storage storage
export const originate = (init_storage: Token.storage) : originated => {
    let orig = Test.originate(contract_of(Token), init_storage, 0tez);
    let contr = Test.to_contract (orig.addr);
    let addr = Test.to_address (orig.addr);
    return { addr : addr, taddr : orig.addr, contr : contr };
};

export const originateFromFile = (init_storage : Token.storage) : originated => {
    let f = "../../src/main.jsligo";
    let orig = Test.originate_from_file(f, init_storage, 0tez);
    let contr = Test.to_contract (orig.addr);
    let addr = Test.to_address (orig.addr);
    return {addr : addr, taddr : orig.addr , contr : contr}
};


// Make a permit with given packed params and secret key
// The chain_id is equal to 0x00000000 in the test framework
export const makePermit = (hash_: bytes, account: [address, key, string], token_addr: address, counter: nat) : Token.permitParams => {
    let [_, pubKey, secretKey] = account;
    let packed = Bytes.pack ([[0x00000000, token_addr], [counter, hash_]]);
    let sig = Test.sign(secretKey, packed);
    return [pubKey, [sig, hash_]]
};

// Call entry point of Token contr contract
const call = (p: parameter_of Token, contr: contr) : test_exec_result =>
    Test.transfer_to_contract(contr, p, 0mutez)

export const permit = (p: list<Token.permitParams>, contr: contr) : test_exec_result =>
    call(Permit(p), contr)

export const setExpiry = (p: Token.expiryParams, contr: contr) : test_exec_result =>
    call(SetExpiry(p), contr)

export const setAdmin = (p: address, contr: contr) : test_exec_result =>
    call(SetAdmin(p), contr)

export const transfer = (p: Token.FA2.transfer, contr: contr) : test_exec_result => {
    let param : parameter_of Token = Transfer(p);
    return call(param, contr)
};

export const createToken = (md: Token.FA2.TokenMetadata.data, owner: address, amount: nat, contr: contr) : test_exec_result =>
    call(Create_token([md, owner, amount]), contr);

export const mintToken = (p: list<Token.mintOrBurn>, contr: contr) : test_exec_result =>
    call(Mint_token(p), contr)

export const burnToken = (p: list<Token.mintOrBurn>, contr: contr) : test_exec_result =>
    call(Burn_token(p), contr)

export const permitSuccess = (p: list<Token.permitParams>, contr: contr) : unit =>
    Assert.tx_success (permit(p, contr))

export const setExpirySuccess = (p: Token.expiryParams, contr: contr) : unit =>
    Assert.tx_success (setExpiry(p, contr))

export const setAdminSuccess = (p: address, contr: contr) : unit =>
    Assert.tx_success (setAdmin(p, contr))

export const transferSuccess = (p: Token.FA2.transfer, contr: contr) : unit =>
    Assert.tx_success (transfer(p, contr))

export const createTokenSuccess = (md: Token.FA2.TokenMetadata.data, owner: address, amount: nat, contr: contr) : unit =>
    Assert.tx_success (createToken(md, owner, amount, contr))

export const mintTokenSuccess = (p: list<Token.mintOrBurn>, contr: contr) : unit =>
    Assert.tx_success (mintToken(p, contr))

export const burnTokenSuccess = (p: list<Token.mintOrBurn>, contr: contr) : unit => {
    Assert.tx_success (burnToken(p, contr));
};

// Assert Token contract at [taddr] has permit with [address, hash] key
export const assertHasPermit = (taddr: taddr, paramPermitKey: Token.Extension.permitKey) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt(paramPermitKey, s.extension.permits)) {
        when(Some(_)): unit;
        when(None()): Test.failwith("Permits Big_map key should not be missing");
    }
};

// Assert Token contract at [taddr] has no permit with [address, hash] key
export const assertNoPermit = (taddr: taddr, paramPermitKey: Token.Extension.permitKey) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt(paramPermitKey, s.extension.permits)) {
        when(Some(_)): Test.failwith("Permits Big_map key should be None");
        when(None()): unit;
    }
};

// Assert Token contract at [taddr] has counter equals to [counter]
export const assertCounter = (taddr: taddr, counter: nat) : unit => {
    let s = Test.get_storage (taddr);
    assert_with_error( (s.extension.counter == counter), "Counter does not have expected value");
};

// Assert Token contract at [taddr] has user expiry for [userAddr] equal to [seconds]
export const assertUserExpiry = (taddr: taddr, userAddr: address, seconds: option<nat>) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt(userAddr, s.extension.userExpiries)) {
        when(Some(s)): assert (s == seconds);
        when(None()): Test.failwith("User epiries Big_map key should not be missing");
    }
};

// Assert Token contract at [taddr] has user permit expiry for [userAddr] and
// hash [hash_] equal to [seconds]
export const assertPermitExpiry = (taddr: taddr, userAddr: address, hash_: bytes, seconds: option<nat>) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt([userAddr, hash_], s.extension.permitExpiries)) {
        when(Some(s)): assert (s == seconds);
        when(None()): Test.failwith("Permit epiries Big_map key should not be missing");
    }
};

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

// assert Token contract at [taddr] have tokenTotalSupply for [tokenId] matching [amount_]
export const assertSupply = (taddr: taddr, tokenId: Token.FA2.Ledger.token_id, amount_: nat) : unit => {
    let s = Test.get_storage (taddr);
    return match (Big_map.find_opt(tokenId, s.extension.extension)) {
        when(Some(tokens)): assert(tokens == amount_);
        when(None()): Test.failwith("Big_map key should not be missing");
    }
};


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

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

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = () : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(
      admin, Token_helper.dummyDefaultExpiry, Token_helper.dummyMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful token mint
const _test_success = () : unit => {
    let [tok, admin, owners] = bootstrap();
    let [[owner1_addr, _owner1_1, _owner1_2], _owner2, _owner3] = owners;
    Test.set_source (admin);
    let token_id = 1n;
    let amount_ = 56n;
    Token_helper.mintTokenSuccess(list([{
       owner: owner1_addr,
       tokenId: token_id,
       amount_: amount_
    }]), tok.contr);
    let new_amount =  init_tok_amount + amount_;
    Token_helper.assertBalance(tok.taddr, owner1_addr, token_id, new_amount);
    Token_helper.assertSupply(tok.taddr, token_id, new_amount);
};

// Failure because sender is not current admin
const _test_failure_not_admin = () : unit => {
    let [tok, _, owners] = bootstrap();
    let [[owner1_addr, _owner1_1, _owner1_2], _owner2, _owner3] = owners;
    Test.set_source (owner1_addr);
    let r = Token_helper.mintToken(list([{
       owner: owner1_addr,
       tokenId: 1n,
       amount_: 1n,
    }]), tok.contr);
    Assert.string_failure(r, Token.Errors.requiresAdmin)
}

const test_success : unit = _test_success();
const test_failure_not_admin : unit = _test_failure_not_admin();


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

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

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = (init_ts: timestamp, initDefaultExpiry: nat, initMaxExpiry: nat) : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(init_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful permit creation
const _test_success_add_permit_one = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    let transfer_requests : Token.FA2.transfer = list([{
                from_:owner1_addr,
                txs: (list([{
                    to_:owner2_addr,
                    amount:2n,
                    token_id:1n}]) as list<Token.FA2.atomic_trans>)
            }]);
    let hash_ = Crypto.blake2b (Bytes.pack(transfer_requests));
    let permit = Token_helper.makePermit(hash_, owner1, tok.addr, 0n);
    Token_helper.permitSuccess(list([permit]), tok.contr);
    Token_helper.assertHasPermit(tok.taddr, [owner1_addr, hash_]);
    Token_helper.assertCounter(tok.taddr, 1n)
};

// Successful successive permit creation
const _test_success_add_permit_list = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n,7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    let transfer_requests : Token.FA2.transfer = list([
        {
            from_: owner1_addr,
            txs: list([
                {to_:owner2_addr, amount:2n, token_id:1n}
            ])
        }
    ]);
    let hash_ = Crypto.blake2b (Bytes.pack(transfer_requests));
    let permit1 = Token_helper.makePermit(hash_, owner1, tok.addr,0n);
    let transfer_requests2 : Token.FA2.transfer = list([
        {
            from_:owner2_addr,
            txs: list([
                { to_:owner1_addr, amount:2n, token_id:1n}
            ])
        }
    ]);
    let hash_2 = Crypto.blake2b (Bytes.pack (transfer_requests2));
    let permit2 = Token_helper.makePermit(hash_2, owner2, tok.addr,1n);
    Token_helper.permitSuccess(list([permit1, permit2]), tok.contr);
    Token_helper.assertHasPermit(tok.taddr, [owner2_addr, hash_2]);
    Token_helper.assertCounter(tok.taddr,2n)
};

// Successful permit update
const _test_success_update_permit = () : unit => {
    let initDefaultExpiry = 86_400n;
    let initMaxExpiry = 259_200n;
    let now = ("2000-01-03t10:10:10Z" as timestamp);
    let expired = ("2000-01-01t10:10:10Z" as timestamp);

    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(now);
    let [owner1, owner2, _owner3] = owners_with_keys;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;

    let transfer_requests : Token.FA2.transfer = list([
        ({from_: owner1_addr, txs: list([{to_:owner2_addr, amount:2n, token_id:1n}])})
    ]);
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_requests));

    let extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let extended_storage_modified = { ...extended_storage,
        permits : Big_map.literal (list([[
            [owner1_addr, hash_], expired
            ]])),
        counter : 1n
    };

    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, extended_storage_modified);
    let permit = Token_helper.makePermit(hash_, owner1, tok.addr,1n);
    Token_helper.permitSuccess(list([permit]), tok.contr);
    Token_helper.assertHasPermit(tok.taddr, [owner1_addr, hash_])
};

// Failing permit update because it alredy exists and has not expired
const _test_success_update_permit_already_exist = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp),3600n,7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    let transfer_requests : Token.FA2.transfer = list([
        ({from_:owner1_addr, txs: list([{to_:owner2_addr, amount:2n, token_id:1n}])})
    ]);
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_requests));
    let permit = Token_helper.makePermit(hash_, owner1, tok.addr,0n);
    Token_helper.permitSuccess(list([permit]), tok.contr);
    let permit2 = Token_helper.makePermit(hash_, owner1, tok.addr,1n);
    let r = Token_helper.permit(list([permit2]), tok.contr);
    Assert.string_failure(r, Token.Errors.dupPermit)
};

const test_success_add_permit_one : unit = _test_success_add_permit_one();
const test_success_add_permit_list : unit = _test_success_add_permit_list();
const test_success_update_permit : unit = _test_success_update_permit();
const test_success_update_permit_already_exist : unit = _test_success_update_permit_already_exist();


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

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

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = () : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(Bootstrap.dummy_genesis_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(
      admin, Token_helper.dummyDefaultExpiry, Token_helper.dummyMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful setting of admin
const _test_success_set_admin = (_: unit) : unit => {
    let [tok, admin, owners] = bootstrap();
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source(admin);
    Token_helper.setAdminSuccess(owner1_addr, tok.contr);
    let s = Test.get_storage(tok.taddr);
    assert (s.extension.admin == owner1_addr)
};

// Failure because sender is not current admin
const _test_failure_not_admin = (_: unit) : unit => {
    let [tok,_admin, owners] = bootstrap();
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let r = Token_helper.setAdmin(owner1_addr, tok.contr);
    Assert.string_failure(r, Token.Errors.requiresAdmin)
};

const test_success_set_admin : unit = _test_success_set_admin();
const test_failure_not_admin : unit = _test_failure_not_admin();


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

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

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = (init_ts: timestamp, initDefaultExpiry: nat, initMaxExpiry: nat) : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(init_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful setting of user expiry
const _test_success_set_user_expiry = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source (owner1_addr);
    let expiryParams : Token.expiryParams = [owner1_addr, [5400n, (None() as option<bytes>)]];
    Token_helper.setExpirySuccess(expiryParams, tok.contr);
    Token_helper.assertUserExpiry(tok.taddr, owner1_addr, Some(5400n))
};

// Successful setting of permit expiry
const _test_success_set_permit_expiry = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, _owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    Test.set_source (owner1_addr);
    let hash_ = 0x01;
    let expiryParams : Token.expiryParams = [owner1_addr, [5400n, (Some(hash_))]];
    Token_helper.setExpirySuccess(expiryParams, tok.contr);
    Token_helper.assertPermitExpiry(tok.taddr, owner1_addr, hash_, Some(5400n));
};

// Failure because sender is not the updated user expiry
const _test_failure_forbidden = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    Test.set_source (owner2_addr);
    let expiryParams : Token.expiryParams = [owner1_addr, [5400n, (None() as option<bytes>)]];
    let r = Token_helper.setExpiry(expiryParams, tok.contr);
    Assert.string_failure(r, Token.Errors.forbiddenExpiryUpdate)
};

// Failure because tried to set value exceeding maxExpiry
const _test_failure_max_seconds_exceeded = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    Test.set_source (owner2_addr);
    let expiryParams : Token.expiryParams = [owner1_addr, [14_400n, (None() as option<bytes>)]];
    let r = Token_helper.setExpiry(expiryParams, tok.contr);
    Assert.string_failure(r, Token.Errors.maxSecondsExceeded)
};

const test_success_set_user_expiry : unit = _test_success_set_user_expiry();
const test_success_set_permit_expiry : unit = _test_success_set_permit_expiry();
const test_failure_forbidden : unit = _test_failure_forbidden();
const test_failure_max_seconds_exceeded : unit = _test_failure_max_seconds_exceeded();


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

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

// Boostrapping of the test environment
const init_tok_amount = 10n;

const bootstrap = (init_ts: timestamp, initDefaultExpiry: nat, initMaxExpiry: nat) : [Token_helper.originated, address, [[address, key, string], [address, key, string], [address, key, string]]] => {
    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(init_ts);
    let base_extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, base_extended_storage);
    return [tok, admin, owners_with_keys]
};

// Successful transfer with permit
const _test_success = () : unit => {
    let [tok, _, owners] = bootstrap(("2000-01-01t10:10:10Z" as timestamp), 3600n, 7200n);
    let [owner1, owner2, _owner3] = owners;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    let transfer_request : Token.FA2.transfer_from = {
        from_:owner1_addr,
        txs:list([{to_:owner2_addr, amount:2n, token_id:1n}])
    };
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_request));
    let permit = Token_helper.makePermit(hash_, owner1, tok.addr, 0n);
    Token_helper.permitSuccess(list([permit]), tok.contr);
    let transfer_requests  : Token.FA2.transfer = list([transfer_request]);
    Test.set_source (owner2_addr);
    Token_helper.transferSuccess(transfer_requests, tok.contr);
    Token_helper.assertBalance(tok.taddr, owner1_addr, 1n, 8n);
    Token_helper.assertBalance(tok.taddr, owner2_addr, 1n, 2n);
    Token_helper.assertNoPermit(tok.taddr, [owner1_addr, hash_])
};

// Successful with permit expired but sender is operator
const _test_success_by_operator_with_expired_permit = () : unit => {
    let initDefaultExpiry = 86_400n;
    let initMaxExpiry = 259_200n;
    let now = ("2000-01-03t10:10:10Z" as timestamp);
    let expired = ("2000-01-01t10:10:10Z" as timestamp);

    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(now);
    let [owner1, owner2, _owner3] = owners_with_keys;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;
    let [op1, _op2, _op3] = ops;

    let transfer_request : Token.FA2.transfer_from = {
        from_:owner1_addr,
        txs:list([{to_:owner2_addr, amount:2n, token_id:1n}])
    };
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_request));

    let extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let extended_storage_modified = { ...extended_storage,
        permits : Big_map.literal(list([ [[owner1_addr, hash_], expired] ])),
        counter : 1n
    };

    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, extended_storage_modified);
    Test.set_source (op1);
    let transfer_requests : Token.FA2.transfer = list([transfer_request]);
    Token_helper.transferSuccess(transfer_requests, tok.contr);
    Token_helper.assertBalance(tok.taddr, owner1_addr, 1n, 8n);
    Token_helper.assertBalance(tok.taddr, owner2_addr, 1n, 2n);
};

// Failing because the permit has expired
const _test_failure_expired_permit = () : unit => {
    let initDefaultExpiry = 86_400n;
    let initMaxExpiry = 259_200n;
    let now = ("2000-01-03t10:10:10Z" as timestamp);
    let expired = ("2000-01-01t10:10:10Z" as timestamp);

    let [admin, owners, owners_with_keys, ops] = Bootstrap.boot_state(now);
    let [owner1, owner2, _owner3] = owners_with_keys;
    let [owner1_addr, _owner1_1, _owner1_2] = owner1;
    let [owner2_addr, _owner2_1, _owner2_2] = owner2;

    let transfer_request = ({
        from_:owner1_addr,
        txs:list([{to_:owner2_addr, amount:2n, token_id:1n}])
    });
    let hash_ = Crypto.blake2b (Bytes.pack (transfer_request));

    let extended_storage = Token_helper.getInitialExtendedStorage(admin, initDefaultExpiry, initMaxExpiry);
    let extended_storage_modified = { ...extended_storage,
        permits : Big_map.literal(list([
            [[owner1_addr, hash_], expired]
        ])),
        counter : 1n
    };

    let tok = Bootstrap.boot_token(owners, ops, init_tok_amount, extended_storage_modified);
    Test.set_source (owner2_addr);
    let r = Token_helper.transfer(list([transfer_request]), tok.contr);
    Assert.string_failure(r, Token.FA2.Errors.not_operator)
};

const test_success : unit = _test_success();
const test_success_by_operator_with_expired_permit : unit = _test_success_by_operator_with_expired_permit();
const test_failure_expired_permit : unit = _test_failure_expired_permit();


Permit-JsLIGOv1.0

example of a permit contract in JsLIGO Resources

Use template

Readme

permit-jsligo

Why permits?

Requirements

Usage

Token distribution

Permit creation

Permit consumption

Entrypoints

Smart Contract Data Types

Resources

Contract informations

update_operators

Arguments

Marigold