Hashed Time-Locked Contracts (HTLCs)

Facilitating secure, trustless, and atomic transactions across different blockchains

A Hashed Time-Lock Contract (HTLC) is a type of smart contract used in blockchain and cryptocurrency transactions to facilitate atomic swaps and cross-chain trading without the need for a trusted third party. HTLCs ensure that a transaction will either be completed successfully by both parties or will be canceled, preventing either party from defrauding the other.

Key Components of HTLC

1. Hash Lock: A cryptographic hash is created from a secret value. The recipient of the payment must reveal this secret value to claim the funds.

2. Time Lock: A time limit is set, after which the funds are returned to the sender if the recipient has not revealed the secret.

Working Mechanism of HTLC

1. Initialization:

   • Party A wants to send funds to Party B. Party A generates a random secret value and hashes it to create a hash value 𝐻.

   • Party A initiates the contract by locking the funds with the hash value 𝐻 and a time lock (e.g., 24 hours).

2. Funding the Contract:

   • The funds are now locked in the contract and can only be claimed if the recipient provides the secret value corresponding to 𝐻 before the time lock expires.

3. Revealing the Secret:

   • Party B needs to provide the secret value to unlock the funds.

   • Once Party B reveals the secret value, Party A can verify it by hashing it and comparing it with 𝐻. If they match, Party A can also retrieve the secret.

4. Refund Mechanism:

   • If Party B does not reveal the secret value within the specified time frame, the contract expires, and Party A can reclaim the funds.

Using HTLC for Atomic Transactions

HTLCs are commonly used for atomic swaps, which are exchanges of cryptocurrencies between two different blockchains without an intermediary.

Example of an Atomic Swap

Assume Party A wants to swap Bitcoin (BTC) for Litecoin (LTC) with Party B.

1. Party A and Party B agree on terms: The amount of BTC and LTC to be exchanged, and the secret hash 𝐻.

2. Initiating Contracts:

   • On Bitcoin Blockchain: Party A creates an HTLC that locks BTC with the hash 𝐻 and a time lock.

   • On Litecoin Blockchain: Party B creates an HTLC that locks LTC with the same hash 𝐻 but with a shorter time lock than Party A's HTLC.

3. Claiming Funds:

   • Party A reveals the secret to claim the LTC from Party B’s HTLC on the Litecoin blockchain.

   • Party B, upon seeing the revealed secret on the Litecoin blockchain, uses it to unlock the BTC from Party A’s HTLC on the Bitcoin blockchain.

4. Fail-safe Mechanism:

   • If any party fails to reveal the secret within the specified time, the funds are refunded to their respective original owners once the time locks expire.

Benefits of HTLC

• Trustless Transactions: Neither party needs to trust the other, as the contract ensures that either both transactions occur, or none do.

• Security: The cryptographic nature of the hash lock and time lock provides security and prevents fraud.

• Cross-Chain Compatibility: HTLCs enable cross-chain transactions, allowing users to swap assets between different blockchains.

HTLC Implementation

Implementing a Hashed Time-Lock Contract (HTLC) involves creating and deploying smart contracts on the respective blockchain networks to handle the atomic swap. Here, I'll outline a general process for implementing HTLC on a blockchain like Ethereum using Solidity, and then provide a simplified example of how we could do this.

General Steps to Implement HTLC

1. Generate Secret and Hash: One party (say Alice) generates a secret and computes its hash.

2. Deploy HTLC Smart Contract: Alice deploys a smart contract that locks her funds with the hash and a time lock.

3. Deploy Counterparty HTLC: The counterparty (say Bob) deploys a similar HTLC contract on another blockchain, referencing the same hash but with a shorter time lock.

4. Fund the Contracts: Both parties send their respective cryptocurrencies to the HTLC contracts.

5. Reveal Secret to Claim Funds: The party receiving the funds reveals the secret to unlock the funds in their respective HTLC contract.

6. Retrieve Funds: The party who revealed the secret can then claim the funds from the counterparty's HTLC contract.

Example Implementation on Ethereum Using Solidity

Below is a simplified Solidity contract for HTLC on Ethereum. This example assumes that Alice wants to swap Ether with Bob for another cryptocurrency on a different blockchain.

Solidity Smart Contract

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

contract HTLC {
    address payable public sender;
    address payable public recipient;
    bytes32 public hashLock;
    uint256 public timeLock;
    bool public isClaimed;

    event Funded(uint256 amount);
    event Claimed(bytes32 secret);
    event Refunded();

    modifier onlySender() {
        require(msg.sender == sender, "Not the sender");
        _;
    }

    modifier onlyRecipient() {
        require(msg.sender == recipient, "Not the recipient");
        _;
    }

    constructor(
        address payable _recipient,
        bytes32 _hashLock,
        uint256 _timeLock
    ) payable {
        sender = payable(msg.sender);
        recipient = _recipient;
        hashLock = _hashLock;
        timeLock = block.timestamp + _timeLock;
        isClaimed = false;

        require(msg.value > 0, "No funds provided");
        emit Funded(msg.value);
    }

    function claim(bytes32 _secret) public onlyRecipient {
        require(sha256(abi.encodePacked(_secret)) == hashLock, "Invalid secret");
        require(block.timestamp < timeLock, "Time lock expired");
        require(!isClaimed, "Already claimed");

        isClaimed = true;
        recipient.transfer(address(this).balance);
        emit Claimed(_secret);
    }

    function refund() public onlySender {
        require(block.timestamp >= timeLock, "Time lock not expired");
        require(!isClaimed, "Already claimed");

        sender.transfer(address(this).balance);
        emit Refunded();
    }
}