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

这个脚本： 
```
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}`);
```

给出这样的输出：签名者是：0xeb7265f6625eae66403a637c073e63ccf33b8CDC

那么为什么 javascript 会计算 0x1ab26702a8068a247bd33a9555dfef791d2bd68D，而 hardhat 的 solidity 编译器会计算 0xeb7265f6625ea66403a637c073e63ccf33b8CDC？

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

Solidity 和 ethers.js 用同一个签名计算出不同的地址

我不明白 Location 和 newLocation 的 uint256 是什么，有人能向我解释一下，它们在哪里吗？谢谢. 
以下是代码：

//spdx 许可证标识符：麻省理工学院

pragma solidity ^0.8.18；

从 “afoundryCourseChallenge.sol” 导入 {afoundryCourseChallenge}；
从 “3-lessonHelper.sol” 导入 {lessonThreeHelper}；

contract lessonThree 是 FoundryCourseChallenge，lesson
 错误 lessonThree__wronLocation ()；

 字符串私有常量 LESSON_IMAGE = “ipfs: //qmfwyprrx1sx7sfgrwr4pnmwtqvlxcp4fej39m2fpfye”；

 构造函数（地址 fcn）afoundryCourseChallenge (fcn) {
 s_booleanArray = [假、假、假、真、假]；
 }

 /*
 * 调用这个函数！
 * 
 * @param location-真实布尔值的位置.  
 * @param newLocation-为下一个人选择布尔值的位置！
 * @param YourTwitterHandle-你的推特账号. 可以是空字符串. 
 */
 函数 solveChallenge（uint256 位置，uint256 newLocation，字符串内存 yourTwitter Handle）
 if (s_booleanArray [位置]!= 真的）{
 还原第三课__错误位置 ()；
 }
 s_booleanArray [location] = false；
 s_booleanArray [newLocation] = 真；
 _updateAndrewardSolver（你的推特账号）；
 }

 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 ///////////////////以下是 NFT 所需的函数，请随意忽略. ///////////////////
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 函数描述 () 外部纯覆盖返回（字符串内存）{
 返回 “Cyfrin Foundry 完整课程：你从坚固中继承了技能！”;
 }

 函数属性 () 外部纯覆盖返回（字符串内存）{
 返回 “继承和工厂模式可知”；
 }

 函数 specialImage () 外部纯覆盖返回（字符串内存）{
 返回 LESSON_IMAGE；
 }
}

can't understand what are the locations(uint256)

不明白有哪些位置 (uint256)

我需要以下代码的帮助，其中给了我一个参数的 keccak256，需要反转它才能找到解决挑战的参数

```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

如何在 solidity 中反转 keccak256

嘿大家，

我正在努力加深��智能合约开发中某些条件的理解，我有一个关于特定场景的问题. 

假设智能合约中有一个 “要求” 条件必须得到满足. 如果此条件失效，合同需要恢复所有更改，并退还交易中使用的任何汽油. 我的问题是，考虑到在计算过程中总是消耗汽油，汽油退款流程是如何运作的？

此外，我听说过 “还原” 条件，但如果能澄清一下它与智能合约开发中的 “要求” 有何不同，我将不胜感激. 

文章

关于Solidity的教育材料和教程

赚取你的 1000 Sui 份额

帖子