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

Kịch bản này: 
```
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}`);
```

Cung cấp cho đầu ra này: người ký là: 0xEB7265F6625EAE66403A637C073E63CCF33B8CDC

Vậy tại sao javascript tính 0x1AB26702A8068A247BD33A9555DFEF791D2BD68D, trong khi trình biên dịch solidity của hardhat tính 0xEB7265F6625EAE66403A637C073E63CCF33B8CDC?

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

Solidity và ethers.js Tính toán các địa chỉ khác nhau từ cùng một chữ ký

Tôi không hiểu uint256 của Location và NewLocation là gì, ai đó có thể giải thích cho tôi không, họ đang ở đâu? Cảm ơn bạn.
Dưới đây là đoạn code:

//Mã định danh giấy phép SPDX-: MIT

độ rắn thực dụng ^ 0.8.18;

nhập {aFoundryCourseChallenge} từ “AfoundryCourseChallenge.sol”;
nhập {LessonThreeHelper} từ “3-LessonHelper.sol”;

hợp đồng bài họcThree là AoundryCourseChallenge, LessonThreeHelper {
 lỗi LessOnThree__wrongLocation ();

 chuỗi hằng số riêng LESSON_IMAGE = “ipfs: //qmfWyPrRX1sX7sfGrWR4pNmWtQVLXMwCp4FeJ39m2fPfYE”;

 constructor (địa chỉ fcn) aFoundryCourseChallenge (fcn) {
 s_booleanArray = [sai, sai, sai, đúng, sai];
 }

 /*
 * GỌI CHỨC NĂNG NÀY!
 * 
 * @param location - Vị trí của boolean thật. 
 * @param newLocation - Chọn vị trí của boolean cho người tiếp theo!
 * @param YourTwitterHandle - Xử lý twitter của bạn. Có thể là một chuỗi trống.
 */
 hàm solveChallenge (vị trí uint256, uint256 newLocation, bộ nhớ chuỗi YourTwitterHandle) bên ngoài {
 if (s_booleanArray [vị trí]! = đúng) {
 hoàn nguyên bài họcThree__wrongLocation ();
 }
 S_booleanArray [vị trí] = sai;
 s_booleanArray [newLocation] = đúng;
 _UpdateAndrewardSolver (YourTwitterHandle);
 }

 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 /////////////////////Sau đây là các chức năng cần thiết cho NFT, vui lòng bỏ qua. /////////////////////
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 function description () trả về override thuần túy bên ngoài (bộ nhớ chuỗi) {
 trở lại “Khóa học đầy đủ của Cyfrin Foundry: Bạn đã thừa hưởng kỹ năng từ sự vững chắc!” ;
 }

 function attribute () trả về override thuần túy bên ngoài (bộ nhớ chuỗi) {
 trả về “Thừa kế và mẫu nhà máy có kiến thức”;
 }

 hàm specialImage () trả về override thuần túy bên ngoài (bộ nhớ chuỗi) {
 trả về LESSON_IMAGE;
 }
}

can't understand what are the locations(uint256)

không thể hiểu các vị trí là gì (uint256)

Tôi cần trợ giúp với đoạn mã sau, nơi tôi được cung cấp keccak256 của một tham số và cần đảo ngược nó để tìm tham số để giải quyết thách thức

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

Làm thế nào để đảo ngược keccak256 trong độ rắn

Chào mọi người,

Tôi đang cố gắng hiểu sâu hơn về các điều kiện nhất định trong phát triển hợp đồng thông minh và tôi có một câu hỏi về một kịch bản cụ thể.

Giả sử có một điều kiện “yêu cầu” trong hợp đồng thông minh phải được đáp ứng. Nếu điều kiện này không thành công, hợp đồng cần hoàn lại tất cả các thay đổi được thực hiện và hoàn lại bất kỳ khí nào được sử dụng trong giao dịch. Câu hỏi của tôi là, quá trình hoàn trả khí hoạt động như thế nào khi xét đến việc khí luôn được tiêu thụ trong quá trình tính toán?

Ngoài ra, tôi đã nghe nói về điều kiện “đảo ngược” nhưng sẽ đánh giá cao một số cách làm rõ về sự khác biệt của nó với “yêu cầu” trong phát triển hợp đồng thông minh.

Bài Viết

Tài liệu học tập & hướng dẫn về Solidity

Kiếm phần của bạn từ 1000 Sui

Bài viết