feat: create deploySingleRequestProxy functionality in the sdk

packages/payment-processor/src/index.ts

@@ -27,6 +27,8 @@ export * from './payment/encoder-approval';
 export * as Escrow from './payment/erc20-escrow-payment';
 export * from './payment/prepared-transaction';
 export * from './payment/utils-near';
+export * from './payment/single-request-proxy';
+
 import * as utils from './payment/utils';
 
 export { utils };

packages/payment-processor/src/payment/single-request-proxy.ts

@@ -0,0 +1,271 @@
+import { Contract, Signer, ethers } from 'ethers';
+import {
+  PaymentReferenceCalculator,
+  getPaymentNetworkExtension,
+} from '@requestnetwork/payment-detection';
+import { ClientTypes, ExtensionTypes, CurrencyTypes } from '@requestnetwork/types';
+import { singleRequestProxyFactoryArtifact } from '@requestnetwork/smart-contracts';
+import { IERC20__factory } from '@requestnetwork/smart-contracts/types';
+
+/**
+ * Deploys a Single Request Proxy contract for a given request.
+ *
+ * @param request - The request data object containing payment network and currency information.
+ * @param signer - The Ethereum signer used to deploy the contract.
+ * @returns A Promise that resolves to the address of the deployed Single Request Proxy contract.
+ * @throws {Error} If the payment network is unsupported, payment chain is not found, payee is not found, or if there are invalid payment network values.
+ *
+ * @remarks
+ * This function supports deploying proxies for ERC20_FEE_PROXY_CONTRACT and ETH_FEE_PROXY_CONTRACT payment networks.
+ * It uses the SingleRequestProxyFactory contract to create either an ERC20 or Ethereum Single Request Proxy.
+ * The function calculates the payment reference and handles the deployment transaction, including waiting for confirmation.
+ * The factory address is automatically determined based on the payment chain using the singleRequestProxyFactoryArtifact.
+ */
+export async function deploySingleRequestProxy(
+  request: ClientTypes.IRequestData,
+  signer: Signer,
+): Promise<string> {
+  const requestPaymentNetwork = getPaymentNetworkExtension(request);
+
+  // Check if the payment network is supported, only ERC20_FEE_PROXY_CONTRACT and ETH_FEE_PROXY_CONTRACT are supported
+  if (
+    !requestPaymentNetwork ||
+    (requestPaymentNetwork.id !== ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_FEE_PROXY_CONTRACT &&
+      requestPaymentNetwork.id !== ExtensionTypes.PAYMENT_NETWORK_ID.ETH_FEE_PROXY_CONTRACT)
+  ) {
+    throw new Error('Unsupported payment network');
+  }
+
+  const paymentChain = request.currencyInfo.network;
+  if (!paymentChain) {
+    throw new Error('Payment chain not found');
+  }
+
+  // Use artifact's default address for the payment chain
+  const singleRequestProxyFactory = singleRequestProxyFactoryArtifact.connect(
+    paymentChain as CurrencyTypes.EvmChainName,
+    signer,
+  );
+
+  if (!singleRequestProxyFactory.address) {
+    throw new Error(`SingleRequestProxyFactory not found on chain ${paymentChain}`);
+  }
+
+  const salt = requestPaymentNetwork?.values?.salt;
+  const feeAddress = requestPaymentNetwork?.values?.feeAddress;
+  const feeAmount = requestPaymentNetwork?.values?.feeAmount;
+  const paymentRecipient = requestPaymentNetwork?.values?.paymentAddress;
+
+  if (!salt || !feeAddress || !feeAmount || !paymentRecipient) {
+    throw new Error('Invalid payment network values');
+  }
+
+  const paymentReference = `0x${PaymentReferenceCalculator.calculate(
+    request.requestId,
+    salt,
+    paymentRecipient,
+  )}`;
+
+  const isERC20 =
+    requestPaymentNetwork.id === ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_FEE_PROXY_CONTRACT;
+
+  let tx;
+
+  if (isERC20) {
+    const tokenAddress = request.currencyInfo.value;
+    tx = await singleRequestProxyFactory.createERC20SingleRequestProxy(
+      paymentRecipient,
+      tokenAddress,
+      paymentReference,
+      feeAddress,
+      feeAmount,
+    );
+  } else {
+    tx = await singleRequestProxyFactory.createEthereumSingleRequestProxy(
+      paymentRecipient,
+      paymentReference,
+      feeAddress,
+      feeAmount,
+    );
+  }
+
+  const receipt = await tx.wait();
+
+  const event = receipt.events?.[0];
+
+  if (!event) {
+    throw new Error('Single request proxy creation event not found');
+  }
+
+  const proxyAddress = ethers.utils.defaultAbiCoder.decode(['address', 'address'], event.data)[0];
+
+  if (!proxyAddress) {
+    throw new Error('Proxy address not found in event data');
+  }
+
+  return proxyAddress;
+}
+
+/**
+ * Validates that a contract is a SingleRequestProxy by checking required methods
+ * @param proxyAddress - The address of the contract to validate
+ * @param signer - The Ethereum signer used to interact with the contract
+ * @throws {Error} If the contract is not a valid SingleRequestProxy
+ */
+async function validateSingleRequestProxy(proxyAddress: string, signer: Signer): Promise<void> {
+  const proxyInterface = new ethers.utils.Interface([
+    'function payee() view returns (address)',
+    'function paymentReference() view returns (bytes)',
+    'function feeAddress() view returns (address)',
+    'function feeAmount() view returns (uint256)',
+  ]);
+
+  const proxyContract = new Contract(proxyAddress, proxyInterface, signer);
+
+  try {
+    await Promise.all([
+      proxyContract.payee(),
+      proxyContract.paymentReference(),
+      proxyContract.feeAddress(),
+      proxyContract.feeAmount(),
+    ]);
+  } catch (error) {
+    throw new Error('Invalid SingleRequestProxy contract');
+  }
+}
+
+/**
+ * Executes a payment through an ERC20SingleRequestProxy contract
+ * @param proxyAddress - The address of the SingleRequestProxy contract
+ * @param signer - The Ethereum signer used to execute the payment transaction
+ * @param amount - The amount to be paid
+ * @throws {Error} If the contract is not an ERC20SingleRequestProxy
+ */
+export async function payWithERC20SingleRequestProxy(
+  proxyAddress: string,
+  signer: Signer,
+  amount: string,
+): Promise<void> {
+  if (!amount || ethers.BigNumber.from(amount).lte(0)) {
+    throw new Error('Amount must be a positive number');
+  }
+
+  const proxyInterface = new ethers.utils.Interface([
+    'function tokenAddress() view returns (address)',
+  ]);
+
+  const proxyContract = new Contract(proxyAddress, proxyInterface, signer);
+
+  let tokenAddress: string;
+  try {
+    // Attempt to fetch the token address from the proxy contract, to determine if it's an ERC20 SingleRequestProxy.
+    tokenAddress = await proxyContract.tokenAddress();
+  } catch {
+    throw new Error('Contract is not an ERC20SingleRequestProxy');
+  }
+
+  const erc20Contract = IERC20__factory.connect(tokenAddress, signer);
+
+  // Transfer tokens to the proxy
+  const transferTx = await erc20Contract.transfer(proxyAddress, amount);
+  await transferTx.wait();
+
+  // Trigger the proxy's receive function to finalize payment
+  const triggerTx = await signer.sendTransaction({
+    to: proxyAddress,
+    value: ethers.constants.Zero,
+  });
+  await triggerTx.wait();
+}
+
+/**
+ * Executes a payment through an EthereumSingleRequestProxy contract
+ * @param proxyAddress - The address of the SingleRequestProxy contract
+ * @param signer - The Ethereum signer used to execute the payment transaction
+ * @param amount - The amount to be paid
+ * @throws {Error} If the contract is an ERC20SingleRequestProxy
+ */
+export async function payWithEthereumSingleRequestProxy(
+  proxyAddress: string,
+  signer: Signer,
+  amount: string,
+): Promise<void> {
+  if (!amount || ethers.BigNumber.from(amount).lte(0)) {
+    throw new Error('Amount must be a positive number');
+  }
+
+  const proxyInterface = new ethers.utils.Interface([
+    'function tokenAddress() view returns (address)',
+  ]);
+
+  const proxyContract = new Contract(proxyAddress, proxyInterface, signer);
+
+  try {
+    // Attempt to fetch the token address from the proxy contract, to determine if it's an Ethereum SingleRequestProxy.
+    await proxyContract.tokenAddress();
+
+    // If the token address is fetched, it means the contract is an ERC20SingleRequestProxy.
+    throw new Error('Contract is not an EthereumSingleRequestProxy');
+  } catch (error) {
+    // If the token address is not fetched, it means the contract is an EthereumSingleRequestProxy.
+    if (error.message === 'Contract is not an EthereumSingleRequestProxy') {
+      // If the error message is 'Contract is not an EthereumSingleRequestProxy', throw the error.
+      throw error;
+    }
+  }
+
+  const tx = await signer.sendTransaction({
+    to: proxyAddress,
+    value: amount,
+  });
+  await tx.wait();
+}
+
+/**
+ * Executes a payment through a Single Request Proxy contract.
+ *
+ * @param singleRequestProxyAddress - The address of the deployed Single Request Proxy contract.
+ * @param signer - The Ethereum signer used to execute the payment transaction.
+ * @param amount - The amount to be paid, as a string representation of the value.
+ * @returns A Promise that resolves when the payment transaction is confirmed.
+ * @throws {Error} If the SingleRequestProxy contract is invalid.
+ * @throws {Error} If the proxy contract type cannot be determined, or if any transaction fails.
+ *
+ * @remarks
+ * This function supports both ERC20 and Ethereum payments.
+ * For ERC20 payments, it first transfers the tokens to the proxy contract and then triggers the payment.
+ * For Ethereum payments, it directly sends the Ether to the proxy contract.
+ * The function automatically detects whether the proxy is for ERC20 or Ethereum based on the contract interface.
+ */
+export async function payRequestWithSingleRequestProxy(
+  singleRequestProxyAddress: string,
+  signer: Signer,
+  amount: string,
+): Promise<void> {
+  if (!amount || ethers.BigNumber.from(amount).lte(0)) {
+    throw new Error('Amount must be a positive number');
+  }
+
+  // Validate the SingleRequestProxy contract
+  await validateSingleRequestProxy(singleRequestProxyAddress, signer);
+
+  const proxyInterface = new ethers.utils.Interface([
+    'function tokenAddress() view returns (address)',
+  ]);
+
+  const proxyContract = new Contract(singleRequestProxyAddress, proxyInterface, signer);
+
+  let isERC20: boolean;
+  try {
+    await proxyContract.tokenAddress();
+    isERC20 = true;
+  } catch {
+    isERC20 = false;
+  }
+
+  if (isERC20) {
+    await payWithERC20SingleRequestProxy(singleRequestProxyAddress, signer, amount);
+  } else {
+    await payWithEthereumSingleRequestProxy(singleRequestProxyAddress, signer, amount);
+  }
+}