Fountain 3

0x56325d180ec3878a9028afc7b0edcee7486cc9df Copy

ERC20

This contract is an ERC20 token.

Name Fountain 3

Symbol FTN

Decimals 18

Total Supply 2,208,919,511 FTN

About

Fountain (FTN) is a cryptocurrency and operates on the Ethereum platform. Fountain has a current supply of 2,208,919,510.99 with 88,674,657.890022 in circulation. The last known price of Fountain is 0.00816011 USD and is up 4.36 over the last 24 hours. It is currently trading on 2 active market(s) with $6,912.15 traded over the last 24 hours. More information can be found at https://fountainhub.com.

Stats

Public Functions 48

Event Types 20

Code Size 26,714 bytes

Events (20)

Approval Event

Parameters

owner	address
spender	address
value	uint256

Burn Event

Parameters

user	address
amount	uint256

ContractPause Event

Parameters

ContractPauseSchedule Event

Parameters

from	uint256
to	uint256

ContractResume Event

Parameters

FinishUpgrade Event

Parameters

ForgeStart Event

Parameters

ForgeStop Event

Parameters

FoundationOwnershipTransferred Event

Parameters

oldFoundationOwner	address
newFoundationOwner	address

InvestStart Event

Parameters

InvestStop Event

Parameters

Mint Event

Parameters

user	address
amount	uint256

NewInvest Event

Parameters

release_start	uint256
release_duration	uint256

OwnershipTransferred Event

Parameters

oldone	address
newone	address

Refund Event

Parameters

	address
	uint

SetFoundation Event

Parameters

uint

SetRefund Event

Parameters

	address
	uint

Transfer Event

Parameters

from	address
to	address
value	uint256

UpgradeStart Event

Parameters

UpgradeStop Event

Parameters

Constants (6)

name Constant

string

Fountain 3

symbol Constant

string

FTN

decimals Constant

uint8

TOKEN_CAP Constant

uint256

10000000000 * UNKNOWN VALUE

TOKEN_FOUNDATION_CAP Constant

uint256

300000000 * UNKNOWN VALUE

TOKEN_INITIAL Constant

uint256

0 * UNKNOWN VALUE

State Variables (22)

upgrade_running Variable

bool

upgrade_finish Variable

bool

oldContract Variable

address

releaseStart Variable

uint256

releaseDuration Variable

uint256

forceStopInvest Variable

bool

forge_running Variable

bool

token_cap Variable

uint256

token_created Variable

uint256

token_foundation_cap Variable

uint256

token_foundation_created Variable

uint256

upgraded Variable

mapping(address => bool)

skiplist Variable

mapping(address => bool)

refundlist Variable

mapping(address => uint)

wallets Variable

mapping(address => uint256)

ftn Variable

FountainToken

Internal Variable

lockbins Variable

mapping(address => mapping(uint => LockBin))

Internal Variable

owner Variable

address

Internal Variable

foundationOwner Variable

address

Internal Variable

pauseFrom Variable

uint256

Internal Variable

pauseTo Variable

uint256

Internal Variable

warrants Variable

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

Internal Variable

Functions Expand All Collapse All

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

newOwner must not be equal to owner

newOwner must not be equal to foundationOwner

wallets for owner must be equal to 0

wallets for newOwner must be equal to 0

Source Code

function transferOwnership(address newOwner) public onlyOwner returns (bool) {
  require(newOwner != address(0));
  require(newOwner != owner);
  require(newOwner != foundationOwner);
  require(wallets[owner] == 0);
  require(wallets[newOwner] == 0);

  address oldOwner = owner;
  owner = newOwner;
  emit OwnershipTransferred(oldOwner, newOwner);

  return true;
}

setFountainFoundationOwner

Parameters

Name	Type
newFoundationOwner	address

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

owner must be equal to the sender's address

Requirements

newFoundationOwner must not be equal to UNKNOWN VALUE

newFoundationOwner must not be equal to foundationOwner

newFoundationOwner must not be equal to owner

wallets for newFoundationOwner must be equal to 0

Source Code

function setFountainFoundationOwner(address newFoundationOwner)
  public
  onlyOwner
  returns (bool)
{
  require(newFoundationOwner != address(0));
  require(newFoundationOwner != foundationOwner);
  require(newFoundationOwner != owner);
  require(wallets[newFoundationOwner] == 0);

  address oldFoundation = foundationOwner;
  foundationOwner = newFoundationOwner;

  emit FoundationOwnershipTransferred(oldFoundation, foundationOwner);

  uint256 all = wallets[oldFoundation];
  wallets[oldFoundation] -= all;
  wallets[newFoundationOwner] = all;
  emit Transfer(oldFoundation, newFoundationOwner, all);

  return true;
}

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

Source Code

function pause() public onlyOwner {
  pauseFrom = now - 1;
  pauseTo = now + 30000 days;
  emit ContractPause();
}

pause

Parameters

Name	Type
from	uint256
to	uint256

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

owner must be equal to the sender's address

Requirements

to must be greater than from

Source Code

function pause(uint256 from, uint256 to) public onlyOwner {
  require(to > from);
  pauseFrom = from;
  pauseTo = to;
  emit ContractPauseSchedule(from, to);
}

resume

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 resume() public onlyOwner {
  pauseFrom = now - 2;
  pauseTo = now - 1;
  emit ContractResume();
}

totalSupply

Parameters

This function has no parameters.

Properties

Visibility public

Mutability view

Source Code

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

balanceOf

Parameters

Name	Type
user	address

Properties

Visibility public

Mutability view

Source Code

function balanceOf(address user) public view returns (uint256) {
  return wallets[user];
}

transfer

Parameters

Name	Type
target	address
value	uint256

Properties

Visibility public

Mutability transaction

Modifiers

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

canTransfer checks for the following:

target must not be equal to the sender's address

value must be greater than 0

Requirements

target must not be equal to owner

null

Source Code

function transfer(address target, uint256 value)
  public
  whenRunning
  canTransfer(msg.sender, target, value)
  returns (bool)
{
  require(target != owner);
  require(canPay(msg.sender, value));

  wallets[msg.sender] = wallets[msg.sender].sub(value);
  wallets[target] = wallets[target].add(value);
  emit Transfer(msg.sender, target, value);
  return true;
}

transferFrom

Parameters

Name	Type
from	address
to	address
value	uint256

Properties

Visibility public

Mutability transaction

Modifiers

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

canTransfer checks for the following:

target must not be equal to the sender's address

value must be greater than 0

Requirements

from must not be equal to owner

to must not be equal to owner

null

Source Code

function transferFrom(
  address from,
  address to,
  uint256 value
) public whenRunning canTransfer(from, to, value) returns (bool) {
  require(from != owner);
  require(to != owner);
  require(canPay(from, value));

  uint256 warrant;
  if (msg.sender != from) {
    warrant = warrants[from][msg.sender];
    require(value <= warrant);
    warrants[from][msg.sender] = warrant.sub(value);
  }

  wallets[from] = wallets[from].sub(value);
  wallets[to] = wallets[to].add(value);
  emit Transfer(from, to, value);
  return true;
}

allowance

Parameters

Name	Type
owner	address
delegator	address

Properties

Visibility public

Mutability view

Source Code

function allowance(address owner, address delegator)
  public
  view
  returns (uint256)
{
  return warrants[owner][delegator];
}

approve

Parameters

Name	Type
delegator	address
value	uint256

Properties

Visibility public

Mutability transaction

Modifiers

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

Source Code

function approve(address delegator, uint256 value)
  public
  whenRunning
  returns (bool)
{
  if (delegator == msg.sender) return true;
  warrants[msg.sender][delegator] = value;
  emit Approval(msg.sender, delegator, value);
  return true;
}

increaseApproval

Parameters

Name	Type
delegator	address
delta	uint256

Properties

Visibility public

Mutability transaction

Modifiers

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

Source Code

function increaseApproval(address delegator, uint256 delta)
  public
  whenRunning
  returns (bool)
{
  if (delegator == msg.sender) return true;
  uint256 value = warrants[msg.sender][delegator].add(delta);
  warrants[msg.sender][delegator] = value;
  emit Approval(msg.sender, delegator, value);
  return true;
}

decreaseApproval

Parameters

Name	Type
delegator	address
delta	uint256

Properties

Visibility public

Mutability transaction

Modifiers

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

Source Code

function decreaseApproval(address delegator, uint256 delta)
  public
  whenRunning
  returns (bool)
{
  if (delegator == msg.sender) return true;
  uint256 value = warrants[msg.sender][delegator];
  if (value < delta) {
    value = 0;
  } else {
    value = value.sub(delta);
  }
  warrants[msg.sender][delegator] = value;
  emit Approval(msg.sender, delegator, value);
  return true;
}

invest

Parameters

Name	Type
investor	address
amount	uint256

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

owner must be equal to the sender's address

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

canInvest checks for the following:

forceStopInvest must not be true

Requirements

investor must not be equal to UNKNOWN VALUE

investor must not be equal to owner

investor must not be equal to foundationOwner

amount must be greater than 0

null

Source Code

function invest(address investor, uint256 amount)
  public
  onlyOwner
  whenRunning
  canInvest
  returns (bool)
{
  require(investor != address(0));
  require(investor != owner);
  require(investor != foundationOwner);
  require(amount > 0);
  require(canMint(amount));

  mapping(uint256 => LockBin) locks = lockbins[investor];
  LockBin storage info = locks[0];
  uint256 index = info.amount + 1;
  locks[index] = LockBin({
    start: releaseStart,
    finish: releaseStart + releaseDuration,
    duration: releaseDuration / (1 days),
    amount: amount
  });
  info.amount = index;

  token_created = token_created.add(amount);
  wallets[investor] = wallets[investor].add(amount);
  emit Mint(investor, amount);
  emit Transfer(address(0), investor, amount);

  return true;
}

getInvestedToken

Parameters

Name	Type
investor	address

Properties

Visibility public

Mutability view

Requirements

investor must not be equal to foundationOwner

investor must not be equal to owner

investor must not be equal to UNKNOWN VALUE

Source Code

function getInvestedToken(address investor) public view returns (uint256) {
  require(
    investor != address(0) && investor != owner && investor != foundationOwner
  );

  mapping(uint256 => LockBin) locks = lockbins[investor];
  uint256 balance = 0;
  uint256 l = locks[0].amount;
  for (uint256 i = 1; i <= l; i++) {
    LockBin memory bin = locks[i];
    balance = balance.add(bin.amount);
  }
  return balance;
}

getLockedToken

Parameters

Name	Type
investor	address

Properties

Visibility public

Mutability view

Requirements

investor must not be equal to foundationOwner

investor must not be equal to owner

investor must not be equal to UNKNOWN VALUE

Source Code

function getLockedToken(address investor) public view returns (uint256) {
  require(
    investor != address(0) && investor != owner && investor != foundationOwner
  );

  mapping(uint256 => LockBin) locks = lockbins[investor];
  uint256 balance = 0;
  uint256 d = 1;
  uint256 l = locks[0].amount;
  for (uint256 i = 1; i <= l; i++) {
    LockBin memory bin = locks[i];
    if (now <= bin.start) {
      balance = balance.add(bin.amount);
    } else if (now < bin.finish) {
      d = (now - bin.start) / (1 days);
      balance = balance.add(bin.amount - (bin.amount * d) / bin.duration);
    }
  }
  return balance;
}

availableWallet

Parameters

Name	Type
user	address

Properties

Visibility public

Mutability view

Source Code

function availableWallet(address user) public view returns (uint256) {
  return wallets[user].sub(getLockedToken(user));
}

changeCap

Parameters

Name	Type
_cap	uint256

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

owner must be equal to the sender's address

Source Code

function changeCap(uint256 _cap) public onlyOwner returns (bool) {
  if (_cap < token_created && _cap > 0) return false;
  token_cap = _cap;
  return true;
}

canMint

Parameters

Name	Type
amount	uint256

Properties

Visibility public

Mutability view

Source Code

function canMint(uint256 amount) public view returns (bool) {
  return (token_cap == 0) || (token_created.add(amount) <= token_cap);
}

startForge

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

cannotForge checks for the following:

forge_running must not be true

Source Code

function startForge() public onlyOwner cannotForge returns (bool) {
  forge_running = true;
  emit ForgeStart();
  return true;
}

stopForge

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

canForge checks for the following:

forge_running must be true

Source Code

function stopForge() public onlyOwner canForge returns (bool) {
  forge_running = false;
  emit ForgeStop();
  return true;
}

totalFountainSupply

Parameters

This function has no parameters.

Properties

Visibility public

Mutability view

Source Code

function totalFountainSupply() public view returns (uint256) {
  return token_foundation_created;
}

mint

Parameters

Name	Type
target	address
amount	uint256

Properties

Visibility public

Mutability transaction

Modifiers

hasMintability checks for the following:

One or more of the following: - foundationOwner must be equal to the sender's address - OR owner must be equal to the sender's address

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

canForge checks for the following:

forge_running must be true

Requirements

target must not be equal to foundationOwner

target must not be equal to owner

null

Source Code

function mint(address target, uint256 amount)
  public
  hasMintability
  whenRunning
  canForge
  returns (bool)
{
  require(target != owner && target != foundationOwner);
  require(canMint(amount));

  if (msg.sender == foundationOwner) {
    require(canMintFoundation(amount));
    token_foundation_created = token_foundation_created.add(amount);
  }

  token_created = token_created.add(amount);
  wallets[target] = wallets[target].add(amount);

  emit Mint(target, amount);
  emit Transfer(address(0), target, amount);
  return true;
}

burn

Parameters

Name	Type
amount	uint256

Properties

Visibility public

Mutability transaction

Modifiers

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

canForge checks for the following:

forge_running must be true

Requirements

amount must be less than or equal to balance

Source Code

function burn(uint256 amount) public whenRunning canForge returns (bool) {
  uint256 balance = availableWallet(msg.sender);
  require(amount <= balance);

  token_created = token_created.sub(amount);
  wallets[msg.sender] = wallets[msg.sender].sub(amount);

  emit Burn(msg.sender, amount);
  emit Transfer(msg.sender, address(0), amount);

  return true;
}

pauseInvest

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

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

Requirements

forceStopInvest must not be true

Source Code

function pauseInvest() public onlyOwner whenRunning returns (bool) {
  require(!forceStopInvest);
  forceStopInvest = true;
  emit InvestStop();
  return true;
}

resumeInvest

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

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

Requirements

forceStopInvest must be true

Source Code

function resumeInvest() public onlyOwner whenRunning returns (bool) {
  require(forceStopInvest);
  forceStopInvest = false;
  emit InvestStart();
  return true;
}

setInvest

Parameters

Name	Type
release_start	uint256
release_duration	uint256

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

owner must be equal to the sender's address

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

Requirements

releaseStart must be less than releaseStart + releaseDuration

Source Code

function setInvest(uint256 release_start, uint256 release_duration)
  public
  onlyOwner
  whenRunning
  returns (bool)
{
  releaseStart = release_start;
  releaseDuration = release_duration;
  require(releaseStart + releaseDuration > releaseStart);
  forceStopInvest = false;

  emit NewInvest(release_start, release_duration);
  return true;
}

batchInvest

Parameters

Name	Type
investors	address[]
amount	uint256

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

owner must be equal to the sender's address

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

canInvest checks for the following:

forceStopInvest must not be true

Requirements

amount must be greater than 0

investorsCount must be greater than 0

null

Source Code

function batchInvest(address[] investors, uint256 amount)
  public
  onlyOwner
  whenRunning
  canInvest
  returns (bool)
{
  require(amount > 0);

  uint256 investorsLength = investors.length;
  uint256 investorsCount = 0;
  uint256 i;
  address r;
  for (i = 0; i < investorsLength; i++) {
    r = investors[i];
    if (r == address(0) || r == owner || r == foundationOwner) continue;
    investorsCount++;
  }
  require(investorsCount > 0);

  uint256 totalAmount = amount.mul(uint256(investorsCount));
  require(canMint(totalAmount));

  token_created = token_created.add(totalAmount);

  for (i = 0; i < investorsLength; i++) {
    r = investors[i];
    if (r == address(0) || r == owner || r == foundationOwner) continue;

    mapping(uint256 => LockBin) locks = lockbins[r];
    LockBin storage info = locks[0];
    uint256 index = info.amount + 1;
    locks[index] = LockBin({
      start: releaseStart,
      finish: releaseStart + releaseDuration,
      duration: releaseDuration / (1 days),
      amount: amount
    });
    info.amount = index;

    wallets[r] = wallets[r].add(amount);
    emit Mint(r, amount);
    emit Transfer(address(0), r, amount);
  }

  return true;
}

batchInvests

Parameters

Name	Type
investors	address[]
amounts	uint256[]

Properties

Visibility public

Mutability transaction

Modifiers

onlyOwner checks for the following:

owner must be equal to the sender's address

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

canInvest checks for the following:

forceStopInvest must not be true

Requirements

investorsLength must be equal to the number of values in amounts

totalAmount must be greater than 0

null

Source Code

function batchInvests(address[] investors, uint256[] amounts)
  public
  onlyOwner
  whenRunning
  canInvest
  returns (bool)
{
  uint256 investorsLength = investors.length;
  require(investorsLength == amounts.length);

  uint256 investorsCount = 0;
  uint256 totalAmount = 0;
  uint256 i;
  address r;
  for (i = 0; i < investorsLength; i++) {
    r = investors[i];
    if (r == address(0) || r == owner || r == foundationOwner) continue;
    investorsCount++;
    totalAmount = totalAmount.add(amounts[i]);
  }
  require(totalAmount > 0);
  require(canMint(totalAmount));

  uint256 amount;
  token_created = token_created.add(totalAmount);
  for (i = 0; i < investorsLength; i++) {
    r = investors[i];
    if (r == address(0) || r == owner || r == foundationOwner) continue;
    amount = amounts[i];
    if (amount == 0) continue;
    wallets[r] = wallets[r].add(amount);
    emit Mint(r, amount);
    emit Transfer(address(0), r, amount);

    mapping(uint256 => LockBin) locks = lockbins[r];
    LockBin storage info = locks[0];
    uint256 index = info.amount + 1;
    locks[index] = LockBin({
      start: releaseStart,
      finish: releaseStart + releaseDuration,
      duration: releaseDuration / (1 days),
      amount: amount
    });
    info.amount = index;
  }

  return true;
}

batchTransfer

Parameters

Name	Type
receivers	address[]
amount	uint256

Properties

Visibility public

Mutability transaction

Modifiers

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

Requirements

amount must be greater than 0

receiverCount must be greater than 0

null

Source Code

function batchTransfer(address[] receivers, uint256 amount)
  public
  whenRunning
  returns (bool)
{
  require(amount > 0);

  uint256 receiveLength = receivers.length;
  uint256 receiverCount = 0;
  uint256 i;
  address r;
  for (i = 0; i < receiveLength; i++) {
    r = receivers[i];
    if (r == address(0) || r == owner) continue;
    receiverCount++;
  }
  require(receiverCount > 0);

  uint256 totalAmount = amount.mul(uint256(receiverCount));
  require(canPay(msg.sender, totalAmount));

  wallets[msg.sender] = wallets[msg.sender].sub(totalAmount);
  for (i = 0; i < receiveLength; i++) {
    r = receivers[i];
    if (r == address(0) || r == owner) continue;
    wallets[r] = wallets[r].add(amount);
    emit Transfer(msg.sender, r, amount);
  }
  return true;
}

batchTransfers

Parameters

Name	Type
receivers	address[]
amounts	uint256[]

Properties

Visibility public

Mutability transaction

Modifiers

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

Requirements

receiveLength must be equal to the number of values in amounts

totalAmount must be greater than 0

null

Source Code

function batchTransfers(address[] receivers, uint256[] amounts)
  public
  whenRunning
  returns (bool)
{
  uint256 receiveLength = receivers.length;
  require(receiveLength == amounts.length);

  uint256 receiverCount = 0;
  uint256 totalAmount = 0;
  uint256 i;
  address r;
  for (i = 0; i < receiveLength; i++) {
    r = receivers[i];
    if (r == address(0) || r == owner) continue;
    receiverCount++;
    totalAmount = totalAmount.add(amounts[i]);
  }
  require(totalAmount > 0);
  require(canPay(msg.sender, totalAmount));

  wallets[msg.sender] = wallets[msg.sender].sub(totalAmount);
  uint256 amount;
  for (i = 0; i < receiveLength; i++) {
    r = receivers[i];
    if (r == address(0) || r == owner) continue;
    amount = amounts[i];
    if (amount == 0) continue;
    wallets[r] = wallets[r].add(amount);
    emit Transfer(msg.sender, r, amount);
  }
  return true;
}

batchTransferFrom

Parameters

Name	Type
from	address
receivers	address[]
amount	uint256

Properties

Visibility public

Mutability transaction

Modifiers

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

Requirements

from must not be equal to owner

from must not be equal to UNKNOWN VALUE

amount must be greater than 0

receiverCount must be greater than 0

null

Source Code

function batchTransferFrom(
  address from,
  address[] receivers,
  uint256 amount
) public whenRunning returns (bool) {
  require(from != address(0) && from != owner);
  require(amount > 0);

  uint256 receiveLength = receivers.length;
  uint256 receiverCount = 0;
  uint256 i;
  address r;
  for (i = 0; i < receiveLength; i++) {
    r = receivers[i];
    if (r == address(0) || r == owner) continue;
    receiverCount++;
  }
  require(receiverCount > 0);

  uint256 totalAmount = amount.mul(uint256(receiverCount));
  require(canPay(from, totalAmount));

  uint256 warrant;
  if (msg.sender != from) {
    warrant = warrants[from][msg.sender];
    require(totalAmount <= warrant);
    warrants[from][msg.sender] = warrant.sub(totalAmount);
  }

  wallets[from] = wallets[from].sub(totalAmount);
  for (i = 0; i < receiveLength; i++) {
    r = receivers[i];
    if (r == address(0) || r == owner) continue;
    wallets[r] = wallets[r].add(amount);
    emit Transfer(from, r, amount);
  }
  return true;
}

batchTransferFroms

Parameters

Name	Type
from	address
receivers	address[]
amounts	uint256[]

Properties

Visibility public

Mutability transaction

Modifiers

whenRunning checks for the following:

One or more of the following: - now must be greater than pauseTo - OR now must be less than pauseFrom

Requirements

from must not be equal to owner

from must not be equal to UNKNOWN VALUE

receiveLength must be equal to the number of values in amounts

totalAmount must be greater than 0

null

Source Code

function batchTransferFroms(
  address from,
  address[] receivers,
  uint256[] amounts
) public whenRunning returns (bool) {
  require(from != address(0) && from != owner);

  uint256 receiveLength = receivers.length;
  require(receiveLength == amounts.length);

  uint256 receiverCount = 0;
  uint256 totalAmount = 0;
  uint256 i;
  address r;
  for (i = 0; i < receiveLength; i++) {
    r = receivers[i];
    if (r == address(0) || r == owner) continue;
    receiverCount++;
    totalAmount = totalAmount.add(amounts[i]);
  }
  require(totalAmount > 0);
  require(canPay(from, totalAmount));

  uint256 warrant;
  if (msg.sender != from) {
    warrant = warrants[from][msg.sender];
    require(totalAmount <= warrant);
    warrants[from][msg.sender] = warrant.sub(totalAmount);
  }

  wallets[from] = wallets[from].sub(totalAmount);
  uint256 amount;
  for (i = 0; i < receiveLength; i++) {
    r = receivers[i];
    if (r == address(0) || r == owner) continue;
    amount = amounts[i];
    if (amount == 0) continue;
    wallets[r] = wallets[r].add(amount);
    emit Transfer(from, r, amount);
  }
  return true;
}

punch

Parameters

Name	Type
addr	address
amount	uint256

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:

now must be less than or equal to pauseTo

now must be greater than or equal to pauseFrom

Requirements

addr must not be equal to owner

addr must not be equal to UNKNOWN VALUE

amount must be greater than 0

Source Code

function punch(address addr, uint256 amount)
  public
  onlyOwner
  whenPaused
  returns (bool)
{
  require(addr != address(0) && addr != owner);
  require(amount > 0);
  uint256 accountAmount = availableWallet(addr);
  uint256 burnAmount = amount;
  if (amount > accountAmount) {
    burnAmount = accountAmount;
  }
  token_created = token_created.sub(burnAmount);
  wallets[addr] = wallets[addr].sub(burnAmount);
  emit Burn(addr, burnAmount);
  emit Transfer(addr, address(0), burnAmount);

  return true;
}

batchPunchKO

Parameters

Name	Type
addrs	address[]

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:

now must be less than or equal to pauseTo

now must be greater than or equal to pauseFrom

Requirements

len must be greater than 0

Source Code

function batchPunchKO(address[] addrs)
  public
  onlyOwner
  whenPaused
  returns (bool)
{
  uint256 len = addrs.length;
  require(len > 0);
  address addr;

  for (uint256 i = 0; i < len; i++) {
    addr = addrs[i];
    if (addr == address(0) || addr == owner) continue;
    uint256 amount = availableWallet(addr);
    token_created = token_created.sub(amount);
    wallets[addr] = wallets[addr].sub(amount);
    emit Burn(addr, amount);
    emit Transfer(addr, address(0), amount);
  }
  return true;
}

batchPunchs

Parameters

Name	Type
addrs	address[]
amounts	uint256[]

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:

now must be less than or equal to pauseTo

now must be greater than or equal to pauseFrom

Requirements

len must be greater than 0

the number of values in addrs must be equal to the number of values in amounts

Source Code

function batchPunchs(address[] addrs, uint256[] amounts)
  public
  onlyOwner
  whenPaused
  returns (bool)
{
  uint256 len = addrs.length;
  require(len > 0);
  require(addrs.length == amounts.length);

  address addr;
  uint256 amount;
  uint256 availableAmount;

  for (uint256 i = 0; i < len; i++) {
    addr = addrs[i];
    if (addr == address(0) || addr == owner) continue;
    amount = amounts[i];
    availableAmount = availableWallet(addr);
    if (amount > availableAmount) {
      amount = availableAmount;
    }
    token_created = token_created.sub(amount);
    wallets[addr] = wallets[addr].sub(amount);
    emit Burn(addr, amount);
    emit Transfer(addr, address(0), amount);
  }
  return true;
}

suicide

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 suicide() public onlyOwner {
  selfdestruct(owner);
}

finishUpgrade

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Modifiers

whenNotUpgrading checks for the following:

upgrade_running must not be true

canUpgrade checks for the following:

upgrade_finish must not be true

onlyOwner checks for the following:

owner must be equal to the sender's address

Source Code

function finishUpgrade() public whenNotUpgrading canUpgrade onlyOwner {
  upgrade_finish = true;
  emit FinishUpgrade();
}

setFoundation

Parameters

Name	Type
amount	uint

Properties

Visibility public

Mutability transaction

Modifiers

whenUpgrading checks for the following:

upgrade_running must be true

whenPaused checks for the following:

now must be less than or equal to pauseTo

now must be greater than or equal to pauseFrom

canUpgrade checks for the following:

upgrade_finish must not be true

onlyOwner checks for the following:

owner must be equal to the sender's address

Source Code

function setFoundation(uint256 amount)
  public
  whenUpgrading
  whenPaused
  canUpgrade
  onlyOwner
{
  token_foundation_created = amount;
  emit SetFoundation(amount);
}

setRefund

Parameters

Name	Type
addr	address
amount	uint

Properties

Visibility public

Mutability transaction

Modifiers

whenUpgrading checks for the following:

upgrade_running must be true

canUpgrade checks for the following:

upgrade_finish must not be true

onlyOwner checks for the following:

owner must be equal to the sender's address

Requirements

addr must not be equal to UNKNOWN VALUE

addr must not be equal to foundationOwner

addr must not be equal to owner

Source Code

function setRefund(address addr, uint256 amount)
  public
  whenUpgrading
  canUpgrade
  onlyOwner
{
  require(addr != address(0));
  require(addr != foundationOwner);
  require(addr != owner);
  refundlist[addr] = amount;
  emit SetRefund(addr, amount);
}

batchSetRefund

Parameters

Name	Type
addrs	address[]
amounts	uint[]

Properties

Visibility public

Mutability transaction

Modifiers

whenUpgrading checks for the following:

upgrade_running must be true

canUpgrade checks for the following:

upgrade_finish must not be true

onlyOwner checks for the following:

owner must be equal to the sender's address

Requirements

l1 must be equal to l2

l1 must be greater than 0

Source Code

function batchSetRefund(address[] addrs, uint256[] amounts)
  public
  whenUpgrading
  canUpgrade
  onlyOwner
{
  uint256 l1 = addrs.length;
  uint256 l2 = amounts.length;
  address addr;
  uint256 amount;
  require(l1 > 0 && l1 == l2);
  for (uint256 i = 0; i < l1; i++) {
    addr = addrs[i];
    amount = amounts[i];
    if (addr == address(0) || addr == foundationOwner || addr == owner)
      continue;
    refundlist[addr] = amount;
    emit SetRefund(addr, amount);
  }
}

runRefund

Parameters

Name	Type
addr	address

Properties

Visibility public

Mutability transaction

Modifiers

whenUpgrading checks for the following:

upgrade_running must be true

canUpgrade checks for the following:

upgrade_finish must not be true

onlyOwner checks for the following:

owner must be equal to the sender's address

Source Code

function runRefund(address addr) public whenUpgrading canUpgrade onlyOwner {
  uint256 amount = refundlist[addr];
  wallets[addr] = wallets[addr].add(amount);
  token_created = token_created.add(amount);
  refundlist[addr] = 0;
  emit Refund(addr, amount);
  emit Mint(addr, amount);
  emit Transfer(address(0), addr, amount);
}

batchRunRefund

Parameters

Name	Type
addrs	address[]

Properties

Visibility public

Mutability transaction

Modifiers

whenUpgrading checks for the following:

upgrade_running must be true

canUpgrade checks for the following:

upgrade_finish must not be true

onlyOwner checks for the following:

owner must be equal to the sender's address

Requirements

l must be greater than 0

Source Code

function batchRunRefund(address[] addrs)
  public
  whenUpgrading
  canUpgrade
  onlyOwner
{
  uint256 l = addrs.length;
  address addr;
  uint256 amount;
  require(l > 0);
  for (uint256 i = 0; i < l; i++) {
    addr = addrs[i];
    amount = refundlist[addr];
    wallets[addr] = wallets[addr].add(amount);
    token_created = token_created.add(amount);
    refundlist[addr] = 0;
    emit Refund(addr, amount);
    emit Mint(addr, amount);
    emit Transfer(address(0), addr, amount);
  }
}

startUpgrade

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Modifiers

whenNotUpgrading checks for the following:

upgrade_running must not be true

canUpgrade checks for the following:

upgrade_finish must not be true

onlyOwner checks for the following:

owner must be equal to the sender's address

Source Code

function startUpgrade() public whenNotUpgrading canUpgrade onlyOwner {
  upgrade_running = true;
  emit UpgradeStart();
}

stopUpgrade

Parameters

This function has no parameters.

Properties

Visibility public

Mutability transaction

Modifiers

whenUpgrading checks for the following:

upgrade_running must be true

canUpgrade checks for the following:

upgrade_finish must not be true

onlyOwner checks for the following:

owner must be equal to the sender's address

Source Code

function stopUpgrade() public whenUpgrading canUpgrade onlyOwner {
  upgrade_running = false;
  emit UpgradeStop();
}

setSkiplist

Parameters

Name	Type
addrs	address[]

Properties

Visibility public

Mutability transaction

Modifiers

whenUpgrading checks for the following:

upgrade_running must be true

whenPaused checks for the following:

now must be less than or equal to pauseTo

now must be greater than or equal to pauseFrom

canUpgrade checks for the following:

upgrade_finish must not be true

onlyOwner checks for the following:

owner must be equal to the sender's address

Source Code

function setSkiplist(address[] addrs)
  public
  whenUpgrading
  whenPaused
  canUpgrade
  onlyOwner
{
  uint256 len = addrs.length;
  if (len > 0) {
    for (uint256 i = 0; i < len; i++) {
      skiplist[addrs[i]] = true;
    }
  }
}

upgrade

Parameters

Name	Type
addr	address

Properties

Visibility public

Mutability transaction

Modifiers

whenUpgrading checks for the following:

upgrade_running must be true

whenPaused checks for the following:

now must be less than or equal to pauseTo

now must be greater than or equal to pauseFrom

canUpgrade checks for the following:

upgrade_finish must not be true

onlyOwner checks for the following:

owner must be equal to the sender's address

Requirements

skiplist for addr must not be true

amount must be greater than 0

upgraded for addr must not be true

Source Code

function upgrade(address addr) whenUpgrading whenPaused canUpgrade onlyOwner {
  uint256 amount = ftn.balanceOf(addr);
  require(!upgraded[addr] && amount > 0 && !skiplist[addr]);

  upgraded[addr] = true;
  wallets[addr] = amount;

  (uint256 a, uint256 b, uint256 c, uint256 d) = ftn.lockbins(addr, 0);
  uint256 len = d;
  if (len > 0) {
    lockbins[addr][0].amount = len;
    for (uint256 i = 1; i <= len; i++) {
      (a, b, c, d) = ftn.lockbins(addr, i);
      lockbins[addr][i] = LockBin({
        start: a,
        finish: b,
        duration: c,
        amount: d
      });
    }
  }

  token_created = token_created.add(amount);
  emit Mint(addr, amount);
  emit Transfer(address(0), addr, amount);
}

batchUpgrade

Parameters

Name	Type
addrs	address[]

Properties

Visibility public

Mutability transaction

Modifiers

whenUpgrading checks for the following:

upgrade_running must be true

whenPaused checks for the following:

now must be less than or equal to pauseTo

now must be greater than or equal to pauseFrom

canUpgrade checks for the following:

upgrade_finish must not be true

onlyOwner checks for the following:

owner must be equal to the sender's address

Requirements

l must be greater than 0

Source Code

function batchUpgrade(address[] addrs)
  whenUpgrading
  whenPaused
  canUpgrade
  onlyOwner
{
  uint256 l = addrs.length;
  require(l > 0);
  uint256 a;
  uint256 b;
  uint256 c;
  uint256 d;
  for (uint256 i = 0; i < l; i++) {
    address addr = addrs[i];
    uint256 amount = ftn.balanceOf(addr);
    if (upgraded[addr] || amount == 0 || skiplist[addr]) {
      continue;
    }

    upgraded[addr] = true;
    wallets[addr] = amount;

    (a, b, c, d) = ftn.lockbins(addr, 0);
    uint256 len = d;
    if (len > 0) {
      lockbins[addr][0].amount = len;
      for (uint256 j = 1; j <= len; j++) {
        (a, b, c, d) = ftn.lockbins(addr, j);
        lockbins[addr][j] = LockBin({
          start: a,
          finish: b,
          duration: c,
          amount: d
        });
      }
    }

    token_created = token_created.add(amount);
    emit Mint(addr, amount);
    emit Transfer(address(0), addr, amount);
  }
}

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 LockableToken.canPay

Parameters

Name	Type
user	address
amount	uint256

Properties

Visibility internal

Mutability view

Source Code

function canPay(address user, uint256 amount) internal view returns (bool) {
  uint256 balance = availableWallet(user);
  return amount <= balance;
}

internal CappedToken.canMintFoundation

Parameters

Name	Type
amount	uint256

Properties

Visibility internal

Mutability view

Source Code

function canMintFoundation(uint256 amount) internal view returns (bool) {
  return (token_foundation_created.add(amount) <= token_foundation_cap);
}

Fountain 3

ERC20

About link description

Stats

Events (20) 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.

ContractPause Event

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

ContractPauseSchedule Event

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

ContractResume Event

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

FinishUpgrade Event

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

ForgeStart Event

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

ForgeStop Event

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

FoundationOwnershipTransferred Event

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

InvestStart Event

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

InvestStop 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.

NewInvest 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.

Refund Event

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

SetFoundation Event

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

SetRefund 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.

UpgradeStart Event

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

UpgradeStop Event

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

Constants (6) keyboard_arrow_up

name Constant

symbol Constant

decimals Constant

TOKEN_CAP Constant

TOKEN_FOUNDATION_CAP Constant

TOKEN_INITIAL Constant

State Variables (22) keyboard_arrow_up

upgrade_running Variable

upgrade_finish Variable

oldContract Variable

releaseStart Variable

releaseDuration Variable

forceStopInvest Variable

forge_running Variable

token_cap Variable

token_created Variable

token_foundation_cap Variable

token_foundation_created Variable

upgraded Variable

skiplist Variable

refundlist Variable

wallets Variable

ftn Variable

lockbins Variable

owner Variable

foundationOwner Variable

pauseFrom Variable

pauseTo Variable

warrants Variable

Functions Expand All Collapse All

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.

About

Events (20)

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Parameters

Constants (6)

State Variables (22)

transferOwnership

Parameters

Modifiers

Requirements

setFountainFoundationOwner

Parameters

Modifiers

Requirements

pause

Parameters

Modifiers

pause

Parameters

Modifiers

Requirements

resume

Parameters

Modifiers

totalSupply

Parameters

balanceOf

Parameters

transfer

Parameters

Modifiers

Requirements

transferFrom

Parameters

Modifiers

Requirements

allowance

Parameters

approve

Parameters

Modifiers

increaseApproval

Parameters

Modifiers