nft-auction-v4r1.func

#include "./stdlib.fc";
#include "op-codes.fc";


;; auction for jettons/tons
;; see https://github.com/getgems-io/nft-contracts

;;
;;  custom TVM exit codes
;;

int exit::low_bid()             asm "1000 PUSHINT";
int exit::auction_init()        asm "1001 PUSHINT";
int exit::no_transfer()         asm "1002 PUSHINT";
int exit::not_cancel()          asm "1004 PUSHINT";
int exit::auction_end()         asm "1005 PUSHINT";
int exit::already_activated()   asm "1006 PUSHINT";
int exit::low_amount()          asm "1008 PUSHINT";
int exit::cant_cancel_bid()     asm "1009 PUSHINT";
int exit::cant_stop_time()      asm "1010 PUSHINT";
int exit::bad_mode()            asm "1012 PUSHINT";
int exit::last_bid_too_close()  asm "1013 PUSHINT";
int exit::its_too_long_auc()     asm "1014 PUSHINT";
int exit::not_activated_yet()   asm "1015 PUSHINT";
int exit::broken_state()   asm "1016 PUSHINT";
int exit::wrong_currency()   asm "1017 PUSHINT";


const int op::finish_acution = "finish_auction"c;
const int op::cancel_acution = "cancel_auction"c;
const int op::set_jetton_wallet = "set_jetton_wallet"c;
const int op::process_ton_bid = "process_ton_bid"c;
const int op::deploy_auction = "deploy_auction"c;

const int TON_FOR_NFT_PROCESS = 100000000; ;; 0.1 TON
const int TON_FOR_JETTON = 50000000; ;; 0.05 TON
const int TON_FOR_END_JETTON_AUC = TON_FOR_JETTON + TON_FOR_JETTON + TON_FOR_JETTON + TON_FOR_NFT_PROCESS;
const int TON_FOR_END_TON_AUC = TON_FOR_NFT_PROCESS;

forall X -> int cast_to_int(X x) asm "NOP";
slice null_addr() asm "b{00} PUSHSLICE";
int get_compute_fee(int workchain, int gas_used) asm(gas_used workchain) "GETGASFEE";

;;
;;  persistant and runtime storage description
;;

global int      init?; ;; init_data safe check
global int      end?; ;; end auction or not
global slice    mp_addr; ;; the address of the marketplace from which the contract is deployed
global int      activated?; ;; contract is activated by external message or by nft transfer
global int      created_at?; ;; timestamp of created acution
global int      is_canceled?; ;; auction was cancelled by owner

global cell fees_cell;
global cell constant_cell;

global int      is_jetton_mode; ;;
global slice    jetton_wallet; ;; jetton wallet address or null
global slice    jetton_master; ;; jetton master address or null for detect jettons
global int      min_bid; ;; minimal bid
global int      max_bid; ;; maximum bid
global int      min_step; ;; minimum step (can be 0)
global slice    last_member; ;; last member address
global int      last_bid; ;; last bid amount
global int      last_bid_at; ;; timestamp of last bid
global int      last_query_id; ;; last processed query id
global int      end_time; ;; unix end time
global int      step_time; ;; by how much the time increases with the new bid (e.g. 30)
global int      public_key; ;; public key for jetton mode
global int      is_broken_state; ;; broken state
global cell     jt_cell;

;; nft info cell (ref)
global slice    nft_owner; ;; nft owner addres (should be sent nft if auction canceled or money from auction)
global slice    nft_addr; ;; nft address

;;
;;  math utils
;;
int math::get_percent(int a, int percent, int factor) inline {
    if (factor == 0) {
        return 0;
    } else {
        return muldiv(a, percent, factor);
    }
}

int math::check_profitable(int mp_fee_factor, int mp_fee_base, int royalty_fee_factor, int royalty_fee_base) inline {
    int amount = 10000000000;
    int mp_fee = math::get_percent(amount, mp_fee_factor, mp_fee_base);
    int royalty_fee = math::get_percent(amount, royalty_fee_factor, royalty_fee_base);
    int profit = amount - mp_fee - royalty_fee;
    if (profit < 1) {
        return 0;
    }
    return 1;
}


() send_jettons(slice jetton_wallet_address, int query_id, slice address, int amount, slice response_address, int fwd_amount) impure inline_ref {
    if (amount <= 0) {
        return ();
    }

    int should_carry_gas = false;
    if (fwd_amount == -1) {
        fwd_amount = 0;
        should_carry_gas = true;
    }

    var msg_payload = begin_cell()
        .store_uint(jetton::transfer(), 32) ;; transfer
        .store_uint(query_id, 64)
        .store_coins(amount)
        .store_slice(address)
        .store_slice(response_address)
        .store_int(0, 1)
        .store_coins(fwd_amount)
        .store_uint(0, 1)
        .end_cell();

    var msg = begin_cell()
        .store_uint(0x10, 6) ;; nobounce
        .store_slice(jetton_wallet_address)
        .store_coins(should_carry_gas ? 0 : (40000000 + fwd_amount)) ;; 0.04 TON or zero
        .store_uint(1, 1 + 4 + 4 + 64 + 32 + 1 + 1)
        .store_ref(msg_payload)
        .end_cell();

    int flag = should_carry_gas ? (64 + 2) : (1 + 2);
    send_raw_message(msg, flag);
}

() pack_data() impure inline_ref {
    set_data(
        begin_cell()
            .store_int(end?, 1) ;;              1
            .store_int(is_canceled?, 1) ;;      1
            .store_slice(last_member) ;;            267 ($10 with Anycast = 0)
            .store_coins(last_bid) ;;               127
            .store_uint(last_bid_at, 32) ;;     32
            .store_uint(end_time, 32) ;;        32
            .store_slice(nft_owner) ;;              267
            .store_uint(last_query_id, 64) ;;   64
            .store_ref(fees_cell) ;; + ref
            .store_ref(constant_cell) ;; + ref
            .store_maybe_ref(jt_cell) ;; +1
            .end_cell() ;; total 1+1+267+127+32+32+267+64+1 = 792
    );
}

() init_data() impure inline_ref {- save for get methods -} {
    ifnot (null?(init?)) {
        return ();
    }

    slice ds = get_data().begin_parse();
    end? = ds~load_int(1);
    is_canceled? = ds~load_int(1);
    last_member = ds~load_msg_addr();
    last_bid = ds~load_coins();
    last_bid_at = ds~load_uint(32);
    end_time = ds~load_uint(32);
    nft_owner = ds~load_msg_addr();
    activated? = nft_owner.slice_bits() > 2;
    last_query_id = ds~load_uint(64);

    fees_cell = ds~load_ref();
    constant_cell = ds~load_ref();
    slice constants = constant_cell.begin_parse();
    mp_addr = constants~load_msg_addr(); ;; 267
    min_bid = constants~load_coins(); ;; 127
    max_bid = constants~load_coins(); ;; 127
    min_step = constants~load_uint(7); ;;7
    step_time = constants~load_uint(17); ;;17
    nft_addr = constants~load_msg_addr(); ;; 267
    created_at? = constants~load_uint(32); ;; 32
    ;; total 267+127+127+7+17+267+32=844

    int has_jetton_data = ds~load_uint(1);
    public_key = 0;
    is_jetton_mode = false;
    if (has_jetton_data == 1) {
        jt_cell = ds~load_ref();
        slice jt_slice = jt_cell.begin_parse();

        jetton_wallet = jt_slice~load_msg_addr(); ;; 267
        jetton_master = jt_slice~load_msg_addr(); ;; 267
        is_jetton_mode = jetton_wallet.slice_bits() > 2;

        is_broken_state = false;
        if ((jetton_master.slice_bits() > 2) & (is_jetton_mode == false)) {
            is_broken_state = true;
        }

        int has_public_key = jt_slice~load_uint(1);
        if (has_public_key == 1) {
            public_key = jt_slice~load_uint(256);
            is_broken_state = true;
        }
    } else {
        jetton_wallet = null_addr();
        jetton_master = null_addr();
        is_broken_state = false;
    }




    init? = true;
}

(slice, slice, int, int, int, int) get_fees_addresses() inline_ref {
    slice fees = fees_cell.begin_parse();
    slice mp_fee_addr = fees~load_msg_addr();
    slice royalty_fee_addr = fees~load_msg_addr();
    int mp_fee_factor = fees~load_uint(32);
    int mp_fee_base = fees~load_uint(32);
    int royalty_fee_factor = fees~load_uint(32);
    int royalty_fee_base = fees~load_uint(32);
    return (
        mp_fee_addr,
        royalty_fee_addr,
        mp_fee_factor,
        mp_fee_base,
        royalty_fee_factor,
        royalty_fee_base
    );
}

{-
    SHOULD
    [+] check init auction or not
    [+] check op
    [+] change nft owner
    [+] change auction status
-}
() handle::try_init_auction(slice sender_addr, slice in_msg_body) impure inline_ref {
    throw_if(exit::auction_init(), nft_owner.slice_bits() > 2); ;; throw if auction already init
    throw_unless(exit::no_transfer(), in_msg_body~load_uint(32) == op::ownership_assigned()); ;; throw if it`s not ownership assigned
    in_msg_body~skip_bits(64); ;; query id
    nft_owner = in_msg_body~load_msg_addr();
    end? = false;
    activated? = true;
    pack_data();
}

() return_nft(int query_id, slice fee_pay_address, slice new_owner) impure inline_ref {
    builder nft_transfer_body = begin_cell()
        .store_uint(op::transfer(), 32)
        .store_uint(query_id, 64) ;; query id
        .store_slice(new_owner) ;; return nft no creator
        .store_slice(fee_pay_address) ;; response_destination
        .store_uint(0, 1) ;; custom payload
        .store_coins(1) ;; forward amount
        .store_uint(0, 1); ;; forward payload

    builder nft_return_msg = begin_cell()
        .store_uint(0x18, 6)
        .store_slice(nft_addr)
        .store_coins(0)
        .store_uint(1, 1 + 4 + 4 + 64 + 32 + 1 + 1)
        .store_ref(nft_transfer_body.end_cell());

    send_raw_message(nft_return_msg.end_cell(), 130);  ;; 128 +2 for ignoring errors
}

() handle::cancel(int query_id, slice sender_addr) impure inline_ref {
    return_nft(query_id, sender_addr, nft_owner);
    end? = true;
    is_canceled? = true;
    pack_data();
}

() send_founds(slice to_address, int amonut, int query_id, slice fee_pay_address) impure inline_ref {
    if (is_jetton_mode == true) {
        send_jettons(jetton_wallet, query_id, to_address, amonut, fee_pay_address, 1);
    } else {
        builder transfer = begin_cell()
            .store_uint(0x10, 6) ;; 0 (int_msg_info) 1 (ihr_disabled) 1 (no bounces) 00 (address)
            .store_slice(to_address)
            .store_coins(amonut)
            .store_uint(0, 1 + 4 + 4 + 64 + 32 + 1 + 1);

        send_raw_message(transfer.end_cell(), 2);
    }
}

int get_price_for_end_auction() inline {
    if (is_jetton_mode == true) {
        return TON_FOR_END_JETTON_AUC;
    } else {
        return TON_FOR_END_TON_AUC;
    }
}

() check_ok_balance(int my_balance) impure inline {
    throw_if(exit::low_bid(), my_balance < get_price_for_end_auction());
    accept_message();
}

() handle::end_auction(slice sender_addr, int from_external, int query_id) impure inline_ref {
    if (last_bid == 0) {
        ;; just return nft

        if (from_external == true) {
            [int my_balance, _] = get_balance();
            check_ok_balance(my_balance);
        }

        handle::cancel(query_id, sender_addr);
        return ();
    }

    var (
        mp_fee_addr,
        royalty_fee_addr,
        mp_fee_factor,
        mp_fee_base,
        royalty_fee_factor,
        royalty_fee_base
    ) = get_fees_addresses();

    int last_bid_avaliable_profit = last_bid;
    if (is_jetton_mode == false) {
        [int my_balance, _] = get_balance();
        last_bid_avaliable_profit = min(last_bid_avaliable_profit, (my_balance - get_price_for_end_auction()));
        throw_unless(exit::low_amount(), last_bid_avaliable_profit > 0);
    }


    int mp_fee = math::get_percent(last_bid_avaliable_profit, mp_fee_factor, mp_fee_base);
    int royalty_fee = math::get_percent(last_bid_avaliable_profit, royalty_fee_factor, royalty_fee_base);
    int profit = last_bid_avaliable_profit - mp_fee - royalty_fee;

    if (from_external == true) {
        if (is_jetton_mode == false) {
            check_ok_balance(profit);
            profit = profit - get_price_for_end_auction();
        } else {
            [int my_balance, _] = get_balance();
            check_ok_balance(my_balance);
        }
    }

    if (mp_fee > 0) {
        send_founds(mp_fee_addr, mp_fee, query_id, sender_addr);
    }

    if (royalty_fee > 0) {
        send_founds(royalty_fee_addr, royalty_fee, query_id, sender_addr);
    }

    if (profit > 0) {
        send_founds(nft_owner, profit, query_id, sender_addr);
    }


    return_nft(query_id, sender_addr, last_member);
    end? = true;
    is_canceled? = false;
    end_time = now();
    pack_data();
}

;;
;;  main code
;;

() return_last_bid(int query_id, slice fee_pay_address, int my_balance) impure inline_ref {
    if (last_bid <= 0) {
        return ();
    }
    if (is_jetton_mode == true) {
        send_jettons(jetton_wallet, query_id, last_member, last_bid, fee_pay_address, 1);
    } else {
        int magic_gas_price = get_compute_fee(false, 11169);
        int return_bid_amount = last_bid - magic_gas_price;
        if (return_bid_amount > (my_balance - 10000000)) {
            ;; - 0.01 TON
            return_bid_amount = my_balance - 10000000;
        }
        if (return_bid_amount > 0) {
            builder return_prev_bid = begin_cell()
                .store_uint(0x18, 6)
                .store_slice(last_member)
                .store_coins(return_bid_amount)
                .store_uint(0, 1 + 4 + 4 + 64 + 32 + 1 + 1)
                .store_uint(0, 32)
                .store_slice("Your bid has been outbid by another user");

            send_raw_message(return_prev_bid.end_cell(), 2);
        }
    }
}

int get_next_min_bid() {
    if (is_jetton_mode) {
        return math::get_percent(last_bid, 100 + min_step, 100);
    } else {
        return max(
            last_bid + 100000000, ;; 0.1 ton
            math::get_percent(last_bid, 100 + min_step, 100)
        );
    }
}

() process_new_bid(int query_id, slice sender_addr, int bid_value, int ton_value, int my_balance) impure inline_ref {
    if (activated? == false) {
        throw(exit::not_activated_yet());
        return ();
    }

    if (is_broken_state == true) {
        throw(exit::broken_state());
        return ();
    }

    if ((end? == true) | (now() >= end_time)) {
        throw(exit::auction_end());
        return ();
    }

    ;; auction large than 20 days not allowed
    int duration = end_time - now();
    throw_if(exit::its_too_long_auc(), duration > 60 * 60 * 24 * 20);

    ;; max bid buy nft
    if ((bid_value >= max_bid) & (max_bid > 0)) {
        if (is_jetton_mode == true) {
            throw_if(exit::low_amount(), ton_value < TON_FOR_END_JETTON_AUC);
        } else {
            throw_if(exit::low_amount(), ton_value < (max_bid + TON_FOR_END_TON_AUC));
        }

        return_last_bid(query_id, sender_addr, my_balance);
        last_member = sender_addr;
        last_bid = max_bid;
        last_bid_at = now();
        last_query_id = query_id;
        handle::end_auction(sender_addr, false, query_id);
        return ();
    }

    ;; prevent bid at last second
    if ((end_time - step_time) < now()) {
        end_time += step_time;
    }

    ifnot (last_bid) {
        throw_if(exit::low_bid(), bid_value < min_bid);
        last_bid = bid_value;
        last_member = sender_addr;
        last_bid_at = now();
        last_query_id = query_id;
        pack_data();
        return ();
    }

    int new_min_bid = get_next_min_bid();
    if (bid_value < new_min_bid) {
        throw(exit::low_bid());
        return ();
    }

    if (is_jetton_mode == true) {
        throw_if(exit::low_amount(), ton_value < TON_FOR_JETTON);
    }
    return_last_bid(query_id, sender_addr, my_balance);

    last_member = sender_addr;
    last_bid = bid_value;
    last_bid_at = now();
    last_query_id = query_id;

    pack_data();
}

() recv_internal(int my_balance, int msg_value, cell in_msg_cell, slice in_msg_body) impure {
    slice cs = in_msg_cell.begin_parse();
    throw_if(0, cs~load_uint(4) & 1);

    slice sender_addr = cs~load_msg_addr();
    init_data();

    if (equal_slices(sender_addr, nft_addr)) {
        if (end? == false) {
            handle::try_init_auction(sender_addr, in_msg_body);
        } else {
            int query_id = in_msg_body~load_uint(64); ;; query id
            slice old_nft_owner = in_msg_body~load_msg_addr();
            return_nft(query_id, sender_addr, old_nft_owner);
        }
        return ();
    }

    int op = 0;
    int query_id = 0;
    if (slice_empty?(in_msg_body) == false) {
        op = in_msg_body~load_uint(32);
        if (op != 0) {
            query_id = in_msg_body~load_uint(64);
        }
    }


    if (op == 555) {
        throw_unless(exit::not_cancel(), ((end? == true) | (activated? == false)));
        throw_unless(403, equal_slices(sender_addr, mp_addr));
        ;; way to fix unexpected troubles with auction contract
        ;; for example if some one transfer nft to this contract
        var msg = in_msg_body~load_ref().begin_parse();
        var mode = msg~load_uint(8);
        throw_if(exit::bad_mode(), mode & 32);

        int ten_min = 10 * 60;
        throw_if(exit::last_bid_too_close(), (now() > (end_time - ten_min)) & (now() < (end_time + ten_min)));
        if (last_bid_at != 0) {
            throw_if(exit::last_bid_too_close(), (now() > (last_bid_at - ten_min)) & (now() < (last_bid_at + ten_min)));
        }

        send_raw_message(msg~load_ref(), mode);
        if (end? != true) {
            end? = true;
            pack_data();
        }
        return ();
    }

    if (op == op::cancel_acution) {
        ;; cancel command, return nft if no bid yet
        throw_if(exit::auction_end(), now() >= end_time); ;; after timeout can't cancel
        throw_if(exit::auction_end(), end? == true); ;; already canceled/ended
        throw_if(exit::not_activated_yet(), activated? == false);
        throw_if(exit::low_amount(), msg_value < TON_FOR_NFT_PROCESS);
        throw_if(exit::cant_cancel_bid(), last_bid > 0); ;; can't cancel if someone already placed a bid
        throw_unless(403, equal_slices(sender_addr, nft_owner) | equal_slices(sender_addr, mp_addr));
        handle::cancel(query_id, sender_addr);
        return ();
    }

    if (op == op::finish_acution) {
        ;; stop auction
        throw_if(exit::auction_end(), end? == true); ;; end = true mean this action already executed
        throw_if(exit::not_activated_yet(), activated? == false);
        int price_for_end = get_price_for_end_auction();
        throw_if(exit::low_amount(), msg_value < price_for_end);
        throw_if(exit::cant_stop_time(), now() < end_time); ;; can't end auction in progress, only after end time
        throw_unless(403, equal_slices(sender_addr, nft_owner) | equal_slices(sender_addr, mp_addr) | equal_slices(sender_addr, last_member));
        handle::end_auction(sender_addr, false, query_id);
        return ();
    }

    if (op == op::deploy_auction) {
        ;; just accept coins
        return ();
    }

    if (op == op::set_jetton_wallet) {
        throw_if(exit::already_activated(), public_key == 0);
        throw_if(exit::cant_cancel_bid(), last_bid > 0);

        var signature = in_msg_body~load_bits(512);
        var payload = slice_hash(in_msg_body);
        throw_unless(35, check_signature(payload, signature, public_key));
        ;; check than update from expected address
        throw_unless(403, equal_slices(sender_addr, jetton_wallet));

        jetton_wallet = in_msg_body~load_msg_addr();
        in_msg_body.end_parse();
        var (wc, hash) = parse_std_addr(jetton_wallet);
        throw_unless(36, wc == 0);

        jt_cell = begin_cell()
            .store_slice(jetton_wallet)
            .store_slice(jetton_master)
            .store_uint(0, 1)
            .end_cell();

        pack_data();
        return ();
    }

    ;; bid process

    if ((op == 0) | (op == op::process_ton_bid)) {
        throw_unless(exit::wrong_currency(), is_jetton_mode == false);
        process_new_bid(query_id, sender_addr, msg_value, msg_value, msg_value);
        return ();
    }

    if (op == jetton::transfer_notification()) {
        var (wc, addr_hash) = parse_std_addr(sender_addr);

        ;; check workchain
        throw_unless(452, wc == 0);

        ;; load amount
        var jetton_amount = in_msg_body~load_coins();
        var buyer_address = in_msg_body~load_msg_addr();

        if ((is_jetton_mode == false) | (equal_slices(sender_addr, jetton_wallet) == false)) {
            send_jettons(sender_addr, exit::wrong_currency(), buyer_address, jetton_amount, buyer_address, -1);
            return ();
        }

        try {
            process_new_bid(query_id, buyer_address, jetton_amount, msg_value, my_balance);
        }  catch (__, error_code) {
            send_jettons(sender_addr, error_code, buyer_address, jetton_amount, buyer_address, -1);
        }

        return ();
    }

    throw(0xffff);
}

() recv_external(slice in_msg) impure {
    init_data();

    int op = in_msg~load_uint(32);
    int query_id = in_msg~load_uint(64);

    if (op == op::finish_acution) {
        throw_if(exit::not_activated_yet(), activated? == false);
        throw_if(exit::auction_end(), end? == true); ;; end = true mean this action already executed
        throw_if(exit::cant_stop_time(), now() < end_time); ;; can't end auction in progress, only after end time
        handle::end_auction(nft_owner, true, query_id);
        return ();
    }

    throw(0xffff);
}

(int, int, int, slice, slice, slice, int, slice, int, slice, int, int, slice, int, int, int, int, int, int, int, int, int, slice, slice, int, int) get_auction_data_v4() method_id {
    init_data();

    var (
        mp_fee_addr,
        royalty_fee_addr,
        mp_fee_factor,
        mp_fee_base,
        royalty_fee_factor,
        royalty_fee_base
    ) = get_fees_addresses();

    var profitable = math::check_profitable(mp_fee_factor, mp_fee_base, royalty_fee_factor, royalty_fee_base);
    if (profitable == 0) {
        is_broken_state = true;
    }

    if (last_bid > 0) {
        min_bid = get_next_min_bid();
    }

    return (
        activated?, ;;1
        end?, ;; 2
        end_time, ;; 3
        mp_addr, ;; 4
        nft_addr, ;; 5
        nft_owner, ;; 6
        last_bid, ;; 7
        last_member, ;; 8
        min_step, ;; 9 min step
        mp_fee_addr, ;; 10
        mp_fee_factor, mp_fee_base, ;; 11, 12
        royalty_fee_addr, ;; 13
        royalty_fee_factor, royalty_fee_base, ;; 14, 15
        max_bid, ;; 16
        min_bid, ;; 17
        created_at?, ;; 18
        last_bid_at, ;; 19
        is_canceled?, ;; 20
        step_time, ;; 21
        last_query_id, ;; 22
        jetton_wallet, ;; 23
        jetton_master, ;; 24
        is_broken_state, ;; 25
        public_key ;; 26
    );
}