- 跳转到页面顶部  gg
- 跳转到页面底部  G
- 向上半屏查看 ctrl + b
- 向下半屏查看 ctrl + f
- 显示行号 set nu
- 删除当前行 dd
- 拷贝1,4行到5行开始 1,4 copy 5 
- 移动1,4行到第5行开始 1,4 move 5

import path from "path";
import { fileURLToPath } from "url";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
console.log("__fileName:", __filename);
console.log("__dirName:", __dirname);

{
  "scripts": {
   	"build": "webpack "
 	},
 "dependencies": {
   "antd": "^4.8.6",
   "css-loader": "^5.0.1",
   "css-minimizer-webpack-plugin": "^1.1.5",
   "less": "^3.12.2",
   "less-loader": "^7.1.0",
   "mini-css-extract-plugin": "^1.3.1",
   "style-loader": "^2.0.0",
   "webpack": "^5.8.0",
   "webpack-cli": "^4.2.0"
 	}
 }

import "antd/dist/antd.less"

	const path = require("path");
const MiniCssExtractPlugin = require("mini-css-extract-plugin");
const CssMinimizerPlugin = require('css-minimizer-webpack-plugin');
module.exports = {
  mode: "production",
  entry: "./src/main.js",			//入口js
  output: {
    filename: "main.js",			// 输出的js,我们不需要,这里是个空文件
    path: path.resolve(__dirname, "dist"),
  },
  plugins: [
    new MiniCssExtractPlugin({
      filename: "myant.min.css",		// 输出的css文件名
    }),
  ],
  optimization: {
    minimizer: [
      new CssMinimizerPlugin(),
    ],
  },
  module: {
    rules: [
      {
        test: /\.less$/,
        use: [
          { loader: MiniCssExtractPlugin.loader },
          {
            loader: "css-loader",
          },
          {
            loader: "less-loader",
            options: {
              lessOptions: {
                javascriptEnabled: true,
                modifyVars: {
                  "primary-color": "#1DA57A",	// 要修改的less变量
                },
              },
            },
          },
        ],
      },
    ],
  },
};

import {Button} from 'antd';
import React, {useState} from 'react';

function switchTheme(theme: number) {
	let cssArr = ["antd.min.css", "antd.dark.min.css"];
	let headHTML = document.getElementsByTagName('head')[0];
	let link = document.createElement("link");
	link.type = "text/css";
	link.rel = "Stylesheet";
	link.href = cssArr[theme % 2];
	headHTML.append(link);
}

function App() {
	const [theme, updateSet] = useState(0);
	React.useEffect(() => {
		switchTheme(theme);
	}, [theme]);
	return (
		<div className="App">
			<Button type={"primary"} onClick={() => {
				updateSet(x => x + 1);
			}}> switch theme </Button>
		</div>
	);
}

import Koa from "koa";
import { ApolloServer } from "apollo-server-koa";
import resolvers from "./resolvers";
import typeDefs from "./schema";
import models from "./models";
const app = new Koa();
const server = new ApolloServer({
  typeDefs,
  resolvers,
  context: {
    models,
    me: models.users[1],
  },
});
server.applyMiddleware({ app });

app.listen({ port: 5000 }, () =>
  console.log(`🚀 Server ready at http://localhost:4000${server.graphqlPath}`)
);

import {gql} from "apollo-server-koa";

const User = gql`
    extend type Query {
        users: [User!]
        user(id: ID!): User
        me: String!
    }

    type User {
        id: ID!
        username: String!
        messages: [Message!]
    }
`;
export default User;
```   

- 定义schema的导出文件,定义空的schema,以便具体的实体可以继承,固定写法

```javascritp
	import { gql } from "apollo-server-koa";
	import message from "./message";
	import user from "./user";
	const linkSchema = gql`
	  type Query {
	    _: Boolean
	  }
	
	  type Mutation {
	    _: Boolean
	  }
	
	  type Subscription {
	    _: Boolean
	  }
	`;
	
	export default [linkSchema, user, message];

import {IResolvers} from "apollo-server-koa";

const user: IResolvers = {
	Query: {
		users: (parent, args, {models}) => {
			return Object.values(models.users);
		},
		user: (parent, {id}, {models}) => {
			return models.users[id];
		},
	},
	User: {
		messages: (user, args, {models}) => {
			return Object.values(models.messages).filter(
				//@ts-ignore
				(message) => message.userId === user.id
			);
		},
	},
};

export default user;

import message from "./message";
import user from "./user";

export default [message, user];

let users = {
  1: {
    id: "1",
    username: "hello shoakun 1",
    messageIds: [1],
  },
  2: {
    id: "2",
    username: "hello shaokun2",
    messageIds: [2],
  },
};

let messages = {
  1: {
    id: "1",
    text: "Hello World",
    userId: "1",
  },
  2: {
    id: "2",
    text: "By World",
    userId: "2",
  },
};

export default {
  users,
  messages,
};

function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) internal pure returns (uint amountOut) {
      require(amountIn > 0, 'UniswapV2Library: INSUFFICIENT_INPUT_AMOUNT');
      require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
      uint amountInWithFee = amountIn.mul(997);
      uint numerator = amountInWithFee.mul(reserveOut);
      uint denominator = reserveIn.mul(1000).add(amountInWithFee);
      amountOut = numerator / denominator;
  }

  // given an output amount of an asset and pair reserves, returns a required input amount of the other asset
  function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn) {
      require(amountOut > 0, 'UniswapV2Library: INSUFFICIENT_OUTPUT_AMOUNT');
      require(reserveIn > 0 && reserveOut > 0, 'UniswapV2Library: INSUFFICIENT_LIQUIDITY');
      uint numerator = reserveIn.mul(amountOut).mul(1000);
      uint denominator = reserveOut.sub(amountOut).mul(997);
      amountIn = (numerator / denominator).add(1);
  }

function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
    require(amount0Out > 0 || amount1Out > 0, 'UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT');
    (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
    require(amount0Out < _reserve0 && amount1Out < _reserve1, 'UniswapV2: INSUFFICIENT_LIQUIDITY');

    uint balance0;
    uint balance1;
    { // scope for _token{0,1}, avoids stack too deep errors
    address _token0 = token0;
    address _token1 = token1;
    require(to != _token0 && to != _token1, 'UniswapV2: INVALID_TO');
    if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
    if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
    if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
    balance0 = IERC20(_token0).balanceOf(address(this));
    balance1 = IERC20(_token1).balanceOf(address(this));
    }
    uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
    uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
    require(amount0In > 0 || amount1In > 0, 'UniswapV2: INSUFFICIENT_INPUT_AMOUNT');
    { // scope for reserve{0,1}Adjusted, avoids stack too deep errors
    uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
    uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
    require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'UniswapV2: K');
    }

    _update(balance0, balance1, _reserve0, _reserve1);
    emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
}

bytes memory bytecode = type(UniswapV2Pair).creationCode;
bytes32 salt = keccak256(abi.encodePacked(token0, token1));
    assembly {
         pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
   }
     IUniswapV2Pair(pair).initialize(token0, token1);

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;

contract Apple {
    struct Action {
        uint step;
        string from;
        string to;
        uint256 time;
        address player;
    }

    uint256 public id;                      // 序列号
    string public color;                    //颜色
    uint256 public flashMemory;             // 运行内存大小 4g
    uint256 public diskMemory;              //  储存空间大小 256g
    address public player;                  // 可以更新此合约数据的用户
    uint256 public actionCount;             // 总共加工次数
    Action[] public actions;
    address public factory;

    function getApple()
    public
    view
    returns (uint _id, uint _memory, uint _disk, uint _count, address _player, string memory _color){
        _id = id;
        _memory = flashMemory;
        _disk = diskMemory;
        _count = actionCount;
        _player = player;
        _color = color;

    }

    constructor() {
        factory = msg.sender;
    }

    event Trace(address player, string from, string to, uint256 time);
    event PlayerUpdate(address _pre, address newPlayer, uint256 time);

    function initialize(
        address _player,
        uint256 _id,
        uint256 _memory,
        uint256 _disk,
        string memory _color)
    external {
        require(msg.sender == factory, "permission deny");
        player = _player;
        id = _id;
        color = _color;
        flashMemory = _memory;
        diskMemory = _disk;
        _processAction("apple", "init");
    }

    function getActions(uint _start, uint _end) public view returns (Action[] memory atcs){
        uint end = _end + 1 >=  actions.length ? actions.length : _end;
        atcs = new Action[](end - _start);
        for (uint i = _start; i < end; i++) {
            atcs[i - _start] = actions[i];
        }
    }

    modifier onlyPlayer {
        require(player == msg.sender, "permission deny");
        _;
    }

    function updatePlayer(address _player) onlyPlayer external {
        address oldPlayer = player;
        player = _player;
        emit PlayerUpdate(oldPlayer, _player, block.timestamp);
    }

    function _processAction(string memory _from, string memory _to) internal {
        actionCount += 1;
        actions.push(Action({from : _from, to : _to, time : block.timestamp, step : actionCount,player:msg.sender}));
        emit Trace(player, _from, _to, block.timestamp);
    }

    function processAction(string memory _from, string memory _to) onlyPlayer public {
        _processAction(_from, _to);
    }

}

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

import "./Apple.sol";

interface IApple {
    function initialize(address _player, uint256 _id, uint256 _mem, uint256 _disk, string memory _c) external;
}

contract AppleFactory {

    address[] public apples;

    mapping(address => bool) public checkApple;
    
    bytes32 public hash;
    
    function getAllApples(uint _start, uint _end) public view returns(address[] memory _apples){
        _apples = new address[](_end - _start);
        for(uint i = _start; i < _end ; i++){
            _apples[i - _start] = apples[i];
        }
    }

    function totalApple() external view returns (uint256) {
        return apples.length;
    }

    event AppleCreated(address maker, uint256 _id, uint256 _memory, uint256 _disk, string _color, address _apple);

    function makeApple(
        uint256 _memory,
        uint256 _disk,
        string memory _color)
    external returns (address apple) {
        uint256 _id = apples.length + 1;
        bytes memory bytecode = type(Apple).creationCode;
        if (hash == bytes32(0)) {
            hash = keccak256(bytecode);
        }
        bytes32 salt = keccak256(abi.encodePacked(_id, _memory, _color));
        assembly {
            apple := create2(0, add(bytecode, 32), mload(bytecode), salt)
        }
        require(checkApple[apple] == false, 'this apple have been made');
        IApple(apple).initialize(msg.sender, _id, _memory, _disk, _color);
        apples.push(apple);
        emit AppleCreated(msg.sender, _id, _memory, _disk, _color, apple);
    }
    /// 可以通过同样的参数计算出对应的合约地址
    function getApple(int256 _id, uint256 _memory, uint256 _disk, string calldata _color)
    external
    view
    returns (address apple){
        apple = address(uint(keccak256(abi.encodePacked(
                hex'ff',
                address(this),
                keccak256(abi.encodePacked(_id, _memory, _disk, _color)),
                hash
            ))));
    }
}

pragma solidity ^0.7.0;

contract Test {
    bytes32 public DOMAIN_SEPARATOR;
    address public rc;
    mapping(address => uint) public nonces;
    mapping(address => uint) public amounts;
    bytes32 public constant TEST_TYPEHASH = keccak256('Test(address owner,uint256 amount,uint256 nonce)');
    constructor() {
        uint chainId;
        assembly {
            chainId := chainid() // 大于6.0以上是个方法,不是属性
        }
        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
                keccak256(bytes("shaokun")), // 此处一般填写此合约有意义的值
                keccak256(bytes('1')),
                chainId,
                address(this)
            )
        );
    }

    function testEIP712(address owner, uint256 amount, uint8 v, bytes32 r, bytes32 s) external {

        bytes32 digest = keccak256(
            abi.encodePacked('\x19\x01',
            DOMAIN_SEPARATOR,
            keccak256(abi.encode(TEST_TYPEHASH, owner, amount, nonces[owner]++))
            )
        );
        address recoveredAddress = ecrecover(digest, v, r, s);
        require(recoveredAddress != address(0) && recoveredAddress == owner, "account not fit");
        rc = recoveredAddress;
        amounts[owner] += amount;

    }
}

// 两个字段 types与domain
const eip712Obj = {
    types: {
        EIP712Domain: [
            { name: 'name', type: 'string' },
            { name: 'version', type: 'string' },
            { name: 'chainId', type: 'uint256' },
            { name: 'verifyingContract', type: 'address' },
        ],
        // 签名的结构,与合约保持一致
        Test: [
            { name: 'owner', type: 'address' },
            { name: 'amount', type: 'uint256' },
            { name: 'nonce', type: 'uint256' },
        ],
    },
   	
    domain: (chainId: number) => ({
        name: 'shaokun',
        version: '1',
        chainId: chainId,
        verifyingContract: '0x9F8C390b7048395d4DeBc7636031aD992115C303',
    }),
}
		
	// 签名所要的数据
  const data = JSON.stringify({
            types: eip712Obj.types,		
            domain: eip712Obj.domain(web3.chainId!!), // 获取当前的id,并返回与合约一致的数据
            primaryType: 'Test',	// 最开始hash的类型,如果有多个类型,需指定按照合约的顺序的第一个
            // test的数据具体内容
            message: {
                owner: web3.account,
                amount: inputV,
                nonce,
            },
        })


// 此处使用的web3-react,provider 为metamask
 web3.library.provider.request(
            {
                method: 'eth_signTypedData_v4',
                params: [web3.account, data],   // 两个参数,第一个必须为账号地址,第二个
            }).then((result: string) => {
            const signature = result.substring(2)
            const r = '0x' + signature.substring(0, 64)
            const s = '0x' + signature.substring(64, 128)
            const v = parseInt(signature.substring(128, 130), 16)
            // 得到签名结果的r,s,v,发送到链上校验即可
            console.log('---sign result -',{r,s,v})
        })