first deploy

.env.example

@@ -0,0 +1,5 @@
+PRIVATE_KEY=[YOUR_PRIVATE_KEY]
+ETHERSCAN_API_KEY=[YOUR_API_KEY]
+MAINNET_URL=https://mainnet.infura.io/v3/<YOUR_KEY>
+GOERLI_URL=https://eth-goerli.g.alchemy.com/v2/<YOUR_KEY>
+SEPOLIA_URL=https://eth-sepolia.g.alchemy.com/v2/<YOUR_KEY>

README.md

@@ -1 +1,5 @@
-# zkAMM-contracts
+# zkAMM-contracts
+
+Token0 0x1b3631A99A69275bC7E3b539FeD4DaAFaDDfe1B0
+Token1 0x7aBF19CE8696A1D8945F9125758EbCe2F6F0Fd91
+ZkAmmPair 0x94aD21Bf72F0f4ab545E59ea3d5C1F863d74C629

contracts/ZkAmmPair.sol

@@ -8,7 +8,7 @@ import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 contract ZkAmmPair is IZkAmmPair, ERC20 {
     address public immutable token0;
     address public immutable token1;
-    address public immutable zkGraph;
+    address public zkGraph;
 
     uint public reserve0;
     uint public reserve1;
@@ -18,10 +18,14 @@ contract ZkAmmPair is IZkAmmPair, ERC20 {
         _;
     }
 
-    constructor(address tokenA, address tokenB, address zkGraph_) ERC20("ZK AMM", "ZK-AMM") {
+    constructor(address tokenA, address tokenB) ERC20("ZK AMM", "ZK-AMM") {
         require(tokenA != tokenB, 'IDENTICAL_ADDRESSES');
         (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
-        zkGraph = zkGraph_;
+    }
+
+    function setGraph(address graph) external override {
+        require(graph != address(0), "zero address");
+        zkGraph = graph;
     }
 
     function addInitLiquidity(

contracts/interfaces/IZkAmmPair.sol

@@ -16,6 +16,8 @@ interface IZkAmmPair {
     function reserve0() external view returns (uint);
     function reserve1() external view returns (uint);
 
+    function setGraph(address graph) external;
+
     function addInitLiquidity(
         address recipient, 
         uint amount0, 

contracts/test/MockToken.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.9;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract MockToken is ERC20 {
+    constructor(string memory name_, string memory symbol_) ERC20(name_, symbol_) {}
+
+    function mint(address to, uint256 amount) external {
+        _mint(to, amount);
+    }
+}

hardhat.config.ts

@@ -1,8 +1,33 @@
 import { HardhatUserConfig } from "hardhat/config";
 import "@nomicfoundation/hardhat-toolbox";
+import dotenv from "dotenv";
+dotenv.config();
+
+const PRIVATE_KEY = process.env.PRIVATE_KEY;
 
 const config: HardhatUserConfig = {
-  solidity: "0.8.19",
+  solidity: {
+    compilers: [
+      {
+        version: "0.8.18",
+        settings: {
+          optimizer: {
+            enabled: true,
+            runs: 200,
+          },
+        },
+      },
+    ],
+  },
+  networks: {
+    sepolia: {
+      url: process.env.SEPOLIA_URL,
+      accounts: [`${PRIVATE_KEY}`],
+    },
+  },
+  etherscan: {
+    apiKey: process.env.ETHERSCAN_API_KEY,
+  },
 };
 
 export default config;

package.json

@@ -11,6 +11,7 @@
   "devDependencies": {
     "@nomicfoundation/hardhat-toolbox": "^3.0.0",
     "@openzeppelin/contracts": "4.9.3",
-    "hardhat": "^2.17.2"
+    "hardhat": "^2.17.2",
+    "dotenv": "^16.0.3"
   }
 }

scripts/deploy.ts

@@ -1,22 +1,49 @@
 import { ethers } from "hardhat";
 
 async function main() {
-  const currentTimestampInSeconds = Math.round(Date.now() / 1000);
-  const unlockTime = currentTimestampInSeconds + 60;
+  const verifyStr = "npx hardhat verify --network";
 
-  const lockedAmount = ethers.parseEther("0.001");
+  const MockToken = await ethers.getContractFactory("MockToken");
 
-  const lock = await ethers.deployContract("Lock", [unlockTime], {
-    value: lockedAmount,
-  });
+  const tokenA = await MockToken.deploy("MockWBTC", "WBTC");
+  const addressTokenA = await tokenA.getAddress();
+  console.log("TokenA", addressTokenA);
+  console.log(
+    verifyStr,
+    process.env.HARDHAT_NETWORK,
+    addressTokenA,
+    "MockWBTC",
+    "WBTC"
+  );
 
-  await lock.waitForDeployment();
+  const tokenB = await MockToken.deploy("MockWETH", "WETH");
+  const addressTokenB = await tokenB.getAddress();
+  console.log("TokenB", addressTokenB);
+  console.log(
+    verifyStr,
+    process.env.HARDHAT_NETWORK,
+    addressTokenB,
+    "MockWETH",
+    "WETH"
+  );
 
+  const ZkAmmPair = await ethers.getContractFactory("ZkAmmPair");
+  const pair = await ZkAmmPair.deploy(addressTokenA, addressTokenB);
+  const pairAddress = await pair.getAddress();
+  console.log("ZkAmmPair", pairAddress);
   console.log(
-    `Lock with ${ethers.formatEther(
-      lockedAmount
-    )}ETH and unlock timestamp ${unlockTime} deployed to ${lock.target}`
+    verifyStr,
+    process.env.HARDHAT_NETWORK,
+    pairAddress,
+    addressTokenA,
+    addressTokenB
   );
+
+  // set zkGraph
+  // const zkGraph = "";
+  // const pairAddress = ""
+  // const pair = await ethers.getContractAt("ZkAmmPair", pairAddress);
+  // await pair.setGraph(zkGraph);
 }
 
 // We recommend this pattern to be able to use async/await everywhere