gn-contract 1.0.0

package/test/Swap.test.ts

@@ -0,0 +1,182 @@
+import { expect } from "chai";
+import { ethers, upgrades } from "hardhat";
+import { initialize, getState, getAccounts } from "./lib/initializer";
+import { Swap } from "../typechain-types";
+import { toBn } from "evm-bn";
+
+describe("Swap Contract", function () {
+  let swap: Swap;
+
+  before(async () => {
+    // Initialize the environment (deploys USDT, CUSDT, CROWD, etc.)
+    await initialize();
+    const { usdt, cusdt, crowd, owner } = getState();
+
+    // Deploy Swap Contract
+    const SwapFactory = await ethers.getContractFactory("Swap", owner);
+    swap = (await upgrades.deployProxy(
+      SwapFactory,
+      [
+        usdt.address,
+        cusdt.address,
+        crowd.address,
+        owner.address, // feeReceiver
+        owner.address, // feeMarketing
+      ],
+      { kind: "uups" },
+    )) as Swap;
+    await swap.deployed();
+
+    // Fund the Swap contract with CUSDT and CROWD so users can swap
+    // Owner (admin) should have initial supply from initialize() or we can mint/transfer
+    // Check initial balances of owner
+    const ownerCusdtBal = await cusdt.balanceOf(owner.address);
+    const ownerCrowdBal = await crowd.balanceOf(owner.address);
+
+    // Transfer some liquidity to Swap contract
+    await cusdt.connect(owner).transfer(swap.address, toBn("100000", 18));
+    await crowd.connect(owner).transfer(swap.address, toBn("1000000", 18));
+  });
+
+  it("should initialize with correct token addresses", async () => {
+    const { usdt, cusdt, crowd } = getState();
+    expect(await swap.usdt()).to.eq(usdt.address);
+    expect(await swap.cusdt()).to.eq(cusdt.address);
+    expect(await swap.crowd()).to.eq(crowd.address);
+  });
+
+  it("should swap USDT to CUSDT 1:1", async () => {
+    const { usdt, cusdt } = getState();
+    const [user] = await getAccounts(1, 1);
+    const amount = toBn("100", 18);
+
+    // Fund user with USDT
+    const { owner } = getState();
+    await usdt.connect(owner).transfer(user.address, amount);
+
+    // Approve Swap contract
+    await usdt.connect(user).approve(swap.address, amount);
+
+    const userUsdtBefore = await usdt.balanceOf(user.address);
+    const userCusdtBefore = await cusdt.balanceOf(user.address);
+
+    // Perform Swap
+    await swap.connect(user).swapToCUSDT(amount);
+
+    const userUsdtAfter = await usdt.balanceOf(user.address);
+    const userCusdtAfter = await cusdt.balanceOf(user.address);
+
+    expect(userUsdtAfter).to.eq(userUsdtBefore.sub(amount));
+    expect(userCusdtAfter).to.eq(userCusdtBefore.add(amount));
+  });
+
+  it("should fail swapToCUSDT if insufficient pool balance", async () => {
+    const { usdt } = getState();
+    const [user] = await getAccounts(2, 1);
+    // Try to swap more than available in pool (we put 100k)
+    const amount = toBn("200000", 18);
+
+    const { owner } = getState();
+    await usdt.connect(owner).transfer(user.address, amount);
+    await usdt.connect(user).approve(swap.address, amount);
+
+    await expect(swap.connect(user).swapToCUSDT(amount)).to.be.revertedWith(
+      "Insufficient Pool",
+    );
+  });
+
+  it("should swap USDT to CROWD 1:500", async () => {
+    const { usdt, crowd } = getState();
+    const [user] = await getAccounts(3, 1);
+    const amount = toBn("10", 18); // 10 USDT
+    const expectedCrowd = amount.mul(500); // 5000 CROWD
+
+    // Fund user
+    const { owner } = getState();
+    await usdt.connect(owner).transfer(user.address, amount);
+
+    // Approve
+    await usdt.connect(user).approve(swap.address, amount);
+
+    const userUsdtBefore = await usdt.balanceOf(user.address);
+    const userCrowdBefore = await crowd.balanceOf(user.address);
+
+    // Swap
+    await swap.connect(user).swapToCROWD(amount);
+
+    const userUsdtAfter = await usdt.balanceOf(user.address);
+    const userCrowdAfter = await crowd.balanceOf(user.address);
+
+    expect(userUsdtAfter).to.eq(userUsdtBefore.sub(amount));
+    expect(userCrowdAfter).to.eq(userCrowdBefore.add(expectedCrowd));
+  });
+
+  it("should fail swapToCROWD if insufficient pool balance", async () => {
+    const { usdt } = getState();
+    const [user] = await getAccounts(4, 1);
+    // Pool has 1M CROWD.
+    // Need > 1M CROWD output.
+    // 1 USDT = 500 CROWD.
+    // 2001 USDT = 1,000,500 CROWD > 1M.
+    const amount = toBn("2001", 18);
+
+    const { owner } = getState();
+    await usdt.connect(owner).transfer(user.address, amount);
+    await usdt.connect(user).approve(swap.address, amount);
+
+    await expect(swap.connect(user).swapToCROWD(amount)).to.be.revertedWith(
+      "Insufficient Pool",
+    );
+  });
+
+  describe("Owner Withdrawals", function () {
+    it("should allow owner to withdraw USDT", async () => {
+      const { usdt, owner } = getState();
+      // Swap contract likely has USDT from previous tests
+      const contractUsdtBal = await usdt.balanceOf(swap.address);
+      const withdrawAmount = contractUsdtBal;
+
+      const ownerBefore = await usdt.balanceOf(owner.address);
+      await swap.connect(owner).withdrawUSDT(withdrawAmount);
+      const ownerAfter = await usdt.balanceOf(owner.address);
+
+      expect(ownerAfter).to.eq(ownerBefore.add(withdrawAmount));
+    });
+
+    it("should allow owner to withdraw CUSDT", async () => {
+      const { cusdt, owner } = getState();
+      const amount = toBn("50", 18); // Withdraw small amount
+
+      const ownerBefore = await cusdt.balanceOf(owner.address);
+      await swap.connect(owner).withdrawCUSDT(amount);
+      const ownerAfter = await cusdt.balanceOf(owner.address);
+
+      expect(ownerAfter).to.eq(ownerBefore.add(amount));
+    });
+
+    it("should allow owner to withdraw CROWD", async () => {
+      const { crowd, owner } = getState();
+      const amount = toBn("500", 18);
+
+      const ownerBefore = await crowd.balanceOf(owner.address);
+      await swap.connect(owner).withdrawCROWD(amount);
+      const ownerAfter = await crowd.balanceOf(owner.address);
+
+      expect(ownerAfter).to.eq(ownerBefore.add(amount));
+    });
+
+    it("should NOT allow non-owner to withdraw", async () => {
+      const [user] = await getAccounts(5, 1);
+      const amount = toBn("1", 18);
+      await expect(swap.connect(user).withdrawUSDT(amount)).to.be.revertedWith(
+        "Ownable: caller is not the owner",
+      );
+      await expect(swap.connect(user).withdrawCUSDT(amount)).to.be.revertedWith(
+        "Ownable: caller is not the owner",
+      );
+      await expect(swap.connect(user).withdrawCROWD(amount)).to.be.revertedWith(
+        "Ownable: caller is not the owner",
+      );
+    });
+  });
+});

package/test/lib/initializer.ts

@@ -0,0 +1,193 @@
+/* eslint-disable prettier/prettier */
+/* eslint-disable node/no-missing-import */
+import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers";
+import { toBn } from "evm-bn";
+import { ethers, upgrades, network } from "hardhat";
+import { reserveAddress } from "../../constants/rootAddress";
+import {
+  Network,
+  CROWD,
+  NFT,
+  NFTGenesis,
+  USDT,
+  NFTFounder,
+  CUSDT,
+} from "../../typechain-types";
+
+let valhalla: Network = null as any;
+let crowd: CROWD = null as any;
+let nft: NFT = null as any;
+let cusdt: CUSDT = null as any;
+let accounts: SignerWithAddress[] = [];
+let feeReceiver: SignerWithAddress = null as any;
+let feeReceiver2: SignerWithAddress = null as any;
+let owner: SignerWithAddress = null as any;
+let nftFounder: NFTFounder = null as any;
+
+let nftGenesis: NFTGenesis = null as any;
+let usdt: USDT = null as any;
+
+const initiateAccounts = async () => {
+  const accounts = await ethers.getSigners();
+  return accounts;
+};
+
+export const createSignerWithInitialBalance = async (
+  balance: string | number,
+) => {
+  const wallet = ethers.Wallet.createRandom().connect(ethers.provider);
+  await network.provider.send("hardhat_setBalance", [
+    wallet.address,
+    "0x" + Number(toBn("" + balance).toString()).toString(16),
+  ]);
+  return await ethers.getImpersonatedSigner(wallet.address);
+};
+
+export const setBalance = async (address: string, amount: string | number) => {
+  await network.provider.send("hardhat_setBalance", [
+    address,
+    "0x" + Number(toBn("" + amount).toString()).toString(16),
+  ]);
+};
+
+export const getAccounts = async (startIndex: number, amount: number = 1) => {
+  if (startIndex + amount + 1 > accounts.length) {
+    // adjust start index in case its greater
+    // than the total length of cached accounts
+    startIndex = startIndex >= accounts.length ? accounts.length : startIndex;
+
+    for (let i = accounts.length - 1; i <= startIndex + amount; i++) {
+      const signer = await createSignerWithInitialBalance(1000);
+      accounts.push(signer);
+    }
+  }
+
+  return accounts.filter((_, idx) => {
+    return idx >= startIndex && idx < startIndex + amount;
+  });
+};
+
+export const initialize = async () => {
+  await initiateAccounts();
+  const _accounts = await getAccounts(0, 15);
+
+  feeReceiver = await createSignerWithInitialBalance(0);
+  feeReceiver2 = await createSignerWithInitialBalance(0);
+
+  const CROWDContract = await ethers.getContractFactory("CROWD");
+  const admin = _accounts[0];
+  crowd = await CROWDContract.connect(admin).deploy();
+  await crowd.connect(admin).deployed();
+
+  const USDTContract = await ethers.getContractFactory("USDT");
+  usdt = await USDTContract.connect(admin).deploy();
+  await usdt.connect(admin).deployed();
+
+  const CUSDTContract = await ethers.getContractFactory("CUSDT");
+  cusdt = await CUSDTContract.connect(admin).deploy();
+  await cusdt.connect(admin).deployed();
+
+  const ValhallaContract = await ethers.getContractFactory("Network");
+  valhalla = (await upgrades.deployProxy(
+    ValhallaContract,
+    [
+      admin.address,
+      [
+        _accounts[0].address,
+        _accounts[1].address,
+        _accounts[2].address,
+        _accounts[3].address,
+        _accounts[4].address,
+        _accounts[5].address,
+        _accounts[6].address,
+        _accounts[7].address,
+        _accounts[8].address,
+        _accounts[9].address,
+        _accounts[10].address,
+        _accounts[11].address,
+        _accounts[12].address,
+        _accounts[13].address,
+        _accounts[14].address,
+      ],
+      feeReceiver.address,
+      feeReceiver2.address,
+      reserveAddress,
+      0,
+      toBn("50", 18), // Registration fee: 50 USDT
+    ],
+    { kind: "transparent" },
+  )) as any;
+  await valhalla.connect(admin).deployed();
+
+  const NFTContract = await ethers.getContractFactory("NFT");
+  nft = (await upgrades.deployProxy(
+    NFTContract,
+    [crowd.address, valhalla.address],
+    { kind: "transparent" },
+  )) as any;
+  await nft.connect(admin).deployed();
+
+  const [receiverAddress] = await getAccounts(420, 2);
+  const NFTGenesiscontract = await ethers.getContractFactory("NFTGenesis");
+  nftGenesis = (await upgrades.deployProxy(
+    NFTGenesiscontract,
+    [
+      crowd.address,
+      usdt.address,
+      nft.address,
+      valhalla.address,
+      receiverAddress.address,
+    ],
+    { kind: "transparent" },
+  )) as any;
+  await nftGenesis.connect(admin).deployed();
+
+  const NFTFounderContract = await ethers.getContractFactory("NFTFounder");
+  nftFounder = (await upgrades.deployProxy(
+    NFTFounderContract,
+    [usdt.address, valhalla.address, receiverAddress.address],
+    { kind: "transparent" },
+  )) as any;
+  await nftFounder.connect(admin).deployed();
+
+  owner = admin;
+
+  const tx = await crowd.setMinterContract(nft.address);
+  await tx.wait();
+
+  const tx2 = await valhalla.connect(admin).setNftAddress(nft.address);
+  await tx2.wait();
+
+  const tx3 = await valhalla.connect(admin).setCRWDAddress(crowd.address);
+  await tx3.wait();
+
+  const tx4 = await nft.setNFTGenesis(nftGenesis.address);
+  await tx4.wait();
+
+  // Set USDT as the registration token
+  const tx5 = await valhalla.connect(admin).setCUSDAddress(usdt.address);
+  await tx5.wait();
+
+  const tx6 = await valhalla
+    .connect(admin)
+    .setNFTFounderAddress(nftFounder.address);
+  await tx6.wait();
+
+  const receiverAddress2 = await createSignerWithInitialBalance(0);
+
+  const tx7 = await nftFounder.setReceiverAddress2(receiverAddress2.address);
+  await tx7.wait();
+};
+
+export const getState = () => ({
+  valhalla,
+  usdt,
+  crowd,
+  nft,
+  feeReceiver,
+  feeReceiver2,
+  nftGenesis,
+  owner,
+  nftFounder,
+  cusdt,
+});