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 {}
+}