test SafeERC20 relaxed functions

test/token/ERC20/utils/SafeERC20.test.js

@@ -5,14 +5,15 @@ const ERC20ReturnFalseMock = artifacts.require('$ERC20ReturnFalseMock');
 const ERC20ReturnTrueMock = artifacts.require('$ERC20'); // default implementation returns true
 const ERC20NoReturnMock = artifacts.require('$ERC20NoReturnMock');
 const ERC20ForceApproveMock = artifacts.require('$ERC20ForceApproveMock');
+const ERC1363 = artifacts.require('$ERC1363');
 
 const { expectRevertCustomError } = require('../../../helpers/customError');
 
 const name = 'ERC20Mock';
 const symbol = 'ERC20Mock';
 
 contract('SafeERC20', function (accounts) {
-  const [hasNoCode, receiver, spender] = accounts;
+  const [hasNoCode, owner, receiver, spender, other] = accounts;
 
   before(async function () {
     this.mock = await SafeERC20.new();
@@ -144,6 +145,83 @@ contract('SafeERC20', function (accounts) {
       });
     });
   });
+
+  describe('with ERC1363', function () {
+    const value = web3.utils.toBN(100);
+
+    beforeEach(async function () {
+      this.token = await ERC1363.new(name, symbol);
+    });
+
+    shouldOnlyRevertOnErrors(accounts);
+
+    describe('transferAndCall', function () {
+      it('cannot transferAndCall to an EOA directly', async function () {
+        await this.token.$_mint(owner, 100);
+
+        await expectRevertCustomError(
+          this.token.methods['transferAndCall(address,uint256,bytes)'](receiver, value, '0x', { from: owner }),
+          'ERC1363InvalidReceiver',
+          [receiver],
+        );
+      });
+
+      it('can transferAndCall to an EOA using helper', async function () {
+        await this.token.$_mint(this.mock.address, value);
+
+        const { tx } = await this.mock.$transferAndCallRelaxed(this.token.address, receiver, value, '0x');
+        await expectEvent.inTransaction(tx, this.token, 'Transfer', {
+          from: this.mock.address,
+          to: receiver,
+          value,
+        });
+      });
+    });
+
+    describe('transferFromAndCall', function () {
+      it('cannot transferFromAndCall to an EOA directly', async function () {
+        await this.token.$_mint(owner, value);
+        await this.token.approve(other, constants.MAX_UINT256, { from: owner });
+
+        await expectRevertCustomError(
+          this.token.methods['transferFromAndCall(address,address,uint256,bytes)'](owner, receiver, value, '0x', { from: other }),
+          'ERC1363InvalidReceiver',
+          [receiver],
+        );
+      });
+
+      it('can transferFromAndCall to an EOA using helper', async function () {
+        await this.token.$_mint(owner, value);
+        await this.token.approve(this.mock.address, constants.MAX_UINT256, { from: owner });
+
+        const { tx } = await this.mock.$transferFromAndCallRelaxed(this.token.address, owner, receiver, value, '0x');
+        await expectEvent.inTransaction(tx, this.token, 'Transfer', {
+          from: owner,
+          to: receiver,
+          value,
+        });
+      });
+    });
+
+    describe('approveAndCall', function () {
+      it('cannot approveAndCall to an EOA directly', async function () {
+        await expectRevertCustomError(
+          this.token.methods['approveAndCall(address,uint256,bytes)'](receiver, value, '0x'),
+          'ERC1363InvalidSpender',
+          [receiver],
+        );
+      });
+
+      it('can approveAndCall to an EOA using helper', async function () {
+        const { tx } = await this.mock.$approveAndCallRelaxed(this.token.address, receiver, value, '0x');
+        await expectEvent.inTransaction(tx, this.token, 'Approval', {
+          owner: this.mock.address,
+          spender: receiver,
+          value,
+        });
+      });
+    });
+  });
 });
 
 function shouldOnlyRevertOnErrors([owner, receiver, spender]) {