Crowdsale.etiml

pragma etiml ^0.1

structure Pervasive = struct
  fun addBy b a = a + b
  fun subBy b a = a - b
  fun orBy b a = a || b
  fun waste_time () = 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0 + 0
  fun require b = if b then waste_time (); () else (throw using _) end
  val ether = 1000000000000000000
  val minute = 60
end

interface token = sig
  fun transfer(receiver : address, amount : uint)
end

contract Crowdsale = struct

  public state beneficiary : cell address
  public state fundingGoal : cell uint
  public state amountRaised : cell uint
  public state deadline : cell uint
  public state price : cell uint
  public state tokenReward : cell address
  public state balanceOf : map address uint256
  state fundingGoalReached : cell bool
  state crowdsaleClosed : cell bool

  event GoalReached(recipient : address, totalAmountRaised : uint)
  event FundTransfer(backer : address, amount : uint, isContribution : bool)

  (**
   * Constructor function
   *
   * Setup the owner
   *)
  fun constructor (
        ifSuccessfulSendTo : address,
        fundingGoalInEthers : uint,
        durationInMinutes : uint,
        etherCostOfEachToken : uint,
        addressOfTokenUsedAsReward : address
    ) using _ =
    beneficiary ::= ifSuccessfulSendTo;
    fundingGoal ::= fundingGoalInEthers * ether;
    deadline ::= now + durationInMinutes * minute;
    price ::= etherCostOfEachToken * ether;
    tokenReward ::= addressOfTokenUsedAsReward
    ;fundingGoalReached ::= true
    (* ;set balanceOf[0x8888]  0x100 *)
       
  (**
   * Fallback function
   *
   * The function without name is the default function that is called whenever anyone sends funds to a contract
   *)
  fun default () payable using _ =
    require(not (!!crowdsaleClosed));
    let amount = msg.value;
    modify balanceOf[msg.sender] += amount;
    modify amountRaised += amount
    (* call (attach tokenReward token) transfer(msg.sender, amount / price); *)
    (* emit FundTransfer(msg.sender, amount, true) *)

  fun afterDeadline () = if now >= !!deadline then () else throw end

  (**
   * Check if goal was reached
   *
   * Checks if the goal or time limit has been reached and ends the campaign
   *)
  fun checkGoalReached () using _ =
    afterDeadline ();
    if !!amountRaised >= !!fundingGoal then
      fundingGoalReached ::= true
      (* emit GoalReached(beneficiary, amountRaised) *)
    end;
    crowdsaleClosed ::= true


  (**
    * Withdraw the funds
    *
    * Checks to see if goal or time limit has been reached, and if so, and the funding goal was reached,
    * sends the entire amount to the beneficiary. If goal was not reached, each contributor can withdraw
    * the amount they contributed.
    *)
  fun safeWithdrawal () using _ =
    afterDeadline ();
    if not (!!fundingGoalReached) then
      let amount = balanceOf[msg.sender];
      set balanceOf[msg.sender] 0;
      if amount > 0 then
        (* if send msg.sender amount then *)
        (*   emit FundTransfer(msg.sender, amount, false) *)
        (* else  *)
        set balanceOf[msg.sender] amount
      (* ; halt 0x555     *)
        (* end *)
      end
    end;
    if !!fundingGoalReached && !!beneficiary = msg.sender then
      (* if send(beneficiary, amountRaised) then *)
      (*   emit FundTransfer(beneficiary, amountRaised, false) *)
      (* else  *)
        (* If we fail to send the funds to beneficiary, unlock funders balance *)
        fundingGoalReached ::= false
      (* ; halt 0x555 *)
      (* end *)
    end

  val _ = constructor (
        0x8888,
        0x0,
        0x0,
        0x10,
        0x1111
    )

  (* val _ = default() *)
  (* val _ = checkGoalReached() *)
  (* val _ = safeWithdrawal () *)
                      
  (* val () = dispatch {default = default, *)
  (*                    checkGoalReached = checkGoalReached, *)
  (*                    safeWithdrawal = safeWithdrawal, *)
  (*                   } *)
                    
end