Skip to main content

Developer Guide

Build on Inception using the same tools and workflows you already know from Ethereum. This guide covers the essentials for deploying smart contracts and interacting with the Inception network.

Quick Start​

Inception is fully EVM-compatible. If you've built on Ethereum, you can deploy on Inception with minimal changes.

Network Configuration​

Add these values to your development tools:

SettingValue
Network NameInception Mainnet
Chain ID1805
RPC URLhttps://rpc.inceptionera.com
CurrencyINCP
Block Explorerhttps://explorer.inceptionera.com

Supported Tools​

Inception works with all standard Ethereum development tools:

Hardhat​

Update your hardhat.config.js:

module.exports = {
  networks: {
    inception: {
      url: "https://rpc.inceptionera.com",
      chainId: 1805,
      accounts: [process.env.PRIVATE_KEY], // Use environment variables!
    },
  },
  etherscan: {
    apiKey: {
      inception: "YOUR_API_KEY", // For contract verification
    },
    customChains: [
      {
        network: "inception",
        chainId: 1805,
        urls: {
          apiURL: "https://explorer.inceptionera.com/api",
          browserURL: "https://explorer.inceptionera.com"
        }
      }
    ]
  }
};

Deploy your contract:

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

Foundry​

Add Inception to your Foundry project:

# Deploy contract
forge create --rpc-url https://rpc.inceptionera.com \
  --chain-id 1805 \
  --private-key $PRIVATE_KEY \
  src/MyContract.sol:MyContract

# Verify contract
forge verify-contract \
  --chain-id 1805 \
  --etherscan-api-key YOUR_API_KEY \
  CONTRACT_ADDRESS \
  src/MyContract.sol:MyContract

Remix​

  1. Open Remix IDE
  2. Write or import your Solidity contract
  3. Compile the contract
  4. In "Deploy & Run Transactions":
    • Environment: "Injected Provider - MetaMask"
    • Ensure MetaMask is connected to Inception (Chain ID 1805)
  5. Deploy your contract

Contract Verification​

Verify your contracts on the Inception block explorer for transparency and easier interaction.

Etherscan-Compatible API

The Inception explorer supports Etherscan-compatible verification APIs (when live). Use standard Hardhat or Foundry verification workflows. Check the Status page for API availability.

Automatic Verification (Hardhat)​

npx hardhat verify --network inception CONTRACT_ADDRESS "Constructor" "Args"

Manual Verification​

  1. Visit Inception Explorer (when live)
  2. Search for your contract address
  3. Click "Verify & Publish"
  4. Select "Solidity (Single file)" or "Solidity (Standard JSON)"
  5. Enter contract details:
    • Compiler version
    • Optimization settings
    • Constructor arguments (if any)
  6. Upload your contract source code
  7. Submit for verification

Sourcify Compatible​

Inception's explorer supports Sourcify metadata format, making verification seamless with modern Solidity tooling.

Gas and Transactions​

EIP-1559 Fee Model​

Inception uses EIP-1559 for predictable transaction fees:

  • Base Fee: Automatically adjusted based on network congestion
  • Priority Fee: Optional tip to validators for faster inclusion
// Example transaction with EIP-1559
const tx = await contract.someFunction({
  maxFeePerGas: ethers.utils.parseUnits("50", "gwei"),
  maxPriorityFeePerGas: ethers.utils.parseUnits("2", "gwei"),
});

Gas Limits​

Inception has the following gas limits:

  • Block Gas Limit: 30,000,000 gas
  • Block Gas Target: 15,000,000 gas

For complex contracts, estimate gas before deploying:

const gasEstimate = await contract.estimateGas.someFunction(args);
console.log("Estimated gas:", gasEstimate.toString());

Development Best Practices​

Use Environment Variables​

Never commit private keys to version control:

# .env file (add to .gitignore!)
PRIVATE_KEY=0x...
RPC_URL=https://rpc.inceptionera.com
EXPLORER_API_KEY=...
// In your config
require('dotenv').config();

const PRIVATE_KEY = process.env.PRIVATE_KEY;

Test Locally First​

Always test on a local network before deploying:

# Hardhat
npx hardhat test

# Foundry
forge test

Start with Small Amounts​

Deploy with minimal INCP first to test functionality before committing large amounts.

Audit Critical Contracts​

For production applications, especially those handling funds:

  • Get professional security audits
  • Use established libraries (OpenZeppelin)
  • Test extensively
  • Consider bug bounty programs

Interacting with Contracts​

Web3.js​

const Web3 = require('web3');
const web3 = new Web3('https://rpc.inceptionera.com');

const contract = new web3.eth.Contract(ABI, CONTRACT_ADDRESS);

// Read
const value = await contract.methods.getValue().call();

// Write
const tx = await contract.methods.setValue(123).send({
  from: YOUR_ADDRESS,
  gas: 100000,
});

Ethers.js​

const { ethers } = require('ethers');

const provider = new ethers.providers.JsonRpcProvider('https://rpc.inceptionera.com');
const wallet = new ethers.Wallet(PRIVATE_KEY, provider);
const contract = new ethers.Contract(CONTRACT_ADDRESS, ABI, wallet);

// Read
const value = await contract.getValue();

// Write
const tx = await contract.setValue(123);
await tx.wait();

Viem (Modern Alternative)​

import { createPublicClient, createWalletClient, http } from 'viem';
import { inception } from './chains'; // Custom chain config

const publicClient = createPublicClient({
  chain: inception,
  transport: http('https://rpc.inceptionera.com'),
});

const walletClient = createWalletClient({
  chain: inception,
  transport: http('https://rpc.inceptionera.com'),
});

Network Specifications​

Understanding the network helps you optimize your applications:

SpecificationValue
Block Time~12 seconds
Finality~12.8 minutes (64 epochs)
ConsensusProof of Stake (Gasper FFG)
Sustained TPS≈35 TPS
Peak TPS≈120 TPS

Implications:

  • Block confirmations: Most UIs wait for 1-2 blocks (~12-24 seconds)
  • Finality: Critical applications should wait for finality (~12.8 minutes)
  • Transaction throughput: Design for moderate TPS; batch operations when possible

Common Patterns​

Deploy and Initialize Pattern​

// MyContract.sol
contract MyContract {
    address public owner;

    function initialize(address _owner) external {
        require(owner == address(0), "Already initialized");
        owner = _owner;
    }
}
// Deploy script
const contract = await MyContract.deploy();
await contract.deployed();
await contract.initialize(ownerAddress);

Upgradeability (Proxy Pattern)​

Consider using upgradeable contracts for long-term projects:

npm install @openzeppelin/contracts-upgradeable
import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";

contract MyContract is Initializable {
    function initialize() public initializer {
        // Initialization logic
    }
}

Subgraph and Indexing​

For querying blockchain data efficiently, consider:

  • The Graph: Decentralized indexing protocol (check Inception support)
  • Custom indexer: Run your own event indexer
  • Explorer API: Use Inception Explorer's API for basic queries

Frontend Integration​

Connecting to Wallets​

// Request account access
if (window.ethereum) {
  try {
    await window.ethereum.request({ method: 'eth_requestAccounts' });

    // Switch to Inception network
    await window.ethereum.request({
      method: 'wallet_switchEthereumChain',
      params: [{ chainId: '0x70D' }], // 1805 in hex
    });
  } catch (error) {
    // Handle errors
  }
}

Add Network Programmatically​

await window.ethereum.request({
  method: 'wallet_addEthereumChain',
  params: [{
    chainId: '0x70D',
    chainName: 'Inception Mainnet',
    nativeCurrency: {
      name: 'INCP',
      symbol: 'INCP',
      decimals: 18,
    },
    rpcUrls: ['https://rpc.inceptionera.com'],
    blockExplorerUrls: ['https://explorer.inceptionera.com'],
  }],
});

Troubleshooting​

"Insufficient funds for gas"​

Ensure you have INCP for gas fees. See Get INCP guide.

"Invalid chain ID"​

Double-check you're using Chain ID 1805 (not 18050 or 180).

"Nonce too low"​

Your local nonce is out of sync. Reset MetaMask: Settings → Advanced → Reset Account.

"Transaction underpriced"​

Network congestion requires higher gas prices. Increase maxFeePerGas or wait for congestion to clear.

Contract verification fails​

  • Ensure exact compiler version matches
  • Include all imported files
  • Match optimization settings
  • Provide constructor arguments if any

Example: Full Deployment Flow​

# 1. Initialize project
mkdir my-inception-project
cd my-inception-project
npm init -y
npm install --save-dev hardhat

# 2. Initialize Hardhat
npx hardhat

# 3. Write contract in contracts/
# 4. Write deployment script in scripts/
# 5. Configure hardhat.config.js with Inception network
# 6. Deploy
npx hardhat run scripts/deploy.js --network inception

# 7. Verify
npx hardhat verify --network inception CONTRACT_ADDRESS

Resources​

Status Updates

For live endpoints, caps, and incident updates, always check the Inception Status page: https://inceptionera.com/status

Security Considerations​

Smart Contract Security
  • Smart contracts are immutable once deployed
  • Bugs can result in loss of funds
  • Always audit critical contracts
  • Test thoroughly on testnet (when available)
  • Use established patterns and libraries
  • Consider formal verification for high-value contracts

Next Steps​

Need Help?​