合约部署和使用hardhat验证的官方文档在这里

https://docs.base.org/guides/deploy-smart-contracts

合约文件

前面部分全是openzeppelin拷贝的，合约部署时需要传入代币名字、符号、以及要mint给部署者的代币数量。

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

interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );

    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address to, uint256 amount) external returns (bool);

    function allowance(
        address owner,
        address spender
    ) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) external returns (bool);
}

interface IERC20Metadata is IERC20 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);
}

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    function name() public view virtual override returns (string memory) {
        return _name;
    }

    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(
        address account
    ) public view virtual override returns (uint256) {
        return _balances[account];
    }

    function transfer(
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    function allowance(
        address owner,
        address spender
    ) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(
        address spender,
        uint256 amount
    ) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    function increaseAllowance(
        address spender,
        uint256 addedValue
    ) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    function decreaseAllowance(
        address spender,
        uint256 subtractedValue
    ) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(
            currentAllowance >= subtractedValue,
            "ERC20: decreased allowance below zero"
        );
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(
            fromBalance >= amount,
            "ERC20: transfer amount exceeds balance"
        );
        unchecked {
            _balances[from] = fromBalance - amount;

            _balances[to] += amount;
        }
        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(
                currentAllowance >= amount,
                "ERC20: insufficient allowance"
            );
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

contract ErcToken is ERC20 {
   
    constructor(
        string memory name,
        string memory symbol,
        uint256 totalSupply
    ) ERC20(name, symbol) {
        _mint(msg.sender, totalSupply * (10 ** 18));
    }
}

跨桥代码

从goerli到base

from web3 import Web3
from web3.middleware import geth_poa_middleware
# goerli rpc 替换为自己的或者公用的
goerli_rpc = "xxxxx"
# goerli_rpc = "https://mainnet.infura.io/v3/"
w3_goerli = Web3(Web3.HTTPProvider(goerli_rpc))
w3_goerli.middleware_onion.inject(geth_poa_middleware, layer=0)
# bridge contract
# 跨桥合约地址
bridge_contract_address = Web3.to_checksum_address("0xe93c8cD0D409341205A592f8c4Ac1A5fe5585cfA")
# 跨桥合约用到的ABI
bridge_abi = [{"inputs": [{"internalType": "address", "name": "_to", "type": "address"}, {"internalType": "uint256", "name": "_value", "type": "uint256"},
                          {"internalType": "uint64", "name": "_gasLimit", "type": "uint64"}, {"internalType": "bool", "name": "_isCreation", "type": "bool"},
                          {"internalType": "bytes", "name": "_data", "type": "bytes"}], "name": "depositTransaction", "outputs": [], "stateMutability": "payable", "type": "function"}]
# 构建跨桥合约对象
bridge_contract = w3_goerli.eth.contract(address=bridge_contract_address, abi=bridge_abi)
# 实现跨桥的函数，传入账户私钥和跨桥金额即可。
def goerli_base_bridge(private_key, amount):
    account = w3_goerli.eth.account.from_key(private_key)
    tx_data = {"from": account.address, "nonce": w3_goerli.eth.get_transaction_count(account.address), "value": Web3.to_wei(amount, "ether")}
    tx = bridge_contract.functions.depositTransaction(account.address, Web3.to_wei(amount, "ether"), 100000, False, b'').build_transaction(tx_data)
    signed_tx = account.sign_transaction(tx)
    tx_hash = w3_goerli.eth.send_raw_transaction(signed_tx.rawTransaction)
    tx_receipt = w3_goerli.eth.wait_for_transaction_receipt(tx_hash)
    return tx_hash.hex()

# ex: 跨桥1个ETH
goerli_base_bridge("你的私钥",1)

批量创建账户

from eth_account import Account
import eth_account.hdaccount as HDAccount
from web3 import Web3
import os
Account.enable_unaudited_hdwallet_features()  # 若需创建助记词需要执行此句
web3 = Web3(Web3.HTTPProvider("https://mainnet.infura.io/v3/"))


def createAccount(numbers: int, Seed: bool):
    """传入钱包数量和是否需要助记词"""
    if Seed:
        with open('wallets.txt', 'a+', encoding='utf-8') as f:
            for _ in range(numbers):
                mnemonic = HDAccount.generate_mnemonic(12, 'english')
                account = Account.from_mnemonic(mnemonic)
                address = account.address
                private_key = account.key.hex()
                f.write(f"{address} {private_key} {mnemonic}\n")
    else:
        with open('wallets.txt', 'a+', encoding='utf-8') as f:
            for _ in range(numbers):
                account = Account.create()
                address = account.address
                private_key = account.key.hex()
                f.write(f"{address} {private_key}\n")
    return


# ex:创建10000个无助记词钱包
createAccount(10000,False)  
# ex:创建10000个有助记词钱包
createAccount(10000,True)

批量发送ETH

# coding:utf-8
import random
import string
from web3 import Web3
from web3.middleware import geth_poa_middleware

# goerli_rpc = "https://rpc.ankr.com/eth_goerli"
goerli_rpc = "你的goerli网络rpc"
w3_goerli = Web3(Web3.HTTPProvider(goerli_rpc))
w3_goerli.middleware_onion.inject(geth_poa_middleware, layer=0)
# base network rpc
base_rpc = "https://goerli.base.org"
w3 = Web3(Web3.HTTPProvider(base_rpc))
w3.middleware_onion.inject(geth_poa_middleware, layer=0)

# 从批量创建的账户文件中读取账户列表
def get_account_list(file):
    account_list = []
    with open(file, "r", encoding='utf-8') as f:
        for line in f.readlines():
            temp_address = line.split(" ")[0]
            temp_private_key = line.split(" ")[1].strip()
            account_list.append([temp_address, temp_private_key])
    return account_list

# 在base网络上批量发送eth
def base_transfer_eth(send_account, receipt, amount):
    tx_params = {
        "from": send_account.address,
        "chainId": w3.eth.chain_id,
        "to": Web3.to_checksum_address(receipt),
        "value": Web3.to_wei(amount, "ether"),
        "gas": 21000,
        "gasPrice": w3.eth.gas_price,
        "nonce": w3.eth.get_transaction_count(send_account.address),
    }
    # 签署交易并发送
    signed_txn = send_account.signTransaction(tx_params)
    txn_hash = w3.eth.send_raw_transaction(signed_txn.rawTransaction)
    wait_txn = w3.eth.wait_for_transaction_receipt(txn_hash)
    return txn_hash.hex()

# 在goerli网络上批量发送eth
def goerli_transfer_eth(send_account, receipt, amount):
    tx_params = {
        "from": send_account.address,
        "chainId": w3_goerli.eth.chain_id,
        "to": Web3.to_checksum_address(receipt),
        "value": Web3.to_wei(amount, "ether"),
        "gas": 21000,
        "gasPrice": w3_goerli.eth.gas_price,
        "nonce": w3_goerli.eth.get_transaction_count(send_account.address),
    }
    # 签署交易并发送
    signed_txn = send_account.signTransaction(tx_params)
    txn_hash = w3_goerli.eth.send_raw_transaction(signed_txn.rawTransaction)
    wait_txn = w3_goerli.eth.wait_for_transaction_receipt(txn_hash)
    return txn_hash.hex()


if __name__ == '__main__':
    send_key = "你要发送ETH的账户的私钥"
    send_account = w3.eth.account.from_key(send_key)
    # 获取需要接收ETH的账户列表
    account_list = get_account_list("wallets.txt")
    for account_data in account_list:
        account = w3.eth.account.from_key(account_data[1])
        print(f"{account_data[0]} transfering...")
        try:
            # 示例在base网络上转账，如果要在goerli上换成对应的函数即可
            tx = base_transfer_eth(send_account, account.address, 0.001)
            # 记录转账成功账户
            with open("transfer_eth.txt", "a+", encoding='utf-8') as f:
                f.write(f"{account_data[0]} {tx}\n")
        except:
            # 记录转账失败的账户
            with open("transfer_eth.txt", "a+", encoding='utf-8') as f:
                f.write(f"{account_data[0]} {account_data[1]}\n")
        print(f"{account_data[0]} transfered")
    print("done")

随机生成合约名字-符号-总供给、替换合约内容、随机构造合约部署时传入的参数、编译合约

使用python编译合约需要安装py-solc-x这个库，再随机生成合约名字的时候，为了让名字有含义，我们还需安装nltk这个库，它是一个常用的自然语言处理工具包，广泛应用于文本分析、语言模型等，他可以解决我们随机生成的合约名字有含义。

import nltk
import random
# 下载words集合（如果还没有下载的话）
nltk.download('words')

# 获取words集合中的所有单词
words_list = nltk.corpus.words.words()

# 从所有单词中随机选择一万个单词
def create_random_name():
    # 为了挑选出10000万个符合条件的词，我们需要扩大范围所以这里在100000个筛选出长度在3到8之间的单词
    random_words = [_ for _ in [random.choice(words_list) for _ in range(100000)] if (len(_) > 3 and len(_) < 9)]
    # 去重
    random_words = list(set(random_words))
    # 选出10000个单词
    result_words = [_ for _ in [random.choice(random_words) for _ in range(10000)] if (len(_) > 3 and len(_) < 9)]
    return result_words


# 替换sol文件中的合约名
def replace_contract_name(contranct_name_words_list):
    for one_words in contranct_name_words_list:
        # 保存合约名
        with open("Contract_name.txt", "a+") as f:
            # 随机生成一个长度为0到2的随机数
            randons = len(one_words)-random.randint(0, 2)
            # 生成合约名，和一个基于合约名的symbol（长度随机减少了0,2） 写入文件，后面部署合约会用到
            f.write(f"{str(one_words).capitalize()} {str(one_words[:randons]).upper()}\n")
        # 替换sol文件中的合约名
        with open("Token.sol", "r") as f:
            # 读取文件内容
            contents = f.read()
            # 替换单词
            new_contents = contents.replace("需要替换为你通用合约文件中的合约名字（尽量唯一，以防替换到合约文件中其它的内容）", f"{str(one_words).capitalize()}")
            # 打开新的sol文件并写入新内容./contractfile/是保存合约文件的文件夹，如果没有请自行创建和更改
            with open(f"./contractfile/{str(one_words).capitalize()}.sol", "w") as f:
                f.write(new_contents)

# 读取保存的随机名字的文件
def create_name_symbol():
    """Create random name and symbol"""
    temp_list = []
    with open("Contract_name.txt", "r", encoding="utf-8") as f:
        name_list = f.readlines()
        for i in name_list:
            temp_list.append([i.split(" ")[0].strip(), i.split(" ")[1].strip()])
    return temp_list

# 随机给出代币的总供给
def create_total_supply():
    """Create random data for contract"""
    total_supply_head = random.randint(1, 99)
    total_supply_tail = random.randint(6, 10)
    total_supply = total_supply_head * 10 ** total_supply_tail
    return total_supply

# 编译合约 传入使用的合约文件和合约名字，返回该合约的abi和字节码用于部署
def compile_sol_file(sol_file, contract_name):
    """Compile solidity file"""
    with open(sol_file, "r", encoding='utf-8') as file:
        source_code = file.read()
    compile_sol = compile_standard(
        {
            "language": "Solidity",
            "sources": {f"{contract_name}.sol": {"content": source_code}},
            "settings": {
                "outputSelection": {"*": {"*": ["abi", "metadata", "evm.bytecode", "evm.sourceMap"]}}
            }
        }
    )
    # get bytecode
    byte_code = compile_sol["contracts"][f"{contract_name}.sol"][f"{contract_name}"]["evm"]["bytecode"]["object"]
    # get abi
    abi = compile_sol["contracts"][f"{contract_name}.sol"][f"{contract_name}"]["abi"]
    return abi, byte_code

完整部署合约代码

在做好账户创建、保证每个账户中有足够的ETH、合约名字、合约名字对应的sol文件这些准备工作后，就可以开始批量部署了。

# coding:utf-8
import random
import nltk
import string
from web3 import Web3
from web3.middleware import geth_poa_middleware
from solcx import compile_standard,install_solc
import time
# 确保安装了你想要的sol文件编译版本
install_solc("0.8.18")
# 确保下载了词库
nltk.download('words')
words_list = nltk.corpus.words.words()
# base RPC 公共的，如果有更快的你可以更换
base_rpc = "https://goerli.base.org"
w3 = Web3(Web3.HTTPProvider(base_rpc))
w3.middleware_onion.inject(geth_poa_middleware, layer=0)

# 编译合约
def compile_sol_file(sol_file, contract_name):
    """Compile solidity file"""
    with open(sol_file, "r", encoding='utf-8') as file:
        source_code = file.read()
    compile_sol = compile_standard(
        {
            "language": "Solidity",
            "sources": {f"{contract_name}.sol": {"content": source_code}},
            "settings": {
                "outputSelection": {"*": {"*": ["abi", "metadata", "evm.bytecode", "evm.sourceMap"]}}
            }
        }
    )
    # get bytecode
    byte_code = compile_sol["contracts"][f"{contract_name}.sol"][f"{contract_name}"]["evm"]["bytecode"]["object"]
    # get abi
    abi = compile_sol["contracts"][f"{contract_name}.sol"][f"{contract_name}"]["abi"]
    return abi, byte_code

# 获取随机合约名
def create_name_symbol():
    """Create random name and symbol"""
    temp_list = []
    with open("Contract_name.txt", "r", encoding="utf-8") as f:
        name_list = f.readlines()
        for i in name_list:
            temp_list.append([i.split(" ")[0].strip(), i.split(" ")[1].strip()])
    return temp_list

# 创建随机供给
def create_total_supply():
    """Create random data for contract"""
    total_supply_head = random.randint(1, 99)
    total_supply_tail = random.randint(6, 10)
    total_supply = total_supply_head * 10 ** total_supply_tail
    return total_supply

# 部署合约
def deploy_contract(private_key, abi, byte_code, _name, _symbol, _total_supply):
    """Deploy contract"""
    account = w3.eth.account.from_key(private_key)
    # create contract
    contract = w3.eth.contract(abi=abi, bytecode=byte_code)
    # deploy contract
    tx_data = {"from": account.address, "nonce": w3.eth.get_transaction_count(account.address), "gasPrice": w3.eth.gas_price}
    tx = contract.constructor(_name, _symbol, _total_supply).build_transaction(tx_data)
    signed_tx = account.sign_transaction(tx)
    tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
    tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
    # get contract address
    contract_address = tx_receipt.contractAddress
    return contract_address

def get_account_list(file):
    account_list = []
    with open(file, "r", encoding='utf-8') as f:
        for line in f.readlines():
            temp_address = line.split(" ")[0]
            temp_private_key = line.split(" ")[1].strip()
            account_list.append([temp_address, temp_private_key])
    return account_list


if __name__ == '__main__':
    # 获取要部署合约的用户列表
    account_list = get_account_list("wallets.txt")
    # 获取合约名字和符号的列表
    name_symbol_list = create_name_symbol()
    # 任务索引id
    index_i = 0
    # 循环每个账户进行部署合约
    for account_data in account_list:
        # 使用的合约名字
        name = name_symbol_list[index_i][0]
        # 使用的合约符号
        symbol = name_symbol_list[index_i][1]
        # 使用的总供给
        total_supply = create_total_supply()
        # 对应合约文件编译后的abi、字节码
        abi, byte_code = compile_sol_file(f"./contractfile/{name}.sol", name)
        # 账户实例化
        account = w3.eth.account.from_key(account_data[1])
        print(f"{account_data[0]} deploying...")
        try:
            # 开始部署
            tx = deploy_contract(account_data[1], abi, byte_code, name, symbol, total_supply)
            # 写入部署成功的信息，包含你部署的合约地址，后面mint会用到。
            with open("deploy.txt", "a+", encoding='utf-8') as f:
                f.write(f"{account_data[0]} {account_data[1]} {tx} {name} {symbol} {total_supply}\n")
        except Exception as e:
            # 打印报错信息
            print(e)
            # 写入部署失败的信息
            with open("deployfaild.txt", "a+", encoding='utf-8') as f:
                f.write(f"{account_data[0]} {account_data[1]}\n")
        print(f"{account_data[0]} deployed")
        index_i += 1

合约部署完成以后你就可以使用你部署的合约地址去下面这个网址去mint你的NFT了。

https://quests.base.org/

合约验证

合约验证使用hardhat来实现。不需要像主网、goerli和bsc验证合约需要api。你只需要按照官方的那个文档配置号你的config文件就可以了。

在你的hardhat.config.js中大概就像这样

require("@nomiclabs/hardhat-etherscan");
require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config()
/** @type import('hardhat/config').HardhatUserConfig */
// 合约验证
module.exports = {
  solidity: {
    version: "0.8.19",
  },
  etherscan: {
    apiKey: {
      // Basescan doesn't require an API key, however
      // Hardhat still expects an arbitrary string to be provided.
      "basegoerli": "PLACEHOLDER_STRING"
    },
    customChains: [
      {
        network: "basegoerli",
        chainId: 84531,
        urls: {
          apiURL: "https://api-goerli.basescan.org/api",
          browserURL: "https://goerli.basescan.org"
        }
      }
    ]
  },
  networks: {
    basegoerli: {
      url: process.env.BASEGOERLI_URL,
      accounts: [process.env.PRIVATE_KEY],
    },
  },
};

1、把你部署好的合约文件拷贝一份到hardhat的contract文件夹下

2、在命令行输入npx hardhat compile编译好这个合约文件，然后在scripts文件夹下编写验证合约的js脚本，我这里以两个为例我是这样写的。然后在命令行输入npx hardhat run scripts/（这个部署js的文件名.js）--network basegoerli(我给他去的名字是这个，你的要对应更改)

const hre = require("hardhat");

async function main() {
    const { ethers } = hre;

    //你对应的合约地址，多个的话可以写个函数读取
    const contractAddresses = [
        "0x045d788952D4DA8aA1D0dEDc2fBe1dDeE387C018",
        // ...
    ];
    //你对应的合约部署时的参数，多个的话可以写个函数读取
    const constructorArgs = [
        ["Gobelin", "GOBELI", 1000000000],
        // ...
    ];

    for (let i = 0; i < contractAddresses.length; i++) {
        const address = contractAddresses[i];
        const args = constructorArgs[i];
        console.log(`Verifying contract at ${address}...`);
        await hre.run("verify:verify", {
            address,
            constructorArguments: args,
            # 你的合约文件名和合约名，多个的话写成函数传参形式替换
            contract: "Token.sol:Token",
            network: "basegoerli",
        });
        console.log(`Contract at ${address} verified successfully.`);
    }
}

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

3、如果你只有单个合约，那验证那就直接在命令行就可以解决了。对应的更改合约地址（contract_address），参数(arg1,arg2,arg3,…)就可以了,参数有多少个传多少个。

npx hardhat verify --network network_name contract_address arg1 arg2 arg3 ....

4、验证完以后的合约就有这个对钩啦。

刚开始学写这些内容，如果对你有用的话，给我点个关注吧,Thanks♪(･ω･)ﾉ。

https://twitter.com/runker54

RPC、地址信息

• 免费领取USDC的地址：0xeF71Ddc12Bac8A2ba0b9068b368189FFa2628942

• USDC Token地址：0xA0D71B9877f44C744546D649147E3F1e70a93760

• ScrollAlpha RPC: https://alpha-rpc.scroll.io/l2

合约ABI

• erc20_abi.json

       因为涉及USDC的转移，所以用ERC20的ABI中的transfer和balanceOf即可

  [{        "type": "function",        "stateMutability": "nonpayable",        "outputs": [            {                "type": "bool",                "name": "",                "internalType": "bool"            }        ],
          "name": "transfer",
          "inputs": [
              {
                  "type": "address",
                  "name": "to",
                  "internalType": "address"
              },
              {
                  "type": "uint256",
                  "name": "amount",
                  "internalType": "uint256"
              }
          ]
      },
      {
          "type": "function",
          "stateMutability": "view",
          "outputs": [
              {
                  "type": "uint256",
                  "name": "",
                  "internalType": "uint256"
              }
          ],
          "name": "balanceOf",
          "inputs": [
              {
                  "type": "address",
                  "name": "account",
                  "internalType": "address"
              }
          ]
      }
  ]
  

• usdc_faucet_abi.json

       因为要和领取USDC的合约交互，所以还需要usdc_faucet的abi，在这个ABI中只用到了claim函数，所以可以把其它多于的部分删除。

  [    {        "type": "function",        "stateMutability": "nonpayable",        "outputs": [],
          "name": "claim",
          "inputs": []
      }
  ]
  

代码准备

• 批量创建账户

  const ethers = require('ethers');
  const fs = require('fs');
  
  // 批量创建账户函数
  function createAccounts(filename, number) {
      for (let i = 0; i < number; i++) {
          const wallet = ethers.Wallet.createRandom();
          fs.writeFileSync(`${filename}.txt`, wallet.address + " " + wallet.privateKey + "\n", { flag: 'a' });
          console.log(wallet.address, wallet.privateKey);
      }
  
  }
  // 在当前目录下创建localwallets.txt文件保存新创建的1000个账户信息
  createAccounts("localwallets", 1000);
  

• 发送ETH

  // transfer eth
  async function transfer_eth(wallet, to, value) {
      const tx = await wallet.sendTransaction({
          to: to,
          value: ethers.utils.parseEther(value),
          gasPrice: await get_gas_price(),
      });
      return tx.hash;
  }
  

• 领取USDC

  // claim usdc token
  async function claim_usdc(wallet) {
      const contract = usdc_faucet_contract.connect(wallet);
      const tx = await contract.claim({ gasPrice: await get_gas_price() });
      return tx.hash;
  }
  

• 转移USDC Token

  //transfer usdc token
  async function transfer_token(wallet, to, value) {
      const contract = usdc_token_contract.connect(wallet);
      const tx = await contract.transfer(to, ethers.utils.parseEther(value));
      return tx.hash;
  }
  

第一套方案

     逐个账户进行，转移ETH到账户下，账户领取USDC，账户发USDC到归集地址，然后发送剩余ETH到下一个账户，循环进行。代码如下：

const ethers = require("ethers");
const fs = require('fs');
const { promisify } = require('util');
const readFileAsync = promisify(fs.readFile);
// provider
const scrollAlphaProvider = new ethers.providers.JsonRpcProvider('https://alpha-rpc.scroll.io/l2');
// contract abi
// 导入你的合约abi  json文件 需要自己修改
const usdc_abi = require("../abi_source/usdc_faucet_abi.json");
const usdc_token_abi = require("../abi_source/usdc_token_abi.json");

// contract address
// 导入交互的合约地址
const usdc_faucet = "0xeF71Ddc12Bac8A2ba0b9068b368189FFa2628942";
const usdc_token = "0xA0D71B9877f44C744546D649147E3F1e70a93760";
// contract
// 创建你的合约实例
// usdc faucet
const usdc_faucet_contract = new ethers.Contract(usdc_faucet, usdc_abi, scrollAlphaProvider);
// usdc token
const usdc_token_contract = new ethers.Contract(usdc_token, usdc_token_abi, scrollAlphaProvider);


// 获取账户列表
async function get_account_list(filename) {
    const contents = await readFileAsync(`${filename}.txt`, 'utf8');
    let account_list = [];
    const walletsList = contents.split("\n");
    for (let i = 0; i < walletsList.length; i++) {
        result = walletsList[i].split(" ");
        result_list = [result[0], result[1]];
        account_list.push(result_list);
    }
    return account_list;
}

// 计算当前gas价格
async function get_gas_price() {
    gas_price = await scrollAlphaProvider.getGasPrice();
    result = Number(gas_price);
    return result;
}


// 获取余额
async function get_balance(wallets) {
    balance = await scrollAlphaProvider.getBalance(wallets.address);
    result = ethers.utils.formatEther(balance);
    return result;
}


// 转移eth
async function transfer_eth(wallet, to, value) {
    const tx = await wallet.sendTransaction({
        to: to,
        value: ethers.utils.parseEther(value),
        gasPrice: await get_gas_price(),
    });
    return tx.hash;
}


// 主函数,需要保证第一个账户有足够的eth
const main = async () => {
    // 从文件中读取账户列表,需要自己修改传入的文件名
    const account_list = await get_account_list("xxx");
    // 接收usdc的钱包的地址,需要自己修改
    const receipt_usdc_wallet_address = "......"
    for (let i = 0; i < account_list.length; i++) {
        // 创建钱包对象
        const wallet1 = new ethers.Wallet(account_list[i][1], scrollAlphaProvider);
        const wallet2 = new ethers.Wallet(account_list[i+1][1], scrollAlphaProvider);// 超过列表范围没有做异常捕获
        //claim usdc
        try{
            await claim_usdc(wallet1);
        }catch(e){
            fs.writeFileSync('claimerror.txt', `${account_list[i][0]} ${account_list[i][1]} \n`, { flag: 'a' });
        }
        // transfer usdc
        try{
            // 每次固定领取到的是5000个usdc，所以这里写死了
            await transfer_usdc(wallet1, receipt_usdc_wallet_address, "5000");
        }catch(e){
            fs.writeFileSync('transfererror.txt', `${account_list[i][0]} ${account_list[i][1]} \n`, { flag: 'a' });
        }
        // transfer eth 发送eth到下一个账户执行
        // 设置需要花费的gas总量
        let gas_total = 100000000000000;
        while (true) {
            try {
                let wallet_balance = (await wallet1.getBalance()) - gas_total;
                let wallet_balance_string = ethers.BigNumber.from(wallet_balance.toString());
                await transfer_eth(wallet1, wallet2.address, wallet_balance_string);
                console.log("eth transfer success")
                break;
            } catch (e) {
                console.log(e);
                console.log("gas not enough")
                gas_total = gas_total + 50000000000000;
                continue;
            }
        }
    }
}

main();

第二套方案

     就是把三个步骤分开，分为统一发送eth，统一claim, 统一transfer usdc。实际运行的时候，让发送eth先跑一会，等待一段时候后在执行claim，我再实测的时候发现claim的速度是比发送eth要快的。transfer usdc同理。

transfer_eth.js

批量转移eth。

const ethers = require("ethers");
const fs = require('fs');
const { promisify } = require('util');
const readFileAsync = promisify(fs.readFile);
// provider
const scrollAlphaProvider = new ethers.providers.JsonRpcProvider('https://alpha-rpc.scroll.io/l2');
//wallets
//你发送eth的钱包私钥，需要自己修改
const send_key = "0x0000000";
const send_wallets = new ethers.Wallet(send_key, scrollAlphaProvider);

// 获取账户列表
async function get_account_list(filename) {
    const contents = await readFileAsync(`${filename}.txt`, 'utf8');
    let account_list = [];
    const walletsList = contents.split("\n");
    for (let i = 0; i < walletsList.length; i++) {
        result = walletsList[i].split(" ");
        result_list = [result[0], result[1]];
        account_list.push(result_list);
    }
    return account_list;
}

// 计算当前gas价格
async function get_gas_price() {
    gas_price = await scrollAlphaProvider.getGasPrice();
    result = 2 * Number(gas_price);
    return result;
}


// 获取余额
async function get_balance(wallets) {
    balance = await scrollAlphaProvider.getBalance(wallets.address);
    result = ethers.utils.formatEther(balance);
    return result;
}


// 转移eth
async function transfer_eth(wallet, to, value) {
    const tx = await wallet.sendTransaction({
        to: to,
        value: ethers.utils.parseEther(value),
        gasPrice: await get_gas_price(),
    });
    return tx.hash;
}

// transfer主函数，批量发送eth。
const main = async () => {
    //从文件中读取账户列表,需要自己修改传入的文件名
    const account_list = await get_account_list(“xxx”);
    for (let i = 0; i < account_list.length; i++) {
        const wallet1 = new ethers.Wallet(account_list[i][1], scrollAlphaProvider);
        console.log(send_wallets.address, wallet1.address)
        try {
            // 实测发现每个账户转移0.0008eth就可以了，gas费用高的话可以适当调高。
            await transfer_eth(send_wallets, wallet1.address, "0.0008");
            fs.writeFileSync('transfer_success_local1.txt', account_list[i][0] + " " + account_list[i][1] + "\n", { flag: 'a' });
        } catch (e) {
            fs.writeFileSync('transfer_fail_local1.txt', account_list[i][0] + " " + account_list[i][1] + "\n", { flag: 'a' });
        }

    }

}

main();

claim_usdc.js

统一领取免费的USDC Token

const ethers = require("ethers");
const fs = require('fs');
const { promisify } = require('util');
const readFileAsync = promisify(fs.readFile);
require("dotenv").config();
// provider
const scrollAlphaProvider = new ethers.providers.JsonRpcProvider('https://alpha-rpc.scroll.io/l2');
// contract
// usdc faucet
const usdc_faucet = "0xeF71Ddc12Bac8A2ba0b9068b368189FFa2628942";
// 传入和合约交互的abi的json文件, 需要自己修改
const usdc_abi = require("../abi_source/usdc_faucet_abi.json");
const usdc_faucet_contract = new ethers.Contract(usdc_faucet, usdc_abi, scrollAlphaProvider);

// 获取账户列表
async function get_account_list(filename) {
    const contents = await readFileAsync(`${filename}.txt`, 'utf8');
    let account_list = [];
    const walletsList = contents.split("\n");
    for (let i = 0; i < walletsList.length; i++) {
        result = walletsList[i].split(" ");
        result_list = [result[0], result[1]];
        account_list.push(result_list);
    }
    return account_list;
}

// 计算当前gas价格
async function get_gas_price() {
    gas_price = await scrollAlphaProvider.getGasPrice();
    result = 2 * Number(gas_price);
    return result;
}


// claim token
async function claim_usdc(wallet) {
    const contract = usdc_faucet_contract.connect(wallet);
    const tx = await contract.claim();
    return tx.hash;
}

// transfer主函数
const main = async () => {
    //从文件中读取账户列表,需要自己修改传入的文件名
    const account_list = await get_account_list("xxx");
    for (let i = 0; i < account_list.length; i++) {
        const wallet1 = new ethers.Wallet(account_list[i][1], scrollAlphaProvider);
        console.log(wallet1.address)
        try {
            await claim_usdc(wallet1);
            console.log("claim_usdc success");
            fs.writeFileSync('claimsuccess_local1.txt', account_list[i][0] + " " + account_list[i][1] + "\n", { flag: 'a' });
        } catch (e) {
            fs.writeFileSync('claimfail_local1.txt', account_list[i][0] + " " + account_list[i][1] + "\n", { flag: 'a' });
        }
    }
}
main();

transfer_usdc.js

统一发送usdc到归集账户，然后去uniswap兑换就可以啦。

https://uniswap-v3.scroll.io/#/swap

const ethers = require("ethers");
const fs = require('fs');
const { promisify } = require('util');
const readFileAsync = promisify(fs.readFile);
// provider
const scrollAlphaProvider = new ethers.providers.JsonRpcProvider('https://alpha-rpc.scroll.io/l2');

// usdc token
const usdc_token = "0xA0D71B9877f44C744546D649147E3F1e70a93760";
// 传入和合约交互的abi的json文件, 需要自己修改
const usdc_token_abi = require("../abi_source/usdc_token_abi.json");
const usdc_token_contract = new ethers.Contract(usdc_token, usdc_token_abi, scrollAlphaProvider);


// 获取账户列表
async function get_account_list(filename) {
    const contents = await readFileAsync(`${filename}.txt`, 'utf8');
    let account_list = [];
    const walletsList = contents.split("\n");
    for (let i = 0; i < walletsList.length; i++) {
        result = walletsList[i].split(" ");
        result_list = [result[0], result[1]];
        account_list.push(result_list);
    }
    return account_list;
}


// 转移token
async function transfer_token(wallet, to, value) {
    const contract = usdc_token_contract.connect(wallet);
    const tx = await contract.transfer(to, ethers.utils.parseEther(value));
    return tx.hash;
}


// transfer主函数
const main = async () => {
    // 创建一个接收usdc的地址, 需要自己修改
    const receipt_usdc_address = "......."
    // 传入账户列表的文件名, 需要自己修改
    const account_list = await get_account_list("xxx");
    for (let i = 0; i < account_list.length; i++) {
        const wallet1 = new ethers.Wallet(account_list[i][1], scrollAlphaProvider);
        console.log(wallet1.address)
        try {
            await transfer_token(wallet1, receipt_usdc_address, "5000");
            console.log("send success");
            fs.writeFileSync('sendsuccess_local1.txt', account_list[i][0] + " " + account_list[i][1] + "\n", { flag: 'a' });
        } catch (e) {
            fs.writeFileSync('sendfail_local1.txt', account_list[i][0] + " " + account_list[i][1] + "\n", { flag: 'a' });
        }
    }
}
main();

总结

     在我开始发现这个的时候5000usdc能换取0.012个eth,2023年4月18日13:41:50现在好像只能换取0.005个了，但是都还有4倍多的收益，缺eth的可以搞一下，我搞了几百个就没搞了，也够我测试用了。      我觉得凡是测试网有免费claim代币的，且有池子的应该都有这种撸eth的机会。从此不在为GETH领不到而发愁了。。。

如果觉得对你有用的话，给我点个关注。

https://twitter.com/runker54