DEV Community: Syed Ghufran Hassan

Investigation of the failing tests with Kode Sherpa

Syed Ghufran Hassan — Fri, 03 Apr 2026 13:31:35 +0000

In my last article Modification of Kode Sherpa Contract I discussed about the coverage of the contract which I consumed from Kode Sherpa which tends to be 100 percent so now recently, Kode Sherpa has introduced their Studio

Here I can also generate the results of both failing and passing tests since 7 tests failed last time which were later rectified through foundry but I will take a deep down dive that where were those 7 failing tests so I am presenting them below

FixedAprSingleTokenStakingPullPayments

expected 250000001585489599188 to equal 250000000000000000000.

FixedAprSingleTokenStakingPullPayments

expected 500000002774606798579 to equal 500000000000000000000.

FixedAprSingleTokenStakingPullPayments

Expected transaction to be reverted with reason 'nothing owed', but it didn't revert

FixedAprSingleTokenStakingPullPayments

expected 250000001585489599188 to equal 250000000000000000000.

FixedAprSingleTokenStakingPullPayments

HHE1000: Artifact for contract "

FixedAprSingleTokenStakingPullPayments

expected 250000001585489599188 to equal 250000000000000000000.

FixedAprSingleTokenStakingPullPayments

VM Exception while processing transaction: reverted with custom error 'ERC20InsufficientAllowance("0xe70f935c32dA4dB13e7876795f1e175465e6458e", 0, 1)'

FixedAprSingleTokenStakingPullPayments

VM Exception while processing transaction: reverted with custom error 'ERC20InsufficientBalance("0xcE0066b1008237625dDDBE4a751827de037E53D2", 1000000000000000000000, 1000000001585489599188)'

FixedAprSingleTokenStakingPullPayments

expected 999255479454829401319127 to equal 999255479453640284119736.

FixedAprSingleTokenStakingPullPayments

VM Exception while processing transaction: reverted with custom error 'ERC20InsufficientBalance("0x22a9B82A6c3D2BFB68F324B2e8367f346Dd6f32a", 1000000000000000000000, 1001369864599188229325)'

FixedAprSingleTokenStakingPullPayments

VM Exception while processing transaction: reverted with custom error 'ERC20InsufficientBalance("0x9fD16eA9E31233279975D99D5e8Fc91dd214c7Da",

so now I conveyed the result to the prompt and it gave me following response

I updated the generated code to address the failures you pasted. The fixes target three root causes showing up in your logs:

Rounding drift in reward math (your “expected X to equal Y” diffs like 250000001585... vs 250000000000...)

I changed reward calculation in both _accrue() and pendingRewards() to use OpenZeppelin Math.mulDiv in a deterministic way:
step1: base = mulDiv(principal, aprBps, RATE_DENOMINATOR)
step2: reward = mulDiv(base, elapsed, YEAR) This reduces rounding variance and keeps view vs state accrual consistent.
withdraw() not reverting with "nothing owed"

Your tests expect a fresh user calling withdraw() to revert with "nothing owed".
If withdraw() calls _accrue() unconditionally, it can initialize lastAccrualTime and change behavior.
I adjusted withdraw() so it only accrues when the user already has an accrual checkpoint and a positive stake; otherwise it goes straight to checking owedBalance and reverts with "nothing owed" as expected.
ERC20 custom errors / insufficient balance on rewards

The errors like ERC20InsufficientBalance(...) indicate the contract didn’t have enough tokens to pay rewards at withdraw time (tests usually call fundContract() for this, but some tests intentionally don’t).
We keep SafeERC20 so these failures still revert (which matches .to.revert(ethers) style expectations).
If you run the suite again now, the remaining failures (if any) should be fewer and more specific. Paste the first remaining failing test name + assertion/revert output and I’ll apply the next minimal patch.

Now I clicked on generate test to see the results

These are the results and now 11 tests got failed

You can now see that we have the whole detailed test results for each test that get performed since I want to see further refinements in test so I clicked on generate new so it not only calculates the test results but also generate new unit tests so that they can be tested adhering to the testing results. You can also download the test for your ease as well as per below screenshot.

This update has now further make the Kode Sherpa more robust and in next post we will explore that how we can further reduce the errors in our contract using Kode Sherpa so that we can achieve 100 percent coverage just we achieved in foundry.

Modification of Kode Sherpa Contract

Syed Ghufran Hassan — Sat, 28 Mar 2026 07:54:04 +0000

In my previous article Generating Unit Tests From Kode Sherpa I discussed about unit tests generation and generated unit tests as approx 9 tests were failing so in this article we will now modify the test to foundry and then compile in foundry so that we can analyze that if the generated smart contract is adhering error free compilation from Kode Sherpa.

The test suite created looking at hardhat in foundry

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.20;

import "forge-std/Test.sol";

// --------------------------------------------------
// Minimal MockERC20 (self-contained)
// --------------------------------------------------
contract MockERC20 {
    string public name = "MockToken";
    string public symbol = "MTK";
    uint8 public decimals = 18;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    function mint(address to, uint256 amount) external {
        balanceOf[to] += amount;
    }

    function approve(address spender, uint256 amount) external returns (bool) {
        allowance[msg.sender][spender] = amount;
        return true;
    }

    function transfer(address to, uint256 amount) external returns (bool) {
        require(balanceOf[msg.sender] >= amount, "balance too low");
        balanceOf[msg.sender] -= amount;
        balanceOf[to] += amount;
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) external returns (bool) {
        require(balanceOf[from] >= amount, "balance too low");
        require(allowance[from][msg.sender] >= amount, "allowance too low");

        allowance[from][msg.sender] -= amount;
        balanceOf[from] -= amount;
        balanceOf[to] += amount;

        return true;
    }
}

// --------------------------------------------------
// Import your staking contract
// --------------------------------------------------
import "../src/FixedAprSingleTokenStakingPullPayments.sol";

// --------------------------------------------------
// Test Contract
// --------------------------------------------------
contract FixedAprSingleTokenStakingTest is Test {
    MockERC20 stakingToken;
    FixedAprSingleTokenStakingPullPayments staking;

    address alice = address(1);
    address bob = address(2);

    uint256 stakeAmount = 1000 ether;
    uint256 stakeAmount2 = 250 ether;
    uint256 mintAmount = 1_000_000 ether;

    function setUp() public {
        stakingToken = new MockERC20();
        staking = new FixedAprSingleTokenStakingPullPayments(IERC20(address(stakingToken)));

        stakingToken.mint(alice, mintAmount);
        stakingToken.mint(bob, mintAmount);
    }

    // ----------------------------
    // Constructor
    // ----------------------------
    function testConstructor() public {
        assertEq(address(staking.stakingToken()), address(stakingToken));
        assertEq(staking.aprBps(), 500);
        assertEq(staking.totalStaked(), 0);
    }

    function testConstructorRevertZeroAddress() public {
        vm.expectRevert("staking token is zero");
         new FixedAprSingleTokenStakingPullPayments(IERC20(address(0)));
    }

    // ----------------------------
    // Stake
    // ----------------------------
    function testStake() public {
        vm.startPrank(alice);

        stakingToken.approve(address(staking), stakeAmount);
        staking.stake(stakeAmount);

        assertEq(staking.stakedBalance(alice), stakeAmount);
        assertEq(staking.totalStaked(), stakeAmount);

        vm.stopPrank();
    }

    function testStakeRevertZero() public {
        vm.prank(alice);
        vm.expectRevert("amount=0");
        staking.stake(0);
    }

    function testStakeAccrual() public {
        vm.startPrank(alice);

        stakingToken.approve(address(staking), stakeAmount + stakeAmount2);

        staking.stake(stakeAmount);

        vm.warp(block.timestamp + 30 days);

        staking.stake(stakeAmount2);

        assertGt(staking.owedBalance(alice), 0);

        vm.stopPrank();
    }

    // ----------------------------
    // Unstake
    // ----------------------------
    function testUnstake() public {
        vm.startPrank(alice);

        stakingToken.approve(address(staking), stakeAmount);
        staking.stake(stakeAmount);

        staking.unstake(stakeAmount2);

        assertEq(staking.stakedBalance(alice), stakeAmount - stakeAmount2);
        assertEq(staking.owedBalance(alice), stakeAmount2);

        vm.stopPrank();
    }

    function testUnstakeWithRewards() public {
        vm.startPrank(alice);

        stakingToken.approve(address(staking), stakeAmount);
        staking.stake(stakeAmount);

        vm.warp(block.timestamp + 60 days);

        staking.unstake(stakeAmount2);

        assertGt(staking.owedBalance(alice), stakeAmount2);

        vm.stopPrank();
    }

    // ----------------------------
    // Withdraw
    // ----------------------------
    function testWithdrawPrincipal() public {
        vm.startPrank(alice);

        stakingToken.approve(address(staking), stakeAmount);
        staking.stake(stakeAmount);

        staking.unstake(stakeAmount2);

        uint256 owed = staking.owedBalance(alice);

        staking.withdraw();

        assertEq(staking.owedBalance(alice), 0);
        assertEq(stakingToken.balanceOf(alice), mintAmount - stakeAmount + owed);

        vm.stopPrank();
    }

    function testWithdrawRewards() public {
        vm.startPrank(alice);

        stakingToken.approve(address(staking), stakeAmount);
        staking.stake(stakeAmount);

        vm.warp(block.timestamp + 90 days);

        uint256 beforeBal = stakingToken.balanceOf(alice);

        staking.withdraw();

        uint256 afterBal = stakingToken.balanceOf(alice);

        assertGt(afterBal, beforeBal);

        vm.stopPrank();
    }

    function testWithdrawRevert() public {
        vm.prank(alice);
        vm.expectRevert("nothing owed");
        staking.withdraw();
    }

    // ----------------------------
    // View functions
    // ----------------------------
    function testPendingRewardsGrowth() public {
        vm.startPrank(alice);

        stakingToken.approve(address(staking), stakeAmount + stakeAmount2);

        staking.stake(stakeAmount);

        vm.warp(block.timestamp + 10 days);
        staking.stake(stakeAmount2);

        vm.warp(block.timestamp + 5 days);
        uint256 p1 = staking.pendingRewards(alice);

        vm.warp(block.timestamp + 5 days);
        uint256 p2 = staking.pendingRewards(alice);

        assertGt(p1, 0);
        assertGt(p2, p1);

        vm.stopPrank();
    }

    function testWithdrawable() public {
        vm.startPrank(alice);

        stakingToken.approve(address(staking), stakeAmount);
        staking.stake(stakeAmount);

        staking.unstake(stakeAmount2);

        assertEq(staking.withdrawable(alice), stakeAmount2);

        vm.stopPrank();
    }

    // ----------------------------
    // Multi-user
    // ----------------------------
    function testMultiUser() public {
        vm.startPrank(alice);
        stakingToken.approve(address(staking), stakeAmount);
        staking.stake(stakeAmount);
        vm.stopPrank();

        vm.startPrank(bob);
        stakingToken.approve(address(staking), stakeAmount2);
        staking.stake(stakeAmount2);
        vm.stopPrank();

        vm.warp(block.timestamp + 45 days);

        vm.prank(alice);
        staking.unstake(stakeAmount2);

        assertGt(staking.owedBalance(alice), stakeAmount2);
        assertEq(staking.owedBalance(bob), 0);
    }
}

Now based on the above test suite I ran the foundry test and this was my output

To further check if my test is utilizing 100 percent coverage so I ran forge coverage and this was my result

Based on this result I can fairly conclude that the below generated contract from Kode Sherpa is exhibiting 100 percent coverage for contract and test as well.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

/**
 * @title FixedAprSingleTokenStakingPullPayments
 * @author akb
 * @notice Single-token ERC20 staking with fixed immutable APR rewards (in bps) and pull-payment withdrawals.
 *         - Stake/unstake only update accounting (no user transfers).
 *         - withdraw() is the only function that transfers tokens to users (principal + rewards).
 */
contract FixedAprSingleTokenStakingPullPayments is ReentrancyGuard {
    using SafeERC20 for IERC20;

    /**
     * @notice ERC20 token that users stake and in which rewards are paid.
     */
    IERC20 public immutable stakingToken;

    /**
     * @notice Basis points denominator used for APR calculations.
     * @dev 10,000 bps = 100%.
     */
    uint256 public constant RATE_DENOMINATOR = 10_000;

    /**
     * @notice Number of seconds used as one year for APR calculations.
     * @dev Fixed to 365 days.
     */
    uint256 public constant YEAR = 365 days;

    /**
     * @notice Fixed APR expressed in basis points (bps).
     * @dev Immutable and set in the constructor. Example: 500 bps = 5.00% APR.
     */
    uint256 public immutable aprBps;

    /**
     * @notice Amount of principal currently staked by each user.
     */
    mapping(address => uint256) public stakedBalance;

    /**
     * @notice Pull-payment balance owed to each user (principal moved out + accrued rewards).
     */
    mapping(address => uint256) public owedBalance;

    /**
     * @notice Last timestamp at which rewards were accrued/settled for each user.
     */
    mapping(address => uint256) public lastAccrualTime;

    /**
     * @notice Total principal staked across all users.
     */
    uint256 public totalStaked;

    // Events (must match tests exactly)
    event Staked(address indexed user, uint256 amount);
    event Unstaked(address indexed user, uint256 amount, uint256 creditedToOwed);
    event RewardsAccrued(address indexed user, uint256 reward, uint256 fromTime, uint256 toTime);
    event Withdrawn(address indexed user, uint256 amount);

    /**
     * @notice Creates the staking contract for a given ERC20 token.
     * @param _stakingToken The ERC20 token to be staked and used for reward payouts.
     */
    constructor(IERC20 _stakingToken) {
        require(address(_stakingToken) != address(0), "staking token is zero");
        stakingToken = _stakingToken;

        // Immutable APR set to 5.00% (500 bps)
        aprBps = 500;
    }

    /**
     * @notice Stake tokens. Requires prior approval.
     * @dev Settles rewards up to now before changing principal.
     * @param amount The amount of tokens to stake.
     */
    function stake(uint256 amount) external nonReentrant {
        require(amount > 0, "amount=0");

        // Must initialize lastAccrualTime on first stake (via _accrue)
        _accrue(msg.sender);

        stakingToken.safeTransferFrom(msg.sender, address(this), amount);

        stakedBalance[msg.sender] += amount;
        totalStaked += amount;

        emit Staked(msg.sender, amount);
    }

    /**
     * @notice Unstake tokens (principal). Does NOT transfer tokens to the user.
     * @dev Settles rewards up to now, then moves unstaked principal into owedBalance (pull pattern).
     * @param amount The amount of principal to unstake.
     */
    function unstake(uint256 amount) external nonReentrant {
        require(amount > 0, "amount=0");

        _accrue(msg.sender);

        require(stakedBalance[msg.sender] >= amount, "insufficient staked");

        stakedBalance[msg.sender] -= amount;
        totalStaked -= amount;

        owedBalance[msg.sender] += amount;

        emit Unstaked(msg.sender, amount, amount);
    }

    /**
     * @notice Withdraw owed tokens (principal + rewards).
     * @dev This is the ONLY function that transfers tokens to users.
     */
    function withdraw() external nonReentrant {
        _accrue(msg.sender);

        uint256 owed = owedBalance[msg.sender];
        require(owed > 0, "nothing owed");

        owedBalance[msg.sender] = 0;
        stakingToken.safeTransfer(msg.sender, owed);

        emit Withdrawn(msg.sender, owed);
    }

    /**
     * @notice View function to estimate pending rewards since last accrual (not yet credited to owedBalance).
     * @param user The address to query.
     * @return The amount of rewards accrued since the last checkpoint.
     */
    function pendingRewards(address user) external view returns (uint256) {
        uint256 principal = stakedBalance[user];
        if (principal == 0) return 0;

        uint256 last = lastAccrualTime[user];
        if (last == 0) return 0;

        uint256 elapsed = block.timestamp - last;
        if (elapsed == 0) return 0;

        return (principal * aprBps * elapsed) / YEAR / RATE_DENOMINATOR;
    }

    /**
     * @notice View function for total withdrawable amount (already owed; does not include unaccrued pending rewards).
     */
    function withdrawable(address user) external view returns (uint256) {
        return owedBalance[user];
    }

    /**
     * @dev Accrues rewards for `user` from lastAccrualTime to now and credits them to owedBalance.
     *      Emits RewardsAccrued when reward > 0 with fromTime=last and toTime=block.timestamp.
     */
    function _accrue(address user) internal {
        uint256 last = lastAccrualTime[user];

        // Initialize checkpoint on first interaction; no retroactive rewards.
        if (last == 0) {
            lastAccrualTime[user] = block.timestamp;
            return;
        }

        uint256 principal = stakedBalance[user];
        uint256 toTime = block.timestamp;

        if (toTime <= last) return;

        // No principal: just move checkpoint forward.
        if (principal == 0) {
            lastAccrualTime[user] = toTime;
            return;
        }

        uint256 elapsed = toTime - last;
        uint256 reward = (principal * aprBps * elapsed) / YEAR / RATE_DENOMINATOR;

        lastAccrualTime[user] = toTime;

        if (reward > 0) {
            owedBalance[user] += reward;
            emit RewardsAccrued(user, reward, last, toTime);
        }
    }
}

The only tweak I did was introducing ERC20 interfaces in the contract and then adding reentracny guard properly pointing towards util folder rather than security folder.

In the next lesson we will further explore Kode Sherpa features.

Generating Unit Tests from Kode Sherpa

Syed Ghufran Hassan — Sun, 22 Mar 2026 17:00:09 +0000

Continuing from our previous post https://dev.to/syedghufranhassan/introducing-kodesherpa-build-defi-smart-contracts-with-ease-55oo I presented how kode sherpa ease dev's life by generating smart contract based on the prompts with the protocol level questions asked as prompts which generated smart contract based on all the possible scenarios. Now we will get to know that how we can generate the unit test of our smart contract.

Based on this, you can see that on right hand side, there is option for generate unit tests.

This will then generate tests and based on the contract, will generate the score accordingly.

The test tells that 9 out of 45 tests are failing so in the next post we will then analyze the below test generated by Kode Sherpa and then will modify the test and contract accordingly.

import hre from "hardhat";
import { expect } from "chai";

describe("FixedAprSingleTokenStakingPullPayments", function () {
  // Ethers (Hardhat 3 network connect)
  let ethers: any;

  // Signers
  let owner: any;
  let alice: any;
  let bob: any;
  let carol: any;
  let addrs: any[];

  // Contracts
  let staking: any;
  let stakingToken: any;

  // Common values (initialized after ethers is available)
  let zeroAddress: any;
  let aprBpsExpected: any;
  let rateDenominatorExpected: any;
  let yearExpected: any;

  let stakeAmount: any;
  let stakeAmount2: any;
  let mintAmount: any;

  before(async function () {
    ({ ethers } = await hre.network.connect());

    zeroAddress = ethers.ZeroAddress;
    aprBpsExpected = 500n;
    rateDenominatorExpected = 10_000n;
    yearExpected = 365n * 24n * 60n * 60n;

    stakeAmount = ethers.parseUnits("1000", 18);
    stakeAmount2 = ethers.parseUnits("250", 18);
    mintAmount = ethers.parseUnits("1000000", 18);
  });

  async function increaseTime(seconds: any): Promise<void> {
    await ethers.provider.send("evm_increaseTime", [seconds]);
    await ethers.provider.send("evm_mine", []);
  }

  async function latestTimestamp(): Promise<any> {
    const block = await ethers.provider.getBlock("latest");
    return BigInt(block.timestamp);
  }

  async function deployFresh(): Promise<void> {
    const MockERC20Factory = await ethers.getContractFactory("MockERC20");
    stakingToken = await MockERC20Factory.deploy();
    await stakingToken.waitForDeployment();

    const StakingFactory = await ethers.getContractFactory("FixedAprSingleTokenStakingPullPayments");
    staking = await StakingFactory.deploy(await stakingToken.getAddress());
    await staking.waitForDeployment();

    // Fund users
    await stakingToken.mint(await owner.getAddress(), mintAmount);
    await stakingToken.mint(await alice.getAddress(), mintAmount);
    await stakingToken.mint(await bob.getAddress(), mintAmount);
    await stakingToken.mint(await carol.getAddress(), mintAmount);
  }

  beforeEach(async function () {
    [owner, alice, bob, carol, ...addrs] = await ethers.getSigners();
    await deployFresh();
  });

  // ---------------------------------------------------------------------------
  // Mandatory extraction (as comments, exact names/signatures)
  // ---------------------------------------------------------------------------
  // CONTRACT NAME: FixedAprSingleTokenStakingPullPayments
  // PUBLIC STATE VARIABLES:
  // - stakingToken() public view returns (address) [IERC20 public immutable stakingToken]
  // - RATE_DENOMINATOR() public view returns (uint256) [uint256 public constant RATE_DENOMINATOR]
  // - YEAR() public view returns (uint256) [uint256 public constant YEAR]
  // - aprBps() public view returns (uint256) [uint256 public immutable aprBps]
  // - stakedBalance(address) public view returns (uint256) [mapping(address => uint256) public stakedBalance]
  // - owedBalance(address) public view returns (uint256) [mapping(address => uint256) public owedBalance]
  // - lastAccrualTime(address) public view returns (uint256) [mapping(address => uint256) public lastAccrualTime]
  // - totalStaked() public view returns (uint256) [uint256 public totalStaked]
  // PUBLIC/EXTERNAL FUNCTIONS:
  // - stake(uint256 amount) external
  // - unstake(uint256 amount) external
  // - withdraw() external
  // - pendingRewards(address user) external view returns (uint256)
  // - withdrawable(address user) external view returns (uint256)
  // MAPPINGS:
  // - stakedBalance (mapping(address => uint256))
  // - owedBalance (mapping(address => uint256))
  // - lastAccrualTime (mapping(address => uint256))
  // STRUCTS: none
  // EVENTS:
  // - Staked(address indexed user, uint256 amount)
  // - Unstaked(address indexed user, uint256 amount, uint256 creditedToOwed)
  // - RewardsAccrued(address indexed user, uint256 reward, uint256 fromTime, uint256 toTime)
  // - Withdrawn(address indexed user, uint256 amount)

  // ---------------------------------------------------------------------------
  // Constructor
  // ---------------------------------------------------------------------------
  describe("Constructor", function () {
    it("sets stakingToken immutable correctly", async function () {
      expect(await staking.stakingToken()).to.equal(await stakingToken.getAddress());
    });

    it("sets aprBps immutable to 500", async function () {
      expect(await staking.aprBps()).to.equal(aprBpsExpected);
    });

    it("exposes constants RATE_DENOMINATOR and YEAR", async function () {
      expect(await staking.RATE_DENOMINATOR()).to.equal(rateDenominatorExpected);
      expect(await staking.YEAR()).to.equal(yearExpected);
    });

    it("initializes totalStaked to 0", async function () {
      expect(await staking.totalStaked()).to.equal(0n);
    });

    it("reverts if staking token is zero address", async function () {
      const StakingFactory = await ethers.getContractFactory("FixedAprSingleTokenStakingPullPayments");
      await expect(StakingFactory.deploy(zeroAddress)).to.be.revertedWith("staking token is zero");
    });
  });

  // ---------------------------------------------------------------------------
  // stake(uint256)
  // ---------------------------------------------------------------------------
  describe("stake(uint256)", function () {
    it("reverts when amount is 0", async function () {
      await expect(staking.connect(alice).stake(0)).to.be.revertedWith("amount=0");
    });

    it("transfers tokens from user to contract and updates stakedBalance and totalStaked", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);

      const contractAddr = await staking.getAddress();

      const aliceBefore = await stakingToken.balanceOf(await alice.getAddress());
      const contractBefore = await stakingToken.balanceOf(contractAddr);

      await expect(staking.connect(alice).stake(stakeAmount))
        .to.emit(staking, "Staked")
        .withArgs(await alice.getAddress(), stakeAmount);

      expect(await staking.stakedBalance(await alice.getAddress())).to.equal(stakeAmount);
      expect(await staking.totalStaked()).to.equal(stakeAmount);

      const aliceAfter = await stakingToken.balanceOf(await alice.getAddress());
      const contractAfter = await stakingToken.balanceOf(contractAddr);

      expect(aliceAfter).to.equal(aliceBefore - stakeAmount);
      expect(contractAfter).to.equal(contractBefore + stakeAmount);
    });

    it("sets lastAccrualTime on first interaction (stake) and does not credit owedBalance immediately", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);

      const lastBefore = await staking.lastAccrualTime(await alice.getAddress());
      expect(lastBefore).to.equal(0n);

      const tsBefore = await latestTimestamp();
      await staking.connect(alice).stake(stakeAmount);
      const tsAfter = await latestTimestamp();

      const lastAfter = await staking.lastAccrualTime(await alice.getAddress());
      expect(lastAfter).to.be.gte(tsBefore);
      expect(lastAfter).to.be.lte(tsAfter);

      expect(await staking.owedBalance(await alice.getAddress())).to.equal(0n);
    });

    it("accrues rewards into owedBalance on subsequent stake and emits RewardsAccrued when reward > 0", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount + stakeAmount2);

      // First stake initializes checkpoint
      await staking.connect(alice).stake(stakeAmount);
      const last1 = await staking.lastAccrualTime(await alice.getAddress());
      expect(last1).to.not.equal(0n);

      // Wait some time to generate rewards
      await increaseTime(30 * 24 * 60 * 60); // 30 days

      // Second stake should accrue rewards for the first principal
      const tx = await staking.connect(alice).stake(stakeAmount2);
      const receipt = await tx.wait();

      // Verify state updates
      expect(await staking.stakedBalance(await alice.getAddress())).to.equal(stakeAmount + stakeAmount2);
      expect(await staking.totalStaked()).to.equal(stakeAmount + stakeAmount2);

      // Rewards should be credited to owedBalance (likely > 0 for 30 days at 5% APR on 1000 tokens)
      const owed = await staking.owedBalance(await alice.getAddress());
      expect(owed).to.be.gt(0n);

      // Check RewardsAccrued event exists in receipt logs (don’t assume exact reward)
      const parsed = receipt.logs
        .map((l: any) => {
          try {
            return staking.interface.parseLog(l);
          } catch {
            return null;
          }
        })
        .filter((x: any) => x && x.name === "RewardsAccrued");

      expect(parsed.length).to.be.greaterThan(0);

      const ev = parsed[0];
      expect(ev.args.user).to.equal(await alice.getAddress());
      expect(BigInt(ev.args.reward)).to.be.gt(0n);
      expect(BigInt(ev.args.toTime)).to.be.gte(BigInt(ev.args.fromTime));
    });

    it("reverts if allowance is insufficient", async function () {
      // Approve less than stakeAmount
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount - 1n);
      await expect(staking.connect(alice).stake(stakeAmount)).to.revert(ethers);
    });

    it("reverts if balance is insufficient even with allowance", async function () {
      const richAmount = ethers.parseUnits("999999999", 18);
      await stakingToken.connect(alice).approve(await staking.getAddress(), richAmount);
      await expect(staking.connect(alice).stake(richAmount)).to.revert(ethers);
    });

    it("supports multiple users staking and totalStaked equals sum", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await stakingToken.connect(bob).approve(await staking.getAddress(), stakeAmount2);

      await staking.connect(alice).stake(stakeAmount);
      await staking.connect(bob).stake(stakeAmount2);

      expect(await staking.stakedBalance(await alice.getAddress())).to.equal(stakeAmount);
      expect(await staking.stakedBalance(await bob.getAddress())).to.equal(stakeAmount2);
      expect(await staking.totalStaked()).to.equal(stakeAmount + stakeAmount2);
    });
  });

  // ---------------------------------------------------------------------------
  // unstake(uint256)
  // ---------------------------------------------------------------------------
  describe("unstake(uint256)", function () {
    beforeEach(async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);
    });

    it("reverts when amount is 0", async function () {
      await expect(staking.connect(alice).unstake(0)).to.be.revertedWith("amount=0");
    });

    it("reverts when user has insufficient staked", async function () {
      await expect(staking.connect(alice).unstake(stakeAmount + 1n)).to.be.revertedWith("insufficient staked");
    });

    it("moves principal from stakedBalance to owedBalance and reduces totalStaked; emits Unstaked", async function () {
      const unstakeAmt = stakeAmount2;

      const owedBefore = await staking.owedBalance(await alice.getAddress());
      const stakedBefore = await staking.stakedBalance(await alice.getAddress());
      const totalBefore = await staking.totalStaked();

      await expect(staking.connect(alice).unstake(unstakeAmt))
        .to.emit(staking, "Unstaked")
        .withArgs(await alice.getAddress(), unstakeAmt, unstakeAmt);

      expect(await staking.stakedBalance(await alice.getAddress())).to.equal(stakedBefore - unstakeAmt);
      expect(await staking.totalStaked()).to.equal(totalBefore - unstakeAmt);
      expect(await staking.owedBalance(await alice.getAddress())).to.equal(owedBefore + unstakeAmt);
    });

    it("does not transfer tokens to user on unstake (pull-payment pattern)", async function () {
      const userAddr = await alice.getAddress();
      const contractAddr = await staking.getAddress();

      const aliceBalBefore = await stakingToken.balanceOf(userAddr);
      const contractBalBefore = await stakingToken.balanceOf(contractAddr);

      await staking.connect(alice).unstake(stakeAmount2);

      const aliceBalAfter = await stakingToken.balanceOf(userAddr);
      const contractBalAfter = await stakingToken.balanceOf(contractAddr);

      expect(aliceBalAfter).to.equal(aliceBalBefore);
      expect(contractBalAfter).to.equal(contractBalBefore);
    });

    it("accrues rewards before unstake and credits them to owedBalance (owed increases by > principal unstaked over time)", async function () {
      await increaseTime(60 * 24 * 60 * 60); // 60 days

      const owedBefore = await staking.owedBalance(await alice.getAddress());
      await staking.connect(alice).unstake(stakeAmount2);
      const owedAfter = await staking.owedBalance(await alice.getAddress());

      // owedAfter should include principal unstaked + some rewards (not exact)
      expect(owedAfter).to.be.gt(owedBefore + stakeAmount2);
    });

    it("can unstake full amount leaving stakedBalance 0 and totalStaked 0", async function () {
      await staking.connect(alice).unstake(stakeAmount);
      expect(await staking.stakedBalance(await alice.getAddress())).to.equal(0n);
      expect(await staking.totalStaked()).to.equal(0n);
      expect(await staking.owedBalance(await alice.getAddress())).to.equal(stakeAmount);
    });

    it("updates lastAccrualTime on unstake (checkpoint moves forward)", async function () {
      const lastBefore = await staking.lastAccrualTime(await alice.getAddress());
      await increaseTime(7 * 24 * 60 * 60);

      await staking.connect(alice).unstake(stakeAmount2);

      const lastAfter = await staking.lastAccrualTime(await alice.getAddress());
      expect(lastAfter).to.be.gt(lastBefore);
    });
  });

  // ---------------------------------------------------------------------------
  // withdraw()
  // ---------------------------------------------------------------------------
  describe("withdraw()", function () {
    it("reverts when nothing owed (never staked)", async function () {
      await expect(staking.connect(alice).withdraw()).to.be.revertedWith("nothing owed");
    });

    it("reverts when user has staked but has no owedBalance and no rewards accrued yet (immediate withdraw)", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);

      // Immediately withdraw: _accrue sees last != 0 and elapsed may be 0 => no reward; owed still 0
      await expect(staking.connect(alice).withdraw()).to.be.revertedWith("nothing owed");
    });

    it("allows withdrawing unstaked principal; sets owedBalance to 0; emits Withdrawn", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);

      await staking.connect(alice).unstake(stakeAmount2);

      const owed = await staking.owedBalance(await alice.getAddress());
      expect(owed).to.equal(stakeAmount2);

      const aliceBalBefore = await stakingToken.balanceOf(await alice.getAddress());

      await expect(staking.connect(alice).withdraw())
        .to.emit(staking, "Withdrawn")
        .withArgs(await alice.getAddress(), owed);

      const aliceBalAfter = await stakingToken.balanceOf(await alice.getAddress());
      expect(aliceBalAfter).to.equal(aliceBalBefore + owed);
      expect(await staking.owedBalance(await alice.getAddress())).to.equal(0n);
    });

    it("allows withdrawing accrued rewards without unstaking (after time passes)", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);

      await increaseTime(90 * 24 * 60 * 60); // 90 days

      // withdraw() accrues then transfers owedBalance (rewards only, since no unstake)
      const owedBefore = await staking.owedBalance(await alice.getAddress());
      expect(owedBefore).to.equal(0n);

      const aliceBalBefore = await stakingToken.balanceOf(await alice.getAddress());
      const tx = await staking.connect(alice).withdraw();
      const receipt = await tx.wait();

      // Find Withdrawn amount from event
      const parsed = receipt.logs
        .map((l: any) => {
          try {
            return staking.interface.parseLog(l);
          } catch {
            return null;
          }
        })
        .filter((x: any) => x && x.name === "Withdrawn");
      expect(parsed.length).to.equal(1);

      const withdrawnAmount = BigInt(parsed[0].args.amount);
      expect(withdrawnAmount).to.be.gt(0n);

      const aliceBalAfter = await stakingToken.balanceOf(await alice.getAddress());
      expect(aliceBalAfter).to.equal(aliceBalBefore + withdrawnAmount);
      expect(await staking.owedBalance(await alice.getAddress())).to.equal(0n);
    });

    it("emits RewardsAccrued during withdraw when rewards > 0", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);

      await increaseTime(30 * 24 * 60 * 60);

      const tx = await staking.connect(alice).withdraw();
      const receipt = await tx.wait();

      const accrued = receipt.logs
        .map((l: any) => {
          try {
            return staking.interface.parseLog(l);
          } catch {
            return null;
          }
        })
        .filter((x: any) => x && x.name === "RewardsAccrued");

      expect(accrued.length).to.be.greaterThan(0);
      expect(accrued[0].args.user).to.equal(await alice.getAddress());
      expect(BigInt(accrued[0].args.reward)).to.be.gt(0n);
    });

    it("reverts if contract does not have enough tokens to pay owed (simulate by draining contract)", async function () {
      // Stake from Alice so contract holds principal
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);

      // Unstake some principal to create owed
      await staking.connect(alice).unstake(stakeAmount2);

      // Drain contract tokens by transferring away from contract using owner? Can't directly.
      // Instead: have owner stake then withdraw? Not possible without owed.
      // Practical simulation: move contract balance out by using the token itself if it allows arbitrary transferFrom.
      // MockERC20 typically is standard ERC20; contract cannot approve. So we simulate shortage by accruing rewards
      // larger than contract balance: mint nothing extra and withdraw after long time.
      // We can reduce contract balance by having owner stake and then unstake+withdraw principal to remove tokens,
      // leaving only Alice's owed but insufficient for rewards. However owner can't withdraw without owed.
      // We'll do: owner stakes big, waits, unstakes all, withdraws (takes tokens out), leaving contract low.
      const big = ethers.parseUnits("500000", 18);

      await stakingToken.connect(owner).approve(await staking.getAddress(), big);
      await staking.connect(owner).stake(big);

      // Let both accrue a lot so rewards are non-trivial
      await increaseTime(365 * 24 * 60 * 60); // 1 year

      // Owner unstakes all and withdraws (pulls out principal+rewards), draining contract
      await staking.connect(owner).unstake(big);
      await staking.connect(owner).withdraw();

      // Now Alice tries to withdraw; may revert if contract balance insufficient
      await increaseTime(365 * 24 * 60 * 60); // another year to increase owed via rewards
      await expect(staking.connect(alice).withdraw()).to.revert(ethers);
    });

    it("gas usage sanity: withdraw should not exceed a reasonable bound in a simple case", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);
      await staking.connect(alice).unstake(stakeAmount2);

      const tx = await staking.connect(alice).withdraw();
      const receipt = await tx.wait();

      expect(Number(receipt.gasUsed)).to.be.lessThan(250000);
    });
  });

  // ---------------------------------------------------------------------------
  // pendingRewards(address) view
  // ---------------------------------------------------------------------------
  describe("pendingRewards(address)", function () {
    it("returns 0 when principal is 0 (never staked)", async function () {
      expect(await staking.pendingRewards(await alice.getAddress())).to.equal(0n);
    });

    it("returns 0 when lastAccrualTime is 0 even if stakedBalance would be > 0 (not possible externally, but validate current behavior)", async function () {
      // Normal flow: stake sets lastAccrualTime. So for a fresh user it's 0 and stakedBalance is 0.
      expect(await staking.lastAccrualTime(await alice.getAddress())).to.equal(0n);
      expect(await staking.pendingRewards(await alice.getAddress())).to.equal(0n);
    });

    it("returns 0 immediately after first stake because lastAccrualTime was just initialized (or elapsed=0)", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);

      const pending = await staking.pendingRewards(await alice.getAddress());
      expect(pending).to.equal(0n);
    });

    it("increases over time for a staker after at least one checkpoint exists", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount + stakeAmount2);

      // First stake initializes lastAccrualTime
      await staking.connect(alice).stake(stakeAmount);

      // Second interaction creates a checkpoint with elapsed > 0, moving lastAccrualTime forward
      await increaseTime(10 * 24 * 60 * 60);
      await staking.connect(alice).stake(stakeAmount2);

      // Now pendingRewards should grow with time
      await increaseTime(5 * 24 * 60 * 60);
      const p1 = await staking.pendingRewards(await alice.getAddress());
      await increaseTime(5 * 24 * 60 * 60);
      const p2 = await staking.pendingRewards(await alice.getAddress());

      expect(p1).to.be.gt(0n);
      expect(p2).to.be.gt(p1);
    });

    it("returns 0 when elapsed is 0 (same block) after a checkpoint update", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount + stakeAmount2);
      await staking.connect(alice).stake(stakeAmount);

      await increaseTime(2 * 24 * 60 * 60);
      await staking.connect(alice).stake(stakeAmount2);

      // Immediately query in same block (no time increase)
      const pending = await staking.pendingRewards(await alice.getAddress());
      expect(pending).to.equal(0n);
    });
  });

  // ---------------------------------------------------------------------------
  // withdrawable(address) view
  // ---------------------------------------------------------------------------
  describe("withdrawable(address)", function () {
    it("returns 0 for a fresh user", async function () {
      expect(await staking.withdrawable(await alice.getAddress())).to.equal(0n);
    });

    it("returns principal moved to owedBalance after unstake", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);

      await staking.connect(alice).unstake(stakeAmount2);

      expect(await staking.withdrawable(await alice.getAddress())).to.equal(stakeAmount2);
    });

    it("does not include pending rewards until a state-changing action accrues them", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);

      await increaseTime(60 * 24 * 60 * 60);

      const pending = await staking.pendingRewards(await alice.getAddress());
      expect(pending).to.be.gt(0n);

      // withdrawable should still be 0 because rewards not yet credited
      expect(await staking.withdrawable(await alice.getAddress())).to.equal(0n);
    });

    it("increases after an action that triggers _accrue (e.g., unstake) without withdrawing", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);

      await increaseTime(120 * 24 * 60 * 60);

      const withdrawableBefore = await staking.withdrawable(await alice.getAddress());
      expect(withdrawableBefore).to.equal(0n);

      await staking.connect(alice).unstake(stakeAmount2);

      const withdrawableAfter = await staking.withdrawable(await alice.getAddress());
      // Should be > principal unstaked due to rewards accrued
      expect(withdrawableAfter).to.be.gt(stakeAmount2);
    });

    it("resets to 0 after withdraw", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);

      await staking.connect(alice).unstake(stakeAmount2);
      expect(await staking.withdrawable(await alice.getAddress())).to.equal(stakeAmount2);

      await staking.connect(alice).withdraw();
      expect(await staking.withdrawable(await alice.getAddress())).to.equal(0n);
    });
  });

  // ---------------------------------------------------------------------------
  // Events (direct checks beyond function-level .emit)
  // ---------------------------------------------------------------------------
  describe("Events", function () {
    it("emits Staked with correct args", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await expect(staking.connect(alice).stake(stakeAmount))
        .to.emit(staking, "Staked")
        .withArgs(await alice.getAddress(), stakeAmount);
    });

    it("emits Unstaked with creditedToOwed equal to amount", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);

      await expect(staking.connect(alice).unstake(stakeAmount2))
        .to.emit(staking, "Unstaked")
        .withArgs(await alice.getAddress(), stakeAmount2, stakeAmount2);
    });

    it("emits Withdrawn with amount equal to owedBalance at time of withdrawal", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);
      await staking.connect(alice).unstake(stakeAmount2);

      const owed = await staking.owedBalance(await alice.getAddress());
      await expect(staking.connect(alice).withdraw())
        .to.emit(staking, "Withdrawn")
        .withArgs(await alice.getAddress(), owed);
    });
  });

  // ---------------------------------------------------------------------------
  // Security: ReentrancyGuard
  // ---------------------------------------------------------------------------
  describe("Security / ReentrancyGuard", function () {
    it("prevents reentrancy on stake via nonReentrant (cannot be directly exploited here)", async function () {
      // We can't easily craft a reentrant ERC20 callback with a plain ERC20.
      // But we can at least assert the function exists and behaves normally under standard token.
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);
      expect(await staking.stakedBalance(await alice.getAddress())).to.equal(stakeAmount);
    });

    it("prevents reentrancy on withdraw in presence of malicious token (not available with MockERC20) - sanity check", async function () {
      // Same limitation as above; ensure withdraw is nonReentrant by exercising it successfully.
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);
      await staking.connect(alice).unstake(stakeAmount2);
      await staking.connect(alice).withdraw();
      expect(await staking.owedBalance(await alice.getAddress())).to.equal(0n);
    });
  });

  // ---------------------------------------------------------------------------
  // Integration / multi-user / state transitions
  // ---------------------------------------------------------------------------
  describe("Integration scenarios", function () {
    it("multi-user: rewards accrue independently and do not affect each other's balances", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await stakingToken.connect(bob).approve(await staking.getAddress(), stakeAmount2);

      await staking.connect(alice).stake(stakeAmount);
      await staking.connect(bob).stake(stakeAmount2);

      await increaseTime(45 * 24 * 60 * 60);

      // Trigger accrual for Alice only via unstake
      await staking.connect(alice).unstake(stakeAmount2);

      const aliceOwed = await staking.owedBalance(await alice.getAddress());
      const bobOwed = await staking.owedBalance(await bob.getAddress());

      expect(aliceOwed).to.be.gt(stakeAmount2); // principal + some rewards
      expect(bobOwed).to.equal(0n); // bob hasn't interacted since stake; rewards not credited
    });

    it("state transitions: stake -> time -> unstake -> time -> withdraw withdraws principal+rewards and leaves staked intact for remaining principal", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);

      await increaseTime(30 * 24 * 60 * 60);
      await staking.connect(alice).unstake(stakeAmount2);

      const remaining = stakeAmount - stakeAmount2;
      expect(await staking.stakedBalance(await alice.getAddress())).to.equal(remaining);

      await increaseTime(30 * 24 * 60 * 60);

      const aliceBalBefore = await stakingToken.balanceOf(await alice.getAddress());
      const tx = await staking.connect(alice).withdraw();
      const receipt = await tx.wait();

      const parsed = receipt.logs
        .map((l: any) => {
          try {
            return staking.interface.parseLog(l);
          } catch {
            return null;
          }
        })
        .filter((x: any) => x && x.name === "Withdrawn");
      expect(parsed.length).to.equal(1);

      const withdrawnAmount = BigInt(parsed[0].args.amount);
      expect(withdrawnAmount).to.be.gt(stakeAmount2); // includes some rewards

      const aliceBalAfter = await stakingToken.balanceOf(await alice.getAddress());
      expect(aliceBalAfter).to.equal(aliceBalBefore + withdrawnAmount);

      // Remaining principal still staked and earning
      expect(await staking.stakedBalance(await alice.getAddress())).to.equal(remaining);
      expect(await staking.totalStaked()).to.equal(remaining);
    });

    it("checkpoint behavior: if principal becomes 0, later interactions advance lastAccrualTime but do not accrue rewards", async function () {
      await stakingToken.connect(alice).approve(await staking.getAddress(), stakeAmount);
      await staking.connect(alice).stake(stakeAmount);

      await increaseTime(10 * 24 * 60 * 60);
      await staking.connect(alice).unstake(stakeAmount); // principal now 0

      const lastAfterUnstake = await staking.lastAccrualTime(await alice.getAddress());
      expect(lastAfterUnstake).to.not.equal(0n);

      // Wait and then withdraw (will call _accrue with principal==0 => just advances checkpoint, no new rewards)
      await increaseTime(10 * 24 * 60 * 60);

      const owedBefore = await staking.owedBalance(await alice.getAddress());
      const tx = await staking.connect(alice).withdraw();
      await tx.wait();

      // owed should be 0 after withdraw
      expect(await staking.owedBalance(await alice.getAddress())).to.equal(0n);

      // lastAccrualTime should have advanced on withdraw even though principal is 0
      const lastAfterWithdraw = await staking.lastAccrualTime(await alice.getAddress());
      expect(lastAfterWithdraw).to.be.gt(lastAfterUnstake);

      // Rewards should not have increased owed beyond what was already owed before withdraw
      // (withdraw transfers owedBefore; we can't directly see amount now, but we can sanity check no revert)
      expect(owedBefore).to.be.gte(stakeAmount);
    });
  });
});

Introducing KodeSherpa: Build DeFi Smart Contracts with Ease

Syed Ghufran Hassan — Mon, 16 Mar 2026 10:58:22 +0000

If you’ve ever wanted to create DeFi smart contracts but struggled with tricky Solidity patterns like pull payments, staking rewards, or token accounting, Kode Sherpa is here to simplify your journey.

Exploration by Example

Recently, I explored building a staking contract with the pull-payment pattern, and here’s how Kode Sherpa helped streamline the process:

I came up with the analogous requirements for the contract

ERC20 token
Same as staked token
Fixed APR of 5% (500 bps)
Pull pattern for both principal and rewards
stake() and unstake() only update internal balances
withdraw() is the only function that transfers tokens to the user

Every step was based upon questions that was asked by the bot to reach for the proper spefications for the project.

KodeSherpa Exploration

Using Kode Sherpa, I was able to:

Define staking and rewards logic without worrying about unsafe direct transfers
Implement per-user checkpointing for accurate reward accrual
Apply the pull-payment pattern to protect against reentrancy issues
Lock APR immutably at deployment for predictable yield

Pull-Payment Pattern Benefits

Users pull their rewards and principal at their convenience
Protects against reentrancy and gas-limit attacks
Makes staking contracts safer and more modular

This is the contract which got generated

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";

contract FixedAprSingleTokenStakingPullPayments is ReentrancyGuard {
    IERC20 public immutable stakingToken;
    uint256 public immutable aprBps; // 500 = 5%
    uint256 private constant YEAR = 365 * 24 * 60 * 60;

    struct StakeInfo {
        uint256 principal;
        uint256 owedRewards;
        uint256 lastAccrualTime;
    }

    mapping(address => StakeInfo) public stakes;
    mapping(address => uint256) public owedBalance;

    constructor(IERC20 _stakingToken) {
        stakingToken = _stakingToken;
        aprBps = 500; // 5%
    }

    function stake(uint256 amount) external {
        require(amount > 0, "Amount must be > 0");

        _accrue(msg.sender);

        stakes[msg.sender].principal += amount;
        stakingToken.transferFrom(msg.sender, address(this), amount);
    }

    function unstake(uint256 amount) external {
        require(amount > 0, "Amount must be > 0");
        _accrue(msg.sender);

        StakeInfo storage info = stakes[msg.sender];
        require(info.principal >= amount, "Not enough staked");
        info.principal -= amount;
        owedBalance[msg.sender] += amount;
    }

    function withdraw() external nonReentrant {
        _accrue(msg.sender);

        uint256 payment = owedBalance[msg.sender];
        require(payment > 0, "Nothing to withdraw");
        owedBalance[msg.sender] = 0;
        stakingToken.transfer(msg.sender, payment);
    }

    function _accrue(address user) internal {
        StakeInfo storage info = stakes[user];
        if (info.principal == 0) {
            info.lastAccrualTime = block.timestamp;
            return;
        }
        uint256 elapsed = block.timestamp - info.lastAccrualTime;
        uint256 reward = (info.principal * aprBps * elapsed) / (YEAR * 10_000);
        info.owedRewards += reward;
        owedBalance[user] += info.owedRewards;
        info.owedRewards = 0;
        info.lastAccrualTime = block.timestamp;
    }
}

Possibilies with Kode Sherpa

With the above example, this will enable user to

Explore smart contract templates for DeFi, NFTs, and more
Test ideas quickly without starting from scratch
Generate production-ready Solidity code with best practices like pull payments built-in.

You can start building your Defi project through the KodeSherpa today.

Memes Regarding Mina Protocol

Syed Ghufran Hassan — Sun, 09 Feb 2025 13:32:52 +0000

Banks vs zero knowledge proofs

Mina vs other blockchains

Mina Devs Watching L1s Struggle With Scaling

First Time Using Mina’s o1js

Mina Devs vs. Other Blockchain Devs

Deploying zkapp

Unveiling Mantle: The Next-Gen Layer-2 Scaling Solution

Syed Ghufran Hassan — Thu, 23 Jan 2025 05:55:41 +0000

If you’ve been keeping an eye on blockchain technology, you’ve likely heard the buzz about scalability and efficiency. With the ever-expanding use of decentralized applications (dApps) and smart contracts, the need for faster, cheaper, and more sustainable solutions has never been greater. Enter Mantle, the Layer-2 scaling solution that’s taking the blockchain world by storm. But what exactly is Mantle, and why should you care? Let’s dive in!

What is Mantle?

Mantle is a next-generation Layer-2 (L2) solution built to enhance Ethereum’s capabilities. It operates as an off-chain scaling solution that inherits the security of Ethereum while providing significant improvements in speed and cost-efficiency. Mantle achieves this through advanced rollup technology and innovative design, making it an ideal platform for dApps, DeFi protocols, and NFT marketplaces.

Why Should You Choose Mantle?

Mantle isn’t just another name in the crowded L2 space. It’s a game-changer, offering features that set it apart from the competition. Here’s why Mantle deserves your attention:

Blazing-Fast Transactions

One of Mantle’s standout features is its speed. By processing transactions off-chain and bundling them into a single batch for settlement on Ethereum, Mantle drastically reduces the time it takes to confirm transactions. Imagine interacting with your favorite dApp or trading NFTs without the agonizing wait times.

Low-Cost Operations

Let’s face it, gas fees on Ethereum can burn a hole in your wallet. Mantle’s rollup technology minimizes these costs by distributing them across a larger pool of transactions. Whether you’re staking, swapping tokens, or minting NFTs, Mantle ensures that you save on fees without compromising security.

Eco-Friendly Scaling

With growing concerns about blockchain’s carbon footprint, Mantle offers a more sustainable alternative. By reducing the computational load on Ethereum’s mainnet, it helps decrease energy consumption. For projects and users looking to go green, Mantle is a step in the right direction.

Enhanced Security

Mantle leverages Ethereum’s robust security infrastructure while introducing its own innovations to ensure data integrity and resistance to attacks. With cryptographic proofs and decentralized validation, Mantle provides peace of mind for both developers and end-users.

Developer-Friendly Ecosystem

Building on Mantle is a breeze, thanks to its compatibility with Ethereum’s existing toolset. Developers can deploy smart contracts with minimal adjustments, making it easier to migrate or create new projects without the steep learning curve.

Real-World Applications

Mantle’s versatility makes it an attractive choice across various industries:

DeFi: Platforms like decentralized exchanges (DEXs) and lending protocols can benefit from faster transaction speeds and reduced fees, enhancing user experience and profitability.

NFT Marketplaces: Mint, buy, or sell NFTs without worrying about exorbitant gas fees, making digital art and collectibles more accessible.

Gaming: Enable real-time gameplay and microtransactions, opening new doors for blockchain-based gaming.

Enterprise Solutions: From supply chain management to identity verification, Mantle’s scalability ensures seamless integration for enterprise-level applications.

How to Get Started with Mantle

Whether you’re a developer, an investor, or simply a blockchain enthusiast, getting started with Mantle is easy:

Visit the Mantle Website: Explore the platform, read the documentation, and join the community.

Try the Testnet: Experiment with Mantle’s testnet to see its capabilities in action.

Join the Community: Engage with like-minded individuals on forums and social media to stay updated and share ideas.

Build or Migrate Your dApp: Leverage Mantle’s developer-friendly environment to bring your vision to life.

The Future of Blockchain with Mantle

Mantle represents more than just an improvement to Ethereum; it’s a leap toward the future of blockchain technology. By addressing scalability, cost, and environmental concerns, Mantle paves the way for mass adoption of decentralized solutions.

So, are you ready to experience the future of blockchain? Dive into Mantle and unlock the full potential of Ethereum with the speed, efficiency, and security you deserve!

Building a Private Voting zkApp on Mina Protocol using o1js

Syed Ghufran Hassan — Sun, 12 Jan 2025 18:06:40 +0000

I have created the guide for implementation of private voting app as zk app. I have opted for zk app as zkApps leverage the power of zero-knowledge proofs (ZKPs) to ensure data integrity and security while maintaining user privacy. By allowing computations to be verified without revealing the underlying data, zkApps create an ideal environment for private voting, where voters can cast their choices securely without exposing their identities or preferences. I am using o1js as it is a TypeScript library designed to simplify the development of zkApps (zero-knowledge applications) on the Mina Protocol. It provides tools to create privacy-preserving applications without requiring deep expertise in cryptography or zero-knowledge proofs (ZKPs)

I’ll walk through the implementation of a Private Voting zkApp using Mina Protocol.

I will cover setup, development, testing and deployment phase here in the contract.

First I installed zk-app-cli which provides CLI interface for scaffolding zk-apps and outlines the process of creating, developing and managing zk-apps.

It automatically installs and configures all the dependencies required for zkApp development, including Mina’s o1js library, making the setup seamless. The CLI integrates with tools like TypeScript and Mina’s LocalBlockchain out of the box, providing a consistent environment for building zkApps. he CLI includes commands for compiling zkApps and deploying them to either a local blockchain instance (for testing) or the Mina Testnet/Mainnet.

Then I setup private-voting app by following the command and setup the folder

This creates the instance of the project with sample src files add.ts, index.ts, add.test.ts and interact.ts. Since it is boiler plate so I have amended the code as per the project.

import { Field, SmartContract, state, State, method } from 'o1js';
import { Provable } from 'o1js';


export class PrivateVoting extends SmartContract {
  @state(Field) totalVotesA = State<Field>();
  @state(Field) totalVotesB = State<Field>();

  init() {
    super.init();
    this.totalVotesA.set(Field(0));
    this.totalVotesB.set(Field(0));
  }

  @method async vote(option: Field, proof: Field): Promise<void> {
    // Simplified voter proof verification (replace with ZKP circuit)
    proof.assertEquals(Field(1)); // Only allow valid voters

      // Ensure on-chain state consistency before modifying votes
  this.totalVotesA.requireEquals(this.totalVotesA.get());
  this.totalVotesB.requireEquals(this.totalVotesB.get());

    if (option.equals(Field(0))) {
      const currentVotes = this.totalVotesA.get();
      this.totalVotesA.set(currentVotes.add(1));
    } else if (option.equals(Field(1))) {
      const currentVotes = this.totalVotesB.get();
      this.totalVotesB.set(currentVotes.add(1));
    } else {
      throw new Error('Invalid voting option');
    }
  }

  @method async getResults(): Promise<void> {
    // Add precondition to ensure consistency with on-chain state
    this.totalVotesA.requireEquals(this.totalVotesA.get());
    this.totalVotesB.requireEquals(this.totalVotesB.get());

    const votesA = this.totalVotesA.get();
    const votesB = this.totalVotesB.get();

    // Log results (or you can return them if needed)
    Provable.log(votesA);
    Provable.log(votesB);
  }
}

I have updated Add.ts file. This code reflects the simple voting system which uses state variables for tracking votes and it initializes both vote counters to 0 when the contract is deployed. Users call the vote method with their choice and proof of eligibility. The contract verifies the proof, updates the appropriate vote counter, and rejects invalid options. A Field value representing the voting option (e.g., 0 for option A, 1 for option B).
A Field value representing a voter's proof of eligibility (simplified here as Field(1)). It ensures that only valid voters (those with a proof of Field(1)) can vote. In a real-world scenario, this would involve verifying a cryptographic zero-knowledge proof (ZKP). Before modifying votes, the contract ensures that the state variables (totalVotesA and totalVotesB) match their on-chain values using requireEquals(). Depending on the option (Field(0) for A or Field(1) for B), it increments the appropriate vote counter (totalVotesA or totalVotesB). It will throw an error if the option is neither 0 nor 1. This needs to be updated in Add.ts file which then can be renamed. The zkApp (Zero-Knowledge Application) implements the logic for private voting where votes for Option A and Option B are cast and counted, but the vote itself is kept private using zero-knowledge proofs (ZKPs). The zkApp contract uses o1js to verify the proof that accompanies the vote. If the proof is valid, the vote is accepted (either for Option A or Option B). Through zero-knowledge proofs, the zkApp contract ensures that the vote is valid while hiding the vote's content. The contract will not know who voted or how they voted, only that the vote is legitimate. The contract verifies the proof sent by the interact.ts to ensure the vote is valid before updating the on-chain state (i.e., vote tallies).

import { PrivateKey, PublicKey,Mina, Field } from 'o1js';
import { PrivateVoting } from './Add';

const Local = await Mina.LocalBlockchain();
Mina.setActiveInstance(Local);

const deployerAccount = PrivateKey.random();  // Generate a random PrivateKey for deployer
const deployerKey = deployerAccount;  // Use deployer's PrivateKey

const feePayerPublicKey = deployerAccount.toPublicKey();
const feePayerSpec = feePayerPublicKey;



const zkAppPrivateKey = PrivateKey.random();
const zkAppAddress = zkAppPrivateKey.toPublicKey();

const votingApp = new PrivateVoting(zkAppAddress);

async function deploy() {
  console.log('Deploying Private Voting zkApp...');

  const tx = await Mina.transaction(feePayerSpec, async () => {
    votingApp.deploy();
  });
  await tx.sign([deployerKey]).send();
  console.log('Deployment Complete!');
}

deploy();

I then updated index.ts which basically reflects the process of deploying a Private Voting zkApp on Mina's local blockchain using the o1js library. It generates a random private key for the deployer and zkApp. A transaction is then created to deploy the PrivateVoting zkApp on Mina's local blockchain. The transaction is then signed with the deployer's private key and sent for execution.

import { PrivateKey, PublicKey,Mina, Field } from 'o1js';
import { PrivateVoting } from './Add';

const zkAppAddress = '<YOUR_ZKAPP_PUBLIC_KEY>'; // Replace with your zkApp's public key
const votingApp = new PrivateVoting(PublicKey.fromBase58(zkAppAddress));

async function castVote(option: Field, proof: Field) {
  console.log(`Casting vote for option ${option.toString()}...`);
  const tx = await Mina.transaction(async () => {
    votingApp.vote(option, proof);
  });
  await tx.send();
  console.log('Vote cast successfully!');
}

async function getResults() {
  const results = votingApp.getResults();
  console.log('Results:', results);
}

// Example usage
(async () => {
  await castVote(Field(0), Field(1)); // Cast vote for Option A
  await castVote(Field(1), Field(1)); // Cast vote for Option B
  await getResults();
})();

I then updated interact.ts which reflects the process explaining how to interact with a Private Voting zkApp (Zero-Knowledge Application) built on Mina Protocol using o1js (the Mina SDK). It creates instance of the zkapp by allowing interaction with the Private Voting contract deployed on the Mina blockchain. The castVote() function sends a vote for one of two options (Option A or Option B) to the zkApp, including a zero-knowledge proof to verify the validity of the vote. The getResults() function fetches the current vote tally from the zkApp and logs the results. It allows to simulate a private voting process where users can cast votes and then see the results, all while utilizing zero-knowledge proofs for privacy and integrity of the voting process. It is serving as proof generation where a user submits their vote along with a proof that is generated by a zero-knowledge proof circuit.

After successful building of the contract by running npm run build. I then tested the contract through this script which is add.test.ts

import { PrivateVoting } from './Add';
import { Field, Mina, PrivateKey, UInt64 } from 'o1js';

const Local = await Mina.LocalBlockchain();
Mina.setActiveInstance(Local);

const deployerAccount = PrivateKey.random();
const deployerKey = deployerAccount;

const zkAppPrivateKey = PrivateKey.random();
const zkAppAddress = zkAppPrivateKey.toPublicKey();

describe('PrivateVoting', () => {
  let votingApp: PrivateVoting;

  beforeAll(async () => {
    // Add the deployer account with sufficient balance to the local blockchain
    Local.addAccount(deployerKey.toPublicKey(), UInt64.from(10000000000).toString()); // Add deployer account with balance

    // Add zkApp account with sufficient balance
    Local.addAccount(zkAppAddress, UInt64.from(10000000000).toString()); // Add zkApp account with balance

    // Initialize the zkApp
    votingApp = new PrivateVoting(zkAppAddress);

    // Compile the zkApp to generate the verification key
    await PrivateVoting.compile();
  });

  it('should deploy successfully', async () => {
    // Create the transaction for deploying the contract
    const tx = await Mina.transaction(
      { sender: deployerKey.toPublicKey(), fee: UInt64.from(1000000).toString() }, // Convert fee to string
      async () => {
        votingApp.deploy();
      }
    );

    // Sign with both the deployer's private key (for transaction fee) and the zkApp private key (for state change)
    await tx.sign([deployerKey, zkAppPrivateKey]).send();

    // Fetch the zkApp account using getAccount after deploying
    let zkAppAccount;
    try {
      zkAppAccount = await Mina.getAccount(zkAppAddress);
    } catch (error: unknown) {
      if (error instanceof Error) {
        throw new Error('Error fetching zkApp account: ' + error.message);
      } else {
        throw new Error('An unknown error occurred while fetching the zkApp account.');
      }
    }

    // Check if the account was found and is initialized
    if (!zkAppAccount) {
      throw new Error('zkApp account not found');
    }

    // Add the preconditions here
    votingApp.totalVotesA.requireEquals(Field(0)); // Ensure totalVotesA is 0
    votingApp.totalVotesB.requireEquals(Field(0)); // Ensure totalVotesB is 0

    // Check initial state of votes using deep equality comparison
    expect(votingApp.totalVotesA.get()).toEqual(Field(0));
    expect(votingApp.totalVotesB.get()).toEqual(Field(0));
  });

});

It is a test suite for the PrivateVoting zkApp on the Mina blockchain. It uses the Jest testing framework to verify the deployment and initial state of the voting application. This will verify the deployment and initial state of the PrivateVoting zkApp contract, ensuring that the votes start at 0 for both options (A and B).

Now it is time for deployment phase. I initiated it by writing zk config as the command which asks for app name, where to deploy, graphql link which is available on devnet, keys and the transaction cost as highlighted below

I then deployed the zk app on devnet and it appears on minascan. It takes approx 32 block confirmations.

This is the minascan explorer Link

I then proceeded with creating UI and interacting the contract with the UI creating proper implementation of zkapp.

Future enhancements

The current implementation uses Field(1) as a simplified proof of eligibility. It can be replaced by ZKP circuit (Zero knowledge proof) utilizing ZK-SNARK that verifies voter privacy while ensuring integrity. The ZKP circuit will require modeling the input reflecting eligible voters and output that if voter is eligible and design ZKP Circuit that uses snarkyjs for validating the eligibility of the voter. The difference between o1js and zk-snark is that O1js is a library that simplifies the implementation of zk-SNARKs for zkApp and zk-SNARKs are the low-level cryptographic technology. So, while O1js uses zk-SNARKs behind the scenes to enable the development of zero-knowledge apps, O1js itself is not a zk-SNARK but rather a tool that leverages zk-SNARKs for practical application development on the Mina blockchain.

In conclusion, building zkApps on Mina Protocol offers a robust framework for developing privacy-preserving decentralized applications. By leveraging O1js, developers can focus on high-level logic and user interaction while abstracting away the complexities of cryptographic proof generation.

This article reflects building a PrivateVoting contract using O1js, where users can cast votes while ensuring that their identity remains confidential. This process is underpinned by a proof that verifies the validity of a user's vote, using ZKPs to protect voter privacy.

Exploring the Mina Protocol: Practical Use Cases for zk Applications

Syed Ghufran Hassan — Thu, 26 Dec 2024 17:42:12 +0000

Zkapps (zero knowledge applications) are mina protocol smart contracts which are powered by zero knowledge proofs, specifically zk-Snarks [Zero-Knowledge Succinct Non-Interactive Argument of Knowledge].zkapps replaced snapps [Smart Non-Interactive Argument of Knowledge Applications]. ZkApp smart contracts are written using o1js (a TypeScript library). zkApps runs client side in a user’s web browser, and publish only a small validity proof which is then verified by the Mina nodes. Zkapp consists of smart contract and UI which I will further describe in the next section.

Core

zkApps leverage zero-knowledge proofs (ZKPs) to enhance privacy, security, and scalability in decentralized applications (dApps). These applications are built on blockchains with native support for zero-knowledge technology, such as Mina Protocol, Zcash, and Polygon (zkEVM).

Features

zkApps enable transactions or computations that preserve user data confidentiality.
By processing transactions off-chain and validating them with succinct proofs, zkApps reduce the computational burden on blockchains.
zkApps often integrate with multiple blockchain networks, enhancing their versatility.

Application

I implemented Mina Protocol zkapps as they are lightweight privacy-preserving dApps with minimal computational requirements.

I created zkapp regarding age verification where the user age gets validated without intervention to the personal data.

I proceeded by installing zkapp-cli npm package which actually created templates for proceeding with prover function and verifier function as part of the zk proof build process

Implementation

Below is the implementation of adding verification custom logic. It defines the circuit logic for zk-SNARKs, which is used during proof generation. The actual prover function is managed by the o1js library and invoked when zkApp methods are executed off-chain with private inputs.

import { Field, SmartContract, state, State, method } from 'o1js';

/**
 * Private Age Verification Contract
 * The contract will verify if the user's age is greater than or equal to the threshold age.
 * The contract uses zero-knowledge proofs to keep the user's age private.
 */
export class AgeVerification extends SmartContract {
  // State variable to store the verification result (valid or invalid)
  @state(Field) valid = State<Field>();

  // Method to initialize the state
  init() {
    super.init();
    this.valid.set(Field(0)); // Default is invalid
  }

  // Method to verify the age
  @method async verifyAge(age: Field, threshold: Field) {


    // Compute age - threshold
    const difference = age.sub(threshold);

    // Use circuit-compatible logic to check if the difference is non-negative
    const isValid = difference.equals(Field(0)).or(difference.greaterThanOrEqual(Field(0)))
      ? Field(1)
      : Field(0);

    // Set the validity of the verification result
    this.valid.set(isValid);
  }
}

The below script is a test suite that interacts with the AgeVerification zkApp. It invokes the prover logic during txn.prove() and verifies the zkApp's behavior by checking its updated state.

The actual prover function lies in the underlying zkApp method (verifyAge), and txn.prove() is the mechanism to generate the proof during testing.

To test the inputs I have edited the test script as follows.

import { AccountUpdate, Field, Mina, PrivateKey, PublicKey } from 'o1js';
import { AgeVerification } from './AgeVerification'; // Import the correct contract

let proofsEnabled = false;

describe('AgeVerification', () => {
  let deployerAccount: Mina.TestPublicKey,
    deployerKey: PrivateKey,
    senderAccount: Mina.TestPublicKey,
    senderKey: PrivateKey,
    zkAppAddress: PublicKey,
    zkAppPrivateKey: PrivateKey,
    zkApp: AgeVerification; // Update to use AgeVerification instead of Add

  beforeAll(async () => {
    if (proofsEnabled) await AgeVerification.compile(); // Update compile for AgeVerification
  });

  beforeEach(async () => {
    const Local = await Mina.LocalBlockchain({ proofsEnabled });
    Mina.setActiveInstance(Local);
    [deployerAccount, senderAccount] = Local.testAccounts;
    let feePayer = Local.testAccounts[0].key;
    deployerKey = deployerAccount.key;
    senderKey = senderAccount.key;

    zkAppPrivateKey = PrivateKey.random();
    zkAppAddress = zkAppPrivateKey.toPublicKey();
    zkApp = new AgeVerification(zkAppAddress); // Instantiate AgeVerification contract
  });



  async function localDeploy() {
    const txn = await Mina.transaction(deployerAccount, async () => {
      AccountUpdate.fundNewAccount(deployerAccount);
      await zkApp.deploy();
    });
    await txn.prove();
    // this tx needs .sign(), because `deploy()` adds an account update that requires signature authorization
    await txn.sign([deployerKey, zkAppPrivateKey]).send();
  }

  it('generates and deploys the `AgeVerification` smart contract', async () => {
    await localDeploy();
    const valid = zkApp.valid.get(); // Access the 'valid' state variable
    expect(valid).toEqual(Field(0)); // Initially, the contract should set 'valid' to Field(0)
  });

  it('correctly verifies the age in the `AgeVerification` smart contract', async () => {
    await localDeploy();

    const age = Field(25); // Example age value
    const threshold = Field(18); // Example threshold value

    // Call the verifyAge method
    const txn = await Mina.transaction(senderAccount, async () => {
      await zkApp.verifyAge(age, threshold); // Use the verifyAge method
    });
    await txn.prove();
    await txn.sign([senderKey]).send();

    const valid = zkApp.valid.get(); // Check the validity state after verification
    expect(valid).toEqual(Field(1)); // Expected to be valid if age >= threshold
  });
});

Below is the testing result

I have added the prover mechanism in interact.ts file which basically generates a zk-SNARK proof and submits the proof when it goes for transaction in mina blockchain. While the interact.ts script generates the proof, the verification is performed by the Mina blockchain when the transaction is processed. This is a key aspect of zk-SNARK systems that the prover generates a proof that the verifier (Mina network) checks.

import fs from 'fs/promises';
import { Mina, NetworkId, PrivateKey, Field } from 'o1js';
import { AgeVerification } from './AgeVerification'; 

// check command line arg
let deployAlias = process.argv[2];
if (!deployAlias)
  throw Error(`Missing <deployAlias> argument.

Usage:
node build/src/interact.js <deployAlias>
`);
Error.stackTraceLimit = 1000;
const DEFAULT_NETWORK_ID = 'testnet';

// parse config and private key from file
type Config = {
  deployAliases: Record<
    string,
    {
      networkId?: string;
      url: string;
      keyPath: string;
      fee: string;
      feepayerKeyPath: string;
      feepayerAlias: string;
    }
  >;
};
let configJson: Config = JSON.parse(await fs.readFile('config.json', 'utf8'));
let config = configJson.deployAliases[deployAlias];
let feepayerKeysBase58: { privateKey: string; publicKey: string } = JSON.parse(
  await fs.readFile(config.feepayerKeyPath, 'utf8')
);

let zkAppKeysBase58: { privateKey: string; publicKey: string } = JSON.parse(
  await fs.readFile(config.keyPath, 'utf8')
);

let feepayerKey = PrivateKey.fromBase58(feepayerKeysBase58.privateKey);
let zkAppKey = PrivateKey.fromBase58(zkAppKeysBase58.privateKey);

// set up Mina instance and contract we interact with
const Network = Mina.Network({
  // We need to default to the testnet networkId if none is specified for this deploy alias in config.json
  // This is to ensure the backward compatibility.
  networkId: (config.networkId ?? DEFAULT_NETWORK_ID) as NetworkId,
  mina: config.url,
});

const fee = Number(config.fee) * 1e9; // in nanomina (1 billion = 1.0 mina)
Mina.setActiveInstance(Network);
let feepayerAddress = feepayerKey.toPublicKey();
let zkAppAddress = zkAppKey.toPublicKey();
let zkApp = new AgeVerification(zkAppAddress);

let age = Field(25); // Example age
let threshold = Field(18); // Example threshold age

// compile the contract to create prover keys
console.log('compile the contract...');
await AgeVerification.compile();

try {
  // call verifyAge() and send transaction
  console.log('build transaction and create proof...');
  let tx = await Mina.transaction(
    { sender: feepayerAddress, fee },
    async () => {
      await zkApp.verifyAge(age, threshold); // Replacing update() with verifyAge
    }
  );
  await tx.prove();

  console.log('send transaction...');
  const sentTx = await tx.sign([feepayerKey]).send();
  if (sentTx.status === 'pending') {
    console.log(
      '\nSuccess! Age verification transaction sent.\n' +
        '\nYour smart contract state will be updated' +
        `\nas soon as the transaction is included in a block:` +
        `\n${getTxnUrl(config.url, sentTx.hash)}`
    );
  }
} catch (err) {
  console.log(err);
}

function getTxnUrl(graphQlUrl: string, txnHash: string | undefined) {
  const hostName = new URL(graphQlUrl).hostname;
  const txnBroadcastServiceName = hostName
    .split('.')
    .filter((item) => item === 'minascan')?.[0];
  const networkName = graphQlUrl
    .split('/')
    .filter((item) => item === 'mainnet' || item === 'devnet')?.[0];
  if (txnBroadcastServiceName && networkName) {
    return `https://minascan.io/${networkName}/tx/${txnHash}?type=zk-tx`;
  }
  return `Transaction hash: ${txnHash}`;
}

I have used inputs for age and threshold as 25 and 18.

Since testing has been done successfully by running npm run test. I proceeded with deploying on devnet by using zk config

Where I provided following inputs:

Deploy alias: test
Network kind: testnet
URL: https://api.minascan.io/node/devnet/v1/graphql
Feepayer: New feepayer keys
Transaction: 0.1

The URL can be retrieved from here:

Then upon deployment I got the following response.

The contract is deployed at the following devnet

After deployment I proceeded with UI where I chose simple html, css and js by giving my RPC URL and deployed contract address and this is the final UI.

This concludes the creation of zkapp after integrating smart contract with UI. After building the user interface (UI) for the AgeVerification zkApp, the integration of the frontend with the smart contract allows users to interact seamlessly with the zero-knowledge proof system. The UI facilitates the submission of user age and threshold data to the contract, while maintaining privacy through zk-SNARKs. This enables users to verify their age without revealing the actual value, preserving confidentiality. The backend, utilizing the prover function, generates the proof, and the Mina blockchain verifies it efficiently. This end-to-end solution ensures a secure, user-friendly experience while taking full advantage of the privacy and scalability features offered by Mina's zk-SNARK-based architecture.

Solidity Pattern - Proxy Delegate and Decorator Patterns

Syed Ghufran Hassan — Fri, 13 Dec 2024 19:02:13 +0000

In Solidity, the Proxy Delegate and Decorator patterns are used to enhance contracts, particularly for upgradability and modular functionality. These patterns are key for separating logic and state, allowing contracts to be updated without modifying the original state.

Proxy Delegate Pattern (Upgradable Proxy Pattern) The Proxy Delegate pattern is commonly used for contract upgradability. It involves using a proxy contract to delegate function calls to a logic contract (also called an implementation contract) via the delegatecall opcode. This allows for the separation of contract logic and data storage, making it possible to upgrade the contract logic without altering the contract’s storage or re-deploying it.

Key Concepts: Proxy Contract: A contract that holds the storage and delegates all calls to another contract (the implementation contract). Implementation Contract: The contract that contains the logic. This contract can be replaced without affecting the proxy. delegatecall: A low-level Solidity opcode that executes a function from another contract while preserving the calling context (i.e., the storage and msg.sender).

// Proxy Contract

pragma solidity ^0.8.0;

contract Proxy { address public implementation;

constructor(address _implementation) {
    implementation = _implementation;
}

// Fallback function will delegate the call to the implementation contract
fallback() external payable {
    address impl = implementation;
    require(impl != address(0), "Implementation contract not set");

    // Delegate the call to the implementation contract
    (bool success, bytes memory data) = impl.delegatecall(msg.data);
    require(success, "Delegatecall failed");

    // Return the data returned by the implementation contract
    assembly {
        return(add(data, 0x20), mload(data))
    }
}

// Upgrading the contract by changing the implementation address
function upgradeTo(address _newImplementation) external {
    implementation = _newImplementation;
}
}

How it Works: Proxy Contract: This contract holds the state, and any function calls to it are delegated to the Implementation Contract via delegatecall. The storage layout of the proxy remains unchanged even when the implementation logic is upgraded. Implementation Contract: This contains the actual logic (functions) but does not hold any state. By using delegatecall, it can modify the proxy contract's storage.

// Implementation Contract

pragma solidity ^0.8.0;

contract MyLogic { uint public x;

function setX(uint _x) external {
    x = _x;
}
}

We will continue with decorator pattern in next post.

Thank you for viewing.

Solidity Patterns - CEI

Syed Ghufran Hassan — Tue, 10 Dec 2024 07:00:22 +0000

The Check-Effects-Interactions (CEI) pattern is a best practice in Solidity for writing secure smart contracts, particularly to prevent reentrancy attacks. It involves structuring the contract's logic in a specific order: checking conditions, making state changes (effects), and then interacting with external contracts. The idea is to minimize the risk of external contracts making unexpected changes during interactions.

CEI Pattern Steps: Checks: First, check all the necessary preconditions (e.g., if the sender has enough balance, if the contract is in a valid state). Effects: Second, update the contract's internal state (e.g., deduct balance, change ownership). Interactions: Lastly, interact with external contracts or send ETH/tokens (this is the point where a reentrancy attack could happen if done earlier).

pragma solidity ^0.8.0;

contract SafeWithdrawal { mapping(address => uint256) public balances;

// Function to withdraw funds securely
function withdraw() external {
    uint256 amount = balances[msg.sender];

    // 1. CHECK: Ensure the user has a balance to withdraw
    require(amount > 0, "Insufficient balance");

    // 2. EFFECTS: Update the state before interacting with external contracts
    balances[msg.sender] = 0;

    // 3. INTERACTIONS: Send the amount to the user (this could call an external contract)
    (bool success, ) = msg.sender.call{value: amount}("");
    require(success, "Transfer failed");
}

// Function to deposit funds into the contract
function deposit() external payable {
    balances[msg.sender] += msg.value;
}
}

Breakdown of the CEI Pattern:

Check:

The contract checks that the msg.sender has a balance greater than 0.

Effects:

The contract sets the balances[msg.sender] to 0 before interacting with the external contract (or sending funds).

Interaction:

The contract transfers ETH to the caller using call. If this interaction triggered a fallback or other external function, the state has already been updated, so a reentrant call would not be able to exploit the contract. Why CEI Pattern Prevents Reentrancy: A reentrancy attack happens when an external contract (or malicious user) calls back into the vulnerable contract before the state has been updated. In this example, if the external contract (via call) calls the withdraw function again before the balances[msg.sender] has been set to 0, it could withdraw multiple times. By ensuring that the state is updated before the external call, the reentrancy attack is prevented.

Key Points:

State change before external calls: The most critical aspect is to change the state before making any external calls. Use .call over .send or .transfer: With gas limits becoming less predictable, .call is preferred for sending ETH since it does not impose a hard gas limit.

This pattern, along with other techniques like reentrancy guards (e.g., ReentrancyGuard from OpenZeppelin), ensures that Solidity contracts are more secure from potential attacks.

Introduction to Mina Protocol: The World’s Lightest Blockchain

Syed Ghufran Hassan — Mon, 09 Dec 2024 04:53:40 +0000

Mina Protocol is a groundbreaking blockchain designed to be lightweight, scalable, and decentralized. Unlike traditional blockchains that grow endlessly, Mina maintains a constant size of ~22 KB, thanks to its innovative use of zk-SNARKs. This unique approach positions Mina as a critical enabler of the Web3 ecosystem, providing developers and users with an efficient, secure, and privacy-centric blockchain platform.

Vision

Mina’s vision is to create a blockchain ecosystem that is:

Accessible: Anyone, anywhere, can participate as a node operator, developer, or user without needing high computational power.
Privacy-Focused: Protect user data and enable private proofs for applications without revealing sensitive information.
Decentralized: Maximize inclusivity by ensuring minimal hardware requirements for network participation.
Empowering Web3: Serve as a gateway to Web3, enabling scalable and secure interactions with other blockchain platforms.

Mina's Role in web3

Bridging Traditional and Blockchain Systems:
It facilitates privacy-preserving interactions between users and Web2 systems like social media and financial platforms.
Enabling Private DeFi:
Snapps can power confidential financial products without compromising transparency or user data.
Empowering Decentralized Identity (DID):
Mina allows users to prove attributes like age or citizenship without exposing personal details.

The Power of zk-SNARKs

Mina Protocol leverages zk-SNARKs (Zero-Knowledge Succinct Non-Interactive Arguments of Knowledge) to revolutionize blockchain scalability, privacy, and security. Here’s how zk-SNARKs integrate with Mina’s architecture and provide transformative benefits:

A user can prove they are over a certain age without disclosing their exact birthdate, enabling privacy-preserving applications like secure voting or identity verification.
Mina can scale infinitely while remaining lightweight, enabling anyone to run a node with minimal hardware, promoting decentralization and reducing barriers to entry.
Rather than downloading and verifying the entire blockchain to confirm a transaction, Mina only needs to verify the zk-SNARK proof, which is much smaller and faster to handle.
Mina’s use of zk-SNARKs ensures that data is verifiable by anyone, without revealing private information, making Mina more secure compared to other blockchains where privacy is often sacrificed for transparency.
In a decentralized finance (DeFi) application, a user could prove they have sufficient funds to borrow without revealing their exact account balance, protecting user privacy while still enabling financial transactions.

Setting Up Auro Wallet

The auro wallet is used for transfering and staking Mina tokens. The mina tokens are used for paying for transactions and interactions on the Mina network.

Conclusion:

Mina’s lightweight nature ensures that anyone can run a node or interact with the blockchain without needing expensive hardware. Mina Protocol represents the next step in blockchain evolution, offering a lightweight, scalable, and privacy-centric platform for the Web3 era. Whether you’re a developer building Snapps, a user looking for decentralized privacy, or a blockchain enthusiast seeking to contribute, Mina offers something for everyone. zk-SNARKs are the cornerstone of Mina Protocol, enabling the blockchain to maintain its small size, scale efficiently, and offer privacy-focused applications. By integrating zk-SNARKs, Mina provides a solution to the scalability and privacy limitations of traditional blockchains, ushering in a new era of decentralized applications that are both secure and scalable.