Feature Tip: Add private address tag to any address under My Name Tag !
Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 1 from a total of 1 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
0x60606040 | 3713374 | 2508 days ago | IN | Create: BonusFinalizeAgent | 0 ETH | 0.00957776 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
This contract contains unverified libraries: SafeMathLib
Contract Name:
BonusFinalizeAgent
Compiler Version
v0.4.8+commit.60cc1668
Optimization Enabled:
Yes with 200 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2017-05-15 */ /** * Safe unsigned safe math. * * https://blog.aragon.one/library-driven-development-in-solidity-2bebcaf88736#.750gwtwli * * Originally from https://raw.githubusercontent.com/AragonOne/zeppelin-solidity/master/contracts/SafeMathLib.sol * * Maintained here until merged to mainline zeppelin-solidity. * */ library SafeMathLib { function times(uint a, uint b) returns (uint) { uint c = a * b; assert(a == 0 || c / a == b); return c; } function minus(uint a, uint b) returns (uint) { assert(b <= a); return a - b; } function plus(uint a, uint b) returns (uint) { uint c = a + b; assert(c>=a && c>=b); return c; } function assert(bool assertion) private { if (!assertion) throw; } } /* * Ownable * * Base contract with an owner. * Provides onlyOwner modifier, which prevents function from running if it is called by anyone other than the owner. */ contract Ownable { address public owner; function Ownable() { owner = msg.sender; } modifier onlyOwner() { if (msg.sender != owner) { throw; } _; } function transferOwnership(address newOwner) onlyOwner { if (newOwner != address(0)) { owner = newOwner; } } } /* * Haltable * * Abstract contract that allows children to implement an * emergency stop mechanism. Differs from Pausable by causing a throw when in halt mode. * * * Originally envisioned in FirstBlood ICO contract. */ contract Haltable is Ownable { bool public halted; modifier stopInEmergency { if (halted) throw; _; } modifier onlyInEmergency { if (!halted) throw; _; } // called by the owner on emergency, triggers stopped state function halt() external onlyOwner { halted = true; } // called by the owner on end of emergency, returns to normal state function unhalt() external onlyOwner onlyInEmergency { halted = false; } } /** * Interface for defining crowdsale pricing. */ contract PricingStrategy { /** Interface declaration. */ function isPricingStrategy() public constant returns (bool) { return true; } /** Self check if all references are correctly set. * * Checks that pricing strategy matches crowdsale parameters. */ function isSane(address crowdsale) public constant returns (bool) { return true; } /** * When somebody tries to buy tokens for X eth, calculate how many tokens they get. * * * @param value - What is the value of the transaction send in as wei * @param tokensSold - how much tokens have been sold this far * @param weiRaised - how much money has been raised this far * @param msgSender - who is the investor of this transaction * @param decimals - how many decimal units the token has * @return Amount of tokens the investor receives */ function calculatePrice(uint value, uint tokensSold, uint weiRaised, address msgSender, uint decimals) public constant returns (uint tokenAmount); } /** * Finalize agent defines what happens at the end of succeseful crowdsale. * * - Allocate tokens for founders, bounties and community * - Make tokens transferable * - etc. */ contract FinalizeAgent { function isFinalizeAgent() public constant returns(bool) { return true; } /** Return true if we can run finalizeCrowdsale() properly. * * This is a safety check function that doesn't allow crowdsale to begin * unless the finalizer has been set up properly. */ function isSane() public constant returns (bool); /** Called once by crowdsale finalize() if the sale was success. */ function finalizeCrowdsale(); } /* * ERC20 interface * see https://github.com/ethereum/EIPs/issues/20 */ contract ERC20 { uint public totalSupply; function balanceOf(address who) constant returns (uint); function allowance(address owner, address spender) constant returns (uint); function transfer(address to, uint value) returns (bool ok); function transferFrom(address from, address to, uint value) returns (bool ok); function approve(address spender, uint value) returns (bool ok); event Transfer(address indexed from, address indexed to, uint value); event Approval(address indexed owner, address indexed spender, uint value); } /** * A token that defines fractional units as decimals. */ contract FractionalERC20 is ERC20 { uint public decimals; } /** * Abstract base contract for token sales. * * Handle * - start and end dates * - accepting investments * - minimum funding goal and refund * - various statistics during the crowdfund * - different pricing strategies * - different investment policies (require server side customer id, allow only whitelisted addresses) * */ contract Crowdsale is Haltable { using SafeMathLib for uint; /* The token we are selling */ FractionalERC20 public token; /* How we are going to price our offering */ PricingStrategy public pricingStrategy; /* Post-success callback */ FinalizeAgent public finalizeAgent; /* tokens will be transfered from this address */ address public multisigWallet; /* if the funding goal is not reached, investors may withdraw their funds */ uint public minimumFundingGoal; /* the UNIX timestamp start date of the crowdsale */ uint public startsAt; /* the UNIX timestamp end date of the crowdsale */ uint public endsAt; /* the number of tokens already sold through this contract*/ uint public tokensSold = 0; /* How many wei of funding we have raised */ uint public weiRaised = 0; /* How many distinct addresses have invested */ uint public investorCount = 0; /* How much wei we have returned back to the contract after a failed crowdfund. */ uint public loadedRefund = 0; /* How much wei we have given back to investors.*/ uint public weiRefunded = 0; /* Has this crowdsale been finalized */ bool public finalized; /* Do we need to have unique contributor id for each customer */ bool public requireCustomerId; /** * Do we verify that contributor has been cleared on the server side (accredited investors only). * This method was first used in FirstBlood crowdsale to ensure all contributors have accepted terms on sale (on the web). */ bool public requiredSignedAddress; /* Server side address that signed allowed contributors (Ethereum addresses) that can participate the crowdsale */ address public signerAddress; /** How much ETH each address has invested to this crowdsale */ mapping (address => uint256) public investedAmountOf; /** How much tokens this crowdsale has credited for each investor address */ mapping (address => uint256) public tokenAmountOf; /** Addresses that are allowed to invest even before ICO offical opens. For testing, for ICO partners, etc. */ mapping (address => bool) public earlyParticipantWhitelist; /** This is for manul testing for the interaction from owner wallet. You can set it to any value and inspect this in blockchain explorer to see that crowdsale interaction works. */ uint public ownerTestValue; /** State machine * * - Preparing: All contract initialization calls and variables have not been set yet * - Prefunding: We have not passed start time yet * - Funding: Active crowdsale * - Success: Minimum funding goal reached * - Failure: Minimum funding goal not reached before ending time * - Finalized: The finalized has been called and succesfully executed * - Refunding: Refunds are loaded on the contract for reclaim. */ enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding} // A new investment was made event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId); // Refund was processed for a contributor event Refund(address investor, uint weiAmount); // The rules were changed what kind of investments we accept event InvestmentPolicyChanged(bool requireCustomerId, bool requiredSignedAddress, address signerAddress); // Address early participation whitelist status changed event Whitelisted(address addr, bool status); // Crowdsale end time has been changed event EndsAtChanged(uint endsAt); function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) { owner = msg.sender; token = FractionalERC20(_token); setPricingStrategy(_pricingStrategy); multisigWallet = _multisigWallet; if(multisigWallet == 0) { throw; } if(_start == 0) { throw; } startsAt = _start; if(_end == 0) { throw; } endsAt = _end; // Don't mess the dates if(startsAt >= endsAt) { throw; } // Minimum funding goal can be zero minimumFundingGoal = _minimumFundingGoal; } /** * Don't expect to just send in money and get tokens. */ function() payable { throw; } /** * Make an investment. * * Crowdsale must be running for one to invest. * We must have not pressed the emergency brake. * * @param receiver The Ethereum address who receives the tokens * @param customerId (optional) UUID v4 to track the successful payments on the server side * */ function investInternal(address receiver, uint128 customerId) stopInEmergency private { // Determine if it's a good time to accept investment from this participant if(getState() == State.PreFunding) { // Are we whitelisted for early deposit if(!earlyParticipantWhitelist[receiver]) { throw; } } else if(getState() == State.Funding) { // Retail participants can only come in when the crowdsale is running // pass } else { // Unwanted state throw; } uint weiAmount = msg.value; uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals()); if(tokenAmount == 0) { // Dust transaction throw; } if(investedAmountOf[receiver] == 0) { // A new investor investorCount++; } // Update investor investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount); tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount); // Update totals weiRaised = weiRaised.plus(weiAmount); tokensSold = tokensSold.plus(tokenAmount); // Check that we did not bust the cap if(isBreakingCap(tokenAmount, weiAmount, weiRaised, tokensSold)) { throw; } assignTokens(receiver, tokenAmount); // Pocket the money if(!multisigWallet.send(weiAmount)) throw; // Tell us invest was success Invested(receiver, weiAmount, tokenAmount, customerId); } /** * Allow anonymous contributions to this crowdsale. */ function investWithSignedAddress(address addr, uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable { bytes32 hash = sha256(addr); if (ecrecover(hash, v, r, s) != signerAddress) throw; if(customerId == 0) throw; // UUIDv4 sanity check investInternal(addr, customerId); } /** * Track who is the customer making the payment so we can send thank you email. */ function investWithCustomerId(address addr, uint128 customerId) public payable { if(requiredSignedAddress) throw; // Crowdsale allows only server-side signed participants if(customerId == 0) throw; // UUIDv4 sanity check investInternal(addr, customerId); } /** * Allow anonymous contributions to this crowdsale. */ function invest(address addr) public payable { if(requireCustomerId) throw; // Crowdsale needs to track partipants for thank you email if(requiredSignedAddress) throw; // Crowdsale allows only server-side signed participants investInternal(addr, 0); } /** * Invest to tokens, recognize the payer and clear his address. * */ function buyWithSignedAddress(uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable { investWithSignedAddress(msg.sender, customerId, v, r, s); } /** * Invest to tokens, recognize the payer. * */ function buyWithCustomerId(uint128 customerId) public payable { investWithCustomerId(msg.sender, customerId); } /** * The basic entry point to participate the crowdsale process. * * Pay for funding, get invested tokens back in the sender address. */ function buy() public payable { invest(msg.sender); } /** * Finalize a succcesful crowdsale. * * The owner can triggre a call the contract that provides post-crowdsale actions, like releasing the tokens. */ function finalize() public inState(State.Success) onlyOwner stopInEmergency { // Already finalized if(finalized) { throw; } // Finalizing is optional. We only call it if we are given a finalizing agent. if(address(finalizeAgent) != 0) { finalizeAgent.finalizeCrowdsale(); } finalized = true; } /** * Allow to (re)set finalize agent. * * Design choice: no state restrictions on setting this, so that we can fix fat finger mistakes. */ function setFinalizeAgent(FinalizeAgent addr) onlyOwner { finalizeAgent = addr; // Don't allow setting bad agent if(!finalizeAgent.isFinalizeAgent()) { throw; } } /** * Set policy do we need to have server-side customer ids for the investments. * */ function setRequireCustomerId(bool value) onlyOwner { requireCustomerId = value; InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress); } /** * Set policy if all investors must be cleared on the server side first. * * This is e.g. for the accredited investor clearing. * */ function setRequireSignedAddress(bool value, address _signerAddress) onlyOwner { requiredSignedAddress = value; signerAddress = _signerAddress; InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress); } /** * Allow addresses to do early participation. * */ function setEarlyParicipantWhitelist(address addr, bool status) onlyOwner { earlyParticipantWhitelist[addr] = status; Whitelisted(addr, status); } /** * Allow crowdsale owner to close early or extend the crowdsale. * * This is useful e.g. for a manual soft cap implementation: * - after X amount is reached determine manual closing * * This may put the crowdsale to an invalid state, * but we trust owners know what they are doing. * */ function setEndsAt(uint time) onlyOwner { if(now > time) { throw; // Don't change past } endsAt = time; EndsAtChanged(endsAt); } /** * Allow to (re)set pricing strategy. * * Design choice: no state restrictions on the set, so that we can fix fat finger mistakes. */ function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner { pricingStrategy = _pricingStrategy; // Don't allow setting bad agent if(!pricingStrategy.isPricingStrategy()) { throw; } } /** * Allow load refunds back on the contract for the refunding. * * The team can transfer the funds back on the smart contract in the case the minimum goal was not reached.. */ function loadRefund() public payable inState(State.Failure) { if(msg.value == 0) throw; loadedRefund = loadedRefund.plus(msg.value); } /** * Investors can claim refund. */ function refund() public inState(State.Refunding) { uint256 weiValue = investedAmountOf[msg.sender]; if (weiValue == 0) throw; investedAmountOf[msg.sender] = 0; weiRefunded = weiRefunded.plus(weiValue); Refund(msg.sender, weiValue); if (!msg.sender.send(weiValue)) throw; } /** * @return true if the crowdsale has raised enough money to be a succes */ function isMinimumGoalReached() public constant returns (bool reached) { return weiRaised >= minimumFundingGoal; } /** * Crowdfund state machine management. * * We make it a function and do not assign the result to a variable, so there is no chance of the variable being stale. */ function getState() public constant returns (State) { if(finalized) return State.Finalized; else if (address(finalizeAgent) == 0) return State.Preparing; else if (!finalizeAgent.isSane()) return State.Preparing; else if (!pricingStrategy.isSane(address(this))) return State.Preparing; else if (block.timestamp < startsAt) return State.PreFunding; else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding; else if (isMinimumGoalReached()) return State.Success; else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding; else return State.Failure; } /** This is for manual testing of multisig wallet interaction */ function setOwnerTestValue(uint val) onlyOwner { ownerTestValue = val; } // // Modifiers // /** Modified allowing execution only if the crowdsale is currently running. */ modifier inState(State state) { if(getState() != state) throw; _; } // // Abstract functions // /** * Check if the current invested breaks our cap rules. * * * The child contract must define their own cap setting rules. * We allow a lot of flexibility through different capping strategies (ETH, token count) * Called from invest(). * * @param weiAmount The amount of wei the investor tries to invest in the current transaction * @param tokenAmount The amount of tokens we try to give to the investor in the current transaction * @param weiRaisedTotal What would be our total raised balance after this transaction * @param tokensSoldTotal What would be our total sold tokens count after this transaction * * @return true if taking this investment would break our cap rules */ function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken); /** * Check if the current crowdsale is full and we can no longer sell any tokens. */ function isCrowdsaleFull() public constant returns (bool); /** * Create new tokens or transfer issued tokens to the investor depending on the cap model. */ function assignTokens(address receiver, uint tokenAmount) private; } /** * Math operations with safety checks */ contract SafeMath { function safeMul(uint a, uint b) internal returns (uint) { uint c = a * b; assert(a == 0 || c / a == b); return c; } function safeDiv(uint a, uint b) internal returns (uint) { assert(b > 0); uint c = a / b; assert(a == b * c + a % b); return c; } function safeSub(uint a, uint b) internal returns (uint) { assert(b <= a); return a - b; } function safeAdd(uint a, uint b) internal returns (uint) { uint c = a + b; assert(c>=a && c>=b); return c; } function max64(uint64 a, uint64 b) internal constant returns (uint64) { return a >= b ? a : b; } function min64(uint64 a, uint64 b) internal constant returns (uint64) { return a < b ? a : b; } function max256(uint256 a, uint256 b) internal constant returns (uint256) { return a >= b ? a : b; } function min256(uint256 a, uint256 b) internal constant returns (uint256) { return a < b ? a : b; } function assert(bool assertion) internal { if (!assertion) { throw; } } } /** * Standard ERC20 token * * https://github.com/ethereum/EIPs/issues/20 * Based on code by FirstBlood: * https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol */ contract StandardToken is ERC20, SafeMath { mapping(address => uint) balances; mapping (address => mapping (address => uint)) allowed; function transfer(address _to, uint _value) returns (bool success) { balances[msg.sender] = safeSub(balances[msg.sender], _value); balances[_to] = safeAdd(balances[_to], _value); Transfer(msg.sender, _to, _value); return true; } function transferFrom(address _from, address _to, uint _value) returns (bool success) { var _allowance = allowed[_from][msg.sender]; // Check is not needed because safeSub(_allowance, _value) will already throw if this condition is not met // if (_value > _allowance) throw; balances[_to] = safeAdd(balances[_to], _value); balances[_from] = safeSub(balances[_from], _value); allowed[_from][msg.sender] = safeSub(_allowance, _value); Transfer(_from, _to, _value); return true; } function balanceOf(address _owner) constant returns (uint balance) { return balances[_owner]; } function approve(address _spender, uint _value) returns (bool success) { allowed[msg.sender][_spender] = _value; Approval(msg.sender, _spender, _value); return true; } function allowance(address _owner, address _spender) constant returns (uint remaining) { return allowed[_owner][_spender]; } } /** * Upgrade agent interface inspired by Lunyr. * * Upgrade agent transfers tokens to a new contract. * Upgrade agent itself can be the token contract, or just a middle man contract doing the heavy lifting. */ contract UpgradeAgent { uint public originalSupply; /** Interface marker */ function isUpgradeAgent() public constant returns (bool) { return true; } function upgradeFrom(address _from, uint256 _value) public; } /** * A token upgrade mechanism where users can opt-in amount of tokens to the next smart contract revision. * * First envisioned by Golem and Lunyr projects. */ contract UpgradeableToken is StandardToken { /** Contract / person who can set the upgrade path. This can be the same as team multisig wallet, as what it is with its default value. */ address public upgradeMaster; /** The next contract where the tokens will be migrated. */ UpgradeAgent public upgradeAgent; /** How many tokens we have upgraded by now. */ uint256 public totalUpgraded; /** * Upgrade states. * * - NotAllowed: The child contract has not reached a condition where the upgrade can bgun * - WaitingForAgent: Token allows upgrade, but we don't have a new agent yet * - ReadyToUpgrade: The agent is set, but not a single token has been upgraded yet * - Upgrading: Upgrade agent is set and the balance holders can upgrade their tokens * */ enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading} /** * Somebody has upgraded some of his tokens. */ event Upgrade(address indexed _from, address indexed _to, uint256 _value); /** * New upgrade agent available. */ event UpgradeAgentSet(address agent); /** * Do not allow construction without upgrade master set. */ function UpgradeableToken(address _upgradeMaster) { upgradeMaster = _upgradeMaster; } /** * Allow the token holder to upgrade some of their tokens to a new contract. */ function upgrade(uint256 value) public { UpgradeState state = getUpgradeState(); if(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)) { // Called in a bad state throw; } // Validate input value. if (value == 0) throw; balances[msg.sender] = safeSub(balances[msg.sender], value); // Take tokens out from circulation totalSupply = safeSub(totalSupply, value); totalUpgraded = safeAdd(totalUpgraded, value); // Upgrade agent reissues the tokens upgradeAgent.upgradeFrom(msg.sender, value); Upgrade(msg.sender, upgradeAgent, value); } /** * Set an upgrade agent that handles */ function setUpgradeAgent(address agent) external { if(!canUpgrade()) { // The token is not yet in a state that we could think upgrading throw; } if (agent == 0x0) throw; // Only a master can designate the next agent if (msg.sender != upgradeMaster) throw; // Upgrade has already begun for an agent if (getUpgradeState() == UpgradeState.Upgrading) throw; upgradeAgent = UpgradeAgent(agent); // Bad interface if(!upgradeAgent.isUpgradeAgent()) throw; // Make sure that token supplies match in source and target if (upgradeAgent.originalSupply() != totalSupply) throw; UpgradeAgentSet(upgradeAgent); } /** * Get the state of the token upgrade. */ function getUpgradeState() public constant returns(UpgradeState) { if(!canUpgrade()) return UpgradeState.NotAllowed; else if(address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent; else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade; else return UpgradeState.Upgrading; } /** * Change the upgrade master. * * This allows us to set a new owner for the upgrade mechanism. */ function setUpgradeMaster(address master) public { if (master == 0x0) throw; if (msg.sender != upgradeMaster) throw; upgradeMaster = master; } /** * Child contract can enable to provide the condition when the upgrade can begun. */ function canUpgrade() public constant returns(bool) { return true; } } /** * Define interface for releasing the token transfer after a successful crowdsale. */ contract ReleasableToken is ERC20, Ownable { /* The finalizer contract that allows unlift the transfer limits on this token */ address public releaseAgent; /** A crowdsale contract can release us to the wild if ICO success. If false we are are in transfer lock up period.*/ bool public released = false; /** Map of agents that are allowed to transfer tokens regardless of the lock down period. These are crowdsale contracts and possible the team multisig itself. */ mapping (address => bool) public transferAgents; /** * Limit token transfer until the crowdsale is over. * */ modifier canTransfer(address _sender) { if(!released) { if(!transferAgents[_sender]) { throw; } } _; } /** * Set the contract that can call release and make the token transferable. * * Design choice. Allow reset the release agent to fix fat finger mistakes. */ function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public { // We don't do interface check here as we might want to a normal wallet address to act as a release agent releaseAgent = addr; } /** * Owner can allow a particular address (a crowdsale contract) to transfer tokens despite the lock up period. */ function setTransferAgent(address addr, bool state) onlyOwner inReleaseState(false) public { transferAgents[addr] = state; } /** * One way function to release the tokens to the wild. * * Can be called only from the release agent that is the final ICO contract. It is only called if the crowdsale has been success (first milestone reached). */ function releaseTokenTransfer() public onlyReleaseAgent { released = true; } /** The function can be called only before or after the tokens have been releasesd */ modifier inReleaseState(bool releaseState) { if(releaseState != released) { throw; } _; } /** The function can be called only by a whitelisted release agent. */ modifier onlyReleaseAgent() { if(msg.sender != releaseAgent) { throw; } _; } function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) { // Call StandardToken.transfer() return super.transfer(_to, _value); } function transferFrom(address _from, address _to, uint _value) canTransfer(_from) returns (bool success) { // Call StandardToken.transferForm() return super.transferFrom(_from, _to, _value); } } /** * A token that can increase its supply by another contract. * * This allows uncapped crowdsale by dynamically increasing the supply when money pours in. * Only mint agents, contracts whitelisted by owner, can mint new tokens. * */ contract MintableToken is StandardToken, Ownable { using SafeMathLib for uint; bool public mintingFinished = false; /** List of agents that are allowed to create new tokens */ mapping (address => bool) public mintAgents; /** * Create new tokens and allocate them to an address.. * * Only callably by a crowdsale contract (mint agent). */ function mint(address receiver, uint amount) onlyMintAgent canMint public { totalSupply = totalSupply.plus(amount); balances[receiver] = balances[receiver].plus(amount); Transfer(0, receiver, amount); } /** * Owner can allow a crowdsale contract to mint new tokens. */ function setMintAgent(address addr, bool state) onlyOwner canMint public { mintAgents[addr] = state; } modifier onlyMintAgent() { // Only crowdsale contracts are allowed to mint new tokens if(!mintAgents[msg.sender]) { throw; } _; } /** Make sure we are not done yet. */ modifier canMint() { if(mintingFinished) throw; _; } } /** * A crowdsaled token. * * An ERC-20 token designed specifically for crowdsales with investor protection and further development path. * * - The token transfer() is disabled until the crowdsale is over * - The token contract gives an opt-in upgrade path to a new contract * - The same token can be part of several crowdsales through approve() mechanism * - The token can be capped (supply set in the constructor) or uncapped (crowdsale contract can mint new tokens) * */ contract CrowdsaleToken is ReleasableToken, MintableToken, UpgradeableToken { string public name; string public symbol; uint public decimals; /** * Construct the token. * * This token must be created through a team multisig wallet, so that it is owned by that wallet. */ function CrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint _decimals) UpgradeableToken(msg.sender) { // Create any address, can be transferred // to team multisig via changeOwner(), // also remember to call setUpgradeMaster() owner = msg.sender; name = _name; symbol = _symbol; totalSupply = _initialSupply; decimals = _decimals; // Create initially all balance on the team multisig balances[owner] = totalSupply; } /** * When token is released to be transferable, enforce no new tokens can be created. */ function releaseTokenTransfer() public onlyReleaseAgent { mintingFinished = true; super.releaseTokenTransfer(); } /** * Allow upgrade agent functionality kick in only if the crowdsale was success. */ function canUpgrade() public constant returns(bool) { return released; } } /** * At the end of the successful crowdsale allocate % bonus of tokens to the team. * * Unlock tokens. * * BonusAllocationFinal must be set as the minting agent for the MintableToken. * */ contract BonusFinalizeAgent is FinalizeAgent { using SafeMathLib for uint; CrowdsaleToken public token; Crowdsale public crowdsale; /** Total percent of tokens minted to the team at the end of the sale as base points (0.0001) */ uint public bonusBasePoints; /** Where we move the tokens at the end of the sale. */ address public teamMultisig; /* How much bonus tokens we allocated */ uint public allocatedBonus; function BonusFinalizeAgent(CrowdsaleToken _token, Crowdsale _crowdsale, uint _bonusBasePoints, address _teamMultisig) { token = _token; crowdsale = _crowdsale; if(address(crowdsale) == 0) { throw; } teamMultisig = _teamMultisig; if(address(teamMultisig) == 0) { throw; } bonusBasePoints = _bonusBasePoints; } /* Can we run finalize properly */ function isSane() public constant returns (bool) { return (token.mintAgents(address(this)) == true) && (token.releaseAgent() == address(this)); } /** Called once by crowdsale finalize() if the sale was success. */ function finalizeCrowdsale() { if(msg.sender != address(crowdsale)) { throw; } // How many % of tokens the founders and others get uint tokensSold = crowdsale.tokensSold(); allocatedBonus = tokensSold.times(bonusBasePoints) / 10000; // move tokens to the team multisig wallet token.mint(teamMultisig, allocatedBonus); // Make token transferable token.releaseTokenTransfer(); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"constant":false,"inputs":[],"name":"finalizeCrowdsale","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"isFinalizeAgent","outputs":[{"name":"","type":"bool"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"allocatedBonus","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"bonusBasePoints","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"isSane","outputs":[{"name":"","type":"bool"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"crowdsale","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"teamMultisig","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"token","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"inputs":[{"name":"_token","type":"address"},{"name":"_crowdsale","type":"address"},{"name":"_bonusBasePoints","type":"uint256"},{"name":"_teamMultisig","type":"address"}],"payable":false,"type":"constructor"}]
Contract Creation Code
606060405234610000576040516080806105b083398101604090815281516020830151918301516060909301519092905b60008054600160a060020a03808716600160a060020a031992831617909255600180548684169216919091179081905516151561006c57610000565b60038054600160a060020a031916600160a060020a03838116919091179182905516151561009957610000565b60028290555b505050505b6104fd806100b36000396000f300606060405236156100725763ffffffff60e060020a6000350416630bf318a38114610077578063614cb904146100865780636a457ee9146100a75780637424bebc146100c657806382771c8e146100e55780639c1e03a014610106578063dbc0c0851461012f578063fc0c546a14610158575b610000565b3461000057610084610181565b005b3461000057610093610386565b604080519115158252519081900360200190f35b34610000576100b461038c565b60408051918252519081900360200190f35b34610000576100b4610392565b60408051918252519081900360200190f35b3461000057610093610398565b604080519115158252519081900360200190f35b34610000576101136104a4565b60408051600160a060020a039092168252519081900360200190f35b34610000576101136104b3565b60408051600160a060020a039092168252519081900360200190f35b34610000576101136104c2565b60408051600160a060020a039092168252519081900360200190f35b60015460009033600160a060020a0390811691161461019f57610000565b600154604080516000602091820181905282517f518ab2a80000000000000000000000000000000000000000000000000000000081529251600160a060020a039094169363518ab2a89360048082019493918390030190829087803b156100005760325a03f115610000575050604080518051600254600060209384015283517f1d3b9edf000000000000000000000000000000000000000000000000000000008152600481018390526024810191909152925190945061271093507380308f4359ffc4c6f5698886b44532afe525d78392631d3b9edf926044808301939192829003018186803b156100005760325a03f41561000057505060405151905081156100005704600481815560008054600354604080517f40c10f19000000000000000000000000000000000000000000000000000000008152600160a060020a0392831695810195909552602485019590955293519316926340c10f1992604480820193929182900301818387803b156100005760325a03f11561000057505060008054604080517f5f412d4f0000000000000000000000000000000000000000000000000000000081529051600160a060020a039092169350635f412d4f92600480830193919282900301818387803b156100005760325a03f115610000575050505b50565b60015b90565b60045481565b60025481565b6000805460408051602090810184905281517f42c1867b000000000000000000000000000000000000000000000000000000008152600160a060020a033081166004830152925192909316926342c1867b926024808301939282900301818787803b156100005760325a03f1156100005750506040515115156001149050801561049e575030600160a060020a0316600060009054906101000a9004600160a060020a0316600160a060020a031663d1f276d36000604051602001526040518163ffffffff1660e060020a028152600401809050602060405180830381600087803b156100005760325a03f1156100005750505060405180519050600160a060020a0316145b90505b90565b600154600160a060020a031681565b600354600160a060020a031681565b600054600160a060020a0316815600a165627a7a72305820183a8ecf81541ddfc5c66ed66d4dbe667c475150e7eb279cc8c5fe759bb47a3a002900000000000000000000000071d6a613af53a0c057f2d6833dc9ade67824326700000000000000000000000091c92f8bd1e17801edacad6b943e20c1777ee7540000000000000000000000000000000000000000000000000000000000005b25000000000000000000000000e8baf9df0ded92c5f28aab97f13936e7716a4a5b
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000071d6a613af53a0c057f2d6833dc9ade67824326700000000000000000000000091c92f8bd1e17801edacad6b943e20c1777ee7540000000000000000000000000000000000000000000000000000000000005b25000000000000000000000000e8baf9df0ded92c5f28aab97f13936e7716a4a5b
-----Decoded View---------------
Arg [0] : _token (address): 0x71D6a613af53A0c057F2d6833Dc9ade678243267
Arg [1] : _crowdsale (address): 0x91C92f8BD1e17801eDAcaD6b943e20C1777eE754
Arg [2] : _bonusBasePoints (uint256): 23333
Arg [3] : _teamMultisig (address): 0xE8BaF9DF0DeD92c5f28AaB97f13936E7716A4a5B
-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 00000000000000000000000071d6a613af53a0c057f2d6833dc9ade678243267
Arg [1] : 00000000000000000000000091c92f8bd1e17801edacad6b943e20c1777ee754
Arg [2] : 0000000000000000000000000000000000000000000000000000000000005b25
Arg [3] : 000000000000000000000000e8baf9df0ded92c5f28aab97f13936e7716a4a5b
Swarm Source
bzzr://183a8ecf81541ddfc5c66ed66d4dbe667c475150e7eb279cc8c5fe759bb47a3a
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 24 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.