Migrate Your EVM dApp to Paxeer

Paxeer offers full EVM bytecode compatibility with fast finality and high throughput. This guide distills what product teams need to do when they already run on Polygon, Base, Ethereum, Arbitrum, Avalanche or another EVM chain and want to bring your dApp stack to Paxeer.

Chain Comparison Overview

Before diving into migration steps, understand how Paxeer compares to your source chain:

Chain-Specific Migration Guides

Select your source chain to see specific migration considerations:

// Before (Ethereum EIP-1559)
const tx = await contract.method({
  maxFeePerGas: ethers.parseUnits('50', 'gwei'),
  maxPriorityFeePerGas: ethers.parseUnits('2', 'gwei')
});

// After (Paxeer - simplified)
const tx = await contract.method({
  gasPrice: ethers.parseUnits('50', 'gwei')
});

Step 1: Evaluate Compatibility

Revisit the Divergence from Ethereum doc and confirm every assumption your contracts/frontends make still holds.

Step 2: Prepare Your Development Environment

Add Paxeer Network Configuration

Hardhat Configuration:

import { defineConfig, configVariable } from 'hardhat/config';
import hardhatToolboxMochaEthers from '@nomicfoundation/hardhat-toolbox-mocha-ethers';

export default defineConfig({
  networks: {
    paxeerMainnet: {
      type: 'http',
      chainId: 125,
      url: 'https://public-rpc.paxeer.app/evm/reference',
      accounts: [configVariable('PAXEER_PRIVATE_KEY')]
    }
  },
  plugins: [hardhatToolboxMochaEthers]
});

Store your deployer key in Hardhat's encrypted keystore with npx hardhat keystore set PAXEER_PRIVATE_KEY. Contract verification via Sourcify is enabled by default in Hardhat 3's hardhat-verify (bundled with the toolbox).

Foundry Configuration:

[profile.default]
src = "src"
out = "out"
libs = ["lib"]

[rpc_endpoints]
paxeer_mainnet = "https://public-rpc.paxeer.app/evm/reference"

# Verification uses Sourcify (no API key needed)
# Run: forge verify-contract --verifier sourcify --chain-id 125 <ADDRESS> <PATH:CONTRACT>

See the Hardhat tutorial and Foundry guide for complete setup instructions.

Wallet Configuration

Pre-configure MetaMask or other wallets with Paxeer chain params:

const paxeerMainnet = {
  chainId: '0x7d', // 125
  chainName: 'Paxeer',
  nativeCurrency: { name: 'Paxeer', symbol: 'HPX', decimals: 18 },
  rpcUrls: ['https://public-rpc.paxeer.app/evm/reference'],
  blockExplorerUrls: ['https://paxscan.io']
};

await window.ethereum.request({
  method: 'wallet_addEthereumChain',
  params: [paxeerMainnet]
});

Step 3: Bootstrap Common Infrastructure

Paxeer already exposes canonical helper contracts - reference them instead of redeploying:

For third-party contracts (LayerZero, Safe, etc.), consult the full Ecosystem Contracts page.

Step 4: Port Contracts and Configuration

Parameterize Chain-Specific Constants

// Example: Chain-aware deadline calculation
function getDeadline(uint256 secondsFromNow) internal view returns (uint256) {
    if (block.chainid == 125) { // Paxeer mainnet
        return block.timestamp + secondsFromNow;
    } else if (block.chainid == 1) { // Ethereum
        return block.timestamp + secondsFromNow;
    }
    return block.timestamp + secondsFromNow;
}

Adjust Gas and Size Assumptions

• Keep gasLimit buffers modest but ensure calldata stays under the block limit
• Large deployments may need batching

Refactor Deprecated Patterns

// Before: SELFDESTRUCT (deprecated)
function destroy() external onlyOwner {
    selfdestruct(payable(owner));
}

// After: Soft close pattern
bool public closed;

function close() external onlyOwner {
    closed = true;
    // Transfer remaining funds
    payable(owner).transfer(address(this).balance);
}

modifier notClosed() {
    require(!closed, "Contract is closed");
    _;
}

Step 5: Plan Bridging and Cross-Chain Connectivity

LayerZero V2

See the complete LayerZero integration guide.

import { EndpointId } from '@layerzerolabs/lz-definitions';

const paxeerContract = {
  eid: EndpointId.PAXEER_V2_MAINNET,
  contractName: 'MyOFT'
};

Other Bridge Options

• Circle CCTP: For USDC bridging (check availability)

Step 6: Handle Assets and Oracles

Oracle Integration

Paxeer supports multiple oracle solutions:

Step 7: Launch Checklist

Mainnet Deployment (chain ID 125)

• Deploy contracts to mainnet (chain ID: 125)
• Run full integration test suite
• Verify contracts via Sourcify
• Test wallet connections and transaction flows
• Validate oracle integrations
• Test cross-chain messaging if applicable
• Re-run smoke tests
• Update frontend configurations
• Prepare user migration documentation

Step 8: Operational Readiness

Contract Verification

Automate verification through CI using Sourcify:

# Foundry verification
forge verify-contract --watch \
  --verifier sourcify \
  --chain-id 125 \
  <CONTRACT_ADDRESS> \
  <CONTRACT_NAME>

RPC and Indexer Health

• Primary RPC: https://public-rpc.paxeer.app/evm/reference
• For mission-critical paths, consider self-hosted nodes or premium RPC providers

Monitoring Gas Parameters

Periodically query fee data to keep dashboards aligned:

// Monitor current gas prices
const feeHistory = await provider.send('eth_feeHistory', ['0x5', 'latest', []]);
const gasPrice = await provider.getGasPrice();

Helpful References

• Divergence from Ethereum - Opcode, gas, and state nuances
• EVM Networks - RPCs, explorers, and MetaMask payloads
• Precompiles - Interoperability patterns
• Ecosystem Contracts - Canonical addresses
• LayerZero Integration - Cross-chain messaging
• Contract Verification - Contract verification guide