Memory leaks happen when a program drains your computer’s Dynamic Random Access Memory (DRAM). It often arises from unpatched software, such as when you fail to update the Operating System (OS) to the newest release.

Out of Memory is an error when there is no longer any spare memory to allocate to programs, or the memory requested exceeds the amount of memory available. An Out of Memory error causes programs to terminate or even the entire computer to crash triggering a Core Dump. The Out of Memory occurs when

• A computer has a small amount of Random Access Memory (RAM)
• Too many Applications or hardware pieces running at once
• A request is made for a large amount of Random Access Memory (RAM) that exceeds amount available

Note: Deleting items from the hard drive does not alleviate this problem

A Heap Error is when code inadvertently overwrites control information memory management functions use to control heap usage. The application that you are debugging must have been built with the heap check capability.

The Stack Memory is the working area of memory that grows and shrinks dynamically with the demands of your executing program. Whenever an Application, program, function, procedure or a declarative block is invoked, or a local Variable is created, memory is allocated from the Stack. Some common reasons for this error are:

• There are too many active procedure call being made (i.e., functions, procedures, methods, etc.)
• There is a request to allocate local variables that exceed the available stack space
• There are too many fixed-length strings, which in most compilers is allocated from the Stack
• There is a Recursion issue

Division by Zero (DIV/0) can occur in any application where the quotient is a Variable value substituted at Run Time. It is an error typically associated with spreadsheets. When formula inputs in the spreadsheet are left blank, the total might display a DIV/0 error. The cell formulas need to be formatted in a precise manner to produce the correct output.

Encoding errors happen when you’re rendering a file, say a video file, to convert it into a usable or accessible file format. This is due to the resource-intensive nature of the encoding process. Error messages linked to this type of error include “encoding overloaded” or “encoding failed.”

Input/Output (I/O) device errors occur when issues arise with the read/write function of a device. Common causes include device malfunction, outdated drivers, OS incompatibility, and faulty universal serial bus (USB) ports. As a result, users would get a prompt saying that the device wasn’t accessible, making it impossible to transfer or encode files into it. Usually, the memory drive or the computer only needs to be restarted to get rid of the issue.

Overflow Error occurs when an attempt is made to place a value into memory an integer (whole number) that is too large for the integer data type in a given system. For exaample, putting a 32-Bit value into a 16-Bit data field). Also see: Wrap Around

A Range Error occurs when a value is not in the set or range of allowed values. For example, a percent might only allow numbers between 0 and 100, and an attempt is made to store a -1 or 101 into the field.

Segmentation Fault (SEGFAULT) is an error returned by Hardware (H/W) with memory protection that tells the Operating System (OS) that a memory access violation has occurred.

An undefined object error happens when a program attempts to call a function for a PHP or JavaScript object (or a C++ variable) that isn’t defined or assigned a value. The error also occurs for deeply nested objects. In simpler terms, the code “cannot read” or find where a property is because it does not exist or is buried several levels deep within the code.

An Underflow Error occurs when a mathematical operation results in a number which is smaller than what the device is capable of storing. For example, an negative number being put into an unsigned number space. Also see: Wrap Around.

User Defined Exception occurs is part of the architecture and design of an Application, routine, methd or object.

tx.origin is useful only in very exceptional cases. If you use it for authentication, you usually want to replace it by “msg.sender”, because otherwise any contract you call can act on your behalf.

Example:

require ( tx.origin == owner );

Potential Violation of Checks-Effects-Interaction pattern can lead to Reentrancy Attack vulnerability.

Example:

// sending ether first
msg.sender.transfer ( amount );

// updating state afterwards
balances [ msg.sender ] -= amount;

Use of inline assembly is advised only in rare cases.

Example:

assembly 
{ // retrieve the size of the code, this needs assembly
  let size := extcodesize(_addr)
} // End assembly

now does not mean current time. now is an alias for block.timestamp. block.timestamp can be influenced by miners to a certain degree, be careful.

Example:

// using now for date comparison
if ( startDate > now )
  { isStarted = true;
  } // End if
// using block.timestamp
uint c = block.timestamp;

Use of low level call, callcode or delegatecall should be avoided whenever possible. send does not throw an exception when not successful, make sure you deal with the failure case accordingly. Use transfer whenever failure of the ether transfer should rollback the whole transaction.

Example:

x.call ( 'something' );
x.send ( 1 wei );

blockhash is used to access the last 256 block hashes. A miner computes the block hash by “summing up” the information in the current block mined. By summing up the information in a clever way a miner can try to influence the outcome of a transaction in the current block.

Example:

bytes32 b = blockhash(100);

selfdestruct can block calling contracts unexpectedly. Be especially careful if this contract is planned to be used by other contracts (i.e. library contracts, interactions). Selfdestruction of the callee contract can leave callers in an inoperable state.

Example:

selfdestruct(address(0x123abc..));

Never use this to call functions in the same contract, it only consumes more gas than normal local calls.

Example:

contract test 
{ function callb() public 
  { address x;
    this.b(x);
  } // End function callb
    
  function b (address a ) 
    public 
    returns ( bool ) 
  {} // End function b
}

The delete operation when applied to a dynamically sized array in Solidity generates code to delete each of the elements contained. If the array is large, this operation can surpass the block gas limit and raise an OOG exception. Also nested dynamically sized objects can produce the same results.

Example:

contract arr 
{ uint[] users;
  function resetState() 
  public
  { delete users;
  } // End function resetState
} // End contract arr

Loops that do not have a fixed number of iterations, for example, loops that depend on storage values, have to be used carefully: Due to the block gas limit, transactions can only consume a certain amount of gas. The number of iterations in a loop can grow beyond the block gas limit, which can stall the complete contract at a certain point. Additionally, using unbounded loops can incur in a lot of avoidable gas costs. Carefully test how many items at maximum you can pass to such functions to make it successful.

Example:

contract forLoopArr 
{ uint[] array;

  function shiftArrItem
    ( uint index ) 
    public 
    returns ( uint[] memory ) 
  { for ( uint i = index; 
               i < array.length; 
               i++
        ) 
     { array [ i ] = array [i + 1 ];
     } // End for i
     return array;
  } // End function shiftArrItem
} // End contract forLoopArr

Ether payout should not be done in a loop. Due to the block gas limit, transactions can only consume a certain amount of gas. The number of iterations in a loop can grow beyond the block gas limit, which can cause the complete contract to be stalled at a certain point. If required, make sure that the number of iterations are low, and you trust each address involved.

Example:

contract etherTransferInLoop 
{ address payable owner;

  function transferInForLoop
    ( uint index ) 
    public  
  { for ( uint i = index; 
               i < 100; 
               i++
         ) 
    { owner.transfer ( i );
    } // End for i
  } // End function transferInForLoop

  function transferInWhileLoop
    ( uint index ) 
    public
  { uint i = index;
    while ( i < 100 )
    { owner.transfer(i);
      i++;
    } // End while loop
  } // End function transferInWhileLoop
} // End contract etherTransferInLoop

ERC20 Contracts decimals function should have uint8 as return type.

Example:

contract EIP20 
{ uint public decimals = 12;
} // End contract EIP20

It warns for the methods which potentially should be constant/view/pure but are not.

Example:

function b
  ( address a ) 
  public 
  returns ( bool )
  { return true;
  } // End function b

It warns on the usage of similar variable names.

Example:

// Variables have very similar names voter and voters.
function giveRightToVote
  ( address voter ) 
  public 
{ require ( voters [ voter ].weight == 0 );
  voters [ voter ].weight = 1;
} // End function giveRightToVote

It warns for the methods which define a return type but never explicitly return a value.

Example:

function noreturn
  ( string memory _dna ) 
  public 
  returns (bool) 
{ dna = _dna;
} // End function noreturn

Use assert(x) if you never ever want x to be false, not in any circumstance (apart from a bug in your code). Use require(x) if x can be false, due to e.g. invalid input or a failing external component.

Example:

assert(a.balance == 0);

A binary operation yields a value that is not used in the following code. This is often caused by confusing assignment (=) and comparison (==).

Example:

c == 5;
 // or
a + b;

Bytes and string length are not the same since strings are assumed to be UTF-8 encoded (according to the ABI definition) therefore one character is not necessarily encoded in one byte of data.

Example:

function length
  ( string memory a )
  public 
  pure 
  returns ( uint ) 
{ bytes memory x = bytes ( a );
    return x.length;
} // End function length

Using delete on an array leaves a gap. The length of the array remains the same. If you want to remove the empty position you need to shift items manually and update the length property.

Example:

contract arr 
{ uint[] array = [ 1, 2, 3 ];
  function removeAtIndex() 
    public 
    returns ( uint[] memory ) 
  { delete array[1];
    return array;
  } // End function removeAtIndex
} // End contract arr

Division of integer values yields an integer value again. That means e.g. 10 / 100 = 0 instead of 0.1 since the result is an integer again. This does not hold for division of (only) literal values since those yield rational constants.

Example:

function contribute() 
  payable 
  public 
{ uint fee = msg.value * uint256 ( feePercentage / 100 );
  fee = msg.value * ( p2 / 100 );
} // End function contribute