standard info retriever for native token detections

packages/payment-detection/src/erc20/fee-proxy-contract.ts

@@ -5,7 +5,12 @@ import {
   PaymentTypes,
   RequestLogicTypes,
 } from '@requestnetwork/types';
-import { CurrencyDefinition, EvmChains, ICurrencyManager } from '@requestnetwork/currency';
+import {
+  CurrencyDefinition,
+  EvmChains,
+  ICurrencyManager,
+  NearChains,
+} from '@requestnetwork/currency';
 import ProxyInfoRetriever from './proxy-info-retriever';
 
 import { loadCurrencyFromContract } from './currency';
@@ -71,22 +76,33 @@ export abstract class ERC20FeeProxyPaymentDetectorBase<
   );
 }
 
+export type GetSubGraphClient = (
+  network: CurrencyTypes.ChainName,
+) => TheGraphClient | TheGraphClient<'near'>;
+
 /**
  * Handle payment networks with ERC20 fee proxy contract extension
  */
 export class ERC20FeeProxyPaymentDetector extends ERC20FeeProxyPaymentDetectorBase {
-  private readonly getSubgraphClient: PaymentNetworkOptions['getSubgraphClient'];
+  protected readonly network: CurrencyTypes.VMChainName | undefined;
+  private readonly getSubgraphClient: GetSubGraphClient;
   constructor({
     advancedLogic,
     currencyManager,
     getSubgraphClient,
-  }: ReferenceBasedDetectorOptions & Pick<PaymentNetworkOptions, 'getSubgraphClient'>) {
+    network,
+  }: ReferenceBasedDetectorOptions & {
+    network?: CurrencyTypes.VMChainName;
+    getSubgraphClient: GetSubGraphClient;
+  }) {
     super(
       ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_FEE_PROXY_CONTRACT,
-      advancedLogic.extensions.feeProxyContractErc20,
+      advancedLogic.getFeeProxyContractErc20ForNetwork(network) ??
+        advancedLogic.extensions.feeProxyContractErc20,
       currencyManager,
     );
     this.getSubgraphClient = getSubgraphClient;
+    this.network = network;
   }
 
   /**
@@ -100,7 +116,11 @@ export class ERC20FeeProxyPaymentDetector extends ERC20FeeProxyPaymentDetectorBa
     paymentChain: CurrencyTypes.VMChainName,
     paymentNetwork: ExtensionTypes.IState,
   ): Promise<PaymentTypes.AllNetworkEvents<PaymentTypes.IERC20FeePaymentEventParameters>> {
-    EvmChains.assertChainSupported(paymentChain);
+    if (this.network && paymentChain !== this.network) {
+      throw new NetworkNotSupported(
+        `Unsupported network '${paymentChain}' for payment detector instanciated with '${this.network}'`,
+      );
+    }
     if (!toAddress) {
       return Promise.resolve({
         paymentEvents: [],
@@ -112,10 +132,16 @@ export class ERC20FeeProxyPaymentDetector extends ERC20FeeProxyPaymentDetectorBa
 
     const subgraphClient = this.getSubgraphClient(paymentChain);
     if (subgraphClient) {
-      const graphInfoRetriever = new TheGraphInfoRetriever(
-        subgraphClient as TheGraphClient,
-        this.currencyManager,
-      );
+      const graphInfoRetriever = EvmChains.isChainSupported(paymentChain)
+        ? new TheGraphInfoRetriever(subgraphClient as TheGraphClient, this.currencyManager)
+        : NearChains.isChainSupported(paymentChain) && this.network
+        ? new NearInfoRetriever(subgraphClient as TheGraphClient<'near'>)
+        : undefined;
+      if (!graphInfoRetriever) {
+        throw new Error(
+          `Could not find graphInfoRetriever for chain ${paymentChain} in payment detector`,
+        );
+      }
       return graphInfoRetriever.getTransferEvents({
         eventName,
         paymentReference,
@@ -125,6 +151,7 @@ export class ERC20FeeProxyPaymentDetector extends ERC20FeeProxyPaymentDetectorBa
         acceptedTokens: [requestCurrency.value],
       });
     } else {
+      EvmChains.assertChainSupported(paymentChain);
       const proxyInfoRetriever = new ProxyInfoRetriever(
         paymentReference,
         proxyContractAddress,

packages/payment-detection/src/native-token-detector.ts

@@ -1,4 +1,4 @@
-import { ExtensionTypes, PaymentTypes } from '@requestnetwork/types';
+import { CurrencyTypes, ExtensionTypes, PaymentTypes } from '@requestnetwork/types';
 
 import { ReferenceBasedDetector } from './reference-based-detector';
 import { NativeDetectorOptions } from './types';
@@ -10,7 +10,14 @@ export abstract class NativeTokenPaymentDetector extends ReferenceBasedDetector<
   ExtensionTypes.PnReferenceBased.IReferenceBased,
   PaymentTypes.IETHPaymentEventParameters
 > {
-  protected constructor({ network, advancedLogic, currencyManager }: NativeDetectorOptions) {
+  protected readonly network: CurrencyTypes.NearChainName | undefined;
+  protected readonly getSubgraphClient: NativeDetectorOptions['getSubgraphClient'];
+  protected constructor({
+    network,
+    advancedLogic,
+    currencyManager,
+    getSubgraphClient,
+  }: NativeDetectorOptions) {
     const extensionId = ExtensionTypes.PAYMENT_NETWORK_ID.NATIVE_TOKEN;
     const extension = advancedLogic.getNativeTokenExtensionForNetwork(
       network,
@@ -19,5 +26,7 @@ export abstract class NativeTokenPaymentDetector extends ReferenceBasedDetector<
       throw new Error(`the ${extensionId} extension is not supported for the network ${network}`);
     }
     super(extensionId, extension, currencyManager);
+    this.getSubgraphClient = getSubgraphClient;
+    this.network = network;
   }
 }

packages/payment-detection/src/near/near-detector.ts

@@ -75,14 +75,23 @@ export class NearNativeTokenPaymentDetector extends NativeTokenPaymentDetector {
         paymentEvents: [],
       };
     }
-    const infoRetriever = new NearInfoRetriever(
+    const subgraphClient = this.getSubgraphClient(paymentChain);
+    if (!subgraphClient) {
+      throw new Error(
+        `Could not find graphInfoRetriever for chain ${paymentChain} in payment detector`,
+      );
+    }
+    const infoRetriever = new NearInfoRetriever(subgraphClient);
+    const { paymentEvents } = await infoRetriever.getTransferEvents({
       paymentReference,
-      address,
-      NearNativeTokenPaymentDetector.getContractName(paymentChain, paymentNetwork.version),
+      toAddress: address,
+      contractAddress: NearNativeTokenPaymentDetector.getContractName(
+        paymentChain,
+        paymentNetwork.version,
+      ),
       eventName,
       paymentChain,
-    );
-    const { paymentEvents } = await infoRetriever.getTransferEvents();
+    });
     return {
       paymentEvents,
     };

packages/payment-detection/src/near/retrievers/near-info-retriever.ts

@@ -62,26 +62,18 @@ export class NearInfoRetriever implements ITheGraphBaseInfoRetriever<NearPayment
     payment: GetNearPaymentsQuery['payments'][0],
     params: TransferEventsParams,
   ): PaymentTypes.IPaymentNetworkEvent<NearPaymentEvent> {
-    // const block: number = payment.block;
     return {
       amount: payment.amount,
       name: params.eventName,
+      timestamp: Number(payment.timestamp),
       parameters: {
-        // amount: payment.amount,
-        // timestamp: payment.timestamp,
         feeAmount: payment.feeAmount,
-        // currency: payment.currency,
         receiptId: payment.receiptId,
-        // block: Number(payment.block) as number,
-        // gasUsed: payment.gasUsed,
-        // gasPrice: payment.gasPrice,
-        // amountInCrypto: payment.amountInCrypto,
-        // feeAmountInCrypto: payment.feeAmountInCrypto,
+        block: payment.block,
         to: params.toAddress,
         from: payment.from,
         feeAddress: payment.feeAddress ?? undefined,
         tokenAddress: params.acceptedTokens ? params.acceptedTokens[0] : undefined,
-        // contractAddress: this.proxyContractName,
       },
     };
   }

packages/payment-detection/src/types.ts

@@ -83,7 +83,7 @@ export type ReferenceBasedDetectorOptions = {
 };
 
 export type NativeDetectorOptions = ReferenceBasedDetectorOptions & {
-  network: CurrencyTypes.ChainName;
+  network: CurrencyTypes.NearChainName;
   /** override the default Subgraph for payment detection (EVM, Near) */
   getSubgraphClient: (network: CurrencyTypes.ChainName) => TheGraphClient<'near'> | undefined;
 };

packages/payment-detection/test/erc20/fee-proxy-contract.test.ts

@@ -6,11 +6,7 @@ import {
   RequestLogicTypes,
 } from '@requestnetwork/types';
 import { CurrencyManager } from '@requestnetwork/currency';
-import { AdvancedLogic } from '@requestnetwork/advanced-logic';
-import {
-  ERC20FeeProxyPaymentDetector,
-  ERC20NearFeeProxyPaymentDetector,
-} from '../../src/erc20/fee-proxy-contract';
+import { ERC20FeeProxyPaymentDetector } from '../../src/erc20/fee-proxy-contract';
 import { mockAdvancedLogicBase } from '../utils';
 
 let erc20FeeProxyContract: ERC20FeeProxyPaymentDetector;
@@ -22,24 +18,25 @@ const createAddFeeAction = jest.fn();
 const createAddPaymentInstructionAction = jest.fn();
 const createAddRefundInstructionAction = jest.fn();
 
+const feeProxyContractErc20 = {
+  createAddPaymentAddressAction,
+  createAddRefundAddressAction,
+  createCreationAction,
+  createAddFeeAction,
+  // inherited from declarative
+  createAddPaymentInstructionAction,
+  createAddRefundInstructionAction,
+} as any as ExtensionTypes.PnFeeReferenceBased.IFeeReferenceBased;
+
 const mockAdvancedLogic: AdvancedLogicTypes.IAdvancedLogic = {
   ...mockAdvancedLogicBase,
   extensions: {
-    feeProxyContractErc20: {
-      createAddPaymentAddressAction,
-      createAddRefundAddressAction,
-      createCreationAction,
-      createAddFeeAction,
-      // inherited from declarative
-      createAddPaymentInstructionAction,
-      createAddRefundInstructionAction,
-    },
+    feeProxyContractErc20,
   } as any as AdvancedLogicTypes.IAdvancedLogicExtensions,
+  getFeeProxyContractErc20ForNetwork: (_network) => feeProxyContractErc20,
 };
 
 const currencyManager = CurrencyManager.getDefault();
-const advancedLogic = new AdvancedLogic(currencyManager);
-
 /* eslint-disable @typescript-eslint/no-unused-expressions */
 describe('api/erc20/fee-proxy-contract', () => {
   beforeEach(() => {
@@ -551,12 +548,47 @@ describe('api/erc20/fee-proxy-contract', () => {
   });
 
   describe('on Near', () => {
+    beforeEach(() => {
+      // Same Detector, but instanciated with a Near network and a mocked Near graph client
+      erc20FeeProxyContract = new ERC20FeeProxyPaymentDetector({
+        advancedLogic: mockAdvancedLogic,
+        currencyManager,
+        network: 'aurora-testnet',
+        getSubgraphClient: (_network) => ({
+          GetFungibleTokenPayments: jest.fn().mockImplementation(() => ({
+            payments: [
+              {
+                contractAddress: 'pay.reqnetwork.testnet',
+                tokenAddress: 'fau.reqnetwork.testnet',
+                to: 'issuer.reqnetwork.testnet',
+                from: 'payer.reqnetwork.testnet',
+                amount: '168040800000000000000000',
+                feeAmount: '13386000000000000000',
+                reference: 'f59c9445040531b1',
+                block: 15767215,
+                gasUsed: '73152',
+                gasPrice: '12709127644',
+                timestamp: 1666002347,
+                amountInCrypto: null,
+                feeAddress: 'builder.reqnetwork.testnet',
+                feeAmountInCrypto: null,
+                maxRateTimespan: null,
+              },
+            ],
+          })),
+          GetPaymentsAndEscrowState: jest.fn(),
+          GetNearConversionPayments: jest.fn(),
+          GetNearPayments: jest.fn(),
+          GetLastSyncedBlock: jest.fn(),
+          GetSyncedBlock: jest.fn(),
+        }),
+      });
+    });
     it('can createExtensionsDataForCreation', async () => {
       await erc20FeeProxyContract.createExtensionsDataForCreation({
         paymentAddress: 'issuer.reqnetwork.testnet',
         salt: 'ea3bc7caf64110ca',
       });
-
       expect(createCreationAction).toHaveBeenCalledWith({
         feeAddress: undefined,
         feeAmount: undefined,
@@ -567,7 +599,6 @@ describe('api/erc20/fee-proxy-contract', () => {
     });
 
     it('can retrieve payment using thegraph info retriever', async () => {
-      // graphql.request.mockResolvedValue();
       const mockRequest: RequestLogicTypes.IRequest = {
         creator: { type: IdentityTypes.TYPE.ETHEREUM_ADDRESS, value: '0x2' },
         currency: {
@@ -608,40 +639,8 @@ describe('api/erc20/fee-proxy-contract', () => {
         timestamp: 0,
         version: '0.2',
       };
-      const nearErc20FeeProxyContract = new ERC20NearFeeProxyPaymentDetector({
-        advancedLogic,
-        currencyManager,
-        network: 'aurora-testnet',
-        getSubgraphClient: () => ({
-          GetFungibleTokenPayments: jest.fn().mockImplementation(() => ({
-            payments: [
-              {
-                contractAddress: 'pay.reqnetwork.testnet',
-                tokenAddress: 'fau.reqnetwork.testnet',
-                to: 'issuer.reqnetwork.testnet',
-                from: 'payer.reqnetwork.testnet',
-                amount: '168040800000000000000000',
-                feeAmount: '13386000000000000000',
-                reference: 'f59c9445040531b1',
-                block: 15767215,
-                gasUsed: '73152',
-                gasPrice: '12709127644',
-                timestamp: 1666002347,
-                amountInCrypto: null,
-                feeAddress: 'builder.reqnetwork.testnet',
-                feeAmountInCrypto: null,
-                maxRateTimespan: null,
-              },
-            ],
-          })),
-          GetNearConversionPayments: jest.fn(),
-          GetNearPayments: jest.fn(),
-          GetLastSyncedBlock: jest.fn(),
-          GetSyncedBlock: jest.fn(),
-        }),
-      });
 
-      const { balance, error, events } = await nearErc20FeeProxyContract.getBalance(mockRequest);
+      const { balance, error, events } = await erc20FeeProxyContract.getBalance(mockRequest);
       expect;
       expect(error).toBeUndefined();
       expect(balance).toBe('168040800000000000000000');