Skip to main content

​
Contract architecture

Tron uses EVM-compatible smart contracts for atomic swaps. The implementation is identical to the EVM guide, but currently only supports TRC20 tokens (native TRX is not supported yet).
Garden uses Hashed Time Lock Contracts (HTLCs) to implement atomic swap functionality on Tron. The contract manages the lifecycle of a swap through four main operations with enhanced signature support and flexible initiation methods:

Initiate

Redeem

Refund

Instant refund

​
Core functions

​
Initiate

The initiate function creates a new HTLC by locking TRC20 tokens in the contract:

​
Basic initiation

function initiate(
    address redeemer,
    uint256 timelock,
    uint256 amount,
    bytes32 secretHash
) external

​
Initiation on behalf

function initiateOnBehalf(
    address initiator,
    address redeemer,
    uint256 timelock,
    uint256 amount,
    bytes32 secretHash
) external

​
Signature-based initiation

function initiateWithSignature(
    address initiator,
    address redeemer,
    uint256 timelock,
    uint256 amount,
    bytes32 secretHash,
    bytes calldata signature
) external
Uses EIP712 signatures for off-chain authorization, enabling gasless transactions where authorized third parties can initiate swaps on behalf of users.

​
Redeem

The redeem function allows the redeemer to claim the locked TRC20 tokens by providing the secret that hashes to the stored secret hash. 
function redeem(
    bytes32 orderID,
    bytes calldata secret
) external
The secret must hash to the exact value stored during initiation using SHA256. Once revealed, this secret enables the counterparty to claim funds on the other chain. No signature required - anyone can execute if they know the secret.

​
Refund

The refund function allows the initiator to reclaim their TRC20 tokens after the timelock has expired and the redeemer has not claimed the funds. 
function refund(bytes32 orderID) external
Uses absolute block numbers for timelock, which provides predictable settlement windows based on consistent block production times.

​
Instant refund

The instant refund function provides a way for the redeemer to consent to canceling the swap before the timelock expires using EIP712 signatures. 
function instantRefund(
    bytes32 orderID,
    bytes calldata signature
) external
This requires the redeemer’s EIP712 signature to prevent unauthorized instant refunds. This ensures mutual consent before the settlement window expires.

​
Tron-specific features

​
Order state management

The contract uses a struct to store swap state: 
struct Order {
    address initiator;
    address redeemer;
    uint256 initiatedAt;
    uint256 timelock;
    uint256 amount;
    uint256 fulfilledAt;
}

​
Token handling

TRC20 implementation:
  • Uses SafeERC20 for secure token transfers.
  • Requires token approval before initiation.
  • Transfers tokens via transferFrom and transfer.
Native TRX transfers are not currently supported. Only TRC20 tokens can be used for atomic swaps on Tron.

​
EIP712 signature support

The contract implements EIP712 for secure off-chain message signing: 
bytes32 private constant _REFUND_TYPEHASH = keccak256("Refund(bytes32 orderId)");

function instantRefundDigest(bytes32 orderID) public view returns (bytes32) {
    return _hashTypedDataV4(keccak256(abi.encode(_REFUND_TYPEHASH, orderID)));
}

​
Event logging

The contract emits events for each state transition to enable efficient off-chain monitoring: 
event Initiated(bytes32 indexed orderID);
event Redeemed(bytes32 indexed orderID, bytes secret);
event Refunded(bytes32 indexed orderID);

​
Order ID generation

Unique order identifiers are generated using SHA256 hashing with chain-specific parameters: 
bytes32 orderID = sha256(abi.encode(
    block.chainid, 
    secretHash, 
    initiator, 
    redeemer, 
    timelock, 
    amount
));
Chain ID inclusion prevents cross-chain replay attacks, while the parameter combination ensures each order is uniquely identifiable across the network.