Does it cost gas when sending ether from a contract to an address?

Question

Every transaction that modifies blockchain state costs gas. However, I have a doubt and would like to ask. Does it cost gas when sending ether from a contract to an address? If it does, how to implement deposit/withdraw scenario? After a user deposits some ethers to the contract, he/she likely would not withdraw the same amount of ethers because he/she needs to pay the transaction fee. So, how deposit/withdraw works anyway?

Answer 1

It breaks down like this.

First, there are two kinds of address, externally owned (regular) accounts (EOA) and contracts.

Every EOA has a signing key and can sign and send a transaction to anyone it wants, including a contract, any time it wants.

Contracts do not have signing keys and can never initiate a transaction. They have code and must execute their function if an EOA or another contract sends a transaction.

All transactions begin with a transaction signed by an EOA. If it goes to a contract, that contract may do stuff. The signer pays for gas. That contract may send a message to another contract making it do stuff. The signer still pays for the gas. And so on. No matter how long the chain of contracts and messages is, the original signer pays for all gas.

Suppose Alice wants to deposit, then withdraw from a contract that works like an ATM.

First, Alice deposits funds into contract 0x123. The contract function looks something like:

function acceptDeposit() public payable {
  balances[msg.sender] += msg.value; 
}

Then, Alice wants to withdraw her money. The 'withdrawal' pattern is good practice. In the contract, it would look something like:

function withdrawFunds(uint amount) public {
  require(balances[msg.sender] >= amount;
  balances[msg.sender] -= amount;
  msg.sender.transfer(amount);
}

In both cases, Alice starts the process, signs the transaction and pays for gas. First, the "processing fee" to accept her deposit. Then, the "processing fee" to process her withdrawal.

Hope it helps.

Answer 2

Think of it like this,

1. Who call the function/initialize a transaction will pay for the gas fee
2. A smartcontract's function can not just run by itself, either another smartcontract or an EOA must call it first

which means that the first one to call a smartcontract's function must be an EOA, because no smartcontract's function can call another smartcontract's function by itself. So the EOA which initialize the first call of the call chain will pay for the gas fee.

For example, consider the following call chain:

Alice => smartcontractA => smartcontractB => smartcontractC=>.....

You can see that, only a smartcontract or an EOA can call a smartcontract's function. And for any call chain, when you trace to its root, it must be an EOA who start the chain, then that EOA will pay for all the fee of the call chain not the smartcontract itself.