Hybrid dApps

Hybrid dApps are applications that run their core logic on TAC’s EVM Layer while providing a completely native experience for TON users. Unlike traditional cross-chain applications that require users to switch networks or manage multiple wallets, hybrid dApps feel like native TON applications while leveraging the full power of EVM’s mature ecosystem.

​

What Makes an App “Hybrid”

Traditional dApps exist entirely within one ecosystem. Hybrid dApps span two ecosystems seamlessly:

​

The Hybrid dApp Advantage

Hybrid dApps unlock a new paradigm where users and developers enjoy the strengths of both TON and EVM ecosystems—without compromise.

​

For Users: Native Experience, Expanded Capabilities

​

For Developers: Best of Both Worlds

​

Hybrid dApp Architecture

Here’s how the different components work together to create a seamless hybrid experience:

​

Development Patterns

Hybrid dApps on TAC are designed to feel native to both TON and EVM users, blending familiar interfaces with powerful cross-chain capabilities.

By leveraging TAC’s architecture, developers can build applications that seamlessly connect users, assets, and protocols across ecosystems—without compromising on user experience or security. Below are the key patterns and best practices for building truly hybrid applications.

​

Frontend Architecture

Most hybrid dApps follow a common frontend pattern:

// 1. Initialize TAC SDK
import { TacSdk, Network } from "@tonappchain/sdk";
const tacSdk = await TacSdk.create({ network: Network.TESTNET });

// 2. Connect TON wallet
import { TonConnectUI } from "@tonconnect/ui";
const tonConnect = new TonConnectUI({
  manifestUrl: "https://yourapp.com/tonconnect-manifest.json",
});

// 3. Create cross-chain transactions
const transactionLinker = await tacSdk.sendCrossChainTransaction(
  {
    evmTargetAddress: "0xYourContract",
    methodName: "yourMethod(bytes,bytes)",
    encodedParameters: encodedParams,
  },
  sender,
  assets
);

// 4. Track transaction status
const tracker = new OperationTracker(Network.TESTNET);
const status = await tracker.getOperationStatus(operationId);

​

Smart Contract Architecture

EVM-side contracts follow standard patterns with TAC-specific proxy integration:

pragma solidity ^0.8.0;

import "@tac/proxy-contracts/TacProxyV1.sol";

contract HybridDeFiProtocol is TacProxyV1 {
    constructor(address _crossChainLayer) TacProxyV1(_crossChainLayer) {}

    // This function receives cross-chain calls from TON
    function executeSwap(bytes calldata tacHeader, bytes calldata args)
        external
        _onlyCrossChainLayer
    {
        // Decode TAC header to get user info
        TacHeaderV1 memory header = _decodeTacHeader(tacHeader);

        // Decode your application-specific arguments
        SwapParams memory params = abi.decode(args, (SwapParams));

        // Execute your application logic
        performSwap(params);

        // Optionally send results back to TON
        _sendMessageV1(createReturnMessage(header, results));
    }
}

​

User Journey Example

Let’s follow a TON user interacting with a hybrid DEX:

​

Best Practices for Hybrid dApps

​

Common Challenges & Solutions

​

Ready to Build?

Hybrid dApps represent the future of cross-chain applications - combining the best of both ecosystems while hiding complexity from users.