Developing your first app

​

Setting up the Timelock Wallet project

• Set up a complete development environment using Hardhat
• Configure your wallet and obtain test NEX tokens
• Write, compile, and deploy a timelock smart contract
• Verify your contract on the Nexus blockchain
• Interact with your deployed contract through scripts

• Creating savings accounts with built-in discipline
• Setting up vesting schedules for tokens
• Building escrow mechanisms for time-sensitive agreements

​

What Is a Smart Contract?

“If this happens, then do that” — enforced by code and trustless infrastructure.

​

Analogy: A Digital Vending Machine

1. You insert $1 and select a soda.
2. The machine checks your input.
3. If the condition (enough money + valid selection) is true, it dispenses the soda.
4. If not, it does nothing or gives your money back.

• Input: A user sends funds or data to the contract.
• Condition: The contract checks the terms (e.g., “Has the payment been made?”).
• Action: If conditions are met, it executes the logic (e.g., transfers ownership, sends tokens).

​

How It Works (Technically)

• Written in code (like Solidity for Ethereum).
• Deployed to a blockchain, where it gets an address.
• Interacts with users or other contracts via transactions that other users send to its address.
• Immutable: Once deployed, you can’t alter it (unless you build upgradeable patterns).
• Transparent: Anyone can read the code and verify what it does.

​

Key Components of a Smart Contract

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

contract SimpleStorage {
    // State Variables
    uint256 private storedData;
    
    // Events
    event DataStored(uint256 newValue);
    
    // Constructor
    constructor() {
        storedData = 0;
    }
    
    // Functions
    function set(uint256 x) public {
        storedData = x;
        emit DataStored(x);
    }
    
    function get() public view returns (uint256) {
        return storedData;
    }
}

1. License and Version
   • // SPDX-License-Identifier: MIT: Specifies the license
   • pragma solidity ^0.8.0: Specifies the Solidity version
2. State Variables
   • Variables that are permanently stored in contract storage
   • Example: uint256 private storedData
   • Can be marked as public, private, or internal
3. Events
   • Used to log important actions on the blockchain
   • Example: event DataStored(uint256 newValue)
   • Help frontend applications track contract state changes
4. Constructor
   • Runs once when the contract is deployed
   • Used for initial setup
   • Example: constructor() { storedData = 0; }
5. Functions
   public: Can be called by anyone

   Copy

   Ask AI

   contract PublicFunctionExample {
       // Public function - can be called by anyone
       function publicFunction() public {
           // This function can be called by:
           // 1. Other contracts
           // 2. External accounts
           // 3. The contract itself
       }
       
       // Public state variable - automatically creates a getter function
       uint256 public number;
       
       // Internal function - can only be called within the contract
       function internalFunction() internal {
           // This can only be called by other functions in this contract
       }
   }
   

   Public functions:

   • Can be called by anyone (external accounts, other contracts)
   • Can be called by the contract itself
   • Are part of the contract’s external interface
   • Generate more bytecode than internal functions
   • Are more gas-expensive than internal functions

   Common use cases:

   • External contract interactions
   • User-facing functions
   • Functions that need to be called by other contracts
   • Functions that implement external interfaces
   private: Can only be called within the contract

   Copy

   Ask AI

   contract PrivateFunctionExample {
       // Private function - can only be called within this contract
       function privateFunction() private {
           // This function can only be called by other functions
           // in this specific contract
       }
       
       // Internal function - can be called by this contract and derived contracts
       function internalFunction() internal {
           // This can be called by this contract and any contracts
           // that inherit from this contract
       }
       
       function publicFunction() public {
           // Can call private functions
           privateFunction();
       }
   }
   

   Private functions:

   • Can only be called within the same contract
   • Cannot be called by derived contracts
   • Are more restrictive than internal functions
   • Are gas-efficient for internal operations
   • Help with code organization and security

   Common use cases:

   • Internal helper functions
   • Security-sensitive operations
   • Functions that should never be exposed externally
   • Code that should not be inherited
   view: Doesn't modify state

   Copy

   Ask AI

   contract ViewFunctionExample {
       uint256 public number;
       
       // View function - reads state but doesn't modify it
       function getNumber() public view returns (uint256) {
           return number;  // Reads state but doesn't modify it
       }
       
       // Not view - modifies state
       function setNumber(uint256 newNumber) public {
           number = newNumber;  // Modifies state
       }
       
       // View function can call other view functions
       function getNumberPlusOne() public view returns (uint256) {
           return getNumber() + 1;
       }
   }
   

   View functions:

   • Can read contract state
   • Cannot modify contract state
   • Are gas-efficient for read operations
   • Can be called without a transaction
   • Can call other view functions
   • Can call pure functions

   Common use cases:

   • Reading contract state
   • Computing values based on state
   • Data validation that requires state
   • Getter functions
   • Status checks
   pure: Doesn't read or modify state

   Copy

   Ask AI

   contract PureFunctionExample {
       // Pure function - only performs computation
       function add(uint256 a, uint256 b) public pure returns (uint256) {
           return a + b;
       }
       
       // Not pure - reads state variable
       uint256 public number;
       function addToNumber(uint256 a) public view returns (uint256) {
           return a + number;  // Reads state, so it's view, not pure
       }
       
       // Not pure - modifies state
       function setNumber(uint256 newNumber) public {
           number = newNumber;  // Modifies state, so it's not pure or view
       }
   }
   

   Pure functions:

   • Only perform computations
   • Don’t read from blockchain state
   • Don’t modify blockchain state
   • Are gas-efficient for read operations
   • Can be called without a transaction
   • Are deterministic (same input always produces same output)

   Common use cases:

   • Mathematical calculations
   • String manipulation
   • Data validation
   • Hash computations
   • Any computation that doesn’t need blockchain data

​

Setting Up Your Development Environment

​

1. Install Required Tools

# Install Node.js and npm if not already installed
# Then install Hardhat
npm install --save-dev hardhat

​

2. Create a New Project

# Create a new directory
mkdir my-first-contract
cd my-first-contract

# Initialize a Node.js project with package.json
npm init -y

# Initialize a new Hardhat project
npx hardhat

​

3. Configure Hardhat for Nexus

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

module.exports = {
  solidity: "0.8.20",
  networks: {
    nexus: {
      url: "https://testnet3.rpc.nexus.xyz",
      chainId: 3940,
      accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : []
    }
  }
};

​

4. Configure your private key in .env file

1. Get your private key from Nexus
   • Go to the Nexus Web App
   • Sign in to your account in the top right corner
   • Click the “Settings” tab
   • Navigate to “Account & Security”
   • Click on “Private Key”
   • Click “Reveal” to view your private key
2. Create your .env file
   • Create a new file named .env in your project root directory
   • Add your private key in this format:
   Copy

   Ask AI

   PRIVATE_KEY=your_private_key_here
   

3. Install dotenv package
   Copy

   Ask AI

   npm install dotenv
   

4. Update hardhat.config.js
   • Add this line at the top of your hardhat.config.js if not already present:
   Copy

   Ask AI

   require("dotenv").config();
   

• Never share your private key
• Never commit it to version control
• Keep it secure and backed up
• Use a test account for development

​

5. Receive test NEX from a faucet for contract deployment

1. Earn NEX through Proving
   • Submit proofs to earn points and NEX in real-time
   • This is the recommended way as it helps secure the network
   • For detailed instructions on proving, visit our Proving Guide
2. Use the Nexus Faucet
   • A faucet is a service that provides small amounts of cryptocurrency for testing.
   • It’s like a water faucet, but instead of water, it dispenses test tokens
   • Visit our Faucet to receive test NEX

​

Writing and Deploying Your First Contract

​

1. Create a Contract File

• A future unlockTime (timestamp),
• And an ETH payment (payable constructor).

• Time-based escrow
• Delayed disbursements or vesting
• Testing ETH flow logic with time-based constraints

contract Lock {
    uint public unlockTime;
    address payable public owner;

    event Withdrawal(uint amount, uint when);

    constructor(uint _unlockTime) payable {
        require(
            block.timestamp < _unlockTime,
            "Unlock time should be in the future"
        );

        unlockTime = _unlockTime;
        owner = payable(msg.sender);
    }

    function withdraw() public {
        // Uncomment this line, and the import of "hardhat/console.sol", to print a log in your terminal
        // console.log("Unlock time is %o and block timestamp is %o", unlockTime, block.timestamp);

        require(block.timestamp >= unlockTime, "You can't withdraw yet");
        require(msg.sender == owner, "You aren't the owner");

        emit Withdrawal(address(this).balance, block.timestamp);

        owner.transfer(address(this).balance);
    }
}

​

2. Create a Deployment Script

• Automate contract deployment
• Set constructor arguments dynamically
• Log or save deployed addresses
• Chain deployments in a predictable order
• Integrate easily into testing, development, or CI/CD pipelines

const hre = require("hardhat");

async function main() {
  console.log("Deploying Lock contract...");

  // Get the contract factory
  const Lock = await hre.ethers.getContractFactory("Lock");
  
  // Deploy the contract
  // The constructor requires a timestamp for the unlock time
  const unlockTime = Math.floor(Date.now() / 1000) + 60 * 60 * 24 * 365; // 1 year from now
  const lock = await Lock.deploy(unlockTime);

  // Wait for deployment to finish
  await lock.waitForDeployment();

  const lockAddress = await lock.getAddress();
  console.log(`Lock contract deployed to: ${lockAddress}`);

  // Wait for a few block confirmations before verifying
  console.log("Waiting for block confirmations...");
  await new Promise(resolve => setTimeout(resolve, 30000)); // Wait 30 seconds

  // Verify the contract
  console.log("Verifying contract...");
  try {
    await hre.run("verify:verify", {
      address: lockAddress,
      constructorArguments: [unlockTime],
    });
    console.log("Contract verified successfully");
  } catch (error) {
    if (error.message.includes("Already Verified")) {
      console.log("Contract is already verified!");
    } else {
      console.error("Error verifying contract:", error);
    }
  }
}

// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
}); 

• It handles constructor parameters (unlockTime)
• Manages asynchronous deployment logic with await
• Provides helpful logs to track progress
• Prepares for contract verification (though it may be disabled or optional in some cases)

​

Deploying Your Contract

​

1. Deploy to Nexus

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

Deploying Lock contract...
Lock contract deployed to: 0x...  # Your contract's address will appear here

​

2. Examine Lock contract on the Nexus Explorer

• View all transactions
• Check contract code
• Monitor contract interactions
• Track token transfers
• View account balances

1. Copy your contract’s address from the deployment output
2. Paste it into the search bar at the top of the explorer
3. Click on your contract to view its details

• Contract code (verified)
• Transaction history
• Contract balance
• Recent interactions
• Event logs

​

Project Structure

my-first-contract/
├── contracts/
│   └── Lock.sol
├── scripts/
│   └── deploy.js
├── .env
├── hardhat.config.js
└── package.json

• contracts/: Contains your Solidity smart contracts
• scripts/: Contains deployment and interaction scripts
• .env: Stores your private key and other sensitive data
• hardhat.config.js: Configures your development environment
• package.json: Manages your project dependencies

​

Conclusion and Next Steps

• Set up your development environment
• Created and deployed your first smart contract
• Verified your contract on the Nexus Explorer

1. Learn More
   • Read the Solidity Documentation
   • Study OpenZeppelin Contracts, a widely-used, open-source library of secure and reusable smart contracts written in Solidity.
   • Join the Nexus Discord community for:
     • Frequent build events
     • Developer rewards
     • Technical discussions
     • Community support
2. Build More
   • Try deploying more complex contracts (see additional guides)
   • Build a full-stack dApp