I really like the fact that it remains fully ERC20 compatible, and does not force receivers of the token to implement a certain function to signal that they accept them.

One question though: what is the rationale behind making the external call before the transfer or approval? I would have expected the call to occur afterwards, so the receiver of the tokens can check the transferred/approved balance and act upon it on that same call. And by throwing if the call goes wrong, the transfer gets rolled back all the same.

@spalladino In the approveData method the call is executed after the approve and in the transfer methods the call is executed before the transfer. At first all calls were executed before the ERC20 methods, but I changed the order in the approveData because I think the next call to be executed after an approve will want to have the amount to be transfered already approved, doing this you can execute a transferFrom inside the call and if all the things you wanted to do and check went fine you claim the tokens.

I think the order of the function call in approveData is not explained correctly in the issue, Im going to update it.

You are right that if the call fails the transfer and transferFrom will be reverted, the order can be changed and it will have the same effect I guess.

I have no problem on changing the order :)

Oops sorry, I misunderstood the order in approveData. As for the order in transferData and transferDataFrom, I'd follow the same approach of transfer-then-call as in approve, for the same reasons you mention. WDYT?

I agree, im going to change the description in the issue.

I like this. Where do you envision this standard relative to ERCs 20, 223, and 777? It seems like 827 is a fantastic stopgap that's 20-compatible that should be adopted relatively quickly before the community gets around to ratifying 223 or 777.

Thoughts?

I really like this, thanks a lot! What do you think about overloading transfer, approve and transferFrom functions considering the new bytes _data argument?

@shrugs yes I agree, less code is safer and easier to test, and I think this new methods fulfill the needs that the rest of the standards are trying to cover.

@facuspagnuolo but if we do that we will change the ERC20 function signatures and it wont be ERC20 compatible anymore, right? I think we cant have functions with the same name and different arguments, or we can? 🤔

@AugustoL as far as I know, if we provide an overloaded function changing the amount of parameters, I think it won't change the signature of the ERC20 functions, for example:

• ERC20 transfer function will keep being: keccak256("transfer(address,uint256)")
• ERC827 transfer function will be: keccak256("transfer(address,uint256,bytes)")

am I right?

@facuspagnuolo I think you are, let me do a quick test! 👀

Another quick thing, we might want to distinguish between throw and revert in the spec

@facuspagnuolo I changed the method names to be the same as ERC20 but with the data argument and the signature is different so there is not issue on having the same name but with the _data argument.

I think that allowing the token contract to call any function at any address is much less useful than calling some sort of tokensReceived method on the receiving contract (as in ERC223/777). Receiving contracts have no way of knowing that the calling address is a token contract, so they can't really do anything useful with the passed in data.

A big part of this is that msg.sender will always be the token address, where a tokensReceived method knows the intended sender from the passed in arguments. There is also no explicit way to link the token transfer to the function call, which really limits the possibilities.

It also seems like it could have unintended consequences to allow a token to call any arbitrary data. For example, if tokenA is accidentally transferred to an ERC827 token contract, anyone would be able to claim these tokens by simply calling tokenA.transfer(self, value) from the ERC827 token.

@abandeali1 thanks for the feedback! But I think this is more useful because you dont need to have any specific method in the receiver contract to call it, but if the contract has it you can still use it, so you can call any other contract and make use of the tokenFallback function. In fact I think we can say that this token is also ERC223-Receiver compatible ?

There is way to know who executed the transaction, you can send a signature of the msg.sata as a parameter and verify the signer in the contract that is receiving the call form the token. you can also use tx.origin but I understand that is not recommended.

And if there is tokens transfered to this contract they can be claimed by anyone, I dont see any problem there, at least they are not stuck there, which I think is the main problem, having tokens that are not able to being used.

@AugustoL this is partially true. The major difference is that in ERC223/777, from and value are always passed to the tokensReceived callback, so receiving contacts can rely on those arguments with the assumption that the token conforms to the standard. With ERC827, what is preventing me from telling the receiving contract that I transferred 10000000 tokens when I actually only transferred 1?

To the second point, this particular case might not be that bad. But this is just a single example of unintended consequences, and I can't confidently say that there aren't other cases out there that would lead to a worse outcome.

As of yesterday's release of zeppelin, those links in the above post no longer work because the contract code has been migrated into separate directories:

https://github.com/OpenZeppelin/zeppelin-solidity/blob/master/contracts/token/ERC827/ERC827Token.sol

Thanks @strotter ! fixed :)

I find one important problem with this standard. The call to the receiver's contract is not authenticated. The receiver's contract cannot tell if the data received comes in fact from the sender or anyone else. I see people will start using it in this way:

token.transfer(receiver,amount, abiEncodingOf(received(sender ,amount))
The receiver contract would have a method received(address sender, uint amount).
The security of this pattern is obviously completely broken.

It would be much much useful if the receiver would receive the arguments token, sender and amount right from the token contract, and not from the supposedly sender.

The pattern that uses approve/transferFrom can also lead to common mistakes if a honest sender uses token.transferFrom(receiver,amount), and then a malicious user uses token.transfer(receiver,0,simData) just to simulate the previous transferFrom() has a data argument.

Also this standard will break any other future standard that tries to fix this problem and try to notify a receiver with authenticated source/amount information. Once you allow the token to emit any message, you cannot authenticate anything later.

Still another problem is that you can use the token to send messages to itself. If the token contract is owner of tokens, then you can use this to steal the tokens from the token contract.

Very bad standard IMHO.

Now that I read the previous comments, I note that ALL that I said has been already said in a previous comment by @abandeali1

@SergioDemianLerner Thanks for your feedback!

We require that the the _spender and _to cant be the token address itself but I didnt had any note about that in the spec.

If the contract have any other tokens or assets they are open for grabs, I dont see a problem there since the contract in my opinion in only responsible of handling the internal balances.

Authentication is something that I think it can be done from the other contract too, without requiring the contract to be called to have a function to receive tokens.

How do you see message signing/verification being used in the receiver contract for authentication? If you need to authenticate a user it can send a signature of a hash generated inside the function and verify the real sender there.

I use a lot more transferFrom (with _data param) and approval to check the availability of the value that the sender is willing to transfer, and claiming it afterwards. The use of transfer (with _data param) can be useful for some cases, but I see much more utility in transferFrom & approve strategy for transferring value.

@AugustoL To be clear,

I use a lot more transferFrom (with _data param) and approval to check the availability of the value that the sender is willing to transfer, and claiming it afterwards. The use of transfer (with _data param) can be useful for some cases, but I see much more utility in transferFrom & approve strategy for transferring value.

You are talking about a pattern like this?

token.approve(receiver, value, keccak256("canRecieve(sender)");

Contract Receiver {
  function canReceive(address sender) public {
    uint256 allowedValue = tokenContract.allowance(sender, self);
    tokenContract.transferFrom(sender, self, allowedValue);
    doBusinessLogic();
  }

  function doBusinessLogic() { ... }
}

This would require the receiving contract be aware of the token contract address. It would be nice if the sender and value were passed as arguments so we would not need to do the approval-allowance-transferFrom dance.

@dadeg Something like that, yes! Keep in mind that you can send the value in the call data and you also can instantiate a ERC20 token using the msg.sender address.

token.approve(receiver, value, keccak256("canRecieve(sender, value)");

Contract Receiver {
  function canReceive(address sender, uint256 value) public {
    ERC20 tokenContract = ERC20(msg.sender);
    uint256 allowedValue = tokenContract.allowance(sender, value);
    tokenContract.transferFrom(sender, value, allowedValue);
    doBusinessLogic();
  }

  function doBusinessLogic() { ... }
}

Although I would recommend to have some way to specify the token address in the contract itself, if not it can be called from any ERC827 token.

Thanks! I am unsure if sending value is a wise idea, considering there is no guarantee that the value mentioned in the _data argument matches the value argument in the original approve call: token.approve(receiver, 10, keccak256("canReceive(sender, 1000)"))

As long as the receiving contract knows the address of the token contract, this approve-allowance-transferFrom pattern seems like a strong guarantee that nothing bad will happen. Even if the user initially screws up the approve() call, like typo-ing the _data string, token.approve(receiver, 10, keccak256("someTypoFunction(sender, 1000)")), they can recover by simply calling canReceive directly themselves, or calling approve again with the correct data signature. And the rest of the pattern is hardcoded in a single transaction to limit the UI/UX complications.

Edit: To add on to this, There is no risk of a malicious actor calling receiver.canReceive because the method is hardcoded to just check the token for the allowance from any arbitrary user. The assumption being that a user wouldn't call approve previously unless they actually intended on having the receiver take ownership of all the tokens immediately.

Please correct me if I'm wrong, but doesn't this standard mean that the resulting 827 tokens will not be compatible with most (all?) ERC223 #223 receiver contracts (to the extent they exist)? ERC223 requires that the receiving contract accept tokenFallback from pre-approved sending contract addresses to validate that the second argument 'value' represents a guaranteed transfer to the receiver. In this case, however, the invocation of tokenFallback will be composed by the caller of the transfer(with bytes) function. You can't know that they are not nefarious and crediting themselves with more tokens than they are indeed transferring.

This is essentially the same argument that @SergioDemianLerner and @abandeali1 made - and I concur. For the "transfer" function, this is at least useless and quite possibly dangerous. For the "approve", it works because the receiver then has to call transferFrom and can inspect the implementation of transferFrom to ensure they are satisfied with its behavior.

What happened to the old "approveAndCall" pattern? OpenZeppelin/openzeppelin-contracts#346

@yarrumretep as far as I can tell, the current implementation of microraiden, which is a #223 receiver contract, is susceptible to this attack:

https://github.com/raiden-network/microraiden/blob/master/contracts/contracts/RaidenMicroTransferChannels.sol#L149

But I wonder if this an issue with ERC827, or with #223 receivers (and #777 receivers for that matter). They probably shouldn't trust that tokens have been transferred. Otherwise they need to implement a white/black list to be safe.

Since when is it a good idea to execute arbitrary calls to contracts? Let alone make that part of a token standard?

Just popping in since I heard "microraiden".

Basically re-iterating what @abandeali1, @SergioDemianLerner and @yarrumretep mentioned.

In the spec you have this function:

function transfer(address _to, uint256 _value, bytes _data) returns (bool success)

You describe it as:

Execute a function on _to with the _data parameter, if the function ends successfully execute the
transfer of _value amount of tokens to address _to, and MUST fire the Transfer event.

The function SHOULD revert if the call to _to address fails or if _from account balance does not have enough tokens to spend.
The ERC20 transfer method is called before the _to.call(_data).

So essentialy I can do an ERC20 transfer of 1 token to contract _to but in the data I provide to it say I sent it 1 million tokens.

@LefterisJP i think your example highlights a weakness in the target contract, not in this token standard.

@dadeg As a 'receiving' contract under this standard as described above all I effectively get is a ping that my balance may change in the future by some unspecified amount. Because the standard does not mandate anything about the contents of the _data (nor could it really control that without a significant on-chain burden), the receiver isn't guaranteed anything in particular about the arguments passed therein and their relation to the 827 token contract's actual anticipated transfer. Receiver can't even keep his old balance and compare to verify because the actual transfer is not completed until after his call.

Any contract expecting to receive ERC223 tokens (with some kind of tokenFallback function) would not be able to receive tokens that implemented this function without specific precautions to prevent callers invoking tokenFallback in the _data parameter. tokenFallback value parameter can be trusted with sending contract source inspection. _data cannot be trusted to report the quantity of the transfer.

Also, couldn't this pattern of calling out prior to making data changes open this function to reentrancy issues?

The approveAndCall variant above, on the other hand, seems more reasonable and useful to me. There is no incentive to 'lie' about the amount being approved in the _data invocation - because the amount is either approved or not in the sending contract. Although it takes more gas than the 223 method, the only trust that must be verified before accepting calls from a sending token is that the tranferFrom function functions as advertised (and the rest of the token behaves in an ERC20 way). This is, in essence, a way to chain 2 calls together (approve and then doSomethingWithThisApproval). Existing ERC20 handlers expecting the approve/doSomething pattern might even be usable directly without modification (if they have a doSomething variant that doesn't depend on msg.sender).

We have a proposal for changes to fix current issues in the token standard and also add more control over which functions can be executed from the token contract allowing the receiver contracts to have control ownership over it.

Proposal Summary

The receiver contract where the callback function will be executed now needs to allow the execution of that callback itself, if the sender attempt to execute a function that is not allowed on a receiver contract it will fail.
The callback can be allowed to certain address or they can be public, which means that anyone can execute it. There is also the option for a receiver contract to allow the execution of any function from any address.

The allowedCallbacks mapping works like this:

Receiver => Sender => Function Signature => FunctionType => Allowed

The receiver is the contract where the callbak function will be executed.

The sender can be an specific address or it can be 0x0, if it is 0x0 means that is a public callback.

The function signature can be an specific signature or it can be 0x0, if it is 0x0 means that any function can be executed.

The function type can be 1(approval), 2(transfer) or 3(transferFrom).

The allowed variable is a boolean that is true or false depending if the callback is allowed by the sender or not.

To manage the allowance of the callback the proposal adds two new functions:

function allowCallback(address from, bytes4 functionSignature, uint8 fType) public
function removeCallback(address from, bytes4 functionSignature, uint8 fType) public

Implementation: https://github.com/windingtree/erc827/blob/master/contracts/ERC827/proposals/ERC827TokenMockAllowedCallbacks.sol

Merged pull request with description and discussion: windingtree/erc827#2

Thanks @Perseverance for the help and review 👏

Second proposal submitted to the windingtree/erc827 repository: windingtree/erc827#4

Summary

The proposal adds an ERC827Proxy to the token to be used for every method that will execute arbitrary calls, doing this the msg.sender in the receiver contracts will be the ERC827Proxy address and not the ERC827 token,

Implementation

The implementation is done in the contracts/proposals folder on the ERC827TokenWithProxy.sol file.
The same tests that are being used for ERC827Token are used for this implementation with the same results.

My thoughts: I like a lot this one, it does not give as much control over the arbitrary calls as the AllowedCallbacks but it solves the main issue, making calls in behalf of the token contract.

Based on the proxy idea by @k06a

Implementation of proxy proposal simplified and ready to be merged windingtree/erc827#4

@AugustoL would you mind summarizing what the current state of this proposal. from what I can understand:

• there are security issues with transferAndCall, and two solutions have been proposed
• these vulnerabilities do not apply to approveAndCall

On a related note, do you know if the vulnerabilities also apply to #677, or does the fact that it defines a specific callback method (tokenFallback) mean it is not affected?

@ptrwtts approveAndCall have issues related to arbitrary call attack from token smart contract. Attacker can spend anything this smart contract own. I personally don’t like idea of permissioning some method signatures, I prefer to extract arbitrary call to another smart contract called Caller, which owns nothing. But it seems we can’t reach the consensus in this question, I really wonder why :)

@k06a thanks. why not just use the old school approveAndCall, as seen many past token implementations (e.g. MiniMe) , or the transferAndCall from #677? what are the main benefits of being able to call any arbitrary method?

@ptrwtts calling arbitrary method allows you to send your token to any smart contract in a way it supports. There are some DEXes with different smart contract interfaces. No need for all contract to support special token protocol, just being compatible with ERC20. #677 has a problem with checks, anyone implementing receiveApproval should perform checks, that it was called from token and not from any hacker with random arguments. Please look at #1003, I am suggesting this implementation because it is fully compatible with ERC20, even transferFrom is called for msg.sender as in simple ERC20.

TransferAndCall is this function ‘_to’ a contract address or a receiver address?

@RNHaoHao to the contract address, then you should redistribute the approval from the contract.

@AugustoL _to represents the address of other contracts. Functions that can be invoked by other contracts?

"TransferAndCall" I always failed to call （"0xacb6208f4fbc6ac8fb60ad92f7096b4100538f45",100,"0xa9059cbb0000000000000000000000004ffe370c88549717a552f9ed7aac84b12e6bc1680000000000000000000000000000000000000000000000000de0b6b3a7640000"）

PR created to integrate proxy proposal into standard and update to solidity v0.5.0
windingtree/erc827#14

PR created to change proxy handling, instead of using one single proxy a proxy can be created and destroyed for each call without any remaining balance of tokens and ETH left in it.

This also allows the verification of the original msg.sender by calculating the address of the proxy in the receiver contract in case if needed.

windingtree/erc827#18

How approveAndCall would work:
1.- Sender calls the Token to approve 100 tokens to the Receiver contract and execute claimTokens function in the Receiver contract.
2.- The Token contract changes the allowance of Sender to Receiver to 100, creates a ERC827Proxy contract where the salt is keccak256(sender, receiver, nonces[sender]).
Important note: The token has two public variables, one is proxyBytecode and the other is a mapping of the nonces by address.
3.- The Token contract executes the call to the receiver through the proxy.
4.- The Receiver contract can access the allowed balance and also verify that the sender address by comparing the msg.sender (which would be the proxy address) to the address computed by create2 of the proxy, having everything it needs to compute it (sender, token address, proxyBytecode and nonce of the sender accesible as public variables on the token).

This is definitely much better than a single proxy since it allows the verification of the original sender if necessary.

This is definitely much better than a single proxy since it allows the verification of the original sender if necessary.

And because the proxy address is not being reused and shared between accounts now!

@AugustoL what is the status of ERC827, as of your latest proposal to dynamically create and destroy poxies (#827 (comment))?

Is ERC827 in use in the real world? I am trying to decide whether to add this interface to a contract, and I'm interested to know if this has been battle-tested, and/or if it has seen any adoption.

Also, what does it mean that "This standard... is proven to be unsafe to be used" mean? What part is unsafe, specifically?

I am going to close this as GitHub is no longer the proper place to discuss ideas for EIPs (it used to be). If the author of this wants to pursue this further, they can either create a thread on Ethereum Magicians to continue discussion, or they can create a draft EIP and start working through the EIP process as described in EIP-1.

@AugustoL