In dit artikel zullen we behandelen hoe we kunnen compileren, implementeren en communiceren met een ERC-721 Smart Contract gebouwd met Solidity en de Openzeppelin-bibliotheek op het abstracte Sepolia-testnet. We zullen Hardhat, ZkSync-Ethers en TypeScript gebruiken om OUT-project te maken.
Samenvatting is een laag 2 (L2) netwerk dat bovenop Ethereum is gebouwd met behulp van de ZK -stapelEen modulair raamwerk voor het maken van Blockchains met ZK-aangedreven. Zoals elke L2, is het doel om de doorvoer van Ethereum te schalen, terwijl de gaskosten aanzienlijk worden verlaagd.
Samenvatting is EVM-compatibelOndersteunende soliditeit Slimme contracten en populaire Ethereum Development Frameworks Like Vandaag En Gieterij. Het werkt ook naadloos met veel gebruikte bibliotheken zoals zoals Ik weet En Ethers.js.
De meeste bestaande Ethereum slimme contracten zullen in abstract werken met minimale wijzigingen, waardoor ontwikkelaars gemakkelijk kunnen worden voor poorttoepassingen met weinig wrijving. Abstracte slimme contracten gebruiken echter verschillende bytecode dan de Ethereum Virtual Machine (EVM).
Bekijk dit voor meer informatie over abstract.
ERC-721 is een Ethereum -token -standaard voor Niet-schimmelbare tokens (NFTS)wat betekent dat elk token is uniek En kan niet worden vervangen. Het maakt eigendom, overdracht en metadata management mogelijk voor digitale activa zoals kunst, verzamelobjecten en in-game items.
Als het nieuw is bij ERC-721 Smart Contracts, bekijk deze twee artikelen:
Voorwaarden
- WSL2 (aanbevolen voor Windows -gebruikers)
- Node.js 22
Om knooppunt 22 in uw machine in te stellen, kunt u NVM gebruiken:
nvm install 22
nvm use 22
nvm alias default 22 #global
Maak een nieuwe map en navigeer erin:
mkdir abstract_nft && cd abstract_nft
Maak een nieuw hardhat -project:
npx hardhat init
Aanbevolen opstelling:
✔ What do you want to do? · Create a TypeScript project
✔ Hardhat project root: · /path/to/my-abstract-project
✔ Do you want to add a .gitignore? (Y/n) · y
✔ Do you ... install ... dependencies with npm ... · y
Installeer de vereiste afhankelijkheden om SMART -contracten te compileren, te implementeren en te communiceren met abstract contracten:
npm install -D @matterlabs/hardhat-zksync zksync-ethers@6 ethers@6
Installeer ook dotenv om de omgevingsvariabelen af te handelen:
npm install -D dotenv
Maak een .env Bestand in de hoofdmap om de privésleutel van uw account op te slaan. U kunt elke ethereum-compatibele portemonnee gebruiken, zoals Metamask of Coinbase. Schrijven:
PRIVATE_KEY=your_private_key
Wijzig nu het bestand hardhat.config.ts :
import { HardhatUserConfig } from "hardhat/config";
import "@matterlabs/hardhat-zksync";
import 'dotenv/config';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",
},
};
export default config;
Laten we de Openzeppelin -contracten installeren:
npm install -D @openzeppelin/contracts
Dit is het ERC 721 SMART -contract dat ik in het bestand heb geplaatstcontracts/CarsNft.sol :
// SPDX-License-Identifier: MIT
// Compatible with OpenZeppelin Contracts ^5.0.0
pragma solidity ^0.8.24;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";
contract CarsNft is ERC721, ERC721Enumerable, ERC721URIStorage {
uint256 private _nextTokenId;
constructor()
ERC721("CarsNft", "CARS")
{}
function safeMint(address to, string memory uri) public {
uint256 tokenId = _nextTokenId++;
_safeMint(to, tokenId);
_setTokenURI(tokenId, uri);
}
// The following functions are overrides required by Solidity.
function _update(address to, uint256 tokenId, address auth)
internal
override(ERC721, ERC721Enumerable)
returns (address)
{
return super._update(to, tokenId, auth);
}
function _increaseBalance(address account, uint128 value)
internal
override(ERC721, ERC721Enumerable)
{
super._increaseBalance(account, value);
}
function tokenURI(uint256 tokenId)
public
view
override(ERC721, ERC721URIStorage)
returns (string memory)
{
return super.tokenURI(tokenId);
}
function supportsInterface(bytes4 interfaceId)
public
view
override(ERC721, ERC721Enumerable, ERC721URIStorage)
returns (bool)
{
return super.supportsInterface(interfaceId);
}
}
Zoals je kunt zien, is het een heel eenvoudige ERC 721 gemaakt met de Openzeppelin -wizard.
Als we het compileren, laten we alle bestaande artefacten wissen:
npx hardhat clean
Nu kunnen we ons slimme contract samenstellen zksolc compiler:
npx hardhat compile --network abstractTestnet
Voordat u onze slimme contracten implementeert, hebt u een testether in uw portemonnee nodig. U kunt ofwel krijgen Vertrekt eth Van een kraan en overbrugt het met behulp van de Arbitrumbrugof gebruik een Arbitrumkraan om arbitrumtest ether rechtstreeks te verkrijgen.
Hier vindt u de pagina Arbitrum kranen.
Hier vindt u de TestNet Arbitrum -brug.
Voordat u dat doet, voegt u ervoor dat u het Arbitrum -testnet aan uw portemonnee toevoegt door de informatie op deze pagina te gebruiken.
Om ons slimme contract te implementeren, moeten we een implementatiescript maken op /deploy/deploy.ts:
import { Wallet } from "zksync-ethers";
import { HardhatRuntimeEnvironment } from "hardhat/types";
import { Deployer } from "@matterlabs/hardhat-zksync";
import "dotenv/config";// 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`);
// Initialize the wallet using your private key.
const wallet = new Wallet(process.env.PRIVATE_KEY!);
// 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");
// Deploy this contract. The returned object will be of a `Contract` type,
// similar to the ones in `ethers`.
const tokenContract = await deployer.deploy(artifact);
console.log(
`${
artifact.contractName
} was deployed to ${await tokenContract.getAddress()}`
);
}
Om dit bestand uit te voeren, kunt u uitvoeren:
npx hardhat deploy-zksync --script deploy.ts --network abstractTestnet
Het zal zoiets loggen als:
Testnet
Running deploy script
CarsNft was deployed to 0x32d5014AF5387002331d2AaC10fA29a6B5f3E943
En u kunt de transactie controleren op arbitrumscan.
Om de code te implementeren, gebruiken we ZKSYNC-Ethers en u kunt er hier meer over leren.
We kunnen ook ons slimme contract op de Block Explorer verifiëren door te draaien:
npx hardhat verify --network abstractTestnet 0x32d5014AF5387002331d2AaC10fA29a6B5f3E943
U kunt hier de geverifieerde code van het vorige slimme contract controleren.
Om te communiceren met het slimme contract heb ik het bestand gemaakt scripts/interact.ts:
import hre from "hardhat";const CONTRACT_ADDRESS = "0x32d5014AF5387002331d2AaC10fA29a6B5f3E943";
const MY_ADDRESS = "0x20c6F9006d563240031A1388f4f25726029a6368";
if (!CONTRACT_ADDRESS)
throw "⛔️ Provide address of the contract to interact with!";
async function main() {
console.log(`Running script to interact with contract ${CONTRACT_ADDRESS}`);
// Get the first signer
const [signer] = await hre.ethers.getSigners();
// Get the contract factory and deploy
const CarsNft = await hre.ethers.getContractFactory("CarsNft");
const carsNft = await CarsNft.connect(signer).attach(CONTRACT_ADDRESS);
// Run contract read function name
const name = await carsNft.name();
console.log(`Current name is: ${name}`);
// 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();
// Run contract read function balanceOf
const balance = await carsNft.balanceOf(MY_ADDRESS);
console.log(`Balance of the address ${MY_ADDRESS} is: ${balance.toString()}`);
// Run contract read function tokenURI
const tokenURI = await carsNft.tokenURI(0);
console.log(`Token URI of token 0 is: ${tokenURI}`);
}
main()
.then(() => process.exit(0))
.catch((error) => {
console.error(error);
process.exit(1);
});
Om het vorige script uit te voeren dat u kunt uitvoeren:
npx hardhat run scripts/interact.ts
Dit zou het resultaat moeten zijn:
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
In deze twee pagina’s kun je meer leren:
De GitHub -repository van dit project is hier te vinden.
