Combine analyzeToken() and interactWithPost() methods to simplify contract usage

Author: mikyjo

contracts/XRequestProcessor.sol

@@ -24,9 +24,8 @@ contract XRequestProcessor is Ownable {
   event NewPostInteraction(
     address indexed payer,
     XActionType indexed actionType,
-    string indexed xPostUri
+    string uriOrTicker
   );
-  event NewTokenAnalysis(address indexed payer, string indexed tokenTicker);
   event PaymentTokenChanged(address newToken);
 
   /**
@@ -97,33 +96,23 @@ contract XRequestProcessor is Ownable {
   }
 
   /**
-   * @dev This function allows users to perform XActionType for the given postUri on X (Twitter)
+   * @dev This function allows users to perform XActionType for the given postUri on X (Twitter) or $TICKER
    * @param actionType A value from XActionType enum
-   * @param postUri A URI to a post in X (Twitter)
+   * @param uriOrTicker A URI to a post in X (Twitter) or a token $TICKER
    */
-  function interactWithPost(XActionType actionType, string memory postUri) public {
-    require(
-      actionType != XActionType.TokenAnalysis,
-      'TokenAnalysis action cannot be used with this function'
-    );
+  function interactWithPost(XActionType actionType, string memory uriOrTicker) public {
+    require(bytes(uriOrTicker).length > 0, 'URI or TICKER cannot be empty');
 
-    uint256 paymentAmount = getActionPrice(actionType);
-
-    // Safely transfer the required token amount from the user to this contract
-    SafeERC20.safeTransferFrom(_paymentToken, msg.sender, address(this), paymentAmount);
+    if (actionType == XActionType.TokenAnalysis) {
+      require(bytes(uriOrTicker).length <= 20, 'Invalid token ticker');
+    }
 
-    emit NewPostInteraction(msg.sender, actionType, postUri);
-  }
-
-  function analyzeToken(string memory tokenTicker) public {
-    require(bytes(tokenTicker).length <= 20, 'Invalid token ticker');
-
-    uint256 paymentAmount = getActionPrice(XActionType.TokenAnalysis);
+    uint256 paymentAmount = getActionPrice(actionType);
 
     // Safely transfer the required token amount from the user to this contract
     SafeERC20.safeTransferFrom(_paymentToken, msg.sender, address(this), paymentAmount);
 
-    emit NewTokenAnalysis(msg.sender, tokenTicker);
+    emit NewPostInteraction(msg.sender, actionType, uriOrTicker);
   }
 
   /**

scripts/deploy.js

@@ -8,6 +8,10 @@ const { collectActionAmounts, submitActionAmounts } = require('./modules/blockch
 
 const cliReader = readline.createInterface({ input: process.stdin, output: process.stdout })
 
+async function sleep(seconds) {
+  return new Promise(resolve => setTimeout(resolve, seconds * 1000))
+}
+
 async function main() {
   const chainId = hre.network.config.chainId
   const rpcUrl = hre.network.config.url
@@ -53,6 +57,7 @@ async function main() {
   console.log()
 
   console.log('Publishing specified action prices...')
+  await sleep(5)
   const txData = await submitActionAmounts(actionsDto, requestProcessorAddress, walletSigner)
   console.log(`TX: ${txData.hash}`)
 }

test/XRequestProcessor.test.js

@@ -183,24 +183,25 @@ describe(`XRequestProcessor tests`, function () {
     expect(processorContractBalance).to.equal(repostAmount)
   })
 
-  it('interactWithPost() - User should NOT be able to invoke actions without ERC20 balance', async function () {
-    const { user1, processorContract, tokenContract } = await loadFixture(
+  it('interactWithPost() - User should be able to invoke XActionType.TokenAnalysis actions', async function () {
+    const { owner, user1, processorContract, tokenContract } = await loadFixture(
       deployXRequestProcessorFixture
     )
 
-    const spender = await processorContract.getAddress()
-    await tokenContract.connect(user1).approve(spender, likeAmount)
+    await tokenContract.connect(owner).transfer(user1.address, tokenAnalysisAmount)
+    const processorContractAddress = await processorContract.getAddress()
+    await tokenContract.connect(user1).approve(processorContractAddress, tokenAnalysisAmount)
 
-    const userBalance = await tokenContract.balanceOf(user1.address)
-    expect(userBalance).to.equal(0n)
+    const userBalanceBefore = await tokenContract.balanceOf(user1.address)
+    expect(userBalanceBefore).to.equal(tokenAnalysisAmount)
 
-    const xPostUri = 'https://x.com/SpaceX/status/1928107204931940365'
+    const ticker = 'GIANTAI'
     await expect(
-      processorContract.connect(user1).interactWithPost(XActionType.Like, xPostUri)
-    ).to.be.revertedWithCustomError(tokenContract, 'ERC20InsufficientBalance')
+      processorContract.connect(user1).interactWithPost(XActionType.TokenAnalysis, ticker)
+    ).not.to.be.reverted
   })
 
-  it('interactWithPost() - User should NOT be able to invoke XActionType.TokenAnalysis through this method', async function () {
+  it('interactWithPost() - User should NOT be able to invoke XActionType.TokenAnalysis with invalid TICKER', async function () {
     const { owner, user1, processorContract, tokenContract } = await loadFixture(
       deployXRequestProcessorFixture
     )
@@ -212,13 +213,13 @@ describe(`XRequestProcessor tests`, function () {
     const userBalanceBefore = await tokenContract.balanceOf(user1.address)
     expect(userBalanceBefore).to.equal(tokenAnalysisAmount)
 
-    const xPostUri = 'https://x.com/SpaceX/status/1928107204931940365'
+    const ticker = 'SUPER_LONG_AND_INVALID_TICKER_NAME'
     await expect(
-      processorContract.connect(user1).interactWithPost(XActionType.TokenAnalysis, xPostUri)
+      processorContract.connect(user1).interactWithPost(XActionType.TokenAnalysis, ticker)
     ).to.be.reverted
   })
 
-  it('analyzeToken() - User should be able to invoke token analysis action', async function () {
+  it('interactWithPost() - User should NOT be able to invoke actions with empty URI or TICKER', async function () {
     const { owner, user1, processorContract, tokenContract } = await loadFixture(
       deployXRequestProcessorFixture
     )
@@ -230,41 +231,29 @@ describe(`XRequestProcessor tests`, function () {
     const userBalanceBefore = await tokenContract.balanceOf(user1.address)
     expect(userBalanceBefore).to.equal(tokenAnalysisAmount)
 
-    await expect(processorContract.connect(user1).analyzeToken('GIANTAI')).to.emit(
-      processorContract,
-      'NewTokenAnalysis'
-    )
-
-    const userBalanceAfter = await tokenContract.balanceOf(user1.address)
-    expect(userBalanceAfter).to.equal(0n)
-
-    const processorContractBalance = await tokenContract.balanceOf(processorContractAddress)
-    expect(processorContractBalance).to.equal(tokenAnalysisAmount)
+    const xPostUri = ''
+    await expect(
+      processorContract.connect(user1).interactWithPost(XActionType.TokenAnalysis, xPostUri)
+    ).to.be.reverted
   })
 
-  it('analyzeToken() - User should NOT be able to invoke token analysis without ERC20 balance', async function () {
+  it('interactWithPost() - User should NOT be able to invoke actions without ERC20 balance', async function () {
     const { user1, processorContract, tokenContract } = await loadFixture(
       deployXRequestProcessorFixture
     )
 
     const spender = await processorContract.getAddress()
-    await tokenContract.connect(user1).approve(spender, tokenAnalysisAmount)
+    await tokenContract.connect(user1).approve(spender, likeAmount)
 
     const userBalance = await tokenContract.balanceOf(user1.address)
     expect(userBalance).to.equal(0n)
 
+    const xPostUri = 'https://x.com/SpaceX/status/1928107204931940365'
     await expect(
-      processorContract.connect(user1).analyzeToken('GIANTAI')
+      processorContract.connect(user1).interactWithPost(XActionType.Like, xPostUri)
     ).to.be.revertedWithCustomError(tokenContract, 'ERC20InsufficientBalance')
   })
 
-  it('analyzeToken() - Should throw when invalid token ticker is provided', async function () {
-    const { user1, processorContract } = await loadFixture(deployXRequestProcessorFixture)
-
-    const invalidTicker = 'INVALID_SUPER_LONG_TICKER_NAME'
-    await expect(processorContract.connect(user1).analyzeToken(invalidTicker)).to.be.reverted
-  })
-
   it('getPaymentTokenAddress() - Should return the ERC20 address set during deploy time', async function () {
     const { processorContract, tokenContract } = await loadFixture(deployXRequestProcessorFixture)