# Quickstart

Get a Solidity smart contract running on Armchain in just a few minutes. This guide uses Remix IDE and the Armchain Ethers SDK, no complex local setup required.

> **Coming from Ethereum?** The workflow is very similar. The main difference is that Armchain uses ML-DSA44 (post-quantum) signatures instead of ECDSA, so you'll use the Armchain Ethers SDK instead of standard ethers.js for any signing operations.

> **Tooling note**: Hardhat and Foundry do not natively support ML-DSA44 signing. Use **Remix IDE** for contract development and the [**Armchain Ethers SDK**](/developers/overview-1.md) for programmatic interaction.

## Prerequisites

* [Node.js](https://nodejs.org/) v18+
* **Armchain Wallet** browser extension connected to devnet
* Familiarity with Solidity and Ethereum development

## Step 1: Write Your Contract in Remix

1. Open [Remix IDE](https://remix.ethereum.org) in your browser
2. In the **File Explorer**, create a new file: `HelloArmchain.sol`
3. Paste the following contract:

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

contract HelloArmchain {
    string public greeting;
    address public owner;

    event GreetingChanged(string oldGreeting, string newGreeting, address changedBy);

    constructor(string memory _greeting) {
        greeting = _greeting;
        owner = msg.sender;
    }

    function setGreeting(string memory _newGreeting) external {
        string memory oldGreeting = greeting;
        greeting = _newGreeting;
        emit GreetingChanged(oldGreeting, _newGreeting, msg.sender);
    }

    function getGreeting() external view returns (string memory) {
        return greeting;
    }
}
```

## Step 2: Compile

1. Open the **Solidity Compiler** tab in Remix (the `<S>` icon)
2. Select compiler version **0.8.24**
3. Set the EVM version to **london** under Advanced Settings
4. Click **Compile HelloArmchain.sol**

## Step 3: Deploy to Armchain

1. Open the **Deploy & Run Transactions** tab in Remix
2. Under **Environment**, select **Injected Provider**. Remix will connect to your Armchain Wallet
3. Make sure your wallet is connected to the **Armchain Devnet** (Chain ID: 55)
4. In the constructor field, enter `"Hello from Armchain!"`
5. Click **Deploy** and confirm the transaction in your wallet

Your contract address will appear in the **Deployed Contracts** panel.

> For local development without a wallet, see [Fakenet Setup](/node-operators/fakenet.md) to run a local Armchain network and use the SDK directly.

## Step 4: Interact with Your Contract

Use the **Armchain Ethers SDK** to interact with your deployed contract from JavaScript or TypeScript.

Install the SDK:

```bash
npm install @armchain-ethersv6/ethers
```

Then interact with your contract:

```typescript
import { JsonRpcProvider, Wallet, Contract } from "@armchain-ethersv6/ethers";

const provider = new JsonRpcProvider("https://www.armchain.org/devnet");
const wallet = new Wallet(process.env.PRIVATE_KEY, provider);

// Paste the ABI from Remix (Compiler tab → ABI button)
const abi = [
  "function getGreeting() view returns (string)",
  "function setGreeting(string) external",
  "event GreetingChanged(string, string, address)"
];

const contract = new Contract("YOUR_CONTRACT_ADDRESS", abi, wallet);

// Read
const greeting = await contract.getGreeting();
console.log("Current greeting:", greeting);

// Write
const tx = await contract.setGreeting("Quantum-safe greetings!");
await tx.wait();
console.log("Greeting updated!");
```

## Alternative: Hardhat + Armchain Ethers SDK

> **⚠ Partial Compatibility**: Hardhat does not natively support ML-DSA44 signing. `npx hardhat compile` works, but Hardhat's built-in accounts and `hre.ethers` signers use ECDSA and **cannot sign Armchain transactions**. All signing must go through `@armchain-ethersv6/ethers`. Deployment scripts, fork testing, and self-funding are **not supported** via standard Hardhat workflows.

Hardhat can be used for **compilation and project structure**:

```bash
mkdir my-armchain-dapp && cd my-armchain-dapp
npm init -y
npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox
npm install @armchain-ethersv6/ethers
npx hardhat init
```

Configure `hardhat.config.js` for Armchain:

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

module.exports = {
  solidity: {
    version: "0.8.24",
    settings: { evmVersion: "london" },
  },
  networks: {
    armchain: {
      url: "https://www.armchain.org/devnet",
      chainId: 55,
    },
    "armchain-local": {
      url: "http://localhost:4000",
      chainId: 55,
    },
  },
};
```

Compile your contracts:

```bash
npx hardhat compile
```

For deployments, write scripts using `@armchain-ethersv6/ethers` directly instead of `hre.ethers`:

```javascript
// scripts/deploy.js - uses Armchain Ethers SDK for signing, not hre.ethers
import { JsonRpcProvider, Wallet, ContractFactory } from "@armchain-ethersv6/ethers";
import HelloArmchainArtifact from "../artifacts/contracts/HelloArmchain.sol/HelloArmchain.json" assert { type: "json" };

const provider = new JsonRpcProvider("http://localhost:4000");
const wallet = new Wallet(process.env.PRIVATE_KEY, provider);

const factory = new ContractFactory(HelloArmchainArtifact.abi, HelloArmchainArtifact.bytecode, wallet);
const contract = await factory.deploy("Hello from Armchain!");
await contract.waitForDeployment();
console.log("Deployed to:", await contract.getAddress());
```

> **Note**: Do not use `hre.ethers.getSigners()`, `hre.ethers.getContractFactory()`, or `deployer.sendTransaction()`. These all use ECDSA and will fail on Armchain.

## Next Steps

* [Network Configuration](/get-started/network-configuration.md) for RPC endpoints, chain details, and wallet setup
* [Smart Contract Development](/developers/overview.md) for contract patterns and best practices
* [Armchain Ethers SDK](/developers/overview-1.md) for the full SDK reference
* [Understanding PQC](/pqc/overview.md) to learn about the cryptography powering Armchain


---

# 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.armchain.org/get-started/quickstart.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.