add back swap to any token

examples/swap/contracts/Swap.sol

@@ -47,19 +47,28 @@ contract Swap is UniversalContract {
             params.to = recipient;
         }
 
+        swapAndWithdraw(zrc20, amount, params.target, params.to);
+    }
+
+    function swapAndWithdraw(
+        address inputToken,
+        uint256 amount,
+        address targetToken,
+        bytes memory recipient
+    ) internal {
         uint256 inputForGas;
         address gasZRC20;
         uint256 gasFee;
         uint256 swapAmount;
 
-        (gasZRC20, gasFee) = IZRC20(params.target).withdrawGasFee();
+        (gasZRC20, gasFee) = IZRC20(targetToken).withdrawGasFee();
 
-        if (gasZRC20 == zrc20) {
+        if (gasZRC20 == inputToken) {
             swapAmount = amount - gasFee;
         } else {
             inputForGas = SwapHelperLib.swapTokensForExactTokens(
                 systemContract,
-                zrc20,
+                inputToken,
                 gasFee,
                 gasZRC20,
                 amount
@@ -69,23 +78,23 @@ contract Swap is UniversalContract {
 
         uint256 outputAmount = SwapHelperLib.swapExactTokensForTokens(
             systemContract,
-            zrc20,
+            inputToken,
             swapAmount,
-            params.target,
+            targetToken,
             0
         );
 
-        if (gasZRC20 == params.target) {
+        if (gasZRC20 == targetToken) {
             IZRC20(gasZRC20).approve(address(gateway), outputAmount + gasFee);
         } else {
             IZRC20(gasZRC20).approve(address(gateway), gasFee);
-            IZRC20(params.target).approve(address(gateway), outputAmount);
+            IZRC20(targetToken).approve(address(gateway), outputAmount);
         }
 
         gateway.withdraw(
-            params.to,
+            recipient,
             outputAmount,
-            params.target,
+            targetToken,
             RevertOptions({
                 revertAddress: address(0),
                 callOnRevert: false,

examples/swap/contracts/SwapToAnyToken.sol

@@ -59,20 +59,36 @@ contract SwapToAnyToken is UniversalContract {
             params.withdraw = withdrawFlag;
         }
 
+        swapAndWithdraw(
+            zrc20,
+            amount,
+            params.target,
+            params.to,
+            params.withdraw
+        );
+    }
+
+    function swapAndWithdraw(
+        address inputToken,
+        uint256 amount,
+        address targetToken,
+        bytes memory recipient,
+        bool withdraw
+    ) internal {
         uint256 inputForGas;
         address gasZRC20;
         uint256 gasFee;
         uint256 swapAmount = amount;
 
-        if (params.withdraw) {
-            (gasZRC20, gasFee) = IZRC20(params.target).withdrawGasFee();
+        if (withdraw) {
+            (gasZRC20, gasFee) = IZRC20(targetToken).withdrawGasFee();
 
-            if (gasZRC20 == zrc20) {
+            if (gasZRC20 == inputToken) {
                 swapAmount = amount - gasFee;
             } else {
                 inputForGas = SwapHelperLib.swapTokensForExactTokens(
                     systemContract,
-                    zrc20,
+                    inputToken,
                     gasFee,
                     gasZRC20,
                     amount
@@ -83,26 +99,26 @@ contract SwapToAnyToken is UniversalContract {
 
         uint256 outputAmount = SwapHelperLib.swapExactTokensForTokens(
             systemContract,
-            zrc20,
+            inputToken,
             swapAmount,
-            params.target,
+            targetToken,
             0
         );
 
-        if (params.withdraw) {
-            if (gasZRC20 == params.target) {
+        if (withdraw) {
+            if (gasZRC20 == targetToken) {
                 IZRC20(gasZRC20).approve(
                     address(gateway),
                     outputAmount + gasFee
                 );
             } else {
                 IZRC20(gasZRC20).approve(address(gateway), gasFee);
-                IZRC20(params.target).approve(address(gateway), outputAmount);
+                IZRC20(targetToken).approve(address(gateway), outputAmount);
             }
             gateway.withdraw(
-                params.to,
+                recipient,
                 outputAmount,
-                params.target,
+                targetToken,
                 RevertOptions({
                     revertAddress: address(0),
                     callOnRevert: false,
@@ -112,12 +128,24 @@ contract SwapToAnyToken is UniversalContract {
                 })
             );
         } else {
-            IWETH9(params.target).transfer(
-                address(uint160(bytes20(params.to))),
+            IWETH9(targetToken).transfer(
+                address(uint160(bytes20(recipient))),
                 outputAmount
             );
         }
     }
 
+    function swap(
+        address inputToken,
+        uint256 amount,
+        address targetToken,
+        bytes memory recipient,
+        bool withdraw
+    ) public {
+        IZRC20(inputToken).transferFrom(msg.sender, address(this), amount);
+
+        swapAndWithdraw(inputToken, amount, targetToken, recipient, withdraw);
+    }
+
     function onRevert(RevertContext calldata revertContext) external override {}
 }

examples/swap/hardhat.config.ts

@@ -1,4 +1,5 @@
 import "./tasks/deploy";
+import "./tasks/swap";
 import "@zetachain/localnet/tasks";
 import "@nomicfoundation/hardhat-toolbox";
 import "@zetachain/toolkit/tasks";

examples/swap/tasks/swap.ts

@@ -0,0 +1,44 @@
+import { task } from "hardhat/config";
+import { HardhatRuntimeEnvironment } from "hardhat/types";
+import { parseEther } from "@ethersproject/units";
+import { ethers } from "ethers";
+import ZRC20 from "@zetachain/protocol-contracts/abi/ZRC20.sol/ZRC20.json";
+
+const main = async (args: any, hre: HardhatRuntimeEnvironment) => {
+  const [signer] = await hre.ethers.getSigners();
+
+  const factory = await hre.ethers.getContractFactory("SwapToAnyToken");
+  const contract = factory.attach(args.contract);
+
+  const amount = parseEther(args.amount);
+  const inputToken = args.inputToken;
+  const targetToken = args.targetToken;
+  const recipient = ethers.utils.arrayify(args.recipient);
+  const withdraw = JSON.parse(args.withdraw);
+
+  const zrc20 = new ethers.Contract(args.inputToken, ZRC20.abi, signer);
+  // const inputTokenContract = zrc20.attach(args.inputToken);
+
+  const approval = await zrc20.approve(args.contract, amount);
+  await approval.wait();
+
+  const tx = await contract.swap(
+    inputToken,
+    amount,
+    targetToken,
+    recipient,
+    withdraw
+  );
+
+  await tx.wait();
+  console.log(`Transaction hash: ${tx.hash}`);
+};
+
+task("swap", "Interact with the Swap contract from ZetaChain", main)
+  .addFlag("json", "Output JSON")
+  .addParam("contract", "Contract address")
+  .addParam("amount", "Token amount to send")
+  .addParam("inputToken", "Input token address")
+  .addParam("targetToken", "Target token address")
+  .addParam("recipient", "Recipient address")
+  .addParam("withdraw", "Withdraw flag (true/false)");

omnichain/swap/hardhat.config.ts

@@ -1,6 +1,7 @@
 import "./tasks/deploy";
 import "./tasks/solana/interact";
 import "./tasks/interact";
+import "./tasks/swap";
 import "@zetachain/localnet/tasks";
 import "@nomicfoundation/hardhat-toolbox";
 import "@zetachain/toolkit/tasks";