🔌Integrating with external Defi protocols

Protect the privacy of users of any DeFi protocol by integrating Veilnyx

Introduction

The integration of Veilnyx with any DeFi protocol aims to supercharge the users of that protocol with Veilnyx's privacy and compliance features. In this integration example, we integrate Veilnyx with Uniswap, one of the leading decentralized exchange protocols offering liquidity and trading capabilities. This integration will enable users to execute trades on Uniswap while maintaining complete privacy over their transactions.

Benefits of Integrating with Uniswap

• Enhanced Privacy: Users can trade on Uniswap without exposing their wallet address.

• Selective Deanonymisation: Transactions can be decoded when necessary using a revoker and a guardian network, ensuring compliance and accountability.

• Seamless Experience: The integration ensures that users can leverage the best of both protocols without compromising on usability.

Getting Started

Prerequisites

Before integrating Veilnyx with an external DeFi protocol, ensure you have the following prerequisites in place:

• Veilnyx Protocol as Submodule: Include the Veilnyx protocol as a submodule in your project. This will provide the necessary functionalities required for the integration.

• Interface/Periphery Contracts of the Target DeFi Protocol: Obtain the interface of the periphery contracts of the DeFi protocol you are integrating with. These contracts will be essential for interacting with the protocol’s core functionalities.

• Address of the Periphery Contracts: Ensure you have the correct addresses of the periphery contracts of the DeFi protocol you're integrating with, on the deployment network (e.g., Ethereum mainnet, testnet, etc.). These addresses are crucial for interfacing with the target protocol.

• Involved Token Addresses: Identify and obtain the addresses of the tokens involved in the transactions on the deployment network. This includes both the tokens you plan to trade and any intermediary tokens required by the protocol.

With these prerequisites in place, you are ready to proceed with the installation and setup of the Veilnyx protocol. Let's go!

Installation

To integrate Veilnyx with your chosen DeFi protocol, follow these steps to install and set up the necessary tools and libraries. This guide assumes you are using Foundry and Solidity for smart contract development.

Install Foundry: Foundry is a fast, portable, and modular toolkit for Ethereum application development. Installing Foundry will also handle the installation of the Solidity compiler (solc).

curl -L https://foundry.paradigm.xyz | bash
foundryup

Install Veilnyx Protocol

Install the Veilnyx protocol using Foundry:

forge install veilnyx/v1-protocol

Create the interface of the periphery contract

Include just the interface of the periphery contract of the DeFi protocol you are integrating with in your project directory, under the interfaces folder.

We advise against including the complete DeFi protocol as a submodule, as you can run into version conflicts with the Solidity compiler and other common dependencies like OpenZeppelin.

Install OpenZeppelin Contracts

OpenZeppelin provides a library of modular, reusable, and secure smart contracts for Ethereum. Install OpenZeppelin contracts for secure ERC20-related operations.

forge install OpenZeppelin/openzeppelin-contracts

With these steps completed, your development environment is set up, and you are ready to proceed with integrating Veilnyx with your target DeFi protocol.

Transaction Flow

You will use the Veilnyx SDK to create and submit a ZTransaction Veilnyx Pool proxy contract for execution of your transaction. Here’s how your ZTransaction will flow:

Veilnyx `IAdaptor` implementation

Veilnyx offers the IAdaptor An interface for protocol devs to implement in their DeFi adaptors. This interface offers a adaptorConnect(...) function:

function adaptorConnect(
        uint24[] calldata inAssetIds,
        uint256[] calldata inValues,
        bytes calldata payload
    )
        external
        payable
        virtual
        returns (uint24[] memory outAssetIds, uint256[] memory outValues);

inAssetIds : The array of incoming asset IDs involved in the transaction.

Veilnyx offers a struct Asset to whitelist the assets you’re going to use during Veilnyx protocol initialization itself. The asset IDs used as inAssetIds and outAssetIds are returned once an asset is whitelisted during Veilnyx initialization. We will cover this in the deployment section.

inValues : The quantity of each incoming asset.

payload : Miscellaneous parameters (encoded as bytes) that your DeFi adaptor might need for the transaction to the target DeFi protocol. These are generally parameters expected by the target protocol to execute. For eg, Uniswap expects information of outToken, beneficiary, slippage protection, etc, to execute a swap, which can all be encoded in the payload params and made available to your adaptor contract by decoding it.

Here’s an implementation of the adaptorConnect(...) function of the UniswapV3 adaptor which executes a swap between WETH<>USDC tokens:

The adaptorConnect(...) is called via delegatecall by the Veilnyx::AdaptorHandler.sol, with all the required input tokens/assets already in balance. The converted assets or outputs are then returned in the same function.

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.24;

import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { AdaptorBase } from "src/base/AdaptorBase.sol";
import {Asset, AssetType} from "src/libraries/Asset.sol";
import {ISwapRouter02} from "./ISwapRouter02.sol";

contract UniswapV3Adapter is AdaptorBase {
    // Errors //
    error UnsupportedAsset(uint24 assetId);
    error MultiAssetSwap();
    error ZeroValues();
    error ZeroAddress();

    ISwapRouter02 public immutable swapRouter02; // Uniswap's Periphery contract interface
    uint24 public constant feeTier = 3000; // Uniswap variable

    constructor(address swapRouter02_, address pool_) AdaptorBase(pool_) {
        swapRouter02 = ISwapRouter02(swapRouter02_); // Uniswap V3 Swap router
    }

/// @dev Will be called by the Veilnyx AdaptorHandler.sol to execute the swap.
    function adaptorConnect(
        uint24[] calldata inAssetIds,
        uint256[] calldata inValues,
        bytes calldata payload
    )
        external
        payable
        override
        returns (uint24[] memory outAssetIds, uint256[] memory outValues)
    {
        uint256 inValue;
        // Checks
        if (inAssetIds.length != 1 || inValues.length != 1) {
            revert MultiAssetSwap();
        }

        if (inValues[0] == 0) {
            revert ZeroValues();
        } else {
            inValue = inValues[0];
            console.log("UniswapV3Adp:: inValue to swap:", inValue);
        }

        Asset memory inAsset = getAsset(inAssetIds[0]); // offered by Veilnyx::adaptorBase.sol
        if (!inAsset.isSupported) {
            revert UnsupportedAsset(inAssetIds[0]);
        }

        if (inAsset.assetAddress == address(0)) {
            revert ZeroAddress();
        }

        // decoding payload
        (uint24 outAssetId, address beneficiary, uint256 minOut) = abi.decode(
            payload,
            (uint24, address, uint256)
        );

        Asset memory outAsset = getAsset(outAssetId); // offered by Veilnyx::adaptorBase.sol
        if (!outAsset.isSupported) {
            revert UnsupportedAsset(outAssetId);
        }

        if (beneficiary == address(0)) {
            // means the out tokens will go to the Veilnyx AdaptorHandler and have to be processed to the pool
            beneficiary = address(this); // AdaptorHandler.sol
        }

        // Executing swap using UniswapV3
        uint256 tokenOutAmount = swapExactInputSingle({
            tokenIn: inAsset.assetAddress,
            tokenInAmt: inValue,
            tokenOut: outAsset.assetAddress,
            minOut: minOut,
            beneficiary: beneficiary
        });

        // initialising out arrays
        if (beneficiary == address(this)) { // address(this) > Veilnyx::AdaptorHandler.sol
            outAssetIds = new uint24[](1);
            outValues = new uint256[](1);

            outAssetIds[0] = outAssetId;
            outValues[0] = tokenOutAmount;
        } else {
            outAssetIds = new uint24[](0);
            outValues = new uint256[](0);
        }

        return (outAssetIds, outValues);
    }

    /// @param tokenIn The address of the token to be swapped
    /// @param tokenInAmt The amount of `tokenIn` tokens to swap
    /// @param tokenOut The address of the output token
    /// @param minOut The minimum amount of output token the user expects to get back. This is used for slippage protection.
    /// @param beneficiary The address which will receive the output tokens. This will be the Veilnyx Convertor.sol contract.
    function swapExactInputSingle(
        address tokenIn,
        uint256 tokenInAmt,
        address tokenOut,
        uint256 minOut,
        address beneficiary
    ) public returns (uint256 amountOut) {
        // Veilnyx convertor to approve the Uniswap adaptor the inTokens received.
        SafeERC20.forceApprove(
            IERC20(tokenIn),
            address(swapRouter02), 
            tokenInAmt
        );

        // Create the params that will be used to execute the swap
        /// @param sqrtPriceLimitX96 This is the sqrt of potential value decrease of outAsset relative to inAsset (uint160), that the trader is willing to ignore for the swap. We will be deactivating this protective measure for the MVP. We will only be deploying the slippage protection using `amountOutMinimum`
        ISwapRouter02.ExactInputSingleParams memory params = ISwapRouter02
            .ExactInputSingleParams({
                tokenIn: tokenIn,
                tokenOut: tokenOut,
                fee: feeTier,
                recipient: beneficiary,
                amountIn: tokenInAmt,
                amountOutMinimum: minOut,
                sqrtPriceLimitX96: uint160(0)
            });

        // The call to `exactInputSingle` executes the swap.
        amountOut = swapRouter02.exactInputSingle(params);
    }

Deploy

Once you’re done testing your DeFi adaptor, it’s finally time to ship!

If you’re deploying on a network which has Veilnyx and the target DeFi protocols, then you just need to deploy your newly written adaptor. Just grab the Veilnyx PoolProxy contract address, the periphery contract addresses of your target protocol and deploy your adaptor with the required addresses:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {UniswapV3Adapter} from "src/adaptors/uniswap-v3/UniswapV3Adapter.sol";

contract UniswapV3AdaptorDeploy {
    function run() external broadcast returns(UniswapV3Adapter) {
        address poolProxy = `${veilnyx_pool_proxy_address_on_target_network}`;
        address uniswapRouter02 = `${uniswapSwapRouter02_address_on_target_network};

        UniswapV3Adapter uniswapV3Adapter = new UniswapV3Adapter(uniswapRouter02, poolProxy);
        return uniswapV3Adapter;
    }
}

If either protocols are not deployed on your target network, please refer to their respective documentation to deploy the protocols on your target network before proceeding with your adaptor deployment.