http:/exnew.finding3.io/jdDetail?id=181&color-theme=light&desc=&has-h-padding=true&has-v-padding=true&modules=comment&receiver=0x39Ef50bd29Ae125FE10C6a909E42e1C6a94Dde29&target_uri=baidu.com&height=800&display=iframe

https://www.ezswap.io&display=iframe

热武器热武器若发的说法

https://www.ezswap.io?color-theme=light&desc=&has-h-padding=true&has-v-padding=true&modules=comment&receiver=0x39Ef50bd29Ae125FE10C6a909E42e1C6a94Dde29&target_uri=baidu.com&height=800&display=iframe

开源方法：

1. 我比较喜欢的是标准json开源。如果是remix部署，请删除artifacts文件夹重新编译。然后获取build-info文件夹里的图片中的json

如果无法开源，看下构造函数中是否有复杂的参数，不如list。有的话请使用这个网站构造参数的abi-encode

https://abi.hashex.org/#

然后填入这里

2.ama很重要，也不要让人觉得太空洞无用，说点项目规划，真诚一点

3.合约需要验证，现在大家都不傻，多多少少能看明白

4.退款函数也要有，拉盘利器，什么时候放看自己项目，但是有这个就是很好的保障，对mint和币价都有支撑作用

5.mint三阶段 白名单，waitlist，公募。公募也设置好结束时间

6.转化率：Twitter40000人关注，premint 2万人，mint了几百个，来听space的几十个。第一天mint的人最多，效果不好，要及时ama之类的动作，不然凉的很快

7.premint很多机器人，要处理，网站上的的筛选条件不行，筛选可以设置的严格一点，premint设置的条件也可以严格一些

8.很意外，opensea上mint20个eth都能上排行榜，nft可能并没有想象中那么火

9.会有合作团队找上来要空投，白单，白的来源有多个地方，mint的时候也可能有人来找，梅克尔树可能会随时改

10.梅克尔树方面，5000个address，前端处理也问题不大，用户不会感觉慢，但是因为会随时改，所以可以弄个接口或者读文件，免的还要上线前端

11.就算opensea比mint的价格高，20%以内的收益都不会抹平，也会有大量的人观望，而不是像swap一样搬砖抹平差价，因为nft的流动性太小了。

12.谨记：赚钱的时候，请不要用公共的电脑，请不要用公共网络，请妥善管理相关钱包，黑客比想象中强大

13.用户会各种角度找问题质疑你，连域名剩余时间都会拿来做文章。所以多买几年吧，域名花不了几个钱

14.宣传要早，半个月就开mint会让人觉得赶时间，月抛

15.dc很重要，基本只有dc能很好的处理项目方和用户之间的沟通问题，请项目方做好mod工作

16.mod也是外人，但还是属于团队中的人，需要及时沟通，做到消息对等

17.pinata要用，但是注意要baseuri要设置成ipfs://xxxxx而不是他网站复制出来的网关。不然很容易爆

18.和实物结合的nft有问题，实物的真假，邮寄，权益的转移，权益使用的记录

19.opensea的元数据刷新机制很傻逼，要一个个进入详情点击刷新，opensea24小时内不会自动刷新缓存，之后会不会我就不知道了。我目前只知道这一个方法刷新缓存

总结

1. 设置好新区块总gas

2. 检查总gas，重放

3. 将gas转化成msg

4. 创建evm

5. 检查我们的余额是否足够接下来的操作

6. 调用evm执行合约/eth转账

7. 转账的话addr放入内存，然后执行transfer，修改stateobject的值

8. 给矿工钱

9. 返回receipt

源码

miner.start()

//入口
func (w *worker) commitTransactions(txs *types.TransactionsByPriceAndNonce, coinbase common.Address, interrupt *int32) bool {
   // Short circuit if current is nil
   if w.current == nil {
      return true
   }
  //先设置好总的gas，因为eth是按gas上限来规定一个区块的大小，btc是按区块容量
   gasLimit := w.current.header.GasLimit
   if w.current.gasPool == nil {
      w.current.gasPool = new(core.GasPool).AddGas(gasLimit)
   }

   var coalescedLogs []*types.Log

   for {
      // In the following three cases, we will interrupt the execution of the transaction.
在以下三种情况下，我们将中断事务的执行。
      // (1) new head block event arrival, the interrupt signal is 1
新磁头块事件到达时，中断信号为1
      // (2) worker start or restart, the interrupt signal is 1
工人启动或重启，中断信号为1
      // (3) worker recreate the mining block with any newly arrived transactions, the interrupt signal is 2.
工人用任何新到达的事务重新创建采矿区块，中断信号为2。
      // For the first two cases, the semi-finished work will be discarded.
对于前两种情况，半成品将被丢弃。
      // For the third case, the semi-finished work will be submitted to the consensus engine.
对于第三种情况，半成品将提交给共识引擎。
      if interrupt != nil && atomic.LoadInt32(interrupt) != commitInterruptNone {
         // Notify resubmit loop to increase resubmitting interval due to too frequent commits.
由于提交过于频繁，通知重新提交循环以增加重新提交间隔。
         if atomic.LoadInt32(interrupt) == commitInterruptResubmit {
            ratio := float64(gasLimit-w.current.gasPool.Gas()) / float64(gasLimit)
            if ratio < 0.1 {
               ratio = 0.1
            }
            w.resubmitAdjustCh <- &intervalAdjust{
               ratio: ratio,
               inc:   true,
            }
         }
         return atomic.LoadInt32(interrupt) == commitInterruptNewHead
      }
      // If we don't have enough gas for any further transactions then we're done
如果我们没有足够的gas来做进一步的交易，那我们结束
      if w.current.gasPool.Gas() < params.TxGas {
         log.Trace("Not enough gas for further transactions", "have", w.current.gasPool, "want", params.TxGas)
         break
      }
      // Retrieve the next transaction and abort if all done
//检索下一笔交易，如果交易集合为空则退出 commit
      tx := txs.Peek()
      if tx == nil {
         break
      }
      // Error may be ignored here. The error has already been checked
//这里可以忽略错误。已检查错误
      // during transaction acceptance is the transaction pool.
//在事务接受期间，是事务池。
      // We use the eip155 signer regardless of the current hf.
//我们使用eip155签名者，而不考虑当前的hf。eth硬分叉事件
      from, _ := types.Sender(w.current.signer, tx)
      // Check whether the tx is replay protected. If we're not in the EIP155 hf
      // phase, start ignoring the sender until we do.
      if tx.Protected() && !w.chainConfig.IsEIP155(w.current.header.Number) {
         log.Trace("Ignoring reply protected transaction", "hash", tx.Hash(), "eip155", w.chainConfig.EIP155Block)

         txs.Pop()
         continue
      }
      // Start executing the transaction
      w.current.state.Prepare(tx.Hash(), w.current.tcount)
      // 执行交易
      logs, err := w.commitTransaction(tx, coinbase)
      switch {
      case errors.Is(err, core.ErrGasLimitReached):
         // Pop the current out-of-gas transaction without shifting in the next from the account
在不从账户转入下一笔交易的情况下，弹出当前的out of gas交易
         log.Trace("Gas limit exceeded for current block", "sender", from)
         txs.Pop()

      case errors.Is(err, core.ErrNonceTooLow):
         // New head notification data race between the transaction pool and miner, shift
         log.Trace("Skipping transaction with low nonce", "sender", from, "nonce", tx.Nonce())
            // 移动到用户的下一个交易
         txs.Shift()

      case errors.Is(err, core.ErrNonceTooHigh):
         // Reorg notification data race between the transaction pool and miner, skip account =
         log.Trace("Skipping account with hight nonce", "sender", from, "nonce", tx.Nonce())
         txs.Pop()

      case errors.Is(err, nil):
         // Everything ok, collect the logs and shift in the next transaction from the same account
         coalescedLogs = append(coalescedLogs, logs...)
         w.current.tcount++
         txs.Shift()

      case errors.Is(err, core.ErrTxTypeNotSupported):
         // Pop the unsupported transaction without shifting in the next from the account
         log.Trace("Skipping unsupported transaction type", "sender", from, "type", tx.Type())
         txs.Pop()

      default:
         // Strange error, discard the transaction and get the next in line (note, the
         // nonce-too-high clause will prevent us from executing in vain).
         log.Debug("Transaction failed, account skipped", "hash", tx.Hash(), "err", err)
         txs.Shift()
      }
   }

   if !w.isRunning() && len(coalescedLogs) > 0 {
      // We don't push the pendingLogsEvent while we are mining. The reason is that
      // when we are mining, the worker will regenerate a mining block every 3 seconds.
      // In order to avoid pushing the repeated pendingLog, we disable the pending log pushing.

      // make a copy, the state caches the logs and these logs get "upgraded" from pending to mined
      // logs by filling in the block hash when the block was mined by the local miner. This can
      // cause a race condition if a log was "upgraded" before the PendingLogsEvent is processed.
        // 因为需要把log发送出去，而这边在挖矿完成后需要对log进行修改，所以拷贝一份发送出去，避免争用。
      cpy := make([]*types.Log, len(coalescedLogs))
      for i, l := range coalescedLogs {
         cpy[i] = new(types.Log)
         *cpy[i] = *l
      }
      w.pendingLogsFeed.Send(cpy)
   }
   // Notify resubmit loop to decrease resubmitting interval if current interval is larger
   // than the user-specified one.
   if interrupt != nil {
      w.resubmitAdjustCh <- &intervalAdjust{inc: false}
   }
   return false
}

func ApplyTransaction(config *params.ChainConfig, bc ChainContext, author *common.Address, gp *GasPool, statedb *state.StateDB, header *types.Header, tx *types.Transaction, usedGas *uint64, cfg vm.Config) (*types.Receipt, error) {
//将types.Transaction结构变量转为core.Message对象；这过程中会对发送者做签名验证，并获得发送者的地址缓存起来
   msg, err := tx.AsMessage(types.MakeSigner(config, header.Number), header.BaseFee)
   if err != nil {
      return nil, err
   }
   // Create a new context to be used in the EVM environment
    //创建新的上下文（Context），此上下文将在EVM 环境（EVM environment）中使用；上下文中包含msg，区块头、区块指针、作者（挖矿者、获益者）

   blockContext := NewEVMBlockContext(header, bc, author)
    //创建新的EVM environment，其中包括了交易相关的所有信息以及调用机制；
   vmenv := vm.NewEVM(blockContext, vm.TxContext{}, statedb, config, cfg)
    //处理交易，将交易应用于当前的状态中，也就是执行状态转换，新的状态包含在环境对象中；得到执行结果以及花费的gas；
   return applyTransaction(msg, config, bc, author, gp, statedb, header.Number, header.Hash(), tx, usedGas, vmenv)
}

跳过一段调用ApplyMessage，并将返回的内容整理成receipt代码

func (st *StateTransition) TransitionDb() (*ExecutionResult, error) {
   // First check this message satisfies all consensus rules before
//首先检查此消息是否满足所有共识规则
   // applying the message. The rules include these clauses
//应用消息。规则包括这些条款
   //
   // 1. the nonce of the message caller is correct
//调用方的nonce是正确的
   // 2. caller has enough balance to cover transaction fee(gaslimit * gasprice)
//调用者有足够的余额支付交易费用（gaslimit*gasprice）
   // 3. the amount of gas required is available in the block
区块内有可用的所需gas
   // 4. the purchased gas is enough to cover intrinsic usage
   // 5. there is no overflow when calculating intrinsic gas
没有gas溢出
   // 6. caller has enough balance to cover asset transfer for **topmost** call
//调用者有足够的gas to transfer
   // Check clauses 1-3, buy gas if everything is correct
    //    b. buyGas：根据发送者定的gaslimit和GasPrice，从发送者余额中扣除以太币；从区块gas池中减掉本次gas；并对运行环境做好更新；
   if err := st.preCheck(); err != nil {
      return nil, err
   }
   msg := st.msg
   sender := vm.AccountRef(msg.From())
   homestead := st.evm.ChainConfig().IsHomestead(st.evm.Context.BlockNumber)
   istanbul := st.evm.ChainConfig().IsIstanbul(st.evm.Context.BlockNumber)
   contractCreation := msg.To() == nil

   // Check clauses 4-5, subtract intrinsic gas if everything is correct
    //支付固定费用 intrinsic gas。contractCreation为true即为合约创建,固定费用为53000；为false，则为普通交易固定费用为21000
   gas, err := IntrinsicGas(st.data, st.msg.AccessList(), contractCreation, homestead, istanbul)
   if err != nil {
      return nil, err
   }
   if st.gas < gas {
      return nil, fmt.Errorf("%w: have %d, want %d", ErrIntrinsicGas, st.gas, gas)
   }
   st.gas -= gas

   // Check clause 6
   if msg.Value().Sign() > 0 && !st.evm.Context.CanTransfer(st.state, msg.From(), msg.Value()) {
      return nil, fmt.Errorf("%w: address %v", ErrInsufficientFundsForTransfer, msg.From().Hex())
   }

   // Set up the initial access list.
   if rules := st.evm.ChainConfig().Rules(st.evm.Context.BlockNumber); rules.IsBerlin {
      st.state.PrepareAccessList(msg.From(), msg.To(), vm.ActivePrecompiles(rules), msg.AccessList())
   }
   var (
      ret   []byte
      vmerr error // vm errors do not effect consensus and are therefore not assigned to err
   )
    //如果是合约创建， 那么调用evm的Create方法创建新的合约，使用交易的data作为新合约的部署代码
   if contractCreation {
      ret, _, st.gas, vmerr = st.evm.Create(sender, st.data, st.gas, st.value)
   } else {
      // Increment the nonce for the next transaction
//否则不是合约创建，增加发送者的Nonce值，然后调用evm.Call执行交易
      st.state.SetNonce(msg.From(), st.state.GetNonce(sender.Address())+1)
//真正转账的地方
      ret, st.gas, vmerr = st.evm.Call(sender, st.to(), st.data, st.gas, st.value)
   }
   if !st.evm.ChainConfig().IsLondon(st.evm.Context.BlockNumber) {
      // Before EIP-3529: refunds were capped to gasUsed / 2
      st.refundGas(params.RefundQuotient)
   } else {
      // After EIP-3529: refunds are capped to gasUsed / 5
      st.refundGas(params.RefundQuotientEIP3529)
   }
   effectiveTip := st.gasPrice
   if st.evm.ChainConfig().IsLondon(st.evm.Context.BlockNumber) {
      effectiveTip = cmath.BigMin(st.gasTipCap, new(big.Int).Sub(st.gasFeeCap, st.evm.Context.BaseFee))
   }
   st.state.AddBalance(st.evm.Context.Coinbase, new(big.Int).Mul(new(big.Int).SetUint64(st.gasUsed()), effectiveTip))

   return &ExecutionResult{
      UsedGas:    st.gasUsed(),
      Err:        vmerr,
      ReturnData: ret,
   }, nil
}

//转账
func (evm *EVM) Call(caller ContractRef, addr common.Address, input []byte, gas uint64, value *big.Int) (ret []byte, leftOverGas uint64, err error) {
    //检查是否允许递归执行以及执行深度，若深度超过params.CallCreateDepth（即1024）就出错返回；
   if evm.Config.NoRecursion && evm.depth > 0 {
      return nil, gas, nil
   }
   // Fail if we're trying to execute above the call depth limit
   if evm.depth > int(params.CallCreateDepth) {
      return nil, gas, ErrDepth
   }
   // Fail if we're trying to transfer more than the available balance
   if value.Sign() != 0 && !evm.Context.CanTransfer(evm.StateDB, caller.Address(), value) {
      return nil, gas, ErrInsufficientBalance
   }
   snapshot := evm.StateDB.Snapshot()
   p, isPrecompile := evm.precompile(addr)
    
  //这个地址如果不在statedb中，则创建，就是不在内存中，就放到内存里
   if !evm.StateDB.Exist(addr) {
      if !isPrecompile && evm.chainRules.IsEIP158 && value.Sign() == 0 {
         // Calling a non existing account, don't do anything, but ping the tracer
         if evm.Config.Debug && evm.depth == 0 {
            evm.Config.Tracer.CaptureStart(evm, caller.Address(), addr, false, input, gas, value)
            evm.Config.Tracer.CaptureEnd(ret, 0, 0, nil)
         }
         return nil, gas, nil
      }
      evm.StateDB.CreateAccount(addr)
   }
//转账
   evm.Context.Transfer(evm.StateDB, caller.Address(), addr, value)

   // Capture the tracer start/end events in debug mode
   if evm.Config.Debug && evm.depth == 0 {
      evm.Config.Tracer.CaptureStart(evm, caller.Address(), addr, false, input, gas, value)
      defer func(startGas uint64, startTime time.Time) { // Lazy evaluation of the parameters
         evm.Config.Tracer.CaptureEnd(ret, startGas-gas, time.Since(startTime), err)
      }(gas, time.Now())
   }

   if isPrecompile {
      ret, gas, err = RunPrecompiledContract(p, input, gas)
   } else {
      // Initialise a new contract and set the code that is to be used by the EVM.
      // The contract is a scoped environment for this execution context only.
      code := evm.StateDB.GetCode(addr)
      if len(code) == 0 {
         ret, err = nil, nil // gas is unchanged
      } else {
         addrCopy := addr
         // If the account has no code, we can abort here
         // The depth-check is already done, and precompiles handled above
         contract := NewContract(caller, AccountRef(addrCopy), value, gas)
         contract.SetCallCode(&addrCopy, evm.StateDB.GetCodeHash(addrCopy), code)
         ret, err = evm.interpreter.Run(contract, input, false)
         gas = contract.Gas
      }
   }
   // When an error was returned by the EVM or when setting the creation code
   // above we revert to the snapshot and consume any gas remaining. Additionally
   // when we're in homestead this also counts for code storage gas errors.
   if err != nil {
      evm.StateDB.RevertToSnapshot(snapshot)
      if err != ErrExecutionReverted {
         gas = 0
      }
      // TODO: consider clearing up unused snapshots:
      //} else {
      // evm.StateDB.DiscardSnapshot(snapshot)
   }
   return ret, gas, err
}

//转账操作，实际上就是再stateobject中加减，然后写入journal
func Transfer(db vm.StateDB, sender, recipient common.Address, amount *big.Int) {
    db.SubBalance(sender, amount)
    db.AddBalance(recipient, amount)
}

简单总结流程：

1. 将from打包成钱包

2. 将请求参数包装成tx

3. 签名

4. 验证签名

5. 验证交易是否合法

6. 加入queue前的一些校验

7. 加入pool的queue队列和all数组

8. 加入pending前的一些校验

9. 加入pool的pending队列

10. 广播

//命令
eth.sendTransaction({from:'0xc57998cd5e4ad8bd82f7f6495771edb438d7452c' , to: '0xe16b36be71d89641bd2bae440b348bdcd93f127c', value: web3.toWei(1,"ether")})
//入口
func (s *PublicTransactionPoolAPI) SendTransaction(ctx context.Context, args TransactionArgs) (common.Hash, error) {
    // Look up the wallet containing the requested signer
    account := accounts.Account{Address: args.from()}

    wallet, err := s.b.AccountManager().Find(account)
    if err != nil {
        return common.Hash{}, err
    }

    if args.Nonce == nil {
        // Hold the addresse's mutex around signing to prevent concurrent assignment of
        // the same nonce to multiple accounts.
        s.nonceLock.LockAddr(args.from())
        defer s.nonceLock.UnlockAddr(args.from())
    }

    // Set some sanity defaults and terminate on failure
    if err := args.setDefaults(ctx, s.b); err != nil {
        return common.Hash{}, err
    }
    // Assemble the transaction and sign with the wallet
        // 打包请求参数，封装成tx
    tx := args.toTransaction()
        //签名
    signed, err := wallet.SignTx(account, tx, s.b.ChainConfig().ChainID)
    if err != nil {
        return common.Hash{}, err
    }
        //处理交易
    return SubmitTransaction(ctx, s.b, signed)
}

签名

//使用规定的规范进行签名，我的版本是伦敦升级版本
func SignTx(tx *Transaction, s Signer, prv *ecdsa.PrivateKey) (*Transaction, error) {
  //1.对交易进行哈希
   h := s.Hash(tx)
//2.生成签名，里面就看不懂了，总之就是算出R，S，V，在放入tx中
   sig, err := crypto.Sign(h[:], prv)
   if err != nil {
      return nil, err
   }
//3.将签名数据填充到Tx信息中
   return tx.WithSignature(s, sig)
}

type txLookup struct {
   slots   int
   lock    sync.RWMutex
   locals  map[common.Hash]*types.Transaction
   remotes map[common.Hash]*types.Transaction
}

交易加入pool

//前面跳过了一些可以不用关心的步骤
func (pool *TxPool) add(tx *types.Transaction, local bool) (replaced bool, err error) {
    // If the transaction is already known, discard it
//获取交易hash并以此判断交易池中是否已存在该笔交易
    hash := tx.Hash()
    if pool.all.Get(hash) != nil {
        log.Trace("Discarding already known transaction", "hash", hash)
        knownTxMeter.Mark(1)
        return false, ErrAlreadyKnown
    }
    // Make the local flag. If it's from local source or it's from the network but
    // the sender is marked as local previously, treat it as the local transaction.
    isLocal := local || pool.locals.containsTx(tx)

    // If the transaction fails basic validation, discard it
// 验证交易合法性
    if err := pool.validateTx(tx, isLocal); err != nil {
        log.Trace("Discarding invalid transaction", "hash", hash, "err", err)
        invalidTxMeter.Mark(1)
        return false, err
    }
    // If the transaction pool is full, discard underpriced transactions
// 如果交易池已满，按priced数组中gas price较低的交易剔除
    if uint64(pool.all.Slots()+numSlots(tx)) > pool.config.GlobalSlots+pool.config.GlobalQueue {
        // If the new transaction is underpriced, don't accept it
        if !isLocal && pool.priced.Underpriced(tx) {
            log.Trace("Discarding underpriced transaction", "hash", hash, "gasTipCap", tx.GasTipCap(), "gasFeeCap", tx.GasFeeCap())
            underpricedTxMeter.Mark(1)
            return false, ErrUnderpriced
        }
        // New transaction is better than our worse ones, make room for it.
        // If it's a local transaction, forcibly discard all available transactions.
        // Otherwise if we can't make enough room for new one, abort the operation.
        drop, success := pool.priced.Discard(pool.all.Slots()-int(pool.config.GlobalSlots+pool.config.GlobalQueue)+numSlots(tx), isLocal)

        // Special case, we still can't make the room for the new remote one.
        if !isLocal && !success {
            log.Trace("Discarding overflown transaction", "hash", hash)
            overflowedTxMeter.Mark(1)
            return false, ErrTxPoolOverflow
        }
        // Kick out the underpriced remote transactions.
        for _, tx := range drop {
            log.Trace("Discarding freshly underpriced transaction", "hash", tx.Hash(), "gasTipCap", tx.GasTipCap(), "gasFeeCap", tx.GasFeeCap())
            underpricedTxMeter.Mark(1)
            pool.removeTx(tx.Hash(), false)
        }
    }
    // Try to replace an existing transaction in the pending pool
// 如果交易已经存在于pending列表，比较新旧交易gasPrice的差值是否超过PriceBump
    // 若超过则使用新交易代替旧交易
    from, _ := types.Sender(pool.signer, tx) // already validated
    if list := pool.pending[from]; list != nil && list.Overlaps(tx) {
        // Nonce already pending, check if required price bump is met
        inserted, old := list.Add(tx, pool.config.PriceBump)
        if !inserted {
            pendingDiscardMeter.Mark(1)
            return false, ErrReplaceUnderpriced
        }
        // New transaction is better, replace old one
        if old != nil {
            pool.all.Remove(old.Hash())
            pool.priced.Removed(1)
            pendingReplaceMeter.Mark(1)
        }
        pool.all.Add(tx, isLocal)
        pool.priced.Put(tx, isLocal)
        pool.journalTx(from, tx)
        pool.queueTxEvent(tx)
        log.Trace("Pooled new executable transaction", "hash", hash, "from", from, "to", tx.To())

        // Successful promotion, bump the heartbeat
        pool.beats[from] = time.Now()
        return old != nil, nil
    }
    // New transaction isn't replacing a pending one, push into queue
// 将交易添加到queue队列
    replaced, err = pool.enqueueTx(hash, tx, isLocal, true)
    if err != nil {
        return false, err
    }
    // Mark local addresses and journal local transactions
// 判断是否本地交易，保证本地交易优先被加入到TxPool
    if local && !pool.locals.contains(from) {
        log.Info("Setting new local account", "address", from)
        pool.locals.add(from)
        pool.priced.Removed(pool.all.RemoteToLocals(pool.locals)) // Migrate the remotes if it's marked as local first time.
    }
    if isLocal {
        localGauge.Inc(1)
    }
    pool.journalTx(from, tx)

    log.Trace("Pooled new future transaction", "hash", hash, "from", from, "to", tx.To())
    return replaced, nil
}

//验证tx是否合法
func (pool *TxPool) validateTx(tx *types.Transaction, local bool) error {
   // Accept only legacy transactions until EIP-2718/2930 activates.
   if !pool.eip2718 && tx.Type() != types.LegacyTxType {
      return ErrTxTypeNotSupported
   }
   // Reject dynamic fee transactions until EIP-1559 activates.
   if !pool.eip1559 && tx.Type() == types.DynamicFeeTxType {
      return ErrTxTypeNotSupported
   }
   // Reject transactions over defined size to prevent DOS attacks
   if uint64(tx.Size()) > txMaxSize {
      return ErrOversizedData
   }
   // Transactions can't be negative. This may never happen using RLP decoded
   // transactions but may occur if you create a transaction using the RPC.
   if tx.Value().Sign() < 0 {
      return ErrNegativeValue
   }
   // Ensure the transaction doesn't exceed the current block limit gas.
   if pool.currentMaxGas < tx.Gas() {
      return ErrGasLimit
   }
   // Sanity check for extremely large numbers
   if tx.GasFeeCap().BitLen() > 256 {
      return ErrFeeCapVeryHigh
   }
   if tx.GasTipCap().BitLen() > 256 {
      return ErrTipVeryHigh
   }
   // Ensure gasFeeCap is greater than or equal to gasTipCap.
   if tx.GasFeeCapIntCmp(tx.GasTipCap()) < 0 {
      return ErrTipAboveFeeCap
   }
   // Make sure the transaction is signed properly.
   from, err := types.Sender(pool.signer, tx)
   if err != nil {
      return ErrInvalidSender
   }
   // Drop non-local transactions under our own minimal accepted gas price or tip
   if !local && tx.GasTipCapIntCmp(pool.gasPrice) < 0 {
      return ErrUnderpriced
   }
   // Ensure the transaction adheres to nonce ordering
   if pool.currentState.GetNonce(from) > tx.Nonce() {
      return ErrNonceTooLow
   }
   // Transactor should have enough funds to cover the costs
   // cost == V + GP * GL
   if pool.currentState.GetBalance(from).Cmp(tx.Cost()) < 0 {
      return ErrInsufficientFunds
   }
   // Ensure the transaction has more gas than the basic tx fee.
   intrGas, err := IntrinsicGas(tx.Data(), tx.AccessList(), tx.To() == nil, true, pool.istanbul)
   if err != nil {
      return err
   }
   if tx.Gas() < intrGas {
      return ErrIntrinsicGas
   }
   return nil
}

//将交易添加到queue队列，这个队列是代表暂时不可处理的交易队列
func (pool *TxPool) enqueueTx(hash common.Hash, tx *types.Transaction, local bool, addAll bool) (bool, error) {
   // Try to insert the transaction into the future queue
  //这个account是否有tx list，没有的话创建一个 
  from, _ := types.Sender(pool.signer, tx) // already validated
   if pool.queue[from] == nil {
      pool.queue[from] = newTxList(false)
   }
   inserted, old := pool.queue[from].Add(tx, pool.config.PriceBump)
   if !inserted {
      // An older transaction was better, discard this
      queuedDiscardMeter.Mark(1)
      return false, ErrReplaceUnderpriced
   }
   // Discard any previous transaction and mark this
   if old != nil {
      pool.all.Remove(old.Hash())
      pool.priced.Removed(1)
      queuedReplaceMeter.Mark(1)
   } else {
      // Nothing was replaced, bump the queued counter
      queuedGauge.Inc(1)
   }
   // If the transaction isn't in lookup set but it's expected to be there,
   // show the error log.
//all队列是否有这笔交易
   if pool.all.Get(hash) == nil && !addAll {
      log.Error("Missing transaction in lookup set, please report the issue", "hash", hash)
   }
   if addAll {
//将这个tx添加到all队列
      pool.all.Add(tx, local)
      pool.priced.Put(tx, local)
   }
   // If we never record the heartbeat, do it right now.
   if _, exist := pool.beats[from]; !exist {
      pool.beats[from] = time.Now()
   }
   return old != nil, nil
}

func (pool *TxPool) promoteExecutables(accounts []common.Address) []*types.Transaction {
   // Track the promoted transactions to broadcast them at once
   var promoted []*types.Transaction

   // Iterate over all accounts and promote any executable transactions
   for _, addr := range accounts {
      list := pool.queue[addr]
      if list == nil {
         continue // Just in case someone calls with a non existing account
      }
      // Drop all transactions that are deemed too old (low nonce)
// 1.1丢弃交易nonce值 < 账户当前nonce的交易
      forwards := list.Forward(pool.currentState.GetNonce(addr))
      for _, tx := range forwards {
         hash := tx.Hash()
         pool.all.Remove(hash)
      }
      log.Trace("Removed old queued transactions", "count", len(forwards))
      // Drop all transactions that are too costly (low balance or out of gas)
// 1.2.丢弃账户余额不足的
      drops, _ := list.Filter(pool.currentState.GetBalance(addr), pool.currentMaxGas)
      for _, tx := range drops {
         hash := tx.Hash()
         pool.all.Remove(hash)
      }
      log.Trace("Removed unpayable queued transactions", "count", len(drops))
      queuedNofundsMeter.Mark(int64(len(drops)))

      // Gather all executable transactions and promote them
// 3.将交易添加到pending列表
      readies := list.Ready(pool.pendingNonces.get(addr))
      for _, tx := range readies {
         hash := tx.Hash()
         //广播tx
         if pool.promoteTx(addr, hash, tx) {
            promoted = append(promoted, tx)
         }
      }
      log.Trace("Promoted queued transactions", "count", len(promoted))
      queuedGauge.Dec(int64(len(readies)))

      // Drop all transactions over the allowed limit
      var caps types.Transactions
      if !pool.locals.contains(addr) {
         caps = list.Cap(int(pool.config.AccountQueue))
         for _, tx := range caps {
            hash := tx.Hash()
            pool.all.Remove(hash)
            log.Trace("Removed cap-exceeding queued transaction", "hash", hash)
         }
         queuedRateLimitMeter.Mark(int64(len(caps)))
      }
      // Mark all the items dropped as removed
      pool.priced.Removed(len(forwards) + len(drops) + len(caps))
      queuedGauge.Dec(int64(len(forwards) + len(drops) + len(caps)))
      if pool.locals.contains(addr) {
         localGauge.Dec(int64(len(forwards) + len(drops) + len(caps)))
      }
      // Delete the entire queue entry if it became empty.
      if list.Empty() {
         delete(pool.queue, addr)
         delete(pool.beats, addr)
      }
   }
   return promoted
}

源码

入口

//命令
eth.getBlock(1,true)
//跳过了前面几层
func (bc *BlockChain) GetBlockByNumber(number uint64) *types.Block {
        //用block number换block的hash
    hash := rawdb.ReadCanonicalHash(bc.db, number)
    if hash == (common.Hash{}) {
        return nil
    }
        //根据hash和number获取block
    return bc.GetBlock(hash, number)
}

//获取hash
func ReadCanonicalHash(db ethdb.Reader, number uint64) common.Hash {
  //这个还没弄明白
   data, _ := db.Ancient(freezerHashTable, number)
   if len(data) == 0 {
  //从db中读
      data, _ = db.Get(headerHashKey(number))
      if len(data) == 0 {
         data, _ = db.Ancient(freezerHashTable, number)
      }
   }
   if len(data) == 0 {
      return common.Hash{}
   }
   return common.BytesToHash(data)
}

//获取区块
func (bc *BlockChain) GetBlock(hash common.Hash, number uint64) *types.Block {
   //从缓存中读，这里用到了lur
   if block, ok := bc.blockCache.Get(hash); ok {
      return block.(*types.Block)
   }
//从db中读，内容和getbalance一样，里面是先获取header，再获取body，然后创建区块，将header和body copy到block返回
   block := rawdb.ReadBlock(bc.db, hash, number)
   if block == nil {
      return nil
   }
//缓存区块
   bc.blockCache.Add(block.Hash(), block)
   return block
}

两篇get方法都是大同小异，进一步了解到eth是可以很简单的实现的，那些很牛逼的东西，都是为了满足区块链、性能这些需求。

另外这篇内容的主要代码都在blockchain内，又一次出现了这个，说明很重要，而statedb却没有出现，目前可以猜测statedb和账户有关，和block无关，需要后续验证。

也能知道leveldb里大致存的内容

1. 用户数据

2. header

3. number→hash

4. body,body里存了tx，uncle

5. 可以想象还有receipt

//block的例子
{
  difficulty: 1461115576915,
  extraData: "0x476574682f76312e302e312f6c696e75782f676f312e342e32",
  gasLimit: 22150,
  gasUsed: 21000,
  hash: "0xeecb25ce31fb7a212500443a31d463b663a2c5f65e7838c5364bb8110a0750f1",
  logsBloom: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
  miner: "0x47ff6576639c2e94762ea5443978d7681c0e78dc",
  mixHash: "0xaaad7bf5c87f1b2fc08ed73a1519dae6832b458a112891cd7c5a0a86125a8321",
  nonce: "0x4e164418632effd2",
  number: 46251,
  parentHash: "0x3c93a7ff6fb6f39e63456e9ea6fb069c7783f3c00b1012e36f0a8a02bdae604a",
  receiptsRoot: "0x5add83c7805c02ab079871e3a2379b6a764d34e557d758ddce00b6a1bf5cc79f",
  sha3Uncles: "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
  size: 652,
  stateRoot: "0x7692ecfeac33453620701bad9eae23f89c01e845274f0e5adec78a5ea96f5083",
  timestamp: 1438919990,
  totalDifficulty: 42835839136947252,
  transactions: [{
      blockHash: "0xeecb25ce31fb7a212500443a31d463b663a2c5f65e7838c5364bb8110a0750f1",
      blockNumber: 46251,
      from: "0xfd2605a2bf58fdbb90db1da55df61628b47f9e8c",
      gas: 21000,
      gasPrice: 88893746891,
      hash: "0x304346de678ddca5b1311970e7e8d3f26a42d2924aaa2f2d73b8781a9a9a2c73",
      input: "0x",
      nonce: 1,
      r: "0x26f3e5c541f526b549d9f003c8e7de442d3cf4bbf9c66934027672693a88275f",
      s: "0x7bd40d54be85b58444d6f0a28f22591474a84380fc8a6a7515bda42b5ebb0e2b",
      to: "0x073f70b5bfade6409e4951ef72bc8f4157677729",
      transactionIndex: 0,
      v: "0x1c",
      value: 10000000000000000
  }],
  transactionsRoot: "0xf642520ac0ce7008292d2c835b8d2e6eb90822f8a68b8ae368b0774229371b5d",
  uncles: []
}

{
    "config": {
        "chainId": 8888, //自行修改
        "homesteadBlock": 0,
        "daoForkBlock": 0,
        "daoForkSupport": true,
        "eip150Block": 0,
        "eip155Block": 0,
        "eip158Block": 0,
        "byzantiumBlock": 0,
        "constantinopleBlock": 0,
        "petersburgBlock": 0,
        "ethash": {}
    },
    "nonce": "0x42",
    "timestamp": "0x0",
    "extraData": "0x11bbe8db4e347b4e8c937c1c8370e4b5ed33adb3db69cbdb7a38e1e50b1b82fa",
    "gasLimit": "0xffffffff",
    "difficulty": "0x700000",//难度，越大挖矿越慢
    "alloc": {
        "093f59f1d91017d30d8c2caa78feb5beb0d2cfaf": {
            "balance": "0xffffffffffffffff"
        },
        "ddf7202cbe0aaed1c2d5c4ef05e386501a054406": {
            "balance": "0xffffffffffffffff"
        }
    }
}

因为要分析源码，所以不是像网上命令行执行，而是使用goland debug

参数
--datadir "/Users/zhangnan/Downloads/self_eth/" init "/Users/zhangnan/Downloads/geth/genesis.json"

初始化
func initGenesis(ctx *cli.Context) error {
    // Make sure we have a valid genesis JSON
    genesisPath := ctx.Args().First()
    if len(genesisPath) == 0 {
        utils.Fatalf("Must supply path to genesis JSON file")
    }
    file, err := os.Open(genesisPath)
    if err != nil {
        utils.Fatalf("Failed to read genesis file: %v", err)
    }
    defer file.Close()

    genesis := new(core.Genesis)
    if err := json.NewDecoder(file).Decode(genesis); err != nil {
        utils.Fatalf("invalid genesis file: %v", err)
    }
//以上是读初始化文件，下面开始第一个重要步骤，配置config
    // Open and initialise both full and light databases
    stack, _ := makeConfigNode(ctx)
    defer stack.Close()

    for _, name := range []string{"chaindata", "lightchaindata"} {
        chaindb, err := stack.OpenDatabase(name, 0, 0, "", false)
        if err != nil {
            utils.Fatalf("Failed to open database: %v", err)
        }
        _, hash, err := core.SetupGenesisBlock(chaindb, genesis)
        if err != nil {
            utils.Fatalf("Failed to write genesis block: %v", err)
        }
        chaindb.Close()
        log.Info("Successfully wrote genesis state", "database", name, "hash", hash)
    }
    return nil
}

声明：eth版本：Geth/v1.10.7-unstable/darwin-arm64/go1.17.5，我对比了网上的一些文章，这块代码有改动，主要以下改变

1. 从BlockChain的snap中读account

2. 几乎放弃从trie中获取account，判断极为严苛，我想不到有什么情况能进入，应该是放弃了这层

分析

入口

//命令
eth.getBalance('0x0d7dd6dbabee2ec9b325aa7aa8b42d75068e8597')

//入口
func (s *PublicBlockChainAPI) GetBalance(ctx context.Context, address common.Address, blockNrOrHash rpc.BlockNumberOrHash) (*hexutil.Big, error) {
  //获取statedb
   state, _, err := s.b.StateAndHeaderByNumberOrHash(ctx, blockNrOrHash)
   if state == nil || err != nil {
      return nil, err
   }
//获取余额
   return (*hexutil.Big)(state.GetBalance(address)), state.Error()
}

创建statedb

func (b *EthAPIBackend) StateAndHeaderByNumberOrHash(ctx context.Context, blockNrOrHash rpc.BlockNumberOrHash) (*state.StateDB, *types.Header, error) {
//根据最新的hader state root创建statedb
   if blockNr, ok := blockNrOrHash.Number(); ok {
      return b.StateAndHeaderByNumber(ctx, blockNr)
   }
   if hash, ok := blockNrOrHash.Hash(); ok {
      header, err := b.HeaderByHash(ctx, hash)
      if err != nil {
         return nil, nil, err
      }
      if header == nil {
         return nil, nil, errors.New("header for hash not found")
      }
      if blockNrOrHash.RequireCanonical && b.eth.blockchain.GetCanonicalHash(header.Number.Uint64()) != hash {
         return nil, nil, errors.New("hash is not currently canonical")
      }
      stateDb, err := b.eth.BlockChain().StateAt(header.Root)
      return stateDb, header, err
   }
   return nil, nil, errors.New("invalid arguments; neither block nor hash specified")
}

func (b *EthAPIBackend) StateAndHeaderByNumber(ctx context.Context, number rpc.BlockNumber) (*state.StateDB, *types.Header, error) {
   // Pending state is only known by the miner
  //有Pending的区块，从这里面获取statedb
   if number == rpc.PendingBlockNumber {
      block, state := b.eth.miner.Pending()
      return state, block.Header(), nil
   }
   // Otherwise resolve the block number and return its state
   header, err := b.HeaderByNumber(ctx, number)
   if err != nil {
      return nil, nil, err
   }
   if header == nil {
      return nil, nil, errors.New("header not found")
   }
//创建新的statedb
   stateDb, err := b.eth.BlockChain().StateAt(header.Root)
   return stateDb, header, err
}

//主要做了两件事，创建trie和snap
func New(root common.Hash, db Database, snaps *snapshot.Tree) (*StateDB, error) {
   fmt.Println("root=====", root.String())
   tr, err := db.OpenTrie(root)
   if err != nil {
      return nil, err
   }
   sdb := &StateDB{
      db:                  db,
      trie:                tr,
      originalRoot:        root,
      snaps:               snaps,
      stateObjects:        make(map[common.Address]*stateObject),
      stateObjectsPending: make(map[common.Address]struct{}),
      stateObjectsDirty:   make(map[common.Address]struct{}),
      logs:                make(map[common.Hash][]*types.Log),
      preimages:           make(map[common.Hash][]byte),
      journal:             newJournal(),
      accessList:          newAccessList(),
      hasher:              crypto.NewKeccakState(),
   }
   if sdb.snaps != nil {
      if sdb.snap = sdb.snaps.Snapshot(root); sdb.snap != nil {
         sdb.snapDestructs = make(map[common.Hash]struct{})
         sdb.snapAccounts = make(map[common.Hash][]byte)
         sdb.snapStorage = make(map[common.Hash]map[common.Hash][]byte)
      }
   }
   return sdb, nil
}

statedb获取完毕，获取balance

回到最开始从GetBalance进入

func (s *StateDB) getDeletedStateObject(addr common.Address) *stateObject {
   fmt.Println("addr=====", addr.String())
   // Prefer live objects if any is available
  //从stateobject中获取
   if obj := s.stateObjects[addr]; obj != nil {
      return obj
   }
   // If no live objects are available, attempt to use snapshots
   var (
      data *Account
      err  error
   )
//从缓存中获取
   if s.snap != nil {
      if metrics.EnabledExpensive {
         defer func(start time.Time) { s.SnapshotAccountReads += time.Since(start) }(time.Now())
      }
      var acc *snapshot.Account
      if acc, err = s.snap.Account(crypto.HashData(s.hasher, addr.Bytes())); err == nil {
         if acc == nil {
            return nil
         }
         data = &Account{
            Nonce:    acc.Nonce,
            Balance:  acc.Balance,
            CodeHash: acc.CodeHash,
            Root:     common.BytesToHash(acc.Root),
         }
         if len(data.CodeHash) == 0 {
            data.CodeHash = emptyCodeHash
         }
         if data.Root == (common.Hash{}) {
            data.Root = emptyRoot
         }
      }
   }
   // If snapshot unavailable or reading from it failed, load from the database
//从trie中获取
   if s.snap == nil || err != nil {
      if metrics.EnabledExpensive {
         defer func(start time.Time) { s.AccountReads += time.Since(start) }(time.Now())
      }
      enc, err := s.trie.TryGet(addr.Bytes())
      if err != nil {
         s.setError(fmt.Errorf("getDeleteStateObject (%x) error: %v", addr.Bytes(), err))
         return nil
      }
      if len(enc) == 0 {
         return nil
      }
      data = new(Account)
      if err := rlp.DecodeBytes(enc, data); err != nil {
         log.Error("Failed to decode state object", "addr", addr, "err", err)
         return nil
      }
   }
   // Insert into the live set
   obj := newObject(s, addr, *data)
   s.setStateObject(obj)
   return obj
}

func (dl *diskLayer) AccountRLP(hash common.Hash) ([]byte, error) {
    dl.lock.RLock()
    defer dl.lock.RUnlock()

    // If the layer was flattened into, consider it invalid (any live reference to
    // the original should be marked as unusable).
    if dl.stale {
        return nil, ErrSnapshotStale
    }
    // If the layer is being generated, ensure the requested hash has already been
    // covered by the generator.
    if dl.genMarker != nil && bytes.Compare(hash[:], dl.genMarker) > 0 {
        return nil, ErrNotCoveredYet
    }
    // If we're in the disk layer, all diff layers missed
    snapshotDirtyAccountMissMeter.Mark(1)

    // Try to retrieve the account from the memory cache
        //从缓存中读
    if blob, found := dl.cache.HasGet(nil, hash[:]); found {
        snapshotCleanAccountHitMeter.Mark(1)
        snapshotCleanAccountReadMeter.Mark(int64(len(blob)))
        return blob, nil
    }
    // Cache doesn't contain account, pull from disk and cache for later
        //从硬盘中读
    blob := rawdb.ReadAccountSnapshot(dl.diskdb, hash)
    dl.cache.Set(hash[:], blob)

    snapshotCleanAccountMissMeter.Mark(1)
    if n := len(blob); n > 0 {
        snapshotCleanAccountWriteMeter.Mark(int64(n))
    } else {
        snapshotCleanAccountInexMeter.Mark(1)
    }
    return blob, nil
}

总结

get balance和传统项目的思路差不多，一层层读缓存，最终读数据库，然后再保存缓存，返回前端

1. getBalance要先获取最新区块的root（stateRoot）来换stateDB

2. 然后从stateDB的stateObject中获取

3. 没有的话好像从snap中获取

   1. 先读缓存

   2. 再读levelDB

   3. 命中的话缓存至快照

4. 没有的话再从trie中获取

5. 命中则缓存至stateObject

6. 返回前端

从上面了解到stateDB这个东西很重要，所有的操作都是围绕他来完成的。stateDB又是靠BlockChain里的数据来创建的

1. 最新区块的state root

2. snaps

3. stateCache

这样就有了个大致的影响，然后通过后面的内容，更加深入的了解eth的架构

业务梳理

1. 固定305APE价格售卖

2. 售卖分为kyc pre-mint(Contributor才行，应该就是白名单吧)、公售（大家抢）、持有无聊猿和变异猿的人可以再mint

3. 5.1买的是盲盒，5.2拆盒

operator也是操作了这些事情，业务理解应该没太大问题

代码注释

删掉了一些业务无关、重复、无需理解的代码

代码还算简单，只有通过随机数将土地和nft721的metadata关联起来有点疑问

通过链上操作可以知道tokenurl是在土拍前就设置了，并且再也没有改过，所以不是其他项目那样卖完后通过改url拆盒

项目方也上传了metadatahashes，所以所有nft metadata是事先就准备好了的

链上的随机数并没有参与链上业务的处理，比如通过随机数+tokenid获取metadata url

既然链上的方法都没有使用，那么这个关联操作应该是放在了链下，

api.otherside.xyz/lands/27893 访问这个地址后，通过他们未开源的算法，将27893+随机数指向了metaurl。但是这样是不是就能够通过修改算法，改变用户的nft了。。。。。。。这点没有想明白，如果有好心人愿意指导下我，可以zn978740431@gmail.com给我发邮件。

网上找到两个还算靠谱的实现文章，看起来都是在链上完成这个操作的，搞不明白ape是怎么想的。因为很多nft项目方在这上面做手脚，还是很想理解透这个事情。

https://vocus.cc/article/6212f73ffd89780001687585

https://zombit.info/write-to-the-nft-project/

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

contract Land  {
using SafeERC20 for IERC20;
// attributes
string private baseURI;

address public operator;
//公售开关
bool public publicSaleActive;
//公售时间
uint256 public publicSaleStartTime;
//荷兰拍用的
uint256 public publicSalePriceLoweringDuration;
uint256 public publicSaleStartPrice;
uint256 public publicSaleEndingPrice;
//荷兰拍用的

//记录当前的土地数量
uint256 public currentNumLandsMintedPublicSale;
//当前mint tokenId
uint256 public mintIndexPublicSaleAndContributors;
//ape地址，用于交钱
address public tokenContract;
//是否需要验证kyc
bool private isKycCheckRequired;
//验证kyc的hash root， Merkle tree验证
bytes32 public kycMerkleRoot;

//每次最大可以mint的上限
uint256 public maxMintPerTx;
//每个地址总共mint的上限
uint256 public maxMintPerAddress;
//每个地址mint的数量
mapping(address => uint256) public mintedPerAddress;
//无聊猿和变异猿是否可以额外mint
bool public claimableActive; 
bool public adminClaimStarted;

//无聊猿mint的信息
address public alphaContract; 
mapping(uint256 => bool) public alphaClaimed;
uint256 public alphaClaimedAmount;
//变异mint的信息
address public betaContract; 
mapping(uint256 => bool) public betaClaimed;
uint256 public betaClaimedAmount;
uint256 public betaNftIdCurrent;

//贡献者mint的信息
bool public contributorsClaimActive;
mapping(address => uint256) public contributors;
uint256 public futureLandsNftIdCurrent;

//未来还可以再mint
address public futureMinter;

//保证官方没有作弊，用于所有人拿这里面的数据进行验证
Metadata[] public metadataHashes;
//随机数seed, 线上结果       0xaa77729d3466ca35ae8d28b3bbac7cc36a5031efdc430821c02bc31a238af445
bytes32 public keyHash;
//请求随机数的费用
uint256 public fee;
//下面三个获得的随机数然后计算出来的偏移量 线上结果 35117
uint256 public publicSaleAndContributorsOffset;
//线上结果 5491
uint256 public alphaOffset;
//线上结果 15491
uint256 public betaOffset;
//是否请求过随机数
mapping(bytes32 => bool) public isRandomRequestForPublicSaleAndContributors;
bool public publicSaleAndContributorsRandomnessRequested;
bool public ownerClaimRandomnessRequested;

// constants
uint256 immutable public MAX_LANDS;
uint256 immutable public MAX_LANDS_WITH_FUTURE;
uint256 immutable public MAX_ALPHA_NFT_AMOUNT;
uint256 immutable public MAX_BETA_NFT_AMOUNT;
uint256 immutable public MAX_PUBLIC_SALE_AMOUNT;
uint256 immutable public RESERVED_CONTRIBUTORS_AMOUNT;
uint256 immutable public MAX_FUTURE_LANDS;
uint256 constant public MAX_MINT_PER_BLOCK = 150;

// structs
struct LandAmount {
    uint256 alpha;
    uint256 beta;
    uint256 publicSale;
    uint256 future;
}
struct ContributorAmount {
    address contributor;
    uint256 amount;
}

struct Metadata {
    bytes32 metadataHash;
    bytes32 shuffledArrayHash;
    uint256 startIndex;
    uint256 endIndex;
}

struct ContractAddresses {
    address alphaContract;
    address betaContract;
    address tokenContract;
}

// modifiers
。。。。。。。。。。

// events
。。。。。。。。。。

constructor(string memory name, string memory symbol,
    ContractAddresses memory addresses,
    LandAmount memory amount,
    ContributorAmount[] memory _contributors,
    address _vrfCoordinator, address _linkTokenAddress,
    bytes32 _vrfKeyHash, uint256 _vrfFee,
    address _operator
) ERC721(name, symbol) VRFConsumerBase(_vrfCoordinator, _linkTokenAddress) {
    //无聊猿和变异猿的地址，持有这个的能够mint（具体的业务忘记了）
    alphaContract = addresses.alphaContract;
    betaContract = addresses.betaContract;
    tokenContract = addresses.tokenContract;

    MAX_ALPHA_NFT_AMOUNT = amount.alpha;
    MAX_BETA_NFT_AMOUNT = amount.beta;
    MAX_PUBLIC_SALE_AMOUNT = amount.publicSale;
    MAX_FUTURE_LANDS = amount.future;

    betaNftIdCurrent = amount.alpha; //beta starts after alpha
    mintIndexPublicSaleAndContributors = amount.alpha + amount.beta; //public sale starts after beta

    //贡献者mint数量
    uint256 tempSum;
    for(uint256 i; i<_contributors.length; ++i){
        contributors[_contributors[i].contributor] = _contributors[i].amount;
        tempSum += _contributors[i].amount;
    }
    RESERVED_CONTRIBUTORS_AMOUNT = tempSum;
    //总数量
    MAX_LANDS = amount.alpha + amount.beta + amount.publicSale + RESERVED_CONTRIBUTORS_AMOUNT;
    //以后还可以mint的数量
    MAX_LANDS_WITH_FUTURE = MAX_LANDS + amount.future;
    futureLandsNftIdCurrent = MAX_LANDS; //future starts after public sale
    //用于随机数请求
    keyHash  = _vrfKeyHash;
    fee = _vrfFee;
    //操作者地址
    operator = _operator;
}

//一些set函数
。。。。。。。。。。

// Public Sale Methods
//公售
function startPublicSale(
    uint256 _publicSalePriceLoweringDuration, 
    uint256 _publicSaleStartPrice, 
    uint256 _publicSaleEndingPrice,
    uint256 _maxMintPerTx,
    uint256 _maxMintPerAddress,
    bool _isKycCheckRequired
) external onlyOperator {
    require(!publicSaleActive, "Public sale has already begun");
    //不用管，荷兰拍取消了
    publicSalePriceLoweringDuration = _publicSalePriceLoweringDuration;
    publicSaleStartPrice = _publicSaleStartPrice;
    publicSaleEndingPrice = _publicSaleEndingPrice;
    publicSaleStartTime = block.timestamp;
    publicSaleActive = true;
    //每次，每个地址的mint限制
    maxMintPerTx = _maxMintPerTx;
    maxMintPerAddress = _maxMintPerAddress;

    isKycCheckRequired = _isKycCheckRequired;

    emit LandPublicSaleStart(publicSalePriceLoweringDuration, publicSaleStartTime);
}

//停止公售
function stopPublicSale() external onlyOperator whenPublicSaleActive {
    emit LandPublicSaleStop(getMintPrice(), getElapsedSaleTime());
    publicSaleActive = false;
}
//本来是荷兰拍的，取消了，改成固定价格
function getElapsedSaleTime() private view returns (uint256) {
    return publicSaleStartTime > 0 ? block.timestamp - publicSaleStartTime : 0;
}

function getMintPrice() public view whenPublicSaleActive returns (uint256) {
    uint256 elapsed = getElapsedSaleTime();
    uint256 price;

    if(elapsed < publicSalePriceLoweringDuration) {
        // Linear decreasing function
        price =
            publicSaleStartPrice -
                ( ( publicSaleStartPrice - publicSaleEndingPrice ) * elapsed ) / publicSalePriceLoweringDuration ;
    } else {
        price = publicSaleEndingPrice;
    }

    return price;
}

//mint land
function mintLands(uint256 numLands, bytes32[] calldata merkleProof) external whenPublicSaleActive nonReentrant {
    //最少一块土地
    require(numLands > 0, "Must mint at least one beta");
    //mint的土地有没有超过最大限制
    require(currentNumLandsMintedPublicSale + numLands <= MAX_PUBLIC_SALE_AMOUNT, "Minting would exceed max supply");
    //每次mint限制
    require(numLands <= maxMintPerTx, "numLands should not exceed maxMintPerTx");
    //每个人的mint限制
    require(numLands + mintedPerAddress[msg.sender] <= maxMintPerAddress, "sender address cannot mint more than maxMintPerAddress lands");
    //是否需要kyc验证，贡献者需要，公售的不要
    if(isKycCheckRequired) {
        require(MerkleProof.verify(merkleProof, kycMerkleRoot, keccak256(abi.encodePacked(msg.sender))), "Sender address is not in KYC allowlist");
    } else {
        //不允许合约等间接调用，老老实实正常操作
        require(msg.sender == tx.origin, "Minting from smart contracts is disallowed");
    }
 
    //获得土地价格
    uint256 mintPrice = getMintPrice();
    //交钱
    IERC20(tokenContract).safeTransferFrom(msg.sender, address(this), mintPrice * numLands);
    //记录当前的土地数量
    currentNumLandsMintedPublicSale += numLands;
    //记录每个用户的的土地数量
    mintedPerAddress[msg.sender] += numLands;
    emit PublicSaleMint(msg.sender, numLands, mintPrice);
    //mint land
    mintLandsCommon(numLands, msg.sender);
}
//调用erc721 mint
function mintLandsCommon(uint256 numLands, address recipient) private {
    for (uint256 i; i < numLands; ++i) {
        _safeMint(recipient, mintIndexPublicSaleAndContributors++);
    }
}
//赚钱喽，取钱
function withdraw() external onlyOwner {
    uint256 balance = address(this).balance;
    if(balance > 0){
        Address.sendValue(payable(owner()), balance);
    }

    balance = IERC20(tokenContract).balanceOf(address(this));
    if(balance > 0){
        IERC20(tokenContract).safeTransfer(owner(), balance);
    }
}

// Alpha/Beta Claim Methods
//无聊猿和变异猿持有者是否可以再mint
function flipClaimableState() external onlyOperator {
    claimableActive = !claimableActive;
    emit ClaimableStateChanged(claimableActive);
}

//无聊猿和变异猿持有者再mint
function nftOwnerClaimLand(uint256[] calldata alphaTokenIds, uint256[] calldata betaTokenIds) external whenClaimableActive {
    require(alphaTokenIds.length > 0 || betaTokenIds.length > 0, "Should claim at least one land");
    require(alphaTokenIds.length + betaTokenIds.length <= MAX_MINT_PER_BLOCK, "Input length should be <= MAX_MINT_PER_BLOCK");
    //无聊猿持有者mint
    alphaClaimLand(alphaTokenIds);
    //变异猿持有者mint
    betaClaimLand(betaTokenIds);
}

function alphaClaimLand(uint256[] calldata alphaTokenIds) private {
    for(uint256 i; i < alphaTokenIds.length; ++i){
        uint256 alphaTokenId = alphaTokenIds[i];
        require(!alphaClaimed[alphaTokenId], "ALPHA NFT already claimed");
        require(ERC721(alphaContract).ownerOf(alphaTokenId) == msg.sender, "Must own all of the alpha defined by alphaTokenIds");
        
        alphaClaimLandByTokenId(alphaTokenId);    
    }
}

function alphaClaimLandByTokenId(uint256 alphaTokenId) private {
    alphaClaimed[alphaTokenId] = true;
    ++alphaClaimedAmount;        
    _safeMint(msg.sender, alphaTokenId);
}


// Contributors Claim Methods
//开始贡献者mint
function startContributorsClaimPeriod() onlyOperator external {
    require(!contributorsClaimActive, "Contributors claim is already active");
    contributorsClaimActive = true;
    emit ContributorsClaimStart(block.timestamp);
}
//结束贡献者mint
function stopContributorsClaimPeriod() onlyOperator external whenContributorsClaimActive {
    contributorsClaimActive = false;
    emit ContributorsClaimStop(block.timestamp);
}

function contributorsClaimLand(uint256 amount, address recipient) external onlyContributors(msg.sender) whenContributorsClaimActive {
    require(amount > 0, "Must mint at least one land");
    require(amount <= MAX_MINT_PER_BLOCK, "amount should not exceed MAX_MINT_PER_BLOCK");
    require(amount <= contributors[msg.sender], "Contributor cannot claim other lands");

    contributors[msg.sender] -= amount;
    mintLandsCommon(amount, recipient);
}
//应该是把没卖完的土地mint掉，但是不可能出现这种事情的吧。。。。留个后手总归好的
function claimUnclaimedAndUnsoldLands(address recipient) external onlyOwner {
    claimUnclaimedAndUnsoldLandsWithAmount(recipient, MAX_MINT_PER_BLOCK);
}
。。。。。。。。。

// metadata
//用于给别人验证，保证我的土拍是没有作弊的
function loadLandMetadata(Metadata memory _landMetadata)
    external onlyOperator checkMetadataRange(_landMetadata)
    checkFirstMetadataRange(metadataHashes.length, _landMetadata.startIndex, _landMetadata.endIndex)
{
    metadataHashes.push(_landMetadata);
} 

function putLandMetadataAtIndex(uint256 index, Metadata memory _landMetadata)
    external onlyOperator checkMetadataRange(_landMetadata)
    checkFirstMetadataRange(index, _landMetadata.startIndex, _landMetadata.endIndex)
{
    metadataHashes[index] = _landMetadata;
}     

// randomness
//用link vrf生成随机数，这个随机数给公售和贡献者用
function requestRandomnessForPublicSaleAndContributors() external onlyOperator returns (bytes32 requestId) {
    require(!publicSaleAndContributorsRandomnessRequested, "Public Sale And Contributors Offset already requested");
    publicSaleAndContributorsRandomnessRequested = true;
    requestId = requestRandomnessPrivate();
    isRandomRequestForPublicSaleAndContributors[requestId] = true;
}

//用link vrf生成随机数，这个随机数给猿持有者用
function requestRandomnessForOwnerClaim() external onlyOperator returns (bytes32 requestId) {
    require(!ownerClaimRandomnessRequested, "Owner Claim Offset already requested");
    ownerClaimRandomnessRequested = true;
    requestId = requestRandomnessPrivate();
    isRandomRequestForPublicSaleAndContributors[requestId] = false;
}

function requestRandomnessPrivate() private returns (bytes32 requestId) {
    require(
        LINK.balanceOf(address(this)) >= fee,
        "Not enough LINK"
    );
    return requestRandomness(keyHash, fee);
}
//link会把产生的随机数回调这个函数，然后项目方进行业务处理，这里猜测应该是概率不同，我持有nft，那拿到好土地的概率会更大
function fulfillRandomness(bytes32 requestId, uint256 randomness) internal override {
    //区分是公售、贡献者还是猿持有者随机数
    if(isRandomRequestForPublicSaleAndContributors[requestId]){
        publicSaleAndContributorsOffset = (randomness % (MAX_PUBLIC_SALE_AMOUNT + RESERVED_CONTRIBUTORS_AMOUNT));
        emit StartingIndexSetPublicSale(publicSaleAndContributorsOffset);
    } else {
        alphaOffset = (randomness % MAX_ALPHA_NFT_AMOUNT);
        betaOffset = (randomness % MAX_BETA_NFT_AMOUNT);
        emit StartingIndexSetAlphaBeta(alphaOffset, betaOffset);
    }
}

统计完之后感觉极度不准

1. 空函数, 21186 gas

   // SPDX-License-Identifier: MIT
   pragma solidity ^0.8.0;
   contract TestMap{
       function set1()  external {}
   }
   

2. 加变量

   一个变量，408 gas
   function set1(uint8 a)  external {}
   两个变量，721 gas
   一个bytes[] memory 2196 gas
   一个bytes[] calldata 1030 gas
   一个uint[] calldata 750 gas
   

3. 函数内部执行操作

   function set1() pure external {
           uint a=1+1;//13 gas
       }
   换成uint a=10324132421421424+143214214;gas费用相同
   
   //赋值storage，22114 gas
   uint a;
       function set1() external {
           a=10324132421421424;
       }
   //在增加个address成员地址 22167 gas
   
   //storage变量的计算，2307 gas
   uint a=1;
       function set1() view external {
           uint c=a+1;
       }
   

4. 操作map

   22192 gas
   mapping(uint=> uint) public resultMap;
       function set1() external {
           resultMap[1]=2;
       }
   

5. 转账eth

   transfer/call 9380 gas 不是说好的固定2300么
   function set1(address to) payable external {
           payable(to).transfer(msg.value);
   }
   call 9586 gas
   

6. 调用别的contract的函数 4493 gas

7. keccak256+abi.encode 863 gas 根据内容多少gas变化

solidity本身的坑

可能因不了解solidity的某些机制而导致的bug

1. 重入

这个老生常谈了，加锁，在重要步骤（如转账）前先修改状态

2.计算溢出

这个说是已经修复了，但还是老老实实用safeMath吧

3.call()和delegatecall()

call() 切换上下文,我->合约1->合约2,msg.sender的结果是合约1

delegatecall() 保持上下文,我->合约1->合约2,msg.sender的结果是合约我

4.随机数

区块链理论上无法产生随机数，要用的话用link提供的随机数

5.call返回值

首先不要用transfer和send，因为这两个函数本来就是为了解决重入问题的，不完美。

call有个问题，失败的话不会报错，返回个false，所以一定要检查返回值

6.时间戳

旷工可以改时间，导致bug。要求很高的话可以用block来确定，BAT币就是用的startBlock和endBlock来确定时间的。要求不怎么高的话可以用时间戳

7.浮点数和精度

如果a/b<1,会变成0，所以最好先变成高精度数字再计算

8.for循环

solidity能不for就千万不要for，能for也尽量不要for，总之就是不要for。solidity的for就像这句话一样又长又臭。首先太贵，贵到最后可能导致超过gas限制，合约就废了。而且效率不高

业务bug

纯属写代码的人水平问题，开发经验问题。这些bug，很可能靠工具，审计是查不出来的。多了解别人的bug，以史为镜，自我反思

1.Akutar NFT 一行代码34M

https://learnblockchain.cn/article/3946

这里讲得很详细，就是判断用错了变量。

反思：测试用例一定要覆盖全，每个逻辑在构思的时候就用小本子把可能出现的bug记录下来；写代码的过程中，再随时记录；产品，技术，测试最后再头脑风暴，查漏补缺，最后形成文档，case；还要内部code review，讲解，避免这些低级bug

2.NBA签名bug

没有验证签名是谁发过来的，并且签名有没有被用过

反思：这个bug我自己写的时候也没有注意到，还好NBA爆出来了，感恩。要注意所有的内容是否要有一次性的判断

3.APE空投漏洞

空投的要求只需要瞬时拥有NFT，而不是持有一段时间，导致可以通过闪电贷撸走

反思：这个应该是设计问题，产品没想到可以这么玩。这个就考验产品、编程、测试人员经验了。

4.opensea过期订单

有人很久前保存了签名，很久之后NFT涨价了，就把签名直接传到合约里，结果NFT被低价买走。合约没有校验签名的过期时间

反思：设计问题，和ape正好相反，看来合约开发的思维要比传统项目多一个时间维度。要思考在很短或者很长的时间里合约是否安全。

5.Sandbox burn他人土地

burn的函数可见性是external而不是internal

反思：每个关键字都要酌情考虑

https://www.bilibili.com/video/BV1LS4y1U72n/?spm_id_from=333.788

稍微总结下

1. java转过去的感觉很亲切，无脑写业务就行（internal-→logic）里面写就行了，别的地方几乎不用管，框架还贴心的写了todo

2. 生成工具很全,一个生成router这样的业务代码，一个生成model层代码，很java

   1. goctl model mysql ddl -src="sql路径" -dir="."

   2. goctl api go -api temp/nft.api -dir .

3. 可以自己写sql，舒服，ORM怎么用都不习惯

4. 单体应用转微服务方便，代价很小

使用时注意点

1. 自动生成的代码不要动，顶部也会提示，不然下次再自动生成会冲掉，业务逻辑则不会冲掉，可以放心自动生成代码

2. model层的后续加业务则没法自动生成，可以记录下哪里是自己写的代码，方便后面重新生成

3. api文件要分模块的话，service名字要一样，这个点稀奇古怪的。

4. mysql创建表时最好勾上not null，不然model层会出现sql.NullString类型，有点不舒服

5. time相关的会忽略，自己看情况维护

async walletSignMessage(message) {
    const signer = await window.ethProvider.getSigner();
    const result = await signer.signMessage(message);
    return result;
  }

2.go后端验证

func VerifySig(address, signature, msg string) bool {
   bytes := []byte(msg)
   fromAddr := common.HexToAddress(address)
   sig := hexutil.MustDecode(signature)
   if sig[64] != 27 && sig[64] != 28 {
      return false
   }
   sig[64] -= 27
   pubKey, err := crypto.SigToPub(signHash(bytes), sig)
   if err != nil {
      return false
   }
   recoveredAddr := crypto.PubkeyToAddress(*pubKey)
   fmt.Println(recoveredAddr)
   result := fromAddr == recoveredAddr
   return result
}

func signHash(data []byte) []byte {
    msg := fmt.Sprintf("\x19Ethereum Signed Message:\n%d%s", len(data), data)
    return crypto.Keccak256([]byte(msg))
}

为了提高安全性，还可以在前端生成时加入salt，时间戳之类的限制

merkle tree原理

用leaves一层又一层计算出root hash，验证时拿leaf+和该leaf有关的leaf再计算一遍root hash是否一样

具体说明看这里，肯定能懂

https://www.npmjs.com/package/merkletreejs

步骤：

1.生成root hash

const { MerkleTree } = require("merkletreejs");
const keccak256 = require("keccak256");
//获取hash root
const leaves = ["地址1","地址2".....].map((x) => keccak256(x));
const tree = new MerkleTree(leaves, keccak256);
const root = tree.getHexRoot();

//获取leaf验证的路径
const leaf = keccak256("a");
const proof = tree.getProof(leaf);

2.solidity校验，airdorp

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

import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "hardhat/console.sol";
contract TestMPT is Ownable {
    //记录root hash
    bytes32 public saleMerkleRoot;
    //是否领取过空投
    mapping(address => bool) public claimed;
    //设置root hash
    function setSaleMerkleRoot(bytes32 merkleRoot) external onlyOwner {
        saleMerkleRoot = merkleRoot;
    }
    //获取root hash
    function getSaleMerkleRoot() external view returns(bytes32) {
        return saleMerkleRoot;
    }
    
    //校验是否合法
    modifier isValidMerkleProof(bytes32[] calldata merkleProof, bytes32 root,bytes memory leaf) {
        require(
            MerkleProof.verify(
                merkleProof,
                root,
                keccak256(abi.encodePacked(leaf))
            ),
            "Address does not exist in list"
        );
        _;
    }
    //获取airdrop
    function getDrop(bytes32[] calldata merkleProof,bytes memory leaf,uint256 _amount)
        external
        isValidMerkleProof(merkleProof, saleMerkleRoot,leaf)
    {
        require(!claimed[msg.sender], "Address already claimed");
        claimed[msg.sender] = true;
        //todo 业务处理
    }
}

3.etherjs调用airdrop合约

const { ethers, artifacts, network } = require("hardhat");
const { writeAbiAddr } = require("./artifact_saver.js");

async function main() {

  const contactName = "TestMPT";
  const Greeter = await ethers.getContractFactory(contactName);
  const greeter = await Greeter.deploy();
  await greeter.deployed();

  // 将abi address等信息保存到文件
  const artifact = await artifacts.readArtifact(contactName);
  await writeAbiAddr(artifact, greeter.address, contactName, network.name);

  //设置root hash
  const [owner] = await ethers.getSigners();
  const counter = await ethers.getContractAt(
    contactName,
    greeter.address,
    owner
  );
  await counter.setSaleMerkleRoot(   "0xc7ec7ffb250de2b95a1c690751b2826ec9d2999dd9f5c6f8816655b1590ca544"
  );
  const merkleRoot = await counter.getSaleMerkleRoot();
//数组里的是获取leaf的验证路径，第二个参数是要验证的内容
//特殊情况，你只有一个leaf，那要传空数组
  const result = await counter.getDrop(
    [
      "0x1575cc1dded49f942913392f94716824d29b8fa45876b2db6295d16a606533a4",
      "0x6c42c6099e51e28eef8f19f71765bb42c571d5c7177996f177606138f65c0c2b",
      "0xb0d6f760008340e3f60414d84b305702faa6418f44f31de07b10e05bf369eb3b",
      "0x4c880bf401add28c4e51270dfe16b28c3ca1b3d263ff7c5863fc8214b4046364",
    ],
    "0xc12ae5Ba30Da6eB11978939379D383beb5Df9b33"
  );
}

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

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/ECDSA.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/draft-EIP712.sol";

contract MyContract is EIP712 {
       
    constructor(string memory name, string memory version) EIP712(name, version) {}
    
     //生成签名的业务参数和生成的签名
    function recoverV4(
        address from,
        address to,
        uint256 value,
        bytes memory signature
    ) public view returns (address) {
        bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
        //需要和js中的type中业务的数据格式对应
        keccak256("Mail(address from,address to,uint256 value)"),
           from,
            to,
            value
        )));
        return ECDSA.recover(digest, signature);
    }
}

合约架构

https://etherscan.io/accounts/label/looksrare

三家的合约高度相似，只不过是将代码重构的好看一些。再加些最近才有的EIP。looksare基本上是把能拆的都拆了，比如手续费、版权（EIP2981）、transfer，对比下另外两家，舒服很多

业务逻辑

1. 基本都是链下操作，只有在真正mint nft，撮合交易成功，取消交易才会上链。甚至现在mint nft都不上链，第一次transfer时才会mint nft。进一步减少gas消耗。

2. 创建订单：使用订单参数+salt进行EIP712 signature，transfer时在合约中验证签名，这样能减少Gas和保证订单没问题。。。。。才怪，open就出了有人拿到signature后，等订单过期了再去调用合约，把人家的nft低价撸走的bug。

3. 取消订单：链上不保存创建订单。就像上面说的，防止bug出现，就要链上保存取消的订单，但是opensea没有判断 currentTime>expireTime 所以拿过期的signature还是可以完成交易

4. 取消所有订单，减少gas，理论上也不是取消所有，一次的上限是500000

5. 版权费：使用EIP2981，原因是像opensea，有版权费上限，如果我要收100%的版权费，没辙，所以要一个链上保存版权费的功能

代码结构

1. 共两个cancelOrder

2. 三个撮合函数

3. 好几个update周边合约函数

4. 两个transfer token函数

5. 一个transfer nft函数

6. 一个校验函数

//取消订单
cancelAllOrdersForSender
cancelMultipleMakerOrders
//撮合函数
//卖家挂单
matchAskWithTakerBidUsingETHAndWETH
matchAskWithTakerBid
//买家询价
matchBidWithTakerAsk
//转钱
_transferFeesAndFunds
_transferFeesAndFundsWithWETH
//转nft
_transferNonFungibleToken
//校验订单
_validateOrder

从上面函数名可以看出，好几个都是相似的内容，所以合约还是比较容易看懂的

Exchange合约注释

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

// OpenZeppelin contracts
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

// LooksRare interfaces
import {ICurrencyManager} from "./interfaces/ICurrencyManager.sol";
import {IExecutionManager} from "./interfaces/IExecutionManager.sol";
import {IExecutionStrategy} from "./interfaces/IExecutionStrategy.sol";
import {IRoyaltyFeeManager} from "./interfaces/IRoyaltyFeeManager.sol";
import {ILooksRareExchange} from "./interfaces/ILooksRareExchange.sol";
import {ITransferManagerNFT} from "./interfaces/ITransferManagerNFT.sol";
import {ITransferSelectorNFT} from "./interfaces/ITransferSelectorNFT.sol";
import {IWETH} from "./interfaces/IWETH.sol";

// LooksRare libraries
import {OrderTypes} from "./libraries/OrderTypes.sol";
import {SignatureChecker} from "./libraries/SignatureChecker.sol";


contract LooksRareExchange is ILooksRareExchange, ReentrancyGuard, Ownable {
    using SafeERC20 for IERC20;
    //订单的卖家和买家信息
    using OrderTypes for OrderTypes.MakerOrder;
    using OrderTypes for OrderTypes.TakerOrder;
    //weth的地址
    address public immutable WETH;
    、、EIP712的信息
    bytes32 public immutable DOMAIN_SEPARATOR;
    //手续费地址
    address public protocolFeeRecipient;
    //looksrare的周边合约地址
    ICurrencyManager public currencyManager;
    IExecutionManager public executionManager;
    IRoyaltyFeeManager public royaltyFeeManager;
    ITransferSelectorNFT public transferSelectorNFT;
    //用于取消订单和校验订单是否合法的逻辑
    mapping(address => uint256) public userMinOrderNonce;
    mapping(address => mapping(uint256 => bool)) private _isUserOrderNonceExecutedOrCancelled;

    event CancelAllOrders(address indexed user, uint256 newMinNonce);
    event CancelMultipleOrders(address indexed user, uint256[] orderNonces);
    event NewCurrencyManager(address indexed currencyManager);
    event NewExecutionManager(address indexed executionManager);
    event NewProtocolFeeRecipient(address indexed protocolFeeRecipient);
    event NewRoyaltyFeeManager(address indexed royaltyFeeManager);
    event NewTransferSelectorNFT(address indexed transferSelectorNFT);

    event RoyaltyPayment(
        address indexed collection,
        uint256 indexed tokenId,
        address indexed royaltyRecipient,
        address currency,
        uint256 amount
    );

    event TakerAsk(
        bytes32 orderHash, // bid hash of the maker order
        uint256 orderNonce, // user order nonce
        address indexed taker, // sender address for the taker ask order
        address indexed maker, // maker address of the initial bid order
        address indexed strategy, // strategy that defines the execution
        address currency, // currency address
        address collection, // collection address
        uint256 tokenId, // tokenId transferred
        uint256 amount, // amount of tokens transferred
        uint256 price // final transacted price
    );

    event TakerBid(
        bytes32 orderHash, // ask hash of the maker order
        uint256 orderNonce, // user order nonce
        address indexed taker, // sender address for the taker bid order
        address indexed maker, // maker address of the initial ask order
        address indexed strategy, // strategy that defines the execution
        address currency, // currency address
        address collection, // collection address
        uint256 tokenId, // tokenId transferred
        uint256 amount, // amount of tokens transferred
        uint256 price // final transacted price
    );

    /**
     * @notice Constructor 保存好签名校验需要的参数，保存周边合约的地址
     * @param _currencyManager currency manager address
     * @param _executionManager execution manager address
     * @param _royaltyFeeManager royalty fee manager address
     * @param _WETH wrapped ether address (for other chains, use wrapped native asset)
     * @param _protocolFeeRecipient protocol fee recipient
     */
    constructor(
        address _currencyManager,
        address _executionManager,
        address _royaltyFeeManager,
        address _WETH,
        address _protocolFeeRecipient
    ) {
        // Calculate the domain separator
        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f, // keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
                0xda9101ba92939daf4bb2e18cd5f942363b9297fbc3232c9dd964abb1fb70ed71, // keccak256("LooksRareExchange")
                0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6, // keccak256(bytes("1")) for versionId = 1
                block.chainid,
                address(this)
            )
        );

        currencyManager = ICurrencyManager(_currencyManager);
        executionManager = IExecutionManager(_executionManager);
        royaltyFeeManager = IRoyaltyFeeManager(_royaltyFeeManager);
        WETH = _WETH;
        protocolFeeRecipient = _protocolFeeRecipient;
    }

    /**
     * @notice Cancel all pending orders for a sender
        取消所有订单
     * @param minNonce minimum user nonce
     */
    function cancelAllOrdersForSender(uint256 minNonce) external {
        require(minNonce > userMinOrderNonce[msg.sender], "Cancel: Order nonce lower than current");
        require(minNonce < userMinOrderNonce[msg.sender] + 500000, "Cancel: Cannot cancel more orders");
        userMinOrderNonce[msg.sender] = minNonce;

        emit CancelAllOrders(msg.sender, minNonce);
    }

    /**
     * @notice Cancel maker orders
      根据需要取消订单
     * @param orderNonces array of order nonces
     */
    function cancelMultipleMakerOrders(uint256[] calldata orderNonces) external {
        require(orderNonces.length > 0, "Cancel: Cannot be empty");

        for (uint256 i = 0; i < orderNonces.length; i++) {
            require(orderNonces[i] >= userMinOrderNonce[msg.sender], "Cancel: Order nonce lower than current");
            _isUserOrderNonceExecutedOrCancelled[msg.sender][orderNonces[i]] = true;
        }

        emit CancelMultipleOrders(msg.sender, orderNonces);
    }

    /**
     * @notice Match ask with a taker bid order using ETH
        核心exchange业务逻辑并且eth和weth混合支付，可能你的weth不足，不要紧，再用点eth，这里面会将eth换成weth，就不用你先去兑换了，节省gas
     * @param takerBid taker bid order
     * @param makerAsk maker ask order
     */
    function matchAskWithTakerBidUsingETHAndWETH(
        OrderTypes.TakerOrder calldata takerBid,
        OrderTypes.MakerOrder calldata makerAsk
    ) external payable override nonReentrant {
     //确定是卖家挂单才行，因为买家询价是不能用eth支付的
        require((makerAsk.isOrderAsk) && (!takerBid.isOrderAsk), "Order: Wrong sides");
        require(makerAsk.currency == WETH, "Order: Currency must be WETH");
        require(msg.sender == takerBid.taker, "Order: Taker must be the sender");
    //eth不足，先将weth转移给卖家
        // If not enough ETH to cover the price, use WETH
        if (takerBid.price > msg.value) {
            IERC20(WETH).safeTransferFrom(msg.sender, address(this), (takerBid.price - msg.value));
        } else {
            require(takerBid.price == msg.value, "Order: Msg.value too high");
        }
        //将eth兑换成weth来交易
        // Wrap ETH sent to this contract
        IWETH(WETH).deposit{value: msg.value}();
        //使用eip712校验订单
        // Check the maker ask order
        bytes32 askHash = makerAsk.hash();
        _validateOrder(makerAsk, askHash);
         //挂单，拍卖有不同的交易费费率，从这取出来
        // Retrieve execution parameters
        (bool isExecutionValid, uint256 tokenId, uint256 amount) = IExecutionStrategy(makerAsk.strategy)
            .canExecuteTakerBid(takerBid, makerAsk);

        require(isExecutionValid, "Strategy: Execution invalid");

        // Update maker ask order status to true (prevents replay)
        //先将订单置为已完成，防止重入
        _isUserOrderNonceExecutedOrCancelled[makerAsk.signer][makerAsk.nonce] = true;

        // Execution part 1/2
        //真正开始交易的地方，分两步，转移钱，再转移nft
        _transferFeesAndFundsWithWETH(
            makerAsk.strategy,
            makerAsk.collection,
            tokenId,
            makerAsk.signer,
            takerBid.price,
            makerAsk.minPercentageToAsk
        );

        // Execution part 2/2
        _transferNonFungibleToken(makerAsk.collection, makerAsk.signer, takerBid.taker, tokenId, amount);

        emit TakerBid(
            askHash,
            makerAsk.nonce,
            takerBid.taker,
            makerAsk.signer,
            makerAsk.strategy,
            makerAsk.currency,
            makerAsk.collection,
            tokenId,
            amount,
            takerBid.price
        );
    }

    /**
     * @notice Match a takerBid with a matchAsk
       基础撮合订单，和上面的区别就是这里只能用weth
     * @param takerBid taker bid order
     * @param makerAsk maker ask order
     */
    function matchAskWithTakerBid(OrderTypes.TakerOrder calldata takerBid, OrderTypes.MakerOrder calldata makerAsk)
        external
        override
        nonReentrant
    {
        require((makerAsk.isOrderAsk) && (!takerBid.isOrderAsk), "Order: Wrong sides");
        require(msg.sender == takerBid.taker, "Order: Taker must be the sender");

        // Check the maker ask order
        bytes32 askHash = makerAsk.hash();
        _validateOrder(makerAsk, askHash);

        (bool isExecutionValid, uint256 tokenId, uint256 amount) = IExecutionStrategy(makerAsk.strategy)
            .canExecuteTakerBid(takerBid, makerAsk);

        require(isExecutionValid, "Strategy: Execution invalid");

        // Update maker ask order status to true (prevents replay)
        _isUserOrderNonceExecutedOrCancelled[makerAsk.signer][makerAsk.nonce] = true;

        // Execution part 1/2
        _transferFeesAndFunds(
            makerAsk.strategy,
            makerAsk.collection,
            tokenId,
            makerAsk.currency,
            msg.sender,
            makerAsk.signer,
            takerBid.price,
            makerAsk.minPercentageToAsk
        );

        // Execution part 2/2
        _transferNonFungibleToken(makerAsk.collection, makerAsk.signer, takerBid.taker, tokenId, amount);

        emit TakerBid(
            askHash,
            makerAsk.nonce,
            takerBid.taker,
            makerAsk.signer,
            makerAsk.strategy,
            makerAsk.currency,
            makerAsk.collection,
            tokenId,
            amount,
            takerBid.price
        );
    }

    /**
     * @notice Match a takerAsk with a makerBid
        撮合订单，这里和上面一个的区别是这里是买家询价，上面是卖家挂单，这里的签名者是买家，上面的是卖家
     * @param takerAsk taker ask order
     * @param makerBid maker bid order
     */
    function matchBidWithTakerAsk(OrderTypes.TakerOrder calldata takerAsk, OrderTypes.MakerOrder calldata makerBid)
        external
        override
        nonReentrant
    {
        require((!makerBid.isOrderAsk) && (takerAsk.isOrderAsk), "Order: Wrong sides");
        require(msg.sender == takerAsk.taker, "Order: Taker must be the sender");

        // Check the maker bid order
        bytes32 bidHash = makerBid.hash();
        _validateOrder(makerBid, bidHash);

        (bool isExecutionValid, uint256 tokenId, uint256 amount) = IExecutionStrategy(makerBid.strategy)
            .canExecuteTakerAsk(takerAsk, makerBid);

        require(isExecutionValid, "Strategy: Execution invalid");

        // Update maker bid order status to true (prevents replay)
        _isUserOrderNonceExecutedOrCancelled[makerBid.signer][makerBid.nonce] = true;

        // Execution part 1/2
        _transferNonFungibleToken(makerBid.collection, msg.sender, makerBid.signer, tokenId, amount);

        // Execution part 2/2
        _transferFeesAndFunds(
            makerBid.strategy,
            makerBid.collection,
            tokenId,
            makerBid.currency,
            makerBid.signer,
            takerAsk.taker,
            takerAsk.price,
            takerAsk.minPercentageToAsk
        );

        emit TakerAsk(
            bidHash,
            makerBid.nonce,
            takerAsk.taker,
            makerBid.signer,
            makerBid.strategy,
            makerBid.currency,
            makerBid.collection,
            tokenId,
            amount,
            takerAsk.price
        );
    }
    //修改周边合约的地址，用于升级或者出bug用
    /**
     * @notice Update currency manager
     * @param _currencyManager new currency manager address
     */
    function updateCurrencyManager(address _currencyManager) external onlyOwner {
        require(_currencyManager != address(0), "Owner: Cannot be null address");
        currencyManager = ICurrencyManager(_currencyManager);
        emit NewCurrencyManager(_currencyManager);
    }

    /**
     * @notice Update execution manager
     * @param _executionManager new execution manager address
     */
    function updateExecutionManager(address _executionManager) external onlyOwner {
        require(_executionManager != address(0), "Owner: Cannot be null address");
        executionManager = IExecutionManager(_executionManager);
        emit NewExecutionManager(_executionManager);
    }

    /**
     * @notice Update protocol fee and recipient
     * @param _protocolFeeRecipient new recipient for protocol fees
     */
    function updateProtocolFeeRecipient(address _protocolFeeRecipient) external onlyOwner {
        protocolFeeRecipient = _protocolFeeRecipient;
        emit NewProtocolFeeRecipient(_protocolFeeRecipient);
    }

    /**
     * @notice Update royalty fee manager
     * @param _royaltyFeeManager new fee manager address
     */
    function updateRoyaltyFeeManager(address _royaltyFeeManager) external onlyOwner {
        require(_royaltyFeeManager != address(0), "Owner: Cannot be null address");
        royaltyFeeManager = IRoyaltyFeeManager(_royaltyFeeManager);
        emit NewRoyaltyFeeManager(_royaltyFeeManager);
    }

    /**
     * @notice Update transfer selector NFT
     * @param _transferSelectorNFT new transfer selector address
     */
    function updateTransferSelectorNFT(address _transferSelectorNFT) external onlyOwner {
        require(_transferSelectorNFT != address(0), "Owner: Cannot be null address");
        transferSelectorNFT = ITransferSelectorNFT(_transferSelectorNFT);

        emit NewTransferSelectorNFT(_transferSelectorNFT);
    }

    //订单是否取消
    /**
     * @notice Check whether user order nonce is executed or cancelled
     * @param user address of user
     * @param orderNonce nonce of the order
     */
    function isUserOrderNonceExecutedOrCancelled(address user, uint256 orderNonce) external view returns (bool) {
        return _isUserOrderNonceExecutedOrCancelled[user][orderNonce];
    }


    /**
       N个费用处理，转移钱，用传入的代币交易
     * @notice Transfer fees and funds to royalty recipient, protocol, and seller
     * @param strategy address of the execution strategy
     * @param collection non fungible token address for the transfer
     * @param tokenId tokenId
     * @param currency currency being used for the purchase (e.g., WETH/USDC)
     * @param from sender of the funds
     * @param to seller's recipient
     * @param amount amount being transferred (in currency)
     * @param minPercentageToAsk minimum percentage of the gross amount that goes to ask
     */
    function _transferFeesAndFunds(
        address strategy,
        address collection,
        uint256 tokenId,
        address currency,
        address from,
        address to,
        uint256 amount,
        uint256 minPercentageToAsk
    ) internal {
        // Initialize the final amount that is transferred to seller
        //最终的给卖家的钱，会经过一层又一层的吃拿卡要
        uint256 finalSellerAmount = amount;

        // 1. Protocol fee 官方手续费
        {
            uint256 protocolFeeAmount = _calculateProtocolFee(strategy, amount);

            // Check if the protocol fee is different than 0 for this strategy
            if ((protocolFeeRecipient != address(0)) && (protocolFeeAmount != 0)) {
                IERC20(currency).safeTransferFrom(from, protocolFeeRecipient, protocolFeeAmount);
                finalSellerAmount -= protocolFeeAmount;
            }
        }

        // 2. Royalty fee 版权费
        {
            (address royaltyFeeRecipient, uint256 royaltyFeeAmount) = royaltyFeeManager
                .calculateRoyaltyFeeAndGetRecipient(collection, tokenId, amount);

            // Check if there is a royalty fee and that it is different to 0
            if ((royaltyFeeRecipient != address(0)) && (royaltyFeeAmount != 0)) {
                IERC20(currency).safeTransferFrom(from, royaltyFeeRecipient, royaltyFeeAmount);
                finalSellerAmount -= royaltyFeeAmount;

                emit RoyaltyPayment(collection, tokenId, royaltyFeeRecipient, currency, royaltyFeeAmount);
            }
        }

        //保证给卖家的钱的最小值，要有人性，手动狗头
        require((finalSellerAmount * 10000) >= (minPercentageToAsk * amount), "Fees: Higher than expected");

        // 3. Transfer final amount (post-fees) to seller
        {
            IERC20(currency).safeTransferFrom(from, to, finalSellerAmount);
        }
    }

    /**
      和上面的类似，只是用了weth
     * @notice Transfer fees and funds to royalty recipient, protocol, and seller
     * @param strategy address of the execution strategy
     * @param collection non fungible token address for the transfer
     * @param tokenId tokenId
     * @param to seller's recipient
     * @param amount amount being transferred (in currency)
     * @param minPercentageToAsk minimum percentage of the gross amount that goes to ask
     */
    function _transferFeesAndFundsWithWETH(
        address strategy,
        address collection,
        uint256 tokenId,
        address to,
        uint256 amount,
        uint256 minPercentageToAsk
    ) internal {
        // Initialize the final amount that is transferred to seller
        uint256 finalSellerAmount = amount;

        // 1. Protocol fee
        {
            uint256 protocolFeeAmount = _calculateProtocolFee(strategy, amount);

            // Check if the protocol fee is different than 0 for this strategy
            if ((protocolFeeRecipient != address(0)) && (protocolFeeAmount != 0)) {
                IERC20(WETH).safeTransfer(protocolFeeRecipient, protocolFeeAmount);
                finalSellerAmount -= protocolFeeAmount;
            }
        }

        // 2. Royalty fee
        {
            (address royaltyFeeRecipient, uint256 royaltyFeeAmount) = royaltyFeeManager
                .calculateRoyaltyFeeAndGetRecipient(collection, tokenId, amount);

            // Check if there is a royalty fee and that it is different to 0
            if ((royaltyFeeRecipient != address(0)) && (royaltyFeeAmount != 0)) {
                IERC20(WETH).safeTransfer(royaltyFeeRecipient, royaltyFeeAmount);
                finalSellerAmount -= royaltyFeeAmount;

                emit RoyaltyPayment(collection, tokenId, royaltyFeeRecipient, address(WETH), royaltyFeeAmount);
            }
        }

        require((finalSellerAmount * 10000) >= (minPercentageToAsk * amount), "Fees: Higher than expected");

        // 3. Transfer final amount (post-fees) to seller
        {
            IERC20(WETH).safeTransfer(to, finalSellerAmount);
        }
    }

    /**
     * @notice Transfer NFT
        那到官方规定的NFT转移合约，转移NFT
     * @param collection address of the token collection
     * @param from address of the sender
     * @param to address of the recipient
     * @param tokenId tokenId
     * @param amount amount of tokens (1 for ERC721, 1+ for ERC1155)
     * @dev For ERC721, amount is not used
     */
    function _transferNonFungibleToken(
        address collection,
        address from,
        address to,
        uint256 tokenId,
        uint256 amount
    ) internal {
        // Retrieve the transfer manager address
        address transferManager = transferSelectorNFT.checkTransferManagerForToken(collection);

        // If no transfer manager found, it returns address(0)
        require(transferManager != address(0), "Transfer: No NFT transfer manager available");

        // If one is found, transfer the token
        ITransferManagerNFT(transferManager).transferNonFungibleToken(collection, from, to, tokenId, amount);
    }

    /**
     * @notice Calculate protocol fee for an execution strategy
     * @param executionStrategy strategy
     * @param amount amount to transfer
     */
    function _calculateProtocolFee(address executionStrategy, uint256 amount) internal view returns (uint256) {
        uint256 protocolFee = IExecutionStrategy(executionStrategy).viewProtocolFee();
        return (protocolFee * amount) / 10000;
    }

    /**
        校验订单
     * @notice Verify the validity of the maker order
     * @param makerOrder maker order
     * @param orderHash computed hash for the order
     */
    function _validateOrder(OrderTypes.MakerOrder calldata makerOrder, bytes32 orderHash) internal view {
        // Verify whether order nonce has expired
        require(
  //订单是否取消，并且订单的nonce>合约记录的订单签名者的nonce值，因为可能其他人恶意取消订单，这里取签名者保证别人恶意取消没用       (!_isUserOrderNonceExecutedOrCancelled[makerOrder.signer][makerOrder.nonce]) &&
                (makerOrder.nonce >= userMinOrderNonce[makerOrder.signer]),
            "Order: Matching order expired"
        );

        // Verify the signer is not address(0)
        require(makerOrder.signer != address(0), "Order: Invalid signer");

        // Verify the amount is not 0
        require(makerOrder.amount > 0, "Order: Amount cannot be 0");

        // Verify the validity of the signature
        require(
            SignatureChecker.verify(
                orderHash,
                makerOrder.signer,
                makerOrder.v,
                makerOrder.r,
                makerOrder.s,
                DOMAIN_SEPARATOR
            ),
            "Signature: Invalid"
        );

        // Verify whether the currency is whitelisted
        require(currencyManager.isCurrencyWhitelisted(makerOrder.currency), "Currency: Not whitelisted");

        // Verify whether strategy can be executed
        require(executionManager.isStrategyWhitelisted(makerOrder.strategy), "Strategy: Not whitelisted");
    }
}

1. 现在网站会提供很多种钱包，web3modal可以提供统一的provider，不需要你操心太多东西

2. 用ether.js而不是web3.js的原因是简单，爽

2.安装

npm i web3modal
npm i ethers
//另外还需要安装对应wallet的包，自行搜索就行

3.连接钱包

// MM默认就有，无需显式加入
const providerOptions = {
  walletconnect: {
    package: walletconnectProvider,
    options: {
      infuraId: "",
    },
  },
};
//构建Web3Modal对象
const web3Modal = new Web3Modal({
  //缓存provider
  cacheProvider: true,
  providerOptions,
});

//连接wallet
async function connect() {
  try {
    const web3ModalProvider = await web3Modal.connect();
    provider = new ethers.providers.Web3Provider(web3ModalProvider);
    //注册监听，比如disconnect，accountsChanged，chainChanged
    registerEthListener(web3ModalProvider);
    //主要是处理业务上的需求
    updateCurrentStatus(await provider.listAccounts());
  } catch (error) {
    console.log(error);
  }
}

4.上面的registerEthListener

//可以根据自己的需要些具体的内容
function registerEthListener(web3ModalProvider) {
  web3ModalProvider
    .on("disconnect", (error) => {
      
    })
    .on("accountsChanged", (accounts) => {
      
    })
    .on("chainChanged", (chainId) => {
      
    });
}

5.切换网络&添加网络

//你需要的network信息
const networkInfo = {
  localhardhat: {
    //这里一定要16进制，不然报错
    chainId: "0x539",
    chainName: "LOCALHARDHAT",
    nativeCurrency: {
      name: "LOCALHARDHAT",
      symbol: "LH",
      decimals: 18,
    },
    rpcUrls: ["http://192.168.50.36:8545/"],
    blockExplorerUrls: ["http://192.168.50.36:8545/"],
  },
  matic: {
    chainId: "0x89",
    chainName: "Ploygon",
    nativeCurrency: {
      name: "MATIC",
      symbol: "MATIC",
      decimals: 18,
    },
    rpcUrls: ["https://rpc-mainnet.maticvigil.com/"],
    blockExplorerUrls: ["https://polygonscan.com/"],
  },
};
//切换网络
//walletProvider是上面的web3ModalProvider，而不是ethers获取的provider
async function switchNetwork(network, walletProvider) {
  try {
    await walletProvider.request({
      method: "wallet_switchEthereumChain",
      params: [{ chainId: networkInfo[network].chainId }],
    });
  } catch (error) {
    console.log(error);
    if ((error.code = 4902)) {
      return await addNetwork(network, walletProvider);
    }
    throw error;
  }
}
//添加网络
async function addNetwork(network, walletProvider) {
  try {
    return await walletProvider.request({
      method: "wallet_addEthereumChain",
      params: [networkInfo[network]],
    });
  } catch (error) {
    console.log(error);
  }
}

6.预估Gas调用合约写方法

1. 这里要引入一个number包用于计算

npm i big-number
//引入项目
import BigNumber from "bignumber.js";

//预估gas,并且调用合约
//functionName:你要调用的方法，如safeMint
//args：调用合约的参数，array类型，例如[arg1, arg2, arg3, {}],最后的{}不能少，函数中会将计算出来的gas要放里面，如果要传入eth，则最后的{}为{value:xxx}
async function executeContractMethosWithEstimatedGas(
  functionName,
  args
) {
//合约信息,provider是连接ethers时的
  const contract=new ethers.Contract(contractAddress,contractAbi,provider);

  const estimatedGas = new BigNumber(
    ethersOf(
      await contract.estimateGasfunctionName
        .then((value) => {
          const minimumGas = ethers.BigNumber.from("300000");
          if (value.lt(minimumGas)) {
            return minimumGas;
          }
          return values;
        })
        .catch((error) => {
          //出错时给个固定值
          return ethers.BigNumber.from("700000");
        })
    )
  );
//将计算结果放入参数中
  const argsForOverridden = args.pop();
  args.gasLimit = parseEthers(estimatedGas.times(1.2).toString());
  args.push(argsForOverridden);
  return contract.connect(getSigner())functionName;
}
//以下是周边函数
function getSigner(){
  if(!provider){
    console.log("please connect awallet first");
    return;
  }
  return provider.getSigner();
}

function parseUnits(amount,unit){
  const bnAmount=new BigNumber(amount);
  try {
    return ethers.utils.parseUnits(bnAmount.toFixed(unit),unit);
  } catch (error) {
    return ethers.BigNumber.from(bnAmount.times(Math.pow(10,unit)).toFixed(0));
  }
}
const ETHER_DECIMALS=18;
function parseEthers(amount){
  return parseUnits(amount,ETHER_DECIMALS);
}

function ethersOf(amount){
  return ethers.utils.formatEther(amount);
}

7.网络确认

说明：一个写操作分为两步。1.提交执行，2.网络确认。类似uni页面操作后会有pending

//tx是上面executeContractMethosWithEstimatedGas会返回的结果
async function waitForTransaction(tx){
  //2是网络确认数量，自定义
  return await provider.waitForTransaction(tx.hash,2);
}

以上就是一些基础操作，还有个读合约，那个别的网站都有，就没贴了

签名：

https://mirror.xyz/0xE3a463d743F762D538031BAD3f1E748BB41f96ec/S1CbvnSfUIMKk1CkUr9nQDiT_YN1iHMGsL2IlJE3KGw