Deploy Smart Contract On Polygon

This guide covers adding the network to a browser wallet, then deploying a simple contract using Foundry and Hardhat — pick whichever you prefer.

Polygon is an EVM-compatible chain, so smart contracts written in Solidity or Vyper deploy without modification using standard tooling: Foundry, Hardhat, or Remix.

Prerequisites

Before deploying, you'll need:

• A wallet with ETH on the target network for gas. See Add Network to Your Wallet below.

• A GetBlock access token — sign up at Dashboard and create an Ethereum endpoint in the dashboard. Every code sample below uses <ACCESS-TOKEN> as the placeholder.

• Node.js 20 or newer installed (for Hardhat).

• A funded deployer address. For testnets, use the faucet page

Network Details

Property	Ethereum Mainnet	amoy Testnet
Chain ID	137 (0x137)	80002(0x13882)
RPC URL	https://go.getblock.io/<ACCESS-TOKEN>/	https://go.getblock.io/<ACCESS-TOKEN>/
Currency Symbol	ETH	ETH
Block Explorer	https://polygonscan.com/	https://amoy.polygonscan.com/

Deploy to a testnet first. Every command below defaults to Mainnet — replace the environment variable values with testnet ones for a dry run before touching real ETH.

Never commit a real private key. Use environment variables and prefer a throwaway deployer key for testing. Private keys committed to a public repo are drained within seconds by automated bots.

Add Network to Your Wallet

If the automatic button isn't available or the request is rejected, add the network manually:

1. Open MetaMask (or your EVM wallet of choice).

2. Click the network dropdown at the top of the wallet.

3. Click Add network → Add a network manually.

4. Enter the network details from the Network Details table above.

5. Save and switch to the newly added network.

How to Deploy a Smart Contract

Foundry

Foundry is a fast, minimal Solidity toolchain. It's the recommended path if you want deterministic, script-based deployments without any Node.js dependencies.

1

Install Foundry

If Foundry is already installed, skip this step:

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

# Install forge, anvil, cast, and chisel
foundryup

2

Create a project

# Initialize a new project
mkdir Poly-deploy && cd Poly-deploy
forge init

3

Create a contract

Create src/HelloEthereum.sol with the following content:

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.30;

contract HelloPolygon {
    function hello() external pure returns (string memory) {
        return "Hello, Polygon!";
    }
}

4

Deploy

Set environment variables, then deploy:

# Set environment variables
export PRIVATE_KEY=0x<your_private_key>
export POLY_RPC_URL=https://go.getblock.io/<ACCESS-TOKEN>/

# Deploy contract
forge create HelloEthereum \
  --rpc-url $POLYGON_RPC_URL \
  --private-key $PRIVATE_KEY \
  --broadcast

The command prints the deployed contract address on success.

5

Verify on Polyscan

Polyscan uses a unified V2 API across all Ethereum networks. Get an API key from polygonscan.com/api, then:

# Verify the contract on Polyscan (Mainnet — chain-id 137)
forge verify-contract <contract_address> \
  src/HelloPolygon.sol:HelloPolygon\
  --chain-id 137 \
  --polyscan-api-key $POLYSCAN_API_KEY

For Amoy use --chain-id 80002; view your contract at https://polygonscan.com/address/<contract_address> (or the corresponding testnet explorer).

Hardhat

Hardhat is a JavaScript/TypeScript-based smart contract framework. It's the recommended path if your project already uses Node.js tooling and you want tight integration with test suites, plugins, and TypeScript typings.

1

Create a project

Initialize your environment and Hardhat project:

# Initialize project and install Hardhat
mkdir poly-deploy && cd poly-deploy
npm init -y
npm install --save-dev hardhat
npx hardhat init

Select Create a JavaScript project (or TypeScript if preferred) when prompted.

2

Configure Ethereum networks

Update hardhat.config.js with the network settings and Etherscan API for verification:

hardhat.config.js

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

module.exports = {
  solidity: "0.8.30",
  networks: {
    mainnet: {
      url: process.env.POLY_RPC_URL,
      chainId: 137,
      accounts: [process.env.PRIVATE_KEY],
    },
    amoy: {
      url: process.env.POLY_RPC_URL,
      chainId: 80002,
      accounts: [process.env.PRIVATE_KEY],
    },
  }
};

Set your environment variables before proceeding:

export PRIVATE_KEY=0x<your_private_key>
export POLY_RPC_URL=https://go.getblock.io/<ACCESS-TOKEN>/
export POLYSCAN_API_KEY=<your_polyscan_v2_api_key>

3

Create a contract

Create contracts/HelloEthereum.sol:

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.30;

contract HelloPolygon {
    function hello() external pure returns (string memory) {
        return "Hello, Polygon!";
    }
}

4

Compile and Deploy

Create scripts/deploy.js:

scripts/deploy.js

const hre = require("hardhat");

async function main() {
  const contract = await hre.ethers.deployContract("HelloPolygon");
  await contract.waitForDeployment();
  console.log("Deployed to:", await contract.getAddress());
}

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

Compile and deploy:

# Compile
npx hardhat compile

# Deploy to Amoy (recommended first)
npx hardhat run scripts/deploy.js --network amoy

# Or deploy to Mainnet when ready
npx hardhat run scripts/deploy.js --network mainnet

5

Verify on Polyscan

# Verify on the network you deployed to
npx hardhat verify --network amoy <contract_address>

After verification, view your contract at the corresponding block explorer:

• Mainnet: https://polyscan.com/address/<contract_address>

• Sepolia: https://amoy.polyscan.com/address/<contract_address>