├── README.md
├── eos_button.abi
├── eos_button.cpp
├── eos_button.hpp
├── eos_button.wasm
└── eos_button.wast


/README.md:
--------------------------------------------------------------------------------
1 | # eosbutton-contract
2 | EOS Button Contract\
3 | EOS account: theeosbutton\
4 | Website: https://eosbutton.io \
5 | Discord: https://discord.gg/ZhyK6xU
6 | 


--------------------------------------------------------------------------------
/eos_button.abi:
--------------------------------------------------------------------------------
  1 | {
  2 |   "____comment": "This file was generated by eosio-abigen. DO NOT EDIT - 2018-07-21T11:15:38",
  3 |   "version": "eosio::abi/1.0",
  4 |   "types": [{
  5 |       "new_type_name": "time",
  6 |       "type": "uint32"
  7 |     }
  8 |   ],
  9 |   "structs": [{
 10 |       "name": "account",
 11 |       "base": "",
 12 |       "fields": [{
 13 |           "name": "balance",
 14 |           "type": "asset"
 15 |         }
 16 |       ]
 17 |     },{
 18 |       "name": "cur_stats",
 19 |       "base": "",
 20 |       "fields": [{
 21 |           "name": "supply",
 22 |           "type": "asset"
 23 |         },{
 24 |           "name": "max_supply",
 25 |           "type": "asset"
 26 |         },{
 27 |           "name": "issuer",
 28 |           "type": "name"
 29 |         }
 30 |       ]
 31 |     },{
 32 |       "name": "ebtgame",
 33 |       "base": "",
 34 |       "fields": [{
 35 |           "name": "id",
 36 |           "type": "uint64"
 37 |         },{
 38 |           "name": "round",
 39 |           "type": "uint64"
 40 |         },{
 41 |           "name": "last_full_press_shares",
 42 |           "type": "uint64"
 43 |         },{
 44 |           "name": "shares",
 45 |           "type": "uint64"
 46 |         },{
 47 |           "name": "total_shares",
 48 |           "type": "uint64"
 49 |         },{
 50 |           "name": "pot",
 51 |           "type": "asset"
 52 |         },{
 53 |           "name": "final_prize",
 54 |           "type": "asset"
 55 |         },{
 56 |           "name": "token_reserved_for_next_round",
 57 |           "type": "asset"
 58 |         },{
 59 |           "name": "dev_fee",
 60 |           "type": "asset"
 61 |         },{
 62 |           "name": "last_full_press_player",
 63 |           "type": "name"
 64 |         },{
 65 |           "name": "start_time",
 66 |           "type": "time"
 67 |         },{
 68 |           "name": "last_full_press_time",
 69 |           "type": "time"
 70 |         },{
 71 |           "name": "last_full_press_remaining_time",
 72 |           "type": "time"
 73 |         }
 74 |       ]
 75 |     },{
 76 |       "name": "eosgame",
 77 |       "base": "",
 78 |       "fields": [{
 79 |           "name": "id",
 80 |           "type": "uint64"
 81 |         },{
 82 |           "name": "round",
 83 |           "type": "uint64"
 84 |         },{
 85 |           "name": "last_full_press_shares",
 86 |           "type": "uint64"
 87 |         },{
 88 |           "name": "shares",
 89 |           "type": "uint64"
 90 |         },{
 91 |           "name": "total_shares",
 92 |           "type": "uint64"
 93 |         },{
 94 |           "name": "pot",
 95 |           "type": "asset"
 96 |         },{
 97 |           "name": "final_prize",
 98 |           "type": "asset"
 99 |         },{
100 |           "name": "token_reserved_for_next_round",
101 |           "type": "asset"
102 |         },{
103 |           "name": "dev_fee",
104 |           "type": "asset"
105 |         },{
106 |           "name": "last_full_press_player",
107 |           "type": "name"
108 |         },{
109 |           "name": "start_time",
110 |           "type": "time"
111 |         },{
112 |           "name": "last_full_press_time",
113 |           "type": "time"
114 |         },{
115 |           "name": "last_full_press_remaining_time",
116 |           "type": "time"
117 |         }
118 |       ]
119 |     },{
120 |       "name": "ebtplayer",
121 |       "base": "",
122 |       "fields": [{
123 |           "name": "account",
124 |           "type": "name"
125 |         },{
126 |           "name": "shares",
127 |           "type": "uint64"
128 |         },{
129 |           "name": "last_press_shares",
130 |           "type": "uint64"
131 |         },{
132 |           "name": "last_press_info",
133 |           "type": "uint64"
134 |         },{
135 |           "name": "last_press_remaining_time",
136 |           "type": "time"
137 |         }
138 |       ]
139 |     },{
140 |       "name": "eosplayer",
141 |       "base": "",
142 |       "fields": [{
143 |           "name": "account",
144 |           "type": "name"
145 |         },{
146 |           "name": "shares",
147 |           "type": "uint64"
148 |         },{
149 |           "name": "last_press_shares",
150 |           "type": "uint64"
151 |         },{
152 |           "name": "last_press_info",
153 |           "type": "uint64"
154 |         },{
155 |           "name": "last_press_remaining_time",
156 |           "type": "time"
157 |         }
158 |       ]
159 |     },{
160 |       "name": "accstate",
161 |       "base": "",
162 |       "fields": [{
163 |           "name": "account",
164 |           "type": "name"
165 |         },{
166 |           "name": "last_airdrop_claim_time",
167 |           "type": "time"
168 |         },{
169 |           "name": "eos_balance",
170 |           "type": "asset"
171 |         }
172 |       ]
173 |     },{
174 |       "name": "ebtpress",
175 |       "base": "",
176 |       "fields": [{
177 |           "name": "account",
178 |           "type": "name"
179 |         },{
180 |           "name": "quantity",
181 |           "type": "asset"
182 |         },{
183 |           "name": "protection",
184 |           "type": "bool"
185 |         },{
186 |           "name": "referrer",
187 |           "type": "name"
188 |         }
189 |       ]
190 |     },{
191 |       "name": "claimad",
192 |       "base": "",
193 |       "fields": [{
194 |           "name": "account",
195 |           "type": "name"
196 |         }
197 |       ]
198 |     }
199 |   ],
200 |   "actions": [{
201 |       "name": "ebtpress",
202 |       "type": "ebtpress",
203 |       "ricardian_contract": ""
204 |     },{
205 |       "name": "claimad",
206 |       "type": "claimad",
207 |       "ricardian_contract": ""
208 |     }
209 |   ],
210 |   "tables": [{
211 |       "name": "accounts",
212 |       "index_type": "i64",
213 |       "key_names": [
214 |         "balance"
215 |       ],
216 |       "key_types": [
217 |         "asset"
218 |       ],
219 |       "type": "account"
220 |     },{
221 |       "name": "stat",
222 |       "index_type": "i64",
223 |       "key_names": [
224 |         "supply"
225 |       ],
226 |       "key_types": [
227 |         "asset"
228 |       ],
229 |       "type": "cur_stats"
230 |     },{
231 |       "name": "ebtgames",
232 |       "index_type": "i64",
233 |       "key_names": [
234 |         "id"
235 |       ],
236 |       "key_types": [
237 |         "uint64"
238 |       ],
239 |       "type": "ebtgame"
240 |     },{
241 |       "name": "eosgames",
242 |       "index_type": "i64",
243 |       "key_names": [
244 |         "id"
245 |       ],
246 |       "key_types": [
247 |         "uint64"
248 |       ],
249 |       "type": "eosgame"
250 |     },{
251 |       "name": "ebtplayers",
252 |       "index_type": "i64",
253 |       "key_names": [
254 |         "account"
255 |       ],
256 |       "key_types": [
257 |         "name"
258 |       ],
259 |       "type": "ebtplayer"
260 |     },{
261 |       "name": "eosplayers",
262 |       "index_type": "i64",
263 |       "key_names": [
264 |         "account"
265 |       ],
266 |       "key_types": [
267 |         "name"
268 |       ],
269 |       "type": "eosplayer"
270 |     },{
271 |       "name": "accstates",
272 |       "index_type": "i64",
273 |       "key_names": [
274 |         "account"
275 |       ],
276 |       "key_types": [
277 |         "name"
278 |       ],
279 |       "type": "accstate"
280 |     }
281 |   ],
282 |   "ricardian_clauses": [],
283 |   "error_messages": [],
284 |   "abi_extensions": []
285 | }


--------------------------------------------------------------------------------
/eos_button.cpp:
--------------------------------------------------------------------------------
  1 | /**
  2 |  *  @file
  3 |  *  @copyright defined in eos/LICENSE.txt
  4 |  */
  5 | 
  6 | #include "eos_button.hpp"
  7 | 
  8 | namespace ebt {
  9 | 
 10 | //Standard token members - Start
 11 | 
 12 | /*
 13 | void eos_button::create( account_name issuer,
 14 |                     asset        maximum_supply )
 15 | {
 16 |     require_auth( _self );
 17 | 
 18 |     auto sym = maximum_supply.symbol;
 19 |     eosio_assert( sym.is_valid(), "invalid symbol name" );
 20 |     eosio_assert( maximum_supply.is_valid(), "invalid supply");
 21 |     eosio_assert( maximum_supply.amount > 0, "max-supply must be positive");
 22 | 
 23 |     stats statstable( _self, sym.name() );
 24 |     auto existing = statstable.find( sym.name() );
 25 |     eosio_assert( existing == statstable.end(), "token with symbol already exists" );
 26 | 
 27 |     statstable.emplace( _self, [&]( auto& s ) {
 28 |        s.supply.symbol = maximum_supply.symbol;
 29 |        s.max_supply    = maximum_supply;
 30 |        s.issuer        = issuer;
 31 |     });
 32 | }
 33 | */
 34 | 
 35 | /*
 36 | void eos_button::issue( account_name to, asset quantity, string memo )
 37 | {
 38 |     auto sym = quantity.symbol;
 39 |     eosio_assert( sym.is_valid(), "invalid symbol name" );
 40 |     eosio_assert( memo.size() <= 256, "memo has more than 256 bytes" );
 41 | 
 42 |     auto sym_name = sym.name();
 43 |     stats statstable( _self, sym_name );
 44 |     auto existing = statstable.find( sym_name );
 45 |     eosio_assert( existing != statstable.end(), "token with symbol does not exist, create token before issue" );
 46 |     const auto& st = *existing;
 47 | 
 48 |     require_auth( st.issuer );
 49 |     eosio_assert( quantity.is_valid(), "invalid quantity" );
 50 |     eosio_assert( quantity.amount > 0, "must issue positive quantity" );
 51 | 
 52 |     eosio_assert( quantity.symbol == st.supply.symbol, "symbol precision mismatch" );
 53 |     eosio_assert( quantity.amount <= st.max_supply.amount - st.supply.amount, "quantity exceeds available supply");
 54 | 
 55 |     statstable.modify( st, 0, [&]( auto& s ) {
 56 |        s.supply += quantity;
 57 |     });
 58 | 
 59 |     add_balance( st.issuer, quantity, st.issuer );
 60 | 
 61 |     if( to != st.issuer ) {
 62 |        SEND_INLINE_ACTION( *this, transfer, {st.issuer,N(active)}, {st.issuer, to, quantity, memo} );
 63 |     }
 64 | }
 65 | */
 66 | 
 67 | /*
 68 | void eos_button::transfer( account_name from,
 69 |                       account_name to,
 70 |                       asset        quantity,
 71 |                       string       memo )
 72 | {
 73 |     eosio_assert( from != to, "cannot transfer to self" );
 74 |     require_auth( from );
 75 |     eosio_assert( is_account( to ), "to account does not exist");
 76 |     auto sym = quantity.symbol.name();
 77 |     stats statstable( _self, sym );
 78 |     const auto& st = statstable.get( sym );
 79 | 
 80 |     require_recipient( from );
 81 |     require_recipient( to );
 82 | 
 83 |     eosio_assert( quantity.is_valid(), "invalid quantity" );
 84 |     eosio_assert( quantity.amount > 0, "must transfer positive quantity" );
 85 |     eosio_assert( quantity.symbol == st.supply.symbol, "symbol precision mismatch" );
 86 |     eosio_assert( memo.size() <= 256, "memo has more than 256 bytes" );
 87 | 
 88 | 
 89 |     sub_balance( from, quantity );
 90 |     add_balance( to, quantity, from );
 91 | }
 92 | 
 93 | void eos_button::sub_balance( account_name owner, asset value ) {
 94 |    accounts from_acnts( _self, owner );
 95 | 
 96 |    const auto& from = from_acnts.get( value.symbol.name(), "no balance object found" );
 97 |    eosio_assert( from.balance.amount >= value.amount, "overdrawn balance" );
 98 | 
 99 | 
100 |    if( from.balance.amount == value.amount ) {
101 |       from_acnts.erase( from );
102 |    } else {
103 |       from_acnts.modify( from, owner, [&]( auto& a ) {
104 |           a.balance -= value;
105 |       });
106 |    }
107 | }
108 | 
109 | void eos_button::add_balance( account_name owner, asset value, account_name ram_payer )
110 | {
111 |    accounts to_acnts( _self, owner );
112 |    auto to = to_acnts.find( value.symbol.name() );
113 |    if( to == to_acnts.end() ) {
114 |       to_acnts.emplace( ram_payer, [&]( auto& a ){
115 |         a.balance = value;
116 |       });
117 |    } else {
118 |       to_acnts.modify( to, 0, [&]( auto& a ) {
119 |         a.balance += value;
120 |       });
121 |    }
122 | }
123 | */
124 | 
125 | //Standard token members - End
126 | 
127 | //Game members - Start
128 | 
129 | void eos_button::ebtpress( account_name account, asset quantity, bool protection, account_name referrer)
130 | {
131 |     eosio_assert( quantity.symbol == string_to_symbol(4, "EBT"), "unsupported symbol name" );
132 |     handle_press<ebtgames, ebtplayers>(account, quantity, protection, referrer);
133 | }
134 | 
135 | /*
136 | void eos_button::eospress( account_name account, asset quantity, bool protection, account_name referrer)
137 | {
138 |     eosio_assert( quantity.symbol == string_to_symbol(4, "EOS"), "unsupported symbol name" );
139 |     handle_press<eosgames, eosplayers>(account, quantity, protection, referrer);
140 | }
141 | */
142 | 
143 | template <typename games_table_type, typename players_table_type>
144 | void eos_button::handle_press( account_name account, asset quantity, bool protection, account_name referrer)
145 | {
146 |     //print("handle_press (", quantity, ") - Start |");
147 | 
148 |     /*
149 |     //Erase records when required (for testing on testnet)
150 |     if (quantity.amount == 0) {
151 |         ebtgames table( _self, _self );
152 |         auto itr = table.find(0);
153 |         if ( itr != table.end() ) {
154 |             table.erase(itr);
155 |         }
156 |     }
157 |     if (quantity.amount == 0) {
158 |         eosgames table( _self, _self );
159 |         auto itr = table.find(0);
160 |         if ( itr != table.end() ) {
161 |             table.erase(itr);
162 |         }
163 |     }
164 |     if (quantity.amount == 0) {
165 |         ebtplayers table( _self, _self );
166 |         for (auto itr = table.begin(); itr != table.end(); ) {
167 |             itr = table.erase(itr);
168 |         }
169 |     }
170 |     if (quantity.amount == 0) {
171 |         eosplayers table( _self, _self );
172 |         for (auto itr = table.begin(); itr != table.end(); ) {
173 |             itr = table.erase(itr);
174 |         }
175 |     }
176 |     return;
177 |     */
178 | 
179 |     require_auth( account );
180 | 
181 |     const time countdown_cap = 120; //2 minutes countdown cap
182 |     const time countdown_increase_step = 120; //Increase 2 minutes per share when pressed
183 |     const time round_interval = 600; //10 minutes between each round
184 |     const uint64_t shares_for_first_press = 10000; //10000 means 1 share
185 |     const uint64_t referrer_percent = 5;
186 |     const uint64_t referee_percent = 5;
187 |     const uint64_t dev_fee_percent = 2;
188 |     const uint64_t token_reserve_percent = 1;
189 |     const uint64_t last_player_reward_percent = 5;
190 |     const uint64_t start_protection_seconds = 5;
191 |     const uint64_t protection_seconds = 0; //Protection is disabled for now
192 |     const uint64_t protection_fee_percent = 50;
193 | 
194 |     //Check game_command
195 |     /*
196 |     uint64_t game_command;
197 |     systemstates systemstates_table( _self, _self );
198 |     auto systemstates_itr = systemstates_table.find(0);
199 |     if ( systemstates_itr == systemstates_table.end() ) {
200 |         game_command = 0;
201 |     } else {
202 |         if (quantity.symbol == string_to_symbol(4, "EBT")) {
203 |             game_command = systemstates_itr->ebtgame_command;
204 |         } else {
205 |             game_command = systemstates_itr->eosgame_command;
206 |         }
207 |     }
208 |     */
209 | 
210 |     //Check if referrer is valid
211 |     bool referrer_is_valid = false;
212 |     if (is_account(referrer) && referrer != account) {
213 |         if (quantity.symbol == string_to_symbol(4, "EBT")) {
214 |             accounts accounts_table( _self, referrer );
215 |             auto accounts_itr = accounts_table.find(quantity.symbol.name());
216 |             if (accounts_itr != accounts_table.end()) {
217 |                 if (accounts_itr->balance.amount > 0) {
218 |                     referrer_is_valid = true;
219 |                 }
220 |             }
221 |         } else {
222 |             accstates accstates_table( _self, _self );
223 |             auto accstates_itr = accstates_table.find(referrer);
224 |             if (accstates_itr != accstates_table.end()) {
225 |                 if (accstates_itr->eos_balance.amount > 0) {
226 |                     referrer_is_valid = true;
227 |                 }
228 |             }
229 |         }
230 |     }
231 | 
232 |     games_table_type games_table( _self, _self );
233 |     auto games_itr = games_table.find(0);
234 |     if ( games_itr == games_table.end() ) {
235 |         games_itr = games_table.emplace(account, [&](auto& g){
236 |             //It is important to initialize all asset type columns with the correct symbol, so that they can be used in future calculations
237 |             g.pot = asset(0, quantity.symbol);
238 |             g.final_prize = asset(0, quantity.symbol);
239 |             g.token_reserved_for_next_round = asset(0, quantity.symbol);
240 |             g.dev_fee = asset(0, quantity.symbol);
241 |         });
242 |     }
243 |     players_table_type players_table( _self, _self );
244 | 
245 |     time remaining_time_right_after_last_full_press = std::min<time>(countdown_cap, s_add(games_itr->last_full_press_remaining_time, s_div(s_mul(countdown_increase_step, games_itr->last_full_press_shares), 10000)));
246 |     //print("remaining_after_last_press: ", remaining_time_right_after_last_full_press, " |");
247 | 
248 |     if (now() >= s_add(games_itr->last_full_press_time, remaining_time_right_after_last_full_press)) {
249 |         //print("Round ended or not started |");
250 |         if (now() >= s_add(s_add(games_itr->last_full_press_time, remaining_time_right_after_last_full_press), round_interval)) {
251 |             //print("Start a new round |");
252 | 
253 |             //Transfer rewards to players
254 |             //Run this logic no matter the pot is 0 or not. If it is 0, it doesn't mean there is no player (if there is only one press last round, the pot is 0).
255 |             for (
256 |                 auto itr = players_table.begin(); //Important to read the table again after adding shares to the last player
257 |                 itr != players_table.end();
258 |             ) {
259 |                 //Calculate the reward. No need to use safe math, because the asset type will check for overflow/underflow. The order is important, the assets must be at the beginning. Make sure the uint64_t won't be rounded to 0.
260 |                 asset last_round_reward;
261 |                 //string ebt_transfer_memo;
262 |                 if (itr->account != games_itr->last_full_press_player) {
263 |                     last_round_reward = games_itr->pot * (100 - last_player_reward_percent) / 100 * itr->shares / games_itr->shares;
264 |                     //ebt_transfer_memo = string("eosbutton.io - Reward (") + std::to_string(itr->shares/10000) + string(" Share(s))");
265 |                 } else {
266 |                     last_round_reward = games_itr->pot * (100 - last_player_reward_percent) / 100 * itr->shares / games_itr->shares + games_itr->pot * (last_player_reward_percent) / 100;
267 |                     //ebt_transfer_memo = string("eosbutton.io - Reward (") + std::to_string(itr->shares/10000) + string(" Share(s) and the FINAL PRIZE)");
268 |                 }
269 |                 if (itr->account != _self && is_account(itr->account) && last_round_reward.amount > 0) {
270 |                     if (quantity.symbol == string_to_symbol(4, "EBT")) {
271 |                         //print("rewarding EBT |");
272 |                         /*
273 |                         ctransfer(
274 |                             _self,
275 |                             itr->account,
276 |                             last_round_reward,
277 |                             ebt_transfer_memo,
278 |                             account
279 |                         );
280 |                         */
281 |                         mtransfer(
282 |                             _self,
283 |                             itr->account,
284 |                             last_round_reward,
285 |                             account
286 |                         );
287 |                     } else {
288 |                         //print("rewarding EOS |");
289 |                         accstates accstates_table( _self, _self );
290 |                         auto accstates_itr = accstates_table.find(itr->account);
291 |                         if (accstates_itr == accstates_table.end()) {
292 |                             accstates_table.emplace( account, [&]( auto& a ) {
293 |                                 a.account = itr->account;
294 |                                 a.eos_balance = last_round_reward;
295 |                           });
296 |                         } else {
297 |                             accstates_table.modify( accstates_itr, 0, [&]( auto& a ) {
298 |                                 a.eos_balance = a.eos_balance + last_round_reward;
299 |                             });
300 |                         }
301 |                     }
302 |                     //print("Transfered last round reward ", last_round_reward, " to ", N(itr->account), " |");
303 |                 }
304 |                 itr = players_table.erase(itr);
305 |             }
306 | 
307 |             /*
308 |             if (game_command == 1) {
309 |                 return;
310 |             }
311 |             */
312 |             if (now() < 1532167200) { //1532167200: July 21, 2018 10:00:00 AM UTC
313 |                 return;
314 |             }
315 | 
316 |             //Emplace referrer's record (no need to check if it exists, because players have been erased previously)
317 |             /*
318 |             uint64_t additional_shares_for_referrer = 0;
319 |             uint64_t additional_shares_for_referee = 0;
320 |             if (referrer_is_valid) {
321 |                 additional_shares_for_referrer = s_div(s_mul(shares_for_first_press, referrer_percent), 100);
322 |                 additional_shares_for_referee = s_div(s_mul(shares_for_first_press, referee_percent), 100);
323 |                 players_table.emplace(account, [&](auto& p){
324 |                     p.account = referrer;
325 |                     p.shares = additional_shares_for_referrer;
326 |                     p.last_press_shares = 0;
327 |                     p.last_press_info = 0;
328 |                     p.last_press_remaining_time = 0;
329 |                 });
330 |             }
331 |             */
332 | 
333 |             //Emplace player's record (no need to check if it exists, because players have been erased previously)
334 |             players_table.emplace(account, [&](auto& p){
335 |                 p.account = account;
336 |                 /*
337 |                 p.shares = s_add(shares_for_first_press, additional_shares_for_referee);
338 |                 p.last_press_shares = s_add(shares_for_first_press, additional_shares_for_referee);
339 |                 */
340 |                 p.shares = shares_for_first_press;
341 |                 p.last_press_shares = shares_for_first_press;
342 |                 p.last_press_info = 2;
343 |                 p.last_press_remaining_time = 0;
344 |             });
345 | 
346 |             //Set initial values for a new round
347 |             games_table.modify(games_itr, account, [&](auto& g){
348 |                 /*
349 |                 if (game_command == 2) {
350 |                     g.round = 1;
351 |                 } else {
352 |                     g.round = s_add(g.round, 1);
353 |                 }
354 |                 */
355 |                 g.round = s_add(g.round, 1);
356 |                 /*
357 |                 g.last_full_press_shares = s_add(shares_for_first_press, additional_shares_for_referee);
358 |                 g.shares = s_add(s_add(shares_for_first_press, additional_shares_for_referrer), additional_shares_for_referee);
359 |                 g.total_shares = s_add(s_add(s_add(g.total_shares, shares_for_first_press), additional_shares_for_referrer), additional_shares_for_referee);
360 |                 */
361 |                 g.last_full_press_shares = shares_for_first_press;
362 |                 g.shares = shares_for_first_press;
363 |                 g.total_shares = s_add(g.total_shares, shares_for_first_press);
364 |                 g.pot = g.token_reserved_for_next_round;
365 |                 g.token_reserved_for_next_round = asset(0, quantity.symbol);
366 |                 //g.dev_fee = g.dev_fee; //The first press is free
367 |                 g.last_full_press_player = account;
368 |                 g.start_time = now();
369 |                 g.last_full_press_time = now();
370 |                 g.last_full_press_remaining_time = 0;
371 |             });
372 | 
373 |         } else {
374 |             //print("Wait before starting a new round |");
375 |             /*
376 |             auto players_itr = players_table.find(account);
377 |             if( players_itr == players_table.end() ) {
378 |                 players_table.emplace(account, [&](auto& p){
379 |                     p.account = account;
380 |                     p.last_press_info = 1;
381 |                 });
382 |             } else {
383 |                 players_table.modify(players_itr, account, [&](auto& p){
384 |                     p.last_press_info = 1;
385 |                 });
386 |             }
387 |             */
388 |             eosio_assert( false, "not started yet");
389 |         }
390 |     } else {
391 |         //print("Round active |");
392 | 
393 |         time remaining = s_sub(remaining_time_right_after_last_full_press, s_sub(now(), games_itr->last_full_press_time));
394 |         //print("remaining: ", remaining, " |");
395 | 
396 |         //Handle protection
397 |         auto players_itr = players_table.find(account);
398 |         if (
399 |             (s_sub(now(), games_itr->start_time) <= start_protection_seconds && (s_sub(countdown_cap, remaining) <= start_protection_seconds)) || //Protect players for free at the beginning of a round.
400 |             (protection && (s_sub(countdown_cap, remaining) <= protection_seconds))
401 |         ) {
402 |             if( players_itr == players_table.end() ) {
403 |                 players_table.emplace(account, [&](auto& p){
404 |                     p.account = account;
405 |                     p.last_press_info = 4;
406 |                 });
407 |             } else {
408 |                 players_table.modify(players_itr, account, [&](auto& p){
409 |                     p.last_press_info = 4;
410 |                 });
411 |             }
412 |             return;
413 |         }
414 | 
415 |         //Calculate shares
416 |         time timeElapsedSinceStart = s_sub(now(), games_itr->start_time);
417 |         //print("remaining: ", remaining, " |");
418 |         //shares = (1036800000 * quantity.amount) / ( (remaining^2 + 2280) * (timeElapsedSinceStart + 86400) )
419 |         uint64_t shares = s_div(s_mul(1036800000, quantity.amount), s_mul(s_add(s_mul(remaining, remaining), 2280), s_add(timeElapsedSinceStart, 86400)));
420 |         if (protection) {
421 |             shares = s_div(s_mul(shares, 100), s_add(100, protection_fee_percent));
422 |         }
423 | 
424 |         //Charge fee
425 |         //No need to assert to check if the EBT balance is enough, because the sub_balance will do.
426 |         //However, if SEND_INLINE_ACTION is used, I must assert here.
427 |         if (quantity.symbol == string_to_symbol(4, "EBT")) {
428 |             if ( account != _self ) {
429 |                 //print("charge EBT |");
430 |                 //ctransfer(account, _self, quantity, string("eosbutton.io - Press"), account);
431 |                 mtransfer(account, _self, quantity, account);
432 |             }
433 |         } else {
434 |             //print("charge EOS |");
435 |             accstates accstates_table( _self, _self );
436 |             auto accstates_itr = accstates_table.find(account);
437 |             eosio_assert(accstates_itr != accstates_table.end(), "unknown account");
438 | 
439 |             accstates_table.modify( accstates_itr, 0, [&]( auto& a ) {
440 |                 eosio_assert( a.eos_balance >= quantity, "insufficient balance" );
441 |                 a.eos_balance -= quantity;
442 |             });
443 |         }
444 | 
445 |         //Update referrer's record
446 |         players_itr = players_table.find(referrer);
447 |         uint64_t additional_shares_for_referrer = 0;
448 |         uint64_t additional_shares_for_referee = 0;
449 |         if (referrer_is_valid) {
450 |             additional_shares_for_referrer = s_div(s_mul(shares, referrer_percent), 100);
451 |             additional_shares_for_referee = s_div(s_mul(shares, referee_percent), 100);
452 |             if( players_itr == players_table.end() ) {
453 |                 players_table.emplace(account, [&](auto& p){
454 |                     p.account = referrer;
455 |                     p.shares = additional_shares_for_referrer;
456 |                     p.last_press_shares = 0;
457 |                     p.last_press_info = 0;
458 |                     p.last_press_remaining_time = 0;
459 |                 });
460 |             } else {
461 |                 players_table.modify(players_itr, account, [&](auto& p){
462 |                     p.shares = s_add(p.shares, additional_shares_for_referrer);
463 |                 });
464 |             }
465 |         }
466 | 
467 |         //Update shares and check if it is a full press
468 |         shares = s_add(shares, additional_shares_for_referee);
469 |         bool full_press = false;
470 |         if (shares >= 10000) {
471 |             full_press = true;
472 |         }
473 | 
474 |         //Update players_table
475 |         players_itr = players_table.find(account);
476 |         if( players_itr == players_table.end() ) {
477 |             players_table.emplace(account, [&](auto& p){
478 |                 p.account = account;
479 |                 p.shares = s_add(p.shares, shares);
480 |                 p.last_press_shares = shares;
481 |                 p.last_press_info = 3;
482 |                 p.last_press_remaining_time = remaining;
483 |             });
484 |         } else {
485 |             players_table.modify(players_itr, account, [&](auto& p){
486 |                 p.shares = s_add(p.shares, shares);
487 |                 p.last_press_shares = shares;
488 |                 p.last_press_info = 3;
489 |                 p.last_press_remaining_time = remaining;
490 |             });
491 |         }
492 | 
493 |         //Update games_table
494 |         //Calculate asset. No need to use safe math, because the asset type will check for overflow/underflow. The order is important, the assets must be at the beginning. Make sure the uint64_t won't be rounded to 0.
495 |         asset token_reserved_for_next_round = quantity * token_reserve_percent / 100;
496 |         asset dev_fee = quantity * dev_fee_percent / 100;
497 |         games_table.modify(games_itr, account, [&](auto& g){
498 |             g.shares = s_add(s_add(g.shares, shares), additional_shares_for_referrer);
499 |             g.total_shares = s_add(s_add(g.total_shares, shares), additional_shares_for_referrer);
500 |             g.pot = g.pot + quantity - token_reserved_for_next_round - dev_fee;
501 |             g.token_reserved_for_next_round += token_reserved_for_next_round;
502 |             g.dev_fee += dev_fee;
503 |             if (full_press) {
504 |                 g.last_full_press_shares = shares;
505 |                 g.last_full_press_player = account;
506 |                 g.last_full_press_time = now();
507 |                 g.last_full_press_remaining_time = remaining;
508 |             }
509 |         });
510 | 
511 |     }
512 | 
513 |     //print("handle_press (", quantity, ") - End |");
514 | }
515 | 
516 | //Game members - End
517 | 
518 | //Asset management members - Start
519 | 
520 | /*
521 | void eos_button::withdraw( account_name account, asset quantity )
522 | {
523 |     //print("withdraw - Start |");
524 | 
525 |     require_auth( account );
526 | 
527 |     eosio_assert( quantity.is_valid(), "invalid quantity" );
528 |     eosio_assert( quantity.amount > 0, "must withdraw positive quantity" );
529 | 
530 |     accstates accstates_table( _self, _self );
531 |     auto accstates_itr = accstates_table.find(account);
532 |     eosio_assert(accstates_itr != accstates_table.end(), "unknown account");
533 | 
534 |     accstates_table.modify( accstates_itr, 0, [&]( auto& a ) {
535 |         eosio_assert( a.eos_balance >= quantity, "insufficient balance" );
536 |         a.eos_balance -= quantity;
537 |     });
538 | 
539 |     action(
540 |         permission_level{ _self, N(active) },
541 |         N(eosio.token), N(transfer),
542 |         std::make_tuple(_self, account, quantity, std::string("eosbutton.io - Withdraw"))
543 |     ).send();
544 | 
545 |     if(
546 |         accstates_itr != accstates_table.end() &&
547 |         accstates_itr->eos_balance.amount <= 0 &&
548 |         accstates_itr->last_airdrop_claim_time == 0
549 |     ) {
550 |         //print("accstates is empty |");
551 |     }
552 | 
553 |     //print("withdraw - End |");
554 | }
555 | */
556 | 
557 | void eos_button::claimad( account_name account )
558 | {
559 |     //print("claimad - Start |");
560 |     require_auth( account );
561 | 
562 |     asset airdrop_claim_quantity = asset(500000000, string_to_symbol(4, "EBT"));
563 |     time airdrop_claim_interval = 86400;
564 |     time airdrop_start_time = 1531908000;
565 |     time airdrop_end_time = 1533117600;
566 | 
567 |     accstates accstates_table( _self, _self );
568 |     auto accstates_itr = accstates_table.find(account);
569 |     /*
570 |     systemstates systemstates_table( _self, _self );
571 |     auto systemstates_itr = systemstates_table.find(0);
572 | 
573 |     eosio_assert(systemstates_itr != systemstates_table.end(), "No airdrop");
574 |     eosio_assert(systemstates_itr->airdrop_available >= systemstates_itr->airdrop_claim_quantity, "Airdrop unavailable");
575 |     eosio_assert(now() >= systemstates_itr->airdrop_start_time, "Airdrop has not started");
576 |     eosio_assert(now() < systemstates_itr->airdrop_end_time, "Airdrop is ended");
577 |     */
578 |     eosio_assert(now() >= airdrop_start_time, "Airdrop has not started");
579 |     eosio_assert(now() < airdrop_end_time, "Airdrop is ended");
580 | 
581 |     if(accstates_itr != accstates_table.end()) {
582 |         //eosio_assert( now() >= accstates_itr->last_airdrop_claim_time + systemstates_itr->airdrop_claim_interval, "claim is too frequent");
583 |         eosio_assert( now() >= accstates_itr->last_airdrop_claim_time + airdrop_claim_interval, "claim is too frequent");
584 |     }
585 | 
586 |     //Update last_airdrop_claim_time
587 |     if( accstates_itr == accstates_table.end() ) {
588 |         //print("itr == end |");
589 |         accstates_table.emplace(account, [&](auto& a){
590 |             a.account = account;
591 |             a.last_airdrop_claim_time = now();
592 |             a.eos_balance = asset(0, string_to_symbol(4, "EOS"));
593 |         });
594 |     } else {
595 |         //print("itr != end |");
596 |         accstates_table.modify(accstates_itr, account, [&](auto& a){
597 |             a.account = account;
598 |             a.last_airdrop_claim_time = now();
599 |         });
600 |     }
601 | 
602 |     //Update available airdrop
603 |     /*
604 |     systemstates_table.modify(systemstates_itr, account, [&](auto& a){
605 |         a.airdrop_available = a.airdrop_available - a.airdrop_claim_quantity;
606 |     });
607 |     */
608 | 
609 |     //Issue
610 |     //cissue(account, systemstates_itr->airdrop_claim_quantity, "eosbutton.io - Airdrop");
611 |     //Use mtransfer to replace cissue
612 |     mtransfer(_self, account, airdrop_claim_quantity, account);
613 | 
614 |     //print("claimad - End |");
615 | }
616 | 
617 | void eos_button::deposit()
618 | {
619 |     /*
620 |     //print("deposit - Start |");
621 | 
622 |     auto transfer_data = unpack_action_data<eosio_token_transfer>();
623 |     //Don't use assert, otherwise other eosio.token transfer actions not intended for deposit will be rejected.
624 |     if (
625 |       transfer_data.from == _self ||
626 |       transfer_data.to != _self ||
627 |       !transfer_data.quantity.is_valid() ||
628 |       transfer_data.quantity.amount <= 0 ||
629 |       transfer_data.quantity.symbol != string_to_symbol(4, "EOS") ||
630 |       transfer_data.memo != "deposit"
631 |     ) {
632 |       return;
633 |     }
634 | 
635 |     require_auth( transfer_data.from );
636 | 
637 |     accstates accstates_table( _self, _self );
638 |     auto accstates_itr = accstates_table.find(transfer_data.from);
639 |     if (accstates_itr == accstates_table.end()) {
640 |         accstates_table.emplace( transfer_data.from, [&]( auto& a ) {
641 |             a.account = transfer_data.from;
642 |             a.eos_balance = transfer_data.quantity;
643 |         });
644 |     } else {
645 |         accstates_table.modify( accstates_itr, 0, [&]( auto& a ) {
646 |             a.eos_balance = a.eos_balance + transfer_data.quantity;
647 |         });
648 |     }
649 | 
650 |     //print(N(transfer_data.from), " deposited ", transfer_data.quantity, " |");
651 | 
652 |     //print("deposit - End |");
653 |     */
654 | }
655 | 
656 | /*
657 | void eos_button::cissue( account_name to, asset quantity, string memo )
658 | {
659 |     auto sym = quantity.symbol;
660 |     eosio_assert( sym.is_valid(), "invalid symbol name" );
661 |     eosio_assert( memo.size() <= 256, "memo has more than 256 bytes" );
662 | 
663 |     auto sym_name = sym.name();
664 |     stats statstable( _self, sym_name );
665 |     auto existing = statstable.find( sym_name );
666 |     eosio_assert( existing != statstable.end(), "token with symbol does not exist, create token before issue" );
667 |     const auto& st = *existing;
668 | 
669 |     //require_auth( st.issuer );
670 |     eosio_assert( quantity.is_valid(), "invalid quantity" );
671 |     eosio_assert( quantity.amount > 0, "must issue positive quantity" );
672 | 
673 |     eosio_assert( quantity.symbol == st.supply.symbol, "symbol precision mismatch" );
674 |     eosio_assert( quantity.amount <= st.max_supply.amount - st.supply.amount, "quantity exceeds available supply");
675 | 
676 |     statstable.modify( st, to, [&]( auto& s ) {
677 |        s.supply += quantity;
678 |     });
679 | 
680 |     c_add_balance( st.issuer, quantity, to );
681 | 
682 |     if( to != st.issuer ) {
683 |        //SEND_INLINE_ACTION( *this, ctransfer, {st.issuer,N(active)}, {st.issuer, to, quantity, memo} );
684 |        ctransfer(st.issuer, to, quantity, memo, to);
685 |     }
686 | }
687 | 
688 | void eos_button::ctransfer( account_name from,
689 |                       account_name to,
690 |                       asset        quantity,
691 |                       string       memo,
692 |                       account_name ram_payer )
693 | {
694 |     eosio_assert( from != to, "cannot transfer to self" );
695 |     //require_auth( from );
696 |     eosio_assert( is_account( to ), "to account does not exist");
697 |     auto sym = quantity.symbol.name();
698 |     stats statstable( _self, sym );
699 |     const auto& st = statstable.get( sym );
700 | 
701 |     require_recipient( from );
702 |     require_recipient( to );
703 | 
704 |     eosio_assert( quantity.is_valid(), "invalid quantity" );
705 |     eosio_assert( quantity.amount > 0, "must transfer positive quantity" );
706 |     eosio_assert( quantity.symbol == st.supply.symbol, "symbol precision mismatch" );
707 |     eosio_assert( memo.size() <= 256, "memo has more than 256 bytes" );
708 | 
709 | 
710 |     c_sub_balance( from, quantity );
711 |     c_add_balance( to, quantity, ram_payer );
712 | }
713 | */
714 | 
715 | void eos_button::mtransfer( account_name from, account_name to, asset quantity, account_name ram_payer )
716 | {
717 |     eosio_assert( is_account( to ), "to account does not exist");
718 | 
719 |     c_sub_balance( from, quantity );
720 |     c_add_balance( to, quantity, ram_payer );
721 | }
722 | 
723 | void eos_button::c_sub_balance( account_name owner, asset value ) {
724 |    accounts from_acnts( _self, owner );
725 | 
726 |    const auto& from = from_acnts.get( value.symbol.name(), "no balance object found" );
727 |    eosio_assert( from.balance.amount >= value.amount, "overdrawn balance" );
728 | 
729 |    from_acnts.modify( from, 0, [&]( auto& a ) {
730 |        a.balance -= value;
731 |    });
732 | }
733 | 
734 | void eos_button::c_add_balance( account_name owner, asset value, account_name ram_payer )
735 | {
736 |    accounts to_acnts( _self, owner );
737 |    auto to = to_acnts.find( value.symbol.name() );
738 |    if( to == to_acnts.end() ) {
739 |       to_acnts.emplace( ram_payer, [&]( auto& a ){
740 |         a.balance = value;
741 |       });
742 |    } else {
743 |       to_acnts.modify( to, 0, [&]( auto& a ) {
744 |         a.balance += value;
745 |       });
746 |    }
747 | }
748 | 
749 | //Asset management members - End
750 | 
751 | //System management members - Start
752 | 
753 | /*
754 | void eos_button::configsystem( asset airdrop_available, asset airdrop_claim_quantity, time airdrop_claim_interval, time airdrop_start_time, time airdrop_end_time, uint64_t ebtgame_command, uint64_t eosgame_command )
755 | {
756 |     print("configsystem - Start |");
757 |     require_auth( _self );
758 |     auto sym = airdrop_available.symbol;
759 | 
760 |     eosio_assert( sym == string_to_symbol(4, "EBT"), "unsupported symbol name" );
761 | 
762 |     systemstates systemstates_table( _self, _self );
763 |     auto systemstates_itr = systemstates_table.find(0);
764 |     if( systemstates_itr == systemstates_table.end() ) {
765 |         print("itr == end |");
766 |         systemstates_table.emplace(_self, [&](auto& a){
767 |             if (airdrop_claim_quantity.amount > 0) {
768 |                 a.airdrop_available = airdrop_available;
769 |                 a.airdrop_claim_quantity = airdrop_claim_quantity;
770 |                 a.airdrop_claim_interval = airdrop_claim_interval;
771 |                 a.airdrop_start_time = airdrop_start_time;
772 |                 a.airdrop_end_time = airdrop_end_time;
773 |             }
774 |             a.ebtgame_command = ebtgame_command;
775 |             a.eosgame_command = eosgame_command;
776 |         });
777 |     } else {
778 |         print("itr != end |");
779 |         systemstates_table.modify(systemstates_itr, _self, [&](auto& a){
780 |             if (airdrop_claim_quantity.amount > 0) {
781 |                 a.airdrop_available = airdrop_available;
782 |                 a.airdrop_claim_quantity = airdrop_claim_quantity;
783 |                 a.airdrop_claim_interval = airdrop_claim_interval;
784 |                 a.airdrop_start_time = airdrop_start_time;
785 |                 a.airdrop_end_time = airdrop_end_time;
786 |             }
787 |             a.ebtgame_command = ebtgame_command;
788 |             a.eosgame_command = eosgame_command;
789 |         });
790 | 
791 |         if(airdrop_end_time == 999) {
792 |             systemstates_table.erase(systemstates_itr);
793 |         }
794 |     }
795 | 
796 |     //Erase records when required (for testing on testnet)
797 |     if (ebtgame_command == 999) {
798 |         ebtgames table( _self, _self );
799 |         auto itr = table.find(0);
800 |         if ( itr != table.end() ) {
801 |             table.erase(itr);
802 |         }
803 |     }
804 |     if (eosgame_command == 999) {
805 |         eosgames table( _self, _self );
806 |         auto itr = table.find(0);
807 |         if ( itr != table.end() ) {
808 |             table.erase(itr);
809 |         }
810 |     }
811 |     if (ebtgame_command == 99999) {
812 |         ebtplayers table( _self, _self );
813 |         for (auto itr = table.begin(); itr != table.end(); ) {
814 |             itr = table.erase(itr);
815 |         }
816 |     }
817 |     if (eosgame_command == 99999) {
818 |         eosplayers table( _self, _self );
819 |         for (auto itr = table.begin(); itr != table.end(); ) {
820 |             itr = table.erase(itr);
821 |         }
822 |     }
823 | 
824 |     print("configsystem - End |");
825 | }
826 | 
827 | void eos_button::withdrawdf( account_name to )
828 | {
829 |     require_auth( _self );
830 |     print("withdrawdf - Start |");
831 |     //withdraw all EBT and EOS dev fee
832 | 
833 |     //Withdraw EBT
834 |     ebtgames ebtgames_table( _self, _self);
835 |     auto ebtgames_itr = ebtgames_table.find(0);
836 |     if (ebtgames_itr != ebtgames_table.end()) {
837 |         asset ebt_quantity;
838 | 
839 |         ebtgames_table.modify( ebtgames_itr, 0, [&]( auto& g ) {
840 |             ebt_quantity = g.dev_fee;
841 |             g.dev_fee = asset(0, string_to_symbol(4, "EBT"));
842 |         });
843 | 
844 |         if (ebt_quantity > asset(0, string_to_symbol(4, "EBT"))) {
845 |             transfer(_self, to, ebt_quantity, "eosbutton.io - Withdrawdf");
846 |         }
847 |     }
848 | 
849 |     //Withdraw EOS
850 |     eosgames eosgames_table( _self, _self);
851 |     auto eosgames_itr = eosgames_table.find(0);
852 |     if (eosgames_itr != eosgames_table.end()) {
853 |         asset eos_quantity;
854 | 
855 |         eosgames_table.modify( eosgames_itr, 0, [&]( auto& g ) {
856 |             eos_quantity = g.dev_fee;
857 |             g.dev_fee = asset(0, string_to_symbol(4, "EOS"));
858 |         });
859 | 
860 |         if (eos_quantity > asset(0, string_to_symbol(4, "EOS"))) {
861 |             action(
862 |                 permission_level{ _self, N(active) },
863 |                 N(eosio.token), N(transfer),
864 |                 std::make_tuple(_self, to, eos_quantity, std::string("eosbutton.io - Withdrawdf"))
865 |             ).send();
866 |         }
867 |     }
868 | 
869 |     print("withdrawdf - End |");
870 | }
871 | */
872 | 
873 | //System management members - End
874 | 
875 | //Safe math - Start
876 | 
877 | uint64_t eos_button::s_add( uint64_t a, uint64_t b )
878 | {
879 |   uint64_t c = a + b;
880 |   eosio_assert(c >= a, "overflow/underflow");
881 |   return c;
882 | }
883 | 
884 | uint64_t eos_button::s_sub( uint64_t a, uint64_t b )
885 | {
886 |   eosio_assert(b <= a, "overflow/underflow");
887 |   return a - b;
888 | }
889 | 
890 | uint64_t eos_button::s_mul( uint64_t a, uint64_t b )
891 | {
892 |   if (a == 0) {
893 |     return 0;
894 |   }
895 | 
896 |   uint64_t c = a * b;
897 |   eosio_assert(c / a == b, "overflow/underflow");
898 |   return c;
899 | }
900 | 
901 | uint64_t eos_button::s_div( uint64_t a, uint64_t b )
902 | {
903 |   eosio_assert(b > 0, "dividing by 0");
904 |   return a / b;
905 | }
906 | 
907 | //Safe math - End
908 | 
909 | }
910 | 
911 | #define EOSIO_ABI_EX( TYPE, MEMBERS ) \
912 | extern "C" { \
913 |    void apply( uint64_t receiver, uint64_t code, uint64_t action ) { \
914 |       auto self = receiver; \
915 |       if( action == N(onerror)) { \
916 |          /* onerror is only valid if it is for the "eosio" code account and authorized by "eosio"'s "active permission */ \
917 |          eosio_assert(code == N(eosio), "onerror action's are only valid from the \"eosio\" system account"); \
918 |       } \
919 |       if( (code == self || action == N(onerror)) && action != N(deposit) ) { \
920 |          TYPE thiscontract( self ); \
921 |          switch( action ) { \
922 |             EOSIO_API( TYPE, MEMBERS ) \
923 |          } \
924 |          /* does not allow destructor of thiscontract to run: eosio_exit(0); */ \
925 |       } else if( code == N(eosio.token) && action == N(transfer) ) { \
926 |          ebt::eos_button eb( receiver ); \
927 |          eb.deposit(); \
928 |       } \
929 |    } \
930 | }
931 | 
932 | EOSIO_ABI_EX(ebt::eos_button,
933 |     //(create)
934 |     //(issue)
935 |     //(transfer)
936 |     (ebtpress)
937 |     //(eospress)
938 |     //(withdraw)
939 |     //(configsystem)
940 |     (claimad)
941 |     //(withdrawdf)
942 | )
943 | 


--------------------------------------------------------------------------------
/eos_button.hpp:
--------------------------------------------------------------------------------
  1 | #pragma once
  2 | 
  3 | #include <eosiolib/asset.hpp>
  4 | #include <eosiolib/eosio.hpp>
  5 | 
  6 | #include <string>
  7 | 
  8 | namespace ebt {
  9 | 
 10 |    using namespace eosio;
 11 |    using std::string;
 12 | 
 13 |    class eos_button : public contract {
 14 | 
 15 |       //Standard token members - Start
 16 | 
 17 |       public:
 18 |          eos_button( account_name self ):contract(self){}
 19 | 
 20 | /*
 21 |          //@abi action
 22 |          void create( account_name issuer,
 23 |                       asset        maximum_supply);
 24 | 
 25 |          //@abi action
 26 |          void issue( account_name to, asset quantity, string memo );
 27 | 
 28 |          //@abi action
 29 |          void transfer( account_name from,
 30 |                         account_name to,
 31 |                         asset        quantity,
 32 |                         string       memo );
 33 |       
 34 |       
 35 |          inline asset get_supply( symbol_name sym )const;
 36 |          
 37 |          inline asset get_balance( account_name owner, symbol_name sym )const;
 38 | */
 39 | 
 40 |       private:
 41 |          //@abi table accounts i64
 42 |          struct account {
 43 |             asset    balance;
 44 | 
 45 |             uint64_t primary_key()const { return balance.symbol.name(); }
 46 |          };
 47 | 
 48 |          //@abi table stat i64
 49 |          struct cur_stats { //The struct name is edited, so that abi can be generated
 50 |             asset          supply;
 51 |             asset          max_supply;
 52 |             account_name   issuer;
 53 | 
 54 |             uint64_t primary_key()const { return supply.symbol.name(); }
 55 |          };
 56 | 
 57 |          typedef eosio::multi_index<N(accounts), account> accounts;
 58 |          typedef eosio::multi_index<N(stat), cur_stats> stats;
 59 | 
 60 |          void sub_balance( account_name owner, asset value );
 61 |          void add_balance( account_name owner, asset value, account_name ram_payer );
 62 | 
 63 | /*
 64 |       public:
 65 |          struct transfer_args {
 66 |             account_name  from;
 67 |             account_name  to;
 68 |             asset         quantity;
 69 |             string        memo;
 70 |          };
 71 | */
 72 | 
 73 |       //Standard token members - End
 74 | 
 75 |       //Game members - Start
 76 | 
 77 |       public:
 78 |          //Note that all shares are 10000 times larger. i.e. "10000 shares" means 1 actual share.
 79 |          /*
 80 |       "ricardian_contract": "The intent of this action is to press the game button. The rule of the game is described on https://eosbutton.io."
 81 |          */
 82 |          //@abi action
 83 |          void ebtpress( account_name account, asset quantity, bool protection, account_name referrer);
 84 |          /*
 85 |       "ricardian_contract": "The intent of this action is to press the game button. The rule of the game is described on https://eosbutton.io."
 86 |          */
 87 |          /*
 88 |          //@abi action
 89 |          void eospress( account_name account, asset quantity, bool protection, account_name referrer);
 90 |          */
 91 | 
 92 |       private:
 93 |          template <typename games_table_type, typename players_table_type>
 94 |          void handle_press( account_name account, asset quantity, bool protection, account_name referrer);
 95 | 
 96 |          //Note that all shares are 10000 times larger. i.e. "10000 shares" means 1 actual share.
 97 |          //@abi table ebtgames i64
 98 |          struct ebtgame {
 99 |             uint64_t id;
100 |             uint64_t round;
101 |             uint64_t last_full_press_shares;
102 |             uint64_t shares;
103 |             uint64_t total_shares;
104 |             asset pot;
105 |             asset final_prize; //Currently unused. Final prize is currently calculated in a different way.
106 |             asset token_reserved_for_next_round;
107 |             asset dev_fee;
108 |             account_name last_full_press_player;
109 |             time start_time;
110 |             time last_full_press_time;
111 |             time last_full_press_remaining_time;
112 | 
113 |             uint64_t primary_key()const { return id; }
114 | 
115 |             EOSLIB_SERIALIZE( ebtgame, 
116 |               (id)
117 |               (round)
118 |               (last_full_press_shares)
119 |               (shares)
120 |               (total_shares)
121 |               (pot)
122 |               (final_prize)
123 |               (token_reserved_for_next_round)
124 |               (dev_fee)
125 |               (last_full_press_player)
126 |               (start_time)
127 |               (last_full_press_time)
128 |               (last_full_press_remaining_time)
129 |             )
130 |          };
131 | 
132 |          //@abi table eosgames i64
133 |          struct eosgame {
134 |             uint64_t id;
135 |             uint64_t round;
136 |             uint64_t last_full_press_shares;
137 |             uint64_t shares;
138 |             uint64_t total_shares;
139 |             asset pot;
140 |             asset final_prize; //Currently unused. Final prize is currently calculated in a different way.
141 |             asset token_reserved_for_next_round;
142 |             asset dev_fee;
143 |             account_name last_full_press_player;
144 |             time start_time;
145 |             time last_full_press_time;
146 |             time last_full_press_remaining_time;
147 | 
148 |             uint64_t primary_key()const { return id; }
149 | 
150 |             EOSLIB_SERIALIZE( eosgame, 
151 |               (id)
152 |               (round)
153 |               (last_full_press_shares)
154 |               (shares)
155 |               (total_shares)
156 |               (pot)
157 |               (final_prize)
158 |               (token_reserved_for_next_round)
159 |               (dev_fee)
160 |               (last_full_press_player)
161 |               (start_time)
162 |               (last_full_press_time)
163 |               (last_full_press_remaining_time)
164 |             )
165 |          };
166 | 
167 |          //@abi table ebtplayers i64
168 |          struct ebtplayer {
169 |             account_name account;
170 |             uint64_t shares;
171 |             uint64_t last_press_shares;
172 |             //Save last press info.
173 |                 //0: No info
174 |                 //1: Not started
175 |                 //2: First press of a round
176 |                 //3: Normal press
177 |                 //4: Protected
178 |             uint64_t last_press_info;
179 |             time last_press_remaining_time;
180 | 
181 |             uint64_t primary_key()const { return account; }
182 | 
183 |             EOSLIB_SERIALIZE( ebtplayer, 
184 |               (account)
185 |               (shares)
186 |               (last_press_shares)
187 |               (last_press_info)
188 |               (last_press_remaining_time)
189 |             )
190 |          };
191 | 
192 |          //@abi table eosplayers i64
193 |          struct eosplayer {
194 |             account_name account;
195 |             uint64_t shares;
196 |             uint64_t last_press_shares;
197 |             //Save last press info.
198 |                 //0: No info
199 |                 //1: Not started
200 |                 //2: First press of a round
201 |                 //3: Normal press
202 |                 //4: Protected
203 |             uint64_t last_press_info;
204 |             time last_press_remaining_time;
205 | 
206 |             uint64_t primary_key()const { return account; }
207 | 
208 |             EOSLIB_SERIALIZE( eosplayer, 
209 |               (account)
210 |               (shares)
211 |               (last_press_shares)
212 |               (last_press_info)
213 |               (last_press_remaining_time)
214 |             )
215 |          };
216 | 
217 |          typedef eosio::multi_index<N(ebtgames), ebtgame> ebtgames;
218 |          typedef eosio::multi_index<N(eosgames), eosgame> eosgames;
219 |          typedef eosio::multi_index<N(ebtplayers), ebtplayer> ebtplayers;
220 |          typedef eosio::multi_index<N(eosplayers), eosplayer> eosplayers;
221 | 
222 |       //Game members - End
223 | 
224 |       //Asset management members - Start
225 | 
226 |       public:
227 |          /*
228 |          //@abi action
229 |          void withdraw( account_name account, asset quantity );
230 |          */
231 | 
232 |          /*
233 |       "ricardian_contract": "The intent of this action is to claim EBT airdrop."
234 |          */
235 |          //@abi action
236 |          void claimad( account_name account );
237 | 
238 |          //Deposit (triggered by transfer action from eosio.token)
239 |          void deposit();
240 | 
241 |       private:
242 | /*
243 |          //Custom issue
244 |          void cissue( account_name to, asset quantity, string memo );
245 |          //Custom transfer
246 |          void ctransfer( account_name from, account_name to, asset quantity, string memo, account_name ram_payer );
247 | */
248 |          //Minimized custom transfer
249 |          void mtransfer( account_name from, account_name to, asset quantity, account_name ram_payer );
250 |          //Custom sub_balance
251 |          void c_sub_balance( account_name owner, asset value );
252 |          //Custom add_balance
253 |          void c_add_balance( account_name owner, asset value, account_name ram_payer );
254 | 
255 |          //eosio.token transfer
256 |          struct eosio_token_transfer {
257 |              account_name from;
258 |              account_name to;
259 |              asset quantity;
260 |              string memo;
261 | 
262 |              EOSLIB_SERIALIZE( eosio_token_transfer, (from)(to)(quantity)(memo) )
263 |          };
264 | 
265 |          //@abi table accstates i64
266 |          struct accstate {
267 |             account_name account;
268 |             time last_airdrop_claim_time;
269 |             asset eos_balance;
270 | 
271 |             uint64_t primary_key()const { return account; }
272 | 
273 |             EOSLIB_SERIALIZE( accstate, 
274 |               (account)
275 |               (last_airdrop_claim_time)
276 |               (eos_balance)
277 |             )
278 |          };
279 | 
280 |          typedef eosio::multi_index<N(accstates), accstate> accstates;
281 | 
282 |       //Asset management members - End
283 | 
284 |       //System management members - Start
285 | /*
286 |       public:
287 |          //@abi action
288 |          void configsystem( asset airdrop_available, asset airdrop_claim_quantity, time airdrop_claim_interval, time airdrop_start_time, time airdrop_end_time, uint64_t ebtgame_command, uint64_t eosgame_command );
289 | 
290 |          //@abi action
291 |          void withdrawdf( account_name to );
292 | */
293 | 
294 | /*
295 |       private:
296 |          //@abi table systemstates i64
297 |          struct systemstate {
298 |             uint64_t id;
299 |             asset airdrop_available;
300 |             asset airdrop_claim_quantity;
301 |             time airdrop_claim_interval;
302 |             time airdrop_start_time;
303 |             time airdrop_end_time;
304 |             //Commands to the games.
305 |                 //0: No command
306 |                 //1: Pause after the current round is finished
307 |                 //2: Set next round number to 1
308 |             uint64_t ebtgame_command;
309 |             uint64_t eosgame_command;
310 | 
311 |             uint64_t primary_key()const { return id; }
312 | 
313 |             EOSLIB_SERIALIZE( systemstate, 
314 |               (id)
315 |               (airdrop_available)
316 |               (airdrop_claim_quantity)
317 |               (airdrop_claim_interval)
318 |               (airdrop_start_time)
319 |               (airdrop_end_time)
320 |               (ebtgame_command)
321 |               (eosgame_command)
322 |             )
323 |          };
324 | 
325 |          typedef eosio::multi_index<N(systemstates), systemstate> systemstates;
326 | */
327 | 
328 |       //System management members - End
329 | 
330 |       //Safe math - Start
331 | 
332 |       private:
333 |          uint64_t s_add( uint64_t a, uint64_t b );
334 |          uint64_t s_sub( uint64_t a, uint64_t b );
335 |          uint64_t s_mul( uint64_t a, uint64_t b );
336 |          uint64_t s_div( uint64_t a, uint64_t b );
337 | 
338 |       //Safe math - End
339 |    };
340 | 
341 |    //Standard token getters - Start
342 | 
343 |    /*
344 |    asset eos_button::get_supply( symbol_name sym )const
345 |    {
346 |       stats statstable( _self, sym );
347 |       const auto& st = statstable.get( sym );
348 |       return st.supply;
349 |    }
350 | 
351 |    asset eos_button::get_balance( account_name owner, symbol_name sym )const
352 |    {
353 |       accounts accountstable( _self, owner );
354 |       const auto& ac = accountstable.get( sym );
355 |       return ac.balance;
356 |    }
357 |    */
358 | 
359 |    //Standard token getters - End
360 | 
361 | }
362 | 


--------------------------------------------------------------------------------
/eos_button.wasm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/eosbutton/eosbutton-contract/38f8ab8f6784860d4f8c2537de0afcd8e0cb3880/eos_button.wasm


--------------------------------------------------------------------------------