> ## Documentation Index
> Fetch the complete documentation index at: https://docs.garden.finance/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Tron

> Implement atomic swaps on Tron using EVM-compatible smart contracts for TRC20 tokens

## Contract architecture

> [!NOTE]
>
> Tron uses EVM-compatible smart contracts for atomic swaps. The implementation is identical to the [EVM guide](https://docs.garden.finance/docs/contracts/evm.md), 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:

> [card] [Initiate](#initiate)

> [card] [Redeem](#redeem)

> [card] [Refund](#refund)

> [card] [Instant refund](#instant-refund)

## Core functions

### Initiate

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

#### Basic initiation

```solidity TRC20 theme={null}
function initiate(
    address redeemer,
    uint256 timelock,
    uint256 amount,
    bytes32 secretHash
) external
```

#### Initiation on behalf

```solidity TRC20 theme={null}
function initiateOnBehalf(
    address initiator,
    address redeemer,
    uint256 timelock,
    uint256 amount,
    bytes32 secretHash
) external
```

#### Signature-based initiation

```solidity theme={null}
function initiateWithSignature(
    address initiator,
    address redeemer,
    uint256 timelock,
    uint256 amount,
    bytes32 secretHash,
    bytes calldata signature
) external
```

> [!NOTE]
>
> 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.

```solidity TRC20 theme={null}
function redeem(
    bytes32 orderID,
    bytes calldata secret
) external
```

> [!NOTE]
>
> 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.

```solidity TRC20 theme={null}
function refund(bytes32 orderID) external
```

> [!NOTE]
>
> 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.

```solidity TRC20 theme={null}
function instantRefund(
    bytes32 orderID,
    bytes calldata signature
) external
```

> [!NOTE]
>
> 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:

```solidity TRC20 theme={null}
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`.

> [!WARNING]
>
> 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:

```solidity theme={null}
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:

```solidity theme={null}
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:

```solidity theme={null}
bytes32 orderID = sha256(abi.encode(
    block.chainid, 
    secretHash, 
    initiator, 
    redeemer, 
    timelock, 
    amount
));
```

> [!TIP]
>
> Chain ID inclusion prevents cross-chain replay attacks, while the parameter combination ensures each order is uniquely identifiable across the network.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.