Multi-chain deployment in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Multi-chain deployment

Write Smart Contract Code

↓

Compile Contract for Chain A

↓

Deploy Contract on Chain A

↓

Compile Contract for Chain B

↓

Deploy Contract on Chain B

↓

Verify Deployment on Both Chains

↓

Interact with Contracts on Multiple Chains

This flow shows writing a smart contract, compiling and deploying it separately on multiple blockchains, then interacting with each deployed contract.

Execution Sample

Blockchain / Solidity

pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 public data;
    function set(uint256 x) public {
        data = x;
    }
}

A simple smart contract storing a number, ready to be deployed on multiple chains.

Execution Table

Step	Action	Chain	Result	Notes
1	Compile contract	Chain A	ABI and Bytecode generated	Ready for deployment on Chain A
2	Deploy contract	Chain A	Contract address 0xA1B2C3	Deployment successful on Chain A
3	Compile contract	Chain B	ABI and Bytecode generated	Ready for deployment on Chain B
4	Deploy contract	Chain B	Contract address 0xD4E5F6	Deployment successful on Chain B
5	Verify deployment	Chain A	Contract verified	Contract accessible on Chain A
6	Verify deployment	Chain B	Contract verified	Contract accessible on Chain B
7	Interact with contract	Chain A	Set data to 42	Transaction confirmed on Chain A
8	Interact with contract	Chain B	Set data to 99	Transaction confirmed on Chain B
9	Read data	Chain A	42	Data stored on Chain A
10	Read data	Chain B	99	Data stored on Chain B
11	End	-	-	All steps completed successfully

💡 All contracts deployed and interacted with on multiple chains successfully.

Variable Tracker

Variable	Start	After Step 7	After Step 8	Final
data on Chain A	0	42	42	42
data on Chain B	0	0	99	99

Key Moments - 3 Insights

Why do we compile the contract separately for each chain?

Because different chains may require different bytecode formats or compiler settings, as shown in steps 1 and 3 of the execution_table.

Why are contract addresses different on each chain?

Each chain generates its own unique address upon deployment, as seen in steps 2 and 4, so addresses differ even for the same contract code.

Does changing data on one chain affect the other chain?

No, data changes on one chain do not affect the other, as shown by different 'data' values in variable_tracker after steps 7 and 8.

Visual Quiz - 3 Questions

Look at the execution_table, what is the contract address after deployment on Chain B?

A 0xD4E5F6

B 0xA1B2C3

C 0x123456

D 0x000000

💡 Hint

Check step 4 in the execution_table for Chain B deployment address.

At which step does the data on Chain A get set to 42?

A Step 6

B Step 7

C Step 8

D Step 9

💡 Hint

Look at the action and result columns in execution_table step 7.

If we did not compile separately for each chain, what would likely happen?

A Deployment would succeed on both chains without issues.

B Contract addresses would be the same on both chains.

C Deployment might fail or produce incompatible bytecode on some chains.

D Data would automatically sync between chains.

💡 Hint

Refer to key_moments about compiling separately and execution_table steps 1 and 3.

Concept Snapshot

Multi-chain deployment means deploying the same smart contract code on different blockchains.
Each chain requires compiling and deploying separately.
Contract addresses differ per chain.
State and data are independent on each chain.
Interaction with contracts happens per chain.
Useful for wider reach and redundancy.

Full Transcript

Multi-chain deployment involves writing a smart contract and then compiling and deploying it on multiple blockchains separately. Each blockchain requires its own compilation step to generate compatible bytecode. After deployment, each chain assigns a unique contract address. The contract's state on one chain does not affect the other chains. Interaction with the contract, such as setting or reading data, happens independently on each chain. This approach allows the same contract logic to run on different blockchains, increasing availability and reach.

Practice

1.

What is the main benefit of multi-chain deployment in blockchain apps?

easy

A. It allows the app to run on multiple blockchains to reach more users.

B. It makes the app run faster on a single blockchain.

C. It reduces the app's code size significantly.

D. It guarantees zero transaction fees on all blockchains.

Solution

1. Step 1: Understand multi-chain deployment purpose

   Multi-chain deployment means putting your app on many blockchains.

2. Step 2: Identify the main benefit

   This helps reach more users and keeps the app working if one chain has issues.

3. Final Answer:

   It allows the app to run on multiple blockchains to reach more users. -> Option A

4. Quick Check:

   Multi-chain deployment = reach more users [OK]

Hint: Multi-chain means many blockchains, so more users [OK]

Common Mistakes:

• Thinking it only speeds up the app
• Believing it reduces code size
• Assuming it removes all fees

2.

Which of the following is the correct way to specify multiple blockchain networks in a deployment config file?

{
  "networks": ["ethereum", "polygon", "binance"]
}

easy

A. { "networks": ["ethereum", "polygon", "binance"] }

B. { networks = [ethereum, polygon, binance] }

C. { networks: (ethereum, polygon, binance) }

D. { "networks": "ethereum, polygon, binance" }

Solution

1. Step 1: Recognize JSON array syntax

   JSON arrays use square brackets [] with comma-separated strings in quotes.

2. Step 2: Match correct syntax

   { "networks": ["ethereum", "polygon", "binance"] } correctly uses ["ethereum", "polygon", "binance"] as an array of strings.

3. Final Answer:

   { "networks": ["ethereum", "polygon", "binance"] } -> Option A

4. Quick Check:

   JSON arrays use [] with quoted strings [OK]

Hint: JSON arrays use square brackets and quotes for strings [OK]

Common Mistakes:

• Using parentheses instead of brackets
• Missing quotes around strings
• Using equals sign instead of colon

3.

Consider this simplified deployment script snippet for multi-chain:

const chains = ["eth", "bsc"];
for (const chain of chains) {
  deployContract(chain);
}

function deployContract(chain) {
  console.log(`Deploying on ${chain}`);
}

What will be the output when this code runs?

medium

A. Deploying on eth,bsc

B. Deploying on eth\nDeploying on bsc

C. Deploying on chains

D. Error: deployContract is not defined

Solution

1. Step 1: Understand the loop over chains array

   The for loop runs twice: once with 'eth', once with 'bsc'.

2. Step 2: Check deployContract output

   Each call prints 'Deploying on ' plus the chain name.

3. Final Answer:

   Deploying on eth\nDeploying on bsc -> Option B

4. Quick Check:

   Loop prints each chain name separately [OK]

Hint: Loop prints each chain separately with deployContract [OK]

Common Mistakes:

• Thinking it prints the whole array as one string
• Expecting an error due to function scope
• Confusing variable names

4.

Find the error in this multi-chain deployment snippet:

const chains = ["eth", "polygon"];
chains.forEach(chain => {
  deploy(chain);
});

function deploy(network) {
  console.log("Deploying to " + network);
}

medium

A. The deploy function name conflicts with a reserved word.

B. The forEach method is not valid on arrays.

C. There is no error; the code runs correctly.

D. The function deploy is called before it is defined.

Solution

1. Step 1: Check function hoisting in JavaScript

   Function declarations are hoisted, so deploy can be called before definition.

2. Step 2: Verify forEach usage

   forEach is valid on arrays and used correctly here.

3. Final Answer:

   There is no error; the code runs correctly. -> Option C

4. Quick Check:

   Function hoisting and forEach usage are correct [OK]

Hint: Function declarations are hoisted; forEach works on arrays [OK]

Common Mistakes:

• Thinking function must be defined before use
• Believing forEach is invalid on arrays
• Assuming deploy is a reserved word

5.

You want to deploy a smart contract on Ethereum, Polygon, and Binance Smart Chain using a script. Which approach best ensures your deployment is safe and works on all chains?

1. Use test networks for each chain first.
2. Deploy directly to mainnets without testing.
3. Write separate scripts for each chain with no shared code.
4. Ignore chain-specific gas fees and settings.

hard

A. Ignore gas fees and settings; they are the same everywhere.

B. Deploy directly to mainnets to save time.

C. Write separate scripts for each chain without sharing code.

D. Use test networks for each chain first to verify deployment.

Solution

1. Step 1: Understand importance of test networks

   Test networks simulate real chains safely to catch errors before mainnet deployment.

2. Step 2: Evaluate deployment best practices

   Deploying directly risks loss; ignoring gas fees causes failures; separate scripts increase errors.

3. Final Answer:

   Use test networks for each chain first to verify deployment. -> Option D

4. Quick Check:

   Testing on testnets ensures safe multi-chain deployment [OK]

Hint: Always test on testnets before mainnet deployment [OK]

Common Mistakes:

• Skipping tests and deploying directly
• Ignoring chain-specific settings
• Duplicating code unnecessarily