Smart Contracts

Deploy and interact with smart contracts on Paxeer Network

Paxeer Network is fully compatible with Ethereum smart contracts and tooling.

Overview

Deploy and interact with smart contracts on Paxeer Network. Fully EVM-compatible with Ethereum tooling including Hardhat, Foundry, and Remix.

Deployment Options

Hardhat

Deploy with Hardhat

Configure Hardhat to deploy on Paxeer Network.

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: 229,
      accounts: [process.env.PRIVATE_KEY]
    }
  },
  etherscan: {
    apiKey: {
      paxeer: "YOUR_API_KEY"
    },
    customChains: [
      {
        network: "paxeer",
        chainId: 229,
        urls: {
          apiURL: "https://scan.paxeer.app/api",
          browserURL: "https://scan.paxeer.app"
        }
      }
    ]
  }
};

3. Deploy

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

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 Paxeer Network.

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 \
  --chain-id 229

Use --verify flag to verify your contract on PaxeerScan 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 Paxeer Network (Chain ID: 229)

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 Paxeer Network 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 229

Verifying Contracts

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

Using Hardhat

npx hardhat verify --network paxeer DEPLOYED_CONTRACT_ADDRESS

Using Foundry

forge verify-contract \
  --chain-id 229 \
  --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 on testnet before mainnet
• Test edge cases and failure scenarios
• Use fuzzing for complex contracts

Network Information

Parameter	Value
Network Name	Paxeer Network
RPC URL	https://public-rpc.paxeer.app/rpc
Chain ID	229
Currency	PAX
Block Explorer	https://scan.paxeer.app

Next Steps

Configuration

Configure different libraries for Paxeer Network

Examples

View complete integration examples

API Reference

Explore all available RPC methods

Tools

Recommended SDKs and development tools