How to Fork and Launch Uniswap V3 Smart Contracts: A Practical Guide

mkdir UNISWAP-V3-FORK-SC && cd ./UNISWAP-V3-FORK-SC

# Project Initialization
npx hardhat init

# Installing Hardhat Plugins
npm install --save-dev @nomicfoundation/hardhat-ignition-ethers @nomicfoundation/hardhat-verify dotenv

# Installing Uniswap Libraries and Dependencies
npm install @uniswap/lib @uniswap/v2-core @uniswap/v3-core @uniswap/v3-periphery base64-sol

# Creating the Directory Structure
mkdir -p src/v3-core src/v3-periphery

# Cloning Uniswap V3 Repositories into Temporary Directories
git clone https://github.com/Uniswap/v3-core.git temp-v3-core
git clone https://github.com/Uniswap/v3-periphery.git temp-v3-periphery

# Copying Contracts from Temporary Directories into Our Structure
cp -r temp-v3-core/contracts/* src/v3-core/
cp -r temp-v3-periphery/contracts/* src/v3-periphery/

# Deleting Temporary Directories
rm -rf temp-v3-core temp-v3-periphery

# Creating the Multicall2 Contract
curl -o src/Multicall2.sol https://raw.githubusercontent.com/makerdao/multicall/master/src/Multicall2.sol

# Creating the WETH Contract for Testnet. For Mainnet, you’ll need to specify this address in the .env file.

curl -o src/WETH9.sol https://raw.githubusercontent.com/gnosis/canonical-weth/master/contracts/WETH9.sol

import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import "@nomicfoundation/hardhat-ignition-ethers";
import "@nomicfoundation/hardhat-verify";
import 'dotenv/config';

const PRIVATE_KEY= process.env.PRIVATE_KEY as string;

const AMOY_RPC_URL = process.env.AMOY_RPC_URL;

const POLYGON_API_KEY = process.env.POLYGON_API_KEY || '';

const config: HardhatUserConfig = {
  solidity: {
    compilers: [
      {
        version: "0.7.6",
        settings: {
          optimizer: {
            enabled: true,
            runs: 200,
            details: {
              yul: true
            }
          },
          viaIR : false,
        },
      },
      {
        version: "0.4.22"
      }
    ]
  },
  paths: {
    sources: "./src"
  },
  networks: {
    amoy: {
      url: AMOY_RPC_URL,
      accounts: [PRIVATE_KEY],
    }
  },
  etherscan: {
    apiKey: {
      amoy: POLYGON_API_KEY
    },
    customChains: [{
      network: "amoy",
      chainId: 80002,
      urls: {
        apiURL: "https://api-amoy.polygonscan.com/api",
        browserURL: "https://amoy.polygonscan.com"
      }
    }]
  }
};

export default config;

PRIVATE_KEY="deployer_private_key"

AMOY_RPC_URL="RPC_URL"

POLYGON_API_KEY="API_KEY"
WETH_ADDRESS=""

//UniswapV3.ts file

import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";
import 'dotenv/config';

export default buildModule('UniswapV3', (m) => {
  // Get the WETH address from the environment variable or deploy a new one if it's not specified
  const wethAddress = process.env.WETH_ADDRESS;
  const weth = wethAddress
    ? m.contractAt("WETH9", wethAddress)
    : m.contract("WETH9");

  // Deploy the factory
  const uniswapV3Factory = m.contract("UniswapV3Factory");

  // Deploy the swap router
  const swapRouter = m.contract("SwapRouter", [uniswapV3Factory, weth], {
    after: [weth, uniswapV3Factory],
  });

  // Deploy the library for the NFT descriptor
  const NFTDescriptor = m.library("NFTDescriptor");
  const nativeCurrencyLabelBytes = '0x46554e4e594d4f4e455900000000000000000000000000000000000000000000'; // cast format-bytes32-string "FUNNYMONEY"
  // These bytes represent the name of the network's native currency in bytes32 format.
  // "FUNNYMONEY" is a test name that should be replaced with the real currency name of your network (for example, "ETH" for Ethereum).

  // Deploy the descriptor for NFT positions
  const nonfungibleTokenPositionDescriptor = m.contract("NonfungibleTokenPositionDescriptor", [weth, nativeCurrencyLabelBytes], {
    after: [weth],
    libraries: {
      NFTDescriptor: NFTDescriptor,
    }
  });

  // Deploy the NFT position manager
  const nonfungibleTokenPositionManager = m.contract("NonfungiblePositionManager", [uniswapV3Factory, weth, nonfungibleTokenPositionDescriptor], {
    after: [uniswapV3Factory, weth, nonfungibleTokenPositionDescriptor]
  });

  // Deploy QuoterV2 for fetching quoted prices
  const quoterV2 = m.contract("QuoterV2", [uniswapV3Factory, weth], {
    after: [uniswapV3Factory, weth],
  })

  // Deploy the interface for multicalls
  const uniswapInterfaceMulticall = m.contract("UniswapInterfaceMulticall");

  // Deploy the standard Multicall2
  const multicall2 = m.contract("Multicall2");

  return {
    weth,
    uniswapV3Factory,
    swapRouter,
    nonfungibleTokenPositionDescriptor,
    nonfungibleTokenPositionManager,
    quoterV2,
    uniswapInterfaceMulticall,
    multicall2
  };
});

// computeInitCodeHash.js файл

const { ethers } = require('ethers');
const fs = require('fs');
const path = require('path');

const jsonFilePath = path.resolve(__dirname, './artifacts/src/v3-core/UniswapV3Pool.sol/UniswapV3Pool.json');

// Asynchronous function to read the ABI JSON file and compute the INIT_CODE_HASH
async function computeInitCodeHash() {
  try {
    // Reading the ABI JSON file
    const contractJson = JSON.parse(fs.readFileSync(jsonFilePath, 'utf8'));

    // Checking for the presence of bytecode in the ABI JSON file
    if (!contractJson.bytecode) {
      throw new Error('Bytecode not found in the ABI JSON file.');
    }

    // Calculating INIT_CODE_HASH using the contract's bytecode
    const computedInitCodeHash = ethers.keccak256(contractJson.bytecode);

    // Outputting the result
    console.log('INIT_CODE_HASH:', computedInitCodeHash);
    return computedInitCodeHash;
  } catch (error) {
    console.error('Error while calculating INIT_CODE_HASH:`, error);
  }
}

// Function call
computeInitCodeHash();

npx hardhat compile

PRIVATE_KEY="your_private_key"
AMOY_RPC_URL="amouy_RPC_URL"
POLYGON_API_KEY="your_api_key_polygonscan"
WETH_ADDRESS="Address_If_Mainnet"

node computeInitCodeHash.js

bytes32 internal constant POOL_INIT_CODE_HASH = GeneratedHash;

npx hardhat compile

npx hardhat ignition deploy ignition/modules/UniswapV3.ts --network amoy --deployment-id amoy --verify