Smart Contracts

Deploy, verify, and interact with Solidity contracts on HyperPaxeer

HyperPaxeer is fully EVM-compatible. Running on the Alexandria Fork with Hyperpax-OS Cronos, all standard Ethereum tooling works — Foundry, Hardhat, Remix, ethers.js, wagmi, and viem. Use --legacy --slow flags with Foundry for reliable transaction inclusion.

Overview

Deploy and interact with smart contracts on HyperPaxeer (Chain ID 125). Foundry is the recommended framework; Hardhat and Remix are also supported.

Deployment Options

Hardhat

Deploy with Hardhat

Configure Hardhat to deploy on HyperPaxeer.

1. Install dependencies

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

2. Configure hardhat.config.js

hardhat.config.js

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

module.exports = {
  solidity: "0.8.20",
  networks: {
    paxeer: {
      url: "https://public-rpc.paxeer.app/rpc",
      chainId: 125,
      accounts: [process.env.PRIVATE_KEY]
    }
  },
  etherscan: {
    apiKey: {
      hyperpaxeer: "any-string"
    },
    customChains: [
      {
        network: "hyperpaxeer",
        chainId: 125,
        urls: {
          apiURL: "https://paxscan.io/api",
          browserURL: "https://paxscan.io"
        }
      }
    ]
  }
};

3. Deploy

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

Store your private key in a .env file and never commit it to version control.

Foundry

Deploy with Foundry

Use Foundry to deploy contracts on HyperPaxeer.

1. Install Foundry

curl -L https://foundry.paradigm.xyz | bash
foundryup

2. Create project

forge init my-project
cd my-project

3. Deploy

forge create src/MyContract.sol:MyContract \
  --rpc-url https://public-rpc.paxeer.app/rpc \
  --private-key $PRIVATE_KEY \
  --legacy --slow

Use --verify flag to verify your contract on PaxScan after deployment.

Remix

Deploy with Remix

Use Remix IDE to deploy contracts via MetaMask.

1. Open Remix

   Go to remix.ethereum.org

2. Write or Import Contract

   Write or import your Solidity contract in the file explorer

3. Compile Contract

   Use the Solidity compiler to compile your contract

4. Connect MetaMask

   Connect MetaMask to HyperPaxeer (Chain ID: 125)

5. Select Environment

   In the Deploy & Run tab, select “Injected Provider - MetaMask”

6. Deploy

   Click “Deploy” and confirm the transaction in MetaMask

Make sure your MetaMask is connected to HyperPaxeer (Chain ID 125) before deploying.

Example Contract

Here’s a simple ERC-20 token contract example:

MyToken.sol

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MyToken is ERC20 {
    constructor() ERC20("MyToken", "MTK") {
        _mint(msg.sender, 1000000 * 10 ** decimals());
    }
}

Deploying the Example

Hardhat

scripts/deploy.js

const hre = require("hardhat");

async function main() {
  const MyToken = await hre.ethers.getContractFactory("MyToken");
  const token = await MyToken.deploy();
  await token.waitForDeployment();

  console.log("MyToken deployed to:", await token.getAddress());
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Run the deployment:

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

Foundry

forge create src/MyToken.sol:MyToken \
  --rpc-url https://public-rpc.paxeer.app/rpc \
  --private-key $PRIVATE_KEY \
  --chain-id 125

Verifying Contracts

After deployment, verify your contract on PaxScan for transparency and easier interaction.

Using Hardhat

npx hardhat verify --network paxeer DEPLOYED_CONTRACT_ADDRESS

Using Foundry

forge verify-contract \
  --chain-id 125 \
  --compiler-version v0.8.20 \
  DEPLOYED_CONTRACT_ADDRESS \
  src/MyToken.sol:MyToken \
  --etherscan-api-key YOUR_API_KEY

Interacting with Contracts

Using ethers.js

import { ethers } from 'ethers';

const provider = new ethers.JsonRpcProvider(
  'https://public-rpc.paxeer.app/rpc'
);

const contract = new ethers.Contract(
  contractAddress,
  contractABI,
  provider
);

// Read contract data
const balance = await contract.balanceOf(address);

// Write contract data (requires signer)
const signer = await provider.getSigner();
const contractWithSigner = contract.connect(signer);
await contractWithSigner.transfer(recipientAddress, amount);

Using wagmi

import { useReadContract, useWriteContract } from 'wagmi';

// Read contract
const { data: balance } = useReadContract({
  address: '0x...',
  abi: tokenABI,
  functionName: 'balanceOf',
  args: [userAddress],
});

// Write contract
const { writeContract } = useWriteContract();

function transfer() {
  writeContract({
    address: '0x...',
    abi: tokenABI,
    functionName: 'transfer',
    args: [recipientAddress, amount],
  });
}

Best Practices

Gas Optimization

• Use appropriate data types (uint256 vs uint8)
• Minimize storage writes
• Use events for logging instead of storage
• Batch operations when possible

Security

• Use OpenZeppelin contracts for standards
• Implement access control
• Validate all inputs
• Test thoroughly before mainnet deployment
• Consider getting an audit for critical contracts

Testing

• Write comprehensive unit tests
• Test locally or on private networks before mainnet
• Test edge cases and failure scenarios
• Use fuzzing for complex contracts

Network Information

Parameter	Value
Network Name	HyperPaxeer
RPC URL	https://public-rpc.paxeer.app/rpc
Chain ID	125
Currency	HPX (ahpx, 18 decimals)
Block Explorer	https://paxscan.io

Next Steps

Configuration

Configure different libraries for HyperPaxeer

Examples

View complete integration examples

API Reference

Explore all available RPC methods

Tools

Recommended SDKs and development tools