config-code.fc

#pragma version =0.4.6;
;; Currently deployed config-contract in mainnet can be found
;; on https://verifier.ton.org/Ef9VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVbxn
;; Tests and other artifacts of this contract version are available at https://github.com/ton-blockchain/config-with-ownable-params

(slice, int) check_exotic(cell c) asm "XCTOS";
int equal_slice_bits (slice a, slice b) asm "SDEQ";

const int CUSTOM_PARAM_1 = -1024;
const int CUSTOM_PARAM_2 = -1025;
const slice ADMIN_ADDRESS_FOR_CUSTOM_PARAMS = "EQA_o6NFLu73wozeYNERTsW8lkU5OarbRbIkoNuWdy5SPDA_"a;
const int OP_SET_CUSTOM_PARAM = 0x6e43536c;

() set_conf_param(int index, cell value) impure {
  var cs = get_data().begin_parse();
  var cfg_dict = cs~load_ref();
  cfg_dict~idict_set_ref(32, index, value);
  set_data(begin_cell().store_ref(cfg_dict).store_slice(cs).end_cell());
}

(cell, int, int, cell) load_data() inline {
  var cs = get_data().begin_parse();
  var res = (cs~load_ref(), cs~load_uint(32), cs~load_uint(256), cs~load_dict());
  cs.end_parse();
  return res;
}

() store_data(cfg_dict, stored_seqno, public_key, vote_dict) impure inline {
  set_data(begin_cell()
    .store_ref(cfg_dict)
    .store_uint(stored_seqno, 32)
    .store_uint(public_key, 256)
    .store_dict(vote_dict)
  .end_cell());
}

;; (min_tot_rounds, max_tot_rounds, min_wins, max_losses, min_store_sec, max_store_sec, bit_price, cell_price)
_ parse_vote_config(cell c) inline {
  var cs = c.begin_parse();
  throw_unless(44, cs~load_uint(8) == 0x36);
  var res = (cs~load_uint(8), cs~load_uint(8), cs~load_uint(8), cs~load_uint(8), cs~load_uint(32), cs~load_uint(32), cs~load_uint(32), cs~load_uint(32));
  cs.end_parse();
  return res;
}

;; cfg_vote_setup#91 normal_params:^ConfigProposalSetup critical_params:^ConfigProposalSetup = ConfigVotingSetup;
_ get_vote_config_internal(int critical?, cell cparam11) inline_ref {
  var cs = cparam11.begin_parse();
  throw_unless(44, cs~load_uint(8) == 0x91);
  if (critical?) {
    cs~load_ref();
  }
  return parse_vote_config(cs.preload_ref());
}

_ get_vote_config(int critical?) inline {
  return get_vote_config_internal(critical?, config_param(11));
}

(int, int) check_validator_set(cell vset) {
  var cs = vset.begin_parse();
  throw_unless(9, cs~load_uint(8) == 0x12);  ;; validators_ext#12 only
  int utime_since = cs~load_uint(32);
  int utime_until = cs~load_uint(32);
  int total = cs~load_uint(16);
  int main = cs~load_uint(16);
  throw_unless(9, main > 0);
  throw_unless(9, total >= main);
  return (utime_since, utime_until);
}

() send_answer(addr, query_id, ans_tag, mode) impure {
  ;; int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool src:MsgAddress -> 011000
  send_raw_message(begin_cell()
    .store_uint(0x18, 6)
    .store_slice(addr)
    .store_uint(0, 5 + 4 + 4 + 64 + 32 + 1 + 1)
    .store_uint(ans_tag, 32)
    .store_uint(query_id, 64)
  .end_cell(), mode);
}

() send_confirmation(addr, query_id, ans_tag) impure inline {
  return send_answer(addr, query_id, ans_tag, 64);
}

() send_error(addr, query_id, ans_tag) impure inline {
  return send_answer(addr, query_id, ans_tag, 64);
}

;; forward a message to elector smart contract to make it upgrade its code
() change_elector_code(slice cs) impure {
  var dest_addr = config_param(1).begin_parse().preload_uint(256);
  var query_id = now();
  send_raw_message(begin_cell()
   .store_uint(0xc4ff, 17)
   .store_uint(dest_addr, 256)
   .store_grams(1 << 30)         ;; ~ 1 Gram (will be returned back)
   .store_uint(0, 1 + 4 + 4 + 64 + 32 + 1 + 1)
   .store_uint(0x4e436f64, 32)   ;; action
   .store_uint(query_id, 64)
   .store_slice(cs)
  .end_cell(), 0);
}

() after_code_upgrade(slice param, cont old_code) impure method_id(1666) {
}

_ perform_action(cfg_dict, public_key, action, cs) inline_ref {
  if (action == 0x43665021) {
    ;; change one configuration parameter
    var param_index = cs~load_int(32);
    var param_value = cs~load_ref();
    cs.end_parse();
    cfg_dict~idict_set_ref(32, param_index, param_value);
    return (cfg_dict, public_key);
  } elseif (action == 0x4e436f64) {
    ;; change configuration smart contract code
    var new_code = cs~load_ref();
    set_code(new_code);
    var old_code = get_c3();
    set_c3(new_code.begin_parse().bless());
    after_code_upgrade(cs, old_code);
    throw(0);
    return (cfg_dict, public_key);
  } elseif (action == 0x50624b21) {
    ;; change configuration master public key
    public_key = cs~load_uint(256);
    cs.end_parse();
    return (cfg_dict, public_key);
  } elseif (action == 0x4e43ef05) {
    ;; change election smart contract code
    change_elector_code(cs);
    return (cfg_dict, public_key);
  } else {
    throw_if(32, action);
    return (cfg_dict, public_key);
  }
}

(cell, int, cell) get_current_vset() inline_ref {
  var vset = config_param(34);
  var cs = begin_parse(vset);
  ;; validators_ext#12 utime_since:uint32 utime_until:uint32
  ;; total:(## 16) main:(## 16) { main <= total } { main >= 1 }
  ;; total_weight:uint64
  throw_unless(40, cs~load_uint(8) == 0x12);
  cs~skip_bits(32 + 32 + 16 + 16);
  var (total_weight, dict) = (cs~load_uint(64), cs~load_dict());
  cs.end_parse();
  return (vset, total_weight, dict);
}

(slice, int) get_validator_descr(int idx) inline_ref {
  var (vset, total_weight, dict) = get_current_vset();
  var (value, _) = dict.udict_get?(16, idx);
  return (value, total_weight);
}

(int, int) unpack_validator_descr(slice cs) inline {
  ;; ed25519_pubkey#8e81278a pubkey:bits256 = SigPubKey;
  ;; validator#53 public_key:SigPubKey weight:uint64 = ValidatorDescr;
  ;; validator_addr#73 public_key:SigPubKey weight:uint64 adnl_addr:bits256 = ValidatorDescr;
  throw_unless(41, (cs~load_uint(8) & ~ 0x20) == 0x53);
  throw_unless(41, cs~load_uint(32) == 0x8e81278a);
  return (cs~load_uint(256), cs~load_uint(64));
}

;; cfg_proposal#f3 param_id:int32 param_value:(Maybe ^Cell) if_hash_equal:(Maybe uint256)
;; c -> (param-id param-cell maybe-hash)
(int, cell, int) parse_config_proposal(cell c) inline_ref {
  var cs = c.begin_parse();
  throw_unless(44, cs~load_int(8) == 0xf3 - 0x100);
  var (id, val, hash) = (cs~load_int(32), cs~load_maybe_ref(), cs~load_int(1));
  if (hash) {
    hash = cs~load_uint(256);
  } else {
    hash = -1;
  }
  cs.end_parse();
  return (id, val, hash);
}

(cell, int, cell) accept_proposal(cell cfg_dict, cell proposal, int critical?) inline_ref {
  var (param_id, param_val, req_hash) = parse_config_proposal(proposal);
  cell cur_val = cfg_dict.idict_get_ref(32, param_id);
  int cur_hash = null?(cur_val) ? 0 : cell_hash(cur_val);
  if ((cur_hash != req_hash) & (req_hash >= 0)) {
    ;; current value has incorrect hash, do not apply changes
    return (cfg_dict, 0, null());
  }
  if ((param_id == CUSTOM_PARAM_1) | (param_id == CUSTOM_PARAM_2)) {
    ;; Custom parameters cannot be changed by validator voting, do not apply changes
    return (cfg_dict, 0, null());
  }
  cell mparams = cfg_dict.idict_get_ref(32, 9);  ;; mandatory parameters
  var (_, found?) = mparams.idict_get?(32, param_id);
  if (found? & param_val.null?()) {
    ;; cannot set a mandatory parameter to (null)
    return (cfg_dict, 0, null());
  }
  cell cparams = cfg_dict.idict_get_ref(32, 10);  ;; critical parameters
  (_, found?) = cparams.idict_get?(32, param_id);
  if (found? < critical?) {
    ;; trying to set a critical parameter after a non-critical voting
    return (cfg_dict, 0, null());
  }
  ;; CHANGE ONE CONFIGURATION PARAMETER (!)
  cfg_dict~idict_set_ref(32, param_id, param_val);
  return (cfg_dict, param_id, param_val);
}

(cell, int) perform_proposed_action(cell cfg_dict, int public_key, int param_id, cell param_val) inline_ref {
  if (param_id == -999) {
    ;; appoint or depose dictator
    return (cfg_dict, param_val.null?() ? 0 : param_val.begin_parse().preload_uint(256));
  }
  if (param_val.null?()) {
    return (cfg_dict, public_key);
  }
  if (param_id == -1000) {
    ;; upgrade code
    var cs = param_val.begin_parse();
    var new_code = cs~load_ref();
    set_code(new_code);
    var old_code = get_c3();
    set_c3(new_code.begin_parse().bless());
    after_code_upgrade(cs, old_code);
    throw(0);
    return (cfg_dict, public_key);
  }
  if (param_id == -1001) {
    ;; update elector code
    var cs = param_val.begin_parse();
    change_elector_code(cs);
  }
  return (cfg_dict, public_key);
}

;; cfg_proposal_status#ce expires:uint32 proposal:^ConfigProposal is_critical:Bool
;;  voters:(HashmapE 16 True) remaining_weight:int64 validator_set_id:uint256
;;  rounds_remaining:uint8 wins:uint8 losses:uint8 = ConfigProposalStatus;
(int, cell, int, cell, int, int, slice) unpack_proposal_status(slice cs) inline_ref {
  throw_unless(44, cs~load_int(8) == 0xce - 0x100);
  return (cs~load_uint(32), cs~load_ref(), cs~load_int(1), cs~load_dict(), cs~load_int(64), cs~load_uint(256), cs);
}

slice update_proposal_status(slice rest, int weight_remaining, int critical?) inline_ref {
  var (min_tot_rounds, max_tot_rounds, min_wins, max_losses, _, _, _, _) = get_vote_config(critical?);
  var (rounds_remaining, wins, losses) = (rest~load_uint(8), rest~load_uint(8), rest~load_uint(8));
  losses -= (weight_remaining >= 0);
  if (losses > max_losses) {
    ;; lost too many times
    return null();
  }
  rounds_remaining -= 1;
  if (rounds_remaining < 0) {
    ;; existed for too many rounds
    return null();
  }
  return begin_cell()
    .store_uint(rounds_remaining, 8)
    .store_uint(wins, 8)
    .store_uint(losses, 8)
  .end_cell().begin_parse();
}

builder begin_pack_proposal_status(int expires, cell proposal, int critical?, cell voters, int weight_remaining, int vset_id) inline {
  return begin_cell()
    .store_int(0xce - 0x100, 8)
    .store_uint(expires, 32)
    .store_ref(proposal)
    .store_int(critical?, 1)
    .store_dict(voters)
    .store_int(weight_remaining, 64)
    .store_uint(vset_id, 256);
}

(cell, cell, int) register_vote(vote_dict, phash, idx, weight) inline_ref {
  var (pstatus, found?) = vote_dict.udict_get?(256, phash);
  ifnot (found?) {
    ;; config proposal not found
    return (vote_dict, null(), -1);
  }
  var (cur_vset, total_weight, _) = get_current_vset();
  int cur_vset_id = cur_vset.cell_hash();
  var (expires, proposal, critical?, voters, weight_remaining, vset_id, rest) = unpack_proposal_status(pstatus);
  if (expires <= now()) {
    ;; config proposal expired, delete and report not found
    vote_dict~udict_delete?(256, phash);
    return (vote_dict, null(), -1);
  }
  if (vset_id != cur_vset_id) {
    ;; config proposal belongs to a previous validator set
    vset_id = cur_vset_id;
    rest = update_proposal_status(rest, weight_remaining, critical?);
    voters = null();
    weight_remaining = muldiv(total_weight, 3, 4);
  }
  if (rest.null?()) {
    ;; discard proposal (existed for too many rounds, or too many losses)
    vote_dict~udict_delete?(256, phash);
    return (vote_dict, null(), -1);
  }
  var (_, found?) = voters.udict_get?(16, idx);
  if (found?) {
    ;; already voted for this proposal, ignore vote
    return (vote_dict, null(), -2);
  }
  ;; register vote
  voters~udict_set_builder(16, idx, begin_cell().store_uint(now(), 32));
  int old_wr = weight_remaining;
  weight_remaining -= weight;
  if ((weight_remaining ^ old_wr) >= 0) {
    ;; not enough votes, or proposal already accepted in this round
    ;; simply update weight_remaining
    vote_dict~udict_set_builder(256, phash, begin_pack_proposal_status(expires, proposal, critical?, voters, weight_remaining, vset_id).store_slice(rest));
    return (vote_dict, null(), 2);
  }
  ;; proposal wins in this round
  var (min_tot_rounds, max_tot_rounds, min_wins, max_losses, _, _, _, _) = get_vote_config(critical?);
  var (rounds_remaining, wins, losses) = (rest~load_uint(8), rest~load_uint(8), rest~load_uint(8));
  wins += 1;
  if (wins >= min_wins) {
    ;; proposal is accepted, remove and process
    vote_dict~udict_delete?(256, phash);
    return (vote_dict, proposal, 6 - critical?);
  }
  ;; update proposal info
  vote_dict~udict_set_builder(256, phash,
    begin_pack_proposal_status(expires, proposal, critical?, voters, weight_remaining, vset_id)
    .store_uint(rounds_remaining, 8)
    .store_uint(wins, 8)
    .store_uint(losses, 8));
  return (vote_dict, null(), 2);
}

int proceed_register_vote(phash, idx, weight) impure inline_ref {
  var (cfg_dict, stored_seqno, public_key, vote_dict) = load_data();
  (vote_dict, var accepted_proposal, var status) = register_vote(vote_dict, phash, idx, weight);
  store_data(cfg_dict, stored_seqno, public_key, vote_dict);
  ifnot (accepted_proposal.null?()) {
    var critical? = 6 - status;
    (cfg_dict, var param_id, var param_val) = accept_proposal(cfg_dict, accepted_proposal, critical?);
    store_data(cfg_dict, stored_seqno, public_key, vote_dict);
    if (param_id) {
      commit();
      (cfg_dict, public_key) = perform_proposed_action(cfg_dict, public_key, param_id, param_val);
      store_data(cfg_dict, stored_seqno, public_key, vote_dict);
    }
  }
  return status;
}

(slice, int) scan_proposal(int phash, slice pstatus) inline_ref {
  var (cur_vset, total_weight, _) = get_current_vset();
  int cur_vset_id = cur_vset.cell_hash();
  var (expires, proposal, critical?, voters, weight_remaining, vset_id, rest) = unpack_proposal_status(pstatus);
  if (expires <= now()) {
    ;; config proposal expired, delete
    return (null(), true);
  }
  if (vset_id == cur_vset_id) {
    ;; config proposal already processed or voted for in this round, change nothing
    return (pstatus, false);
  }
  ;; config proposal belongs to a previous validator set
  vset_id = cur_vset_id;
  rest = update_proposal_status(rest, weight_remaining, critical?);
  voters = null();
  weight_remaining = muldiv(total_weight, 3, 4);
  if (rest.null?()) {
    ;; discard proposal (existed for too many rounds, or too many losses)
    return (null(), true);
  }
  ;; return updated proposal
  return (begin_pack_proposal_status(expires, proposal, critical?, voters, weight_remaining, vset_id).store_slice(rest).end_cell().begin_parse(), true);
}

cell scan_random_proposal(cell vote_dict) inline_ref {
  var (phash, pstatus, found?) = vote_dict.udict_get_nexteq?(256, random());
  ifnot (found?) {
    return vote_dict;
  }
  (pstatus, var changed?) = scan_proposal(phash, pstatus);
  if (changed?) {
    if (pstatus.null?()) {
      vote_dict~udict_delete?(256, phash);
    } else {
      vote_dict~udict_set(256, phash, pstatus);
    }
  }
  return vote_dict;
}

int register_voting_proposal(slice cs, int msg_value) impure inline_ref {
  var (expire_at, proposal, critical?) = (cs~load_uint(32), cs~load_ref(), cs~load_int(1));
  if (expire_at >> 30) {
    expire_at -= now();
  }
  var (param_id, param_val, hash) = parse_config_proposal(proposal);
  if ((param_id == CUSTOM_PARAM_1) | (param_id == CUSTOM_PARAM_2)) {
      return -0xc3726956; ;; negative hash means error and will be returned as answer tag
  }
  if (hash >= 0) {
    cell cur_val = config_param(param_id);
    int cur_hash = null?(cur_val) ? 0 : cell_hash(cur_val);
    if (cur_hash != hash) {
      hash = -0xe2646356;  ;; bad current value
    }
  } else {
    var m_params = config_param(9);
    var (_, found?) = m_params.idict_get?(32, param_id);
    if (found?) {
      hash = -0xcd506e6c;  ;; cannot set mandatory parameter to null
    }
  }
  if (param_val.cell_depth() >= 256) {
    hash = -0xc2616456;  ;; bad value
  }
  if (hash < -1) {
    return hash;  ;; return error if any
  }
  ifnot (critical?) {
    var crit_params = config_param(10);
    var (_, found?) = crit_params.idict_get?(32, param_id);
    if (found?) {
      hash = -0xc3726954;  ;; trying to set a critical parameter without critical flag
    }
  }
  if (hash < -1) {
    return hash;
  }
  ;; obtain vote proposal configuration
  var vote_cfg = get_vote_config(critical?);
  var (min_tot_rounds, max_tot_rounds, min_wins, max_losses, min_store_sec, max_store_sec, bit_price, cell_price) = vote_cfg;
  if (expire_at < min_store_sec) {
    return -0xc5787069;   ;; expired
  }
  expire_at = min(expire_at, max_store_sec);
  ;; compute price
  var (_, bits, refs) = compute_data_size(param_val, 1024);
  var pps = bit_price * (bits + 1024) + cell_price * (refs + 2);
  var price = pps * expire_at;
  expire_at += now();
  var (cfg_dict, stored_seqno, public_key, vote_dict) = load_data();
  int phash = proposal.cell_hash();
  var (pstatus, found?) = vote_dict.udict_get?(256, phash);
  if (found?) {
    ;; proposal already exists; we can only extend it
    var (expires, r_proposal, r_critical?, voters, weight_remaining, vset_id, rest) = unpack_proposal_status(pstatus);
    if (r_critical? != critical?) {
      return -0xc3726955;  ;; cannot upgrade critical parameter to non-critical...
    }
    if (expires >= expire_at) {
      return -0xc16c7245;  ;; proposal already exists
    }
    ;; recompute price
    price = pps * (expire_at - expires + 16384);
    if (msg_value - price < (1 << 30)) {
      return -0xf0617924;   ;; need more money
    }
    ;; update expiration time
    vote_dict~udict_set_builder(256, phash, begin_pack_proposal_status(expire_at, r_proposal, r_critical?, voters, weight_remaining, vset_id).store_slice(rest));
    store_data(cfg_dict, stored_seqno, public_key, vote_dict);
    return price;
  }
  if (msg_value - price < (1 << 30)) {
    return -0xf0617924;   ;; need more money
  }
  ;; obtain current validator set data
  var (vset, total_weight, _) = get_current_vset();
  int weight_remaining = muldiv(total_weight, 3, 4);
  ;; create new proposal
  vote_dict~udict_set_builder(256, phash,
    begin_pack_proposal_status(expire_at, proposal, critical?, null(), weight_remaining, vset.cell_hash())
    .store_uint(max_tot_rounds, 8).store_uint(0, 16));
  store_data(cfg_dict, stored_seqno, public_key, vote_dict);
  return price;
}

() recv_internal(int msg_value, cell in_msg_cell, slice in_msg) impure {
  var cs = in_msg_cell.begin_parse();
  var flags = cs~load_uint(4);  ;; int_msg_info$0 ihr_disabled:Bool bounce:Bool bounced:Bool
  var s_addr = cs~load_msg_addr();
  (int src_wc, int src_addr) = s_addr.parse_std_addr();
  int is_admin_of_custom_param = equal_slice_bits(s_addr, ADMIN_ADDRESS_FOR_CUSTOM_PARAMS);
  int is_valid_workchain = is_admin_of_custom_param | (src_wc == -1);
  if ((~ is_valid_workchain) | (flags & 1) | in_msg.slice_empty?()) {
    ;; source not in masterchain, or a bounced message, or a simple transfer
    return ();
  }
  int tag = in_msg~load_uint(32);
  int query_id = in_msg~load_uint(64);

  throw_if(37, is_admin_of_custom_param & (tag != OP_SET_CUSTOM_PARAM));

  if (tag == 0x4e565354) {
    ;; set next validator set
    var vset = in_msg~load_ref();
    in_msg.end_parse();
    var elector_param = config_param(1);
    var elector_addr = cell_null?(elector_param) ? -1 : elector_param.begin_parse().preload_uint(256);
    var ok = false;
    if (src_addr == elector_addr) {
      ;; message from elector smart contract
      ;; set next validator set
      (var t_since, var t_until) = check_validator_set(vset);
      var t = now();
      ok = (t_since > t) & (t_until > t_since);
    }
    if (ok) {
      set_conf_param(36, vset);
      ;; send confirmation
      return send_confirmation(s_addr, query_id, 0xee764f4b);
    } else {
      return send_error(s_addr, query_id, 0xee764f6f);
    }
  }
  if (tag == OP_SET_CUSTOM_PARAM) {
    cell value = in_msg~load_ref();
    int index = in_msg~load_int(32);
    slice receiver_address = in_msg~load_msg_addr();
    in_msg.end_parse();
    (_, int exotic) = value.check_exotic();
    int depth = value.cell_depth();

    (int response_wc, int response_address_hash) = receiver_address.parse_std_addr(); ;; Checking the validity of the response address
    response_wc~impure_touch(); ;; Prevent compiler optimisation from removing parse_std_addr checking

    if (
      (exotic == 0) & ;; forbid exotic cells in config
      (depth == 0) & ;; forbid cells with more than one ref
      (((index == CUSTOM_PARAM_1) | (index == CUSTOM_PARAM_2)) & is_admin_of_custom_param)
    ) {
      set_conf_param(index, value);
      ;; send confirmation
      return send_confirmation(receiver_address, query_id, 0xef764f4b);
    } else {
      return send_error(receiver_address, query_id, 0xef764f6f);
    }
  }
  if (tag == 0x6e565052) {
    ;; new voting proposal
    var price = register_voting_proposal(in_msg, msg_value);
    int mode = 64;
    int ans_tag = - price;
    if (price >= 0) {
      ;; ok, debit price
      raw_reserve(price, 4);
      ans_tag = 0xee565052;
      mode = 128;
    }
    return send_answer(s_addr, query_id, ans_tag, mode);
  }
  if (tag == 0x566f7465) {
    ;; vote for a configuration proposal
    var signature = in_msg~load_bits(512);
    var msg_body = in_msg;
    var (sign_tag, idx, phash) = (in_msg~load_uint(32), in_msg~load_uint(16), in_msg~load_uint(256));
    in_msg.end_parse();
    throw_unless(37, sign_tag == 0x566f7445);
    var (vdescr, total_weight) = get_validator_descr(idx);
    var (val_pubkey, weight) = unpack_validator_descr(vdescr);
    throw_unless(34, check_data_signature(msg_body, signature, val_pubkey));
    int res = proceed_register_vote(phash, idx, weight);
    return send_confirmation(s_addr, query_id, res + 0xd6745240);
  }
  ;; if tag is non-zero and its higher bit is zero, throw an exception (the message is an unsupported query)
  ;; to bounce message back to sender
  throw_unless(37, (tag == 0) | (tag & (1 << 31)));
  ;; do nothing for other internal messages
}

() recv_external(slice in_msg) impure {
  var signature = in_msg~load_bits(512);
  var cs = in_msg;
  int action = cs~load_uint(32);
  int msg_seqno = cs~load_uint(32);
  var valid_until = cs~load_uint(32);
  throw_if(35, valid_until < now());
  throw_if(39, slice_depth(cs) > 128);
  var (cfg_dict, stored_seqno, public_key, vote_dict) = load_data();
  throw_unless(33, msg_seqno == stored_seqno);
  if (action == 0x566f7465) {
    ;; vote for a configuration proposal
    var (idx, phash) = (cs~load_uint(16), cs~load_uint(256));
    cs.end_parse();
    var (vdescr, total_weight) = get_validator_descr(idx);
    var (val_pubkey, weight) = unpack_validator_descr(vdescr);
    throw_unless(34, check_data_signature(in_msg, signature, val_pubkey));
    accept_message();
    stored_seqno = (stored_seqno + 1) % (1 << 32);
    store_data(cfg_dict, stored_seqno, public_key, vote_dict);
    commit();
    proceed_register_vote(phash, idx, weight);
    return ();
  }
  {-
    throw_unless(34, check_signature(slice_hash(in_msg), signature, public_key));
    accept_message();
    stored_seqno = (stored_seqno + 1) % (1 << 32);
    store_data(cfg_dict, stored_seqno, public_key, vote_dict);
    commit();
    (cfg_dict, public_key) = perform_action(cfg_dict, public_key, action, cs);
    store_data(cfg_dict, stored_seqno, public_key, vote_dict);
  -}
}

() run_ticktock(int is_tock) impure {
  var (cfg_dict, stored_seqno, public_key, vote_dict) = load_data();
  int kl = 32;
  var next_vset = cfg_dict.idict_get_ref(kl, 36);
  var updated? = false;
  ifnot (next_vset.null?()) {
    ;; check whether we have to set next_vset as the current validator set
    var ds = next_vset.begin_parse();
    if (ds.slice_bits() >= 40) {
      var tag = ds~load_uint(8);
      var since = ds.preload_uint(32);
      if ((since <= now()) & (tag == 0x12)) {
        ;; next validator set becomes active!
        var cur_vset = cfg_dict~idict_set_get_ref(kl, 34, next_vset);  ;; next_vset -> cur_vset
        cfg_dict~idict_set_get_ref(kl, 32, cur_vset);   ;; cur_vset -> prev_vset
        cfg_dict~idict_delete?(kl, 36);             ;; (null) -> next_vset
        updated? = true;
      }
    }
  }
  ifnot (updated?) {
    ;; if nothing has been done so far, scan a random voting proposal instead
    vote_dict = scan_random_proposal(vote_dict);
  }
  ;; save data and return
  return store_data(cfg_dict, stored_seqno, public_key, vote_dict);
}

int seqno() method_id {
  return get_data().begin_parse().preload_uint(32);
}

_ unpack_proposal(slice pstatus) inline_ref {
  (int expires, cell proposal, int critical?, cell voters, int weight_remaining, int vset_id, slice rest) = unpack_proposal_status(pstatus);
  var voters_list = null();
  var voter_id = (1 << 32);
  do {
    (voter_id, _, var f) = voters.udict_get_prev?(16, voter_id);
    if (f) {
      voters_list = cons(voter_id, voters_list);
    }
  } until (~ f);
  var (rounds_remaining, wins, losses) = (rest~load_uint(8), rest~load_uint(8), rest~load_uint(8));
  rest.end_parse();
  var (param_id, param_val, param_hash) = parse_config_proposal(proposal);
  return [expires, critical?, [param_id, param_val, param_hash], vset_id, voters_list, weight_remaining, rounds_remaining, wins, losses];
}

_ get_proposal(int phash) method_id {
  (_, _, _, var vote_dict) = load_data();
  var (pstatus, found?) = vote_dict.udict_get?(256, phash);
  ifnot (found?) {
    return null();
  }
  return unpack_proposal(pstatus);
}

_ list_proposals() method_id {
  (_, _, _, var vote_dict) = load_data();
  var phash = (1 << 255) + ((1 << 255) - 1);
  var list = null();
  do {
    (phash, var pstatus, var f) = vote_dict.udict_get_prev?(256, phash);
    if (f) {
      list = cons([phash, unpack_proposal(pstatus)], list);
    }
  } until (~ f);
  return list;
}

_ proposal_storage_price(int critical?, int seconds, int bits, int refs) method_id {
  var cfg_dict = get_data().begin_parse().preload_ref();
  var cparam11 = cfg_dict.idict_get_ref(32, 11);
  var (min_tot_rounds, max_tot_rounds, min_wins, max_losses, min_store_sec, max_store_sec, bit_price, cell_price) = get_vote_config_internal(critical?, cparam11);
  if (seconds < min_store_sec) {
    return -1;
  }
  seconds = min(seconds, max_store_sec);
  return (bit_price * (bits + 1024) + cell_price * (refs + 2)) * seconds;
}