how to modify smart contract template for self defined functionality

Question

I have looked at several smart contract template and go through several tutorials. But none of them go through details of those code line by line. I want to add a function that give back dividends of company profit to customers, where should I add it? For example the following code template, can I add my function giveBackDividend() in the code block?

can anyone walk me through the general structure of smart contract for ICO?

contract HubiiCrowdsale is Crowdsale {
  uint private constant chunked_multiple = 18000 * (10 ** 18); // in wei
  uint private constant limit_per_address = 100000 * (10 ** 18); // in wei
  uint private constant hubii_minimum_funding = 17000 * (10 ** 18); // in wei
  uint private constant token_initial_supply = 0;
  uint8 private constant token_decimals = 15;
  bool private constant token_mintable = true;
  string private constant token_name = "Hubiits";
  string private constant token_symbol = "HBT";
  uint private constant token_in_wei = 10 ** 15;
  // The fraction of 10,000 out of the total target tokens that is used to mint bonus tokens. These are allocated to the team's multisig wallet.
  uint private constant bonus_base_points = 3000;
  function HubiiCrowdsale(address _teamMultisig, uint _start, uint _end) Crowdsale(_teamMultisig, _start, _end, hubii_minimum_funding) public {
      PricingStrategy p_strategy = new FlatPricing(token_in_wei);
      CeilingStrategy c_strategy = new FixedCeiling(chunked_multiple, limit_per_address);
      FinalizeAgent f_agent = new BonusFinalizeAgent(this, bonus_base_points, _teamMultisig); 
      setPricingStrategy(p_strategy);
      setCeilingStrategy(c_strategy);
      // Testing values
      token = new CrowdsaleToken(token_name, token_symbol, token_initial_supply, token_decimals, _teamMultisig, token_mintable);
      token.setMintAgent(address(this), true);
      token.setMintAgent(address(f_agent), true);
      token.setReleaseAgent(address(f_agent));
      setFinalizeAgent(f_agent);
  }

  // These two setters are present only to correct block numbers if they are off from their target date by more than, say, a day
  function setStartingBlock(uint startingBlock) public onlyOwner inState(State.PreFunding) {
      require(startingBlock > block.number && startingBlock < endsAt);
      startsAt = startingBlock;
  }

  function setEndingBlock(uint endingBlock) public onlyOwner notFinished {
      require(endingBlock > block.number && endingBlock > startsAt);
      endsAt = endingBlock;
  }

}

score 1 · Answer 1 · answered Sep 20 '17 at 16:21

TL;DR; This code simply defines the start and end of the ICO using block number, but it extends various other sources to implement the Token, etc. Modifying it won't cause any issues.

I think you're starting in the wrong place. Firstly, you can add any code to any contract without implicating its existing functionality. I know it's a little premature, but I plan to do 2 tutorials in the next day or so on the ERC20 and ERC223 standards which is what a token should be designed around. This will be posted on https://www.youtube.com/channel/UCaWes1eWQ9TbzA695gl_PtA

ERC20

contract ERC20 {
    function totalSupply() constant returns (uint totalSupply);
    function balanceOf(address _owner) constant returns (uint balance);
    function transfer(address _to, uint _value) returns (bool success);
    function transferFrom(address _from, address _to, uint _value) returns (bool success);
    function approve(address _spender, uint _value) returns (bool success);
    function allowance(address _owner, address _spender) constant returns (uint remaining);
    event Transfer(address indexed _from, address indexed _to, uint _value);
    event Approval(address indexed _owner, address indexed _spender, uint _value);
}

ERC223

contract ERC223 {
    uint public totalSupply;
    function balanceOf(address who) constant returns (uint);
    function name() constant returns (string _name);
    function symbol() constant returns (string _symbol);
    function decimals() constant returns (uint8 _decimals);
    function totalSupply() constant returns (uint256 _supply);
    function transfer(address to, uint value) returns (bool ok);
    function transfer(address to, uint value, bytes data) returns (bool ok);
    function transfer(address to, uint value, bytes data, string custom_fallback) returns (bool ok);
    event Transfer(address indexed from, address indexed to, uint value, bytes indexed data);
}

After you have your contract for your token you then want to think about the ICO. With the ICO you should define start and end points. In the example above this is based off the blocks which is why you have:

  require(startingBlock > block.number && startingBlock < endsAt);

and

  require(endingBlock > block.number && endingBlock > startsAt);

This contract is inheriting from a contract called "Crowdsale" which is where most of your implementation looks like it's coming from. The full source code for this can be found on https://etherscan.io/address/0xb9aac097f4dadcd6f06761eb470346415ef28d5a#code This token is based around ERC20 standard and has quite a bit of an inheritance tree.

The code for the token is done in the BasicToken :

/**
 * @title Basic token
 * @dev Basic version of StandardToken, with no allowances. 
 */
contract BasicToken is ERC20Basic {
  using SafeMath for uint;

  mapping(address => uint) balances;

  /**
   * Obsolete. Removed this check based on:
   * https://blog.coinfabrik.com/smart-contract-short-address-attack-mitigation-failure/
   * @dev Fix for the ERC20 short address attack.
   *
   * modifier onlyPayloadSize(uint size) {
   *    require(msg.data.length >= size + 4);
   *    _;
   * }
   */

  /**
  * @dev transfer token for a specified address
  * @param _to The address to transfer to.
  * @param _value The amount to be transferred.
  */
  function transfer(address _to, uint _value) public returns (bool success) {
    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    Transfer(msg.sender, _to, _value);
    return true;
  }

  /**
  * @dev Gets the balance of the specified address.
  * @param _owner The address to query the the balance of. 
  * @return An uint representing the amount owned by the passed address.
  */
  function balanceOf(address _owner) public constant returns (uint balance) {
    return balances[_owner];
  }

}

It looks like it's using bits of ERC20 and ERC223 standards which is fine, but a little confusing if you're trying to follow the source code.

how to modify smart contract template for self defined functionality

1 Answers1