Million Ether Homepage

Storing Colors in a Pixel Grid

Million Ether Page Essential Smart Contract

Tip: Mining only when there are transactions

Tip: Using Remix IDE

Getting Started

Getting The Pixels and Ethereum Events

Building a DApp UI

Drawing in HTML Canvas

Using Websockets with Web3

Web3 and Events Over WebSockets

Drawing Pixels from the Blockchain

Viewing Pixels

Buying An Image -- Reading Pixels

Buying An Image -- Sending Transactions

Pixel bidding and structs

Payable Contracts, payable Functions

Contract Owner and require

Payable color pixel function

Buying Pixels

Sending funds from a contract

The safer way to send funds from a contract

The Pull Payment Pattern - Withdraw payments when outbid

Million Ether Homepage Summary

Auctioning Pixels

solidity

In this course, we'll build a DApp inspired by [The Million Dollar Homepage](https://en.wikipedia.org/wiki/The_Million_Dollar_Homepage). We'll build a 1 million pixel page, and each pixel can be colored by placing the highest bid.

In this course we'll walk through every step of writing a smart contract, deploying it, hosting auctions, and connecting it to the browser through web3. 

If you're looking to build real, full-stack ethereum Dapps, then this is a perfectly-sized example.

We'll build a DApp inspired by the Million Dollar Homepage, powered by an auction on the Ethereum blockchain

The safer way to .send funds -- Why sending funds can fail

If you send funds to a 'normal' address, it won't fail, it will just accept your funds.

your contract can send funds to another contract

. And when you send funds to contract, that contract can run logic too. And you can't tell from the address whether it is going to a normal account or a contract account.

Sometimes the contract receiving your funds will run logic that fails. You need to be prepared for that. 

In fact, sometimes the contract receiving your funds is malicious and 

. We'll walk through an attack scenario like this in a future video. But for now, know that when you send funds, it might fail, and you need to deal with that.

Now let's withdraw these funds. Let's start with two rules:

Here is a buggy and wrong way to do this:

  function withdraw() {
    // DON'T DO THIS
    msg.sender.send(balances[msg.sender]);
    balances[msg.sender] = 0;
  }

Well, the problem is that we're sending the funds, and then clearing the balance, without checking to see if the 

One failure scenario here is that the send fails because the receiving contract runs out of gas. Then we set their balance to zero, but the Ether wasn't transferred! In this case, we'd unfairly clear their balance, but keep their Ether in the bank.

---
title: The safer way to send funds from a contract


slug: 'safer-way-to-send-funds'
thumbnail: https://embed-ssl.wistia.com/deliveries/a1f6034710036962ec4d6e5b2f03049e9f79ea63.jpg

privateVideoUrl: https://fullstack.wistia.com/medias/2bgbv5e46n



---

### The safer way to .send funds -- Why sending funds can fail

If you send funds to a 'normal' address, it won't fail, it will just accept your funds.

**But** in Ethereum, **your contract can send funds to another contract**. And when you send funds to contract, that contract can run logic too. And you can't tell from the address whether it is going to a normal account or a contract account.

Sometimes the contract receiving your funds will run logic that fails. You need to be prepared for that. 

In fact, sometimes the contract receiving your funds is malicious and _designed to deliberately fail_. We'll walk through an attack scenario like this in a future video. But for now, know that when you send funds, it might fail, and you need to deal with that.

### Withdrawing funds from the bank

Now let's withdraw these funds. Let's start with two rules:

1.  You have to withdraw all of your funds, that is, no partial withdrawals right now. And
2.  An address can only withdraw their own funds

Here is a buggy and wrong way to do this:

      function withdraw() {
        // DON'T DO THIS
        msg.sender.send(balances[msg.sender]);
        balances[msg.sender] = 0;
      }

What's wrong with this code?

Well, the problem is that we're sending the funds, and then clearing the balance, without checking to see if the `.send` succeeded.  

One failure scenario here is that the send fails because the receiving contract runs out of gas. Then we set their balance to zero, but the Ether wasn't transferred! In this case, we'd unfairly clear their balance, but keep their Ether in the bank.

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Million Ether Homepage

WELCOMEIntroduction

Introduction:

Start Here

Module 1: Getting Started

Lesson 1: (3:23)

Million Ether Homepage

Lesson 2: (3:18)

Storing Colors in a Pixel Grid

Lesson 3: (4:29)

Million Ether Page Essential Smart Contract

Lesson 4: (1:56)

Tip: Mining only when there are transactions

Lesson 5: (7:08)

Tip: Using Remix IDE

Module 2: Viewing Pixels

Lesson 1: (6:08)

Getting The Pixels and Ethereum Events

Lesson 2: (7:15)

Gas

Lesson 3: (1:01)

Building a DApp UI

Lesson 4: (3:09)

Drawing in HTML Canvas

Lesson 5: (1:15)

Using Websockets with Web3

Lesson 6: (3:09)

Web3 and Events Over WebSockets

Lesson 7: (3:41)

Drawing Pixels from the Blockchain

Module 3: Buying Pixels

Lesson 1: (1:57)

Buying An Image -- Reading Pixels

Lesson 2: (4:51)

Buying An Image -- Sending Transactions

Lesson 3: (1:25)

Pixel bidding and structs

Lesson 4: (2:48)

Payable Contracts, payable Functions

Lesson 5: (3:35)

Contract Owner and require

Lesson 6: (2:38)

Payable color pixel function

Module 4: Auctioning Pixels

Lesson 1: (4:03)

Sending funds from a contract

Lesson 2: (3:26)

The safer way to send funds from a contract

Lesson 3: (4:37)

The Pull Payment Pattern - Withdraw payments when outbid

Lesson 4: (6:46)

Million Ether Homepage Summary

The safer way to send funds from a contract