feat: Develop SingleRequestProxy Smart Contracts

packages/smart-contracts/scripts-create2/compute-one-address.ts

@@ -64,7 +64,8 @@ export const computeCreate2DeploymentAddressesFromList = async (
         case 'BatchConversionPayments':
         case 'ERC20SwapToPay':
         case 'ERC20SwapToConversion':
-        case 'ERC20TransferableReceivable': {
+        case 'ERC20TransferableReceivable':
+        case 'SingleRequestProxyFactory': {
           try {
             const constructorArgs = getConstructorArgs(contract, chain);
             address = await computeCreate2DeploymentAddress({ contract, constructorArgs }, hre);

packages/smart-contracts/scripts-create2/constructor-args.ts

@@ -67,6 +67,17 @@ export const getConstructorArgs = (
       const erc20FeeProxyAddress = erc20FeeProxy.getAddress(network);
       return ['Request Network Transferable Receivable', 'tREC', erc20FeeProxyAddress];
     }
+    case 'SingleRequestProxyFactory': {
+      if (!network) {
+        throw new Error('SingleRequestProxyFactory requires network parameter');
+      }
+      const erc20FeeProxy = artifacts.erc20FeeProxyArtifact;
+      const erc20FeeProxyAddress = erc20FeeProxy.getAddress(network);
+      const ethereumFeeProxy = artifacts.ethereumFeeProxyArtifact;
+      const ethereumFeeProxyAddress = ethereumFeeProxy.getAddress(network);
+
+      return [ethereumFeeProxyAddress, erc20FeeProxyAddress];
+    }
     default:
       return [];
   }

packages/smart-contracts/scripts-create2/transfer-ownership.ts

@@ -12,7 +12,8 @@ export const transferOwnership = async (
       case 'Erc20ConversionProxy':
       case 'BatchConversionPayments':
       case 'ERC20SwapToPay':
-      case 'ERC20SwapToConversion': {
+      case 'ERC20SwapToConversion':
+      case 'SingleRequestProxyFactory': {
         await updateOwner({ contract, hre, signWithEoa });
         break;
       }

packages/smart-contracts/scripts-create2/utils.ts

@@ -20,6 +20,7 @@ export const create2ContractDeploymentList = [
   'BatchConversionPayments',
   'ERC20EscrowToPay',
   'ERC20TransferableReceivable',
+  'SingleRequestProxyFactory',
 ];
 
 /**

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

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.9;
+
+import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+import './interfaces/ERC20FeeProxy.sol';
+import './lib/SafeERC20.sol';
+
+/**
+ * @title ERC20SingleRequestProxy
+ * @notice This contract is used to send a single request to a payee with a fee sent to a third address for ERC20
+ */
+
+contract ERC20SingleRequestProxy {
+  address public payee;
+  address public tokenAddress;
+  address public feeAddress;
+  uint256 public feeAmount;
+  bytes public paymentReference;
+  IERC20FeeProxy public erc20FeeProxy;
+
+  constructor(
+    address _payee,
+    address _tokenAddress,
+    address _feeAddress,
+    uint256 _feeAmount,
+    bytes memory _paymentReference,
+    address _erc20FeeProxy
+  ) {
+    payee = _payee;
+    tokenAddress = _tokenAddress;
+    feeAddress = _feeAddress;
+    feeAmount = _feeAmount;
+    paymentReference = _paymentReference;
+    erc20FeeProxy = IERC20FeeProxy(_erc20FeeProxy);
+  }
+
+  receive() external payable {
+    require(msg.value == 0, 'This function is only for triggering the transfer');
+    _processPayment();
+  }
+
+  function triggerERC20Payment() external {
+    _processPayment();
+  }
+
+  function _processPayment() internal {
+    IERC20 token = IERC20(tokenAddress);
+    uint256 balance = token.balanceOf(address(this));
+    uint256 paymentAmount = balance;
+    if (feeAmount > 0 && feeAddress != address(0)) {
+      require(balance > feeAmount, 'Insufficient balance to cover fee');
+      paymentAmount = balance - feeAmount;
+    }
+
+    require(SafeERC20.safeApprove(token, address(erc20FeeProxy), balance), 'Approval failed');
+
+    erc20FeeProxy.transferFromWithReferenceAndFee(
+      tokenAddress,
+      payee,
+      paymentAmount,
+      paymentReference,
+      feeAmount,
+      feeAddress
+    );
+  }
+
+  /**
+   * @notice Rescues any trapped funds by sending them to the payee
+   * @dev Can be called by anyone, but funds are always sent to the payee
+   */
+  function rescueERC20Funds(address _tokenAddress) external {
+    require(_tokenAddress != address(0), 'Invalid token address');
+    IERC20 token = IERC20(_tokenAddress);
+    uint256 balance = token.balanceOf(address(this));
+    require(balance > 0, 'No funds to rescue');
+    bool success = SafeERC20.safeTransfer(token, payee, balance);
+    require(success, 'ERC20 rescue failed');
+  }
+
+  /**
+   * @notice Rescues any trapped funds by sending them to the payee
+   * @dev Can be called by anyone, but funds are always sent to the payee
+   */
+  function rescueNativeFunds() external {
+    uint256 balance = address(this).balance;
+    require(balance > 0, 'No funds to rescue');
+
+    (bool success, ) = payable(payee).call{value: balance}('');
+    require(success, 'Rescue failed');
+  }
+}

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

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.9;
+
+import './interfaces/EthereumFeeProxy.sol';
+import '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+import './lib/SafeERC20.sol';
+
+/**
+ * @title EthereumSingleRequestProxy
+ * @notice This contract is used to send a single request to a payee with a fee sent to a third address
+ */
+contract EthereumSingleRequestProxy {
+  address public payee;
+  bytes public paymentReference;
+  address public feeAddress;
+  uint256 public feeAmount;
+  IEthereumFeeProxy public ethereumFeeProxy;
+
+  address private originalSender;
+
+  /**
+   * @dev Custom reentrancy guard.
+   * Similar to OpenZeppelin's ReentrancyGuard, but allows reentrancy from ethereumFeeProxy.
+   * This enables controlled callbacks from ethereumFeeProxy while protecting against other reentrancy attacks.
+   */
+  uint256 private constant _NOT_ENTERED = 1;
+  uint256 private constant _ENTERED = 2;
+  uint256 private _status;
+
+  constructor(
+    address _payee,
+    bytes memory _paymentReference,
+    address _ethereumFeeProxy,
+    address _feeAddress,
+    uint256 _feeAmount
+  ) {
+    payee = _payee;
+    paymentReference = _paymentReference;
+    feeAddress = _feeAddress;
+    feeAmount = _feeAmount;
+    ethereumFeeProxy = IEthereumFeeProxy(_ethereumFeeProxy);
+    _status = _NOT_ENTERED;
+  }
+
+  /**
+   * @dev Modified nonReentrant guard.
+   * Prevents reentrancy except for calls from ethereumFeeProxy.
+   */
+  modifier nonReentrant() {
+    if (msg.sender != address(ethereumFeeProxy)) {
+      require(_status != _ENTERED, 'ReentrancyGuard: reentrant call');
+      _status = _ENTERED;
+    }
+    _;
+    if (msg.sender != address(ethereumFeeProxy)) {
+      _status = _NOT_ENTERED;
+    }
+  }
+
+  receive() external payable nonReentrant {
+    if (msg.sender == address(ethereumFeeProxy)) {
+      // Funds are being sent back from EthereumFeeProxy
+      require(originalSender != address(0), 'No original sender stored');
+
+      // Forward the funds to the original sender
+      (bool forwardSuccess, ) = payable(originalSender).call{value: msg.value}('');
+      require(forwardSuccess, 'Forwarding to original sender failed');
+
+      // Clear the stored original sender
+      originalSender = address(0);
+    } else {
+      require(originalSender == address(0), 'Another request is in progress');
+
+      originalSender = msg.sender;
+
+      bytes memory data = abi.encodeWithSignature(
+        'transferWithReferenceAndFee(address,bytes,uint256,address)',
+        payable(payee),
+        paymentReference,
+        feeAmount,
+        payable(feeAddress)
+      );
+
+      (bool callSuccess, ) = address(ethereumFeeProxy).call{value: msg.value}(data);
+      require(callSuccess, 'Call to EthereumFeeProxy failed');
+    }
+  }
+
+  /**
+   * @notice Rescues any trapped funds by sending them to the payee
+   * @dev Can be called by anyone, but funds are always sent to the payee
+   */
+  function rescueNativeFunds() external nonReentrant {
+    uint256 balance = address(this).balance;
+    require(balance > 0, 'No funds to rescue');
+
+    (bool success, ) = payable(payee).call{value: balance}('');
+    require(success, 'Rescue failed');
+  }
+
+  /**
+   * @notice Rescues any trapped ERC20 funds by sending them to the payee
+   * @dev Can be called by anyone, but funds are always sent to the payee
+   * @param _tokenAddress The address of the ERC20 token to rescue
+   */
+  function rescueERC20Funds(address _tokenAddress) external nonReentrant {
+    require(_tokenAddress != address(0), 'Invalid token address');
+    IERC20 token = IERC20(_tokenAddress);
+    uint256 balance = token.balanceOf(address(this));
+    require(balance > 0, 'No funds to rescue');
+    bool success = SafeERC20.safeTransfer(token, payee, balance);
+    require(success, 'Rescue failed');
+  }
+}

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

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.9;
+
+import '@openzeppelin/contracts/access/Ownable.sol';
+import './ERC20SingleRequestProxy.sol';
+import './EthereumSingleRequestProxy.sol';
+
+/**
+ * @title SingleRequestProxyFactory
+ * @notice This contract is used to create SingleRequestProxy instances
+ */
+contract SingleRequestProxyFactory is Ownable {
+  /// @notice The address of the EthereumFeeProxy contract
+  /// @dev This proxy is used for handling Ethereum-based fee transactions
+  address public ethereumFeeProxy;
+
+  /// @notice The address of the ERC20FeeProxy contract
+  /// @dev This proxy is used for handling ERC20-based fee transactions
+  address public erc20FeeProxy;
+
+  event EthereumSingleRequestProxyCreated(
+    address indexed proxyAddress,
+    address indexed payee,
+    bytes indexed paymentReference
+  );
+
+  event ERC20SingleRequestProxyCreated(
+    address indexed proxyAddress,
+    address indexed payee,
+    address tokenAddress,
+    bytes indexed paymentReference
+  );
+
+  event ERC20FeeProxyUpdated(address indexed newERC20FeeProxy);
+  event EthereumFeeProxyUpdated(address indexed newEthereumFeeProxy);
+
+  constructor(address _ethereumFeeProxy, address _erc20FeeProxy) {
+    require(_ethereumFeeProxy != address(0), 'EthereumFeeProxy address cannot be zero');
+    require(_erc20FeeProxy != address(0), 'ERC20FeeProxy address cannot be zero');
+    ethereumFeeProxy = _ethereumFeeProxy;
+    erc20FeeProxy = _erc20FeeProxy;
+  }
+
+  /**
+   * @notice Creates a new EthereumSingleRequestProxy instance
+   * @param _payee The address of the payee
+   * @param _paymentReference The payment reference
+   * @param _feeAddress The address of the fee recipient
+   * @param _feeAmount The fee amount
+   * @return The address of the newly created proxy
+   */
+  function createEthereumSingleRequestProxy(
+    address _payee,
+    bytes memory _paymentReference,
+    address _feeAddress,
+    uint256 _feeAmount
+  ) external returns (address) {
+    EthereumSingleRequestProxy proxy = new EthereumSingleRequestProxy(
+      _payee,
+      _paymentReference,
+      ethereumFeeProxy,
+      _feeAddress,
+      _feeAmount
+    );
+    emit EthereumSingleRequestProxyCreated(address(proxy), _payee, _paymentReference);
+    return address(proxy);
+  }
+
+  /**
+   * @notice Creates a new ERC20SingleRequestProxy instance
+   * @param _payee The address of the payee
+   * @param _tokenAddress The address of the token
+   * @param _paymentReference The payment reference
+   * @param _feeAddress The address of the fee recipient
+   * @param _feeAmount The fee amount
+   * @return The address of the newly created proxy
+   */
+  function createERC20SingleRequestProxy(
+    address _payee,
+    address _tokenAddress,
+    bytes memory _paymentReference,
+    address _feeAddress,
+    uint256 _feeAmount
+  ) external returns (address) {
+    ERC20SingleRequestProxy proxy = new ERC20SingleRequestProxy(
+      _payee,
+      _tokenAddress,
+      _feeAddress,
+      _feeAmount,
+      _paymentReference,
+      erc20FeeProxy
+    );
+
+    emit ERC20SingleRequestProxyCreated(address(proxy), _payee, _tokenAddress, _paymentReference);
+    return address(proxy);
+  }
+
+  /**
+   * @notice Updates the ERC20FeeProxy address
+   * @param _newERC20FeeProxy The new ERC20FeeProxy address
+   */
+  function setERC20FeeProxy(address _newERC20FeeProxy) external onlyOwner {
+    require(_newERC20FeeProxy != address(0), 'ERC20FeeProxy address cannot be zero');
+    erc20FeeProxy = _newERC20FeeProxy;
+    emit ERC20FeeProxyUpdated(_newERC20FeeProxy);
+  }
+
+  /**
+   * @notice Updates the EthereumFeeProxy address
+   * @param _newEthereumFeeProxy The new EthereumFeeProxy address
+   */
+  function setEthereumFeeProxy(address _newEthereumFeeProxy) external onlyOwner {
+    require(_newEthereumFeeProxy != address(0), 'EthereumFeeProxy address cannot be zero');
+    ethereumFeeProxy = _newEthereumFeeProxy;
+    emit EthereumFeeProxyUpdated(_newEthereumFeeProxy);
+  }
+}

packages/smart-contracts/src/contracts/test/EthereumFeeProxyMock.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract MockEthereumFeeProxy {
+  function transferWithReferenceAndFee(
+    address payable _to,
+    bytes calldata _paymentReference,
+    uint256 _feeAmount,
+    address payable _feeAddress
+  ) external payable {
+    // Do nothing, just accept the funds
+  }
+
+  function sendFundsBack(address payable _to, uint256 _amount) external {
+    (bool success, ) = _to.call{value: _amount}('');
+    require(success, 'Failed to send funds back');
+  }
+
+  receive() external payable {}
+}