pragma solidity ^0.4.2;
contract owned {
address public owner;
function owned() {
owner = msg.sender;
}
modifier onlyOwner {
require (msg.sender == owner);
_;
}
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
}
}
contract tokenRecipient {
event receivedEther(address sender, uint amount);
event receivedTokens(address _from, uint256 _value, address _token, bytes _extraData);
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData){
Token t = Token(_token);
require (!t.transferFrom(_from, this, _value));
receivedTokens(_from, _value, _token, _extraData);
}
function () payable {
receivedEther(msg.sender, msg.value);
}
}
contract Token {
mapping (address => uint256) public balanceOf;
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
}
/ The shareholder association contract itself /
contract Association is owned, tokenRecipient {
/* Contract Variables and events */
uint public minimumQuorum;
uint public debatingPeriodInMinutes;
Proposal[] public proposals;
uint public numProposals;
Token public sharesTokenAddress;
event ProposalAdded(uint proposalID, address recipient, uint amount, string description);
event Voted(uint proposalID, bool position, address voter);
event ProposalTallied(uint proposalID, uint result, uint quorum, bool active);
event ChangeOfRules(uint newMinimumQuorum, uint newDebatingPeriodInMinutes, address newSharesTokenAddress);
struct Proposal {
address recipient;
uint amount;
string description;
uint votingDeadline;
bool executed;
bool proposalPassed;
uint numberOfVotes;
bytes32 proposalHash;
Vote[] votes;
mapping (address => bool) voted;
}
struct Vote {
bool inSupport;
address voter;
}
/* modifier that allows only shareholders to vote and create new proposals */
modifier onlyShareholders {
require (sharesTokenAddress.balanceOf(msg.sender) > 0);
_;
}
/* First time setup */
function Association(Token sharesAddress, uint minimumSharesToPassAVote, uint minutesForDebate) payable {
changeVotingRules(sharesAddress, minimumSharesToPassAVote, minutesForDebate);
}
/// @notice Make so that proposals need tobe discussed for at least `minutesForDebate/60` hours and all voters combined must own more than `minimumSharesToPassAVote` shares of token `sharesAddress` to be executed
/// @param sharesAddress token address
/// @param minimumSharesToPassAVote proposal can vote only if the sum of shares held by all voters exceed this number
/// @param minutesForDebate the minimum amount of delay between when a proposal is made and when it can be executed
function changeVotingRules(Token sharesAddress, uint minimumSharesToPassAVote, uint minutesForDebate) onlyOwner {
sharesTokenAddress = Token(sharesAddress);
if (minimumSharesToPassAVote == 0 ) minimumSharesToPassAVote = 1;
minimumQuorum = minimumSharesToPassAVote;
debatingPeriodInMinutes = minutesForDebate;
ChangeOfRules(minimumQuorum, debatingPeriodInMinutes, sharesTokenAddress);
}
/// @notice Propose to send `weiAmount / 1E18` ether to `beneficiary` for `JobDescription`. `transactionBytecode ? Contains : Does not contain` code.
/// @param beneficiary who to send the ether to
/// @param weiAmount amount of ether to send, in wei
/// @param JobDescription Description of job
/// @param transactionBytecode bytecode of transaction
function newProposal(
address beneficiary,
uint weiAmount,
string JobDescription,
bytes transactionBytecode
)
onlyShareholders
returns (uint proposalID)
{
proposalID = proposals.length++;
Proposal storage p = proposals[proposalID];
p.r
Hello to all...
i think that there is a problem with the "create your own crypto-currency" tutorial here
https://www.ethereum.org/token#full-coin-code
I try to explain what i think.
The contract tokenRecipient is an abstract contract right? (if i'm wrong explain that please)
So there are two questions:
1) why the tokenRecipient contract is not inherited from another contract in the tutorial?
2) why in the function approveAndCall inside the "token" contract there is this line of code "tokenRecipient spender = tokenRecipient(_spender);" ?
I mean, if tokenRecipient is an abstract contract should not be used like that.
chain --dev
flag to starting private development mode, and navigate to the web UI to push contracts and interact with them in development mode. Have you tried that and gotten stuck at some point in that process?
tokenRecipient spender = tokenRecipient(_spender);
means "take the _spender
variable (which is an address
value that the transaction sender input) and cast it to a tokenRecipient
contract class (meaning, assume that whatever destination address the user is wanting me to use, assume that it meets the interface defined as tokenRecipient
)" That make sense?
approve
. If the other contract you're giving an allowance to is another smart contract, and it has implemented a receiveApproval
function (to let it do some logic immediately after receiving some tokens), use the approveAndCall
function to trigger that all in the same transaction call.
@MidnightLightning
When a contract is defined in Solidity like the
tokenRecipient
one in that contract, it acts kind of like what an "interface" would be in other languages.
Ok, but i'm confusing...so in that tutorial, should be corrected from
contract tokenRecipient { function receiveApproval(address from, uint256 value, address token, bytes extraData); }
to
interface tokenRecipient { function receiveApproval(address from, uint256 value, address token, bytes extraData); }
right ???
@MidnightLightning
Anyway, with contract keyword it works.
But for complete understanding the tutorial, i need to know this:
Should i deploy only the MyAdvancedToken contract (using truffle)?
Should i call the deployer link also or i don't to link?
This is my migration code:
var owned = artifacts.require("Owned");
var Token = artifacts.require("Token");
var TestCoin = artifacts.require("TestCoin");
module.exports = function(deployer) {
deployer.deploy(owned);
deployer.deploy(Token,1000000,'TestCoin',0,'TEC');
deployer.link(Token, TestCoin);
deployer.link(owned, TestCoin);
deployer.deploy(TestCoin);
};
Thank you very much for help me!
MyAdvancedToken
contract for basic functionality. If you want to test the approveAndCall
functionality, you'd need to deploy a second contract that implements that one receiveApproval
method.