Smart Contracts

const { ethers } = require("ethers");

const TOKEN_ADDR = "0x3Bd71947F288d1dd8B21129B1bE4FF16EDd5d1F4";
const abi = [
  "function decimals() view returns (uint8)",
  "function balanceOf(address) view returns (uint256)",
  "function senderBurnBps() view returns (uint256)",
  "function recipientBurnBps() view returns (uint256)",
  "function poolFeeBps() view returns (uint256)",
  "function feeExempt(address) view returns (bool)",
  "function transfer(address to, uint256 amount) returns (bool)",
  "function setFeeExempt(address account, bool exempt)",
];

const provider = new ethers.providers.JsonRpcProvider(RPC_URL);
const token = new ethers.Contract(TOKEN_ADDR, abi, provider);

// Read fee rates
const senderBurn = await token.senderBurnBps();   // 200 = 2.0%
const recipBurn  = await token.recipientBurnBps(); // 50  = 0.5%
const poolFee   = await token.poolFeeBps();       // 100 = 1.0%

// Calculate net transfer amount (for 1000 IFR)
const amount = ethers.utils.parseUnits("1000", 9);
const totalFee = amount.mul(senderBurn.add(recipBurn).add(poolFee)).div(10000);
const netAmount = amount.sub(totalFee);
console.log("Net received:", ethers.utils.formatUnits(netAmount, 9), "IFR");

// Transfer tokens (signer required)
const signer = provider.getSigner();
const tokenWithSigner = token.connect(signer);
await tokenWithSigner.transfer(recipientAddr, amount);

const RESERVE_ADDR = "0xF7E90D0d17f8232365186AA085D26eaEfAf011aF";
const abi = [
  "function lockEnd() view returns (uint256)",
  "function currentPeriod() view returns (uint256)",
  "function availableToWithdraw() view returns (uint256)",
  "function pendingBalance() view returns (uint256)",
  "function withdraw(address to, uint256 amount)",
  "function paused() view returns (bool)",
];

const reserve = new ethers.Contract(RESERVE_ADDR, abi, provider);

// Check lock status
const lockEnd = await reserve.lockEnd();
const now = Math.floor(Date.now() / 1000);
console.log("Locked:", now < lockEnd.toNumber());

// Check available withdrawal
const available = await reserve.availableToWithdraw();
console.log("Available:", ethers.utils.formatUnits(available, 9), "IFR");

// Withdraw (owner only, via governance proposal)
const amount = ethers.utils.parseUnits("10000000", 9); // 10M IFR
await reserve.connect(owner).withdraw(treasuryAddr, amount);

const VESTING_ADDR = "0xa710f9FE7bf42981E60BE2Fbe7D87Fb3541a3F8B";
const abi = [
  "function beneficiary() view returns (address)",
  "function vestedAmount() view returns (uint256)",
  "function releasableAmount() view returns (uint256)",
  "function released() view returns (uint256)",
  "function vestingSchedule() view returns (uint256, uint256, uint256)",
  "function release()",
];

const vesting = new ethers.Contract(VESTING_ADDR, abi, provider);

// Check vesting progress
const [start, cliff, duration] = await vesting.vestingSchedule();
const vested = await vesting.vestedAmount();
const releasable = await vesting.releasableAmount();
const released = await vesting.released();

console.log("Vested:", ethers.utils.formatUnits(vested, 9), "IFR");
console.log("Releasable:", ethers.utils.formatUnits(releasable, 9), "IFR");
console.log("Released:", ethers.utils.formatUnits(released, 9), "IFR");

// Release vested tokens (beneficiary only)
await vesting.connect(beneficiarySigner).release();

const VAULT_ADDR = "0xC8ABb9039BEd24f4dBf5Cff09699877D81f0D63C";
const abi = [
  "function depositETH() payable",
  "function executeBuyback()",
  "function activationTime() view returns (uint256)",
  "function lastBuybackAt() view returns (uint256)",
  "function cooldown() view returns (uint256)",
  "function pendingExpectedOut() view returns (uint256)",
  "function paused() view returns (bool)",
];

const vault = new ethers.Contract(VAULT_ADDR, abi, provider);

// Deposit ETH for future buyback
await vault.connect(signer).depositETH({
  value: ethers.utils.parseEther("0.5"),
});

// Check if buyback is ready
const activation = await vault.activationTime();
const lastBuyback = await vault.lastBuybackAt();
const cd = await vault.cooldown();
const now = Math.floor(Date.now() / 1000);

const isActive = now >= activation.toNumber();
const cooldownPassed = now >= lastBuyback.add(cd).toNumber();
console.log("Ready:", isActive && cooldownPassed);

// Execute buyback (owner only)
await vault.connect(owner).executeBuyback();

const BURN_ADDR = "0x6D4582FCac792FD3880e252fC0a585A0c1823e80";
const abi = [
  "function pendingBurn() view returns (uint256)",
  "function totalBurned() view returns (uint256)",
  "function deposit(uint256 amount)",
  "function burn(uint256 amount)",
  "function burnAll()",
];

const burnReserve = new ethers.Contract(BURN_ADDR, abi, provider);

// Check burn stats
const pending = await burnReserve.pendingBurn();
const totalBurned = await burnReserve.totalBurned();
console.log("Pending burn:", ethers.utils.formatUnits(pending, 9));
console.log("Total burned:", ethers.utils.formatUnits(totalBurned, 9));

// Deposit tokens (requires prior token.approve())
const amount = ethers.utils.parseUnits("100000", 9);
await token.connect(signer).approve(BURN_ADDR, amount);
await burnReserve.connect(signer).deposit(amount);

// Burn all pending tokens (owner or guardian)
await burnReserve.connect(owner).burnAll();

const GOV_ADDR = "0x6050b22E4EAF3f414d1155fBaF30B868e0107017";
const TOKEN_ADDR = "0x3Bd71947F288d1dd8B21129B1bE4FF16EDd5d1F4";

const govAbi = [
  "function propose(address target, bytes data) returns (uint256)",
  "function execute(uint256 proposalId)",
  "function cancel(uint256 proposalId)",
  "function getProposal(uint256) view returns (address, bytes, uint256, bool, bool)",
  "function delay() view returns (uint256)",
  "function proposalCount() view returns (uint256)",
];

const gov = new ethers.Contract(GOV_ADDR, govAbi, provider);

// Create a proposal to update fee rates on InfernoToken
const iface = new ethers.utils.Interface([
  "function setFeeRates(uint256, uint256, uint256)",
]);
const calldata = iface.encodeFunctionData("setFeeRates", [150, 50, 100]);

const tx = await gov.connect(owner).propose(TOKEN_ADDR, calldata);
const receipt = await tx.wait();
const proposalId = receipt.events[0].args.id;

// After delay has passed, execute
await gov.connect(owner).execute(proposalId);

// Read a proposal
const [target, data, eta, executed, cancelled] =
  await gov.getProposal(proposalId);

const LOCK_ADDR = "0x..."; // IFRLock deployment address
const TOKEN_ADDR = "0x3Bd71947F288d1dd8B21129B1bE4FF16EDd5d1F4";

const lockAbi = [
  "function lock(uint256 amount)",
  "function lockWithType(uint256 amount, bytes32 lockType)",
  "function unlock()",
  "function lockedBalance(address) view returns (uint256)",
  "function isLocked(address, uint256) view returns (bool)",
  "function lockInfo(address) view returns (uint256, uint256)",
  "function totalLocked() view returns (uint256)",
];

const tokenAbi = [
  "function approve(address spender, uint256 amount) returns (bool)",
];

const lockContract = new ethers.Contract(LOCK_ADDR, lockAbi, provider);
const token = new ethers.Contract(TOKEN_ADDR, tokenAbi, provider);

// Approve and lock 10,000 IFR
const amount = ethers.utils.parseUnits("10000", 9);
await token.connect(signer).approve(LOCK_ADDR, amount);
await lockContract.connect(signer).lock(amount);

// Lock with a specific type (e.g. "premium" access)
const lockType = ethers.utils.id("premium"); // keccak256("premium")
await lockContract.connect(signer).lockWithType(amount, lockType);

// Check if user qualifies (has >= 5000 IFR locked)
const minRequired = ethers.utils.parseUnits("5000", 9);
const qualifies = await lockContract.isLocked(userAddr, minRequired);
console.log("Qualifies:", qualifies);

// Get lock details
const [lockedAmt, lockedAt] = await lockContract.lockInfo(userAddr);
console.log("Locked:", ethers.utils.formatUnits(lockedAmt, 9), "IFR");
console.log("Since:", new Date(lockedAt.toNumber() * 1000));

// Unlock all tokens
await lockContract.connect(signer).unlock();

const PAIR_ADDR = "0x2252e8bBDE0E50CD372748aC233A99C08627d9c7";
const pairAbi = [
  "function getReserves() view returns (uint112, uint112, uint32)",
  "function token0() view returns (address)",
  "function token1() view returns (address)",
  "function totalSupply() view returns (uint256)",
];

const pair = new ethers.Contract(PAIR_ADDR, pairAbi, provider);

// Read reserves
const [reserve0, reserve1] = await pair.getReserves();
const token0 = await pair.token0();

console.log("Token0:", token0);
console.log("Reserve0:", reserve0.toString());
console.log("Reserve1:", reserve1.toString());