Add burn mechanism during the invocation of interactWithPost() method

Author: mikyjo

contracts/XRequestProcessor.sol

@@ -9,11 +9,15 @@ import {XActionType} from './XActionType.sol';
 
 contract XRequestProcessor is Ownable {
   IERC20 private _paymentToken;
+  uint8 private _burnPercentage;
 
   mapping(XActionType => uint256) private _actionAmounts;
 
+  address public constant DEAD_ADDRESS = 0x000000000000000000000000000000000000dEaD;
+
   constructor(address paymentToken) Ownable(msg.sender) {
     _paymentToken = IERC20(paymentToken);
+    _burnPercentage = 50;
   }
 
   modifier nonZeroAddress(address account) {
@@ -108,10 +112,18 @@ contract XRequestProcessor is Ownable {
       require(bytes(uriOrTicker).length <= 20, 'Invalid token ticker');
     }
 
+    // Calculate the payment and burn amounts
     uint256 paymentAmount = getActionPrice(actionType);
+    uint256 burnAmount = (paymentAmount * _burnPercentage) / 100;
+    uint256 contractAmount = paymentAmount - burnAmount;
 
-    // Safely transfer the required token amount from the user to this contract
-    SafeERC20.safeTransferFrom(_paymentToken, msg.sender, address(this), paymentAmount);
+    // Safely transfer the payment and burn amounts
+    if (contractAmount > 0) {
+      SafeERC20.safeTransferFrom(_paymentToken, msg.sender, address(this), contractAmount);
+    }
+    if (burnAmount > 0) {
+      SafeERC20.safeTransferFrom(_paymentToken, msg.sender, DEAD_ADDRESS, burnAmount);
+    }
 
     // Get the current day since the Unix epoch, by dividing by 24 hours (in seconds)
     uint128 unixDay = uint128(block.timestamp / 86400);
@@ -135,6 +147,22 @@ contract XRequestProcessor is Ownable {
     emit PaymentTokenChanged(newToken);
   }
 
+  /**
+   * @dev Returns the current burn percentage
+   */
+  function getBurnPercentage() public view returns (uint8) {
+    return _burnPercentage;
+  }
+
+  /**
+   * @dev Sets the burn percentage
+   * @param newPercentage The new burn percentage (e.g., 25 for 25%)
+   */
+  function setBurnPercentage(uint8 newPercentage) public onlyOwner {
+    require(newPercentage <= 100, 'Burn percentage cannot exceed 100');
+    _burnPercentage = newPercentage;
+  }
+
   /**
    * @dev Withdraw all tokens from the contract to the specified address
    * @param to Address to receive the tokens held by the contract

test/XRequestProcessor.test.js

@@ -22,6 +22,17 @@ const XActionType = {
   TokenAnalysis: 5,
 }
 
+/**
+ * @param {bigint} totalAmount
+ * @param {bigint} burnPercentage
+ * @returns {[bigint, bigint]}
+ */
+const applyBurnPercentage = (totalAmount, burnPercentage) => {
+  const burnAmount = (totalAmount * burnPercentage) / 100n
+  const remainingAmount = totalAmount - burnAmount
+  return [remainingAmount, burnAmount]
+}
+
 describe(`XRequestProcessor tests`, function () {
   async function deployXRequestProcessorFixture() {
     const [owner, user1] = await ethers.getSigners()
@@ -179,8 +190,14 @@ describe(`XRequestProcessor tests`, function () {
     const userBalanceAfter = await tokenContract.balanceOf(user1.address)
     expect(userBalanceAfter).to.equal(0n)
 
+    const burnPercent = await processorContract.getBurnPercentage()
+    const [paymentAmount, burnAmount] = applyBurnPercentage(repostAmount, burnPercent)
+
     const processorContractBalance = await tokenContract.balanceOf(processorContractAddress)
-    expect(processorContractBalance).to.equal(repostAmount)
+    expect(processorContractBalance).to.equal(paymentAmount)
+
+    const deadAddressBalance = await tokenContract.balanceOf(await processorContract.DEAD_ADDRESS())
+    expect(deadAddressBalance).to.equal(burnAmount)
   })
 
   it('interactWithPost() - User should be able to invoke XActionType.TokenAnalysis actions', async function () {
@@ -305,6 +322,28 @@ describe(`XRequestProcessor tests`, function () {
       .reverted
   })
 
+  it('setBurnPercentage() - Regular user should NOT be able to change the burn percentage', async function () {
+    const { user1, processorContract } = await loadFixture(deployXRequestProcessorFixture)
+
+    const newBurnPercent = 0n
+    await expect(processorContract.connect(user1).setBurnPercentage(newBurnPercent)).to.be.reverted
+  })
+
+  it('setBurnPercentage() - Owner should be able to change the burn percentage between 0-100', async function () {
+    const { owner, processorContract } = await loadFixture(deployXRequestProcessorFixture)
+
+    const validPercentages = [0n, 15n, 25n, 50n, 80n, 100n]
+    for (let percent of validPercentages) {
+      await expect(processorContract.connect(owner).setBurnPercentage(percent)).not.to.be.reverted
+      expect(await processorContract.getBurnPercentage(), percent)
+    }
+
+    const invalidPercentages = [101n, 150n, 200n]
+    for (let percent of invalidPercentages) {
+      await expect(processorContract.connect(owner).setBurnPercentage(percent)).to.be.reverted
+    }
+  })
+
   it('withdrawFunds() - Owner should be able to withdraw funds to a new address', async function () {
     const { owner, processorContract, tokenContract } = await loadFixture(
       deployXRequestProcessorFixture
@@ -315,13 +354,14 @@ describe(`XRequestProcessor tests`, function () {
     await tokenContract.connect(owner).approve(processorContractAddress, replyToThreadAmount)
     const xPostUri = 'https://x.com/SpaceX/status/1928107204931940365'
     await processorContract.connect(owner).interactWithPost(XActionType.ReplyToThread, xPostUri)
+    const processorContractBalance = await tokenContract.balanceOf(processorContractAddress)
 
     const otherWallet = ethers.Wallet.createRandom()
     await expect(processorContract.connect(owner).withdrawFunds(otherWallet.address)).not.to.be
       .reverted
 
     const otherWalletBalance = await tokenContract.balanceOf(otherWallet.address)
-    expect(otherWalletBalance).to.equal(replyToThreadAmount)
+    expect(otherWalletBalance).to.equal(processorContractBalance)
   })
 
   it('withdrawFunds() - Regular user should NOT be able to withdraw funds', async function () {