implemented custom and external modifiers

Author: Lovegupta112

.deps/npm/@openzeppelin/contracts/access/Ownable.sol

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
+
+pragma solidity ^0.8.20;
+
+import {Context} from "../utils/Context.sol";
+
+/**
+ * @dev Contract module which provides a basic access control mechanism, where
+ * there is an account (an owner) that can be granted exclusive access to
+ * specific functions.
+ *
+ * The initial owner is set to the address provided by the deployer. This can
+ * later be changed with {transferOwnership}.
+ *
+ * This module is used through inheritance. It will make available the modifier
+ * `onlyOwner`, which can be applied to your functions to restrict their use to
+ * the owner.
+ */
+abstract contract Ownable is Context {
+    address private _owner;
+
+    /**
+     * @dev The caller account is not authorized to perform an operation.
+     */
+    error OwnableUnauthorizedAccount(address account);
+
+    /**
+     * @dev The owner is not a valid owner account. (eg. `address(0)`)
+     */
+    error OwnableInvalidOwner(address owner);
+
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    /**
+     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
+     */
+    constructor(address initialOwner) {
+        if (initialOwner == address(0)) {
+            revert OwnableInvalidOwner(address(0));
+        }
+        _transferOwnership(initialOwner);
+    }
+
+    /**
+     * @dev Throws if called by any account other than the owner.
+     */
+    modifier onlyOwner() {
+        _checkOwner();
+        _;
+    }
+
+    /**
+     * @dev Returns the address of the current owner.
+     */
+    function owner() public view virtual returns (address) {
+        return _owner;
+    }
+
+    /**
+     * @dev Throws if the sender is not the owner.
+     */
+    function _checkOwner() internal view virtual {
+        if (owner() != _msgSender()) {
+            revert OwnableUnauthorizedAccount(_msgSender());
+        }
+    }
+
+    /**
+     * @dev Leaves the contract without owner. It will not be possible to call
+     * `onlyOwner` functions. Can only be called by the current owner.
+     *
+     * NOTE: Renouncing ownership will leave the contract without an owner,
+     * thereby disabling any functionality that is only available to the owner.
+     */
+    function renounceOwnership() public virtual onlyOwner {
+        _transferOwnership(address(0));
+    }
+
+    /**
+     * @dev Transfers ownership of the contract to a new account (`newOwner`).
+     * Can only be called by the current owner.
+     */
+    function transferOwnership(address newOwner) public virtual onlyOwner {
+        if (newOwner == address(0)) {
+            revert OwnableInvalidOwner(address(0));
+        }
+        _transferOwnership(newOwner);
+    }
+
+    /**
+     * @dev Transfers ownership of the contract to a new account (`newOwner`).
+     * Internal function without access restriction.
+     */
+    function _transferOwnership(address newOwner) internal virtual {
+        address oldOwner = _owner;
+        _owner = newOwner;
+        emit OwnershipTransferred(oldOwner, newOwner);
+    }
+}

.deps/npm/@openzeppelin/contracts/utils/Context.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
+
+pragma solidity ^0.8.20;
+
+/**
+ * @dev Provides information about the current execution context, including the
+ * sender of the transaction and its data. While these are generally available
+ * via msg.sender and msg.data, they should not be accessed in such a direct
+ * manner, since when dealing with meta-transactions the account sending and
+ * paying for execution may not be the actual sender (as far as an application
+ * is concerned).
+ *
+ * This contract is only required for intermediate, library-like contracts.
+ */
+abstract contract Context {
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+
+    function _msgData() internal view virtual returns (bytes calldata) {
+        return msg.data;
+    }
+
+    function _contextSuffixLength() internal view virtual returns (uint256) {
+        return 0;
+    }
+}

.states/vm-cancun/state.json

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.2 <0.9.0;
+
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+contract ExternalModifier is Ownable{
+
+ constructor()Ownable(msg.sender){
+
+ }
+
+ function welcome(string memory _name) public view onlyOwner returns (string memory)  {
+        return string.concat("hi , Welcome to our world ",_name);
+    }
+
+}

contracts/ExternalModifier.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.2 <0.9.0;
+
+
+contract Modifiers {
+
+    address public ownerAddress;
+
+    constructor(){
+        ownerAddress=msg.sender;
+    }
+    
+    // function addAddress(address _address) public  {
+    //     require(msg.sender==ownerAddress,"You are not the owner!");
+    //     ownerAddress=_address;
+    // }
+
+    // function welcome(string memory _name) public  view returns (string memory) {
+    //     require(msg.sender==ownerAddress,"You have not permission to call this!");
+    //     return string.concat("Welcome to our world ",_name);
+    // }
+    
+    // or we can make modifier----
+
+    modifier  onlyOwner(){
+        require(msg.sender==ownerAddress,"You are not the owner,You haven't access.");
+        _; //it is like next() in express 
+    }
+
+    function addAddress(address _address) public onlyOwner {
+        ownerAddress=_address;
+    }
+
+    function welcome(string memory _name) public view onlyOwner returns (string memory)  {
+        return string.concat("hi , Welcome to our world ",_name);
+    }
+
+}

contracts/Modifiers.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.2 <0.9.0 ;
+
+contract StackMem{
+
+    uint[] numArr;
+
+//local var will store in stack 
+    function add(uint _a,uint _b) public pure returns (uint) {
+        uint res=_a +_b;
+        return res;
+    }
+
+    function init1(uint[] memory _numArr) public {
+// arrays,string etc are stored in memory 
+      for(uint i=0;i<_numArr.length;i++){
+         numArr[i]=_numArr[i];
+      }
+    }
+
+}