Anyone knows what does this contract code mean?

Question

Refer to the link below:

https://github.com/bokkypoobah/Tokens/blob/master/contracts/MyToken.sol

Line 62:

contract ApproveAndCallFallBack {
    function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}

And line 209:

ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);

If I understand correctly, line 209 is calling the default constructor of ApproveAndCallFallBack contract (which obviously does not exist), and call the receiveApproval() interface which is obviously not implemented here.

Anyone know how is this contract suppose to be used?

Answer 1

approveAndCall for exchanges

The approveAndCall / receiveApproval pattern is an old pattern used by exchanges to perform an atomic transfer of funds in a single step. This old method has mostly since been superseded by other standards, however it's still quite common in usage.

The idea is that an exchange wants to do 2 things.

1. Buy tokens for you.
2. Take your money.

Ideally the exchange wants to do these things together so that they don't get stuck holding tokens you can't pay for, or have you pay for tokens they can't retrieve and have to refund you.

The answer to this is to have a way they can call the transfer function and then do something on their side before completing the transfer, and if anything fails, the whole thing falls over and rolls back.

The typical workflow is:

• they call approveAndCall in the token contract which verifies the transfer is possible.
• the token contract calls them (or their surrogate contract) back via receiveApproval.
• the receiveApproval function does the funds transfer (or other action) as required.
• the token contract gets control back and performs the token transfer.
• if any one thing fails, it all fails together and no cleanup is required.

However this can all now be accomplished via ERC223 using the tokenFallback() method, which also has the handy side effect of ensuring that your token doesn't get stuck in contracts that can't handle them.

Answer 2

Okay. So from above discussion I get the following concept. Please correct me if I am wrong. Interfaces are basically like templates so that everyone can use it to create contracts just using these templates and then finally give an address to the interface because a contract needs an address.e.g-contract'x'has an address "0x1"on the blockchain. Now someone(token contract) uses the interface'x' and gives an address"0x2" so that a new contract with same functionality is created at address"0x2". Now function receiveApproval() from this "0x2" contract is called and it automatically approves the transfer. As far as the exchanges are concerned, what happens is that the exchange already has some tokens in its account. Suppose 1000 tokens. Now when exchange receives money from a client, exchange calls the function approveAndCall(client,200tokens,data) from the token contract, gives the client the permission to transfer 200 tokens from exchange's account. Now instead of waiting for the client to approve it creates a contract in the name of client by ApproveandCallFallBack(client).receiveApproval().This receiveApproval automatically approves on the behalf of client and thus transfers 200 tokens to the client's address.