# Your first EVM Smart Contract

## Your First Smart Contract

### Overview

In this guide, we'll create, deploy, and interact with a simple smart contract on UOMI's EVM network using Hardhat. We'll build a basic "Counter" contract that can increment and retrieve a number.

### Prerequisites

Before starting, ensure you have:

* Node.js installed
* A code editor (VS Code recommended)
* A MetaMask wallet with some test tokens
* Basic knowledge of Solidity

### Project Setup

1. Create a new directory and initialize the project:

```bash
mkdir counter-contract
cd counter-contract
npm init -y
```

2. Install required dependencies:

```bash
npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox
```

3. Create a Hardhat project:

```bash
npx hardhat init
```

Select "Create a JavaScript project" when prompted.

### Writing the Contract

Create a new file `contracts/Counter.sol`:

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

contract Counter {
    uint256 private count;
    
    // Event to emit when the counter changes
    event CountUpdated(uint256 newCount);
    
    constructor() {
        count = 0;
    }
    
    function increment() public {
        count += 1;
        emit CountUpdated(count);
    }
    
    function getCount() public view returns (uint256) {
        return count;
    }
}
```

### Deployment Script

Create/modify `scripts/deploy.js`:

```javascript
async function main() {
  const Counter = await ethers.getContractFactory("Counter");
  const counter = await Counter.deploy();
  await counter.waitForDeployment();

  console.log("Counter deployed to:", await counter.getAddress());
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
```

### Test the Contract

Create `test/Counter.js`:

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

describe("Counter", function () {
  let counter;

  beforeEach(async function () {
    const Counter = await ethers.getContractFactory("Counter");
    counter = await Counter.deploy();
  });

  it("Should start with count of 0", async function () {
    expect(await counter.getCount()).to.equal(0);
  });

  it("Should increment count", async function () {
    await counter.increment();
    expect(await counter.getCount()).to.equal(1);
  });
});
```

Run the tests:

```bash
npx hardhat test
```

### Deploy to Testnet

1. Configure your network in `hardhat.config.js`:

```javascript
require("@nomicfoundation/hardhat-toolbox");

// Go to https://finney.uomi.ai and replace this with your own RPC URL
const FINNEY_RPC_URL = "https://finney.uomi.ai";

// Replace this private key with your own
// To export your private key from Metamask, go to Account Details > Export Private Key
const PRIVATE_KEY = "YOUR-METAMASK-PRIVATE-KEY";

module.exports = {
  solidity: "0.8.19",
  networks: {
    finney: {
      url: FINNEY_RPC_URL,
      accounts: [PRIVATE_KEY],
    },
  },
};
```

2. Deploy to Finney testnet:

```bash
npx hardhat run scripts/deploy.js --network finney
```

### Interact with Your Contract

After deployment, you can interact with your contract using:

1. The Hardhat console:

```bash
npx hardhat console --network finney
```

2. Example interactions:

```javascript
// Get the contract
const Counter = await ethers.getContractFactory("Counter");
const counter = await Counter.attach("YOUR-DEPLOYED-CONTRACT-ADDRESS");

// Get the current count
const count = await counter.getCount();
console.log("Current count:", count);

// Increment the counter
await counter.increment();
```

### Next Steps

Now that you've deployed your first contract, you can:

1. Add more functionality to your contract
2. Create a frontend to interact with it
3. Learn about contract security and best practices
4. Explore more complex smart contract patterns

### Common Issues and Solutions

> ⚠️ **Common Problems**
>
> * **Transaction Failed**: Make sure you have enough tokens for gas
> * **Contract Not Found**: Verify the contract address is correct
> * **Network Issues**: Ensure you're connected to the correct network

### Resources

* [Solidity Documentation](https://docs.soliditylang.org/)
* [Hardhat Documentation](https://hardhat.org/getting-started/)
* [OpenZeppelin Contracts](https://docs.openzeppelin.com/contracts/)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.uomi.ai/build/evm-smart-contracts/your-first-evm-smart-contract.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.