feat: ERC20FeeProxy on Near testnet (#1086)

Author: yomarion

packages/advanced-logic/specs/payment-network-erc20-fee-proxy-contract-0.1.0.md

@@ -2,14 +2,18 @@
 
 ## Description
 
-This extension allows payments and refunds to be made in ERC20 tokens on Ethereum and EVM-compatible blockchains.
+This extension allows payments and refunds to be made in fungible tokens, including:
+
+- ERC20 tokens on Ethereum and EVM-compatible blockchains.
+- Fungible tokens on Near and Near testnet (as defined by NEP-141 and NEP-148)
+
 This Payment Network is similar to the [ERC20 Proxy Contract](./payment-network-erc20-proxy-contract-0.1.0.md) extension, with the added feature of allowing a fee to be taken from the payment.
 
 The payment is mainly expected through a proxy payment contract, but the request issuer can also declare payments manually. Fees shall not be paid for declarative payments.
 
-The proxy contract does the ERC20 token transfer on behalf of the user. The contract ensures a link between an ERC20 transfer and a request through a `paymentReference`. This `paymentReference` consists of the last 8 bytes of a salted hash of the requestId: `last8Bytes(hash(lowercase(requestId + salt + address)))`:
+The proxy contract does the fungible token transfer on behalf of the user. The contract ensures a link between a token transfer and a request through a `paymentReference`. This `paymentReference` consists of the last 8 bytes of a salted hash of the requestId: `last8Bytes(hash(lowercase(requestId + salt + address)))`:
 
-The contract also ensures that the `feeAmount` amount of the ERC20 transfer will be forwarded to the `feeAddress`.
+The contract also ensures that the `feeAmount` amount of the token transfer will be forwarded to the `feeAddress`.
 
 - `requestId` is the id of the request
 - `salt` is a random number with at least 8 bytes of randomness. It must be unique to each request
@@ -24,7 +28,7 @@ As a payment network, this extension allows to deduce a payment `balance` for th
 
 ## Payment Proxy Contract
 
-The contract contains one function called `transferFromWithReferenceAndFee` which takes 6 arguments:
+On EVMs, the contract contains one function called `transferFromWithReferenceAndFee` which takes 6 arguments:
 
 - `tokenAddress` is the address of the ERC20 contract
 - `to` is the destination address for the tokens
@@ -33,9 +37,14 @@ The contract contains one function called `transferFromWithReferenceAndFee` whic
 - `feeAmount` is the amount of tokens to transfer to the fee destination address
 - `feeAddress` is the destination address for the fee
 
-The `TransferWithReferenceAndFee` event is emitted when the tokens are transfered. This event contains the same 6 arguments as the `transferFromWithReferenceAndFee` function.
+On Near, users send fungible tokens to the contract with the `ft_transfer_call` method, if the `msg` value given is a valid JSON object with 4 of the 6 arguments listed above: `to`, `paymentReference`, `feeAmount` and `feeAddress`. The `tokenAdress` is taken from the calling fungible token contract. The `amount` is equal to the transfer (total) `amount` less `feeAmount`.
+
+On EVM-compatible chains, the `TransferWithReferenceAndFee` event is emitted when the tokens are transfered. This event contains the same 6 arguments as the `transferFromWithReferenceAndFee` function.
 
-[See smart contract source](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol)
+On Near and Near testnet, a JSON message is logged by the method `on_transfer_with_reference`, containing the same 6 arguments.
+
+[See EVM smart contract source](https://github.com/RequestNetwork/requestNetwork/blob/master/packages/smart-contracts/src/contracts/ERC20FeeProxy.sol)
+[See Near smart contract source](https://github.com/RequestNetwork/near-contracts)
 
 | Network                    | Contract Address                           |
 | -------------------------- | ------------------------------------------ |
@@ -45,6 +54,9 @@ The `TransferWithReferenceAndFee` event is emitted when the tokens are transfere
 | Ethereum Testnet - Rinkeby | 0xda46309973bffddd5a10ce12c44d2ee266f45a44 |
 | Matic Testnet - Mumbai     | 0x131eb294E3803F23dc2882AB795631A12D1d8929 |
 | Private                    | 0x75c35C980C0d37ef46DF04d31A140b65503c0eEd |
+| Near Testnet               | pay.reqnetwork.testnet                     |
+
+The updated list of deployment address can be found [in the smart-contracts package](../../smart-contracts/src/lib/artifacts/ERC20FeeProxy/index.ts);
 
 ## Manual payment declaration
 

packages/advanced-logic/src/advanced-logic.ts

@@ -5,7 +5,12 @@ import {
   IdentityTypes,
   RequestLogicTypes,
 } from '@requestnetwork/types';
-import { CurrencyManager, ICurrencyManager } from '@requestnetwork/currency';
+import {
+  CurrencyManager,
+  ICurrencyManager,
+  NearChains,
+  isSameChain,
+} from '@requestnetwork/currency';
 
 import ContentData from './extensions/content-data';
 import AddressBasedBtc from './extensions/payment-network/bitcoin/mainnet-address-based';
@@ -106,8 +111,9 @@ export default class AdvancedLogic implements AdvancedLogicTypes.IAdvancedLogic
   protected getExtensionForActionAndState(
     extensionAction: ExtensionTypes.IAction,
     requestState: RequestLogicTypes.IRequest,
-  ): ExtensionTypes.IExtension<any> {
+  ): ExtensionTypes.IExtension {
     const id: ExtensionTypes.ID = extensionAction.id;
+    const network = this.getNetwork(extensionAction, requestState) || requestState.currency.network;
     const extension: ExtensionTypes.IExtension | undefined = {
       [ExtensionTypes.ID.CONTENT_DATA]: this.extensions.contentData,
       [ExtensionTypes.PAYMENT_NETWORK_ID.BITCOIN_ADDRESS_BASED]: this.extensions.addressBasedBtc,
@@ -117,17 +123,17 @@ export default class AdvancedLogic implements AdvancedLogicTypes.IAdvancedLogic
       [ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_ADDRESS_BASED]: this.extensions.addressBasedErc20,
       [ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_PROXY_CONTRACT]: this.extensions.proxyContractErc20,
       [ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_FEE_PROXY_CONTRACT]:
-        this.extensions.feeProxyContractErc20,
+        this.getFeeProxyContractErc20ForNetwork(network),
       [ExtensionTypes.PAYMENT_NETWORK_ID.ERC777_STREAM]: this.extensions.erc777Stream,
       [ExtensionTypes.PAYMENT_NETWORK_ID.ETH_INPUT_DATA]: this.extensions.ethereumInputData,
       [ExtensionTypes.PAYMENT_NETWORK_ID.NATIVE_TOKEN]:
-        this.getNativeTokenExtensionForActionAndState(extensionAction, requestState),
+        this.getNativeTokenExtensionForNetwork(network),
       [ExtensionTypes.PAYMENT_NETWORK_ID.ANY_TO_ERC20_PROXY]: this.extensions.anyToErc20Proxy,
       [ExtensionTypes.PAYMENT_NETWORK_ID.ETH_FEE_PROXY_CONTRACT]:
         this.extensions.feeProxyContractEth,
       [ExtensionTypes.PAYMENT_NETWORK_ID.ANY_TO_ETH_PROXY]: this.extensions.anyToEthProxy,
       [ExtensionTypes.PAYMENT_NETWORK_ID.ANY_TO_NATIVE_TOKEN]:
-        this.getAnyToNativeTokenExtensionForActionAndState(extensionAction, requestState),
+        this.getAnyToNativeTokenExtensionForNetwork(network),
       [ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_TRANSFERABLE_RECEIVABLE]:
         this.extensions.erc20TransferableReceivable,
     }[id];
@@ -137,8 +143,6 @@ export default class AdvancedLogic implements AdvancedLogicTypes.IAdvancedLogic
         id === ExtensionTypes.PAYMENT_NETWORK_ID.NATIVE_TOKEN ||
         id === ExtensionTypes.PAYMENT_NETWORK_ID.ANY_TO_NATIVE_TOKEN
       ) {
-        const network =
-          this.getNetwork(extensionAction, requestState) || requestState.currency.network;
         throw Error(`extension with id: ${id} not found for network: ${network}`);
       }
 
@@ -148,50 +152,44 @@ export default class AdvancedLogic implements AdvancedLogicTypes.IAdvancedLogic
   }
 
   public getNativeTokenExtensionForNetwork(
-    network: CurrencyTypes.ChainName,
+    network?: CurrencyTypes.ChainName,
   ): ExtensionTypes.IExtension<ExtensionTypes.PnReferenceBased.ICreationParameters> | undefined {
-    return this.extensions.nativeToken.find((nativeTokenExtension) =>
-      nativeTokenExtension.supportedNetworks.includes(network),
-    );
+    return network
+      ? this.extensions.nativeToken.find((nativeTokenExtension) =>
+          nativeTokenExtension.supportedNetworks.includes(network),
+        )
+      : undefined;
+  }
+
+  public getAnyToNativeTokenExtensionForNetwork(
+    network?: CurrencyTypes.ChainName,
+  ): AnyToNative | undefined {
+    return network
+      ? this.extensions.anyToNativeToken.find((anyToNativeTokenExtension) =>
+          anyToNativeTokenExtension.supportedNetworks.includes(network),
+        )
+      : undefined;
+  }
+
+  public getFeeProxyContractErc20ForNetwork(network?: string): FeeProxyContractErc20 {
+    return NearChains.isChainSupported(network)
+      ? new FeeProxyContractErc20(undefined, undefined, network)
+      : this.extensions.feeProxyContractErc20;
   }
 
-  protected getNativeTokenExtensionForActionAndState(
+  protected getNetwork(
     extensionAction: ExtensionTypes.IAction,
     requestState: RequestLogicTypes.IRequest,
-  ): ExtensionTypes.IExtension<ExtensionTypes.PnReferenceBased.ICreationParameters> | undefined {
+  ): CurrencyTypes.ChainName | undefined {
     if (
       requestState.currency.network &&
       extensionAction.parameters.paymentNetworkName &&
-      requestState.currency.network !== extensionAction.parameters.paymentNetworkName
+      !isSameChain(requestState.currency.network, extensionAction.parameters.paymentNetworkName)
     ) {
       throw new Error(
         `Cannot apply action for network ${extensionAction.parameters.paymentNetworkName} on state with payment network: ${requestState.currency.network}`,
       );
     }
-    const network = requestState.currency.network ?? extensionAction.parameters.paymentNetworkName;
-    return network ? this.getNativeTokenExtensionForNetwork(network) : undefined;
-  }
-
-  public getAnyToNativeTokenExtensionForNetwork(
-    network: CurrencyTypes.ChainName,
-  ): ExtensionTypes.IExtension<ExtensionTypes.PnAnyToEth.ICreationParameters> | undefined {
-    return this.extensions.anyToNativeToken.find((anyToNativeTokenExtension) =>
-      anyToNativeTokenExtension.supportedNetworks.includes(network),
-    );
-  }
-
-  protected getAnyToNativeTokenExtensionForActionAndState(
-    extensionAction: ExtensionTypes.IAction,
-    requestState: RequestLogicTypes.IRequest,
-  ): ExtensionTypes.IExtension<ExtensionTypes.PnAnyToEth.ICreationParameters> | undefined {
-    const network = this.getNetwork(extensionAction, requestState);
-    return network ? this.getAnyToNativeTokenExtensionForNetwork(network) : undefined;
-  }
-
-  protected getNetwork(
-    extensionAction: ExtensionTypes.IAction,
-    requestState: RequestLogicTypes.IRequest,
-  ): CurrencyTypes.ChainName | undefined {
     const network =
       extensionAction.action === 'create'
         ? extensionAction.parameters.network

packages/advanced-logic/src/extensions/payment-network/erc20/fee-proxy-contract.ts

@@ -1,19 +1,62 @@
-import { ExtensionTypes, RequestLogicTypes } from '@requestnetwork/types';
+import { CurrencyTypes, ExtensionTypes, RequestLogicTypes } from '@requestnetwork/types';
+import { NearChains, isSameChain } from '@requestnetwork/currency';
+import { UnsupportedNetworkError } from '../address-based';
 import { FeeReferenceBasedPaymentNetwork } from '../fee-reference-based';
 
-const CURRENT_VERSION = '0.2.0';
+const EVM_CURRENT_VERSION = '0.2.0';
+const NEAR_CURRENT_VERSION = 'NEAR-0.1.0';
 
 /**
  * Implementation of the payment network to pay in ERC20, including third-party fees payment, based on a reference provided to a proxy contract.
  */
 export default class Erc20FeeProxyPaymentNetwork<
   TCreationParameters extends ExtensionTypes.PnFeeReferenceBased.ICreationParameters = ExtensionTypes.PnFeeReferenceBased.ICreationParameters,
 > extends FeeReferenceBasedPaymentNetwork<TCreationParameters> {
+  /**
+   * @param network is only relevant for non-EVM chains (Near and Near testnet)
+   */
   public constructor(
     extensionId: ExtensionTypes.PAYMENT_NETWORK_ID = ExtensionTypes.PAYMENT_NETWORK_ID
       .ERC20_FEE_PROXY_CONTRACT,
-    currentVersion: string = CURRENT_VERSION,
+    currentVersion?: string | undefined,
+    protected network?: string | undefined,
   ) {
-    super(extensionId, currentVersion, RequestLogicTypes.CURRENCY.ERC20);
+    super(
+      extensionId,
+      currentVersion ?? Erc20FeeProxyPaymentNetwork.getDefaultCurrencyVersion(network),
+      RequestLogicTypes.CURRENCY.ERC20,
+    );
+  }
+
+  protected static getDefaultCurrencyVersion(network?: string): string {
+    return NearChains.isChainSupported(network) ? NEAR_CURRENT_VERSION : EVM_CURRENT_VERSION;
+  }
+
+  // Override `validate` to account for network-specific instanciation (non-EVM only)
+  protected validate(
+    request: RequestLogicTypes.IRequest,
+    extensionAction: ExtensionTypes.IAction,
+  ): void {
+    if (
+      this.network &&
+      request.currency.network &&
+      !isSameChain(this.network, request.currency.network)
+    ) {
+      throw new UnsupportedNetworkError(request.currency.network, [this.network]);
+    }
+    super.validate(request, extensionAction);
+  }
+
+  // Override `isValidAddress` to account for network-specific instanciation (non-EVM only)
+  protected isValidAddress(address: string): boolean {
+    if (NearChains.isChainSupported(this.network)) {
+      if (NearChains.isTestnet(this.network as CurrencyTypes.NearChainName)) {
+        return this.isValidAddressForSymbolAndNetwork(address, 'NEAR-testnet', 'near-testnet');
+      } else {
+        return this.isValidAddressForSymbolAndNetwork(address, 'NEAR', 'near');
+      }
+    } else {
+      return super.isValidAddress(address);
+    }
   }
 }

packages/advanced-logic/test/extensions/payment-network/erc20/fee-proxy-contract.test.ts

@@ -1,13 +1,14 @@
 import { ExtensionTypes, RequestLogicTypes } from '@requestnetwork/types';
 
-import Erc20FeeProxyContract from '../../../../src/extensions/payment-network/erc20/fee-proxy-contract';
-
 import * as DataERC20FeeAddData from '../../../utils/payment-network/erc20/fee-proxy-contract-add-data-generator';
 import * as DataERC20FeeCreate from '../../../utils/payment-network/erc20/fee-proxy-contract-create-data-generator';
+import * as DataNearERC20FeeCreate from '../../../utils/payment-network/erc20/near-fee-proxy-contract';
 import * as TestData from '../../../utils/test-data-generator';
 import { deepCopy } from '@requestnetwork/utils';
+import { AdvancedLogic } from '../../../../src';
 
-const erc20FeeProxyContract = new Erc20FeeProxyContract();
+const advancedLogic = new AdvancedLogic();
+const erc20FeeProxyContract = advancedLogic.getFeeProxyContractErc20ForNetwork();
 
 /* eslint-disable @typescript-eslint/no-unused-expressions */
 describe('extensions/payment-network/erc20/fee-proxy-contract', () => {
@@ -69,7 +70,7 @@ describe('extensions/payment-network/erc20/fee-proxy-contract', () => {
       });
     });
 
-    it('cannot createCreationAction with payment address not an ethereum address', () => {
+    it('cannot createCreationAction with an invalid payment address', () => {
       // 'must throw'
       expect(() => {
         erc20FeeProxyContract.createCreationAction({
@@ -112,6 +113,44 @@ describe('extensions/payment-network/erc20/fee-proxy-contract', () => {
         });
       }).toThrowError('feeAmount is not a valid amount');
     });
+
+    describe('on Near testnet', () => {
+      const extension = advancedLogic.getFeeProxyContractErc20ForNetwork('near-testnet');
+      it('can create a create action with all parameters', () => {
+        expect(
+          extension.createCreationAction({
+            feeAddress: 'buidler.reqnetwork.testnet',
+            feeAmount: '0',
+            paymentAddress: 'issuer.reqnetwork.testnet',
+            refundAddress: 'payer.reqnetwork.testnet',
+            salt: 'ea3bc7caf64110ca',
+          }),
+        ).toEqual({
+          action: 'create',
+          id: ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_FEE_PROXY_CONTRACT,
+          parameters: {
+            feeAddress: 'buidler.reqnetwork.testnet',
+            feeAmount: '0',
+            paymentAddress: 'issuer.reqnetwork.testnet',
+            refundAddress: 'payer.reqnetwork.testnet',
+            salt: 'ea3bc7caf64110ca',
+          },
+          version: 'NEAR-0.1.0',
+        });
+      });
+
+      it('cannot createCreationAction with an invalid payment address', () => {
+        expect(() => {
+          extension.createCreationAction({
+            paymentAddress: '0x0000000000000000000000000000000000000002',
+            refundAddress: 'payer.reqnetwork.testnet',
+            salt: 'ea3bc7caf64110ca',
+          });
+        }).toThrowError(
+          "paymentAddress '0x0000000000000000000000000000000000000002' is not a valid address",
+        );
+      });
+    });
   });
 
   describe('createAddPaymentAddressAction', () => {
@@ -338,6 +377,36 @@ describe('extensions/payment-network/erc20/fee-proxy-contract', () => {
           );
         }).toThrowError('version is required at creation');
       });
+
+      describe('on Near testnet', () => {
+        const extension = advancedLogic.getFeeProxyContractErc20ForNetwork('near-testnet');
+        it('can applyActionToExtensions of creation', () => {
+          expect(
+            extension.applyActionToExtension(
+              DataNearERC20FeeCreate.requestStateNoExtensions.extensions,
+              DataNearERC20FeeCreate.actionCreationFull,
+              DataNearERC20FeeCreate.requestStateNoExtensions,
+              TestData.otherIdRaw.identity,
+              TestData.arbitraryTimestamp,
+            ),
+          ).toEqual(DataNearERC20FeeCreate.extensionFullState);
+        });
+        it('cannot applyActionToExtensions of creation', () => {
+          // 'new extension state wrong'
+          expect(() =>
+            extension.applyActionToExtension(
+              // State with currency on the wrong network
+              DataERC20FeeCreate.requestStateNoExtensions.extensions,
+              DataNearERC20FeeCreate.actionCreationFull,
+              DataERC20FeeCreate.requestStateNoExtensions,
+              TestData.otherIdRaw.identity,
+              TestData.arbitraryTimestamp,
+            ),
+          ).toThrowError(
+            "Payment network 'mainnet' is not supported by this extension (only near-testnet)",
+          );
+        });
+      });
     });
 
     describe('applyActionToExtension/addPaymentAddress', () => {