初识 Web3

import Web3 from 'web3'
// 创建账户
const account = Web3.eth.accounts.create();
// create() 参数它是一个可选项，是一个随机字符串，将作为解锁账号的密码。如果没有传递字符串，则使
// 用random生成随机字符串。
console.log(account);

// 获取账户余额
const balance = await Web3.eth.getBalance(account.address);
console.log(Web3.utils.fromWei(balance, 'ether'));

import Web3 from 'web3'
import Tx from 'ethereumjs-tx'
// import { ethers } from 'ethers'
// import { keccak256 } from 'ethers/lib/utils'
// import { Buffer } from 'buffer'
// import { keccak256 as keccak256_ } from 'keccak256'
// import { Wallet } from 'ethereumjs-wallet'
// 获取 gasprice
const gasPrice = await Web3.eth.getGasPrice();
// 发送交易
const tx = {
  from: account.address, // 转账账户
  to: '0x1234567890abcdef1234567890abcdef12345678',  // 接收账户
  value: Web3.utils.toWei('1', 'ether'),  // 转账金额  需要单位转化
  // gas: 21000, // 转账需要消耗的gas   web3.utils.toWei('1', 'gwei'),
  gasPrice: Web3.utils.toWei('10', 'gwei'), // gas价格
};
// 方式一：
// 使用私钥签名交易: privateKey
const signedTx = await Web3.eth.accounts.signTransaction(tx, privateKey);
const receipt = await Web3.eth.sendSignedTransaction(signedTx.rawTransaction);
console.log(receipt);


// 方式二：
// 算出 gas
tx.gas = await Web3.eth.estimateGas(tx);
let t = new Tx(tx);
t.sign(privateKey)
const signedTx = '0x' + t.serialize().toString('hex');
const trans = Web3.eth.sendSignedTransaction(signedTx);


trans.on('transactionHash', function(txid){
  console.log("交易id",txid);
  console.log("https://goerli.etherscan.io/tx/${txid}");
});
trans.on('receipt', function(receipt){
  console.log("交易节点",receipt);
});
trans.on('confirmation', function(confirmationNumber, receipt){
  console.log("交易确认",confirmationNumber ,receipt);
});
trans.on('error', function(error){
  console.log("交易失败",error);
});

import Web3 from 'web3'
import {
  generateMnemonic,
  mnemonicToSeed,
  validateMnemonic,
  fromEntropy,
} from 'bip39'
import {hdkey} from 'ethereumjs-wallet'
// 根据不同情况安装， vite 就安装vite-plugin-node-polyfills插件，然后在vite.config.js中配置
// 注意：vite-plugin-node-polyfills 0.9.0之后的版本有不兼容问题
import { Buffer } from 'buffer'

// 生成助记词  floor upon canvas income hurt abuse gather bean august hold coffee heavy
const mnemonic = generateMnemonic();

const seed = mnemonicToSeedSync(mnemonic);
// 生成种子
const hdwallet = hdkey.fromMasterSeed(seed);
// 生成密钥对
let keypair = hdwallet.derivePath(`m/44'/60'/0'/0/0`);
// 获取钱包对象
let wallet = keypair.getWallet();
// 获取钱包地址
const address = wallet.getAddressString();
// 获取钱包校验地址   全部转小写后与钱包地址相同
const localAddress = wallet.getChecksumAddressString();
//获取私钥
const privateKey = wallet.getPrivateKeyString();

console.log(address, privateKey);

// m/44'/60'/0'/0/0
// m: 表示主私钥
// 44': 表示BIP44协议
// 60': 表示以太坊
// 0': 表示第一个账户
// 0: 表示第一个子账户
// 0: 表示第一个密钥对

m/purpse'/coin_type'/account'/change/address_index

import Web3 from 'web3'
import ethwallet, { Wallet } from 'ethereumjs-wallet'

// 导出账户
// web3方式导出  必须输入正确的密码
web3.eth.accounts.encrypt(privateKey, "123456").then((result) => {
  console.log("🚀 ~ result:", result);
 // 反向获取私钥  必须输入正确的密码
  web3.eth.accounts.decrypt(result, "123456").then((decrypted) => {
    console.log("🚀 ~ decrypted:", decrypted.privateKey);
  })

});


// wallet 钱包方式导出  必须输入正确的密码
wallet.toV3("123456").then((keystore) => {
  console.log("🚀 ~ keystore:", keystore);
  // 反向获取私钥  必须输入正确的密码
  ethwallet.fromV3(keystore, "123456").then((wallet) => {
    let a = decrypted.getPrivateKeyString()
    console.log("🚀 ~ privateKey:", a);
  })
});

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

contract DataTypeDemo {
  unit public x = 1;
  unit8 public z = 1;
  address public addr = 0x5B38Da6a701c568545dCfcB03FcB875f56beddC4;
  address public add = msg.sender;
  struct Person {
    string name;
    unit age;
  }
  Person person;

  // 定长数组   不可以直接修改数组长度 fixedArray.length = 4;
  unit[3] public fixedArray = [1, 2, 3];

  function sumArray() public view returns (unit) {
    unit sum = 0;
    for (unit i = 0; i < fixedArray.length; i++) {
      sum += fixedArray[i];
    }
    return sum;
  }

}

pragma solidity ^0.8.7;

contract HelloWorld {
  // 定义一个状态变量
  string public name = "Hello, World!";

  // 构造函数
  constructor() {}
  // 不修改变量
  function sayName() public view returns (string memory) {
    return name;
  }

  function setName(string calldata _name) public  {
      name = _name;
  }
}

pragma solidity ^0.8.7;

contract Demo {
  // 定义一个storage变量
  unit x = 1;
  // 错误定义storage变量:   unit storage x = 1;

  // 断言不成立，不修改变量
  function doAssert() public  returns (unit) {
    assert(x > 1);
    x = 2;
    return x;
  }
  // require不成立，不修改变量
  function doRequire() public  returns (unit) {
    require(x > 1, "x is not equal to 1");
    x = 2;
    return x;
  }
}

// 1.直接引入项目文件下的合约
// 2.引入GitHub上的合约
// 3.通过包引入
import  "./Factor.sol";
import {AggregatorV3Interface} from "@chainlink/contracts/src/v0.8/shared/interfaces/AggregatorV3Interface.sol";
import { helloWorld } from "./HelloWorld.sol";

// 继承合约
contract HelloWorldChild is Factor {
  // 定义变量
  helloWorld[] public helloWorlds;
  // 构造函数  调用合约的方法和输入简称
  constructor() Factor("functionDo","ft") {}
}

pragma solidity ^0.8.7;

contract ErrorDemo {
  // 定义一个状态变量
  unit public x = 1;
  // 断言不成立，不修改变量
  function doAssert() public  returns (unit) {
    assert(x > 1);
    x = 2;
    return x;
  }
  // require不成立，不修改变量
  function doRequire() public  returns (unit) {
    require(x > 1, "x is not equal to 1");
    x = 2;
    return x;
  }
}

pragma solidity ^0.8.7;

contract EventDemo {
  event Log(unit);
  event Log(string);
  event Log(address);
  event Log(unit, string, address);

  function doEvent() public {
   // 打印数字
    emit Log(1);
    // 打印字符串
    emit Log("hello");
    // sender就是address
    emit Log(msg.sender);
  }
}

pragma solidity ^0.8.7;

contract ModifierDemo {
  // 定义一个状态变量
  unit public x = 1;
  // 定义一个修饰器
  modifier checkX() {
    require(x > 1, "x is not equal to 1");
    _;
  }
  // 使用修饰器
  function doCheckX() public checkX {
    x = 2;
  }
}

pragma solidity ^0.8.7;

contract Factor {
  // 定义一个虚函数
  function factor(unit n) public virtual returns (unit) {
    return n;
  }
}

contract HelloWorld is Factor {
  // 重写虚函数 上面的合约已经默认方法了，可以不需要重写
  function factor(unit n) public override returns (unit) {
    return n * 2;
  }
}

// 智能合约的许可协议
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;

contract HelloWorld {
    // 定义一个状态变量
    string public name = "Hello, World!";

    // 添加 payable 构造函数
    constructor() payable {}

    function sayName() public view returns (string memory) {
        return name;
    }

    function setName(string calldata _name) public  {
        name = _name;
    }
}

// 判断是否连接了"MetaMask"插件
if (typeof window.ethereum !== 'undefined') {
  // 连接到以太坊网络
  const web3 = new Web3(window.ethereum);
  // 请求用户授权连接
  await window.ethereum.enable();
  // 获取账户
  const accounts = await web3.eth.getAccounts();
  // 调用合约方法  contractAddress 为之前Remix线上部署的地址
  const contractInstance = new web3.eth.Contract(abi, contractAddress);
  // 调用合约方法
  const result = await contractInstance.methods.myMethod().call();
  console.log(result);
} else {
  console.error('MetaMask is not installed');
}
// 连接到以太坊网络
const web3 = new Web3('https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID');

// 合约ABI
const abi = [
  // 合约方法定义
  // ...
];

// 合约地址
const contractAddress = '0x1234567890abcdef1234567890abcdef12345678';

// 获取账户
// 调用合约方法
const contractInstance = new web3.eth.Contract(abi, contractAddress);
const result = await contractInstance.methods.myMethod().call();
console.log(result);