Initialize the contract and development environment

Author of this section: @Fish

in this talk, we will initialize the contract in the local development environment and officially start the development.

Initializing the contract

the contract development of Wtfswap continues to be based on the previous contract Local Development and Testing Environment and debugging Local Contracts with Wagmi CLI if you haven't built the local development environment, please build it based on that course.

We combine the design of the interface in the previous lecture, we add a contract/wtfswap the Directory of the initializes the contract as follows:

- contracts
  - wtfswap
    - interfaces
      - IFactory.sol
      - IPool.sol
      - IPoolManager.sol
      - IPositionManager.sol
      - ISwapRouter.sol
    - Factory.sol
    - Pool.sol
    - PoolManager.sol
    - PositionManager.sol
    - SwapRouter.sol

for each contract file, we initialize a basic shelf Pool.sol example:

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

import "./interfaces/IPool.sol";
import "./interfaces/IFactory.sol";

contract Pool is IPool {
    /// @inheritdoc IPool
    address public immutable override factory;
    /// @inheritdoc IPool
    address public immutable override token0;
    /// @inheritdoc IPool
    address public immutable override token1;
    /// @inheritdoc IPool
    uint24 public immutable override fee;
    /// @inheritdoc IPool
    int24 public immutable override tickLower;
    /// @inheritdoc IPool
    int24 public immutable override tickUpper;

    /// @inheritdoc IPool
    uint160 public override sqrtPriceX96;
    /// @inheritdoc IPool
    int24 public override tick;
    /// @inheritdoc IPool
    uint128 public override liquidity;

    // 用一个 mapping 来存放所有 Position 的信息
    mapping(address => Position) public positions;

    constructor() {
        // constructor 中初始化 immutable 的常量
        // Factory 创建 Pool 时会通 new Pool{salt: salt}() 的方式创建 Pool 合约，通过 salt 指定 Pool 的地址，这样其他地方也可以推算出 Pool 的地址
        // 参数通过读取 Factory 合约的 parameters 获取
        // 不通过构造函数传入，因为 CREATE2 会根据 initcode 计算出新地址（new_address = hash(0xFF, sender, salt, bytecode)），带上参数就不能计算出稳定的地址了
        (factory, token0, token1, tickLower, tickUpper, fee) = IFactory(
            msg.sender
        ).parameters();
    }

    function initialize(uint160 sqrtPriceX96_) external override {
        // 初始化 Pool 的 sqrtPriceX96
        sqrtPriceX96 = sqrtPriceX96_;
    }

    function mint(
        address recipient,
        uint128 amount,
        bytes calldata data
    ) external override returns (uint256 amount0, uint256 amount1) {
        // 基于 amount 计算出当前需要多少 amount0 和 amount1
        // TODO 当前先写个假的
        (amount0, amount1) = (amount / 2, amount / 2);
        // 把流动性记录到对应的 position 中
        positions[recipient].liquidity += amount;
        // 回调 mintCallback
        IMintCallback(recipient).mintCallback(amount0, amount1, data);
        // TODO 检查钱到位了没有，如果到位了对应修改相关信息
    }

    function collect(
        address recipient
    ) external override returns (uint128 amount0, uint128 amount1) {
        // 获取当前用户的 position，TODO recipient 应该改为 msg.sender
        Position storage position = positions[recipient];
        // TODO 把钱退给用户 recipient
        // 修改 position 中的信息
        position.tokensOwed0 -= amount0;
        position.tokensOwed1 -= amount1;
    }

    function burn(
        uint128 amount
    ) external override returns (uint256 amount0, uint256 amount1) {
        // 修改 positions 中的信息
        positions[msg.sender].liquidity -= amount;
        // 获取燃烧后的 amount0 和 amount1
        // TODO 当前先写个假的
        (amount0, amount1) = (amount / 2, amount / 2);
        positions[msg.sender].tokensOwed0 += amount0;
        positions[msg.sender].tokensOwed1 += amount1;
    }

    function swap(
        address recipient,
        bool zeroForOne,
        int256 amountSpecified,
        uint160 sqrtPriceLimitX96,
        bytes calldata data
    ) external override returns (int256 amount0, int256 amount1) {}
}

the code corresponding to other contracts can be referred. code view.

Execute after initialization completes npx hardhat compile compile the contract, after the contract is compiled, you can. demo-contract/artifacts directory to see the compiled product, which contains the contract ABI and other information.

Then enter the front-end project. demo directory, executing npx wagmi generate React Hooks for generating contracts (for details, please refer debugging Local Contracts with Wagmi CLI ), so that we can easily call the contract in the front-end code.

Initialize the deployment script

before combining contract Local Development and Testing Environment the content of the tutorial, we create a new ignition/modules/Wtfswap.ts file, writing the deployment script:

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

const WtfswapModule = buildModule("Wtfswap", (m) => {
  const poolManager = m.contract("PoolManager");
  const swapRouter = m.contract("SwapRouter");
  const positionManager = m.contract("PositionManager");

  return { pool, factory, poolManager, swapRouter, positionManager };
});

export default WtfswapModule;

it should be noted that, Factory contracts and Pool contracts do not need to be deployed separately, Factory is made PoolManager inheritance, deploying PoolManager that is, and Pool the contract should be on the chain. PoolManager Deployment.

By npx hardhat node start the local test chain.

Then execute npx hardhat ignition deploy ./ignition/modules/Wtfswap.ts --network localhost to deploy the contract to the local test chain, you will find the following error:

[ Wtfswap ] validation failed ⛔

The module contains futures that would fail to execute:

Wtfswap#SwapRouter:
 - IGN703: The constructor of the contract 'SwapRouter' expects 1 arguments but 0 were given

Wtfswap#PositionManager:
 - IGN703: The constructor of the contract 'PositionManager' expects 1 arguments but 0 were given

Update the invalid futures and rerun the deployment.

this is because the contract SwapRouter and PositionManager the constructor of needs to be PoolManager the contract address is a parameter. We continue to modify ignition/modules/Wtfswap.ts add the relevant logic.

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

const WtfswapModule = buildModule("Wtfswap", (m) => {
  const poolManager = m.contract("PoolManager");
-  const swapRouter = m.contract("SwapRouter");
-  const positionManager = m.contract("PositionManager");
+  const swapRouter = m.contract("SwapRouter", [poolManager]);
+  const positionManager = m.contract("PositionManager", [poolManager]);

  return { poolManager, swapRouter, positionManager };
});

export default WtfswapModule;

As shown in the code above, we will PoolManager contract as a parameter to deploy SwapRouter and PositionManager contract, specific can refer Hardhat Official Documentation .

Then re-execute the above deployment command, if it goes well you can see the following results:

contract Commissioning

in development, we need to test the logic of the contract.

We can do this by writing unit Test to test the contract, you can also run the above deployment script to deploy the contract to the Hardhat local network or test network for debugging.

The following is a reference code, you can put it in demo/pages/test.tsx next, and then visit http://localhost:3000/test to connect Hardhat local network for debugging.

import { useReadSwapRouterQuoteExactInput } from "@/utils/contracts";

import { hardhat } from "wagmi/chains";
import { WagmiWeb3ConfigProvider, Hardhat } from "@ant-design/web3-wagmi";
import { Button } from "antd";
import { createConfig, http } from "wagmi";
import { Connector, ConnectButton } from "@ant-design/web3";

const config = createConfig({
  chains: [hardhat],
  transports: {
    [hardhat.id]: http("http://127.0.0.1:8545/"),
  },
});

const CallTest = () => {
  const { data, refetch } = useReadSwapRouterQuoteExactInput({
    address: "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0",
    args: [
      {
        tokenIn: "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0",
        tokenOut: "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0",
        indexPath: [],
        amountIn: BigInt(123),
        sqrtPriceLimitX96: BigInt(123),
      },
    ],
  });
  console.log("get data", data);
  return (
    <>
      {data?.toString()}
      <Button
        onClick={() => {
          refetch();
        }}
      >
        refetch
      </Button>
    </>
  );
};

export default function Web3() {
  return (
    <WagmiWeb3ConfigProvider
      config={config}
      eip6963={{
        autoAddInjectedWallets: true,
      }}
      chains={[Hardhat]}
    >
      <Connector>
        <ConnectButton />
      </Connector>
      <CallTest />
    </WagmiWeb3ConfigProvider>
  );
}

In the code above we call SwapRouter of quoteExactInput method, you can modify the above code for debugging according to specific requirements during the development process.

Next, starting from the next lecture, we can happily carry out the development. 🎉