Integrate KLAYswap V2 Seamlessly: A Comprehensive Guide for Smart Contract Developers

Integrating KLAYswap programmatically into smart contracts allows users to seamlessly buy and sell tokens within decentralized applications. This tutorial focuses on using KLAYswap V2, providing methods for swapping tokens on the Klaytn Cypress (Mainnet) network. The KLAYswap UniversalRouter provides various methods like swapExactETHForTokens, swapExactTokensForTokens, and swapExactTokensForETH to facilitate these swaps. Users must approve the router to access the specified amount of tokens before initiating a swap. This guide includes a fully working example, instructions for deploying the MiniKLAYswap contract using the thirdweb CLI, and step-by-step instructions for executing swap operations using the dashboard and Klaytnscope.

Integrating KLAYswap V2 into Smart Contracts: A Comprehensive Guide for Developers

Introduction

For developers seeking to enhance the functionality of their decentralized applications (dApps), integrating automated market maker (AMM) protocols such as KLAYswap becomes crucial. This integration enables the seamless swapping of tokens within dApps, enhancing user experience and expanding service offerings.

Understanding KLAYswap

KLAYswap is an AMM protocol designed specifically for the Klaytn network. It operates as a decentralized exchange (DEX), facilitating instant token swaps by relying on on-chain liquidity pools established by liquidity providers. Unlike traditional order book structures, KLAYswap's liquidity pools allow users to trade tokens directly with the pool, eliminating the need for counterparties.

Benefits of Integrating KLAYswap V2

Integrating KLAYswap V2 into smart contracts provides numerous advantages:

• Seamless Token Swapping: Users can conveniently swap tokens directly within your dApp without leaving the interface.
• Enhanced User Experience: By incorporating KLAYswap, you can offer users a more intuitive and efficient trading experience.
• Expanded Functionality: Integrate additional services around specific ERC20 and KIP7 tokens, such as enabling token purchases or lending.

Technical Integration Details

To programmatically integrate KLAYswap V2 into your smart contract, follow these steps:

1. Prerequisites:

• Proficiency in smart contract development.
• Familiarity with smart contract development environments (e.g., thirdweb).

2. KLAYswap Universal Router:

• Utilize the KLAYswap router to access a range of methods for secure token swapping.
• Before executing any swap method, the user must authorize the router to access the desired amount of tokens.

3. Token Swap Methods:

• swapExactETHForTokens: Swaps an exact amount of KLAY for tokens, maximizing the output tokens along the specified path.
• swapExactTokensForTokens: Swaps an exact amount of input tokens for tokens, maximizing the output tokens along the specified path.
• swapExactTokensForETH: Swaps an exact amount of tokens for ETH, maximizing the ETH output along the specified path.

4. Fully Working Example:

// Sample smart contract showcasing KLAYswap operations
pragma solidity ^0.8.20;

interface IKlaySwapRouterV2 {
    struct SwapParams {
        address to;
        address[] path;
        address[] pool;
        uint deadline;
    }
    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        SwapParams calldata params
    ) external returns (uint256[] memory amounts);
    function swapExactETHForTokens(
        uint256 amountOutMin,
        SwapParams calldata p
    ) external payable returns (uint256[] memory amounts);
    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        SwapParams calldata p
    ) external returns (uint256[] memory amounts);
}

interface IERC20 {
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
}

contract MiniKLAYSwap {
    address public constant routerAddress = 0xe0fbB27D0E7F3a397A67a9d4864D4f4DD7cF8cB9;
    address public constant MBX_TOKEN_ADDRESS = 0xD068c52d81f4409B9502dA926aCE3301cc41f623;
    address public constant sKAI_TOKEN_ADDRESS = 0x37d46C6813B121d6A27eD263AeF782081ae95434;
    address public constant WKLAY_ADDRESS = 0x19Aac5f612f524B754CA7e7c41cbFa2E981A4432;

    IKlaySwapRouterV2 public immutable swapRouter = IKlaySwapRouterV2(routerAddress);
    IERC20 public immutable MBX_TOKEN = IERC20(MBX_TOKEN_ADDRESS);
    IERC20 public immutable SKAI_TOKEN = IERC20(sKAI_TOKEN_ADDRESS);

    address[] private pool = [address(0)];
    address[] private path = [MBX_TOKEN_ADDRESS, WKLAY_ADDRESS];
    address[] private path1 = [WKLAY_ADDRESS, sKAI_TOKEN_ADDRESS];
    address[] private path2 = [sKAI_TOKEN_ADDRESS, WKLAY_ADDRESS];

    function swapExactTokensForTokens(uint256 amountIn) external returns (uint256[] memory amountOut) {
        MBX_TOKEN.transferFrom(msg.sender, address(this), amountIn);
        MBX_TOKEN.approve(address(swapRouter), amountIn);

        IKlaySwapRouterV2.SwapParams memory params = IKlaySwapRouterV2.SwapParams(
            to: msg.sender,
            path: path,
            pool: pool,
            deadline: block.timestamp
        );

        amountOut = swapRouter.swapExactTokensForTokens(amountIn, 1, params);
    }

    function swapExactKLAYForTokens() external payable returns (uint256[] memory amountOut) {
        IKlaySwapRouterV2.SwapParams memory params = IKlaySwapRouterV2.SwapParams(
            to: msg.sender,
            path: path1,
            pool: pool,
            deadline: block.timestamp
        );

        amountOut = swapRouter.swapExactETHForTokens{value: msg.value}(1, params);
    }

    function swapExactTokensForKLAY(uint256 amountIn) external returns (uint256[] memory amountOut) {
        SKAI_TOKEN.transferFrom(msg.sender, address(this), amountIn);
        SKAI_TOKEN.approve(address(swapRouter), amountIn);

        IKlaySwapRouterV2.SwapParams memory params = IKlaySwapRouterV2.SwapParams(
            to: msg.sender,
            path: path2,
            pool: pool,
            deadline: block.timestamp
        );

        amountOut = swapRouter.swapExactTokensForETH(amountIn, 1, params);
    }
}

5. Deploying MiniKLAYswap.sol using thirdweb CLI:

Utilize the thirdweb CLI to deploy the MiniKLAYswap.sol contract. Provide a project name and select your desired framework (Hardhat or Foundry). For this example, choose the Empty base contract option.

6. Performing the Swap Operation:

To execute the swap operations, navigate to the explorer tab of your deployed MiniKLAYswap contract on the thirdweb dashboard. Select the appropriate swap method (e.g., swapExactKLAYForTokens) and provide the necessary input parameters. Click 'Execute' to perform the swap.

7. Verifying the Swap Operation:

To verify the swap, paste the transaction hash into the Klaytnscope search bar. This will display the details of the transaction, including the swapped token amounts.

Conclusion

By integrating KLAYswap V2 into your smart contracts, you empower users to seamlessly swap tokens within your dApp. This enhances the user experience and opens up new possibilities for token-related services.

For further exploration and guidance, refer to the Klaytn Docs and KLAYswap Docs. If you encounter any queries, engage with the Klaytn Forum for assistance. Stay tuned for Part 2 of this tutorial, where we will delve into building a minimalistic frontend to interact with the MiniKLAYswap contract using thirdweb and Next.js.