How To Deploy a Smart Contract on Arbitrum Nova

mkdir StorageContract && cd StorageContract
npm init -y
npm install --save-dev hardhat
npm i dotenv
npm i @nomicfoundation/hardhat-toolbox
npx hardhat

mkdir contracts
mkdir test
mkdir scripts
echo > .env

require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();

module.exports = {
  solidity: "0.8.17",
  networks: {
    nova: {
      url: process.env.RPC_URL,
      accounts: [process.env.PRIVATE_KEY]
    }
  }
};

PRIVATE_KEY=<FILLME>
RPC_URL=<FILLME>

echo > contracts/SimpleStorage.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.17;

contract SimpleStorage {
    address public owner;  // Public variable to store the address of the owner of the contract
    uint public value;     // Public variable to store the value

    event NewValueSet(uint value);    // Event emitted when the value is set
    event OwnerChanged(address newOwner); // Event emitted when the owner is changed

    constructor() {
        owner = msg.sender;  // Initialize the owner as the address that deployed the contract
    }

    // Modifier to check if the msg.sender is the owner before execution
    modifier onlyOwner() {
        require(msg.sender == owner, "Only the owner can perform this action.");
        _;
    }

    /**
     * @dev Function to read the current value stored in the contract
     * @return uint - the value stored in the contract
     */
    function readValue() public view returns (uint) {
        return value;
    }

    /**
     * @dev Function to set a new value in the contract
     * @param _value - the new value to be set
     */
    function setValue(uint _value) public onlyOwner {
        value = _value;
        emit NewValueSet(value);
    }

    /**
     * @dev Function to read the current owner stored in the contract
     * @return address - the value stored in the contract
     */
    function getOwner() public view returns (address) {
        return owner;
    }

    /**
     * @dev Function to change the owner of the contract
     * @param _newOwner - the new owner of the contract
     */
    function changeOwner(address _newOwner) public onlyOwner {
        require(_newOwner != address(0), "The new owner address cannot be 0x0");
        owner = _newOwner;
        emit OwnerChanged(owner);
    }
}

echo > test/storageTest.js

const { expect } = require("chai");

describe("Storage Contract Test", function () {
    let owner;

    beforeEach(async function () {
        // Retrieve the default account from ethers
        [owner] = await ethers.getSigners();

        // A helper to get the contracts instance and deploy it locally
        const SimpleStorage = await ethers.getContractFactory("SimpleStorage");
        simpleStorage = await SimpleStorage.deploy();
    });

    it("should set and get value correctly", async () => {
        // Set a new value
        const newValue = 12345;
        await simpleStorage.setValue(newValue);


        // Read the value and expect it to be 12345
        const value = await simpleStorage.readValue();
        expect(value).to.equal(newValue);
    });
  
    it('should return the address of the contract owner', async () => {
        // Get the owner address stored in the contract
        const contractOwner = await simpleStorage.getOwner();
  
        // Expect the contract owner to be the address that deployed the contract
        expect(contractOwner).to.equal(owner.address);
    });

    it("should change the owner correctly", async () => {
        // Change ownership to a new address
        await simpleStorage.changeOwner("0x95222290DD7278Aa3Ddd389Cc1E1d165CC4BAfe5");
        const updatedOwner = await simpleStorage.getOwner();

        // Expect the contract owner to be the new address
        expect(updatedOwner).to.equal("0x95222290DD7278Aa3Ddd389Cc1E1d165CC4BAfe5");
    });

});

npx hardhat test

echo > scripts/deploy.js

const hre = require("hardhat");

async function deploy() {
    // Deploy the contract
    const SimpleStorage = await hre.ethers.getContractFactory("SimpleStorage");
    const simpleStorage = await SimpleStorage.deploy();

    // Print the deployed contracts address
    console.log("SimpleStorage contract deployed at:", simpleStorage.address);
}

deploy()
    .then(() => console.log("Deployment complete"))
    .catch((error) => console.error("Error deploying contract:", error));

npx hardhat run --network nova scripts/deploy.js

echo > scripts/interactStorage.js

const hre = require("hardhat");

async function main() {
    // Get contract factory for the SimpleStorage contract
    const SimpleStorage = await ethers.getContractFactory("SimpleStorage");

    // Attach to deployed contract at the specified address
    const simpleStorage = await SimpleStorage.attach(
      "DEPLOYED_CONTRACT_ADDRESS" // Your deployed contract address
    );
    
    // Call the readValue function to get the current value
    let getValue = await simpleStorage.readValue();
    console.log("currentValue: ", getValue)

    // Call the setValue function to update the value
    let setValueTx = await simpleStorage.setValue(420)
    console.log("setValue function call. Waiting for confirmation...")

    // Wait 3 blocks for the transaction to be confirmed
    await setValueTx.wait(confirm=3);
    
    // Call the readValue function again to get the latest value
    let latestValue = await simpleStorage.readValue();
    console.log("latestValue: ", latestValue)
}

// Start the script and handle any errors
main()
    .then(() => console.log("Script complete"))
    .catch((error) => console.error("Error running script:", error));

npx hardhat run --network nova scripts/interactStorage.js