PART 4 : HASH LOCKING - Kalp Shah

Hash locking is the core mechanism adopted to ensure the security of off-chain transactions in blockchain technology. Leveraging cryptographic hashing algorithms, the hash locking mechanism serves as a safe way to effect conditional transfers and plays pivotal roles in many Layer 2 solutions.

HASH LOCKING

SIMPLE DEFINATION:

In simpler terms, this mechanism locks an asset or value by using a hash of a secret. This means that the transaction will only be completed if the secret corresponding to the hash is revealed. Thus, it ensures that both parties adhere to the agreed-upon conditions.

TECHNICAL DEFINATION:

Hash locking is the technique used in atomic swaps, state channels, and other Layer 2 solutions to enable secure off-chain transactions. By locking assets with the help of a cryptographic hash, the parties involved ensure that the transfer will happen only if a correct preimage (a secret) is provided.

PSUEDO CODE

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleHashLock {
    // Structure to hold lock details
    struct Lock {
        address payable sender;
        address payable receiver;
        uint256 amount;
        bytes32 hashLock;
        bool withdrawn;
        uint256 timelock;
    }

    // Mapping to store locks
    mapping(bytes32 => Lock) public locks;

    // Event for lock creation
    event Locked(address sender, address receiver, bytes32 lockId, uint256 amount);

    // Event for funds withdrawal
    event Withdrawn(address receiver, bytes32 lockId);

    // Create a new lock
    function lockFunds(address payable _receiver, bytes32 _hashLock, uint256 _timelock) external payable {
        require(msg.value > 0, "Amount must be greater than zero");
        bytes32 lockId = keccak256(abi.encodePacked(msg.sender, _receiver, _hashLock, msg.value, _timelock));
        require(locks[lockId].sender == address(0), "Lock already exists");

        locks[lockId] = Lock({
            sender: payable(msg.sender),
            receiver: _receiver,
            amount: msg.value,
            hashLock: _hashLock,
            withdrawn: false,
            timelock: block.timestamp + _timelock
        });

        emit Locked(msg.sender, _receiver, lockId, msg.value);
    }

    // Withdraw funds using the preimage
    function withdrawFunds(bytes32 _lockId, bytes32 _preimage) external {
        Lock storage lock = locks[_lockId];
        require(lock.receiver == msg.sender, "Not the receiver");
        require(!lock.withdrawn, "Already withdrawn");
        require(lock.hashLock == keccak256(abi.encodePacked(_preimage)), "Invalid preimage");

        lock.withdrawn = true;
        lock.receiver.transfer(lock.amount);

        emit Withdrawn(msg.sender, _lockId);
    }

    // Refund funds after timelock expires
    function refundFunds(bytes32 _lockId) external {
        Lock storage lock = locks[_lockId];
        require(lock.sender == msg.sender, "Not the sender");
        require(!lock.withdrawn, "Already withdrawn");
        require(block.timestamp >= lock.timelock, "Timelock not expired");

        lock.sender.transfer(lock.amount);
    }
}

HASH LOCKING MECHANISM

In the case of a standard hash lock, the protocol is always initiated by one of the parties, who first decides to generate some random secret and then calculates the hash of the secret. This hash is then given to the other party entering the contract on the terms of the transaction. This asset is locked with the hash; again, the process finalises the transaction when the original party reveals the secret.

HASH LOCKING IN STATE CHANNELS

Opening the Channel:
- Step 1: Alice and Bob open a state channel by each depositing 10 ETH into the channel’s contract on the blockchain.
Generating a New State:
- Step 2: Alice decides to send 2 ETH to Bob.
- Step 3: Alice computes the new balances (Alice: 8 ETH, Bob: 12 ETH).
Hash Locking:
- Step 4: Alice creates a hash of the new state.
- Step 5: Alice sends this hash and a secret to Bob for verification.
Verification by Bob:
- Step 6: Bob receives the hash and the secret.
- Step 7: Bob verifies the hash using the secret provided by Alice.
- Step 8: If verified, Bob acknowledges the update.
Reveal the New State:
- Step 9: Alice reveals the new state details and the secret to Bob.
Final Acceptance:
- Step 10: Bob verifies the new state using the secret.
- Step 11: If the state is as expected, Bob accepts the new state.
Closure of the Channel:
- Step 12: When ready, either Alice or Bob closes the state channel, and the final state is submitted to the blockchain for settlement.

How is the secret actually generated, and what ensures its randomness?

It is generated in the same way a secret key is produced by a secure random number generator that is truly random and unpredictable. This randomness is very important because the hash lock’s security depends on it. With a predictable or non-random secret, the chances are high that it could be bothered with or computed to breach the lock’s safety.

What if the secret is accidentally revealed or compromised?

If the secret is accidentally revealed or compromised, the security of the hash lock is at risk. An adversary possessing the secret can unlock the transaction before the expected time. This can be mitigated by the parties handling the secret securely and may also be possible by adding more security attempts, such as time locks or multi-signature schemes.

How is hash locking different from some other cryptographic tools employed in blockchain?

Aspect	Hash Locking	Digital Signatures	Multi-Signature
Purpose	Conditional transaction security	Identity verification and authentication	Authorization of transactions
Mechanism	Uses cryptographic hashes and secrets	Uses private-public key pairs	Requires multiple keys for a transaction
Use Cases	Atomic swaps, state channels	Signing transactions, smart contracts	Joint account management, escrow
Security Basis	Hash functions (e.g., SHA-256)	Asymmetric cryptography (e.g., RSA, ECDSA)	Combination of multiple keys
Challenges	Secret management, coordination	Key management, signature forgery	Coordination among key holders

Advantages / Disadvantages

Advantages of Hash Locking:

Security: It is a safe way, and cryptographic connections make sure that the transactions are completed only if the right conditions are met.
Decentralization: Not only is hash locking a trustless way, but it also minimizes the need for an intermediary and increases the level of decentralization for the blockchain ecosystem.
Efficiency: It ensures more rapid and more efficient transactions because parties can complete transactions outside the main blockchain, reducing the load on the central blockchain.

Disadvantages of Hash Locking:

Complexity: The hash locking mechanism is complex, and its implementation process requires solid cryptographic knowledge.
Coordination: It requires good coordination between two parties to ensure the right secrets are revealed and the transaction conditions are satisfied.
Scalability: Although it increases the protocol’s efficiency, it may only help with scalability issues in some situations. Other Layer 2 solutions, such as state channels and rollups, may solve this issue when connected to hash-locking mechanisms.

CONCLUSION

Hash locking is a critical mechanism in securing off-chain transactions within the blockchain ecosystem. Using cryptographic hashes, a transaction is not to be completed unless the correct conditions are met. Therefore, it makes the system very efficient and secure. That is why understanding the role and importance of hash locking is essential when digging deeper into Layer 2 solutions. We will continue our discussion on side channels and bridges to explore secure off-chain transactions further.