feat(erc777): <- add custom function call when minting

contracts/interfaces/IPReceiver.sol

@@ -0,0 +1,16 @@
+pragma solidity ^0.6.2;
+
+/**
+ * @title IPReceiver
+ * @author pNetwork
+ *
+ * @dev Interface for contracts excpecting cross-chain data
+ */
+interface IPReceiver {
+    /*
+     * @dev Function called when userData.length > 0 when minting the pToken
+     *
+     * @param userData
+     */
+    function receiveUserData(bytes calldata userData) external;
+}

contracts/pToken.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.6.2;
 
+import {IPReceiver} from "./interfaces/IPReceiver.sol";
 import "./ERC777GSN.sol";
 import "./ERC777WithAdminOperatorUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
@@ -14,6 +15,8 @@ contract PToken is
     bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
     bytes4 public ORIGIN_CHAIN_ID;
 
+    event ReceiveUserDataFailed();
+
     event Redeem(
         address indexed redeemer,
         uint256 value,
@@ -76,6 +79,17 @@ contract PToken is
             "Recipient cannot be the token contract address!"
         );
         _mint(recipient, value, userData, operatorData);
+        if (userData.length > 0) {
+            // pNetwork aims to deliver cross chain messages successfully regardless of what the user may do with them.
+            // We do not want this mint transaction reverting if their receiveUserData function reverts,
+            // and thus we swallow any such errors, emitting a `ReceiveUserDataFailed` event instead.
+            // The low-level call is used because in the solidity version this contract was written in,
+            // a try/catch block fails to catch the revert caused if the receiver is not in fact a contract.
+            // This way, a user also has the option include userData even when minting to an externally owned account.
+            bytes memory data = abi.encodeWithSelector(IPReceiver.receiveUserData.selector, userData);
+            (bool success, ) = recipient.call(data);
+            if (!success) emit ReceiveUserDataFailed();
+        }
         return true;
     }
 

contracts/pTokenNoGSN.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.6.2;
 
+import {IPReceiver} from "./interfaces/IPReceiver.sol";
 import "./ERC777WithAdminOperatorUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
 import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
@@ -18,6 +19,8 @@ contract PTokenNoGSN is
     bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
     bytes4 public ORIGIN_CHAIN_ID;
 
+    event ReceiveUserDataFailed();
+
     event Redeem(
         address indexed redeemer,
         uint256 value,
@@ -79,6 +82,17 @@ contract PTokenNoGSN is
             "Recipient cannot be the token contract address!"
         );
         _mint(recipient, value, userData, operatorData);
+        if (userData.length > 0) {
+            // pNetwork aims to deliver cross chain messages successfully regardless of what the user may do with them.
+            // We do not want this mint transaction reverting if their receiveUserData function reverts,
+            // and thus we swallow any such errors, emitting a `ReceiveUserDataFailed` event instead.
+            // The low-level call is used because in the solidity version this contract was written in,
+            // a try/catch block fails to catch the revert caused if the receiver is not in fact a contract.
+            // This way, a user also has the option include userData even when minting to an externally owned account.
+            bytes memory data = abi.encodeWithSelector(IPReceiver.receiveUserData.selector, userData);
+            (bool success, ) = recipient.call(data);
+            if (!success) emit ReceiveUserDataFailed();
+        }
         return true;
     }
 

contracts/test-contracts/PReceiver.sol

@@ -0,0 +1,20 @@
+pragma solidity ^0.6.2;
+
+import {IPReceiver} from "../interfaces/IPReceiver.sol";
+
+contract PReceiver is IPReceiver {
+    event UserData(bytes data);
+
+    function receiveUserData(bytes calldata userData) external override {
+        emit UserData(userData);
+    }
+}
+
+contract PReceiverReverting is IPReceiver {
+    function receiveUserData(bytes calldata) external override {
+        require(false, "Revert!");
+    }
+}
+
+contract NotImplementingReceiveUserDataFxn {
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ptokens-erc777-smart-contract",
-  "version": "3.11.1",
+  "version": "3.12.0",
   "description": "The pToken ERC777 smart-contract & CLI",
   "main": "cli.js",
   "scripts": {

test/05-ptoken.test.js

@@ -145,13 +145,14 @@ USE_GSN.map(_useGSN =>
         }
       })
 
-      it('`mint()` w/ data should mint tokens & emit correct events', async () => {
+      it('`mint()` w/ data should mint tokens to a non-contract address & emit correct events', async () => {
         const data = '0xdead'
         const expectedNumEvents = 2
         const operatorData = '0xb33f'
         const recipient = OTHERS[0].address
         const recipientBalanceBefore = await getTokenBalance(recipient, CONTRACT)
-        const tx = await CONTRACT['mint(address,uint256,bytes,bytes)'](recipient, AMOUNT, data, operatorData)
+        const tx =
+          await CONTRACT['mint(address,uint256,bytes,bytes)'](recipient, AMOUNT, data, operatorData)
         const { events } = await tx.wait()
         const recipientBalanceAfter = await getTokenBalance(recipient, CONTRACT)
         assert(recipientBalanceBefore.eq(BigNumber.from(0)))
@@ -161,6 +162,75 @@ USE_GSN.map(_useGSN =>
         assertMintEvent(events, recipient, OWNER.address, AMOUNT, data, operatorData)
       })
 
+      it('`mint()` w/ data should mint & call receiveUserData & emit correct events', async () => {
+        const data = '0xdead'
+        const expectedNumEvents = 3
+        const operatorData = '0xb33f'
+        const recipientContract = await ethers
+          .getContractFactory('contracts/test-contracts/PReceiver.sol:PReceiver')
+          .then(_factory => upgrades.deployProxy(_factory))
+
+        const recipientBalanceBefore = await getTokenBalance(recipientContract.address, CONTRACT)
+        const tx =
+          await CONTRACT['mint(address,uint256,bytes,bytes)'](recipientContract.address, AMOUNT, data, operatorData)
+        const { events } = await tx.wait()
+        const recipientBalanceAfter = await getTokenBalance(recipientContract.address, CONTRACT)
+        assert(recipientBalanceBefore.eq(BigNumber.from(0)))
+        assert(recipientBalanceAfter.eq(BigNumber.from(AMOUNT)))
+        assert.strictEqual(events.length, expectedNumEvents)
+        assertTransferEvent(events, ZERO_ADDRESS, recipientContract.address, AMOUNT)
+        assertMintEvent(events, recipientContract.address, OWNER.address, AMOUNT, data, operatorData)
+        const userDataEvent = recipientContract.interface.parseLog(events.at(-1))
+        assert.strictEqual(userDataEvent.name, 'UserData')
+        assert.strictEqual(userDataEvent.args.data, data)
+      })
+
+      // eslint-disable-next-line max-len
+      it('`mint()` w/ `userData` should mint tokens, emit correct events & not revert despite `receiveUserData` hook being not implemented',
+        async () => {
+          const data = '0xdead'
+          const expectedNumEvents = 3
+          const operatorData = '0xb33f'
+          const recipientContract = await ethers
+            .getContractFactory('contracts/test-contracts/PReceiver.sol:NotImplementingReceiveUserDataFxn')
+            .then(_factory => upgrades.deployProxy(_factory))
+
+          const recipientBalanceBefore = await getTokenBalance(recipientContract.address, CONTRACT)
+          const tx =
+            await CONTRACT['mint(address,uint256,bytes,bytes)'](recipientContract.address, AMOUNT, data, operatorData)
+          const { events } = await tx.wait()
+          const recipientBalanceAfter = await getTokenBalance(recipientContract.address, CONTRACT)
+          assert(recipientBalanceBefore.eq(BigNumber.from(0)))
+          assert(recipientBalanceAfter.eq(BigNumber.from(AMOUNT)))
+          assert.strictEqual(events.length, expectedNumEvents)
+          assertTransferEvent(events, ZERO_ADDRESS, recipientContract.address, AMOUNT)
+          assertMintEvent(events, recipientContract.address, OWNER.address, AMOUNT, data, operatorData)
+          assert.strictEqual(events.at(-1).event, 'ReceiveUserDataFailed')
+        })
+
+      // eslint-disable-next-line max-len
+      it('`mint()` w/ `userData` should mint tokens, emit correct events & not revert despite `receiveUserData` hook reverting',
+        async () => {
+          const data = '0xdead'
+          const expectedNumEvents = 3
+          const operatorData = '0xb33f'
+          const recipientContract = await ethers
+            .getContractFactory('contracts/test-contracts/PReceiver.sol:PReceiverReverting')
+            .then(_factory => upgrades.deployProxy(_factory))
+
+          const recipientBalanceBefore = await getTokenBalance(recipientContract.address, CONTRACT)
+          const tx =
+            await CONTRACT['mint(address,uint256,bytes,bytes)'](recipientContract.address, AMOUNT, data, operatorData)
+          const { events } = await tx.wait()
+          const recipientBalanceAfter = await getTokenBalance(recipientContract.address, CONTRACT)
+          assert(recipientBalanceBefore.eq(BigNumber.from(0)))
+          assert(recipientBalanceAfter.eq(BigNumber.from(AMOUNT)))
+          assert.strictEqual(events.length, expectedNumEvents)
+          assertTransferEvent(events, ZERO_ADDRESS, recipientContract.address, AMOUNT)
+          assertMintEvent(events, recipientContract.address, OWNER.address, AMOUNT, data, operatorData)
+          assert.strictEqual(events.at(-1).event, 'ReceiveUserDataFailed')
+        })
+
       it('Should revert when minting tokens with the contract address as the recipient', async () => {
         const recipient = CONTRACT.address
         try {