Open Source/Audit
We will do our best to make the code as safe as possible, but I can't guarantee that there will never be errors.
If you choose to use the miner, you do so at your own risk, and accept the possibility of a bug. The entire source code for our project is public! This means that anyone can view, review, and contribute to the code. We believe that this will make our project more transparent, accountable, and secure.
We encourage you to review the code and report any bugs you find. We are committed to fixing bugs quickly and efficiently.
We also welcome your contributions to the code. If you have any ideas for how to improve the project, please feel free to submit a pull request.
// module ddos_coin::ddos_coin {
use std::signer;
use std::string::utf8;
use std::vector;
use aptos_std::math128;
use aptos_std::math64;
use aptos_std::table;
use aptos_std::table::Table;
use aptos_framework::coin::{Self, BurnCapability, FreezeCapability};
use aptos_framework::account;
use aptos_framework::account::SignerCapability;
use aptos_framework::aptos_account;
use aptos_framework::block;
use aptos_framework::event;
use aptos_framework::event::EventHandle;
use aptos_framework::object;
use aptos_framework::object::{Object, DeleteRef};
const ERR_NOT_ADMIN: u64 = 1;
const ERR_COIN_INITIALIZED: u64 = 2;
const ERR_COIN_NOT_INITIALIZED: u64 = 3;
// === Errors ===
const EWrongBlock: u64 = 100;
const EDirectorIsPaused: u64 = 101;
const EUserIsRegistered: u64 = 102;
const EUserCounterIsRegistered: u64 = 103;
const EUserCounterIsNotRegistered: u64 = 104;
const EUserCounterIsWrongOwner:u64 = 105;
const TREASURE_SUPPLY:u64 = 1_000_000_000;
const TOTAL_SUPPY:u64 = 21_000_000_000;
const BASE_BLOCK_CONVERT:u64 = 400_000; // 400_000
const BASE_REWARD_PER_BLOCK_CONVERT:u64 = 10_000_000;
const REWARD_DIV_AFTER_BLOCK_CONVERT:u64 = 10; // 10
struct DDOS_COIN {}
struct AdminCap has key, store {
signer_cap:SignerCapability
}
struct Director has key, store {
block_start:u64,
paused:bool,
tx_count:u64,
total_reward_minted:u64,
burn_cap:BurnCapability<DDOS_COIN>,
user_counter_events:EventHandle<CreateUserCounterEvent>,
freeze_cap:FreezeCapability<DDOS_COIN>,
block_convert_counters:Table<u64,BlockConvertCounter>,
}
struct BlockConvertCounter has store {
block_convert:u64,
tx_count:u64,
user_counts:Table<address,u64>
}
struct UserCounter has key, store {
user_addr:address,
block_convert:u64,
tx_count:u64,
registered:bool,
del_ref:DeleteRef
}
struct Stats has copy, drop {
block_started:u64,
block_convert:u64,
paused:bool,
tx_count:u64,
reward_minted:u64,
blocks:vector<BlockConvertStats>
}
struct BlockConvertStats has copy, drop {
block_convert:u64,
tx_count:u64
}
struct UserCounterReponse has copy, drop {
user_addr:address,
block_convert:u64,
tx_count:u64,
registered:bool,
}
struct CreateUserCounterEvent has copy, drop, store {
user_counter:address
}
const ADMIN_ADDR:address = @ddos_coin;
const TREASURE_ADDR:address = @0x73bd5b362d4d1520787b77e176f57b2ee8e4a6ad7ab050eb2d4b8bbe65c8de2a;
fun init_module(coin_admin:&signer) acquires Director {
let sender_address = signer::address_of(coin_admin);
let (burn_cap, freeze_cap, mint_cap) = coin::initialize<DDOS_COIN>(
coin_admin,
utf8(b"DDOS"),
utf8(b"DDOS"),
8,
true,
);
if(!coin::is_account_registered<DDOS_COIN>(sender_address)){
coin::register<DDOS_COIN>(coin_admin);
};
//mint for treassure
let coin_treassures = coin::mint(math64::pow(10,8)*TREASURE_SUPPLY,&mint_cap);
coin::deposit(sender_address,coin_treassures);
let coin_rewards = coin::mint(math64::pow(10,8)*(TOTAL_SUPPY-TREASURE_SUPPLY),&mint_cap);
let (res_signer, signer_cap) = account::create_resource_account(coin_admin, x"01");
let res_addr:address = signer::address_of(&res_signer);
if (!exists<Director>(ADMIN_ADDR)) {
move_to(coin_admin,AdminCap {
signer_cap
})
};
move_to(&res_signer, Director {
block_start:block::get_current_block_height(),
paused:false,
tx_count:0,
total_reward_minted:0,
burn_cap,
freeze_cap,
block_convert_counters: table::new(),
user_counter_events:account::new_event_handle(&res_signer)
});
// init for first block
let director = borrow_global_mut<Director>(res_addr);
table::add(&mut director.block_convert_counters,0,BlockConvertCounter{
block_convert:0,
tx_count:0,
user_counts:table::new<address,u64>()
});
aptos_account::deposit_coins(res_addr,coin_rewards);
coin::destroy_mint_cap(mint_cap);
}
public entry fun new_user_counter(
sender:&signer
) acquires AdminCap, Director {
let sender_addr = signer::address_of(sender);
let admin_cap = borrow_global_mut<AdminCap>(ADMIN_ADDR);
let res_signer = account::create_signer_with_capability(&admin_cap.signer_cap);
let res_addr = signer::address_of(&res_signer);
let director = borrow_global_mut<Director>(res_addr);
assert!(director.paused == false, EDirectorIsPaused);
let constructor_ref = object::create_object_from_account(sender);
let container_signer = object::generate_signer(&constructor_ref);
let delete_ref = object::generate_delete_ref(&constructor_ref);
let transfer_ref = object::generate_transfer_ref(&constructor_ref);
object::disable_ungated_transfer(&transfer_ref);
let current_block = block::get_current_block_height();
let block_convert = (current_block - director.block_start) / BASE_BLOCK_CONVERT;
move_to(&container_signer,UserCounter{
user_addr:sender_addr,
block_convert,
tx_count:1,
registered:false,
del_ref:delete_ref
});
let obj = object::object_from_constructor_ref<UserCounter>(&constructor_ref);
event::emit_event(&mut director.user_counter_events,CreateUserCounterEvent{
user_counter: object::object_address(&obj)
})
}
public entry fun register_user_counter(
sender:&signer,
_user_counter:Object<UserCounter>
) acquires AdminCap, Director, UserCounter {
let sender_addr = signer::address_of(sender);
let admin_cap = borrow_global_mut<AdminCap>(ADMIN_ADDR);
let res_signer = account::create_signer_with_capability(&admin_cap.signer_cap);
let res_addr = signer::address_of(&res_signer);
let director = borrow_global_mut<Director>(res_addr);
let uc_addr = object::object_address(&_user_counter);
let user_counter = borrow_global_mut<UserCounter>(uc_addr);
//
assert!(director.paused == false, EDirectorIsPaused);
assert!(user_counter.registered == false, EUserCounterIsRegistered);
assert!(user_counter.user_addr == sender_addr, EUserCounterIsWrongOwner);
//
let current_block = block::get_current_block_height();
let block_convert = (current_block - director.block_start) / BASE_BLOCK_CONVERT;
//
if (block_convert > 0) {
let prev_block_convert = block_convert - 1;
assert!(user_counter.block_convert == prev_block_convert, EWrongBlock);
}else if (block_convert == 0){
assert!(false, EWrongBlock);
};
//
let prev_block_convert = block_convert - 1;
let block_convert_counter = get_or_create_block_convert_counter(prev_block_convert, director);
assert!(!table::contains(&block_convert_counter.user_counts,sender_addr),EUserIsRegistered);
table::add(&mut block_convert_counter.user_counts,sender_addr,user_counter.tx_count);
block_convert_counter.tx_count = block_convert_counter.tx_count + user_counter.tx_count;
director.tx_count = director.tx_count + user_counter.tx_count;
user_counter.registered = true;
}
public entry fun increment_user_counter(
sender:&signer,
_user_counter:Object<UserCounter>
) acquires UserCounter, AdminCap, Director {
let sender_addr = signer::address_of(sender);
let admin_cap = borrow_global_mut<AdminCap>(ADMIN_ADDR);
let res_signer = account::create_signer_with_capability(&admin_cap.signer_cap);
let res_addr = signer::address_of(&res_signer);
let director = borrow_global_mut<Director>(res_addr);
let uc_addr = object::object_address(&_user_counter);
let user_counter = borrow_global_mut<UserCounter>(uc_addr);
let current_block = block::get_current_block_height();
let block_convert = (current_block - director.block_start) / BASE_BLOCK_CONVERT;
assert!(user_counter.block_convert == block_convert, EWrongBlock);
assert!(user_counter.user_addr == sender_addr, EUserCounterIsWrongOwner);
user_counter.tx_count = user_counter.tx_count + 1;
let service_fee = 9_950;
aptos_account::transfer(sender,TREASURE_ADDR,service_fee);
}
public entry fun destroy_user_counter(
sender:&signer,
_user_counters:vector<Object<UserCounter>>
) acquires UserCounter {
let sender_addr = signer::address_of(sender);
while (!vector::is_empty(&_user_counters)){
let _user_counter = vector::pop_back(&mut _user_counters);
let uc_addr = object::object_address(&_user_counter);
let user_counter = move_from<UserCounter>(uc_addr);
// let uc_addr = object::object_address(&_user_counter);
let UserCounter {
user_addr,
block_convert:_,
tx_count:_,
registered:_,
del_ref
} = user_counter;
assert!(user_addr == sender_addr, EUserCounterIsWrongOwner);
object::delete(del_ref);
}
}
public entry fun claim_user_counter(
sender:&signer,
_user_counter:Object<UserCounter>
) acquires AdminCap, Director, UserCounter {
let sender_addr = signer::address_of(sender);
let admin_cap = borrow_global_mut<AdminCap>(ADMIN_ADDR);
let res_signer = account::create_signer_with_capability(&admin_cap.signer_cap);
let res_addr = signer::address_of(&res_signer);
let director = borrow_global_mut<Director>(res_addr);
let current_block = block::get_current_block_height();
let block_convert = (current_block - director.block_start) / BASE_BLOCK_CONVERT;
let uc_addr = object::object_address(&_user_counter);
let user_counter = borrow_global_mut<UserCounter>(uc_addr);
// let uc_addr = object::object_address(&_user_counter);
assert!(user_counter.user_addr == sender_addr, EUserCounterIsWrongOwner);
let max_allowed_block_convert = block_convert - 2;
assert!(user_counter.block_convert <= max_allowed_block_convert, EWrongBlock);
assert!(user_counter.registered, EUserCounterIsNotRegistered);
let block_convert_counter = table::borrow_mut(&mut director.block_convert_counters,user_counter.block_convert);
let user_txs = table::remove(&mut block_convert_counter.user_counts,sender_addr);
//
let current_total_reward = BASE_REWARD_PER_BLOCK_CONVERT / ((block_convert / REWARD_DIV_AFTER_BLOCK_CONVERT) + 1);
let total_txs = block_convert_counter.tx_count;
let user_reward = (math128::mul_div((current_total_reward as u128),(user_txs as u128),(total_txs as u128)) as u64);
director.total_reward_minted = director.total_reward_minted + math64::pow(10,8)*user_reward;
let vec_user_counters = vector[_user_counter];
destroy_user_counter(sender,vec_user_counters);
let coins = coin::withdraw<DDOS_COIN>(&res_signer,math64::pow(10,8)*user_reward);
aptos_account::deposit_coins(sender_addr,coins);
}
// view fuction
#[view]
public fun stats_for_specific_blocks(
block_convert_numbers:vector<u64>
): Stats acquires AdminCap, Director {
let block_stats = vector<BlockConvertStats>[];
let i = 0;
let count = vector::length(&block_convert_numbers);
let admin_cap = borrow_global_mut<AdminCap>(ADMIN_ADDR);
let res_signer = account::create_signer_with_capability(&admin_cap.signer_cap);
let res_addr = signer::address_of(&res_signer);
let director = borrow_global_mut<Director>(res_addr);
let current_block = block::get_current_block_height();
let block_convert = (current_block - director.block_start) / BASE_BLOCK_CONVERT;
while (i < count){
let block_number = *vector::borrow_mut(&mut block_convert_numbers,i);
if (table::contains(&director.block_convert_counters,block_number)){
let block = table::borrow_mut(&mut director.block_convert_counters,block_number);
let stats = BlockConvertStats{
block_convert:block_number,
tx_count:block.tx_count
};
vector::push_back(&mut block_stats,stats);
}else{
let stats = BlockConvertStats{
block_convert:block_number,
tx_count:0
};
vector::push_back(&mut block_stats,stats);
};
i = i + 1;
};
return Stats {
block_started:director.block_start,
block_convert,
paused:director.paused,
tx_count:director.tx_count,
reward_minted:director.total_reward_minted,
blocks:block_stats
}
}
#[view]
public fun get_user_counters(
_user_counters:vector<address>
):vector<UserCounterReponse> acquires UserCounter {
let res = vector<UserCounterReponse>[];
let i = 0;
let count = vector::length(&_user_counters);
while (i < count) {
let uc_addr = *vector::borrow(& _user_counters,i);
if (!exists<UserCounter>(uc_addr)){
vector::push_back(&mut res,UserCounterReponse{
user_addr:@0x0,
block_convert:0,
tx_count:0,
registered:false,
})
}else {
let user_counter = borrow_global_mut<UserCounter>(uc_addr);
vector::push_back(&mut res,UserCounterReponse{
user_addr:user_counter.user_addr,
block_convert:user_counter.block_convert,
tx_count:user_counter.tx_count,
registered:user_counter.registered,
})
};
i = i + 1;
};
return res
}
// private fuction
fun get_or_create_block_convert_counter(
block_convert:u64,
director:&mut Director
): &mut BlockConvertCounter {
if (!table::contains(&director.block_convert_counters,block_convert)){
let block_convert_counter = BlockConvertCounter{
block_convert,
tx_count:0,
user_counts:table::new<address,u64>()
};
table::add(&mut director.block_convert_counters,block_convert,block_convert_counter);
};
table::borrow_mut(&mut director.block_convert_counters,block_convert)
}
}
Last updated