在Web3应用中，有一个很重要的功能就是存储文件，在传统的Web2应用开发中，我们一般会把文件存储在服务器或OSS中，在Web3我们一般把文件存储在IPFS服务中，IPFS服务可以实现文件的去中心化存储，这篇文章主要讲讲Web3应用中如何使用IPFS服务来存储文件。

一、关于 IPFS

IPFS是一种点对点的超媒体协议，即一个实现文件去中心化存储的协议，通过IPFS可以将文件分解为很多区块并存储在多个提供存储服务的服务器上，和我们Web3去中心化的概念一样，所以我们在Web3应用中文件存储一般也是使用IPFS。

提供IPFS的服务商很多：

• Pinata: Pinata是一个去中心化的文件存储平台，为开发人员和企业提供了稳定、安全、高效的文件存储和分发服务。

• nft.storage: nft.storage是一个专门针对NFT存储的去中心化平台，为开发人员和企业提供了安全、高效的NFT存储服务。

• web3.storage: Web3.storage是用于与IPFS网络和Filecoin区块链互动的网关的另一次迭代。

这次我们选择Pinata来实现IPFS上传的操作，选择其他服务商，如Web3.storage操作也是类似。

二、Pinata 服务申请Gateway及API Key

首先需要去Pinata官网申请一下Gateway和API Key。Gateway是用于最后我们展示图片路径前缀，API Key用于在Web3应用前端中调用Pinata的文件上传服务。

三、编写链端服务

这里我写了一个简单的链端服务，来新增和查询任务。

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

contract List {
    struct Task {
        uint id;
        string name;
        string ipfsHash;
        address owner;
    }

    Task[] private list;

    function createTask(string calldata name, string calldata ipfsHash) public {
        uint taskId = list.length;
        list.push(Task(
            taskId,
            name,
            ipfsHash,
            msg.sender
        ));
    }

    function getTask() public view returns (Task[] memory) {
        Task[] memory temporary = new TaskUnsupported embed;
        uint counter = 0;
        for (uint i = 0; i < list.length; i++) {
            if (list[i].owner == msg.sender) {
                temporary[counter] = list[i];
                counter++;
            }
        }
        Task[] memory result = new TaskUnsupported embed;
        for (uint i = 0; i < counter; i++) {
            result[i] = temporary[i];
        }
        return result;
    }
}

其中的ipfsHash字段就是用于前端上传文件到IPFS后，Pinata返回的Hash字段，最终要展示图片也是用这个Hash值和之前我们申请的Gateway拼接展示。

四、前端调用IPFS服务上传图片

const axios = require('axios')
const FormData = require('form-data')
const fs = require('fs')
const JWT = 'PINATA_IPFS_API_KEY'

const pinFileToIPFS = async () => {
    const formData = new FormData();
    const src = "2.jpg";

    const file = fs.createReadStream(src)
    formData.append('file', file)

    const pinataMetadata = JSON.stringify({
        name: 'testjpg',
    });
    formData.append('pinataMetadata', pinataMetadata);

    const pinataOptions = JSON.stringify({
        cidVersion: 0,
    })
    formData.append('pinataOptions', pinataOptions);

    try{
        const res = await axios.post("https://api.pinata.cloud/pinning/pinFileToIPFS", formData, {
            maxBodyLength: "Infinity",
            headers: {
                'Content-Type': `multipart/form-data; boundary=${formData._boundary}`,
                'Authorization': `Bearer ${JWT}`
            }
        });
        console.log(res.data);
    } catch (error) {
        console.log(error);
    }
}
pinFileToIPFS()

前端主要axios去调用Pinata提供的IPFS上传接口上传文件，上传成功后在res.data中会响应一个IpfsHash字段，我们再把这个字段提供给智能合约存储即可。

最后在前端展示图片时通过https://<your-gateway-domain>/ipfs/<IpfsHash>拼接展示即可。

具体文档也可参考Pinata官网文档：点此查看

五、案例及源码

这个我写一个完整的案例，源码也开源给大家参考：

• 案例演示：点此查看

• 链端源码：点此查看

• 前端源码：点此查看

到此就实现了在Web3应用中通过Pinata提供的IPFS服务实现上传文件的操作，希望各位小伙伴给我多多点赞、收藏哦~

在我们做去中心化应用开发时，其中有两个头疼的问题，一是想要获取去中心化的一些数据，如代币价格等，还有一个就是安全的创建随机数，这篇文章带大家了解一下这两块的实际应用。

一、调用 Chainklink 获取外部数据

1. Chainlink 预言机介绍

由于智能合约无法调用外部 API 这一特性，所以诞生了预言机这个机制用来帮助智能合约获取外部数据，除了应用最广泛的价格数据以外，还包括一些天气数据，体育比赛数据，股票市场数据，交通数据，甚至包括总统选结果等数据。

除了提供数据，预言机广义上的功能也包括提供随机数和作为触发器实现智能合约执行，它们都算是链下的工具来和链上的合约进行交互。

而 Chainlink 是目前预言机数据的最大提供平台。

2. Chainlink 获取数据示例

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

/**
 * THIS IS AN EXAMPLE CONTRACT THAT USES HARDCODED
 * VALUES FOR CLARITY.
 * THIS IS AN EXAMPLE CONTRACT THAT USES UN-AUDITED CODE.
 * DO NOT USE THIS CODE IN PRODUCTION.
 */

/**
 * If you are reading data feeds on L2 networks, you must
 * check the latest answer from the L2 Sequencer Uptime
 * Feed to ensure that the data is accurate in the event
 * of an L2 sequencer outage. See the
 * https://docs.chain.link/data-feeds/l2-sequencer-feeds
 * page for details.
 */

contract DataConsumerV3 {
    AggregatorV3Interface internal dataFeed;

    /**
     * Network: Sepolia
     * Aggregator: BTC/USD
     * Address: 0x1b44F3514812d835EB1BDB0acB33d3fA3351Ee43
     */
    constructor() {
        dataFeed = AggregatorV3Interface(
            0x1b44F3514812d835EB1BDB0acB33d3fA3351Ee43
        );
    }

    /**
     * Returns the latest answer.
     */
    function getPrice() public view returns (int) {
        // prettier-ignore
        (
            /* uint80 roundID */,
            int answer,
            /*uint startedAt*/,
            /*uint timeStamp*/,
            /*uint80 answeredInRound*/
        ) = dataFeed.latestRoundData();
        return answer / (10 ** 8);
    }
}

上面是一个获取BTC/USD价格的智能合约示例。

• 首先 import名为AggregatorV3Interface的接口，这个接口由chainlink官方的包提供。

• constructor构造函数中，初始化一个名为dataFeed的AggregatorV3Interface接口对象，在初始化的接口函数中传入Chainklink部署的对应BTC/USD价格的合约地址，这里因为是用的Sepolia测试网，具体每个网络可以获取哪些价格数据的合约地址，点此查看

• 最后通过一个getPrice函数调用dataFeed的latestRoundData方法来获取价格，返回的answer参数就是具体的价格，但每个交易对的金额精度不一样，一般要除以金额精度才是真正的USD单位，如这里的精度是8，最终answer需要除以10 ** 8才是USD

3. 通过 Remix 部署合约测试

我们的智能合约需要调用Sepolia其他智能合约，所以没办法直接在本地测试，需要部署到Sepolia测试网上，建议通过Remix来部署

首先在MetaMask钱包中添加Sepolia网络，然后在Remix部署界面选择使用MetaMask钱包部署，最后点击Deploy按钮部署。

部署成功后就可以看到我们已经部署的智能合约，执行getPrice方法来获取价格。

更详细的获取外部数据文档，点此查看官方文档

二、调用 Chainlink 生成随机数

1. Solidity 直接生成随机数

/** 
* 链上伪随机数生成
* 利用keccak256()打包一些链上的全局变量/自定义变量
* 返回时转换成uint256类型
*/
function getRandomOnchain() public view returns(uint256){
    // remix运行blockhash会报错
    bytes32 randomBytes = keccak256(abi.encodePacked(block.number, msg.sender, blockhash(block.timestamp-1)));
    return uint256(randomBytes);
}

主要是利用keccak256函数根据区块高度、当前调用人、时间戳等生成随机数，但是这种方法并不安全，因为结果对于矿工是可预测的，如我们做一款Web3彩票项目，矿工可以选择根据这个生成结果是否中奖选择是否上报这个区块。

2. 调用 Chainklink VRF 生成随机数示例

// SPDX-License-Identifier: MIT
// An example of a consumer contract that directly pays for each request.
pragma solidity ^0.8.7;

import "@chainlink/contracts/src/v0.8/shared/access/ConfirmedOwner.sol";
import "@chainlink/contracts/src/v0.8/vrf/VRFV2WrapperConsumerBase.sol";

/**
 * Request testnet LINK and ETH here: https://faucets.chain.link/
 * Find information on LINK Token Contracts and get the latest ETH and LINK faucets here: https://docs.chain.link/docs/link-token-contracts/
 */

/**
 * THIS IS AN EXAMPLE CONTRACT THAT USES HARDCODED VALUES FOR CLARITY.
 * THIS IS AN EXAMPLE CONTRACT THAT USES UN-AUDITED CODE.
 * DO NOT USE THIS CODE IN PRODUCTION.
 */

contract VRFv2DirectFundingConsumer is
    VRFV2WrapperConsumerBase,
    ConfirmedOwner
{
    event RequestSent(uint256 requestId, uint32 numWords);
    event RequestFulfilled(
        uint256 requestId,
        uint256[] randomWords,
        uint256 payment
    );

    struct RequestStatus {
        uint256 paid; // amount paid in link
        bool fulfilled; // whether the request has been successfully fulfilled
        uint256[] randomWords;
    }
    mapping(uint256 => RequestStatus)
        public s_requests; /* requestId --> requestStatus */

    // past requests Id.
    uint256[] public requestIds;
    uint256 public lastRequestId;

    // Depends on the number of requested values that you want sent to the
    // fulfillRandomWords() function. Test and adjust
    // this limit based on the network that you select, the size of the request,
    // and the processing of the callback request in the fulfillRandomWords()
    // function.
    uint32 callbackGasLimit = 100000;

    // The default is 3, but you can set this higher.
    uint16 requestConfirmations = 3;

    // For this example, retrieve 2 random values in one request.
    // Cannot exceed VRFV2Wrapper.getConfig().maxNumWords.
    uint32 numWords = 2;

    // Address LINK - hardcoded for Sepolia
    address linkAddress = 0x779877A7B0D9E8603169DdbD7836e478b4624789;

    // address WRAPPER - hardcoded for Sepolia
    address wrapperAddress = 0xab18414CD93297B0d12ac29E63Ca20f515b3DB46;

    constructor()
        ConfirmedOwner(msg.sender)
        VRFV2WrapperConsumerBase(linkAddress, wrapperAddress)
    {}

    function requestRandomWords()
        external
        onlyOwner
        returns (uint256 requestId)
    {
        requestId = requestRandomness(
            callbackGasLimit,
            requestConfirmations,
            numWords
        );
        s_requests[requestId] = RequestStatus({
            paid: VRF_V2_WRAPPER.calculateRequestPrice(callbackGasLimit),
            randomWords: new uint256Unsupported embed,
            fulfilled: false
        });
        requestIds.push(requestId);
        lastRequestId = requestId;
        emit RequestSent(requestId, numWords);
        return requestId;
    }

    function fulfillRandomWords(
        uint256 _requestId,
        uint256[] memory _randomWords
    ) internal override {
        require(s_requests[_requestId].paid > 0, "request not found");
        s_requests[_requestId].fulfilled = true;
        s_requests[_requestId].randomWords = _randomWords;
        emit RequestFulfilled(
            _requestId,
            _randomWords,
            s_requests[_requestId].paid
        );
    }

    function getRequestStatus(
        uint256 _requestId
    )
        external
        view
        returns (uint256 paid, bool fulfilled, uint256[] memory randomWords)
    {
        require(s_requests[_requestId].paid > 0, "request not found");
        RequestStatus memory request = s_requests[_requestId];
        return (request.paid, request.fulfilled, request.randomWords);
    }

    /**
     * Allow withdraw of Link tokens from the contract
     */
    function withdrawLink() public onlyOwner {
        LinkTokenInterface link = LinkTokenInterface(linkAddress);
        require(
            link.transfer(msg.sender, link.balanceOf(address(this))),
            "Unable to transfer"
        );
    }
}

这是一个Sepolia测试网的示例，每个网络下linkAddress和wrapperAddress地址不同， 每个网络具体可以 点此查看

3. 部署及测试

部署的时候同样选择MetaMask连接到Sepolia网络，部署好了后，我们还需要给部署好的合约转入LINK代币(很重要的)。

复制这个合约地址，用MetaMask钱包给这个地址转入LINK代币2-3个左右(测试用)。

转入成功后就可以调用requestRandomWords方法，它会生成一个requestId，这个requestId可以通过调用lastRequestId方法查看。

最后通过给getRequestStatus方法传入requestId参数并调用就可以查看Chainlink响应给我们的随机字符串了。

具体的获取随机数官方文档，点此查看

这样我们就最终实现了在Solidity 智能合约中调用 Chainklink 获取外部数据及生成随机数，如果各位小伙伴有什么问题，也欢迎留言哦！

这篇文章主要讲一下用hardhat框架开发好了一个solidity智能合约后，如何部署到以太坊(ETH)网络上，我会以以太坊测试网(Sepolia)来部署，和以太坊主网操作完全一样，其中会包含测试网ETH币领取，以一个ERC20代币的智能合约为例部署上线，以及上线后智能合约的验证(不验证的话在区块浏览器中看不到源码，别人不太相信你的项目)。

一、Solidity 智能合约开发

开发这一块如果各位小伙伴还不太懂的话，建议看一下我之前的文章: 聊一聊Web3是什么，Web3从入门到精通开发学习路线。

这里我直接以一个ERC20代币的智能合约为例，项目开源在github上，点此查看

智能合约代码：contract/MyTestToken.sol：

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract MyTestToken is ERC20, Ownable {
    constructor(
        string memory name,
        string memory symbol,
        uint256 initialSupply
    ) ERC20(name, symbol) Ownable(msg.sender) {
        _mint(msg.sender, initialSupply);
    }

    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }

    function burn(address account, uint256 amount) public onlyOwner {
        _burn(account, amount);
    }
}

单测代码：test/MyTestToken.ts：

import { expect } from "chai";
import { ethers } from "hardhat";

describe("MyTestToken", function () {
  const useMTT = async () => {
    const MyTestToken = await ethers.getContractFactory("MyTestToken");
    const MTT = await MyTestToken.deploy("My Test Token", "MTT", 1000000);

    return MTT;
  };

  it("Deployment", async function () {
    const [owner] = await ethers.getSigners();

    const MTT = await useMTT();

    expect(await MTT.totalSupply()).to.equal(1000000);
    expect(await MTT.balanceOf(owner)).to.equal(1000000);
  });

  it("Transfer", async function () {
    const [owner, address1] = await ethers.getSigners();

    const MTT = await useMTT();

    await MTT.transfer(address1, 400000);
    expect(await MTT.balanceOf(owner)).to.equal(600000);
    expect(await MTT.balanceOf(address1)).to.equal(400000);
  });

  it("Mint", async function () {
    const [owner] = await ethers.getSigners();

    const MTT = await useMTT();
    await MTT.mint(owner, 200000);
    expect(await MTT.totalSupply()).to.equal(1200000);
    expect(await MTT.balanceOf(owner)).to.equal(1200000);
  });

  it("Burn", async function () {
    const [owner] = await ethers.getSigners();

    const MTT = await useMTT();
    await MTT.burn(owner, 300000);
    expect(await MTT.totalSupply()).to.equal(700000);
    expect(await MTT.balanceOf(owner)).to.equal(700000);
  });
});

智能合约部署上线后就不能修改了，单测非常非常非常重要，务必保证每个功能点没问题

运行npx hardhat test执行单测，如下图所示，全部通过

二、智能合约部署

我们的智能合约部署必须依赖区块链的节点上，如 Infura 或Alchemy

这里我以Infura为例，需要我们先上去注册一个账号

注册登录好后

1. 创建一个新的API KEY

1. 进入创建的API KEY里选择对应的部署的节点，这里我们部署到ETH的测试网Sepolia上，Infura也提供了一个可以领Sepolia测试币的水龙头，大家可以点后面这个链接领取测试币，Sepolia水龙头

1. 最后可以在激活的节点里复制刚才我们选择的节点URL

回到项目中

1. 安装dotenv并创建env文件

npm i dotenv -D安装支持读取env文件的依赖，并在项目跟目录创建env文件

ETH_SEPOILA_URL为刚才我们复制的节点URL

PRIVATE_KEY是我们需要准备一个钱包来部署我们的智能合约，这里要填钱包的私钥，请一定要保存好私钥不要泄漏，这个钱包在智能合约部署后为智能合约owner，只有他可以增发代币和销毁代币

2. 在hardhat配置文件中添加Sepolia网络节点

hardhat.config.ts：

import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import dotenv from "dotenv";

dotenv.config();

const { ETH_SEPOILA_URL, PRIVATE_KEY = "" } = process.env;

const config: HardhatUserConfig = {
  solidity: "0.8.20",
  networks: {
    sepolia: {
      url: ETH_SEPOILA_URL,
      accounts: [PRIVATE_KEY],
    },
  },
};

export default config;

就是引入我们env中的配置，并通过networks添加sepolia网络节点

3. 编写部署脚本

scripts/deploy.ts：

import { ethers } from "hardhat";

async function main() {
  const [deployer] = await ethers.getSigners();

  console.log("Deploying contracts with the account:", deployer.address);

  const MyTestToken = await ethers.getContractFactory("MyTestToken");
  const MTT = await MyTestToken.deploy("My Test Token", "MTT", 1000000);

  console.log("MyTestToken address:", await MTT.getAddress());
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

其中在MyTestToken.deploy()方法中传入的三个参数就是我们智能合约构造函数所需的三个参数

4. 执行部署

执行npx hardhat run scripts/deploy.ts --network sepolia来部署

成功后可以看到执行部署的钱包地址，及部署后的智能合约地址，前端就可以根据这个智能合约地址来执行相应的操作了

5. 在区块浏览器中查看部署的智能合约

复制上面的智能合约地址，到 区块浏览器 中，就可以搜索查看了

这个我们智能合约的主页，因为我们发的是Token代币，还有个Token代币主页，点击上图中间标红查看

点击下面的Contract后可以看到我们合约是一段编译过的字符，用户并不能看到智能合约的源码，下面教大家如何验证我们的智能合约让用户能够看到源码

三、智能合约验证

为了增强用户对我们智能合约的信任，我们一般会将智能合约验证开源以增强用户对我们智能合约的信任度

1. 在ETH主网区块链浏览器中申请API KEY

API KEY在主网及测试网是通用的，我们在主网申请即可

对API KEY取个名称创建即可，成功后复制这个API KEY

1. 在代码env中添加ETHERSCAN_APIKEY并设置刚才的API KEY

1. 在hardhat.config.ts中添加相应配置

1. 运行命令，执行验证

npx hardhat verify --network sepolia 0x634e6E8b817D5975B9808D0272D1f62DF1AdD91b "My Test Token" "MTT" 1000000

这行命令格式为npx hardhat verify --network 您部署的网络 智能合约地址 构造函数参数

看到如下输出就验证成功了，成功后在区块链浏览器上就可以看到智能合约源码了

如此就完成了我们Web3 开发智能合约部署的全流程，从最初的开发，到编译，单元测试，部署，最后的验证合约。

在使用Solidity开发智能合约时，免不了使用数组，但Solidity中的数组，只提供了push和pop方法来实现尾部新增和删除元素功能，这篇文章主要讲讲实际开发中怎么实现数组删除指定位置元素及指定位置新增元素。

一、数组删除指定位置元素

1. 默认delete操作符

// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

contract ArrayRemoveItem {
    uint[] public arr = [1,2,3,4,5];

    function remove(uint index) public {
        require(index < arr.length, "index not found");
        delete arr[index];
    }

    function getLength() public view returns(uint) {
        return arr.length;
    }
}

这种操作有个问题是，它会把指定位置的元素恢复默认值，如这里uint类型的默认值是0。

我们执行remove(1)操作之后，arr的值为[1,0,3,4,5]，并且执行getLength()值为5。

这种方法的缺点是如果0本身在我们数组中是有意义的，那最终删除了之后值也是0就会导致最终的智能合约逻辑有问题。并且数组长度可能越来越长。

2. 和末尾元素交换位置，并删除末尾位置元素

// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

contract ArrayRemoveItem {
    uint[] public arr = [1,2,3,4,5];

    function remove(uint index) public {
        require(index < arr.length, "index not found");
        arr[index] = arr[arr.length - 1];
        arr.pop();
    }

    function getLength() public view returns(uint) {
        return arr.length;
    }
}

通过把末尾元素值先赋值给目标元素，再删除末尾元素实现删除目标元素的功能。

执行remove(1)操作后，arr的值为[1,5,3,4]，执行getLength()值为4。

这种方法的缺点是我们删除中间一个元素后，数组的顺序会有变化，如果我们数组本身顺序是有意义的(如按照时间排序的)，那最终也会导致我们智能合约逻辑有问题。

3. 目标元素后面所有元素向前移动一位

// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

contract ArrayRemoveItem {
    uint[] public arr = [1,2,3,4,5];

    function remove(uint index) public {
        require(index < arr.length, "index not found");
        for(uint i = index; i < arr.length - 1; i++) {
            arr[i] = arr[i + 1];
        }
        arr.pop();
    }

    function getLength() public view returns(uint) {
        return arr.length;
    }
}

要想删除目标元素也不改变原本数组位置，可以通过把目标元素后面所有元素向前移动一位，再删除最后一个元素来实现删除目标元素。

执行remove(1)后，arr的值为[1,3,4,5]，并且执行getLength()值为4，得到的结果全是我们想要的。

但这种方法也有缺点，就是花费的gas费较高。

所以没有完美的方法，大家可以根据自己业务开发中实际需要选择，如果在你的业务中数组顺序无意义，推荐使用第二种方法(和尾部元素交互位置，删除位置元素)，如果你的业务中是数组顺序有意义，推荐使用第三种方法。

二、指定位置新增元素

// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

contract ArrayRemoveItem {
    uint[] public arr = [1,2,3,4,5];

    function remove(uint index) public {
        require(index < arr.length, "index not found");
        for(uint i = index; i < arr.length - 1; i++) {
            arr[i] = arr[i + 1];
        }
        arr.pop();
    }

    function add(uint index, uint value) public {
        require(index < arr.length, "index not found");
        arr.push();
        for(uint i = arr.length - 1; i > index; i--) {
            arr[i] = arr[i - 1];
        }
        arr[index] = value;
    }

    function getLength() public view returns(uint) {
        return arr.length;
    }
}

指定位置新增元素的原理和上面删除差不多，先把新增一个空元素，然后把指定位置后面的所有元素向后移动一位，再把新值指定位置元素就完成了。

同样的缺点，消耗gas费较多哦。

这样就可以实现Solidity中数组删除指定位置元素和指定位置新增元素，具体选哪种方法，大家可以肯定自己实际业务需要选择。

最近发现Web3这一块非常有意思，概念什么也很新颖超前，这篇文章主要是给大家讲讲关于Web3我的理解，以及如何入门去做这一块的开发。

一、介绍 Web3

Web3区别于传统的Web2的地方是后端这一块，以前我们传统的Web2应用，需要服务器来跑对应的后端服务，数据也需要放到数据库里(MySQL、Redis等)，Web3应用是把我们的后端服务(一般称链端)放到链上运行，数据等也是存到链上。

传统的Web2服务一般使用Java、Go等来写后端服务，Web3一般使用Solidity(最常用)或Rust等来编写智能合约部署到链上运行。

但Web3目前我接触下来发现一些优点和缺点。

优点：因为你整体的服务是放到链上运行的，除非你设置了一个权限很高的账号可以修改数据，或者你写的智能合约本身有安全漏洞（但使用你这个Web3应用的人都能看到你的智能合约代码，别人认为你的智能合约有漏洞之类的可以选择不用），否则数据是不容易被修改的。这也是为什么Web3中Defi项目(去中心化金融)很多。

缺点：也正是因为放到链上运行智能合约，如果你需要修改链上的数据，需要别人对你的数据进行打包确认，数据修改的即时性不是很高会有延时，从我使用ETH测试链部署的智能合约来说，修改一个数据，大约有几秒到十几秒延时时间，所以目前我感觉对即时性很高的应用不是很适合。

但Web3这块，目前还是一个蓝海，我个人包括有兴趣的小伙伴，下面我也列出一份学习路线。

二、了解Web3

学习Web3开发，希望各位小伙伴一定一定要会科学上网(非常重要)。目前很多的资料或问题都只有Google或国外才有。

要从事Web3开发，首先就是要了解区块链。

• 推荐一个视频：北京大学肖臻老师《区块链技术与应用》公开课，非常棒的新手了解区块链课程。

• 以太坊官网：以太坊官网，以太坊是我们做Web3开发最重要，也是应用最多的一条区块链。

三、学习智能合约开发(Solidity)

对区块链有了了解后，就需要进行Web3开发的核心，智能合约(链端)开发了，他是一个Web3应用的核心，当然前端也很重要，如果不会前端的小伙伴，后面也建议去学学前端哦。

• MetaMask钱包：MetaMask小狐狸钱包新手入门使用教程，首先你需要先学习MetaMask钱包的使用，我们所有跟Web3应用的交互都需要通过一个钱包，这块非常重要。

• Solidity开发：WTF Academy(开发者的Web3开源大学)，推荐至少学习Solidity 101、Solidity 102课程。

• 崔棉大师的视频课程：Solidity8.0智能合约全面精通，如果你喜欢看视频学习的话，推荐崔棉大师的课程。

• 理想区块链视频课程：智能合约solidity教程，这也是我经常看的。

• Solidity官方文档：Solidity 中文文档

• Hardhat框架： Hardhat中文文档，这是Solidity的框架，包含了智能合约开发、测试及部署，实际开发中我们也是使用框架进行开发。

• OpenZeppelin智能合约库：OpenZeppelin中文文档，对于一些我们在开发中常用的智能合约库进行封装，我们可以直接引用，提高开发效率。

• 区块链节点：智能合约正式部署的时候我们一般需要用到节点商 Infura 或Alchemy

学习完上面的部分其实也已经跟着写了一些简单的智能合约项目了，比如如何发币或者发NFT其实我们已经知道了，我非常建议大家使用 Remix编辑器 试着开发自己的智能合约，如发币或发NFT等(只完成智能合约部分)，这个编辑器包含了开发、部署、和测试等，建议大家一定要完成全流程哦！

四、Web3 对应的前端开发

学习这块之前大家一定要有前端基础哦，没有的话建议先去学习学习！Web3对应的前端开发主要是学习前端如何通过钱包与我们的智能合约交互。相应的技术栈如下：

• Ether.js，依然推荐WTF Academy的课程Ethers.js 101 入门、Ethers.js 102 进阶

• Ether.js官网文档：ethers.js 中文文档

• wagmi，一个React Hook的集合，包含了一些和智能合约交互的Hook：wagmi

五、实际项目推荐

学习完以上技术其实我们就有开发一个Web3应用的能力了。但是我们还需要实际项目来练手，这里附上我之前练手写的两个项目：

• Web3投票项目：智能合约链端、前端

• Web3 TodoList项目：智能合约链端、前端

进阶的话推荐学习下成熟的Defi项目：Uniswap、Pancakeswap、Sushiswap，可以在Etherscan找对应项目的智能合约源码看。

到此我们就有进行大型Web3开发的能力，后续还需要大家多多实践、学习、进步哦。有问题的话各位小伙伴也可以下面留言交流哦！