The function is calculating a multiplication. If you're using very big numbers, the variables will overflow resulting in 0 instead of a big number.

function calculateSum(uint24 a, uint24 b) returns(uint24) {

  return a * b;

}

This function can only be executed by the owner of the contract because of the modifier `onlyOwner` which is usually an external user, but it's declared `public`. This is a problem because it uses more gas than needed.

function example() public onlyOwner {

  // Do something

}

The function is called `nonZeroSum()` indicating that it's used to sum numbers that are not zero. However the content of the function isn't checking for that condition.

function nonZeroSum(uint256 a, uint256 b) {

  return a + b;

}

You're telling the Solidity compiler to use the latest version of solidity bigger than 0.4.11. This is a problem because you're writing code with the way of doing things in an older version. Newer versions of Solidity deprecate functions like `throw;` and break your program if you're using them.

pragma solidity ^0.4.11;

This refers to any use of `call`, `delegatecall`, `send`, or any direct call to another contract that results in the execution of an unknown, possibly malicious, fallback function.

Example newContract;
function sendEther() {

  // Don't use this function because it's dangerous
  newContract.delegatecall(msg.sender);

}

If the arguments to a direct call from one contract to a function of another contract is incorrectly typed, or the address of the called contract is incorrect, either nothing will happen, or the wrong code will execute. In neither case is an exception thrown, and the caller is not made aware.

function sendEther(address recipient) internal {

  recipient.transfer(this.balance);

}

In some cases, a contract’s fallback function allows it to re-enter a caller function before it has terminated. This can result in the repeated execution of functions intended only to be executed once per transaction.

mapping(address => uint) balances;
function sendEther() payable {

  // Don't use this function because it's dangerous
  msg.sender.call.value(msg.value)();
  balances[msg.sender] = 0;

}

By the public nature of the blockchain, contract fields marked private are not guaranteed to remain secret to set a private field, a contract owner must broadcast a transaction. Cryptographic protocols are required to guarantee that fields are not visible to anyone mining or inspecting the blockchain.

uint private balance;
address private owner;
string private secretKey;

When a contract is added to the blockchain, there is no way to edit it. If a contract is found to be defective, there is often nothing to be done short of killing the contract (assuming measures were taken by the contract creator to make this possible). In this case the contract doesn't have a method to extract the ether received.

contract Lost {

  function () payable {}

}

If you send Ether to an invalid address that it's not existing or if the address is ill-formed, then you'll lose the ether sent without a way to recover it.

function transferEther(address sender) payable {

  sender.tranfer(msg.value);

}

This occurs when the assumed state of the blockchain is not the blockchain’s actual state when a transaction is executed. The order in which transactions are mined can have adverse effects on the execution of any given transaction. This bug is said to be present in up to %15.8 of all contracts on the blockchain. In this contract, you can only `extractReward()` once and if the reward has not been send. It could happen that you try to extract the reward and it's already too late.

bool rewardSent = false;
uint time;
function activateReward() {

  if(now > time) rewardSent = true;

}

function extractReward() onlyOnce {

  require(rewardSent == false) msg.sender.tranfer(this.balance);

}

Here we are not checking what claimThrone Function returns and exceptions are not handled.

module Exception where
import Control.Exception
newtype Address = Address {sender::String, value::Number}
newtype Monarch = Monarch{ ethAddr::Address,
  name::String,
  claimPrice::Number,
  coronationTimeStamp::Number
}

type MyState = State Monarch

claimThrone::String -> Unit
claimThrone name = do
  monarch <- get
  put(monarch.ethAddr, name, monarch.claimPrice, monarch.coronationTimeStamp)
  unit

claimThrone "FluidAI"

claimThroneWithException :: String -> Unit
claimThrone name = do
  monarch <- get
  put(
    monarch.ethAddr,
    name,
    monarch.claimPrice,
    monarch.coronationTimeStamp
  )
  unit
catch (claimThroneWithException "FluidAI") (e -> let err = show (e :: Exception)
  hPutStr stderr ("Warning: Couldn't open " ++ f ++ ": " ++ err)
  return ""))

Here we can again call tokenHandler which would increase the tokenholder value because balance of sender was not yet updated.

module Recursive where

newtype Address = Address {sender:: String, value :: Number}

type MyState = State Address

tokenHandler ::Address -> Unit
tokenHandler address = do
  tokenHolders <- get
  tokenHolders.value += (address.value / 10)
  updateBalanceOfSender address address.value/10

updateBalaneOfSender :: Address-> Number -> Unit
updateBalaneOfSender address value = do
  unit

No text found

module TOD where
import Control.Monad.State
newtype Address = Address {sender:: String, value:: Number}
type MyState = (Number,Number)
startState :: MyState
startState = (0.0,0.0)

updatePrice :: Number -> Address  -> Eff Unit
updatePrice price sender  = do
  if sender.sender == "owner" then do
    (quantity,price1) <- get
    put (quantity,price)
    else
      unit

buy :: Number -> Address -> Eff Unit
buy quantity sender = do
  (total,totalPrice) <- get
  if sender.value > quantity * price then do
    put (total-quantiy,totalPrice+(quantity*price))
    else
      unit

There is possiblity of make call to send money after calling withdrawbalance because we are setting the value to zero at last line of function.

module reentrancy where
newtype Address = Address {sender :: String, value :: Number}
getBalance :: Address -> Number
getBalance address = do
  address.value

addToBalance :: Address -> Number -> Unit
addToBalance address amount = do
  address.value = address.value + amount
  unit

withDrawBalance :: Address -> Unit
withDrawBalance address = do
  address.value = 0
  unit