[Ethereum] pass addresses as parameters in the constructor of the contract

remixsolidity

Well I know that in theory the obvious answer is yes, as the constructor is a function like the others, but have its own characteristics. But, I want to be sure, because let's suppose that I pass an address that was already assigned to another contract in the blockchain, what happen in that situation? There is an option (a kind of alert) to avoid this situation? or just this didn't and will not happen never?

Maybe is 99.9% impossible, but I want to be sure. Is not better that this kind of addresses are generated by the network? I so, how can I do this in the deployment process?

Here a code, to be clear:

contract SimpleContract {
  address public personalAddress;     

  function SimpleContract(address givenAddress) {
    personalAddress = givenAddress;
  }

}

Best Answer

It is perfectly valid to send the constructor an address even if the address you send points to an account that does not "exist."

I quoted "exist" because, in a certain sense, every address exists. Some have been used before (i.e. have bytecode, been involved in a transaction, have a non-zero ether balance) and some have not been used yet.

But every 40-character (20-byte) hex string is a valid Ethereum address, and you can send it to any function (including constructors) you want. Whether the address is useful or not is a different question.

Not expressed in your question, but possibly implied by it, is the question of whether a smart contract has an address prior to finishing its constructor. In other words, can you use address(this) in the constructor and get a valid address. I asked that question here: Is address(this) a valid address in a contract's constructor?

Related Solutions

Calling Constructor Functions of Existing Contracts – Is It Possible?

The constructor function is actually not just a regular function, and actually is called exactly once and cannot be called again.

Not only does the EVM not know what a constructor is, it also doesn't know what a function is. The way functions are implemented in Ethereum is that the compiler includes a check at the beginning of the code which compares the first four bytes of the transaction data with the function signatures, computed as bytes4(sha3("myFunction(uint256, bytes, address, ...)")).

The constructor is not included in the list of function signitures that it checks, and the constructor code is not even included in the contract.

Contracts are created by sending a transaction with no to field. The data in the transaction is interpreted as EVM code. This code (which includes the constructor function) is run, and its return value (which does not include the constructor) is used as the new code in the contract.

Thus there is no security hole here.

Solidity – What Happens If Free Memory Pointer Is Not Updated in Assembly?

What will happen? Will it overwrite my data?

Yes, if the code following adheres to solidity's memory model AND uses memory, it will start writing at the address returned by mload(0x40) and overwrite your data.

  function example() public pure returns (bytes32, string memory) {
        bytes32 myValue;

        assembly {
            // mload(0x40) is 0x80 initially
            mstore(mload(0x40), 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
        }

        string memory myString = "hello";

        assembly {
            myValue := mload(0x80)
        }

        // myValue : 0x0000000000000000000000000000000000000000000000000000000000000005
        // myString : 'hello'
        return (myValue, myString);
    }

Here, myValue becomes 0x05 because the 32 bytes at 0x80 are now used by myString to store the length field. hello is 5 ASCII characters long, so its length is 5 bytes.

If you want to ensure that the memory space is secure (i.e., no side effects) then you must allocate the memory by incrementing the free memory pointer. Using memory above the free memory pointer but not allocating it is perfectly fine as long as you are treating that memory space as a scratch space. You can read more about it in the documentation.

I hope this answers your question.

Best Answer

Related Solutions

Calling Constructor Functions of Existing Contracts – Is It Possible?

Solidity – What Happens If Free Memory Pointer Is Not Updated in Assembly?

Related Topic