Methods for Withdrawing Ether in Solidity Contracts

Understanding how to withdraw funds from a contract involves using transfer, send, or call methods in Solidity.

### Methods for Withdrawing Funds from a Smart Contract
* 💰 To withdraw funds from a smart contract, there are three primary methods: **transfer**, **send**, and **call**, each with distinct functionalities and limitations.
* 🔄 The simplest method is transfer, which uses `message.sender.transfer(address(this).balance)` to **send the contract's entire balance to the caller**, requiring the sender to be a **payable address**.
* ⚠ However, transfer is limited to **2300 gas** and will throw an error if the transaction fails, making it **less flexible in certain scenarios**.
* 📩 The second method, send, also has a gas limit of **2300** but returns a **Boolean indicating success or failure**, allowing for error handling with a `require` statement to **revert the transaction if it fails**.
* 📞 The third method, **call**, is more versatile, allowing you to **send Ether without a gas cap** and can call **any function on Ethereum**, returning both a **success Boolean** and any **data returned from the function**.
* 🔍 Using call, you would structure it as `payable message.sender.call{value: address(this).balance}()` and handle the success with a `require` statement to **ensure the transaction completes**.
* 💡 "As of now, using call is recommended for sending and receiving Ethereum or native blockchain tokens" due to its **flexibility and lack of gas limitations**.
* 📚 If the differences between these methods seem complex, it's advisable to **revisit this topic after gaining a deeper understanding of Solidity and gas mechanics**.

So great, we've gone ahead and reset the array, but how do we actually now withdraw funds from this contract? How do we send the funds back to whomever is calling this, now to actually send ether or send native blockchain currency? There are actually three different ways to do this.

We're going to look at all three and say what the difference is between the three of them. There are three different ways: we're going to be transfer, send, and call. Let's go ahead and start with transfer since transfer is the simplest and at surface level makes the most sense to use.

So, if we want to transfer the funds to whomever is calling this withdrawal function, we would do, we would say `message.sender.transfer` and then we'd get the balance of our contract here by saying `address(this)`. This keyword refers to this whole contract. `.balance` and we can get the native blockchain currency or the Ethereum currency balance of this address like this. And we can just do that. Only thing that we need to do is we need to cast, we need to typecast `message.sender` from an `address` type to a

payable address type. So `message.sender` is of type `address`, whereas `payable(message.sender)` is of type `payable address`. And in Solidity, in order to send the native blockchain token like Ethereum, you can only work with payable addresses to do that. So we just wrap it in this payable typecast. So this is the first way that we can actually send Ethereum or send tokens from different contracts to each other. We wrap the address that we want to send it in in this payable keyword, we do `.transfer`, and then we say exactly how much we want to transfer.

but there are some issues with transfer here we are on solidity by example for sending ether which again is a fantastic resource to refer to if you get lost the method that we just looked at was this transfer method now we saw way earlier in the course that if I sent ethereum

from one address to another it cost about 2100 gas or 2100 gas our transfer function is capped at 2300 gas and if more gas is used it throws an error the next one that we're using is going to be send which is also capped at 2300 gas

and if it fails it'll return a Boolean so with transfer if this line fails it'll err and revert the transaction with send it won't err it'll return a Boolean of whether or not it was successful so using send will do payable message.sender dot send

address this balance but we don't want to finish our call here if this were to fail the contract wouldn't revert the transaction and we just wouldn't get our money sent so we want to do Boolean send success equals this whole bit here and then we want to

require send success and if this send fails we'll throw an error saying send failed this way if this fails we will still revert by adding our require statement here transfer automatically reverts if the transfer fails send will only revert the transaction if we add this require

statement here so great what's the third way that we can actually send ethereum or native currency well it's with this call command now call is going to be one of the first lower level commands that we actually use in our solidity code because this call function is actually

incredibly powerful, and we can use it to call virtually any function in all of Ethereum without even having to have the ABI. We'll learn the advanced ways to use this call much later. For now, we're just going to learn how to use it to send

Ethereum or your native blockchain currency. Call is going to look very similar to send. We're going to do payable message.sender.call, and this is where we'll put any function information or any information about the function we want to call on some other contract. We actually don't

want to call a function, so we're going to leave this blank. We can show that we're leaving it blank by just putting in these two quotes here. We instead want to use this like a transaction, and as we saw in our deployment, there's always

this message.value bit. So we're going to use this call function as if it's a regular transaction, and we can add stuff like message.value. So in here, we're going to add these squiggly brackets and we're going to say value: address

this.balance. This call function returns actually two variables, and when a function returns two variables, we can show that by placing them into parentheses on the left-hand side. The two variables it returns are going to be a Boolean that we're going to call callSuccess

and also a bytes object called dataReturned. Since call allows us to actually call different functions, if that function returns some data or returns a value, we're going to save that in the dataReturned variable. It also returns callSuccess, where if the function was successfully called, this

will be true if not this will be false and since bytes objects are arrays data returned needs to be in memory now for our code here we're actually not calling a function so we don't really care about data returned so similar to what we saw with the price contract we can just go

ahead and delete that and leave the comma to tell solidity yeah we know this function returns two variables but we only care about one and then similar to the send piece above we're going to do require call success call failed meaning that requiring call success is true otherwise we'll revert

with an error that says call failed now if learning the difference between these three is a little complicated for you right now don't let that slow you down feel free to come back to this after you've learned more about how some of these lower level functions work and a

little bit more about how gas works solidity by example does a fantastic job though of saying what the difference is between all three are transfer has a maximum of 2300 gas and throws an error if it fails send has a maximum of 2300

gas returns a Boolean if it fails call forwards all gas so it doesn't have a capped gas and similar to send returns a Boolean if it is successful or if it fails as of recording right now using call is the recommended way to actually send and receive ethereum or your

blockchain native token for now if this part's a little bit confusing for you for now just look at this and see Ah that's how we send and transfer ethereum or native blockchain currency tokens and I'm going to delete this part for the video but I'll keep those comments in

the code repository associated with this course

Lesson 4 Part 18 | Transfer, Send, Call - Solidity & Foundry Full Course

Book a smart contract audit here 👇
https://www.cyfrin.io/


Cyfrin Audits

Explains the need to withdraw funds from a contract and introduces three methods: transfer, send, and call.

Outlines the three methods for withdrawing funds: transfer, send, and call.

Details the 'transfer' method, highlighting the use of `message.sender.transfer` and typecasting to `payable address`.

Explains the necessity of using `payable address` for sending native blockchain tokens.

Comparison of Transfer, Send, and Call Methods

Discusses limitations of the `transfer` method, specifically its 2300 gas cap and error handling.

Compares `send` with `transfer`, emphasizing the Boolean return value of `send` and the need for a `require` statement to handle failures.

Illustrates the use of `send` with error handling using a `require` statement.

Highlights the importance of the `require` statement to revert transactions upon failure with `send`.

Introduces the `call` method as a lower-level function for sending ether.

Explains the versatility of the `call` function and its use in sending ether without needing ABI.

Shows how to use `call` similarly to a transaction, using `message.value`.

Describes the return values of `call`: a Boolean (`callSuccess`) and a `bytes` object (`dataReturned`). Shows how to handle these values.

Emphasizes the use of `require callSuccess` for error handling with the `call` method.

Offers encouragement for those finding the differences between the three methods challenging.

Summarizes the gas limits and error handling of `transfer`, `send`, and `call`.

Recommends using the `call` method for sending and receiving Ethereum or native blockchain tokens.

Offers a concluding note for viewers who may find the concepts confusing.