First smart contract deployment in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - First smart contract deployment

Write Smart Contract Code

↓

Compile Contract to Bytecode

↓

Connect to Blockchain Network

↓

Create Deployment Transaction

↓

Send Transaction to Network

↓

Wait for Transaction Confirmation

↓

Contract Deployed with Address

↓

Use Contract

This flow shows the steps from writing a smart contract to deploying it on the blockchain and getting its address.

Execution Sample

Blockchain / Solidity

pragma solidity ^0.8.0;

contract HelloWorld {
    string public message = "Hello, Blockchain!";
}

This simple smart contract stores a message string that can be read publicly.

Execution Table

Step	Action	Details	Result
1	Write Contract Code	Define contract with message variable	Contract source code ready
2	Compile Contract	Convert Solidity code to bytecode	Bytecode and ABI generated
3	Connect to Network	Use wallet or provider to connect	Connected to blockchain network
4	Create Deployment Tx	Prepare transaction with bytecode	Deployment transaction created
5	Send Transaction	Send deployment tx to network	Transaction hash received
6	Wait Confirmation	Wait for block inclusion	Transaction mined, contract address assigned
7	Contract Deployed	Contract address available	Contract ready to interact
8	Use Contract	Call contract functions	Read message: 'Hello, Blockchain!'

💡 Contract deployed successfully with an address after transaction confirmation.

Variable Tracker

Variable	Start	After Step 2	After Step 5	After Step 6	Final
contractCode	Solidity source code	Compiled bytecode	Bytecode in transaction	Transaction mined	Deployed contract address
transactionHash	None	None	0xabc123...	0xabc123...	0xabc123...
contractAddress	None	None	None	0xdef456...	0xdef456...

Key Moments - 3 Insights

Why do we need to compile the contract before deployment?

Because the blockchain understands bytecode, not Solidity code. Step 2 shows compilation turning code into bytecode.

What does waiting for transaction confirmation mean?

It means waiting for the network to include the deployment transaction in a block, as shown in Step 6.

How do we know the contract is deployed?

When the transaction is mined and a contract address is assigned, as shown in Step 7.

Visual Quiz - 3 Questions

Look at the execution table, what is the result after Step 4?

A Transaction mined, contract address assigned

B Contract source code ready

C Deployment transaction created

D Bytecode and ABI generated

💡 Hint

Check the 'Result' column for Step 4 in the execution table.

At which step does the contract address become available?

A Step 7

B Step 6

C Step 5

D Step 8

💡 Hint

Look at the 'Details' and 'Result' columns for when the contract address is assigned.

If the transaction is never confirmed, what happens to the contract address variable?

A It gets assigned immediately

B It remains None

C It changes to the transaction hash

D It becomes the bytecode

💡 Hint

Refer to variable_tracker for 'contractAddress' before and after Step 6.

Concept Snapshot

First smart contract deployment steps:
1. Write Solidity code
2. Compile to bytecode
3. Connect to blockchain
4. Create deployment transaction
5. Send and wait for confirmation
6. Get contract address and interact

Full Transcript

Deploying a smart contract starts by writing the contract code in Solidity. Then, the code is compiled into bytecode that the blockchain understands. Next, you connect to the blockchain network using a wallet or provider. After that, you create a deployment transaction containing the bytecode and send it to the network. You wait for the transaction to be confirmed in a block. Once confirmed, the blockchain assigns a contract address. Finally, you can use this address to interact with the deployed contract.

Practice

1. What does deploying a smart contract mean in blockchain?

easy

A. Testing the contract on a local computer only

B. Making the contract code live and usable on the blockchain

C. Writing the contract code in a text editor

D. Deleting the contract from the blockchain

Solution

1. Step 1: Understand deployment meaning

   Deployment means putting the contract code on the blockchain so it can run.

2. Step 2: Differentiate from writing and testing

   Writing is coding, testing is checking locally or on test networks, deployment is live on blockchain.

3. Final Answer:

   Making the contract code live and usable on the blockchain -> Option B

4. Quick Check:

   Deploy = live on blockchain [OK]

Hint: Deployment means contract is live on blockchain [OK]

Common Mistakes:

• Confusing deployment with just writing code
• Thinking testing is deployment
• Believing deployment deletes contracts

2. Which of the following is the correct Solidity syntax to start a simple contract named MyContract?

easy

A. contract MyContract { }

B. class MyContract { }

C. function MyContract() { }

D. contract = MyContract()

Solution

1. Step 1: Recall Solidity contract declaration

   Solidity uses the keyword contract followed by the contract name and braces.

2. Step 2: Check each option's syntax

   contract MyContract { } matches Solidity syntax; others use wrong keywords or formats.

3. Final Answer:

   contract MyContract { } -> Option A

4. Quick Check:

   Solidity contract starts with 'contract' keyword [OK]

Hint: Solidity contracts start with 'contract' keyword [OK]

Common Mistakes:

• Using 'class' instead of 'contract'
• Writing function instead of contract
• Assigning contract like a variable

3. Given this Solidity contract snippet deployed on a test network:

contract Counter {
  uint count = 0;
  function increment() public {
    count += 1;
  }
  function getCount() public view returns (uint) {
    return count;
  }
}

If you call increment() twice and then getCount(), what is the output?

medium

A. 0

B. 1

C. 2

D. Error: function not found

Solution

1. Step 1: Understand contract state changes

   Each call to increment() adds 1 to count, starting from 0.

2. Step 2: Calculate after two increments

   After two calls, count becomes 2. getCount() returns this value.

3. Final Answer:

   2 -> Option C

4. Quick Check:

   2 increments = count 2 [OK]

Hint: Each increment adds 1; two increments mean count is 2 [OK]

Common Mistakes:

• Forgetting state changes persist on blockchain
• Assuming count resets each call
• Confusing function names

4. You try to deploy this Solidity contract but get a syntax error:

contract Simple {
  uint number
  function setNumber(uint num) public {
    number = num;
  }
}

What is the cause of the error?

medium

A. Missing return type in function

B. Function setNumber must be private

C. Contract name must be lowercase

D. Missing semicolon after uint number

Solution

1. Step 1: Check Solidity syntax rules

   Variable declarations require a semicolon at the end.

2. Step 2: Identify missing semicolon

   uint number line misses a semicolon, causing syntax error.

3. Final Answer:

   Missing semicolon after uint number -> Option D

4. Quick Check:

   Missing semicolon = syntax error [OK]

Hint: Check semicolons after variable declarations [OK]

Common Mistakes:

• Thinking function visibility causes syntax error
• Believing contract names must be lowercase
• Expecting return type for void functions

5. You want to deploy a smart contract that stores user names and their balances. Which approach is best to deploy and test it safely before using real money?

hard

A. Deploy on a test network like Ropsten or Goerli first

B. Deploy directly on the main Ethereum network

C. Write the contract but never deploy it

D. Deploy on a private computer without blockchain

Solution

1. Step 1: Understand deployment environments

   Mainnet uses real money; testnets simulate blockchain without real cost.

2. Step 2: Choose safe testing method

   Deploying on testnets like Ropsten or Goerli lets you test without risking real funds.

3. Final Answer:

   Deploy on a test network like Ropsten or Goerli first -> Option A

4. Quick Check:

   Testnet deployment = safe testing [OK]

Hint: Use test networks to avoid losing real money [OK]

Common Mistakes:

• Deploying directly on mainnet without testing
• Not deploying at all and missing testing
• Using private computer without blockchain for deployment