{"id":46268,"date":"2025-02-20T13:23:15","date_gmt":"2025-02-20T13:23:15","guid":{"rendered":"https:\/\/mycryptomania.com\/?p=46268"},"modified":"2025-02-20T13:23:15","modified_gmt":"2025-02-20T13:23:15","slug":"how-to-create-and-deploy-an-erc721-smart-contract-on-starknet-with-starknet-foundry-and-starknet-js","status":"publish","type":"post","link":"https:\/\/mycryptomania.com\/?p=46268","title":{"rendered":"How to Create and Deploy an ERC721 Smart Contract on Starknet with Starknet Foundry and Starknet.js"},"content":{"rendered":"

This guide covers how to create, deploy, and interact with an ERC721 smart contract on Starknet using OpenZeppelin, Starknet Foundry, and Starknet.js. You\u2019ll learn how to compile, declare, and deploy the contract, then mint NFTs and manage them efficiently on Layer\u00a02.<\/p>\n

Table Of\u00a0Contents<\/h3>\n

\u00b7 Table Of Contents<\/a>
\u00b7 Introduction to StarkNet and Cairo<\/a>
\u00b7 Starknet Foundry Set Up<\/a>
\u2218 Importing the Braavos Account<\/a>
\u2218 Defining the Profiles<\/a>
\u2218 Install The OpenZeppelin Library<\/a>
\u00b7 StarkNet Faucet<\/a>
\u00b7 Building The Contract<\/a>
\u2218 Declaring The Contract<\/a>
\u00b7 Deploying the Contract<\/a>
\u00b7 Starknet.js<\/a>
\u00b7 Github Repository<\/a>
\u00b7 Conclusion<\/a>
\u00b7\u00a0Sources<\/a><\/p>\n

Introduction to StarkNet and\u00a0Cairo<\/h3>\n

Starknet is a <\/strong>Layer 2 (L2) scaling solution for Ethereum that uses <\/strong>STARK (Scalable Transparent Argument of Knowledge) proofs to batch multiple transactions off-chain and submit a single proof to Ethereum. This drastically reduces gas fees and increases throughput, while maintaining Ethereum\u2019s security and decentralization.<\/p>\n

Unlike Solidity, which is used for Ethereum smart contracts, Cairo is the native smart-contract language for Starknet. Cairo<\/a> allows to write provable program with STARK validity proofs, without a deep knowledge of the complex cryptographic concepts underneath.<\/p>\n

Check out this guide<\/a> for further exploration on Starknet.<\/p>\n

Starknet Foundry Set\u00a0Up<\/h3>\n

To compile and deploy our smart contract, we will use Starknet Foundry<\/strong> in this article. For installation instructions, I recommend checking out this\u00a0guide<\/a>.<\/p>\n

To start a new project called label_nft we will\u00a0execute:<\/p>\n

snforge new label_nft<\/p>\n

Importing the Braavos\u00a0Account<\/h4>\n

For this project I have imported my Braavos <\/a>account using sncast account importboth for Sepolia testnet and\u00a0mainnet:<\/p>\n

sncast
account import
–url https:\/\/starknet-sepolia.infura.io\/v3\/****
–name account_braavos
–address 0xyjozq3nlq7f1fma6d2oz9rd8xa3np961igz7xpg3roxw37c8fl7nzfsz4avkeag4
–private-key 0x7a90aE1b2904F6F6787b0bcB6E4c8D08aF1e4fca5a33b96c8d8e7b8a6f78b60c
–type braavos<\/p>\n

These accounts are saved in the file starknet_open_zeppelin_accounts.json at the path: ~\/.starknet_accounts\/starknet_open_zeppelin_accounts.json<\/p>\n

The file starknet_open_zeppelin_accounts.json should be similar to\u00a0this:<\/p>\n

{
“alpha-mainnet”: {
“account_braavos_mainnet”: {
“address”: “0xyjozq3nlq7f1fma6d2oz9rd8xa3np961igz7xpg3roxw37c8fl7nzfsz4avkeag4”,
“class_hash”: “0xba780ad3e82a6756c2e892a252d527261177324fad6b0622f13aa7354433bef”,
“deployed”: true,
“legacy”: false,
“private_key”: “0x7a90aE1b2904F6F6787b0bcB6E4c8D08aF1e4fca5a33b96c8d8e7b8a6f78b60c”,
“public_key”: “0xyjozq3nlq7f1fma6d2oz9rd8xa3np961igz7xpg3roxw37c8fl7nzfsz4avkeag”,
“type”: “braavos”
}
},
“alpha-sepolia”: {
“account_braavos”: {
“address”: “0xyjozq3nlq7f1fma6d2oz9rd8xa3np961igz7xpg3roxw37c8fl7nzfsz4avkeag4”,
“class_hash”: “0xba780ad3e82a6756c2e892a252d527261177324fad6b0622f13aa7354433bef”,
“deployed”: true,
“legacy”: false,
“private_key”: “0x7a90aE1b2904F6F6787b0bcB6E4c8D08aF1e4fca5a33b96c8d8e7b8a6f78b60c”,
“public_key”: “0xyjozq3nlq7f1fma6d2oz9rd8xa3np961igz7xpg3roxw37c8fl7nzfsz4avkeag”,
“type”: “braavos”
}
}
}<\/p>\n

Here you can find the complete\u00a0guide<\/a>.<\/p>\n

To check the account\u2019s list we can also\u00a0execute:<\/p>\n

sncast account list<\/p>\n

Defining the\u00a0Profiles<\/h4>\n

In the snfoundry.toml file, I have added the account configuration and the RPC URL for deploying the smart contract on both Starknet Testnet Sepolia and Starknet\u00a0Mainnet:<\/p>\n

[sncast.default]
url = “https:\/\/starknet-sepolia.infura.io\/v3\/*****”
accounts-file = “~\/.starknet_accounts\/starknet_open_zeppelin_accounts.json”
account = “account_braavos”<\/p>\n

[sncast.mainnet]
account = “account_braavos_mainnet”
accounts-file = “~\/.starknet_accounts\/starknet_open_zeppelin_accounts.json”
url = “https:\/\/starknet-mainnet.infura.io\/v3\/******”<\/p>\n

Check out this guide to learn more about profile definition<\/a>.<\/p>\n

Install The OpenZeppelin Library<\/h4>\n

To install the OpenZeppelin library in our project, we should add it to the dependencies section of the Scarb.toml file:<\/p>\n

openzeppelin = “0.20.0”<\/p>\n

So our dependencies section should look like\u00a0this:<\/p>\n

[dependencies]
starknet = “2.9.2”
openzeppelin = “0.20.0”<\/p>\n

Take a look at the OpenZeppelin\u2019s guide<\/a> for further exploration.<\/p>\n

StarkNet Faucet<\/h3>\n

To declare, and deploy your tokens or to test your smart contract on StarkNet Sepolia you can use the StarkNet faucet to get test tokens both in ETH and in STRK at this\u00a0url<\/a>.<\/p>\n

Building The\u00a0Contract<\/h3>\n

To create the ERC721 smart contract, I started with the OpenZeppelin Wizard, which is accessible at this\u00a0URL<\/a>.<\/p>\n

I chose to create a mintable and enumerable smart contract using the wizard. I removed owner support to simplify things but added a map called token_uris to store the token URI for each minted NFT. This practice is commonly used to store NFT metadata on external storage, such as\u00a0IPFS.<\/p>\n

I also added a new getter and setter for the token_uris variable, as well as a mint_item function to mint NFTs and use token_uris to store the NFT metadata.<\/p>\n

This is the resulting smart contract:<\/p>\n

\/\/ SPDX-License-Identifier: MIT
\/\/ Compatible with OpenZeppelin Contracts for Cairo ^0.20.0<\/p>\n

use starknet::ContractAddress;<\/p>\n

#[starknet::interface]
pub trait ILabels<TContractState> {
fn get_token_uri(self: @TContractState, token_id: u256) -> ByteArray;
fn set_token_uri(ref self: TContractState, token_id: u256, uri: ByteArray);
fn mint_item(ref self: TContractState, recipient: ContractAddress, uri: ByteArray);
}<\/p>\n

#[starknet::contract]
mod Labels {
use openzeppelin::introspection::src5::SRC5Component;
use openzeppelin::token::erc721::ERC721Component;
use starknet::ContractAddress;
use openzeppelin::token::erc721::extensions::ERC721EnumerableComponent;
use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
use starknet::storage::{Map, StorageMapReadAccess, StorageMapWriteAccess};<\/p>\n

component!(path: ERC721Component, storage: erc721, event: ERC721Event);
component!(path: SRC5Component, storage: src5, event: SRC5Event);
component!(path: ERC721EnumerableComponent, storage: erc721_enumerable, event: ERC721EnumerableEvent);<\/p>\n

\/\/ External
#[abi(embed_v0)]
impl ERC721MixinImpl = ERC721Component::ERC721MixinImpl<ContractState>;
#[abi(embed_v0)]
impl ERC721EnumerableImpl = ERC721EnumerableComponent::ERC721EnumerableImpl<ContractState>;<\/p>\n

\/\/ Internal
impl ERC721InternalImpl = ERC721Component::InternalImpl<ContractState>;
impl ERC721EnumerableInternalImpl = ERC721EnumerableComponent::InternalImpl<ContractState>;<\/p>\n

#[storage]
struct Storage {
#[substorage(v0)]
erc721: ERC721Component::Storage,
#[substorage(v0)]
src5: SRC5Component::Storage,
#[substorage(v0)]
erc721_enumerable: ERC721EnumerableComponent::Storage,
pub counter: u256,
pub token_uris: Map<u256, ByteArray>,
}<\/p>\n

#[event]
#[derive(Drop, starknet::Event)]
enum Event {
#[flat]
ERC721Event: ERC721Component::Event,
#[flat]
SRC5Event: SRC5Component::Event,
#[flat]
ERC721EnumerableEvent: ERC721EnumerableComponent::Event,
}<\/p>\n

#[constructor]
fn constructor(ref self: ContractState) {
self.erc721.initializer(“Labels”, “LBL”, “”);
self.erc721_enumerable.initializer();
}<\/p>\n

impl ERC721HooksImpl of ERC721Component::ERC721HooksTrait<ContractState> {
fn before_update(
ref self: ERC721Component::ComponentState<ContractState>,
to: ContractAddress,
token_id: u256,
auth: ContractAddress,
) {
let mut contract_state = self.get_contract_mut();
contract_state.erc721_enumerable.before_update(to, token_id);
}
}<\/p>\n

#[generate_trait]
#[abi(per_item)]
impl ExternalImpl of ExternalTrait {
#[external(v0)]
fn safe_mint(
ref self: ContractState,
recipient: ContractAddress,
token_id: u256,
data: Span<felt252>,
) {
self.erc721.safe_mint(recipient, token_id, data);
}<\/p>\n

#[external(v0)]
fn safeMint(
ref self: ContractState,
recipient: ContractAddress,
tokenId: u256,
data: Span<felt252>,
) {
self.safe_mint(recipient, tokenId, data);
}
}<\/p>\n

#[abi(embed_v0)]
impl ImplLabels of super::ILabels<ContractState> {
fn get_token_uri(self: @ContractState, token_id: u256) -> ByteArray {
assert(self.erc721.exists(token_id), ERC721Component::Errors::INVALID_TOKEN_ID);
return self.token_uris.read(token_id);
}<\/p>\n

fn set_token_uri(ref self: ContractState, token_id: u256, uri: ByteArray) {
assert(self.erc721.exists(token_id), ERC721Component::Errors::INVALID_TOKEN_ID);
self.token_uris.write(token_id, uri);
}<\/p>\n

fn mint_item(ref self: ContractState, recipient: ContractAddress, uri: ByteArray) {
let current_counter = self.counter.read();
let new_counter = current_counter + 1;
self.counter.write(new_counter);<\/p>\n

self.erc721.mint(recipient, new_counter);
self.set_token_uri(new_counter, uri);
}
}
}<\/p>\n

In a Cairo project, the main file is lib.cairo, located in the src folder. Therefore, you should place your smart contract inside the lib.cairo file.<\/p>\n

Declaring The\u00a0Contract<\/h4>\n

Starknet differentiates between a contract class and a <\/strong>contract instance, similar to the distinction in object-oriented programming between defining a class (MyClass {}) and creating an instance of it (let myInstance = MyClass()).<\/p>\n

Declaring a contract is a required step to make it available on the network. Once declared, the contract can then be deployed and interacted with.<\/p>\n

To declare our smart contract on the Sepolia testnet, we can use the default profile, which points to Sepolia, as seen earlier. Furthermore, if we declare the smart contract using v2, the fees will be paid in ETH. However, to use the latest version and pay fees in STRK, we should use <\/strong>v3. Check out this guide<\/a> to learn\u00a0more.<\/p>\n

So if we\u00a0run:<\/p>\n

sncast declare -v v3 -c Labels<\/p>\n

We are paying the gas fees in STRK and declaring on the <\/strong>Sepolia testnet because we are using the default profile. In fact, this command implicitly includes –profile default. Labels is the name of our smart contract.<\/p>\n

Instead if we want to pay the gass fees in STRK we should\u00a0execute:<\/p>\n

sncast declare -v v2 -c Labels<\/p>\n

If we want to declare our smart contract on the StarkNet mainnet we should\u00a0run:<\/p>\n

sncast –profile mainnet declare -v v2 -c Labels<\/p>\n

Like we said earlier in this case we are paying the fees in ETH but if we want to pay in STRK we should use\u00a0v3.<\/p>\n

If we don\u2019t want to use the profile we can also declare the contract this\u00a0way:<\/p>\n

sncast –account account_braavos
declare
–url https:\/\/starknet-sepolia.infura.io\/v3\/*******
–contract-name Labels<\/p>\n

To learn more about declaring contracts check out this\u00a0guide<\/a>.<\/p>\n

Once you run the command it will compile the smart contract and it will output a class hash. In this case it is: 0x000da2972b416e39ce7cc2a59edf9ff6f40666188ea2add93a1011ba3e59c73c<\/p>\n

Deploying the\u00a0Contract<\/h3>\n

Starknet Foundry\u2019s sncast tool allows smart contract deployment to a specified network using the sncast deploy\u00a0command.<\/p>\n

It operates by calling a Universal Deployer Contract, which deploys the contract using the provided class hash and constructor arguments.<\/p>\n

After declaring our smart contract we can deploy it on Sepolia\u00a0with:<\/p>\n

sncast deploy -v v3 –class-hash 0x000da2972b416e39ce7cc2a59edf9ff6f40666188ea2add93a1011ba3e59c73c<\/p>\n

In this case we use v3 to pay the fees in STRK. If we want to pay the fees in ETH we need to use\u00a0v1.<\/p>\n

If we want to deploy the smart contract on StarkNet mainnet we can\u00a0run:<\/p>\n

sncast –profile mainnet deploy -v v1 –class-hash 0x000da2972b416e39ce7cc2a59edf9ff6f40666188ea2add93a1011ba3e59c73c<\/p>\n

If you don\u2019t want to use the profile, you can deploy the contract\u00a0using:<\/p>\n

sncast
–account my_account
deploy
–url http:\/\/127.0.0.1:5055\/rpc
–class-hash 0x000da2972b416e39ce7cc2a59edf9ff6f40666188ea2add93a1011ba3e59c73c<\/p>\n

The output should be something like\u00a0this:<\/p>\n

command: deploy
contract_address: 0x042de0e88b8d70b02ff6303fdb69cec5718154db91b8c53a58de047dfcbc41c0
transaction_hash: 0x009282ecfa8611a6b2d5a213c9da1a861a2760b96c0a72f1b94b85cb7ed36d97<\/p>\n

To see deployment details, visit:
contract: https:\/\/sepolia.starkscan.co\/contract\/0x042de0e88b8d70b02ff6303fdb69cec5718154db91b8c53a58de047dfcbc41c0
transaction: https:\/\/sepolia.starkscan.co\/tx\/0x009282ecfa8611a6b2d5a213c9da1a861a2760b96c0a72f1b94b85cb7ed36d97<\/p>\n

If you want to learn more about deploying smart contracts with Starknet Foundry check out this\u00a0guide<\/a>.<\/p>\n

Starknet.js<\/h3>\n

To test our smart contract, we can use Starknet.js, a library designed to interact with Starknet and perform operations using JavaScript.<\/p>\n

Let\u2019s create three environment variables in our\u00a0.envfile:<\/p>\n

STARKNET_ADDRESS=your_starnet_address
STARKNET_PRIVATE_KEY=your_account_private_key
STARKNET_RPC_URL=your_rpc_url<\/p>\n

Let\u2019s start by creating an RpcProvider object:<\/p>\n

const provider = new RpcProvider({
nodeUrl: process.env.STARKNET_RPC_URL,
});<\/p>\n

Now let\u2019s connect to our\u00a0account:<\/p>\n

const account = new Account(
provider,
process.env.STARKNET_ADDRESS,
process.env.STARKNET_PRIVATE_KEY
);<\/p>\n

Now, to connect to our smart contract, we need the ABI. We can extract it from our Starknet Foundry repository, where our code was compiled, specifically from the file label_nft_Labels.contract_class.json located in the target\/release folder.<\/p>\n

To extract the ABI field from this file, I\u00a0used:<\/p>\n

jq -r ‘.abi’ .\/target\/release\/label_nft_Labels.contract_class.json > labels.json<\/p>\n

This extracts the abi field and saves it into a new file labels.json.<\/p>\n

To connect to our smart contract with starknet.js we must first import the\u00a0ABI:<\/p>\n

import labelsAbi from “..\/labels.json” with { type: ‘json’ };<\/p>\n

Then we can\u00a0write:<\/p>\n

const erc721 = new Contract(labelsAbi, DEPLOYED_CONTRACT, provider);
erc721.connect(account);<\/p>\n

We should be able to call the name function of the smart contract:<\/p>\n

await contract.name(); \/\/ Labels<\/p>\n

To mint a new NFT we can call the mint_itemfunction that we have created in the smart contract:<\/p>\n

const mintNft = async (
contract: Contract,
account: Account,
provider: RpcProvider,
recipient: string,
uri: string
) => {
\/\/ Transaction with fees paid in ETH
const mintCall = contract.populate(“mint_item”, { recipient, uri });
const { transaction_hash: transferTxHash } = await account.execute(mintCall, {
version: 3, \/\/ version 3 to pay fees in STRK. To pay fees in ETH remove the version field
});
console.log(`Minting NFT with transaction hash: ${transferTxHash}`);
\/\/ Wait for the invoke transaction to be accepted on Starknet
const receipt = await provider.waitForTransaction(transferTxHash);
console.log(receipt);
};<\/p>\n

await mintNft(
erc721,
account,
provider,
account.address,
“NFT1”
);<\/p>\n

Also in this case if we put version: 3 we will pay the fees in STRK, if we remove this field we will pay in\u00a0ETH.<\/p>\n

So, once I execute this, it will mint my first NFT to account.address, which is:0x032e21f8277033fd4ddbb2127f5ebe74c7cdb09e36e72bd0071ad9bf6039b7bd, with the token URI NFT1, and it has returned the transaction hash: 0x6444953ee970574896ccc025b33636aceeb314247dadc4913c3d10f1d9db401.<\/p>\n

It is possible to check the transaction on the Stark\u00a0Scan<\/a>.<\/p>\n

We could call the total_supplymethod of the smart contract to check how many NFTs have been\u00a0minted:<\/p>\n

const totalSupply = await contract.total_supply(); \/\/ 1<\/p>\n

We could also check the token URI of the first\u00a0NFT:<\/p>\n

const uri = await contract.get_token_uri(1); \/\/ NFT1<\/p>\n

Finally, we could also test the balance_of method by calling it on account.address:<\/p>\n

await contract.balance_of(account.address);<\/p>\n

Github Repository<\/h3>\n

The whole code is available at the this Github repository<\/a>.<\/p>\n

Conclusion<\/h3>\n

In this article, we walked through the process of creating an ERC721 smart contract using OpenZeppelin, compiling and deploying it with Starknet Foundry, and interacting with it using Starknet.js. With Starknet\u2019s scalability and low-cost transactions, this approach provides an efficient way to build and manage NFTs on Layer\u00a02.<\/p>\n

Sources<\/h3>\n

https:\/\/www.starknet.io\/blog\/validity-rollups\/<\/a>https:\/\/foundry-rs.github.io\/starknet-foundry\/getting-started\/installation.html<\/a>https:\/\/foundry-rs.github.io\/starknet-foundry\/starknet\/account-import.html<\/a>https:\/\/foundry-rs.github.io\/starknet-foundry\/projects\/configuration.html<\/a>https:\/\/github.com\/OpenZeppelin\/cairo-contracts\/blob\/main\/README.md<\/a>https:\/\/foundry-rs.github.io\/starknet-foundry\/starknet\/declare.html<\/a>https:\/\/foundry-rs.github.io\/starknet-foundry\/starknet\/deploy.html<\/a>https:\/\/starknetjs.com\/<\/a><\/p>\n

How to Create and Deploy an ERC721 Smart Contract on Starknet with Starknet Foundry and Starknet.js<\/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":"

This guide covers how to create, deploy, and interact with an ERC721 smart contract on Starknet using OpenZeppelin, Starknet Foundry, and Starknet.js. You\u2019ll learn how to compile, declare, and deploy the contract, then mint NFTs and manage them efficiently on Layer\u00a02. Table Of\u00a0Contents \u00b7 Table Of Contents\u00b7 Introduction to StarkNet and Cairo\u00b7 Starknet Foundry Set […]<\/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-46268","post","type-post","status-publish","format-standard","hentry","category-interesting"],"_links":{"self":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts\/46268"}],"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=46268"}],"version-history":[{"count":0,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=\/wp\/v2\/posts\/46268\/revisions"}],"wp:attachment":[{"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=46268"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=46268"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mycryptomania.com\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=46268"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}