@coti-io/coti-contracts 0.1.0 → 1.0.2

package/contracts/mocks/utils/mpc/ShiftTestsContract.sol

@@ -1,311 +0,0 @@
-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.19;
-
-import "../../../utils/mpc/MpcCore.sol";
-
-contract ShiftTestsContract {
-
-    struct AllGTCastingValues {
-        gtUint8 a8_s;
-        gtUint8 b8_s;
-        gtUint16 a16_s;
-        gtUint16 b16_s;
-        gtUint32 a32_s;
-        gtUint32 b32_s;
-        gtUint64 a64_s;
-        gtUint64 b64_s;
-    }
-
-    struct Check16 {
-        gtUint16 res16_16;
-        gtUint16 res8_16;
-        gtUint16 res16_8;
-    }
-
-    struct Check32 {
-        gtUint32 res32_32;
-        gtUint32 res8_32;
-        gtUint32 res32_8;
-        gtUint32 res16_32;
-        gtUint32 res32_16;
-    }
-
-    struct Check64 {
-        gtUint64 res64_64;
-        gtUint64 res8_64;
-        gtUint64 res64_8;
-        gtUint64 res16_64;
-        gtUint64 res64_16;
-        gtUint64 res32_64;
-        gtUint64 res64_32;
-    }
-
-    uint8 result;
-    uint16 result16;
-    uint32 result32;
-    uint64 result64;
-
-    function getResult() public view returns (uint8) {
-        return result;
-    }
-
-    function getAllShiftResults()
-        public
-        view
-        returns (uint8, uint16, uint32, uint64)
-    {
-        return (result, result16, result32, result64);
-    }
-
-    function setPublicValues(
-        AllGTCastingValues memory castingValues,
-        uint8 a,
-        uint8 b
-    ) public {
-        castingValues.a8_s = MpcCore.setPublic8(a);
-        castingValues.b8_s = MpcCore.setPublic8(b);
-        castingValues.a16_s = MpcCore.setPublic16(a);
-        castingValues.b16_s = MpcCore.setPublic16(b);
-        castingValues.a32_s = MpcCore.setPublic32(a);
-        castingValues.b32_s = MpcCore.setPublic32(b);
-        castingValues.a64_s = MpcCore.setPublic64(a);
-        castingValues.b64_s = MpcCore.setPublic64(b);
-    }
-
-    function decryptAndCompareResults16(
-        Check16 memory check16
-    ) public returns (uint16) {
-        // Calculate the result
-        uint16 result = MpcCore.decrypt(check16.res16_16);
-
-        require(
-            result == MpcCore.decrypt(check16.res8_16) &&
-                result == MpcCore.decrypt(check16.res16_8),
-            "decryptAndCompareAllResults: Failed to decrypt and compare all results"
-        );
-
-        return result;
-    }
-
-    function decryptAndCompareResults32(
-        Check32 memory check32
-    ) public returns (uint32) {
-        // Calculate the result
-        uint32 result = MpcCore.decrypt(check32.res32_32);
-
-        require(
-            result == MpcCore.decrypt(check32.res8_32) &&
-                result == MpcCore.decrypt(check32.res32_8) &&
-                result == MpcCore.decrypt(check32.res32_16) &&
-                result == MpcCore.decrypt(check32.res16_32),
-            "decryptAndCompareAllResults: Failed to decrypt and compare all results"
-        );
-
-        return result;
-    }
-
-    function decryptAndCompareResults64(
-        Check64 memory check64
-    ) public returns (uint64) {
-        // Calculate the result
-        uint64 result = MpcCore.decrypt(check64.res64_64);
-
-        require(
-            result == MpcCore.decrypt(check64.res8_64) &&
-                result == MpcCore.decrypt(check64.res64_8) &&
-                result == MpcCore.decrypt(check64.res64_16) &&
-                result == MpcCore.decrypt(check64.res16_64) &&
-                result == MpcCore.decrypt(check64.res64_32) &&
-                result == MpcCore.decrypt(check64.res32_64),
-            "decryptAndCompareAllResults: Failed to decrypt and compare all results"
-        );
-
-        return result;
-    }
-
-    function shlTest(
-        uint8 a,
-        uint8 b
-    ) public returns (uint8, uint16, uint32, uint64) {
-        AllGTCastingValues memory castingValues;
-        Check16 memory check16;
-        Check32 memory check32;
-        Check64 memory check64;
-        setPublicValues(castingValues, a, b);
-
-        // Calculate the expected result
-        result = MpcCore.decrypt(
-            MpcCore.shl(castingValues.a8_s, castingValues.b8_s)
-        );
-
-        // Calculate the result with casting to 16
-        check16.res16_16 = MpcCore.shl(
-            castingValues.a16_s,
-            castingValues.b16_s
-        );
-        check16.res8_16 = MpcCore.shl(castingValues.a8_s, castingValues.b16_s);
-        check16.res16_8 = MpcCore.shl(castingValues.a16_s, castingValues.b8_s);
-        result16 = decryptAndCompareResults16(check16);
-
-        // Calculate the result with casting to 32
-        check32.res32_32 = MpcCore.shl(
-            castingValues.a32_s,
-            castingValues.b32_s
-        );
-        check32.res8_32 = MpcCore.shl(castingValues.a8_s, castingValues.b32_s);
-        check32.res32_8 = MpcCore.shl(castingValues.a32_s, castingValues.b8_s);
-        check32.res16_32 = MpcCore.shl(
-            castingValues.a16_s,
-            castingValues.b32_s
-        );
-        check32.res32_16 = MpcCore.shl(
-            castingValues.a32_s,
-            castingValues.b16_s
-        );
-        result32 = decryptAndCompareResults32(check32);
-
-        // Calculate the result with casting to 64
-        check64.res64_64 = MpcCore.shl(
-            castingValues.a64_s,
-            castingValues.b64_s
-        );
-        check64.res8_64 = MpcCore.shl(castingValues.a8_s, castingValues.b64_s);
-        check64.res64_8 = MpcCore.shl(castingValues.a64_s, castingValues.b8_s);
-        check64.res16_64 = MpcCore.shl(
-            castingValues.a16_s,
-            castingValues.b64_s
-        );
-        check64.res64_16 = MpcCore.shl(
-            castingValues.a64_s,
-            castingValues.b16_s
-        );
-        check64.res32_64 = MpcCore.shl(
-            castingValues.a32_s,
-            castingValues.b64_s
-        );
-        check64.res64_32 = MpcCore.shl(
-            castingValues.a64_s,
-            castingValues.b32_s
-        );
-        result64 = decryptAndCompareResults64(check64);
-
-        // Check the result with scalar
-        require(
-            result == MpcCore.decrypt(MpcCore.shl(a, castingValues.b8_s)) &&
-                result == MpcCore.decrypt(MpcCore.shl(castingValues.a8_s, b)),
-            "shlTest: test 8 bits with scalar failed"
-        );
-        require(
-            result16 == MpcCore.decrypt(MpcCore.shl(a, castingValues.b16_s)) &&
-                result16 ==
-                MpcCore.decrypt(MpcCore.shl(castingValues.a16_s, b)),
-            "shlTest: test 16 bits with scalar failed"
-        );
-        require(
-            result32 == MpcCore.decrypt(MpcCore.shl(a, castingValues.b32_s)) &&
-                result32 ==
-                MpcCore.decrypt(MpcCore.shl(castingValues.a32_s, b)),
-            "shlTest: test 32 bits with scalar failed"
-        );
-        require(
-            result64 == MpcCore.decrypt(MpcCore.shl(a, castingValues.b64_s)) &&
-                result64 ==
-                MpcCore.decrypt(MpcCore.shl(castingValues.a64_s, b)),
-            "shlTest: test 64 bits with scalar failed"
-        );
-
-        return (result, result16, result32, result64);
-    }
-
-    function shrTest(uint8 a, uint8 b) public returns (uint8) {
-        AllGTCastingValues memory castingValues;
-        Check16 memory check16;
-        Check32 memory check32;
-        Check64 memory check64;
-        setPublicValues(castingValues, a, b);
-
-        // Calculate the expected result
-        result = MpcCore.decrypt(
-            MpcCore.shr(castingValues.a8_s, castingValues.b8_s)
-        );
-
-        // Calculate the results with casting to 16
-        check16.res16_16 = MpcCore.shr(
-            castingValues.a16_s,
-            castingValues.b16_s
-        );
-        check16.res8_16 = MpcCore.shr(castingValues.a8_s, castingValues.b16_s);
-        check16.res16_8 = MpcCore.shr(castingValues.a16_s, castingValues.b8_s);
-        uint16 res16 = decryptAndCompareResults16(check16);
-        require(res16 == result, "shrTest: cast 16 failed");
-
-        // Calculate the result with casting to 32
-        check32.res32_32 = MpcCore.shr(
-            castingValues.a32_s,
-            castingValues.b32_s
-        );
-        check32.res8_32 = MpcCore.shr(castingValues.a8_s, castingValues.b32_s);
-        check32.res32_8 = MpcCore.shr(castingValues.a32_s, castingValues.b8_s);
-        check32.res16_32 = MpcCore.shr(
-            castingValues.a16_s,
-            castingValues.b32_s
-        );
-        check32.res32_16 = MpcCore.shr(
-            castingValues.a32_s,
-            castingValues.b16_s
-        );
-        uint32 res32 = decryptAndCompareResults32(check32);
-        require(result == res32, "shrTest: cast 32 failed");
-
-        // Calculate the result with casting to 64
-        check64.res64_64 = MpcCore.shr(
-            castingValues.a64_s,
-            castingValues.b64_s
-        );
-        check64.res8_64 = MpcCore.shr(castingValues.a8_s, castingValues.b64_s);
-        check64.res64_8 = MpcCore.shr(castingValues.a64_s, castingValues.b8_s);
-        check64.res16_64 = MpcCore.shr(
-            castingValues.a16_s,
-            castingValues.b64_s
-        );
-        check64.res64_16 = MpcCore.shr(
-            castingValues.a64_s,
-            castingValues.b16_s
-        );
-        check64.res32_64 = MpcCore.shr(
-            castingValues.a32_s,
-            castingValues.b64_s
-        );
-        check64.res64_32 = MpcCore.shr(
-            castingValues.a64_s,
-            castingValues.b32_s
-        );
-        uint64 res64 = decryptAndCompareResults64(check64);
-        require(result == res64, "shrTest: cast 64 failed");
-
-        // Check the result with scalar
-        require(
-            result == MpcCore.decrypt(MpcCore.shr(a, castingValues.b8_s)) &&
-                result == MpcCore.decrypt(MpcCore.shr(castingValues.a8_s, b)),
-            "shrTest: test 8 bits with scalar failed"
-        );
-        require(
-            result == MpcCore.decrypt(MpcCore.shr(a, castingValues.b16_s)) &&
-                result == MpcCore.decrypt(MpcCore.shr(castingValues.a16_s, b)),
-            "shrTest: test 16 bits with scalar failed"
-        );
-        require(
-            result == MpcCore.decrypt(MpcCore.shr(a, castingValues.b32_s)) &&
-                result == MpcCore.decrypt(MpcCore.shr(castingValues.a32_s, b)),
-            "shrTest: test 32 bits with scalar failed"
-        );
-        require(
-            result == MpcCore.decrypt(MpcCore.shr(a, castingValues.b64_s)) &&
-                result == MpcCore.decrypt(MpcCore.shr(castingValues.a64_s, b)),
-            "shrTest: test 64 bits with scalar failed"
-        );
-
-        return result;
-    }
-}

package/contracts/token/PrivateERC20/README.md

@@ -1,104 +0,0 @@
-# PrivateERC20
-
-## Overview
-
-The `PrivateERC20` contract is an abstract implementation of a privacy-enhanced ERC20 token. It introduces mechanisms for handling encrypted addresses and balances, allowing for more secure and private token transfers. This contract builds on top of OpenZeppelin's `Context` and the `IPrivateERC20` interface, and it integrates with the `MpcCore` library for secure multiparty computation (MPC).
-
-## Prerequisites
-
-- **Solidity Version**: `^0.8.19`
-- **License**: MIT
-- **Dependencies**:
-  - OpenZeppelin's `Context` contract
-  - Interface `IPrivateERC20`
-  - Utility `MpcCore` for cryptographic operations.
-
-## Table of Contents
-- [Constants](#constants)
-  - [MAX_UINT_64](#max_uint_64)
-- [State Variables](#state-variables)
-  - [Account Encryption Address Mapping](#account-encryption-address-mapping)
-  - [Balance Mapping](#balance-mapping)
-  - [Allowances Mapping](#allowances-mapping)
-  - [Total Supply](#total-supply)
-  - [Token Name and Symbol](#token-name-and-symbol)
-- [Errors](#errors)
-  - [ERC20InvalidSender](#erc20invalidsender)
-  - [ERC20InvalidReceiver](#erc20invalidreceiver)
-- [Functions](#functions)
-  - To be documented as additional logic is discovered.
-
-## Constants
-
-### MAX_UINT_64
-
-```solidity
-uint64 private constant MAX_UINT_64 = type(uint64).max;
-```
-
-The constant `MAX_UINT_64` represents the maximum value of a 64-bit unsigned integer. This is used as a cap for various operations in the contract.
-
-## State Variables
-
-### Account Encryption Address Mapping
-
-```solidity
-mapping(address account => address) private _accountEncryptionAddress;
-```
-
-This mapping associates each account (public address) with an encryption address. The encryption address could be used for handling cryptographically secure operations involving private balances and transactions.
-
-### Balance Mapping
-
-```solidity
-mapping(address account => utUint64) private _balances;
-```
-
-The `_balances` mapping keeps track of each account's token balance, but it uses a 64-bit unsigned integer (`utUint64`). This might be intended for scaling or privacy-preserving reasons.
-
-### Allowances Mapping
-
-```solidity
-mapping(address account => mapping(address spender => Allowance)) private _allowances;
-```
-
-The `_allowances` mapping tracks the allowance that one account (`account`) has given to another account (`spender`). This is a standard ERC20 allowance mechanism with the added layer of the `Allowance` structure, which may handle encrypted or privacy-preserving amounts.
-
-### Total Supply
-
-```solidity
-ctUint64 private _totalSupply;
-```
-
-The `_totalSupply` variable keeps track of the total number of tokens in existence. Like the `_balances` mapping, it uses a 64-bit unsigned integer (`ctUint64`).
-
-### Token Name and Symbol
-
-```solidity
-string private _name;
-string private _symbol;
-```
-
-These variables store the name and symbol of the token, following the ERC20 standard.
-
-## Errors
-
-### ERC20InvalidSender
-
-```solidity
-error ERC20InvalidSender(address sender);
-```
-
-The `ERC20InvalidSender` error is raised when an invalid sender address attempts to perform a token transfer. It logs the `sender` address that caused the failure.
-
-### ERC20InvalidReceiver
-
-```solidity
-error ERC20InvalidReceiver(address receiver);
-```
-
-The `ERC20InvalidReceiver` error is raised when a transfer fails due to an invalid receiver address. It logs the `receiver` address that caused the failure.
-
-## Functions
-
-Functions in the contract are abstract or unimplemented in this fragment. These likely involve ERC20-style operations, such as `transfer`, `approve`, and `transferFrom`, but with privacy-preserving adjustments, including the handling of encrypted addresses and balances.

package/contracts/token/PrivateERC721/README.md

@@ -1,282 +0,0 @@
-# PrivateERC721
-
-## Overview
-
-`PrivateERC721` is an abstract implementation of the [ERC721 Non-Fungible Token (NFT) Standard](https://eips.ethereum.org/EIPS/eip-721). It includes essential features of the standard, such as token ownership, approval, transfers, and safe transfers. This contract implements key components of the ERC721 standard while maintaining support for token metadata, but without fully implementing the metadata extension.
-
-## Prerequisites
-
-- **Solidity Version**: `^0.8.19`
-- **License**: MIT
-- **Dependencies**:
-  - OpenZeppelin’s `Context`, `ERC165`, and `IERC721` contracts.
-  - `IERC721Receiver` for safe transfer checks.
-  - `IERC721Errors` interface for custom errors (related to the draft standard [IERC6093](https://eips.ethereum.org/EIPS/eip-6093)).
-
-## Table of Contents
-- [Events](#events)
-- [State Variables](#state-variables)
-- [Constructor](#constructor)
-- [Functions](#functions)
-  - [Supports Interface](#supports-interface)
-  - [Balance Of](#balance-of)
-  - [Owner Of](#owner-of)
-  - [Name](#name)
-  - [Symbol](#symbol)
-  - [Approve](#approve)
-  - [Get Approved](#get-approved)
-  - [Set Approval For All](#set-approval-for-all)
-  - [Is Approved For All](#is-approved-for-all)
-  - [Transfer From](#transfer-from)
-  - [Safe Transfer From](#safe-transfer-from)
-  - [Private/Internal Functions](#privateinternal-functions)
-
-## Events
-
-## Event: `Transfer`
-
-```solidity
-event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
-```
-
-### Description:
-This event is emitted whenever an ERC-721 token is transferred from one address to another. It occurs during both direct token transfers (`transferFrom`) and safe token transfers (`safeTransferFrom`). This event helps external observers, such as dApps and explorers, to track the movement of tokens.
-
-### Parameters:
-- **`from`** (`address`): The address of the current owner of the token.
-- **`to`** (`address`): The address that is receiving ownership of the token.
-- **`tokenId`** (`uint256`): The unique identifier (ID) of the token being transferred.
-
-### Important Notes:
-- This event is emitted for both `transferFrom` and `safeTransferFrom` operations.
-- If a token is minted, `from` will be the zero address (`address(0)`).
-- If a token is burned, `to` will be the zero address (`address(0)`).
-
-## Event: `Approval`
-
-```solidity
-event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
-```
-
-### Description:
-The `Approval` event is emitted when an owner grants or revokes permission to another account (the `approved` address) to transfer a specific token. Each ERC-721 token can only have one approved address at a time. The approval is reset when the token is transferred to a new owner.
-
-### Parameters:
-- **`owner`** (`address`): The current owner of the token.
-- **`approved`** (`address`): The address that is approved to transfer the token. This can be the zero address (`address(0)`) if no account is approved.
-- **`tokenId`** (`uint256`): The unique identifier (ID) of the token being approved for transfer.
-
-### Important Notes:
-- This event is specific to individual tokens, meaning approvals apply to a single `tokenId`.
-- Approving the zero address (`address(0)`) clears the previous approval, effectively revoking approval for that token.
-
-## Event: `ApprovalForAll`
-
-```solidity
-event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
-```
-
-### Description:
-This event is emitted when an owner enables or disables an operator to manage all of their assets. Operators can transfer or manage any token owned by the `owner`. The event allows for bulk approval of all tokens owned by a single account.
-
-### Parameters:
-- **`owner`** (`address`): The address of the token owner.
-- **`operator`** (`address`): The address that is granted or revoked permission to manage all of the owner's tokens.
-- **`approved`** (`bool`): A boolean value indicating whether the operator is approved (`true`) or approval is revoked (`false`).
-
-### Important Notes:
-- This event differs from the `Approval` event because it applies to all tokens owned by the `owner`, not a single token.
-- This event is emitted when the `setApprovalForAll` function is called, allowing or revoking an operator’s access to all of the owner's tokens.
-
-## State Variables
-
-- **_name** (`string`): The name of the token collection.
-- **_symbol** (`string`): The symbol for the token collection.
-- **_owners** (`mapping(uint256 => address)`): Maps a token ID to its owner address.
-- **_balances** (`mapping(address => uint256)`): Maps owner addresses to the number of tokens they own.
-- **_tokenApprovals** (`mapping(uint256 => address)`): Maps a token ID to the approved address for that token.
-- **_operatorApprovals** (`mapping(address => mapping(address => bool))`): Maps an owner to an operator, allowing the operator to manage all tokens owned by that owner.
-
-## Constructor
-
-```solidity
-constructor(string memory name_, string memory symbol_)
-```
-
-The constructor initializes the contract by setting the name and symbol of the token collection. It accepts the following parameters:
-
-- **`name_`**: The name of the token collection.
-- **`symbol_`**: The symbol for the token collection.
-
-## Functions
-
-### Supports Interface
-
-```solidity
-function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool)
-```
-
-Implements the `supportsInterface` function to check if the contract implements a specific interface (e.g., `IERC721`).
-
-- **`interfaceId`**: The interface identifier to check.
-- **Returns**: `true` if the contract supports the interface, otherwise `false`.
-
-### Balance Of
-
-```solidity
-function balanceOf(address owner) public view virtual returns (uint256)
-```
-
-Returns the number of tokens owned by the given address.
-
-- **`owner`**: The address to query.
-- **Returns**: The number of tokens owned by the address.
-- **Reverts**: `ERC721InvalidOwner` if `owner` is the zero address.
-
-### Owner Of
-
-```solidity
-function ownerOf(uint256 tokenId) public view virtual returns (address)
-```
-
-Returns the owner of the given `tokenId`.
-
-- **`tokenId`**: The ID of the token.
-- **Returns**: The owner address of the `tokenId`.
-- **Reverts**: If the token does not exist.
-
-### Name
-
-```solidity
-function name() public view virtual returns (string memory)
-```
-
-Returns the name of the token collection.
-
-### Symbol
-
-```solidity
-function symbol() public view virtual returns (string memory)
-```
-
-Returns the symbol of the token collection.
-
-### Approve
-
-```solidity
-function approve(address to, uint256 tokenId) public virtual
-```
-
-Approves the given address (`to`) to transfer the specified token on behalf of the owner.
-
-- **`to`**: The address to be approved.
-- **`tokenId`**: The ID of the token to approve.
-
-### Get Approved
-
-```solidity
-function getApproved(uint256 tokenId) public view virtual returns (address)
-```
-
-Returns the approved address for the given `tokenId`.
-
-- **`tokenId`**: The ID of the token to check.
-- **Returns**: The address approved to transfer the `tokenId`.
-
-### Set Approval For All
-
-```solidity
-function setApprovalForAll(address operator, bool approved) public virtual
-```
-
-Enables or disables approval for a third-party `operator` to manage all tokens owned by the sender.
-
-- **`operator`**: The address of the operator.
-- **`approved`**: `true` to approve, `false` to revoke approval.
-
-### Is Approved For All
-
-```solidity
-function isApprovedForAll(address owner, address operator) public view virtual returns (bool)
-```
-
-Checks if the `operator` is approved to manage all tokens owned by `owner`.
-
-- **`owner`**: The address of the token owner.
-- **`operator`**: The address of the operator.
-- **Returns**: `true` if the operator is approved, otherwise `false`.
-
-### Transfer From
-
-```solidity
-function transferFrom(address from, address to, uint256 tokenId) public virtual
-```
-
-Transfers ownership of the `tokenId` from one address to another.
-
-- **`from`**: The current owner of the token.
-- **`to`**: The address receiving the token.
-- **`tokenId`**: The ID of the token.
-- **Reverts**: `ERC721InvalidReceiver` if `to` is the zero address or if the sender is not authorized to transfer the token.
-
-### Safe Transfer From
-
-```solidity
-function safeTransferFrom(address from, address to, uint256 tokenId) public
-```
-
-Safely transfers a `tokenId` from one address to another, ensuring the receiver can handle ERC721 tokens.
-
-- **`from`**: The current owner of the token.
-- **`to`**: The address receiving the token.
-- **`tokenId`**: The ID of the token.
-
-### Private/Internal Functions
-
-#### `_ownerOf`
-
-```solidity
-function _ownerOf(uint256 tokenId) internal view virtual returns (address)
-```
-
-Internal function that returns the owner of the `tokenId`.
-
-#### `_isAuthorized`
-
-```solidity
-function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool)
-```
-
-Checks if `spender` is authorized to manage `owner`'s token or the specific `tokenId`.
-
-#### `_approve`
-
-```solidity
-function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual
-```
-
-Approves the address `to` to manage the `tokenId`. Optionally emits the `Approval` event.
-
-#### `_mint`
-
-```solidity
-function _mint(address to, uint256 tokenId) internal
-```
-
-Mints a new token with the given `tokenId` and transfers it to the address `to`.
-
-#### `_burn`
-
-```solidity
-function _burn(uint256 tokenId) internal
-```
-
-Burns (destroys) the token with the given `tokenId`.
-
-#### `_checkOnERC721Received`
-
-```solidity
-function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private
-```
-
-Private function to invoke the `IERC721Receiver.onERC721Received` on the target address if it's a contract.