Solidity – Is Contract Address the Msg.sender When Calling Another Contract’s Function

contract-developmentcrowdsaleicosoliditytokens

For example, a crowdsale contract has a function that creates an ERC20 token called "token" using a token contract that is already defined further up in the code being deployed. The constructor contains

token = createTokenContract();

And the createTokenContract() method contains:

function createTokenContract() internal returns (TierToken) {
    return new ERC20Token();
}

When inside a payable function in the crowdsale it now calls a function of "token" inside my crowdsale contract like

token.transfer(beneficiary, tokenAmount);

Inside of that call who is the msg.sender? The transfer function is from OpenZeppelins implementation so contains:

    function transfer(address _to, uint256 _value) public returns (bool success) {
      require(_to != address(0)); //not sending to burn address
      require(_value <= balances[msg.sender]); // If the sender has sufficient funds to send
      require(_value>0);// and the amount is not zero or negative

      // SafeMath.sub will throw if there is not enough balance.
      balances[msg.sender] = balances[msg.sender].sub(_value);
      balances[_to] = balances[_to].add(_value);
      Transfer(msg.sender, _to, _value);
      return true;
   }

In these balance checks and transfers where it uses balances[msg.sender], is that sender now the address of the crowdsale contract that contained the call to this function? Or is the sender the user that sent the ether to the contract (which then made the call to the token function)?

This may be simple but I cannot find this explained well in the docs in terms of msg.sender relating to contracts calling functions of other contracts.

Thanks for any help.

Best Answer

If a contract's function calls a function of another contract within it, is the address of the contract the msg.sender?

yes.

tx.origin is the external account that sent the transaction.

From Solidity docs:

msg.sender (address): sender of the message (current call)

tx.origin (address): sender of the transaction (full call chain)

Related Solutions

[Ethereum] Token transfer: Intrinsic gas too low

I suspect that your issue is because you have not approved the transfer required to call transferFrom(...).

Here are the relevant functions:

    /* Send coins */
    function transfer(address _to, uint256 _value) {
        if (balanceOf[msg.sender] < _value) throw;           // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw; // Check for overflows
        balanceOf[msg.sender] -= _value;                     // Subtract from the sender
        balanceOf[_to] += _value;                            // Add the same to the recipient
        Transfer(msg.sender, _to, _value);                   // Notify anyone listening that this transfer took place
    }

    /* Allow another contract to spend some tokens in your behalf */
    function approveAndCall(address _spender, uint256 _value, bytes _extraData)
        returns (bool success) {
        allowance[msg.sender][_spender] = _value;
        tokenRecipient spender = tokenRecipient(_spender);
        spender.receiveApproval(msg.sender, _value, this, _extraData);
        return true;
    }

    /* A contract attempts to get the coins */
    function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
        if (balanceOf[_from] < _value) throw;                 // Check if the sender has enough
        if (balanceOf[_to] + _value < balanceOf[_to]) throw;  // Check for overflows
        if (_value > allowance[_from][msg.sender]) throw;   // Check allowance
        balanceOf[_from] -= _value;                          // Subtract from the sender
        balanceOf[_to] += _value;                            // Add the same to the recipient
        allowance[_from][msg.sender] -= _value;
        Transfer(_from, _to, _value);
        return true;
    }

If you are the current owner of the tokens, you can call transfer(...) to transfer your balance to another address.

However if you want to transfer from another address, you will need to call transferFrom(...) which will check the allowance[...][...] data structure to confirm whether this transfer has been approved.

So, call approveAndCall(...) first to approve your transfer and you should be able to call transferFrom(...) to transfer your tokens.

When you call transferFrom(...) without first calling approveAndCall(...), and error is thrown in the line

if (_value > allowance[_from][msg.sender]) throw;   // Check allowance

This error will appear as an Out Of Gas error in the Ethereum Wallet.

If you are comfortable using geth, see How can the transaction status from a thrown error be detected when gas can be exactly the same as the gasUsed for a successful transaction? for the following code that can be used to check the exact reason for your error:

> var status = debug.traceTransaction("0xd23219e2ea10528b245deb9e47993cae2ffd3ffe9fc27aeb808e94fc4e75d37b")
undefined
> if (status.structLogs.length > 0) {
  console.log(status.structLogs[status.structLogs.length-1].error)
}
"invalid jump destination (PUSH1) 2"

Crowdsale Contract – How to Mint Tokens in Another Token Contract

Yes what you need to do is first create your token in a separate contract. Then when you create your crowdsale you pass in the constructor the address of your token.

This is a sample taken from the Ethereum Crowdfund your idea

pragma solidity ^0.4.16;

interface token {
    function mintToken(address receiver, uint amount);
}

contract Crowdsale {
    token public tokenReward;

    /**
     * Constrctor function
     */
    function Crowdsale(
        address addressOfTokenUsedAsReward
    ) {
        tokenReward = token(addressOfTokenUsedAsReward);
    }
}

Best Answer

Related Solutions

[Ethereum] Token transfer: Intrinsic gas too low

Crowdsale Contract – How to Mint Tokens in Another Token Contract

Related Topic