punkkit-sdk 1.0.0

package/test/auction/auction.test.ts

@@ -0,0 +1,106 @@
+
+import { anyValue } from "@nomicfoundation/hardhat-chai-matchers/withArgs";
+import { getAuctionID, buildAuctionCreatedReceipt, buildAuctionCreatedTx } from "../../src/auction/serialize";
+
+
+import { expect } from "chai";
+import { ethers, network } from "hardhat";
+import { Contract, Wallet, Transaction, ContractTransaction, ContractReceipt } from "ethers";
+
+
+interface AuctionValue{
+    value: bigint;
+    salt: string;
+    hashSecret: string;
+}
+
+describe("auction", function () {
+    let chainXAuction: Contract;
+    let chainYVault:Contract;
+    let coinBase:Contract;
+
+    let owner: any;
+    let seller: any;
+    let sellerWallet: Wallet;
+    let bidder1: any;
+    let bidder2: any;
+    let configId: bigint = BigInt(0);
+    let abiCoder=new ethers.utils.AbiCoder();
+
+    let auctionValue={
+        value: BigInt(100),
+        salt:ethers.utils.hexZeroPad("0x1234", 32),
+        hashSecret: ethers.utils.solidityKeccak256(
+            ["uint256", "bytes32"],
+            [BigInt(100), ethers.utils.hexZeroPad("0x1234", 32)]
+        )
+    };
+
+    // 测试数据
+    const auctionType = 0x00000000; // 密封竞标
+    const baseAmount = ethers.utils.parseEther("1.0");
+
+    const chainXId = 31337;
+    const chainYId = 22445;
+
+    const gasPrice = ethers.utils.parseUnits("1", "gwei").toBigInt();
+    const gasLimit = BigInt(52_200);
+
+    
+
+    beforeEach(async function () {
+        [owner, bidder1, bidder2] = await ethers.getSigners();
+        seller = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
+        let sellerPk = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
+        sellerWallet = new ethers.Wallet(sellerPk);
+        
+        const coinBaseFactory=await ethers.getContractFactory("CoinBase");
+        coinBase=await coinBaseFactory.deploy();
+        await coinBase.deployed();
+
+
+        const ChainYVaultFactory=await ethers.getContractFactory("ChainYVaultV2");
+        chainYVault=await ChainYVaultFactory.deploy(coinBase.address);
+        await chainYVault.deployed();
+
+
+        const ChainXAuctionV2 = await ethers.getContractFactory("ChainXAuctionV2");
+        chainXAuction = await ChainXAuctionV2.deploy(chainYVault.address);
+        await chainXAuction.deployed();
+    });
+
+    describe("punk链(Y链) 创建拍卖配置", function () {
+
+
+        it ("创建拍卖配置",async function(){
+            configId =  await chainYVault.getActiveConfigsCount();
+            await chainYVault.createAuctionConfig(
+                auctionType,
+                baseAmount,
+                86400 // 1天的扩展时间
+            );
+        });
+
+        it ("Y链创建拍卖",async function(){
+            const expiration = Math.floor(Date.now() / 1000) + 3600; 
+            let auctionCreateTx:ContractTransaction = await chainYVault.connect(seller).createAucion(configId,auctionValue.hashSecret,expiration,{value:baseAmount})
+            let auctionCreateReceipt: ContractReceipt=await auctionCreateTx.wait();
+            const event = auctionCreateReceipt.events?.find(
+                (e: any) => e.event === "AuctionCreated"
+            );
+
+            expect(event).to.not.be.undefined;
+            const auctionId = event.args.auctionId;
+            const auction = await chainYVault.auctions(auctionId);
+            expect(auction.auctionType).to.equal(auctionType);
+            expect(auction.baseAmount).to.equal(baseAmount);
+        });
+
+        it ("X链创建拍卖",async function(){
+            const crossChainMessage=ethers.utils.defaultAbiCoder.encode(
+                ["tuple(uint256 sourceChainId, bytes rawTransaction, bytes rawRecpt)"],
+                [[chainYId, auctionCreateTx.rawTransaction, ]]
+            );
+        });
+    });
+});

package/test/connect_punk.test.ts

@@ -0,0 +1,26 @@
+
+import { utils } from "ethers";
+import { ethers } from "hardhat";
+import { MUTI_VOUCHER_ADDR } from "../config/voucher.config";
+import { RPC_URL} from "../config/env.config"
+
+async function getCode(address:string){
+    const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+    const code = await provider.getCode(address);
+    if (code === "0x"){
+        console.log(`Contract ${address} is not deployed`);
+    }else{
+        console.log("contract code:",code)
+    }
+}
+
+// 判断是否链接到punk链
+// npx hardhat run  test/connect_punk.test.ts --network punk 命令可以执行
+// TODO: 转化为test风格
+function main(){
+    getCode(MUTI_VOUCHER_ADDR);
+}
+
+if (require.main === module){
+    main(); 
+}

package/test/create2.test.ts

@@ -0,0 +1,44 @@
+import { ethers } from "hardhat";
+import { expect } from "chai";
+import { Contract, BigNumber } from "ethers";
+import { CONTRACT_ADDRESSES } from "../config/uniswap.config";
+
+describe("create2 test", function () {
+    let value = BigInt(1000);
+    let create2: Contract;
+
+    beforeEach(async () => {
+        let [deployer] = await ethers.getSigners();
+        let Factory = await ethers.getContractFactory("Create2", deployer);
+        create2 = await Factory.deploy();
+        await create2.deployed();
+    });
+
+    it("deploy example.sol", async function () {
+
+        const Contract = await ethers.getContractFactory("Example");
+        const contract = await Contract.deploy(BigInt(1000));
+        await contract.deployed();
+
+        const storedValue: BigNumber = await contract.getValue();
+        expect(storedValue.toBigInt()).to.equal(value);
+
+        const newValue = BigInt(2000);
+        const tx = await contract.setValue(newValue);
+        await tx.wait();
+
+        const updatedValue: BigNumber = await contract.getValue();
+        expect(updatedValue.toBigInt()).to.equal(newValue);
+    });
+
+    it("judge address", async function () {
+        const tokenName = "Token0";
+        let tokenAddress = CONTRACT_ADDRESSES[tokenName];
+        tokenAddress = "0xa8aAB7BbAfC9bb277332b25B3C5BCA74534Df4A7"
+        if (await ethers.provider.getCode(tokenAddress) != "0x") {
+            console.log(`${tokenName} is deployed at address: ${tokenAddress}`);
+        } else {
+            console.log(`${tokenName} is not deployed`);
+        }
+    });
+});

package/test/normal.ts

@@ -0,0 +1,43 @@
+
+import { utils } from "ethers";
+import { ethers } from "hardhat";
+import { RPC_URL,CONTRACTS, CONTRACT_ADDRESSES } from "../config/uniswap.config";
+
+async function getCode(address:string){
+    const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+    const code = await provider.getCode(address);
+    if (code === "0x"){
+        console.log(`Contract ${address} is not deployed`);
+    }
+}
+
+async function ConvertBytes32(){
+    const voucherName="BitCoin"
+    const voucherNameByte32=ethers.utils.formatBytes32String(voucherName);
+    console.log("voucherNameByte32:",voucherNameByte32);
+
+    let parseNameString=ethers.utils.parseBytes32String(voucherNameByte32);
+    console.log("parseNameString:",parseNameString);
+}
+
+
+function main(){
+    const name = "InvalidTickLower()";
+    const selector = utils.id(name).substring(0, 10) 
+    console.log("%s abi encode:%s",name,selector);
+    
+    ConvertBytes32()
+    // const encoded = utils.defaultAbiCoder.encode(["string"], [name]);
+    // console.log(encoded); 
+    // getCode(CONTRACT_ADDRESSES.Create2);
+    // getCode(CONTRACT_ADDRESSES.Token0);
+    // getCode(CONTRACT_ADDRESSES.Token1);
+    // getCode(CONTRACT_ADDRESSES.PoolManager);
+    // getCode(CONTRACT_ADDRESSES.LiquidPool);
+    // getCode(CONTRACT_ADDRESSES.LimitOrder);
+    // getCode(CONTRACT_ADDRESSES.DynamicFee);
+}
+
+if (require.main === module){
+    main(); 
+}

package/test/test-config.ts

@@ -0,0 +1,18 @@
+import { config } from "../config/env.config";
+
+console.log("=== 配置验证 ===\n");
+
+console.log("ABI 根目录:", config.paths.abiRootDir);
+console.log("\n完整 ABI 路径:");
+console.log("- PoolManager:", config.abiPaths.uniswap.poolManager);
+console.log("- MockERC20:", config.abiPaths.uniswap.mockERC20);
+console.log("- ChainYVault:", config.abiPaths.auction.chainYVault);
+console.log("- ChainXAuction:", config.abiPaths.auction.chainXAuction);
+
+console.log("\n合约地址:");
+console.log("- Token0:", config.contracts.uniswap.token0);
+console.log("- PoolManager:", config.contracts.uniswap.poolManager);
+
+console.log("\nPool 配置:");
+console.log("- PRICE_INIT:", config.pool.priceInit);
+console.log("- INITIAL_LIQUIDITY:", config.pool.initialLiquidity.toString());

package/test/uniswap/example.test.ts

@@ -0,0 +1,62 @@
+import { ethers } from "hardhat";
+import { expect } from "chai";
+import { Contract, BigNumber } from "ethers";
+
+describe("Example", function () {
+    let value=BigInt(1000);
+    let contract: Contract;
+
+    beforeEach(async () => {
+        let [deployer, addr1, addr2] = await ethers.getSigners();
+        let Factory = await ethers.getContractFactory("Example", deployer);
+        contract = await Factory.deploy(value);
+        await contract.deployed();
+    });
+
+    it("initial and store",async function() {
+        const storedValue: BigNumber = await contract.getValue();
+        expect(storedValue.toBigInt()).to.equal(value);
+
+        const newValue = BigInt(2000);
+        const tx = await contract.setValue(newValue);
+        await tx.wait();
+
+        const updatedValue: BigNumber = await contract.getValue();
+        expect(updatedValue.toBigInt()).to.equal(newValue);
+    });
+});
+
+describe("Example2", function () {
+    let value="Hello World!";
+    let contract: Contract;
+    let contractNmae="Example2";
+
+    beforeEach(async () => {
+        let [deployer] = await ethers.getSigners();
+        let Factory = await ethers.getContractFactory(contractNmae, deployer);
+        contract = await Factory.deploy();
+        await contract.deployed();
+    });
+
+    it("initial and store",async function() {
+        const storedValue = await contract.getName();
+        console.log(storedValue);
+        expect(storedValue).to.equal(value);
+
+        const tx = await contract.setName(value);
+        await tx.wait();
+
+        const updatedValue = await contract.getName();
+        console.log(updatedValue);
+        expect(updatedValue).to.equal(value);
+    });
+});
+
+describe("normal test", function () {
+    it("hex concat example", function () {
+        const hex1 = "0x1111";
+        const hex2 = "0x2222";
+        const result = ethers.utils.hexConcat([hex1, hex2]);
+        console.log(`result: ${result}`);
+    });
+});

package/test/uniswap/limitOrder.test.ts

@@ -0,0 +1,184 @@
+import { ethers } from "hardhat";
+import { expect } from "chai";
+// LoadFixture is used to set up a fresh blockchain state for each test
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+
+describe("LimitOrder", function () {
+    const TICK_SPACING = 10;
+    const SWAP_FEE = 3000;
+    const sqrtPriceX96 = ethers.utils.parseEther("1"); 
+
+    async function deployFixture() {
+        const [deployer, user] = await ethers.getSigners();
+
+        const MockERC20Factory = await ethers.getContractFactory("MockERC20", deployer);
+        const token0 = await MockERC20Factory.deploy("Token0", "T0", 18);
+        const token1 = await MockERC20Factory.deploy("Token1", "T1", 18);
+
+        // Ensure token0 is "less than" token1 for pool key purposes
+        const [sortedToken0, sortedToken1] =
+            (token0.address).toLowerCase() < (token1.address).toLowerCase()
+                ? [token0, token1]
+                : [token1, token0];
+
+        const PoolManagerFactory = await ethers.getContractFactory("PoolManager", deployer);
+        const PoolManager = await PoolManagerFactory.deploy(user.address);
+
+        const LimitOrderFactory = await ethers.getContractFactory("LimitOrder", deployer);
+        const limitOrder = await LimitOrderFactory.deploy(PoolManager.address);
+
+        const poolKey = {
+            currency0: sortedToken0.address,
+            currency1: sortedToken1.address,
+            fee: SWAP_FEE,
+            tickSpacing: TICK_SPACING,
+            hooks: limitOrder.address,
+        };
+
+        // Mint some tokens for the user
+        const initialAmount = ethers.utils.parseEther("1000");
+        await sortedToken0.mint(user.address, initialAmount);
+        await sortedToken1.mint(user.address, initialAmount);
+
+        // User approves PoolManager contract to spend their tokens, as it's the one pulling funds
+        await sortedToken0.connect(user).approve(PoolManager.address, ethers.constants.MaxUint256);
+        await sortedToken1.connect(user).approve(PoolManager.address, ethers.constants.MaxUint256);
+        
+        // Initialize PoolManager's pool state (mock)
+        await PoolManager.initialize(poolKey, sqrtPriceX96);
+
+        // Initialize add liquidity
+        const modifyPositionParams={
+            tickLower: -TICK_SPACING * 10,
+            tickUpper: TICK_SPACING * 10,
+            liquidityDelta: ethers.utils.parseEther("1000"),
+        };
+        const tx = await PoolManager.addLiquidity(modifyPositionParams, "");
+        await tx.wait();    
+
+        return {
+            deployer,
+            user,
+            token0: sortedToken0,
+            token1: sortedToken1,
+            PoolManager,
+            limitOrder,
+            poolKey,
+        };
+    }
+
+    describe("Placing a limit order", function () {
+        it("Should allow a user to place a limit order", async function () {
+            const { user, limitOrder, poolKey, token0, PoolManager } = await loadFixture(deployFixture);
+            const orderAmount = ethers.utils.parseEther("10");
+            const tickLower = -10;
+            const zeroForOne = true;
+            const initialUserBalance = await token0.balanceOf(user.address);
+
+            await expect(limitOrder.connect(user).place(poolKey, tickLower, zeroForOne, orderAmount))
+                .to.emit(limitOrder, "Place");
+
+            const finalUserBalance = await token0.balanceOf(user.address);
+            const poolManagerBalance = await token0.balanceOf(PoolManager.address);
+
+            // User's balance decreases
+            expect(finalUserBalance).to.be.lt(initialUserBalance);
+            // PoolManager's balance increases
+            expect(poolManagerBalance).to.be.gt(0);
+        });
+    });
+
+    describe("Filling a limit order", function () {
+        it("Should fill a limit order after a swap", async function () {
+            const { user, limitOrder, PoolManager, poolKey, token0, token1 } = await loadFixture(deployFixture);
+            const orderAmount = ethers.utils.parseEther("10");
+            const tickLower = -10;
+            const zeroForOne = true;
+
+            // Place order
+            await limitOrder.connect(user).place(poolKey, tickLower, zeroForOne, orderAmount);
+            const epoch = await limitOrder.getEpoch(poolKey, tickLower, zeroForOne);
+
+            // Simulate a swap that crosses the tick
+            // Set current tick on mock pool manager to be past the order's tick
+            await PoolManager.setTick(tickLower - TICK_SPACING);
+
+            const swapParams = {
+                zeroForOne: false, // Swap direction is opposite of limit order direction
+                amountSpecified: ethers.utils.parseEther("-1"), // negative for exact output
+                sqrtPriceLimitX96: 0,
+            };
+            
+            const salt = ethers.utils.formatBytes32String("test");
+            const hookData = ethers.utils.defaultAbiCoder.encode(["bytes32"], [salt]);
+
+            // The pool manager would call this hook after a swap
+            await limitOrder.afterSwap(user.address, poolKey, swapParams, "0x", hookData);
+
+            const epochInfo = await limitOrder.epochInfos(epoch);
+            expect(epochInfo.filled).to.be.true;
+
+            // The limit order contract should now hold the filled tokens (token1 in this case)
+            const contractToken1Balance = await token1.balanceOf(limitOrder.address);
+            expect(contractToken1Balance).to.be.gt(0);
+        });
+    });
+
+    describe("Killing/cancelling a limit order", function () {
+        it("Should allow a user to cancel their limit order", async function () {
+            const { user, limitOrder, poolKey, token0 } = await loadFixture(deployFixture);
+            const orderAmount = ethers.utils.parseEther("10");
+            const tickLower = -10;
+            const zeroForOne = true;
+            const initialUserBalance = await token0.balanceOf(user.address);
+
+            // Place order
+            await limitOrder.connect(user).place(poolKey, tickLower, zeroForOne, orderAmount);
+            
+            const balanceAfterPlace = await token0.balanceOf(user.address);
+            expect(balanceAfterPlace).to.be.lt(initialUserBalance);
+
+            // Kill order
+            await expect(limitOrder.connect(user).kill(poolKey, tickLower, zeroForOne, user.address))
+                .to.emit(limitOrder, "Kill");
+
+            // User should get their tokens back
+            const finalUserBalance = await token0.balanceOf(user.address);
+            expect(finalUserBalance).to.equal(initialUserBalance);
+        });
+    });
+
+    describe("Withdrawing from a filled limit order", function () {
+        it("Should allow a user to withdraw from a filled order", async function () {
+            const { user, limitOrder, PoolManager, poolKey, token1 } = await loadFixture(deployFixture);
+            const orderAmount = ethers.utils.parseEther("10");
+            const tickLower = -10;
+            const zeroForOne = true;
+
+            // Place order
+            await limitOrder.connect(user).place(poolKey, tickLower, zeroForOne, orderAmount);
+            const epoch = await limitOrder.getEpoch(poolKey, tickLower, zeroForOne);
+
+            // Simulate swap and fill
+            await PoolManager.setTick(tickLower - TICK_SPACING);
+            const swapParams = { zeroForOne: false, amountSpecified: ethers.utils.parseEther("-1"), sqrtPriceLimitX96: 0 };
+            const salt = ethers.utils.formatBytes32String("test");
+            const hookData = ethers.utils.defaultAbiCoder.encode(["bytes32"], [salt]);
+            await limitOrder.afterSwap(user.address, poolKey, swapParams, "0x", hookData);
+            
+            const initialUserToken1Balance = await token1.balanceOf(user.address);
+
+            // Withdraw
+            await expect(limitOrder.connect(user).withdraw(epoch, user.address))
+                .to.emit(limitOrder, "Withdraw");
+
+            // User should have received the filled tokens
+            const finalUserToken1Balance = await token1.balanceOf(user.address);
+            expect(finalUserToken1Balance).to.be.gt(initialUserToken1Balance);
+
+            // Contract should have no more of the filled tokens for this order
+            const contractToken1Balance = await token1.balanceOf(limitOrder.address);
+            expect(contractToken1Balance).to.equal(0);
+        });
+    });
+});

package/test/uniswap/mockERC20.test.ts

@@ -0,0 +1,142 @@
+import { ethers } from "hardhat";
+import { expect } from "chai";
+import { Contract, Signer, BigNumber } from "ethers";
+import { CONTRACTS, CONTRACT_ADDRESSES, PRIVATE_KEY, RPC_URL } from "../../config/uniswap.config";
+
+describe("MockERC20", function () {
+    let token: Contract;
+    let owner: Signer;
+    let addr1: Signer;
+    let addr2: Signer;
+
+    const tokenName = "Mock Token";
+    const tokenSymbol = "MCK";
+    // 初始供应量为 1000 个代币 (假设18位小数)
+    const initialSupply = ethers.utils.parseEther("1000");
+
+    beforeEach(async function () {
+        // 获取测试账户
+        [owner, addr1, addr2] = await ethers.getSigners();
+
+        // 部署合约
+        const MockERC20Factory = await ethers.getContractFactory("MockERC20", owner);
+        token = await MockERC20Factory.deploy(tokenName, tokenSymbol, initialSupply);
+        await token.deployed();
+    });
+
+    describe("Deployment", function () {
+        it("Should set the right name and symbol", async function () {
+            expect(await token.name()).to.equal(tokenName);
+            expect(await token.symbol()).to.equal(tokenSymbol);
+        });
+
+        it("Should assign the total supply of tokens to the owner", async function () {
+            const ownerAddress = await owner.getAddress();
+            const ownerBalance = await token.balanceOf(ownerAddress);
+            expect(await token.totalSupply()).to.equal(ownerBalance);
+            expect(ownerBalance).to.equal(initialSupply);
+        });
+    });
+
+    describe("Transactions", function () {
+        it("Should transfer tokens between accounts", async function () {
+            const ownerAddress = await owner.getAddress();
+            const addr1Address = await addr1.getAddress();
+            const transferAmount = ethers.utils.parseEther("50");
+
+            // 从 owner 转 50 个代币到 addr1
+            await token.connect(owner).transfer(addr1Address, transferAmount);
+            const addr1Balance = await token.balanceOf(addr1Address);
+            expect(addr1Balance).to.equal(transferAmount);
+
+            // 从 addr1 转 20 个代币到 addr2
+            const addr2Address = await addr2.getAddress();
+            const transferAmount2 = ethers.utils.parseEther("20");
+            await token.connect(addr1).transfer(addr2Address, transferAmount2);
+            const addr2Balance = await token.balanceOf(addr2Address);
+            expect(addr2Balance).to.equal(transferAmount2);
+        });
+
+        it("Should fail if sender doesn’t have enough tokens", async function () {
+            const ownerAddress = await owner.getAddress();
+            const addr1Address = await addr1.getAddress();
+            const initialOwnerBalance = await token.balanceOf(ownerAddress);
+
+            // 尝试从 addr1 (余额为0) 转账
+            const value = 1;
+            await expect(token.connect(addr1).transfer(ownerAddress, value))
+                .to.be.revertedWithCustomError(token, "ERC20InsufficientBalance")
+                .withArgs(addr1Address, 0, value); // address,balance,transfer amount
+
+            // 确认 owner 余额未变
+            expect(await token.balanceOf(ownerAddress)).to.equal(initialOwnerBalance);
+        });
+    });
+
+    describe("Approval", function () {
+        it("Should allow a spender to transfer tokens after approval", async function () {
+            const ownerAddress = await owner.getAddress();
+            const addr1Address = await addr1.getAddress();
+            const addr2Address = await addr2.getAddress();
+            const amountToApprove = ethers.utils.parseEther("100");
+
+            // Owner 授权 addr1 可以动用 100 个代币
+            await token.connect(owner).approve(addr1Address, amountToApprove);
+            const allowance = await token.allowance(ownerAddress, addr1Address);
+            expect(allowance).to.equal(amountToApprove);
+
+            // Addr1 使用 transferFrom 将 owner 的 50 个代币转给 addr2
+            const amountToTransfer = ethers.utils.parseEther("50");
+            await token.connect(addr1).transferFrom(ownerAddress, addr2Address, amountToTransfer);
+
+            // 检查余额
+            expect(await token.balanceOf(ownerAddress)).to.equal(initialSupply.sub(amountToTransfer));
+            expect(await token.balanceOf(addr2Address)).to.equal(amountToTransfer);
+
+            // 检查剩余授权额度
+            const remainingAllowance = await token.allowance(ownerAddress, addr1Address);
+            expect(remainingAllowance).to.equal(amountToApprove.sub(amountToTransfer));
+        });
+    });
+
+    describe("Minting", function () {
+        it("Should allow minting new tokens to any address", async function () {
+            const addr1Address = await addr1.getAddress();
+            const mintAmount = ethers.utils.parseEther("200");
+            const initialTotalSupply = await token.totalSupply();
+
+            // 给 addr1 增发 200 个代ar币
+            await token.connect(owner).mint(addr1Address, mintAmount);
+
+            // 检查 addr1 余额和总供应量
+            expect(await token.balanceOf(addr1Address)).to.equal(mintAmount);
+            expect(await token.totalSupply()).to.equal(initialTotalSupply.add(mintAmount));
+        });
+    });
+});
+
+describe("Deterministic deployment of MockERC20", function () {
+    const tokenName = "BitCoin"
+    const tokenSymbol = "BTC"
+    const initialSupply = ethers.utils.parseUnits("2100000", 18).toBigInt();
+    let walletAddress = "0x";
+    let token0Address = CONTRACT_ADDRESSES["Token0"];
+    let wallet: Signer;
+    let token: Contract;
+
+    beforeEach(async function () {
+        const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
+        wallet = new ethers.Wallet(PRIVATE_KEY, provider);
+        walletAddress = await wallet.getAddress();
+    });
+
+    it("Owner", async function () {
+        const token = await ethers.getContractAt("MockERC20", token0Address, wallet);
+        let res: bigint = await token.balanceOf(walletAddress);
+        console.log(res.toString());
+
+        res = await token.balanceOf(CONTRACT_ADDRESSES["Create2"]);
+        console.log(res.toString())
+    });
+
+});