“Wow!” Gwen Stefani, who was similarly emotional at Carter’s exit, gasped at McEntire’s choice. She also said she would have stolen Carter for her own team if she still had Steal left. McEntire said that Nitti had “continued to impress” her but ...

‘The Voice’: Niall Horan & Gwen Stefani Left in Tears After Shock Elimination

Teacher pay in Wyoming has seen little growth over the last decade, leaving educators struggling to keep pace with inflation, which spiked in 2021 and has remained high since.

Amid teacher exodus, Wyoming eyes $68M to cover rising K-12 costs

Survivor said goodbye to Brando Meyer, but he revealed a secret tribe swap advantage that he claims was taken away by production.

Brando says he found an advantage before Survivor exit, got it taken away by production

U.S. Rep. Cory Mills, a combat veteran who also has specialized in international security, flew to Israel and helped 77 Americans exit the warring nation in the past two days following last week's ...

U.S. Rep. Cory Mills helps 77 Americans exit Israel, says he plans to go back for more

Republican presidential candidates professed their strong support for Israel as they addressed an influential Republican Jewish group during a campaign stop Saturday in Las Vegas. The gathering coinci

Republican presidential candidates profess strong support for Israel as war enters new phase

PROGRAMMING ALERTS: Watch Bret Baier host "Special Report" live on Capitol Hill on Monday, October 9 at 6 p.m. ET on Fox News Channel. The show will feature special coverage on both the House ...

House speaker drama, McCarthy's exit: Surprise lesson George Washington could teach us today

Blue Kim reveals who she thinks is playing the best on Big Brother 25, and she was asked who told her she was being evicted.

Blue Kim says Felicia is playing the best game in new Big Brother exit interview

Big Brother 25 cast member America Lopez had some scathing words for fellow houseguests during her exit interviews.

America goes after Bowie Jane in an angry Big Brother exit interview

Adam Wylie has been arrested on suspicion of shoplifting at a Target store in California. The 39-year-old ' Picket Fences' star was stopped by security guards at the shop in Burbank on October 13 after they saw him picking out a number of health and beauty products but failing to scan some of them at the self-checkout before heading for the exit.

Adam Wylie arrested on suspicion of shoplifting

Sorvino, who was partnered with Gleb Savchenko for the ABC dancing competition series, performed a routine to Cyndi Lauper ’s “Time After Time” on Tuesday’s (October 24) episode, which included a guest appearance from Sorvino’s daughter, Mattea, who is also a dancer.

‘Celebrity Jeopardy!’: Mira Sorvino Wins Big After Shocking ‘DWTS’ Elimination

Exit 7C

exit7c

WorldID on Gnosis? This Cross-Chain System Makes It Happen

How to Build DApp on Rootstock with Next.js, Typescript, and Solidity

This article took longer than expected, and I struggled at almost every step for different reasons. But… stop crying, let's make some code =) 1. Introduction In this article, we dive into with NTFs, and because simply creating a smart contract with an NFT and deploying it is very dull and has already been partly in previous articles on this topic, I decided to complicate my life and make these same NFTs created from a bot in Telegram. web3 2. The boring part that everyone skips An NFT, or Non-Fungible Token, is a unique digital asset that represents ownership of a specific item or piece of content, such as artwork, music, videos, or other forms of creative work, using blockchain technology or, in simple words, a link to your asset (storing the asset itself on the blockchain is costly). Here are some critical aspects of NFTs: : NFTs provide a way for creators to sell digital items with a clear record of ownership. This ownership is secured and verified using blockchain technology, typically on the Ethereum blockchain. Digital Ownership : Each NFT has unique properties that cannot be replicated. This uniqueness can create scarcity, which can drive up the value of the NFT. Uniqueness and Scarcity : NFTs can often be used across different blockchain platforms and applications. This means a digital artwork tokenized as an NFT can be viewed, bought, or sold in various virtual environments and marketplaces. Interoperability : The blockchain ledger records the history of each NFT, including its creation, sale, and previous ownership. This transparency helps verify the authenticity and provenance of the digital asset. Provenance and Authenticity : NFTs can be programmed to provide ongoing royalties to their original creators. Whenever the NFT is sold to a new owner, a percentage of the sale can automatically go back to the original creator. Royalties Because it is expensive to store assets in the blockchain, and there is a strong desire to show off distributed technologies, hipsters reinvent torrents and call it IPFS. IPFS, which stands for InterPlanetary File System, is a protocol and peer-to-peer network for storing and sharing data in a distributed file system. IPFS was created to make the web faster, safer, and more open. Here are some key features and concepts associated with IPFS: : Unlike traditional centralized file storage systems, IPFS is built on a distributed network. This means files aren't stored in a single location but distributed across multiple network nodes. Decentralized and Distributed : IPFS uses content-based addressing rather than location-based addressing. Each file and piece of content on IPFS is identified by a unique fingerprint called a cryptographic hash. This ensures that users are accessing the content they requested, as the hash of the content verifies its integrity. Content Addressing : Since IPFS retrieves files from the nearest node rather than a central server, it can lead to faster download speeds and reduced load on any single server. This also makes the system more resilient to censorship and server failures. Efficient and Resilient : IPFS supports versioning and linking, which allows for the creating of complex webs of data with rich relationships and history. Versioning and Linking : IPFS has a wide range of applications, including decentralized web projects, blockchain data storage, file sharing, and as a replacement for traditional HTTP in specific scenarios. Use Cases : Its decentralized nature makes IPFS a popular choice for storing data in blockchain applications, enhancing storage capacity and access efficiency. Compatibility with Blockchain IPFS is part of a more significant movement towards a decentralized internet, where users have more control over their data and how it functions. It is often associated with decentralized technologies like blockchain and distributed ledger technology. 3. Principles of work How will our bot work? When a user sends a message or image, we check if the user added his Ethereum address. We unobtrusively ask you to add it if he hasn't added it. Otherwise, we won’t let you create an NFT. After we have an address, the user can send us an image, which will be a future NFT. When we got the image, we uploaded it into IPFS and created a metafile with information about NFT. This file will be uploaded into IPFS. After we upload everything, we mint NFT in the contract with a link to a metadata file. Say, user, that's all done. … Profit 4. Prerequisites First, we need an account on Telegram Second, create a bot using @BotFather Init app with next app (not that it's essential, and you can use express, but I make some space for the future) npx create-next-app@latest telegram-bot --use-npm Go to folder cd telegram-bot And init hardhat npx hardhat init And we have a basis for our project.. So clean and nice Create file and add into it .env NEXT_TELEGRAM_TOKEN=6440257800:AAGY...
NEXT_SEED=qwerty
NEXT_VERIFIER_ADDRESS=
NEXT_NFT_ADDRESS=
NEXT_PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
NEXT_JSON_RPC=http://127.0.0.1:8545/
NEXT_CHAIN_ID=1337
NEXT_IPFS_NODE=http://127.0.0.1:5001/ Here is the credential for local development. can be taken from @BotFather NEXT_TELEGRAM_TOKEN 5. Contracts 5.1 Verification Here is a simple key-value storage Create file with the following content contracts/Verification.sol // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.23;

// Uncomment this line to use console.log
// import "hardhat/console.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract Verification is Ownable {
    mapping(uint => address) public verified;

    constructor() Ownable(msg.sender) {}

    function verify(uint256 _id, address _address) public onlyOwner {
        verified[_id] = _address;
    }
} and scripts/deploy_verification.js const hre = require("hardhat");

async function main() {
  const instance = await hre.ethers.deployContract("Verification");
  await instance.waitForDeployment();
  console.log(`Verification Contract deployed to ${await instance.getAddress()}`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});4.2 Nft Deploy it npx hardhat run scripts/deploy_verification.js --network local Save contract address into file .env ...
NEXT_VERIFIER_ADDRESS=...
... 5.2 NFT And here I decided not to bother and created a file through the wizard . It’s very convenient, but first, I would still recommend that you practice writing such contracts yourself. https://docs.openzeppelin.com/contracts/5.x/wizard Create file with the following content. contracts/TelegramBot.sol // SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract TelegramBot is ERC721, ERC721Enumerable, ERC721URIStorage, Ownable {
    uint256 private _nextTokenId;

    constructor(address initialOwner)
    ERC721("TelegramBot", "TGB")
    Ownable(initialOwner)
    {}

    function safeMint(address to, string memory uri) public onlyOwner {
        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);
    }
} and scripts/deploy_nft.js const hre = require("hardhat");

async function main() {
  const signers = await hre.ethers.getSigners();
  console.log("Deploying contracts with the account:", signers[0].address);

  const instance = await hre.ethers.deployContract("TelegramBot", [
    signers[0].address,
  ]);
  await instance.waitForDeployment();
  console.log(`TelegramBot Contract deployed to ${await instance.getAddress()}`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
}); Deploy it npx hardhat run scripts/deploy_nft.js --network local Save the contract address into file .env ...
NEXT_NFT_ADDRESS=...
... 6. Telegram webhook For local testing, I strongly recommend you to use ngrok 6.1 Preparement. Create with the following content. app/api/telegram/route.ts import { TelegramRequest } from "@/app/types";
import { ok } from "@/app/helpers/ok";

export async function POST(request: Request) {
  const reqData = (await request.json()) as TelegramRequest;
  console.log(reqData);

  return ok();
} app/helpers/ok.ts import { NextResponse } from "next/server";

export function ok() {
  return new NextResponse("Ok", {
    status: 200,
    statusText: "Ok",
    headers: {
      "Content-Type": "text/plain",
    },
  });
} helpers for interact with Telegram: app/helpers/tg.ts const sendMessageUrl = `https://api.telegram.org/bot${process.env.NEXT_TELEGRAM_TOKEN}/sendMessage`;
const fileUrl = `https://api.telegram.org/bot${process.env.NEXT_TELEGRAM_TOKEN}/getFile?file_id=`;
const downloadFileUrl = `https://api.telegram.org/file/bot${process.env.NEXT_TELEGRAM_TOKEN}/`;

export async function sendMessage(chat_id: String | number, message: String) {
  const req = await fetch(sendMessageUrl, {
    method: "POST",
    body: JSON.stringify({
      chat_id: chat_id,
      text: message,
      parse_mode: "markdown",
    }),
    headers: {
      "Content-Type": "application/json",
    },
  });

  const resp = await req.json();

  console.log("sendMessage", resp);

  return resp;
}

export async function getFile(file_id: String) {
  const req = await fetch(`${fileUrl}${file_id}`, {
    method: "GET",
  });

  const resp = await req.json();

  console.log("getFile", resp);

  return resp;
}

export async function downloadFile(file_path: String) {
  const req = await fetch(`${downloadFileUrl}${file_path}`, {
    method: "GET",
  });

  return await req.blob();
} Helpers for interact with IPFS: app/helpers/ipfs.ts export async function uploadFile(
  filename: string,
  data: Blob,
): Promise<{ Name: string; Hash: string; Size: string }> {
  const form = new FormData();
  form.append(filename, data, filename);

  const uploadResponse = await fetch(
    `${process.env.NEXT_IPFS_NODE}api/v0/add?pin=true`,
    {
      method: "POST",
      body: form,
      headers: {
        "accept-type": "application/json",
      },
    },
  );

  const resp = await uploadResponse.json();
  console.log(`upload ${filename} response:`, resp);

  return resp;
} app/types.ts export type TelegramPhotoRequest = {
  file_id: string;
  file_unique_id: string;
  file_size: number;
  width: number;
  height: number;
};

export type TelegramEntityRequest = {
  offset: number;
  length: number;
  type: string;
};

export type TelegramRequest = {
  update_id: number;
  message: {
    message_id: number;
    from: {
      id: number;
      is_bot: boolean;
      first_name: string;
      last_name: string;
      username: string;
      language_code: string;
      is_premium: boolean;
    };
    chat: {
      id: number;
      first_name: string;
      last_name: string;
      username: string;
      type: string;
    };
    date: number;
    text: string;
    photo: TelegramPhotoRequest[] | undefined;
    entities: TelegramEntityRequest[] | undefined;
    caption: string | undefined;
  };
}; Next steps will be in file app/api/telegram/route.ts 6.2 Initialise provider for work with Ethereum network. import { ethers, JsonRpcProvider } from "ethers";
import { TelegramRequest } from "@/app/types";
import { ok } from "@/app/helpers/ok";

export async function POST(request: Request) {
  const reqData = (await request.json()) as TelegramRequest;
  console.log(reqData);

  const provider = new JsonRpcProvider();
  const signer = new ethers.Wallet(
    process.env.NEXT_PRIVATE_KEY as string,
    provider,
  );

  return ok();
} 6.3 Initialise verification contract ...

const verifierAbi =
  require("@/artifacts/contracts/Verification.sol/Verification.json").abi;

export async function POST(request: Request) {
  ... 
  const verifierContract = new ethers.Contract(
    process.env.NEXT_VERIFIER_ADDRESS as string,
    verifierAbi,
    signer,
  );

  return ok();
} 6.4 Check user is registered. We need to make a hash of the user ID to preserve his anonymity. As we already know, the blockchain remembers everything, and it will not be very good for the user if we store in clear form a link between the user’s account and his telegram identifier. ...
import * as crypto from "crypto";
...

export async function POST(request: Request) {

	...

  const hash = crypto
    .createHash("sha256")
    .update(`${process.env.NEXT_SEED}:${reqData.message.from.id}`)
    .digest();

  let address = null;

  try {
    address = await verifierContract.verified("0x" + hash.toString("hex"));
  } catch (e) {
    console.log("address", e);
  }

	if (!address || address === "0x0000000000000000000000000000000000000000") {
	
	}

  return ok();
} 6.5 Registration. If the user is not registered yet, we check the message. If it is the correct address - make registration; otherwise, send a message that we need his address. ...
import { isAddress } from "ethers";
import { ok } from "@/app/helpers/ok";
import { sendMessage } from "@/app/helpers/tg";
...

export async function POST(request: Request) {
  ...

  if (!address || address === "0x0000000000000000000000000000000000000000") {
    if (isAddress(reqData.message.text)) {
      let r = await verifierContract.verify(
        "0x" + hash.toString("hex"),
        reqData.message.text.trim(),
      );
      console.log("resp", r);

      let address = await verifierContract.verified(
        "0x" + hash.toString("hex"),
      );

      const resp = await sendMessage(
        reqData.message.chat.id,
        `${address} registered\n now you can send NFTs`,
      );
      console.log("resp 1", resp);
      return ok();
    }

    const resp = await sendMessage(reqData.message.chat.id, "need authorize");
    console.log("resp 2", resp);
    return ok();
  }

  return ok();
} 6.6 Validate photo. If user doesn’t sent to us a photo, we need to talk about it ...

export async function POST(request: Request) {
  ...

  if (!reqData.message.photo) {
    const resp = await sendMessage(reqData.message.chat.id, `not found photos`);
    console.log("resp validate", resp);
    return ok();
  }
  return ok();
} 6.7 Download photo. If all checks are passed, download the sent photo import { downloadFile, getFile } from "@/app/helpers/tg";

export async function POST(request: Request) {
  ...
  let photo = reqData.message.photo[reqData.message.photo.length - 1];

  let file = await getFile(photo.file_id);
  console.log("file", file);

  let data = await downloadFile(file.result.file_path);

  return ok();
} 6.8 Save to IPFS. ...
import { uploadFile } from "@/app/helpers/ipfs";
...
export async function POST(request: Request) {
  ...
  const respNft = await uploadFile("image", data);
  console.log("respNft", respNft);

  const respMetadata = await uploadFile(
    "metadata.json",
    new Blob(
      [
        JSON.stringify({
          name: reqData.message.caption,
          image: `ipfs://${respNft.Hash}`,
        }),
      ],
      { type: "application/json" },
    ),
  );

  return ok();
} 6.9 mint users NFT. After we save all data into IPFS, we can mint NFT. const nftAbi =
  require("@/artifacts/contracts/TelegramBot.sol/TelegramBot.json").abi;

export async function POST(request: Request) {
  ...

  const nftContract = new ethers.Contract(
    process.env.NEXT_NFT_ADDRESS as string,
    nftAbi,
    signer,
  );

  const mint = await nftContract.safeMint(
    address,
    `ipfs://${respMetadata.Hash}`,
  );

  console.log("mint", mint);

  const respMint = await sendMessage(
    reqData.message.chat.id,
    `tx hash: ${mint.tx_hash}`,
  );
  console.log("resp mint", respMint);

  return ok();
} Done =) 7. Conclusion This is the simplest possible implementation, which has some usability problems but is enough to understand the principles of operation. There are plans to make a web version using Metamask, which NEXT was used for. I tried not to use libraries to communicate with Telegram and IPFS so that there would be more understanding of how it works and you can install the library very quickly. I hope this will be enough to understand the principles of operation. The source code is on . GitHub

Dive into Web3 Contracts with Hardhat and Node.js Vol.3 

The modern world of web development is growing every day, and almost every day, new technologies simplify development. As they say, modern solutions require modern problems. Hence, people invented web3, which allows you to create amazing applications using smart contracts with almost no effort (at least they try, and using Copilot brings this wonderful moment even closer). In this post, we'll dive deeper into Web3 contracts and learn how to set them up using Hardhat and Node.js. 1. What Are Web3 and Smart Contracts? Web3 refers to a new paradigm for applications on the internet and represents the third epoch of the web. The history of the Internet can be divided into the following epochs: The first epoch (Web1) brought us static web pages. The current(second) epoch (Web 2.0) introduced interactive websites and social media. The next(third) epoch (Web3), however, promises an internet driven by blockchain technology. Smart contracts are a fundamental feature of Web3. They are not "smart" or "contracts" traditionally. Instead, they are programmable contracts automatically executed when predetermined conditions are met. They operate on the blockchain, providing transparency, security, and decentralization. 2. Why Hardhat? There are various tools available for smart contract development, but Hardhat stands out for a few reasons: It offers a development environment, testing framework, and asset pipeline. A local Ethereum network for development. I liked it more than ganache library =) 3. Why Node.js? Node.js (and JavaScript at all) is a popular runtime that allows developers to use JavaScript on the server side. For Web3 development, it can be useful because society provides a vast repository of libraries, and some of them can be used for web3 development. A moment of bragging and self-promotion: I can write all this in the Rust language, but JS in this context is much easier to understand and reaches a broader audience. 4. Setting up Your Development Environment : Install Node.js and initialize project You need to have installed Node.js (from myself, I can recommend using nvm). After you have prepared the environment, let's initialize the project. mkdir dive-web3
cd dive-web3
npm init -y : Setting up Hardhat Install Hardhat: npm install --save-dev hardhat Run the Hardhat setup: npx hardhat init Follow the setup prompts. In my case, it will be next: 888    888                      888 888               888
888    888                      888 888               888
888    888                      888 888               888
8888888888  8888b.  888d888 .d88888 88888b.   8888b.  888888
888    888     "88b 888P"  d88" 888 888 "88b     "88b 888
888    888 .d888888 888    888  888 888  888 .d888888 888
888    888 888  888 888    Y88b 888 888  888 888  888 Y88b.
888    888 "Y888888 888     "Y88888 888  888 "Y888888  "Y888

👷 Welcome to Hardhat v2.17.4 👷‍

✔ What do you want to do? · Create a TypeScript project
✔ Hardhat project root: · /Users/username/work/web3-dive
✔ Do you want to add a .gitignore? (Y/n) · y
✔ Do you want to install this sample project's dependencies with npm (@nomicfoundation/hardhat-toolbox)? (Y/n) · y I chose TypeScript because it’s more convenient for me, but you can choose JavaScript, and IMHO nothing changes. 5.  Your First Smart Contract In the directory, create a new file named : contracts SimpleStorage.sol pragma solidity ^0.8.0;

contract SimpleStorage {
    uint256 private _storedValue;

    function set(uint256 value) public {
        _storedValue = value;
    }

    function get() public view returns (uint256) {
        return _storedValue;
    }
} This contract simply stores a number and allows you to retrieve it. After we finish with our contract, we need to compile it… npx hardhat compile And test it… Create a test file in the directory, e.g., : test simpleStorageTest.js const { expect } = require("chai");

describe("SimpleStorage", function() {
  it("Should return the new value once it's changed", async function() {
    const SimpleStorage = await ethers.getContractFactory("SimpleStorage");
    const simpleStorage = await SimpleStorage.deploy();

    await simpleStorage.deployed();
    await simpleStorage.set(23);
    expect(await simpleStorage.get()).to.equal(23);
  });
}); Run the test: npx hardhat test That's it, now we are skilled web3 developers. 6. Deploying Your Contract First, we need to create a deploy script. Create in directory: deploySimpleStorage.js scripts import { ethers } from "hardhat";

async function main() {
  const lock = await ethers.deployContract("SimpleStorage");

  await lock.waitForDeployment();

  console.log(`SimpleStorage deployed to ${lock.target}`);
}

// We recommend this pattern to be able to use async/await everywhere
// and properly handle errors.
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
}); Before you deploy your contract, you need to specify the network in or start the hardhat node (in another tab of your terminal): hardhat.config.js npx hardhat node After this command, you will next see: Started HTTP and WebSocket JSON-RPC server at http://127.0.0.1:8545/

Accounts
========

WARNING: These accounts, and their private keys, are publicly known.
Any funds sent to them on Mainnet or any other live network WILL BE LOST.

Account #0: 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266 (10000 ETH)
Private Key: 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80

Account #1: 0x70997970C51812dc3A010C7d01b50e0d17dc79C8 (10000 ETH)
Private Key: 0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d

....

WARNING: These accounts, and their private keys, are publicly known.
Any funds sent to them on Mainnet or any other live network WILL BE LOST. Just remember, it is temporary, and after you stop the node, all data in the node will be lost. For now, you need to run the deploy script : npx hardhat run scripts/deploySimpleStorage.ts As result of this program you can see address of your deployed contract SimpleStorage deployed to 0x5FbDB2315678afecb367f032d93F642f64180aa3 7. Conclusion* The combination of Hardhat and Node.js offers a powerful environment for developing, testing, and deploying smart contracts in the Web3 ecosystem. As you delve deeper, you'll find an expansive community and myriad plugins and tools to enhance your development process. Boooring… I have seen this guide many times, some readers may say, and I apologize for wasting their time and promise to make a continuation of the article with the prize draw contract and the NFT contract (I know this will be a very timely post) As we know from the history of development in Web 2.0, any library becomes outdated approximately yesterday, so everything described in this article may become outdated approximately tomorrow, so I strongly recommend studying the official documentation Links: https://hardhat.org/hardhat-runner/docs/getting-started (really useful resource) https://docs.opensea.io/docs/1-structuring-your-smart-contract

Dive Into Web3 Contracts With Hardhat and Node.js

IoT Performance Load Testing with Locust and Azure [Continuous Delivery]

In a previous , we discussed the importance of verifying Solidity smart contracts before deploying them onto the blockchain. However, there is a way to automate that process and make it more efficient. blog post With the help of Hardhat, a popular development environment for Ethereum, developers can now verify their smart contract code programmatically as part of the deployment process. This means the verification process can be integrated into the development pipeline, ensuring the code is verified automatically each time the contract is deployed. This blog post will explore how to use Hardhat to verify smart contract codes and streamline the verification process programmatically. Hardhat Runtime Environment HRE stands for Hardhat Runtime Environment. It provides a robust set of tools and APIs that can be used to verify the correctness of a smart contract code programmatically. Verification is an essential step in the development process of smart contracts, as it ensures that the code behaves as intended and is secure. Verifying Smart Contracts Programmatically To programmatically verify a smart contract with HRE, we should use a plugin called in combination with the HRE subtask . hardhat-etherscan verify:verify To verify the smart contract automatically, we need to pass: the network name that we can get from the Hardhat Network addon; smart contract address, constructor arguments. We should wait for the deployment transaction to be finished to avoid problems when verifying a smart contract that hasn't been deployed yet. Let's now put it all together in a Hardhat script. import hre, { network, ethers } from "hardhat";

async function main() {
  const SaveNumber = await ethers.getContractFactory("SaveNumbero");

  const number = 6;

  const saveNumber = await SaveNumber.deploy(number);

  await saveNumber.deployed();

  console.log(`SecretNumber deployed to ${saveNumber.address}`);

  try {
    console.log("\nEtherscan verification in progress...");
    await saveNumber.deployTransaction.wait(6);
    await hre.run("verify:verify", {
      network: network.name,
      address: saveNumber.address,
      constructorArguments: [number],
    });
    console.log("Etherscan verification done. ✅");
  } catch (error) {
    console.error(error);
  }
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
}); TL;DR Automated smart contract verification with HRE provides a much more streamlined and efficient way to verify smart contract code than manually verifying it from the terminal. It saves time and reduces the chances of errors compared to manual verification from the terminal. Links How Hardhat Simplifies Smart Contract Verification on Ethereum Hardhat Runtime Environment (HRE) documentation hardhat-verify

How to Programmatically Verify Solidity Smart Contract Code With Hardhat

Building an Ethical Text-to-Image AI-Art Site That Pays Royalties to Original Creators

The Complete Asynchronous Programming Primer for Unity Development

ইউনিটি ডেভেলপমেন্টের জন্য সম্পূর্ণ অ্যাসিঙ্ক্রোনাস প্রোগ্রামিং প্রাইমার

Die vollständige Einführung in die asynchrone Programmierung für die Unity-Entwicklung

El manual completo de programación asíncrona para el desarrollo de Unity

L'introduction complète à la programmation asynchrone pour le développement Unity

एकता विकास के लिए पूर्ण अतुल्यकालिक प्रोग्रामिंग प्राइमर

Unity 開発のための完全な非同期プログラミング入門

Unity 개발을 위한 완벽한 비동기 프로그래밍 입문서

O Primer completo de programação assíncrona para desenvolvimento Unity

Unity Geliştirme için Eksiksiz Eşzamansız Programlama Başlangıç Kılavuzu

Công cụ lập trình không đồng bộ hoàn chỉnh để phát triển Unity

Unity 开发的完整异步编程入门

Today, In this post we wanted to outline changes and features that you can expect with the Lavarel 10 update. Laravel v10 is the next major version of Laravel, after Laravel v9 and Laravel v8, planned for release in February 2023. Laravel 10 Release Date Before Laravel 9, major framework versions were released twice a year or roughly every six months. Starting with Laravel 9, the core team went to an annual schedule, shipping Laravel 9 in February 2022 (instead of the originally planned September 2021). This schedule going forward is one major release annually: Laravel 9: February 8th, 2022 Laravel 10: February 2023 Laravel 11: February 2024 Laravel 9 will continue to get bug fixes until August 8th, 2023, and security fixes until February 6th, 2024. You can expect Laravel 10 bug fixes until August 6th, 2024, and security fixes until February 4th, 2025. Process Layer The laravel process layer service, like the HTTP facade, makes working with APIs a cinch. The process service will make working with, Testing, and running a process a dream to work with. You can check the following example from by . CLI Pull request Taylor Otwell use Illuminate\Support\Facades\Process;

$result = Process::run('ls -la');

$result->successful();
$result->failed();
$result->exitCode();
$result->output();
$result->errorOutput();
$result->throw();
$result->throwIf(condition); Which includes the features such as: Fluent process methods to build a process instance before running it Process Pools Preventing stray processes during tests Rich testing features via fake() Asynchronous processes Laravel 10 drops support for PHP 8.0 Laravel framework will drop support for in Laravel 10. The minimum required version is . PHP <=v8.0 PHP ^8.1 Native type declarations in Laravel 10 skeleton Laravel 10 will use native PHP type declarations across any generated code that can exist in userland: https://twitter.com/taylorotwell/status/1592227118481805312?ref_src=twsrc^tfw|twcamp^tweetembed|twterm^1592227118481805312|twgr^29941c99d091f426b98c0156908eef9e8262f3e5|twcon^s1_&ref_url=https%3A%2F%2Flaravel-news.com%2Flaravel-10-type-declarations&embedable=true Types are being added in a way that brings the latest PHP type-hinting features to Laravel projects without breaking backward compatibility at the framework level: Return types Method arguments Allow user land types in closure arguments Does not include typed properties Invokable Validation rules are the default Starting in laravel 10, are now default. s Invokable Validation When you create a new validation rule via artisan, this is what you can expect: # Laravel 9 creates a rule class that implements the
# Illuminate\Contracts\Validation\Rule interface
artisan make:rule Uppercase

# Laravel 9 flag to create an invokable and implicit rule
artisan make:rule Uppercase --invokable
artisan make:rule Uppercase --invokable --implicit

# Laravel 10 creates an invokable rule by default
artisan make:rule Uppercase

# Laravel 10 implicit rule
artisan make:rule Uppercase --implicit Profile option for tests A new feature coming to Laravel 10 is a option that will make it easy for you to find any slow tests in your application. --profile Deprecations from Laravel 9 Here are some deprecations found in the of the Laravel framework's master branch to the 9. x branch at the time of writing: comparison Remove method handleDeprecation Remove deprecated method assertTimesSent Remove deprecated property ScheduleListCommand's $defaultName Remove deprecated method Route::home Remove deprecated functionality. dispatchNow Testing Laravel 10 If you want to start testing Laravel 10 now, you can install it in a fresh project by using the flag: --dev laravel new <your-project-name> --dev We will be updating this post as those get announced. Thank You! Cheers... Happy Coding! Originally published here.

Stories, News & Mentions about EXIT7C

Exit7c’s Stories on HackerNoon

Exit7c's News & Mentions