@lukso/lsp20-contracts 0.15.0-rc.0

package/README.md

@@ -0,0 +1,9 @@
+# LSP20 Call Verification · [![npm version](https://img.shields.io/npm/v/@lukso/lsp20-contracts.svg?style=flat)](https://www.npmjs.com/package/@lukso/lsp20-contracts)
+
+Package for the LSP20 Call Verification standard.
+
+## Installation
+
+```bash
+npm i @lukso/lsp20-contracts
+```

package/contracts/ILSP20CallVerifier.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.4;
+
+/**
+ * @title Interface for the LSP20 Call Verification standard, a set of functions intended to perform verifications on behalf of another contract.
+ *
+ * @dev Interface to be inherited for contract supporting LSP20-CallVerification
+ */
+interface ILSP20CallVerifier {
+    /**
+     * @return returnedStatus MUST return the first 3 bytes of `lsp20VerifyCall(address,uint256,bytes)` function selector if the call to
+     * the function is allowed, concatened with a byte that determines if the lsp20VerifyCallResult function should
+     * be called after the original function call. The byte that invoke the lsp20VerifyCallResult function is strictly `0x01`.
+     *
+     * @param requestor The address that requested to make the call to `target`.
+     * @param target The address of the contract that implements the `LSP20CallVerification` interface.
+     * @param caller The address who called the function on the `target` contract.
+     * @param value The value sent by the caller to the function called on the msg.sender
+     * @param callData The calldata sent by the caller to the msg.sender
+     */
+    function lsp20VerifyCall(
+        address requestor,
+        address target,
+        address caller,
+        uint256 value,
+        bytes memory callData
+    ) external returns (bytes4 returnedStatus);
+
+    /**
+     * @return MUST return the lsp20VerifyCallResult function selector if the call to the function is allowed
+     *
+     * @param callHash The keccak256 hash of the parameters of {lsp20VerifyCall} concatenated
+     * @param callResult The value result of the function called on the msg.sender
+     */
+    function lsp20VerifyCallResult(
+        bytes32 callHash,
+        bytes memory callResult
+    ) external returns (bytes4);
+}

package/contracts/LSP20CallVerification.sol

@@ -0,0 +1,120 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.4;
+
+// interfaces
+import {ILSP20CallVerifier as ILSP20} from "./ILSP20CallVerifier.sol";
+
+// errors
+import {
+    LSP20CallVerificationFailed,
+    LSP20CallingVerifierFailed,
+    LSP20EOACannotVerifyCall
+} from "./LSP20Errors.sol";
+
+/**
+ * @title Implementation of a contract calling the verification functions according to LSP20 - Call Verification standard.
+ *
+ * @dev Module to be inherited used to verify the execution of functions according to a verifier address.
+ * Verification can happen before or after execution based on a returnedStatus.
+ */
+abstract contract LSP20CallVerification {
+    /**
+     * @dev Calls {lsp20VerifyCall} function on the logicVerifier.
+     *
+     * @custom:info
+     * - Reverts in case the value returned does not match the returned status (lsp20VerifyCall selector).
+     * - Returns whether a verification after the execution should happen based on the last byte of the `returnedStatus`.
+     * - Reverts with no reason if the  data returned by `ILSP20(logicVerifier).lsp20VerifyCall(...)` cannot be decoded (_e.g:_ any other data type besides `bytes4`).
+     * See this link for more info: https://forum.soliditylang.org/t/call-for-feedback-the-future-of-try-catch-in-solidity/1497.
+     */
+    function _verifyCall(
+        address logicVerifier
+    ) internal virtual returns (bool verifyAfter) {
+        if (logicVerifier.code.length == 0) {
+            revert LSP20EOACannotVerifyCall(logicVerifier);
+        }
+
+        // Reverts with no reason if the returned data type is not a `bytes4` value
+        try
+            ILSP20(logicVerifier).lsp20VerifyCall(
+                msg.sender,
+                address(this),
+                msg.sender,
+                msg.value,
+                msg.data
+            )
+        returns (bytes4 returnedStatus) {
+            if (
+                bytes3(returnedStatus) !=
+                bytes3(ILSP20.lsp20VerifyCall.selector)
+            ) {
+                revert LSP20CallVerificationFailed({
+                    postCall: false,
+                    returnedStatus: returnedStatus
+                });
+            }
+
+            return returnedStatus[3] == 0x01;
+        } catch (bytes memory errorData) {
+            _revertWithLSP20DefaultError(false, errorData);
+        }
+    }
+
+    /**
+     * @dev Calls {lsp20VerifyCallResult} function on the logicVerifier.
+     *
+     * @custom:info
+     * - Reverts in case the value returned does not match the returned status (lsp20VerifyCallResult selector).
+     * - Reverts with no reason if the data returned by `ILSP20(logicVerifier).lsp20VerifyCallResult(...)` cannot be decoded (_e.g:_ any other data type besides `bytes4`).
+     * See this link for more info: https://forum.soliditylang.org/t/call-for-feedback-the-future-of-try-catch-in-solidity/1497.
+     */
+    function _verifyCallResult(
+        address logicVerifier,
+        bytes memory callResult
+    ) internal virtual {
+        // Reverts with no reason if the returned data type is not a `bytes4` value
+        try
+            ILSP20(logicVerifier).lsp20VerifyCallResult(
+                keccak256(
+                    abi.encodePacked(
+                        msg.sender,
+                        address(this),
+                        msg.sender,
+                        msg.value,
+                        msg.data
+                    )
+                ),
+                callResult
+            )
+        returns (bytes4 returnedStatus) {
+            if (returnedStatus != ILSP20.lsp20VerifyCallResult.selector) {
+                revert LSP20CallVerificationFailed({
+                    postCall: true,
+                    returnedStatus: returnedStatus
+                });
+            }
+
+            return;
+        } catch (bytes memory errorData) {
+            _revertWithLSP20DefaultError(true, errorData);
+        }
+    }
+
+    function _revertWithLSP20DefaultError(
+        bool postCall,
+        bytes memory returnedData
+    ) internal pure virtual {
+        // Look for revert reason and bubble it up if present
+        if (returnedData.length != 0) {
+            // The easiest way to bubble the revert reason is using memory via assembly
+            // solhint-disable no-inline-assembly
+            /// @solidity memory-safe-assembly
+            assembly {
+                let returndata_size := mload(returnedData)
+                revert(add(32, returnedData), returndata_size)
+            }
+        } else {
+            revert LSP20CallingVerifierFailed(postCall);
+        }
+    }
+}

package/contracts/LSP20Constants.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.4;
+
+// bytes4(keccak256("LSP20CallVerification"))
+bytes4 constant _INTERFACEID_LSP20_CALL_VERIFICATION = 0x1a0eb6a5;
+
+// `lsp20VerifyCall(address,address,address,uint256,bytes)` selector XOR `lsp20VerifyCallResult(bytes32,bytes)` selector
+bytes4 constant _INTERFACEID_LSP20_CALL_VERIFIER = 0x0d6ecac7;
+
+// bytes4(bytes.concat(bytes3(ILSP20.lsp20VerifyCall.selector), hex"01"))
+bytes4 constant _LSP20_VERIFY_CALL_SUCCESS_VALUE_WITH_POST_VERIFICATION = 0xde928f01;
+
+// bytes4(bytes.concat(bytes3(ILSP20.lsp20VerifyCall.selector), hex"00"))
+bytes4 constant _LSP20_VERIFY_CALL_SUCCESS_VALUE_WITHOUT_POST_VERIFICATION = 0xde928f00;
+
+// bytes4(ILSP20.lsp20VerifyCallResult.selector)
+bytes4 constant _LSP20_VERIFY_CALL_RESULT_SUCCESS_VALUE = 0xd3fc45d3;

package/contracts/LSP20Errors.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.4;
+
+/**
+ * @dev reverts when the call to the owner fail with no revert reason
+ * @param postCall True if the execution call was done, False otherwise
+ */
+error LSP20CallingVerifierFailed(bool postCall);
+
+/**
+ * @dev reverts when the call to the owner does not return the LSP20 success value
+ * @param postCall True if the execution call was done, False otherwise
+ * @param returnedStatus The bytes4 decoded data returned by the logic verifier.
+ */
+error LSP20CallVerificationFailed(bool postCall, bytes4 returnedStatus);
+
+/**
+ * @dev Reverts when the logic verifier is an Externally Owned Account (EOA) that cannot return the LSP20 success value.
+ * @param logicVerifier The address of the logic verifier
+ */
+error LSP20EOACannotVerifyCall(address logicVerifier);

package/dist/index.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+const INTERFACE_ID_LSP20CallVerification = "0x1a0eb6a5";
+const INTERFACE_ID_LSP20CallVerifier = "0x0d6ecac7";
+const LSP20_SUCCESS_VALUES = {
+  VERIFY_CALL: {
+    // bytes3(keccak256("lsp20VerifyCall(address,address,address,uint256,bytes)")) + "0x00"
+    NO_POST_VERIFICATION: "0xde928f00",
+    // bytes3(keccak256("lsp20VerifyCall(address,address,address,uint256,bytes)")) + "0x01"
+    WITH_POST_VERIFICATION: "0xde928f01"
+  },
+  // bytes4(keccak256("lsp20VerifyCallResult(bytes32,bytes)"))
+  VERIFY_CALL_RESULT: "0xd3fc45d3"
+};
+
+exports.INTERFACE_ID_LSP20CallVerification = INTERFACE_ID_LSP20CallVerification;
+exports.INTERFACE_ID_LSP20CallVerifier = INTERFACE_ID_LSP20CallVerifier;
+exports.LSP20_SUCCESS_VALUES = LSP20_SUCCESS_VALUES;

package/dist/index.d.cts

@@ -0,0 +1,15 @@
+declare const INTERFACE_ID_LSP20CallVerification = "0x1a0eb6a5";
+declare const INTERFACE_ID_LSP20CallVerifier = "0x0d6ecac7";
+/**
+ * @dev values returned by the `lsp20VerifyCall` and `lsp20VerifyCallResult` functions of the LSP20 standard.
+ * Can be used to check if a calldata payload was check and verified.
+ */
+declare const LSP20_SUCCESS_VALUES: {
+    VERIFY_CALL: {
+        NO_POST_VERIFICATION: string;
+        WITH_POST_VERIFICATION: string;
+    };
+    VERIFY_CALL_RESULT: string;
+};
+
+export { INTERFACE_ID_LSP20CallVerification, INTERFACE_ID_LSP20CallVerifier, LSP20_SUCCESS_VALUES };

package/dist/index.d.mts

@@ -0,0 +1,15 @@
+declare const INTERFACE_ID_LSP20CallVerification = "0x1a0eb6a5";
+declare const INTERFACE_ID_LSP20CallVerifier = "0x0d6ecac7";
+/**
+ * @dev values returned by the `lsp20VerifyCall` and `lsp20VerifyCallResult` functions of the LSP20 standard.
+ * Can be used to check if a calldata payload was check and verified.
+ */
+declare const LSP20_SUCCESS_VALUES: {
+    VERIFY_CALL: {
+        NO_POST_VERIFICATION: string;
+        WITH_POST_VERIFICATION: string;
+    };
+    VERIFY_CALL_RESULT: string;
+};
+
+export { INTERFACE_ID_LSP20CallVerification, INTERFACE_ID_LSP20CallVerifier, LSP20_SUCCESS_VALUES };

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+declare const INTERFACE_ID_LSP20CallVerification = "0x1a0eb6a5";
+declare const INTERFACE_ID_LSP20CallVerifier = "0x0d6ecac7";
+/**
+ * @dev values returned by the `lsp20VerifyCall` and `lsp20VerifyCallResult` functions of the LSP20 standard.
+ * Can be used to check if a calldata payload was check and verified.
+ */
+declare const LSP20_SUCCESS_VALUES: {
+    VERIFY_CALL: {
+        NO_POST_VERIFICATION: string;
+        WITH_POST_VERIFICATION: string;
+    };
+    VERIFY_CALL_RESULT: string;
+};
+
+export { INTERFACE_ID_LSP20CallVerification, INTERFACE_ID_LSP20CallVerifier, LSP20_SUCCESS_VALUES };

package/dist/index.mjs

@@ -0,0 +1,14 @@
+const INTERFACE_ID_LSP20CallVerification = "0x1a0eb6a5";
+const INTERFACE_ID_LSP20CallVerifier = "0x0d6ecac7";
+const LSP20_SUCCESS_VALUES = {
+  VERIFY_CALL: {
+    // bytes3(keccak256("lsp20VerifyCall(address,address,address,uint256,bytes)")) + "0x00"
+    NO_POST_VERIFICATION: "0xde928f00",
+    // bytes3(keccak256("lsp20VerifyCall(address,address,address,uint256,bytes)")) + "0x01"
+    WITH_POST_VERIFICATION: "0xde928f01"
+  },
+  // bytes4(keccak256("lsp20VerifyCallResult(bytes32,bytes)"))
+  VERIFY_CALL_RESULT: "0xd3fc45d3"
+};
+
+export { INTERFACE_ID_LSP20CallVerification, INTERFACE_ID_LSP20CallVerifier, LSP20_SUCCESS_VALUES };

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@lukso/lsp20-contracts",
+  "version": "0.15.0-rc.0",
+  "description": "Package for the LSP20 Call Verification standard",
+  "license": "Apache-2.0",
+  "author": "",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "typings": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    },
+    "./artifacts/*": "./artifacts/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "contracts/**/*.sol",
+    "!contracts/Mocks/**/*.sol",
+    "artifacts/*.json",
+    "dist",
+    "./README.md"
+  ],
+  "keywords": [
+    "LUKSO",
+    "LSP",
+    "Blockchain",
+    "Standards",
+    "Smart Contracts",
+    "Ethereum",
+    "EVM",
+    "Solidity"
+  ],
+  "scripts": {
+    "build": "hardhat compile --show-stack-traces",
+    "build:js": "unbuild",
+    "clean": "hardhat clean && rm -Rf dist/",
+    "format": "prettier --write .",
+    "lint": "eslint . --ext .ts,.js",
+    "lint:solidity": "solhint 'contracts/**/*.sol' && prettier --check 'contracts/**/*.sol'"
+  }
+}