The ICN token for ICONOMI, a Slovenian decentralized crypto fund management platform that raised $10.5M in its 2016 ICO — the third-largest crowdsale in Ethereu
Historical Significance
ICONOMI's ICO was one of the landmark crowdsales of 2016, the third-largest in Ethereum history at the time of its close. It demonstrated that Ethereum-based token sales could attract significant capital for traditional financial services concepts — not just protocol infrastructure. The block-lock mechanism in the ICN token contract became a common pattern in later ICOs for preventing early trading before distribution was finalized.
Context
ICONOMI launched its ICO in the immediate aftermath of The DAO hack and the Ethereum hard fork (July 2016). Despite the community's crisis of confidence following the largest smart contract exploit in history, ICONOMI attracted over $10 million — signaling that investor appetite for Ethereum-based projects had not been permanently damaged. The sale occurred alongside other post-DAO ICOs like FirstBlood (September 2016) and SingularDTV (October 2016), which collectively demonstrated the resilience of the Ethereum ICO model.
Token Information
Key Facts
Description
ICONOMI was a cryptocurrency fund management platform founded by Jani Valjavec and Tim Zagar in Slovenia. The ICN token contract was deployed on October 24, 2016, issuing 100 million ERC-20 compliant tokens representing ownership in the ICONOMI platform.
The ICONOMI ICO ran from August 25 to September 26, 2016, raising over $10.5 million from 3,398 contributors. At the time, it was the third-largest crowdsale in Ethereum history, behind only The DAO and Ethereum's own genesis sale. It was also the largest European fintech crowdfunding project of 2016.
The platform's vision was to become the "Uber of fund management" — enabling anyone to create and manage crypto investment funds. Stage 1 launched two instruments: ICONOMI.INDEX (passive crypto index fund) and ICONOMI.PERFORMANCE (actively managed fund). Stage 2 planned an Open Fund Management (OFM) platform allowing anyone to introduce and manage their own crypto funds.
To ensure fair token distribution, the contract included a block-lock mechanism: tokens were locked until Ethereum block height 2,505,000 (approximately October 25, 2016 at 1 PM UTC), preventing any transfers until after distribution was complete. A test token contract had been deployed earlier at block 2,473,590 for validation purposes.
ICONOMI later pivoted to become a regulated digital asset management platform, continuing operations beyond the ICO era. The ICN token was eventually deprecated in favor of a new token structure as the platform evolved.
Source Verified
Heuristic Analysis
The following characteristics were detected through bytecode analysis and may not be accurate.
Tangerine Whistle Era
Emergency fork to address DoS attacks. Repriced IO-heavy opcodes.
Bytecode Overview
Verified Source Available
Source verified on Etherscan.
Show source code (Solidity)
pragma solidity ^0.4.0;
contract tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData); }
contract IconomiToken {
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event BlockLockSet(uint256 _value);
event NewOwner(address _newOwner);
modifier onlyOwner {
if (msg.sender == owner) {
_;
}
}
modifier blockLock(address _sender) {
if (!isLocked() || _sender == owner) {
_;
}
}
modifier checkIfToContract(address _to) {
if(_to != address(this)) {
_;
}
}
uint256 public totalSupply;
string public name;
uint8 public decimals;
string public symbol;
string public version = '0.0.1';
address public owner;
uint256 public lockedUntilBlock;
function IconomiToken(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
uint256 _lockedUntilBlock
) {
balances[msg.sender] = _initialAmount;
totalSupply = _initialAmount;
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
lockedUntilBlock = _lockedUntilBlock;
owner = msg.sender;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function transfer(address _to, uint256 _value) blockLock(msg.sender) checkIfToContract(_to) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
function transferFrom(address _from, address _to, uint256 _value) blockLock(_from) checkIfToContract(_to) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else {
return false;
}
}
function balanceOf(address _owner) constant returns (uint256 balance) {
return balances[_owner];
}
function approve(address _spender, uint256 _value) returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function setBlockLock(uint256 _lockedUntilBlock) onlyOwner returns (bool success) {
lockedUntilBlock = _lockedUntilBlock;
BlockLockSet(_lockedUntilBlock);
return true;
}
function isLocked() constant returns (bool success) {
return lockedUntilBlock > block.number;
}
function replaceOwner(address _newOwner) onlyOwner returns (bool success) {
owner = _newOwner;
NewOwner(_newOwner);
return true;
}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
}