{"id":48330,"date":"2025-02-27T17:09:30","date_gmt":"2025-02-27T17:09:30","guid":{"rendered":"https:\/\/mycryptomania.com\/?p=48330"},"modified":"2025-02-27T17:09:30","modified_gmt":"2025-02-27T17:09:30","slug":"how-to-deploy-and-interact-with-an-erc-721-smart-contract-on-abstract-using-hardhat-and","status":"publish","type":"post","link":"https:\/\/mycryptomania.com\/?p=48330","title":{"rendered":"How to Deploy and Interact with an ERC-721 Smart Contract on Abstract Using Hardhat and\u2026"},"content":{"rendered":"

How to Deploy and Interact with an ERC-721 Smart Contract on Abstract Using Hardhat and OpenZeppelin<\/h3>\n

In this article, we will cover how to compile, deploy, and interact with an ERC-721 smart contract built using Solidity and the OpenZeppelin library on the Abstract Sepolia testnet. We will be using Hardhat, zkSync-Ethers, and TypeScript to create out\u00a0project.<\/p>\n

What is Abstract?<\/h3>\n

Abstract is a Layer 2 (L2) network built on top of Ethereum using the ZK Stack<\/strong>, a modular framework for creating ZK-powered blockchains. Like any L2, its goal is to scale Ethereum\u2019s throughput while significantly reducing gas\u00a0fees.<\/p>\n

Abstract is EVM-compatible<\/strong>, supporting Solidity smart contracts and popular Ethereum development frameworks like Hardhat<\/strong> and Foundry<\/strong>. It also works seamlessly with widely used libraries such as Viem<\/strong> and Ethers.js<\/strong>.<\/p>\n

Most existing Ethereum smart contracts will function on Abstract with minimal modifications, making it easy for developers to port applications with little friction. However Abstract smart contracts use different bytecode than the Ethereum Virtual Machine\u00a0(EVM).<\/p>\n

To learn more about Abstract check out\u00a0this<\/a>.<\/p>\n

What is an\u00a0ERC-721?<\/h3>\n

ERC-721<\/strong> is an Ethereum token standard for non-fungible tokens (NFTs)<\/strong>, meaning each token is unique<\/strong> and cannot be replaced<\/strong>. It enables ownership, transfer, and metadata management for digital assets like art, collectibles, and in-game\u00a0items.<\/p>\n

If are new to ERC-721 smart contracts check out th<\/a>ese two articles:<\/p>\n

NFT Mastery: Understanding ERC-721 on Ethereum for\u00a0Starter<\/a>sHow to Create ERC-721 NFTs on Ethereum with OpenZeppelin: A Step-by-Step Tutorial<\/a><\/p>\n

Hardhat Project Set\u00a0Up<\/h3>\n

Prerequisites<\/h4>\n

WSL2 (recommended for Windows\u00a0users)Node.js 22<\/p>\n

To set Node 22 in your machine you can use\u00a0nvm:<\/p>\n

nvm install 22
nvm use 22
nvm alias default 22 #global<\/p>\n

Create a new directory and navigate into\u00a0it:<\/p>\n

mkdir abstract_nft && cd abstract_nft<\/p>\n

Create a new Hardhat\u00a0project:<\/p>\n

npx hardhat init<\/p>\n

Recommended setup:<\/p>\n

\u2714 What do you want to do? \u00b7 Create a TypeScript project
\u2714 Hardhat project root: \u00b7 \/path\/to\/my-abstract-project
\u2714 Do you want to add a .gitignore? (Y\/n) \u00b7 y
\u2714 Do you … install … dependencies with npm … \u00b7 y<\/p>\n

Install the required dependencies to compile, deploy and interact with smart contracts on Abstract:<\/p>\n

npm install -D @matterlabs\/hardhat-zksync zksync-ethers@6 ethers@6<\/p>\n

Install also dotenv to handle the environment variables:<\/p>\n

npm install -D dotenv<\/p>\n

Create a\u00a0.env file in the root directory to store your account’s private key. You can use any Ethereum-compatible wallet, such as MetaMask or Coinbase. Write:<\/p>\n

PRIVATE_KEY=your_private_key<\/p>\n

Now modify the file hardhat.config.ts\u00a0:<\/p>\n

import { HardhatUserConfig } from “hardhat\/config”;
import “@matterlabs\/hardhat-zksync”;
import ‘dotenv\/config’;<\/p>\n

const config: HardhatUserConfig = {
zksolc: {
version: “latest”,
settings: {
\/\/ Note: This must be true to call NonceHolder & ContractDeployer system contracts
enableEraVMExtensions: false,
},
},
defaultNetwork: “abstractTestnet”,
networks: {
abstractTestnet: {
url: “https:\/\/api.testnet.abs.xyz”,
ethNetwork: “sepolia”,
zksync: true,
chainId: 11124,
accounts: [process.env.PRIVATE_KEY!]
},
abstractMainnet: {
url: “https:\/\/api.mainnet.abs.xyz”,
ethNetwork: “mainnet”,
zksync: true,
chainId: 2741,
accounts: [process.env.PRIVATE_KEY!]
},
},
etherscan: {
apiKey: {
abstractTestnet: “TACK2D1RGYX9U7MC31SZWWQ7FCWRYQ96AD”,
abstractMainnet: “IEYKU3EEM5XCD76N7Y7HF9HG7M9ARZ2H4A”,
},
customChains: [
{
network: “abstractTestnet”,
chainId: 11124,
urls: {
apiURL: “https:\/\/api-sepolia.abscan.org\/api”,
browserURL: “https:\/\/sepolia.abscan.org\/”,
},
},
{
network: “abstractMainnet”,
chainId: 2741,
urls: {
apiURL: “https:\/\/api.abscan.org\/api”,
browserURL: “https:\/\/abscan.org\/”,
},
},
],
},
solidity: {
version: “0.8.24”,
},
};<\/p>\n

export default config;<\/p>\n

Let\u2019s install the OpenZeppelin contracts:<\/p>\n

npm install -D @openzeppelin\/contracts<\/p>\n

This is the ERC 721 smart contract that I have put in the filecontracts\/CarsNft.sol\u00a0:<\/p>\n

\/\/ SPDX-License-Identifier: MIT
\/\/ Compatible with OpenZeppelin Contracts ^5.0.0
pragma solidity ^0.8.24;<\/p>\n

import {ERC721} from “@openzeppelin\/contracts\/token\/ERC721\/ERC721.sol”;
import {ERC721Enumerable} from “@openzeppelin\/contracts\/token\/ERC721\/extensions\/ERC721Enumerable.sol”;
import {ERC721URIStorage} from “@openzeppelin\/contracts\/token\/ERC721\/extensions\/ERC721URIStorage.sol”;<\/p>\n

contract CarsNft is ERC721, ERC721Enumerable, ERC721URIStorage {
uint256 private _nextTokenId;<\/p>\n

constructor()
ERC721(“CarsNft”, “CARS”)
{}<\/p>\n

function safeMint(address to, string memory uri) public {
uint256 tokenId = _nextTokenId++;
_safeMint(to, tokenId);
_setTokenURI(tokenId, uri);
}<\/p>\n

\/\/ The following functions are overrides required by Solidity.<\/p>\n

function _update(address to, uint256 tokenId, address auth)
internal
override(ERC721, ERC721Enumerable)
returns (address)
{
return super._update(to, tokenId, auth);
}<\/p>\n

function _increaseBalance(address account, uint128 value)
internal
override(ERC721, ERC721Enumerable)
{
super._increaseBalance(account, value);
}<\/p>\n

function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
return super.tokenURI(tokenId);
}<\/p>\n

function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, ERC721URIStorage)
returns (bool)
{
return super.supportsInterface(interfaceId);
}
}<\/p>\n

As you can see it is a very simple ERC 721 created with the OpenZeppelin Wizard<\/a>.<\/p>\n

Becore compiling it, let\u2019s clear any existing artifacts:<\/p>\n

npx hardhat clean<\/p>\n

Now we can compile our smart contract with zksolc compiler:<\/p>\n

npx hardhat compile –network abstractTestnet<\/p>\n

Before deploying our smart contracts, you need some test Ether in your wallet. You can either get Sepolia ETH<\/strong> from a faucet and bridge it using the Arbitrum bridge<\/strong>, or use an Arbitrum faucet<\/strong> to obtain Arbitrum test Ether directly.<\/p>\n

Here <\/a>you can find the Arbitrum faucets\u00a0page.<\/p>\n

Here<\/a> you can find the testnet Arbitrum\u00a0bridge.<\/p>\n

Before doing that make sure to add the Arbitrum testnet to your wallet by using the informations provided at this\u00a0page<\/a>.<\/p>\n

In order to deploy our smart contract we need to create a deployment script at \/deploy\/deploy.ts:<\/p>\n

import { Wallet } from “zksync-ethers”;
import { HardhatRuntimeEnvironment } from “hardhat\/types”;
import { Deployer } from “@matterlabs\/hardhat-zksync”;
import “dotenv\/config”;<\/p>\n

\/\/ An example of a deploy script that will deploy and call a simple contract.
export default async function (hre: HardhatRuntimeEnvironment) {
console.log(`Running deploy script`);<\/p>\n

\/\/ Initialize the wallet using your private key.
const wallet = new Wallet(process.env.PRIVATE_KEY!);<\/p>\n

\/\/ Create deployer object and load the artifact of the contract we want to deploy.
const deployer = new Deployer(hre, wallet);
\/\/ Load contract
const artifact = await deployer.loadArtifact(“CarsNft”);<\/p>\n

\/\/ Deploy this contract. The returned object will be of a `Contract` type,
\/\/ similar to the ones in `ethers`.
const tokenContract = await deployer.deploy(artifact);<\/p>\n

console.log(
`${
artifact.contractName
} was deployed to ${await tokenContract.getAddress()}`
);
}<\/p>\n

To execute this file you can\u00a0run:<\/p>\n

npx hardhat deploy-zksync –script deploy.ts –network abstractTestnet<\/p>\n

It will log something like:<\/p>\n

Testnet
Running deploy script
CarsNft was deployed to 0x32d5014AF5387002331d2AaC10fA29a6B5f3E943<\/p>\n

And you can check the transaction on Arbitrum\u00a0scan<\/a>.<\/p>\n

To deploy the code we are using zksync-ethers and you can learn more about it\u00a0here<\/a>.<\/p>\n

We can also verify our smart contract on the block explorer by\u00a0running:<\/p>\n

npx hardhat verify –network abstractTestnet 0x32d5014AF5387002331d2AaC10fA29a6B5f3E943<\/p>\n

You can check the verified code of the previous smart contract\u00a0here<\/a>.<\/p>\n

To interact with the smart contract I have created the file scripts\/interact.ts:<\/p>\n

import hre from “hardhat”;<\/p>\n

const CONTRACT_ADDRESS = “0x32d5014AF5387002331d2AaC10fA29a6B5f3E943”;
const MY_ADDRESS = “0x20c6F9006d563240031A1388f4f25726029a6368”;<\/p>\n

if (!CONTRACT_ADDRESS)
throw “\u26d4\ufe0f Provide address of the contract to interact with!”;<\/p>\n

async function main() {
console.log(`Running script to interact with contract ${CONTRACT_ADDRESS}`);<\/p>\n

\/\/ Get the first signer
const [signer] = await hre.ethers.getSigners();<\/p>\n

\/\/ Get the contract factory and deploy
const CarsNft = await hre.ethers.getContractFactory(“CarsNft”);
const carsNft = await CarsNft.connect(signer).attach(CONTRACT_ADDRESS);<\/p>\n

\/\/ Run contract read function name
const name = await carsNft.name();
console.log(`Current name is: ${name}`);<\/p>\n

\/\/ Run contract write function safeMint
const transaction = await carsNft.safeMint(MY_ADDRESS, “URI of car n.1”);
console.log(`Transaction hash of safeMint : ${transaction.hash}`);
await transaction.wait();<\/p>\n

\/\/ Run contract read function balanceOf
const balance = await carsNft.balanceOf(MY_ADDRESS);
console.log(`Balance of the address ${MY_ADDRESS} is: ${balance.toString()}`);<\/p>\n

\/\/ Run contract read function tokenURI
const tokenURI = await carsNft.tokenURI(0);
console.log(`Token URI of token 0 is: ${tokenURI}`);
}<\/p>\n

main()
.then(() => process.exit(0))
.catch((error) => {
console.error(error);
process.exit(1);
});<\/p>\n

To run the previous script you can\u00a0execute:<\/p>\n

npx hardhat run scripts\/interact.ts <\/p>\n

This should be the\u00a0result:<\/p>\n

Running script to interact with contract 0x32d5014AF5387002331d2AaC10fA29a6B5f3E943
Current name is: CarsNft
Transaction hash of safeMint : 0x766938205ed335c769124d99ae917f577b3c259815a629b246589e08ded7eb83
Balance of the address 0x20c6F9006d563240031A1388f4f25726029a6368 is: 1
Token URI of token 0 is: URI of car n.1<\/p>\n

In this two pages you can learn\u00a0more:<\/p>\n

https:\/\/docs.zksync.io\/zksync-era\/tooling\/hardhat\/guides\/getting-started<\/a>https:\/\/docs.abs.xyz\/build-on-abstract\/smart-contracts\/hardhat#recommended-hardhat-setup<\/a><\/p>\n

Github Repository<\/h3>\n

The Github repository of this project can be found\u00a0here<\/a>.<\/p>\n

Sources<\/h3>\n

https:\/\/docs.zksync.io\/zk-stack<\/a>https:\/\/docs.abs.xyz\/what-is-abstract<\/a>https:\/\/docs.abs.xyz\/build-on-abstract\/smart-contracts\/hardhat#recommended-hardhat-setup<\/a>https:\/\/docs.zksync.io\/zksync-era\/tooling\/hardhat\/guides\/getting-started<\/a><\/p>\n

How to Deploy and Interact with an ERC-721 Smart Contract on Abstract Using Hardhat and\u2026<\/a> was originally published in Coinmonks<\/a> on Medium, where people are continuing the conversation by highlighting and responding to this story.<\/p>","protected":false},"excerpt":{"rendered":"

How to Deploy and Interact with an ERC-721 Smart Contract on Abstract Using Hardhat and OpenZeppelin In this article, we will cover how to compile, deploy, and interact with an ERC-721 smart contract built using Solidity and the OpenZeppelin library on the Abstract Sepolia testnet. We will be using Hardhat, zkSync-Ethers, and TypeScript to create […]<\/p>\n","protected":false},"author":0,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-48330","post","type-post","status-publish","format-standard","hentry","category-interesting"],"_links":{"self":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts\/48330"}],"collection":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/types\/post"}],"replies":[{"embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=48330"}],"version-history":[{"count":0,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts\/48330\/revisions"}],"wp:attachment":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=48330"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=48330"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=48330"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}