refactor(ERC20RecurringPaymentProxy): rename execution functions and …

…update related comments and tests for clarity

packages/payment-processor/src/payment/erc20-recurring-payment-proxy.ts

@@ -55,7 +55,7 @@ export async function getPayerRecurringPaymentAllowance({
  * @param network - The EVM chain name where the proxy is deployed
  * @param isUSDT - Flag to indicate if the token is USDT, which requires special handling
  *
- * @returns Array of transaction objects ready to be executed by a wallet
+ * @returns Array of transaction objects ready to be sent to the blockchain
  *
  * @throws {Error} If the ERC20RecurringPaymentProxy is not deployed on the specified network
  *
@@ -104,24 +104,24 @@ export function encodeSetRecurringAllowance({
 }
 
 /**
- * Encodes the transaction data to execute a recurring payment through the ERC20RecurringPaymentProxy.
+ * Encodes the transaction data to trigger a recurring payment through the ERC20RecurringPaymentProxy.
  *
  * @param permitTuple - The SchedulePermit struct data
  * @param permitSignature - The signature authorizing the recurring payment schedule
- * @param paymentIndex - The index of the payment to execute (1-based)
- * @param paymentReference - Reference data for the payment execution
+ * @param paymentIndex - The index of the payment to trigger (1-based)
+ * @param paymentReference - Reference data for the payment
  * @param network - The EVM chain name where the proxy is deployed
  *
  * @returns The encoded function data as a hex string, ready to be used in a transaction
  *
  * @throws {Error} If the ERC20RecurringPaymentProxy is not deployed on the specified network
  *
  * @remarks
- * • The function only encodes the transaction data without executing it
+ * • The function only encodes the transaction data without sending it
  * • The encoded data can be used with any web3 library or multisig wallet
- * • Make sure the paymentIndex matches the expected execution sequence
+ * • Make sure the paymentIndex matches the expected payment sequence
  */
-export function encodeRecurringPaymentExecution({
+export function encodeRecurringPaymentTrigger({
   permitTuple,
   permitSignature,
   paymentIndex,
@@ -138,7 +138,7 @@ export function encodeRecurringPaymentExecution({
 }): string {
   const proxyContract = erc20RecurringPaymentProxyArtifact.connect(network, provider);
 
-  return proxyContract.interface.encodeFunctionData('execute', [
+  return proxyContract.interface.encodeFunctionData('triggerRecurringPayment', [
     permitTuple,
     permitSignature,
     paymentIndex,
@@ -147,13 +147,13 @@ export function encodeRecurringPaymentExecution({
 }
 
 /**
- * Executes a recurring payment through the ERC20RecurringPaymentProxy.
+ * Triggers a recurring payment through the ERC20RecurringPaymentProxy.
  *
  * @param permitTuple - The SchedulePermit struct data
  * @param permitSignature - The signature authorizing the recurring payment schedule
- * @param paymentIndex - The index of the payment to execute (1-based)
- * @param paymentReference - Reference data for the payment execution
- * @param signer - The signer that will execute the transaction (must have EXECUTOR_ROLE)
+ * @param paymentIndex - The index of the payment to trigger (1-based)
+ * @param paymentReference - Reference data for the payment
+ * @param signer - The signer that will trigger the transaction (must have RELAYER_ROLE)
  * @param network - The EVM chain name where the proxy is deployed
  *
  * @returns A Promise resolving to the transaction receipt after the payment is confirmed
@@ -163,10 +163,10 @@ export function encodeRecurringPaymentExecution({
  *
  * @remarks
  * • The function waits for the transaction to be mined before returning
- * • The signer must have been granted EXECUTOR_ROLE by the proxy admin
+ * • The signer must have been granted RELAYER_ROLE by the proxy admin
  * • Make sure all preconditions are met (allowance, balance, timing) before calling
  */
-export async function executeRecurringPayment({
+export async function triggerRecurringPayment({
   permitTuple,
   permitSignature,
   paymentIndex,
@@ -183,7 +183,7 @@ export async function executeRecurringPayment({
 }): Promise<providers.TransactionReceipt> {
   const proxyAddress = getRecurringPaymentProxyAddress(network);
 
-  const data = encodeRecurringPaymentExecution({
+  const data = encodeRecurringPaymentTrigger({
     permitTuple,
     permitSignature,
     paymentIndex,

packages/payment-processor/test/payment/erc-20-recurring-payment.test.ts

@@ -1,10 +1,10 @@
-import { Wallet, providers } from 'ethers';
 import { erc20RecurringPaymentProxyArtifact } from '@requestnetwork/smart-contracts';
 import { CurrencyTypes, PaymentTypes } from '@requestnetwork/types';
+import { Wallet, providers } from 'ethers';
 import {
+  encodeRecurringPaymentTrigger,
   encodeSetRecurringAllowance,
-  encodeRecurringPaymentExecution,
-  executeRecurringPayment,
+  triggerRecurringPayment,
 } from '../../src/payment/erc20-recurring-payment-proxy';
 
 const mnemonic = 'candy maple cake sugar pudding cream honey rich smooth crumble sweet treat';
@@ -20,10 +20,10 @@ const schedulePermit: PaymentTypes.SchedulePermit = {
   feeAddress: '0x4234567890123456789012345678901234567890',
   amount: '1000000000000000000', // 1 token
   feeAmount: '10000000000000000', // 0.01 token
-  executorFee: '5000000000000000', // 0.005 token
+  relayerFee: '5000000000000000', // 0.005 token
   periodSeconds: 86400, // 1 day
   firstExec: Math.floor(Date.now() / 1000),
-  totalExecutions: 12,
+  totalPayments: 12,
   nonce: '1',
   deadline: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
   strictOrder: true,
@@ -118,9 +118,9 @@ describe('erc20-recurring-payment-proxy', () => {
     });
   });
 
-  describe('encodeRecurringPaymentExecution', () => {
-    it('should encode execution data correctly', () => {
-      const encodedData = encodeRecurringPaymentExecution({
+  describe('encodeRecurringPaymentTrigger', () => {
+    it('should encode trigger data correctly', () => {
+      const encodedData = encodeRecurringPaymentTrigger({
         permitTuple: schedulePermit,
         permitSignature,
         paymentIndex: 1,
@@ -134,12 +134,12 @@ describe('erc20-recurring-payment-proxy', () => {
     });
   });
 
-  describe('executeRecurringPayment', () => {
+  describe('triggerRecurringPayment', () => {
     it('should throw if proxy not deployed on network', async () => {
       jest.spyOn(erc20RecurringPaymentProxyArtifact, 'getAddress').mockReturnValue('');
 
       await expect(
-        executeRecurringPayment({
+        triggerRecurringPayment({
           permitTuple: schedulePermit,
           permitSignature,
           paymentIndex: 1,
@@ -151,3 +151,45 @@ describe('erc20-recurring-payment-proxy', () => {
     });
   });
 });
+
+describe('ERC20 Recurring Payment', () => {
+  const permit: PaymentTypes.SchedulePermit = {
+    subscriber: '0x1234567890123456789012345678901234567890',
+    token: '0x1234567890123456789012345678901234567890',
+    recipient: '0x1234567890123456789012345678901234567890',
+    feeAddress: '0x1234567890123456789012345678901234567890',
+    amount: '1000000000000000000', // 1 token
+    feeAmount: '10000000000000000', // 0.01 token
+    relayerFee: '5000000000000000', // 0.005 token
+    periodSeconds: 86400, // 1 day
+    firstExec: Math.floor(Date.now() / 1000),
+    totalPayments: 12,
+    nonce: 0,
+    deadline: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
+    strictOrder: false,
+  };
+
+  it('should encode recurring payment execution', () => {
+    const encoded = encodeRecurringPaymentTrigger({
+      permitTuple: permit,
+      permitSignature,
+      paymentIndex: 1,
+      paymentReference,
+      network,
+      provider,
+    });
+    expect(encoded).toBeDefined();
+  });
+
+  it('should execute recurring payment', async () => {
+    const result = await triggerRecurringPayment({
+      permitTuple: permit,
+      permitSignature,
+      paymentIndex: 1,
+      paymentReference,
+      signer: wallet,
+      network,
+    });
+    expect(result).toBeDefined();
+  });
+});

packages/smart-contracts/src/contracts/ERC20RecurringPaymentProxy.sol

@@ -12,7 +12,7 @@ import './lib/SafeERC20.sol';
 
 /**
  * @title ERC20RecurringPaymentProxy
- * @notice Executes recurring ERC20 payments.
+ * @notice Triggers recurring ERC20 payments based on predefined schedules.
  */
 contract ERC20RecurringPaymentProxy is EIP712, AccessControl, Pausable, ReentrancyGuard, Ownable {
   using SafeERC20 for IERC20;
@@ -21,26 +21,26 @@ contract ERC20RecurringPaymentProxy is EIP712, AccessControl, Pausable, Reentran
   error ERC20RecurringPaymentProxy__BadSignature();
   error ERC20RecurringPaymentProxy__SignatureExpired();
   error ERC20RecurringPaymentProxy__IndexTooLarge();
-  error ERC20RecurringPaymentProxy__ExecutionOutOfOrder();
+  error ERC20RecurringPaymentProxy__PaymentOutOfOrder();
   error ERC20RecurringPaymentProxy__IndexOutOfBounds();
   error ERC20RecurringPaymentProxy__NotDueYet();
   error ERC20RecurringPaymentProxy__AlreadyPaid();
   error ERC20RecurringPaymentProxy__ZeroAddress();
 
-  bytes32 public constant EXECUTOR_ROLE = keccak256('EXECUTOR_ROLE');
+  bytes32 public constant RELAYER_ROLE = keccak256('RELAYER_ROLE');
 
-  /* keccak256 of the typed-data struct with executorFee field */
+  /* keccak256 of the typed-data struct with relayerFee field */
   bytes32 private constant _PERMIT_TYPEHASH =
     keccak256(
       'SchedulePermit(address subscriber,address token,address recipient,'
-      'address feeAddress,uint128 amount,uint128 feeAmount,uint128 executorFee,'
-      'uint32 periodSeconds,uint32 firstExec,uint8 totalExecutions,'
+      'address feeAddress,uint128 amount,uint128 feeAmount,uint128 relayerFee,'
+      'uint32 periodSeconds,uint32 firstExec,uint8 totalPayments,'
       'uint256 nonce,uint256 deadline,bool strictOrder)'
     );
 
   /* replay defence */
-  mapping(bytes32 => uint256) public executedBitmap;
-  mapping(bytes32 => uint8) public lastExecutionIndex;
+  mapping(bytes32 => uint256) public triggeredPaymentsBitmap;
+  mapping(bytes32 => uint8) public lastPaymentIndex;
 
   IERC20FeeProxy public erc20FeeProxy;
 
@@ -51,27 +51,25 @@ contract ERC20RecurringPaymentProxy is EIP712, AccessControl, Pausable, Reentran
     address feeAddress;
     uint128 amount;
     uint128 feeAmount;
-    uint128 executorFee;
+    uint128 relayerFee;
     uint32 periodSeconds;
     uint32 firstExec;
-    uint8 totalExecutions;
+    uint8 totalPayments;
     uint256 nonce;
     uint256 deadline;
     bool strictOrder;
   }
 
   constructor(
     address adminSafe,
-    address executorEOA,
+    address relayerEOA,
     address erc20FeeProxyAddress
   ) EIP712('ERC20RecurringPaymentProxy', '1') {
-    if (
-      adminSafe == address(0) || executorEOA == address(0) || erc20FeeProxyAddress == address(0)
-    ) {
+    if (adminSafe == address(0) || relayerEOA == address(0) || erc20FeeProxyAddress == address(0)) {
       revert ERC20RecurringPaymentProxy__ZeroAddress();
     }
     _grantRole(DEFAULT_ADMIN_ROLE, adminSafe);
-    _grantRole(EXECUTOR_ROLE, executorEOA);
+    _grantRole(RELAYER_ROLE, relayerEOA);
     transferOwnership(adminSafe);
     erc20FeeProxy = IERC20FeeProxy(erc20FeeProxyAddress);
   }
@@ -93,12 +91,12 @@ contract ERC20RecurringPaymentProxy is EIP712, AccessControl, Pausable, Reentran
     );
   }
 
-  function execute(
+  function triggerRecurringPayment(
     SchedulePermit calldata p,
     bytes calldata signature,
     uint8 index,
     bytes calldata paymentReference
-  ) external whenNotPaused onlyRole(EXECUTOR_ROLE) nonReentrant {
+  ) external whenNotPaused onlyRole(RELAYER_ROLE) nonReentrant {
     bytes32 digest = _hashSchedule(p);
 
     if (digest.recover(signature) != p.subscriber)
@@ -108,22 +106,22 @@ contract ERC20RecurringPaymentProxy is EIP712, AccessControl, Pausable, Reentran
     if (index >= 256) revert ERC20RecurringPaymentProxy__IndexTooLarge();
 
     if (p.strictOrder) {
-      if (index != lastExecutionIndex[digest] + 1)
-        revert ERC20RecurringPaymentProxy__ExecutionOutOfOrder();
-      lastExecutionIndex[digest] = index;
+      if (index != lastPaymentIndex[digest] + 1)
+        revert ERC20RecurringPaymentProxy__PaymentOutOfOrder();
+      lastPaymentIndex[digest] = index;
     }
 
-    if (index > p.totalExecutions) revert ERC20RecurringPaymentProxy__IndexOutOfBounds();
+    if (index > p.totalPayments) revert ERC20RecurringPaymentProxy__IndexOutOfBounds();
 
     uint256 execTime = uint256(p.firstExec) + uint256(index - 1) * p.periodSeconds;
     if (block.timestamp < execTime) revert ERC20RecurringPaymentProxy__NotDueYet();
 
     uint256 mask = 1 << index;
-    uint256 word = executedBitmap[digest];
+    uint256 word = triggeredPaymentsBitmap[digest];
     if (word & mask != 0) revert ERC20RecurringPaymentProxy__AlreadyPaid();
-    executedBitmap[digest] = word | mask;
+    triggeredPaymentsBitmap[digest] = word | mask;
 
-    uint256 total = p.amount + p.feeAmount + p.executorFee;
+    uint256 total = p.amount + p.feeAmount + p.relayerFee;
 
     IERC20 token = IERC20(p.token);
     token.safeTransferFrom(p.subscriber, address(this), total);
@@ -134,15 +132,15 @@ contract ERC20RecurringPaymentProxy is EIP712, AccessControl, Pausable, Reentran
 
     _proxyTransfer(p, paymentReference);
 
-    if (p.executorFee != 0) {
-      token.safeTransfer(msg.sender, p.executorFee);
+    if (p.relayerFee != 0) {
+      token.safeTransfer(msg.sender, p.relayerFee);
     }
   }
 
-  function setExecutor(address oldExec, address newExec) external onlyOwner {
-    if (newExec == address(0)) revert ERC20RecurringPaymentProxy__ZeroAddress();
-    _revokeRole(EXECUTOR_ROLE, oldExec);
-    _grantRole(EXECUTOR_ROLE, newExec);
+  function setRelayer(address oldRelayer, address newRelayer) external onlyOwner {
+    if (newRelayer == address(0)) revert ERC20RecurringPaymentProxy__ZeroAddress();
+    _revokeRole(RELAYER_ROLE, oldRelayer);
+    _grantRole(RELAYER_ROLE, newRelayer);
   }
 
   function setFeeProxy(address newProxy) external onlyOwner {