Intégration transparente avec KLAYswap V2 : un guide complet pour les développeurs de contrats intelligents

L'intégration programmatique de KLAYswap dans des contrats intelligents permet aux utilisateurs d'acheter et de vendre de manière transparente des jetons au sein d'applications décentralisées. Ce didacticiel se concentre sur l'utilisation de KLAYswap V2, fournissant des méthodes d'échange de jetons sur le réseau Klaytn Cypress (Mainnet). Le KLAYswap UniversalRouter fournit diverses méthodes telles que swapExactETHForTokens, swapExactTokensForTokens et swapExactTokensForETH pour faciliter ces échanges. Les utilisateurs doivent approuver le routeur pour accéder au nombre spécifié de jetons avant de lancer un échange. Ce guide comprend un exemple entièrement fonctionnel, des instructions pour déployer le contrat MiniKLAYswap à l'aide de la troisième CLI Web et des instructions étape par étape pour exécuter des opérations de swap à l'aide du tableau de bord et de Klaytnscope.

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

Intégration de KLAYswap V2 dans les contrats intelligents : un guide complet pour les développeurs

Introduction

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.

Pour les développeurs cherchant à améliorer les fonctionnalités de leurs applications décentralisées (dApps), l'intégration de protocoles de teneur de marché automatisé (AMM) tels que KLAYswap devient cruciale. Cette intégration permet l'échange transparent de jetons au sein des dApps, améliorant ainsi l'expérience utilisateur et élargissant les offres de services.

Understanding KLAYswap

Comprendre 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.

KLAYswap est un protocole AMM conçu spécifiquement pour le réseau Klaytn. Il fonctionne comme un échange décentralisé (DEX), facilitant les échanges instantanés de jetons en s'appuyant sur des pools de liquidité en chaîne établis par les fournisseurs de liquidité. Contrairement aux structures de carnet d'ordres traditionnelles, les pools de liquidités de KLAYswap permettent aux utilisateurs d'échanger des jetons directement avec le pool, éliminant ainsi le besoin de contreparties.

Benefits of Integrating KLAYswap V2

Avantages de l'intégration de KLAYswap V2

Integrating KLAYswap V2 into smart contracts provides numerous advantages:

L'intégration de KLAYswap V2 dans les contrats intelligents offre de nombreux avantages :

• 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

Échange transparent de jetons : les utilisateurs peuvent facilement échanger des jetons directement dans votre dApp sans quitter l'interface. Expérience utilisateur améliorée : en incorporant KLAYswap, vous pouvez offrir aux utilisateurs une expérience de trading plus intuitive et plus efficace. Fonctionnalité étendue : intégrez des services supplémentaires autour des jetons ERC20 et KIP7 spécifiques. , comme l'activation des achats ou des prêts de jetons.Détails techniques de l'intégration

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

Pour intégrer par programmation KLAYswap V2 dans votre contrat intelligent, suivez ces étapes :

1. Prerequisites:

1. Prérequis :

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

2. KLAYswap Universal Router:

Maîtrise du développement de contrats intelligents. Familiarité avec les environnements de développement de contrats intelligents (par exemple, ThirdWeb).2. Routeur universel KLAYswap :

• 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:

Utilisez le routeur KLAYswap pour accéder à une gamme de méthodes d'échange sécurisé de jetons. Avant d'exécuter une méthode d'échange, l'utilisateur doit autoriser le routeur à accéder à la quantité souhaitée de jetons.3. Méthodes d'échange de jetons :

• 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:

swapExactETHForTokens : échange une quantité exacte de KLAY contre des jetons, maximisant les jetons de sortie le long du chemin spécifié.swapExactTokensForTokens : échange une quantité exacte de jetons d'entrée contre des jetons, maximisant les jetons de sortie le long du chemin spécifié.swapExactTokensForETH : échange une quantité exacte de jetons contre ETH, maximisant la sortie ETH le long du chemin spécifié.4. Exemple entièrement fonctionnel :

// Sample smart contract showcasing KLAYswap operations
// Exemple de contrat intelligent présentant les opérations KLAYswap
pragma solidity ^0.8.20;
solidité du pragma ^0.8.20 ;

interface IKlaySwapRouterV2 {
interface IKlaySwapRouterV2 {
    struct SwapParams {
struct SwapParams {
        address to;
Adressé à;
        address[] path;
chemin d'adresse[] ;
        address[] pool;
pool d'adresses[] ;
        uint deadline;
date limite uint ;
    }
}
}
}

    function swapExactTokensForTokens(
fonction swapExactTokensForTokens(
        uint256 amountIn,
uint256 montantIn,
        uint256 amountOutMin,
uint256 montantOutMin,
        SwapParams calldata p
Données d'appel SwapParams p
arams
Paramètres de données d'appel SwapParams
    ) external returns (uint256[] memory amounts);
) retours externes (quantités de mémoire uint256[]) ;
    function swapExactETHForTokens(
fonction swapExactETHForTokens(
        uint256 amountOutMin,
uint256 montantOutMin,
        SwapParams calldata p
Données d'appel SwapParams p
    ) external payable returns (uint256[] memory amounts);
) retours payables externes (montants de mémoire uint256[]) ;
    function swapExactTokensForETH(
fonction swapExactTokensForETH(
        uint256 amountIn,
uint256 montantIn,
        uint256 amountOutMin,
uint256 montantOutMin,
        SwapParams calldata p
Données d'appel SwapParams p
    ) external returns (uint256[] memory amounts);
) retours externes (quantités de mémoire uint256[]) ;
}
}

interface IERC20 {
interface IERC20 {
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
fonction transferFrom (adresse de l'expéditeur, adresse du destinataire, montant uint256) retours externes (bool);
    function approve(address spender, uint256 amount) external returns (bool);
fonction approuver (adresse du dépensier, montant uint256) retours externes (bool) ;
}
}

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

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

    address[] private pool = [address(0)];
adresse[] pool privé = [adresse(0)];
    address[] private path = [MBX_TOKEN_ADDRESS, WKLAY_ADDRESS];
adresse[] chemin privé = [MBX_TOKEN_ADDRESS, WKLAY_ADDRESS] ;
    address[] private path1 = [WKLAY_ADDRESS, sKAI_TOKEN_ADDRESS];
adresse[] chemin privé1 = [WKLAY_ADDRESS, sKAI_TOKEN_ADDRESS] ;
    address[] private path2 = [sKAI_TOKEN_ADDRESS, WKLAY_ADDRESS];
adresse[] chemin privé2 = [sKAI_TOKEN_ADDRESS, WKLAY_ADDRESS] ;

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

        IKlaySwapRouterV2.SwapParams memory params = IKlaySwapRouterV2.SwapParams(
Paramètres de mémoire IKlaySwapRouterV2.SwapParams = IKlaySwapRouterV2.SwapParams (
            to: msg.sender,
à : msg.sender,
            path: path,
chemin : chemin,
            pool: pool,
piscine : piscine,
            deadline: block.timestamp
date limite : block.timestamp
        );
);

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


    function swapExactKLAYForTokens() external payable returns (uint256[] memory amountOut) {
function swapExactKLAYForTokens() retours payables externes (uint256[] montant de mémoireOut) {
        IKlaySwapRouterV2.SwapParams memory params = IKlaySwapRouterV2.SwapParams(
Paramètres de mémoire IKlaySwapRouterV2.SwapParams = IKlaySwapRouterV2.SwapParams (
            to: msg.sender,
à : msg.sender,
            path: path1,
chemin : chemin1,
            pool: pool,
piscine : piscine,
            deadline: block.timestamp
date limite : block.timestamp
        );
);

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


    function swapExactTokensForKLAY(uint256 amountIn) external returns (uint256[] memory amountOut) {
function swapExactTokensForKLAY(uint256 montantIn) renvoie externe (uint256[] mémoire montantOut) {
        SKAI_TOKEN.transferFrom(msg.sender, address(this), amountIn);
SKAI_TOKEN.transferFrom(msg.sender, adresse(this), montantIn);
        SKAI_TOKEN.approve(address(swapRouter), amountIn);
SKAI_TOKEN.approve(adresse(swapRouter), montantIn);

        IKlaySwapRouterV2.SwapParams memory params = IKlaySwapRouterV2.SwapParams(
Paramètres de mémoire IKlaySwapRouterV2.SwapParams = IKlaySwapRouterV2.SwapParams (
            to: msg.sender,
à : msg.sender,
            path: path2,
chemin : chemin2,
            pool: pool,
piscine : piscine,
            deadline: block.timestamp
date limite : block.timestamp
        );
);

        amountOut = swapRouter.swapExactTokensForETH(amountIn, 1, params);
montantOut = 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.

Utilisez la troisième CLI Web pour déployer le contrat MiniKLAYswap.sol. Fournissez un nom de projet et sélectionnez le framework souhaité (Hardhat ou Foundry). Pour cet exemple, choisissez l’option Contrat de base vide.

6. Performing the Swap Operation:

6. Exécution de l'opération d'échange :

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.

Pour exécuter les opérations d'échange, accédez à l'onglet explorateur de votre contrat MiniKLAYswap déployé sur le tableau de bord ThirdWeb. Sélectionnez la méthode d'échange appropriée (par exemple, swapExactKLAYForTokens) et fournissez les paramètres d'entrée nécessaires. Cliquez sur « Exécuter » pour effectuer l'échange.

7. Verifying the Swap Operation:

7. Vérification de l'opération d'échange :

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.

Pour vérifier l'échange, collez le hachage de transaction dans la barre de recherche Klaytnscope. Cela affichera les détails de la transaction, y compris les montants des jetons échangés.

Conclusion

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.

En intégrant KLAYswap V2 dans vos contrats intelligents, vous permettez aux utilisateurs d'échanger de manière transparente des jetons au sein de votre dApp. Cela améliore l'expérience utilisateur et ouvre de nouvelles possibilités pour les services liés aux jetons.

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.

Pour une exploration et des conseils plus approfondis, reportez-vous aux documents Klaytn et KLAYswap. Si vous rencontrez des questions, contactez le forum Klaytn pour obtenir de l'aide. Restez à l'écoute pour la partie 2 de ce didacticiel, où nous approfondirons la création d'une interface minimaliste pour interagir avec le contrat MiniKLAYswap à l'aide de Thirdweb et Next.js.