Timelock pattern in Blockchain / Solidity - Mini Project: Build & Apply

Timelock Pattern in Smart Contracts

📖 Scenario: You are building a simple smart contract on Ethereum that holds funds and only allows withdrawal after a certain time has passed. This is called a timelock pattern, which helps secure funds by delaying access.

🎯 Goal: Create a Solidity contract that stores an amount and a release time. The contract should only allow withdrawal of funds after the release time has passed.

📋 What You'll Learn

Create a releaseTime variable to store the unlock timestamp

Create a depositor address variable to store who deposited the funds

Write a constructor that sets releaseTime and depositor

Write a withdraw function that allows withdrawal only if the current time is after releaseTime

Use block.timestamp to check the current time

💡 Why This Matters

🌍 Real World

Timelock contracts are used to secure funds by delaying access, useful in decentralized finance (DeFi) and governance to prevent immediate fund withdrawal.

💼 Career

Understanding timelock patterns is important for blockchain developers working on secure smart contracts and DeFi applications.

1

Create the contract and state variables

Create a Solidity contract named Timelock with two public state variables: uint256 releaseTime and address depositor.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Timelock {
    // Your code here
}

Hint

Use uint256 public releaseTime; and address public depositor; inside the contract.

2

Add the constructor to set release time and depositor

Add a constructor to Timelock that takes uint256 _releaseTime as input and sets releaseTime = _releaseTime and depositor = msg.sender.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Timelock {
    uint256 public releaseTime;
    address public depositor;

    // Add constructor here
    // Your code here
}

Hint

The constructor sets releaseTime from the input and depositor to the sender.

3

Add the withdraw function with timelock check

Add a public function withdraw that allows the depositor to withdraw funds only if block.timestamp >= releaseTime. Use require to enforce this and transfer the contract balance to depositor.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Timelock {
    uint256 public releaseTime;
    address public depositor;

    constructor(uint256 _releaseTime) {
        releaseTime = _releaseTime;
        depositor = msg.sender;
    }

    // Add withdraw function here
    // Your code here
}

Hint

Use require to check sender and time, then transfer balance.

4

Add a receive function and test withdrawal

Add a receive external payable function to accept funds. Then add a withdraw call after the release time to test the contract. Print "Withdrawal successful" after withdrawal.

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Timelock {
    uint256 public releaseTime;
    address public depositor;

    constructor(uint256 _releaseTime) {
        releaseTime = _releaseTime;
        depositor = msg.sender;
    }

    function withdraw() public {
        require(msg.sender == depositor, "Only depositor can withdraw");
        require(block.timestamp >= releaseTime, "Current time is before release time");
        payable(depositor).transfer(address(this).balance);
    }

    // Add receive function here
    // Your code here
}

Hint

Add receive() external payable {} to accept funds.

Practice

1.

What is the main purpose of the Timelock pattern in blockchain smart contracts?

easy

A. To delay certain actions until a specific time has passed

B. To speed up transaction processing

C. To encrypt user data

D. To reduce gas fees

Solution

1. Step 1: Understand the Timelock pattern concept

   The Timelock pattern is designed to delay actions in smart contracts until a set time has passed.

2. Step 2: Identify the purpose of the delay

   This delay helps protect users by preventing instant changes that could be harmful or unexpected.

3. Final Answer:

   To delay certain actions until a specific time has passed -> Option A

4. Quick Check:

   Timelock pattern = delay actions [OK]

Hint: Timelock means waiting before action happens [OK]

Common Mistakes:

• Thinking it speeds up transactions
• Confusing with encryption
• Assuming it lowers gas fees

2.

Which of the following Solidity code snippets correctly enforces a timelock using block.timestamp?

function execute() public {
  require(__________, "Too early to execute");
  // action code
}

easy

A. block.timestamp >= unlockTime

B. block.timestamp < unlockTime

C. block.number >= unlockTime

D. block.difficulty > unlockTime

Solution

1. Step 1: Understand the condition for timelock

   The action should only execute if the current time is equal or after the unlock time.

2. Step 2: Choose the correct comparison

   Using block.timestamp >= unlockTime ensures the function runs only after the unlock time.

3. Final Answer:

   block.timestamp >= unlockTime -> Option A

4. Quick Check:

   Time check uses block.timestamp >= unlockTime [OK]

Hint: Use block.timestamp and >= for timelock checks [OK]

Common Mistakes:

• Using < instead of >=
• Using block.number instead of block.timestamp
• Using unrelated block properties

3.

What will be the output of the following Solidity function call if block.timestamp is 1650000000 and unlockTime is 1650000100?

function canExecute() public view returns (bool) {
  return block.timestamp >= unlockTime;
}

medium

A. true

B. Revert with error

C. Compilation error

D. false

Solution

1. Step 1: Compare block.timestamp and unlockTime values

   Given block.timestamp = 1650000000 and unlockTime = 1650000100, block.timestamp is less than unlockTime.

2. Step 2: Evaluate the return statement

   The expression block.timestamp >= unlockTime evaluates to false.

3. Final Answer:

   false -> Option D

4. Quick Check:

   1650000000 >= 1650000100 = false [OK]

Hint: Compare timestamps carefully for true/false output [OK]

Common Mistakes:

• Assuming >= means true when timestamp is smaller
• Confusing block.timestamp with block.number
• Expecting errors instead of boolean

4.

Identify the error in this Solidity timelock function and choose the fix:

uint256 public unlockTime;

function execute() public {
  require(block.timestamp > unlockTime, "Too early");
  // perform action
}

medium

A. Use block.number instead of block.timestamp

B. Change block.timestamp > unlockTime to block.timestamp >= unlockTime

C. Remove the require statement

D. Change unlockTime to block.timestamp

Solution

1. Step 1: Analyze the require condition

   The condition block.timestamp > unlockTime disallows execution exactly at unlockTime.

2. Step 2: Adjust condition to allow execution at unlockTime

   Changing to block.timestamp >= unlockTime allows execution starting from unlockTime.

3. Final Answer:

   Change block.timestamp > unlockTime to block.timestamp >= unlockTime -> Option B

4. Quick Check:

   Use >= to include unlockTime moment [OK]

Hint: Use >= to allow execution at unlock time [OK]

Common Mistakes:

• Using > excludes unlockTime moment
• Removing require loses protection
• Using block.number causes wrong timing

5.

You want to create a timelock contract that allows an admin to schedule a withdrawal only after 1 day from scheduling. Which approach correctly implements this?

contract Timelock {
  address public admin;
  uint256 public unlockTime;

  constructor() {
    admin = msg.sender;
  }

  function scheduleWithdrawal() public {
    require(msg.sender == admin, "Not admin");
    unlockTime = block.timestamp + 86400; // 1 day
  }

  function withdraw() public {
    require(msg.sender == admin, "Not admin");
    require(block.timestamp >= unlockTime, "Too early");
    // withdrawal logic
  }
}

hard

A. Admin cannot schedule withdrawal

B. Withdrawal can happen immediately after scheduling

C. Correctly enforces 1-day delay before withdrawal

D. unlockTime is set incorrectly causing errors

Solution

1. Step 1: Check scheduling sets unlockTime correctly

   The scheduleWithdrawal function sets unlockTime to current time plus 86400 seconds (1 day).

2. Step 2: Verify withdraw enforces timelock

   The withdraw function requires current time to be at or after unlockTime, enforcing the delay.

3. Final Answer:

   Correctly enforces 1-day delay before withdrawal -> Option C

4. Quick Check:

   UnlockTime = now + 1 day, withdraw requires >= unlockTime [OK]

Hint: Add 86400 seconds and check block.timestamp >= unlockTime [OK]

Common Mistakes:

• Not adding delay in schedule function
• Using > instead of >= in withdraw
• Not restricting functions to admin