Library contracts in Blockchain / Solidity - Step-by-Step Execution

Concept Flow - Library contracts

Define Library Contract

↓

Deploy Library

↓

Link Library Address to Main Contract

↓

Deploy Main Contract

↓

Main Contract Calls Library Functions

↓

Library Code Executes in Main Contract Context

↓

End

Library contracts are deployed once and linked to main contracts, allowing code reuse without copying, executing in the caller's context.

Execution Sample

Blockchain / Solidity

library MathLib {
  function add(uint a, uint b) internal pure returns (uint) {
    return a + b;
  }
}

contract Calculator {
  function sum(uint x, uint y) public pure returns (uint) {
    return MathLib.add(x, y);
  }
}

This code defines a library with an add function and a contract that uses it to sum two numbers.

Execution Table

Step	Action	Evaluation	Result
1	Deploy MathLib library	Library code stored on blockchain	MathLib address assigned
2	Deploy Calculator contract linked to MathLib	Calculator knows MathLib address	Calculator deployed with link
3	Call Calculator.sum(3, 4)	Calls MathLib.add(3, 4)	7 returned
4	MathLib.add executes in Calculator context	Adds 3 + 4	7 computed
5	Return result to caller	7 returned from sum	7 output
6	End	No more steps	Execution complete

💡 Execution stops after returning the sum result from the library function.

Variable Tracker

Variable	Start	After sum call	After add call	Final
a	undefined	3	3	3
b	undefined	4	4	4
result	undefined	undefined	7	7

Key Moments - 3 Insights

Why does the library code run in the main contract's context?

Because library functions are called using delegatecall, they execute with the main contract's storage and context, as shown in step 4 of the execution_table.

Does the library get deployed every time the main contract is deployed?

No, the library is deployed once separately (step 1), and the main contract links to its address (step 2), avoiding code duplication.

What happens if the library address is not linked correctly?

The main contract will fail to call the library functions, causing runtime errors or failed transactions, as linking is essential (step 2).

Visual Quiz - 3 Questions

Look at the execution_table, what is the result returned by MathLib.add at step 4?

A 7

B 3

C 4

D 0

💡 Hint

Check the 'Result' column at step 4 in the execution_table.

At which step does the Calculator contract get linked to the MathLib library?

A Step 1

B Step 3

C Step 2

D Step 5

💡 Hint

Look for the step mentioning linking in the execution_table.

If the library was not deployed first, which step would fail?

A Step 1

B Step 2

C Step 3

D Step 6

💡 Hint

Refer to the execution_table step where linking happens.

Concept Snapshot

Library contracts are reusable code blocks deployed once.
Main contracts link to libraries by address.
Library functions run in caller's context using delegatecall.
This saves gas and avoids code duplication.
Always deploy libraries before linking.

Full Transcript

Library contracts in blockchain are special contracts that hold reusable code. They are deployed once and then linked to other contracts that want to use their functions. When a main contract calls a library function, the library code runs in the main contract's context, meaning it uses the main contract's storage and environment. This is done using a special call called delegatecall. The process starts by deploying the library contract, then deploying the main contract linked to the library's address. When the main contract calls a library function, the library executes and returns the result. This approach saves space and gas because the library code is not copied into every contract. If the library is not deployed or linked correctly, calls to it will fail. The example code shows a MathLib library with an add function and a Calculator contract that uses it to sum two numbers. The execution table traces deployment, linking, calling, and returning results step by step.