FUD.finance

0x2688213fedd489762a281a67ae4f2295d8e17ecc Copy

ERC20

This contract is an ERC20 token.

Name FUD.finance

Symbol FUD

Decimals 18

Total Supply 23,621 FUD

About

FUD.finance (FUD) is a cryptocurrency and operates on the Ethereum platform. FUD.finance has a current supply of 23,620.585 with 23,619.71 in circulation. The last known price of FUD.finance is 6.05695336 USD and is up 0.38 over the last 24 hours. It is currently trading on 1 active market(s) with $0.00 traded over the last 24 hours. More information can be found at https://fud.finance/.

Stats

Public Functions 26

Event Types 12

Code Size 22,815 bytes

Events (12)

Approval Event

Parameters

owner	address
spender	address
value	uint256

Burn Event

Parameters

burner	address
value	uint256

Freezed Event

Parameters

to	address
release	uint64
amount	uint

Initialized Event

Parameters

Mint Event

Parameters

to	address
amount	uint256

MintFinished Event

Parameters

OwnershipRenounced Event

Parameters

previousOwner

address

OwnershipTransferred Event

Parameters

previousOwner	address
newOwner	address

Pause Event

Parameters

Released Event

Parameters

owner	address
amount	uint

Transfer Event

Parameters

from	address
to	address
value	uint256

Unpause Event

Parameters

Constants (8)

TOKEN_DECIMALS Constant

uint

TOKEN_DECIMALS_UINT8 Constant

uint8

TOKEN_DECIMAL_MULTIPLIER Constant

uint

UNKNOWN VALUE

TOKEN_NAME Constant

string

FUD.finance

TOKEN_SYMBOL Constant

string

FUD

PAUSED Constant

bool

false

TARGET_USER Constant

address

0xAB537a1554Ed87bBcAa0dc2b54ED69CA9682f469

CONTINUE_MINTING Constant

bool

false

State Variables (10)

initialized Variable

bool

mintingFinished Variable

bool

owner Variable

address

paused Variable

bool

chains Variable

mapping(bytes32 => uint64)

Internal Variable

freezings Variable

mapping(bytes32 => uint)

Internal Variable

freezingBalance Variable

mapping(address => uint)

Internal Variable

allowed Variable

mapping(address => mapping(address => uint256))

Internal Variable

balances Variable

mapping(address => uint256)

Internal Variable

totalSupply_ Variable

uint256

Internal Variable

Functions Expand All Collapse All

renounceOwnership

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

owner must be equal to the sender's address

Source Code

function renounceOwnership() public onlyOwner {
  emit OwnershipRenounced(owner);
  owner = address(0);
}

transferOwnership

Parameters

Name	Type
_newOwner	address

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

owner must be equal to the sender's address

Requirements

_newOwner must not be equal to UNKNOWN VALUE

Source Code

function transferOwnership(address _newOwner) public onlyOwner {
  _transferOwnership(_newOwner);
}

pause

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

owner must be equal to the sender's address

whenNotPaused checks for the following:

paused must not be true

Source Code

function pause() public onlyOwner whenNotPaused {
  paused = true;
  emit Pause();
}

unpause

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

owner must be equal to the sender's address

whenPaused checks for the following:

paused must be true

Source Code

function unpause() public onlyOwner whenPaused {
  paused = false;
  emit Unpause();
}

totalSupply

Parameters

This function has no parameters.

Properties

Visibility public

Mutability view

Source Code

function totalSupply() public view returns (uint256) {
  return totalSupply_;
}

balanceOf

Parameters

Name	Type
_owner	address

Properties

Visibility public

Mutability view

Source Code

function balanceOf(address _owner) public view returns (uint256 balance) {
  return super.balanceOf(_owner) + freezingBalance[_owner];
}

transfer

Parameters

Name	Type
_to	address
_value	uint256

Properties

Visibility public

Mutability transaction

Requirements

paused must not be true

_to must not be equal to UNKNOWN VALUE

_value must be less than or equal to balances for the sender's address

Source Code

function transfer(address _to, uint256 _value) public returns (bool _success) {
  require(!paused);
  return super.transfer(_to, _value);
}

burn

Parameters

Name	Type
_value	uint256

Properties

Visibility public

Mutability transaction

Requirements

_value must be less than or equal to balances for the sender's address

Source Code

function burn(uint256 _value) public {
  _burn(msg.sender, _value);
}

allowance

Parameters

Name	Type
_owner	address
_spender	address

Properties

Visibility public

Mutability view

Source Code

function allowance(address _owner, address _spender)
  public
  view
  returns (uint256)
{
  return allowed[_owner][_spender];
}

transferFrom

Parameters

Name	Type
_from	address
_to	address
_value	uint256

Properties

Visibility public

Mutability transaction

Requirements

paused must not be true

_to must not be equal to UNKNOWN VALUE

_value must be less than or equal to balances for _from

_value must be less than or equal to allowed for _from for the sender's address

Source Code

function transferFrom(
  address _from,
  address _to,
  uint256 _value
) public returns (bool _success) {
  require(!paused);
  return super.transferFrom(_from, _to, _value);
}

approve

Parameters

Name	Type
_spender	address
_value	uint256

Properties

Visibility public

Mutability transaction

Source Code

function approve(address _spender, uint256 _value) public returns (bool) {
  allowed[msg.sender][_spender] = _value;
  emit Approval(msg.sender, _spender, _value);
  return true;
}

increaseApproval

Parameters

Name	Type
_spender	address
_addedValue	uint

Properties

Visibility public

Mutability transaction

Source Code

function increaseApproval(address _spender, uint256 _addedValue)
  public
  returns (bool)
{
  allowed[msg.sender][_spender] = (
    allowed[msg.sender][_spender].add(_addedValue)
  );
  emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
  return true;
}

decreaseApproval

Parameters

Name	Type
_spender	address
_subtractedValue	uint

Properties

Visibility public

Mutability transaction

Source Code

function decreaseApproval(address _spender, uint256 _subtractedValue)
  public
  returns (bool)
{
  uint256 oldValue = allowed[msg.sender][_spender];
  if (_subtractedValue > oldValue) {
    allowed[msg.sender][_spender] = 0;
  } else {
    allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
  }
  emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
  return true;
}

mint

Parameters

Name	Type
_to	address
_amount	uint256

Properties

Visibility public

Mutability transaction

Modifiers

hasMintPermission checks for the following:

owner must be equal to the sender's address

canMint checks for the following:

mintingFinished must not be true

Source Code

function mint(address _to, uint256 _amount)
  public
  hasMintPermission
  canMint
  returns (bool)
{
  totalSupply_ = totalSupply_.add(_amount);
  balances[_to] = balances[_to].add(_amount);
  emit Mint(_to, _amount);
  emit Transfer(address(0), _to, _amount);
  return true;
}

finishMinting

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

owner must be equal to the sender's address

canMint checks for the following:

mintingFinished must not be true

Source Code

function finishMinting() public onlyOwner canMint returns (bool) {
  mintingFinished = true;
  emit MintFinished();
  return true;
}

actualBalanceOf

Parameters

Name	Type
_owner	address

Properties

Visibility public

Mutability view

Source Code

function actualBalanceOf(address _owner) public view returns (uint256 balance) {
  return super.balanceOf(_owner);
}

freezingBalanceOf

Parameters

Name	Type
_owner	address

Properties

Visibility public

Mutability view

Source Code

function freezingBalanceOf(address _owner)
  public
  view
  returns (uint256 balance)
{
  return freezingBalance[_owner];
}

freezingCount

Parameters

Name	Type
_addr	address

Properties

Visibility public

Mutability view

Source Code

function freezingCount(address _addr) public view returns (uint256 count) {
  uint64 release = chains[toKey(_addr, 0)];
  while (release != 0) {
    count++;
    release = chains[toKey(_addr, release)];
  }
}

getFreezing

Parameters

Name	Type
_addr	address
_index	uint

Properties

Visibility public

Mutability view

Source Code

function getFreezing(address _addr, uint256 _index)
  public
  view
  returns (uint64 _release, uint256 _balance)
{
  for (uint256 i = 0; i < _index + 1; i++) {
    _release = chains[toKey(_addr, _release)];
    if (_release == 0) {
      return;
    }
  }
  _balance = freezings[toKey(_addr, _release)];
}

freezeTo

Parameters

Name	Type
_to	address
_amount	uint
_until	uint64

Properties

Visibility public

Mutability transaction

Requirements

_to must not be equal to UNKNOWN VALUE

_amount must be less than or equal to balances for the sender's address

_until must be greater than block.timestamp

Source Code

function freezeTo(
  address _to,
  uint256 _amount,
  uint64 _until
) public {
  require(_to != address(0));
  require(_amount <= balances[msg.sender]);

  balances[msg.sender] = balances[msg.sender].sub(_amount);

  bytes32 currentKey = toKey(_to, _until);
  freezings[currentKey] = freezings[currentKey].add(_amount);
  freezingBalance[_to] = freezingBalance[_to].add(_amount);

  freeze(_to, _until);
  emit Transfer(msg.sender, _to, _amount);
  emit Freezed(_to, _until, _amount);
}

releaseOnce

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Requirements

head must not be equal to 0

head must be less than UNKNOWN VALUE

Source Code

function releaseOnce() public {
  bytes32 headKey = toKey(msg.sender, 0);
  uint64 head = chains[headKey];
  require(head != 0);
  require(uint64(block.timestamp) > head);
  bytes32 currentKey = toKey(msg.sender, head);

  uint64 next = chains[currentKey];

  uint256 amount = freezings[currentKey];
  delete freezings[currentKey];

  balances[msg.sender] = balances[msg.sender].add(amount);
  freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);

  if (next == 0) {
    delete chains[headKey];
  } else {
    chains[headKey] = next;
    delete chains[currentKey];
  }
  emit Released(msg.sender, amount);
}

releaseAll

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Source Code

function releaseAll() public returns (uint256 tokens) {
  uint256 release;
  uint256 balance;
  (release, balance) = getFreezing(msg.sender, 0);
  while (release != 0 && block.timestamp > release) {
    releaseOnce();
    tokens += balance;
    (release, balance) = getFreezing(msg.sender, 0);
  }
}

mintAndFreeze

Parameters

Name	Type
_to	address
_amount	uint
_until	uint64

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

owner must be equal to the sender's address

canMint checks for the following:

mintingFinished must not be true

Requirements

_until must be greater than block.timestamp

Source Code

function mintAndFreeze(
  address _to,
  uint256 _amount,
  uint64 _until
) public onlyOwner canMint returns (bool) {
  totalSupply_ = totalSupply_.add(_amount);

  bytes32 currentKey = toKey(_to, _until);
  freezings[currentKey] = freezings[currentKey].add(_amount);
  freezingBalance[_to] = freezingBalance[_to].add(_amount);

  freeze(_to, _until);
  emit Mint(_to, _amount);
  emit Freezed(_to, _until, _amount);
  emit Transfer(msg.sender, _to, _amount);
  return true;
}

name

Parameters

This function has no parameters.

Properties

Visibility public

Mutability pure

Source Code

function name() public pure returns (string _name) {
  return TOKEN_NAME;
}

symbol

Parameters

This function has no parameters.

Properties

Visibility public

Mutability pure

Source Code

function symbol() public pure returns (string _symbol) {
  return TOKEN_SYMBOL;
}

decimals

Parameters

This function has no parameters.

Properties

Visibility public

Mutability pure

Source Code

function decimals() public pure returns (uint8 _decimals) {
  return TOKEN_DECIMALS_UINT8;
}

Internal Functions Expand All Collapse All

Internal functions are parts of the contract that can't be used directly, but instead are used by the public functions listed above.

internal MainToken.init

Parameters

This function has no parameters.

Properties

Visibility private

Mutability transaction

Requirements

initialized must not be true

Source Code

function init() private {
  require(!initialized);
  initialized = true;

  if (PAUSED) {
    pause();
  }

  address[5] memory addresses = [
    address(0x7b9f1d5ee738a10f4d0543012291ae0b1927cb97),
    address(0xc1b7a270ff97a6b8cefbdbc105e70f64f38a09db),
    address(0x92599d6a0a9154c1a3745a82eb1f91250a4b45c3),
    address(0x171ab540b9cb730626db91f648e2b09eb5363484),
    address(0x630dd921efff3c1dff21e6fe1019d11147ab6e46)
  ];
  uint256[5] memory amounts = [
    uint256(1500000000000000000000),
    uint256(500000000000000000000),
    uint256(500000000000000000000),
    uint256(500000000000000000000),
    uint256(21000000000000000000000)
  ];
  uint64[5] memory freezes = [
    uint64(0),
    uint64(0),
    uint64(0),
    uint64(0),
    uint64(0)
  ];

  for (uint256 i = 0; i < addresses.length; i++) {
    if (freezes[i] == 0) {
      mint(addresses[i], amounts[i]);
    } else {
      mintAndFreeze(addresses[i], amounts[i], freezes[i]);
    }
  }

  if (!CONTINUE_MINTING) {
    finishMinting();
  }

  emit Initialized();
}

internal FreezableToken.toKey

Parameters

Name	Type
_addr	address
_release	uint

Properties

Visibility internal

Mutability pure

Source Code

function toKey(address _addr, uint256 _release)
  internal
  pure
  returns (bytes32 result)
{
  // WISH masc to increase entropy
  result = 0x5749534800000000000000000000000000000000000000000000000000000000;
  assembly {
    result := or(result, mul(_addr, 0x10000000000000000))
    result := or(result, _release)
  }
}

internal FreezableToken.freeze

Parameters

Name	Type
_to	address
_until	uint64

Properties

Visibility internal

Mutability transaction

Requirements

_until must be greater than block.timestamp

Source Code

function freeze(address _to, uint64 _until) internal {
  require(_until > block.timestamp);
  bytes32 key = toKey(_to, _until);
  bytes32 parentKey = toKey(_to, uint64(0));
  uint64 next = chains[parentKey];

  if (next == 0) {
    chains[parentKey] = _until;
    return;
  }

  bytes32 nextKey = toKey(_to, next);
  uint256 parent;

  while (next != 0 && _until > next) {
    parent = next;
    parentKey = nextKey;

    next = chains[nextKey];
    nextKey = toKey(_to, next);
  }

  if (_until == next) {
    return;
  }

  if (next != 0) {
    chains[key] = next;
  }

  chains[parentKey] = _until;
}

internal Ownable._transferOwnership

Parameters

Name	Type
_newOwner	address

Properties

Visibility internal

Mutability transaction

Requirements

_newOwner must not be equal to UNKNOWN VALUE

Source Code

function _transferOwnership(address _newOwner) internal {
  require(_newOwner != address(0));
  emit OwnershipTransferred(owner, _newOwner);
  owner = _newOwner;
}

internal BurnableToken._burn

Parameters

Name	Type
_who	address
_value	uint256

Properties

Visibility internal

Mutability transaction

Requirements

_value must be less than or equal to balances for the sender's address

Source Code

function _burn(address _who, uint256 _value) internal {
  require(_value <= balances[_who]);
  // no need to require value <= totalSupply, since that would imply the
  // sender's balance is greater than the totalSupply, which *should* be an assertion failure

  balances[_who] = balances[_who].sub(_value);
  totalSupply_ = totalSupply_.sub(_value);
  emit Burn(_who, _value);
  emit Transfer(_who, address(0), _value);
}

internal Ownable._transferOwnership

Parameters

Name	Type
_newOwner	address

Properties

Visibility internal

Mutability transaction

Requirements

_newOwner must not be equal to UNKNOWN VALUE

Source Code

function _transferOwnership(address _newOwner) internal {
  require(_newOwner != address(0));
  emit OwnershipTransferred(owner, _newOwner);
  owner = _newOwner;
}

FUD.finance

ERC20

About link

Stats

Events (12) keyboard_arrow_up

Approval Event

Parameters help Event parameters list the data that an event contains.

Burn Event

Parameters help Event parameters list the data that an event contains.

Freezed Event

Parameters help Event parameters list the data that an event contains.

Initialized Event

Parameters help Event parameters list the data that an event contains.

Mint Event

Parameters help Event parameters list the data that an event contains.

MintFinished Event

Parameters help Event parameters list the data that an event contains.

OwnershipRenounced Event

Parameters help Event parameters list the data that an event contains.

OwnershipTransferred Event

Parameters help Event parameters list the data that an event contains.

Pause Event

Parameters help Event parameters list the data that an event contains.

Released Event

Parameters help Event parameters list the data that an event contains.

Transfer Event

Parameters help Event parameters list the data that an event contains.

Unpause Event

Parameters help Event parameters list the data that an event contains.

Constants (8) keyboard_arrow_up

TOKEN_DECIMALS Constant

TOKEN_DECIMALS_UINT8 Constant

TOKEN_DECIMAL_MULTIPLIER Constant

TOKEN_NAME Constant

TOKEN_SYMBOL Constant

PAUSED Constant

TARGET_USER Constant

CONTINUE_MINTING Constant

State Variables (10) keyboard_arrow_up

initialized Variable

mintingFinished Variable

owner Variable

paused Variable

chains Variable

freezings Variable

freezingBalance Variable

allowed Variable

balances Variable

totalSupply_ Variable

Functions Expand All Collapse All

renounceOwnership keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Modifiers help Modifiers are additions to a function that typically make various checks before the function is run.

onlyOwner checks for the following:

Source Code

transferOwnership keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Modifiers help Modifiers are additions to a function that typically make various checks before the function is run.

onlyOwner checks for the following:

Requirements help Requirements are checks that the function makes when it runs, and give you insight on what conditions are required for the function to succeed.

Source Code

pause keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Modifiers help Modifiers are additions to a function that typically make various checks before the function is run.

onlyOwner checks for the following:

whenNotPaused checks for the following:

Source Code

unpause keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Modifiers help Modifiers are additions to a function that typically make various checks before the function is run.

onlyOwner checks for the following:

whenPaused checks for the following:

Source Code

totalSupply keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

About

Events (12)

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Constants (8)

State Variables (10)

renounceOwnership

Parameters

Modifiers

transferOwnership

Parameters

Modifiers

Requirements

pause

Parameters

Modifiers

unpause

Parameters

Modifiers

totalSupply

Parameters

balanceOf

Parameters

transfer

Parameters

Requirements

burn

Parameters

Requirements

allowance

Parameters

transferFrom

Parameters

Requirements

approve

Parameters

increaseApproval

Parameters

decreaseApproval

Parameters

mint

Parameters

Modifiers

finishMinting

Parameters

Modifiers

actualBalanceOf

Parameters

freezingBalanceOf

Parameters

freezingCount

Parameters

getFreezing

Parameters

freezeTo

Parameters