Peera is a decentralized questions and answers protocol for Web3 where users can organize and store their interests and skills, creating a common community platform

Peera Meta

Aave is a decentralized non-custodial liquidity protocol where users can participate as depositors or borrowers.

Aave

Solidity is an object-oriented, high-level language for implementing smart contracts. It is a curly-bracket language designed to target the Ethereum Virtual Machine (EVM).

Solidity

Ankr makes accessing Web3 easy for those who want to build and earn on the future web. Ankr is the main infrastructure provider for Polygon, BNB Smart Chain, and Fantom.

Ankr

Vyper is a relatively new, pythonic programming language used to write smart contracts. Vyper targets Ethereum Virtual Machine making it virtually impossible for developers to code misleading programs.

Vyper

Functionland is replacing Cloud Storage and Service Subscription economy by introducing a new category of products, called Blockchain-Attached Storage. It creates value by auto-minting crypto for the users and allocating a share to the developers.

Functionland

Fractal Visions is a builder owned and operated creative web3 NFT project hub and a multifaceted & multidimensional experience. Bridging the gap between the physical and digital world.

Fractal Visions

D_D Academy is an open-source education platform created by the Developer DAO.

D_D Academy

Cyfrin Updraft is an education platform specializing on teaching the next generation of smart contract developers 

Cyfrin Updraft

The Graph is a decentralized protocol for indexing and querying blockchain data. The Graph makes it possible to query data that is difficult to query directly.

The Graph

Polygon is a decentralised Ethereum scaling platform that enables developers to build scalable user-friendly dApps with low transaction fees without ever sacrificing on security.

Polygon

Web3 (also known as Web 3.0) is an idea for a new iteration of the World Wide Web which incorporates concepts such as decentralization, blockchain technologies, and token-based economics.

All Things Web3

Koii is a new way to design communications infrastructure that distributes computing authority across a wider group of personal devices.

Koii Network

I deployed my contract with npx hardhat run scripts/deploySurfaceReachT1NFT.ts --network mumbai. My deploy script looks like this:  

const hre = require("hardhat");

```
async function main() {
  const SurfaceReachT1NFT = await hre.ethers.getContractFactory("SurfaceReachT1NFT");
  const surfaceReachT1NFT = await SurfaceReachT1NFT.deploy("surfaceReachT1NFT", "SRT1", "https://", "https://");
  await surfaceReachT1NFT.deployed();
  console.log("SurfaceReach1NFT deployed to:", surfaceReachT1NFT.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
```

I tried running `npx hardhat verify --network mumbai 0x7C92EA6b2465f49FE2195F2FCFe00d43FD06faAc "SurfaceReachT1NFT" "SRT1" "https://"` but I got this error in my terminal:

```
MYUSERNAME@MYCOMPUTERNAME nft-hh-whitelist % npx hardhat verify --network mumbai 0x7C92EA6b2465f49FE2195F2FCFe00d43FD06faAc "SurfaceReachT1NFT" "SRT1" "https://" "https://" --show-stack-traces
Nothing to compile
No need to generate any newer typings.
Successfully submitted source code for contract
contracts/SurfaceReachT1NFT.sol:SurfaceReachT1NFT at 0x7C92EA6b2465f49FE2195F2FCFe00d43FD06faAc
for verification on the block explorer. Waiting for verification result...

We tried verifying your contract SurfaceReachT1NFT without including any unrelated one, but it failed.
Trying again with the full solc input used to compile and deploy it.
This means that unrelated contracts may be displayed on Etherscan...

Successfully submitted source code for contract
contracts/SurfaceReachT1NFT.sol:SurfaceReachT1NFT at 0x7C92EA6b2465f49FE2195F2FCFe00d43FD06faAc
for verification on the block explorer. Waiting for verification result...

Error in plugin @nomiclabs/hardhat-etherscan: The contract verification failed.
Reason: Fail - Unable to verify

NomicLabsHardhatPluginError: The contract verification failed.
Reason: Fail - Unable to verify
    at SimpleTaskDefinition.verifySubtask [as action] (/Users/MYUSERNAME/Desktop/path/to/repo/nft-hh-whitelist/node_modules/@nomiclabs/hardhat-etherscan/src/index.ts:375:9)
    at processTicksAndRejections (node:internal/process/task_queues:95:5)
    at async Environment._runTaskDefinition (/Users/MYUSERNAME/Desktop/path/to/repo/nft-hh-whitelist/node_modules/hardhat/src/internal/core/runtime-environment.ts:330:14)
    at async Environment.run (/Users/MYUSERNAME/Desktop/path/to/repo/nft-hh-whitelist/node_modules/hardhat/src/internal/core/runtime-environment.ts:163:14)
    at async Environment._runTaskDefinition (/Users/MYUSERNAME/Desktop/path/to/repo/nft-hh-whitelist/node_modules/hardhat/src/internal/core/runtime-environment.ts:330:14)
    at async Environment.run (/Users/MYUSERNAME/Desktop/path/to/repo/nft-hh-whitelist/node_modules/hardhat/src/internal/core/runtime-environment.ts:163:14)
    at async main (/Users/MYUSERNAME/Desktop/path/to/repo/nft-hh-whitelist/node_modules/hardhat/src/internal/cli/cli.ts:277:7)
MYUSERNAME@MYCOMPUTERNAME nft-hh-whitelist %
```

This is my config file:  

```
import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import "./tasks";
const dotenv = require("dotenv");
dotenv.config();

const privKey = process.env.REACT_APP_PRIVATE_KEY ? process.env.REACT_APP_PRIVATE_KEY : '0x0000000000000000000000000000000000000000000000000000000000000000';

const config: HardhatUserConfig = {
  solidity: "0.8.18",
  networks: {
    sepolia: {
      url: process.env.REACT_APP_RINKEBY_RPC_URL,
      accounts: [privKey]
    },
    localhost: {
      url: "http://127.0.0.1:8545",
      accounts: [privKey]
    },
    mumbai: {
      url: process.env.REACT_APP_POLYGON_RPC_URL,
      accounts: [privKey]
    }
  },
  etherscan: {
    apiKey: process.env.REACT_APP_ETHERSCAN_KEY
  }
};
    
export default config;
```

I made my API key (REACT_APP_ETHERSCAN_KEY) by going to https://polygonscan.com, creating an account, and creating a new API key. I know the contract is deployed on mumbai testnet but you can't create an account and login on https://mumbai.polygonscan.com/.  

So why is the verify command failing?

My ERC721 contract successfully deploys, but I can't verify the contract's source code with hardhat

This script:  
```
const { ethers } = require('ethers');

async function recoverSigner(address, nonce, deadline, v, r, s) {
    const domain = {
        name: "RandomReachDebug5Local",
        version: "1",
        chainId: 31337,
        verifyingContract: "0x8464135c8F25Da09e49BC8782676a84730C318bC",
    };
    const types = {
        RequestRandomNFT: [
            { name: 'minter', type: 'address' },
            { name: 'nonce', type: 'uint256' },
            { name: 'deadline', type: 'uint256' },
        ],
    };
    const value = {
        minter: address,
        nonce: nonce,
        deadline: deadline,
    };

    // Get the digest of the message
    const digest = ethers.utils._TypedDataEncoder.hash(domain, types, value);
    
    const sig = {
        r: r,
        s: s,
        v: v,
    };

    if (sig.v < 27) {
        sig.v += 27;
    }

    const signer = ethers.utils.recoverAddress(digest, sig);
    
    return signer;
}

const address = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266";
const nonce = "0";
const deadline = "1685162164";
const v = "28";
const r = "0xe0e4cc2f8b6bac3784f9feb3db4382291631d5f317d08a0b82305e5eb5ffc60a";
const s = "0x0416d521d12e26b8fc1f4bd566d5d67c5dffebe9564fe90db4f12c0a69b63d5e";

async function run() {
    try {
        const signer = await recoverSigner(address, nonce, deadline, v, r, s);
        console.log(`The signer is: ${signer}`);
    } catch (error) {
        console.error(`Error in recovering signer: ${error}`);
    }
}

run();
```  
Produces this output: The signer is: 0x1AB26702A8068a247BD33a9555dfEf791d2BD68D  
<br />

But this solidity contract:

```
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.18;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";

contract GetAddressFromSig is ERC721, EIP712 {
    struct Request {
        address minter;
        uint256 nonce;
        uint256 deadline;
    }

    bytes32 public constant REQUEST_TYPEHASH = keccak256("Request(address minter,uint256 nonce,uint256 deadline)");

    // Initialize _DOMAIN_SEPARATOR directly with static values
    bytes32 private immutable _DOMAIN_SEPARATOR = keccak256(
        abi.encode(
            keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
            keccak256(bytes("RandomReachDebug5Local")), // static name
            keccak256(bytes("1")), // static version
            31337, // static chainId
            0x8464135c8F25Da09e49BC8782676a84730C318bC // static verifyingContract
        )
    );

    constructor(string memory name, string memory symbol) ERC721(name, symbol) EIP712(name, "1") {}

    function domainSeparator() public view returns (bytes32) {
        return _DOMAIN_SEPARATOR;
    }

    function recoverSigner(Request memory request, uint8 v, bytes32 r, bytes32 s) public view returns (address) {
        bytes32 digest = keccak256(
            abi.encodePacked(
                "\x19\x01",
                _DOMAIN_SEPARATOR,
                keccak256(
                    abi.encode(
                        REQUEST_TYPEHASH,
                        request.minter,
                        request.nonce,
                        request.deadline
                    )
                )
            )
        );

        // ECDSA.recover returns the address that is associated with the public key 
        // that was used to sign the given data, in this case, the digest.
        return ECDSA.recover(digest, v, r, s);
    }
}
```  
<br />

Deployed with this script in hardhat:

```
import { ethers } from "hardhat";

const hre = require("hardhat");
const dotenv = require("dotenv");
dotenv.config();

async function main() {
  const GetAddressFromSig = await hre.ethers.getContractFactory("GetAddressFromSig");
  const gasPrice = await GetAddressFromSig.signer.getGasPrice();
  console.log(`Current gas price: ${gasPrice}`);
  const estimatedGas = await GetAddressFromSig.signer.estimateGas(
    GetAddressFromSig.getDeployTransaction("RANDOM NFT 5", "RNFT5"),
  );
  console.log(`Estimated gas: ${estimatedGas}`);
  const deploymentPrice = gasPrice.mul(estimatedGas);
  const deployerBalance = await GetAddressFromSig.signer.getBalance();
  console.log(`Deployer balance:  ${ethers.utils.formatEther(deployerBalance)}`);
  console.log(`Deployment price:  ${ethers.utils.formatEther(deploymentPrice)}`);
  const getAddressFromSig = await GetAddressFromSig.deploy("RANDOM NFT 5", "RNFT5");

  await getAddressFromSig.deployed();

  console.log("GetAddressFromSig deployed to:", getAddressFromSig.address);
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });
```  
<br />

And ran with these commands in the hardhat console:  
```
const Token = await ethers.getContractFactory("GetAddressFromSig");
const token = await Token.attach("0x8464135c8F25Da09e49BC8782676a84730C318bC");
const request = { minter: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", nonce: ethers.BigNumber.from("0"), deadline: ethers.BigNumber.from("1685162164") };
const v = 28
const r = "0xe0e4cc2f8b6bac3784f9feb3db4382291631d5f317d08a0b82305e5eb5ffc60a";
const s = "0x0416d521d12e26b8fc1f4bd566d5d67c5dffebe9564fe90db4f12c0a69b63d5e";
const signer = await token.recoverSigner(request, v, r, s);
console.log(`The signer is: ${signer}`);
```

Gives this output: The signer is: 0xeB7265f6625EaE66403a637c073E63ccf33b8Cdc

So why does the javascript calculate 0x1AB26702A8068a247BD33a9555dfEf791d2BD68D, while hardhat's solidity compiler calculates 0xeB7265f6625EaE66403a637c073E63ccf33b8Cdc?

Solidity and ethers.js Compute Different Addresses from the Same Signature

I don't understand what are the uint256 of Location, and newLocation, can someone explain to me, where are they? Thank you.
Below is the code:

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.18;

import {AFoundryCourseChallenge} from "AFoundryCourseChallenge.sol";
import {LessonThreeHelper} from "3-LessonHelper.sol";

contract LessonThree is AFoundryCourseChallenge, LessonThreeHelper {
    error LessonThree__WrongLocation();

    string private constant LESSON_IMAGE = "ipfs://QmfWyPRrx1sx7sfgrwr4pNMWtqVLXMwCP4fej39m2fPfYe";

    constructor(address fcn) AFoundryCourseChallenge(fcn) {
        s_booleanArray = [false, false, false, true, false];
    }

    /*
     * CALL THIS FUNCTION!
     * 
     * @param location - The location of the true boolean. 
     * @param newLocation - Pick the spot of the boolean for the next person!
     * @param yourTwitterHandle - Your twitter handle. Can be a blank string.
     */
    function solveChallenge(uint256 location, uint256 newLocation, string memory yourTwitterHandle) external {
        if (s_booleanArray[location] != true) {
            revert LessonThree__WrongLocation();
        }
        s_booleanArray[location] = false;
        s_booleanArray[newLocation] = true;
        _updateAndRewardSolver(yourTwitterHandle);
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
    /////////////////// The following are functions needed for the NFT, feel free to ignore. ///////////////////
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
    function description() external pure override returns (string memory) {
        return "Cyfrin Foundry Full Course: You've inherited skillz from solidity!";
    }

    function attribute() external pure override returns (string memory) {
        return "Inheritance and factory pattern knowledgable";
    }

    function specialImage() external pure override returns (string memory) {
        return LESSON_IMAGE;
    }
}

can't understand what are the locations(uint256)

I need help with the following code where I'm given the keccak256 of a parameter and need to reverse it to find the parameter to solve the challenge

```solidity
contract LessonFive is AFoundryCourseChallenge {
    error LessonFive__WrongPassword();

    bytes32 public constant EXPECTED_BYTES = 0xb68fe43f0d1a0d7aef123722670be50268e15365401c442f8806ef83b612976b;


    /*
     * CALL THIS FUNCTION!
     * 
     * Use all the help you can on this one! Google, AI, friends, peeranha, ethereum stack exchange, etc. 
     * 
     * Hint: It's a very common...
     * 
     * @param password - A string that when you keccak256 it will return the `EXPECTED_BYTES`!
     * @param yourTwitterHandle - Your twitter handle. Can be a blank string.
     */
    function solveChallenge(string memory password, string memory yourTwitterHandle) external {
        if (keccak256(abi.encodePacked(password)) == EXPECTED_BYTES) {
            _updateAndRewardSolver(yourTwitterHandle);
        } else {
            revert LessonFive__WrongPassword();
        }
    }
}
```

How to reverse keccak256 in solidity

Hey everyone,

I'm trying to deepen my understanding of certain conditions in smart contract development, and I have a question about a specific scenario.

Let's say there's a "require" condition in a smart contract that must be met. If this condition fails, the contract needs to revert all changes made and refund any gas used in the transaction. My question is, how does the gas refund process work considering that gas is always consumed during computation?

Additionally, I've heard about the "revert" condition but would appreciate some clarification on how it differs from "require" in smart contract development.

Artikel

Bildungsmaterialien und Tutorials über Solidity

Beiträge

Verdiene deinen Anteil an 1000 Sui