Deploy your first contract

Choose between using testnet or a local node.

Review the smart contract code

The quickstart contract is a basic ERC-20 token built with OpenZeppelin. The entire code is as follows:

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";

contract QuickstartToken is ERC20, Ownable, ERC20Burnable {
    constructor(string memory name, string memory symbol) ERC20(name, symbol) Ownable(msg.sender) {
        _mint(msg.sender, 100 * 10 ** decimals());
    }

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
}

The contract:

imports helper contracts from @openzeppelin/contracts so that our contract is a standard ERC-20 contract, has an owner, and allows to tokens to be burned
sets the token name to the symbol using the constructor arguments
sets the deployer wallet as the owner
mints an initial supply of 100 tokens to the deployer
only allows the owner to mint additional tokens using the mint function

The ERC20 token code is provided “as is” without any express or implied warranties.

Regulations governing digital assets are still unclear in many jurisdictions.
ERC20 tokens may possess unique legal, tax, and market risks, so it is up to you to determine which, if any, laws apply to your deployment of ERC20 tokens.
The developers and publishers of this software disclaim any liability for any legal issues that may arise from its use.

Project setup

Choose between using Foundry or Hardhat.

If you don't already have forge installed, you can install it via foundryup.

Create a new foundry project:

forge init QuickstartToken

cd QuickstartToken

Install OpenZeppelin Contracts.
```
forge install OpenZeppelin/openzeppelin-contracts
```
Once installed, add a remappings.txt file and add this line:
```
@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/
```
Create a new file in the src folder called QuickstartToken.sol.
Copy and paste the QuickstartToken contract above into the QuickstartToken.sol file.
Create a new file in the script folder called QuickstartToken.s.sol.

Copy and paste the script below into QuickstartToken.s.sol. This script will be used to deploy the contract.

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

import {Script} from "forge-std/Script.sol";
import {QuickstartToken} from "../src/QuickstartToken.sol";

contract QuickstartTokenScript is Script {
    QuickstartToken public quickstartToken;

    function setUp() public {}

    function run() public {
        vm.startBroadcast();

        quickstartToken = new QuickstartToken("Quickstart Token", "QKT");

        vm.stopBroadcast();
    }
}

Build the project.
```
forge build
```
Set your private key for deploying. Get this from your browser wallet for the same account where you bridged testnet ETH.
```
export TESTNET_PRIVATE_KEY="0x..."
```

Deploy the contract using the command below. Your contract address will be logged in the output.

forge script script/QuickstartToken.s.sol --rpc-url https://zksync-os-testnet-alpha.zksync.dev --broadcast --skip-simulation --private-key $TESTNET_PRIVATE_KEY

(Optional) Verify the contract. This will allow you to see the contract code in the block explorer. Replace 0x<YOUR_CONTRACT_ADDRESS> with your deployed contract address from the previous step.

forge verify-contract \
--chain-id 8022833 \
--verifier custom \
--verifier-url https://block-explorer-api.zksync-os-testnet-alpha.zksync.dev/api \
0x<YOUR_CONTRACT_ADDRESS> \
src/QuickstartToken.sol:QuickstartToken

Verify if the contract was successfully verified by searching for your contract address on the testnet block explorer and clicking on the "Contract" tab.

Create a new project folder

mkdir hardhat-example
cd hardhat-example

Initialize a new Hardhat 3 project. You can choose to either use Mocha with Ethers.js or Node Test Runner with viem. Select y to install the dependencies.
```
npx hardhat --init
```
Install OpenZeppelin Contracts.
```
npm install @openzeppelin/contracts
```

Add ZKsync OS to the hardhat.config.ts file and configure the ignition required confirmations.

hardhat.config.ts

  ignition: {
    requiredConfirmations: 1,
  },
  networks: {
    zksyncOS: {
      type: 'http',
      chainType: 'generic',
      url: 'https://zksync-os-testnet-alpha.zksync.dev',
      accounts: [configVariable('TESTNET_PRIVATE_KEY')],
    },
  },

Add your private key to the Hardhat keystore as TESTNET_PRIVATE_KEY. If you've never used hardhat keystore before, you will be asked to set up a password. Get the private key from your browser wallet for the same account where you bridged testnet ETH.
```
npx hardhat keystore set TESTNET_PRIVATE_KEY
```
Create a new file in the contracts folder called QuickstartToken.sol.
Copy and paste the QuickstartToken contract above into the QuickstartToken.sol file.
Create a new file in the ignition/modules folder called QuickstartToken.ts.

Copy and paste the ignition module below into QuickstartToken.ts. This will be used to deploy the contract.

import { buildModule } from '@nomicfoundation/hardhat-ignition/modules';

export default buildModule('QuickstartToken', (m) => {
  const quickstartToken = m.contract('QuickstartToken', ['Quickstart Token', 'QKT']);

  return { quickstartToken };
});

Compile and deploy the contract. Your contract address will be logged in the output.
```
npx hardhat compile
```
```
npx hardhat ignition deploy ignition/modules/QuickstartToken.ts --network zksyncOS
```

Verify the contract

You can optionally verify the contract so the code shows on the block explorer.

Install the Hardhat verify SDK:

npm install --save-dev @nomicfoundation/hardhat-verify

Add hardhatVerify to the hardhat plugins and configure the verification endpoint:

hardhat.config.ts

import hardhatVerify from "@nomicfoundation/hardhat-verify";

const config: HardhatUserConfig = {
plugins: [
    hardhatVerify,
    // ...other plugins...
],
// ...other config...
  chainDescriptors: {
    8022833: {
      name: 'zksyncOS',
      blockExplorers: {
        blockscout: {
          name: 'Testnet Explorer',
          url: 'https://zksync-os-testnet-alpha.staging-scan-v2.zksync.dev',
          apiUrl: 'https://block-explorer-api.zksync-os-testnet-alpha.zksync.dev/api',
        },
      },
    },
  },
};

Use your deployed contract address to verify using hardhat-verify:

npx hardhat clean
npx hardhat compile --build-profile production
npx hardhat verify --build-profile production --network zksyncOS 0x<YOUR_CONTRACT_ADDRESS> "Quickstart Token" "QKT"

Verify if the contract was successfully verified by searching for your contract address on the block explorer and clicking on the "Contract" tab.

Review the smart contract code

The quickstart contract is a basic ERC-20 token built with OpenZeppelin. The entire code is as follows:

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

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";

contract QuickstartToken is ERC20, Ownable, ERC20Burnable {
    constructor(string memory name, string memory symbol) ERC20(name, symbol) Ownable(msg.sender) {
        _mint(msg.sender, 100 * 10 ** decimals());
    }

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
}

The contract:

imports helper contracts from @openzeppelin/contracts so that our contract is a standard ERC-20 contract, has an owner, and allows to tokens to be burned
sets the token name to the symbol using the constructor arguments
sets the deployer wallet as the owner
mints an initial supply of 100 tokens to the deployer
only allows the owner to mint additional tokens using the mint function

The ERC20 token code is provided “as is” without any express or implied warranties.

Regulations governing digital assets are still unclear in many jurisdictions.
ERC20 tokens may possess unique legal, tax, and market risks, so it is up to you to determine which, if any, laws apply to your deployment of ERC20 tokens.
The developers and publishers of this software disclaim any liability for any legal issues that may arise from its use.

Project setup

Choose between using Foundry or Hardhat.

Create a new foundry project. You should already have forge installed after installing foundryup in the previous setup.
```
forge init QuickstartToken
```
```
cd QuickstartToken
```
Install OpenZeppelin Contracts.
```
forge install OpenZeppelin/openzeppelin-contracts
```
Once installed, add a remappings.txt file and add this line:
```
@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/
```
Create a new file in the src folder called QuickstartToken.sol.
Copy and paste the QuickstartToken contract above into the QuickstartToken.sol file.
Create a new file in the script folder called QuickstartToken.s.sol.

Copy and paste the script below into QuickstartToken.s.sol. This script will be used to deploy the contract.

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

import {Script} from "forge-std/Script.sol";
import {QuickstartToken} from "../src/QuickstartToken.sol";

contract QuickstartTokenScript is Script {
    QuickstartToken public quickstartToken;

    function setUp() public {}

    function run() public {
        vm.startBroadcast();

        quickstartToken = new QuickstartToken("Quickstart Token", "QKT");

        vm.stopBroadcast();
    }
}

Build the project.
```
forge build
```

Deploy the contract using one of the test wallets provided by anvil. Your contract address will be logged in the output.

forge script script/QuickstartToken.s.sol --rpc-url http://localhost:8545 --broadcast --skip-simulation --private-key 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80

Now your first contract is fully deployed! In the next section we'll interact with it using a script to mint and transfer some tokens.

Setup

Get setup with ZKsync testnet or a local node

Interact with your contract

Interact with your deployed contract using a script