Celebrating ¥100M Issued! A Practical Guide to Working with JPYC in Smart Contracts (Using Solidity, Hardhat, and Polygon) - Technical Perspective

mkdir jpyc-sc-tutorial
cd jpyc-sc-tutorial
npx hardhat

npm install @openzeppelin/contracts@5.0.2 dotenv@16.4.5

POLYGON_RPC_URL="YOUR_ALCHEMY_OR_INFURA_POLYGON_RPC_URL"
PRIVATE_KEY="YOUR_METAMASK_PRIVATE_KEY"

require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();

module.exports = {
  solidity: "0.8.20",
  networks: {
    polygon: {
      url: process.env.POLYGON_RPC_URL || "",
      accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [],
    },
  },
};

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

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract JPYCHandler is Ownable {
    IERC20 public immutable jpycToken;

    event Deposit(address indexed user, uint256 amount);
    event Withdraw(address indexed owner, uint256 amount);

    address constant JPYC_POLYGON_ADDRESS = 0x431D5dfF03120AFA4bDf332c61A6e1766eF37BDB;

    constructor() Ownable(msg.sender) {
        jpycToken = IERC20(JPYC_POLYGON_ADDRESS);
    }

    /**
     * @dev Lets a user deposit JPYC into the contract.
     * @param _amount Amount of JPYC (with 18 decimals in mind).
     * Note: User needs to approve this contract first to spend their JPYC.
     */
    function depositJPYC(uint256 _amount) external {
        require(_amount > 0, "Amount must be greater than zero");
        uint256 allowance = jpycToken.allowance(msg.sender, address(this));
        require(allowance >= _amount, "Check the token allowance");
        bool success = jpycToken.transferFrom(msg.sender, address(this), _amount);
        require(success, "Transfer failed");
        emit Deposit(msg.sender, _amount);
    }

    /**
     * @dev Owner can pull out all JPYC from the contract.
     */
    function withdrawAllJPYC() external onlyOwner {
        uint256 balance = getContractBalance();
        require(balance > 0, "No JPYC to withdraw");
        jpycToken.transfer(owner(), balance);
        emit Withdraw(owner(), balance);
    }

    /**
     * @dev Check the contract's JPYC balance.
     * @return Balance in wei-like units.
     */
    function getContractBalance() public view returns (uint256) {
        return jpycToken.balanceOf(address(this));
    }
}

const hre = require("hardhat");

async function main() {
  const jpycHandler = await hre.ethers.deployContract("JPYCHandler");
  await jpycHandler.waitForDeployment();
  console.log(`JPYCHandler deployed to: ${jpycHandler.target}`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

npx hardhat run scripts/deploy.js --network polygon

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

// CONFIG
const JPYC_HANDLER_ADDRESS = "YOUR_DEPLOYED_CONTRACT_ADDRESS";
const JPYC_TOKEN_ADDRESS = "0x431D5dfF03120AFA4bDf332c61A6e1766eF37BDB";
const DEPOSIT_AMOUNT = ethers.parseUnits("10", 18); // JPYC has 18 decimals

async function main() {
  const [signer] = await ethers.getSigners();
  console.log("Using wallet:", signer.address);

  const jpycHandler = await ethers.getContractAt("JPYCHandler", JPYC_HANDLER_ADDRESS, signer);
  const jpycToken = await ethers.getContractAt("IERC20", JPYC_TOKEN_ADDRESS, signer);

  console.log("\\nApproving spend...");
  const approveTx = await jpycToken.approve(JPYC_HANDLER_ADDRESS, DEPOSIT_AMOUNT);
  await approveTx.wait();
  console.log("Approved. Tx:", approveTx.hash);

  console.log("\\nDepositing...");
  const depositTx = await jpycHandler.depositJPYC(DEPOSIT_AMOUNT);
  await depositTx.wait();
  console.log("Deposited. Tx:", depositTx.hash);

  const contractBalance = await jpycHandler.getContractBalance();
  console.log("\\nCheck balance:", ethers.formatUnits(contractBalance, 18) + " JPYC");
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

npx hardhat run scripts/interact.js --network polygon