Why We Chose Polygon for Our Blockchain Layer

Scenario: 10,000 records per day

Gas per transaction:        ~50,000 gas
Average gas price:          30 gwei
ETH price:                  $3,000

Cost per transaction:       50,000 × 30 × 10⁻⁹ × $3,000
                          = $4.50 per transaction

With Merkle batching (256 records/TX):
  Daily transactions:       10,000 ÷ 256 = 40 TXs
  Daily cost:              40 × $4.50 = $180/day
  Monthly cost:            $5,400/month

// Too expensive for most use cases

Scenario: 10,000 records per day

Gas per transaction:        ~52,000 gas
Average gas price:          30 gwei (similar to Ethereum)
MATIC price:                $1.00

Cost per transaction:       52,000 × 30 × 10⁻⁹ × $1.00
                          = $0.00156 per transaction
                          ≈ $0.001 per transaction

With Merkle batching (256 records/TX):
  Daily transactions:       10,000 ÷ 256 = 40 TXs
  Daily cost:              40 × $0.001 = $0.04/day
  Monthly cost:            $1.20/month

Cost per record:           $0.04 ÷ 10,000 = $0.000004

// 4,500x cheaper than Ethereum mainnet!

import { ethers } from 'ethers';

// Same code works for both networks - just change RPC URL
const provider = new ethers.JsonRpcProvider(
  'https://polygon-mainnet.infura.io/v3/YOUR_KEY'  // Polygon
  // 'https://mainnet.infura.io/v3/YOUR_KEY'       // Ethereum
);

const wallet = new ethers.Wallet(privateKey, provider);

// Deploy contract - identical on both chains
const AnchoraAnchor = await ethers.getContractFactory('AnchoraAnchor');
const contract = await AnchoraAnchor.deploy();

// Anchor Merkle root - same interface
const tx = await contract.anchorRoot(merkleRoot, recordCount);
const receipt = await tx.wait();

console.log('Block:', receipt.blockNumber);
console.log('Gas used:', receipt.gasUsed.toString());

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

contract AnchoraAnchor {
    struct Batch {
        bytes32 merkleRoot;
        uint256 timestamp;
        address operator;
        uint256 recordCount;
    }

    mapping(uint256 => Batch) public batches;
    uint256 public totalBatches;

    event RootAnchored(
        uint256 indexed batchId,
        bytes32 merkleRoot,
        uint256 timestamp,
        address operator,
        uint256 recordCount
    );

    /// @notice Anchor a Merkle root to the blockchain
    /// @param _merkleRoot The root hash of the Merkle tree
    /// @param _recordCount Number of records in this batch
    function anchorRoot(
        bytes32 _merkleRoot,
        uint256 _recordCount
    ) external returns (uint256 batchId) {
        batchId = totalBatches++;

        batches[batchId] = Batch({
            merkleRoot: _merkleRoot,
            timestamp: block.timestamp,
            operator: msg.sender,
            recordCount: _recordCount
        });

        emit RootAnchored(
            batchId,
            _merkleRoot,
            block.timestamp,
            msg.sender,
            _recordCount
        );
    }

    /// @notice Verify a Merkle proof on-chain
    function verifyProof(
        uint256 _batchId,
        bytes32 _leaf,
        bytes32[] calldata _proof
    ) external view returns (bool) {
        bytes32 computedRoot = _leaf;

        for (uint256 i = 0; i < _proof.length; i++) {
            bytes32 proofElement = _proof[i];

            if (computedRoot < proofElement) {
                computedRoot = keccak256(
                    abi.encodePacked(computedRoot, proofElement)
                );
            } else {
                computedRoot = keccak256(
                    abi.encodePacked(proofElement, computedRoot)
                );
            }
        }

        return computedRoot == batches[_batchId].merkleRoot;
    }

    /// @notice Get batch details
    function getBatch(uint256 _batchId)
        external
        view
        returns (
            bytes32 merkleRoot,
            uint256 timestamp,
            address operator,
            uint256 recordCount
        )
    {
        Batch storage batch = batches[_batchId];
        return (
            batch.merkleRoot,
            batch.timestamp,
            batch.operator,
            batch.recordCount
        );
    }
}

1. LOCAL DEVELOPMENT
   └─ Hardhat local node (instant transactions, free)
   └─ Unit tests with Hardhat

2. TESTNET (Polygon Amoy)
   └─ Free MATIC from faucet
   └─ Real network conditions
   └─ View transactions on amoy.polygonscan.com

3. MAINNET (Polygon PoS)
   └─ Real MATIC (~$1 per token)
   └─ ~$0.001 per transaction
   └─ View on polygonscan.com

Configuration in hardhat.config.js:
─────────────────────────────────

networks: {
  hardhat: {},  // Local testing

  amoy: {  // Testnet
    url: "https://polygon-amoy.infura.io/v3/KEY",
    accounts: [TESTNET_PRIVATE_KEY]
  },

  polygon: {  // Mainnet
    url: "https://polygon-mainnet.infura.io/v3/KEY",
    accounts: [MAINNET_PRIVATE_KEY]
  }
}

Transaction Hash: 0xb706858a2c9e4a8e3d5f9c1a2b3d4e5f...
Block Number:     45,123,789
Timestamp:        Jan 18, 2026 10:30:45 AM UTC
From:             0x742d35Cc6634C0532925a3b844Bc9e7595f...
To:               0xAnchoraContract...
Value:            0 MATIC
Gas Used:         52,341
Gas Price:        30 gwei
Transaction Fee:  0.00157023 MATIC (~$0.00157)

Input Data:
  Function: anchorRoot(bytes32,uint256)
  merkleRoot: 0x9876543210fedcba9876543210fedcba...
  recordCount: 256

Event Emitted:
  RootAnchored(
    batchId: 30,
    merkleRoot: 0x9876...,
    timestamp: 1737196245,
    operator: 0x742d35...,
    recordCount: 256
  )

View at: https://polygonscan.com/tx/0xb706858a...