github.com/bigzoro/my_simplechain@v0.0.0-20240315012955-8ad0a2a29bb9/permission/service.go (about)

     1  package permission
     2  
     3  import (
     4  	"crypto/ecdsa"
     5  	"errors"
     6  	"fmt"
     7  	"math/big"
     8  	"strings"
     9  	"time"
    10  
    11  	"github.com/bigzoro/my_simplechain/accounts"
    12  	"github.com/bigzoro/my_simplechain/accounts/abi/bind"
    13  	"github.com/bigzoro/my_simplechain/accounts/keystore"
    14  	"github.com/bigzoro/my_simplechain/common"
    15  	"github.com/bigzoro/my_simplechain/consensus/raft/backend"
    16  	"github.com/bigzoro/my_simplechain/crypto"
    17  	"github.com/bigzoro/my_simplechain/eth"
    18  	"github.com/bigzoro/my_simplechain/ethclient"
    19  	"github.com/bigzoro/my_simplechain/ethdb"
    20  	"github.com/bigzoro/my_simplechain/event"
    21  	"github.com/bigzoro/my_simplechain/log"
    22  	"github.com/bigzoro/my_simplechain/node"
    23  	"github.com/bigzoro/my_simplechain/p2p"
    24  	"github.com/bigzoro/my_simplechain/p2p/enode"
    25  	"github.com/bigzoro/my_simplechain/rpc"
    26  )
    27  
    28  var (
    29  	Join     = 0
    30  	Remove   = 1
    31  	Normal   = 0 //normal node
    32  	Isolated = 1
    33  	Admin    = 2
    34  
    35  	permissionContractNotSet = errors.New("the permission contract address has not been set")
    36  )
    37  
    38  type Service struct {
    39  	node                *node.Node
    40  	ethClient           bind.ContractBackend
    41  	eth                 *eth.SimpleService
    42  	permissionContract  *Permission
    43  	storeAbiContract    *StoreAbi
    44  	RaftProtocolManager *backend.ProtocolManager
    45  
    46  	stopFeed event.Feed // broadcasting stopEvent when service is being stopped
    47  
    48  	permissionAddr common.Address
    49  	storeAbiAddr   common.Address
    50  	stop           chan struct{}
    51  	watching       bool
    52  }
    53  
    54  func (s *Service) Start(server *p2p.Server) error {
    55  	s.stop = make(chan struct{})
    56  	log.Debug("permission service: starting")
    57  	return nil
    58  }
    59  
    60  // SetContractAddress 设置权限合约地址
    61  func (s *Service) SetContractAddress(addr common.Address) (bool, error) {
    62  	if s.watching && addr != s.permissionAddr {
    63  		close(s.stop)
    64  		//更换合约地址
    65  		s.permissionAddr = addr
    66  		permission, err := NewPermission(s.permissionAddr, s.ethClient)
    67  		if err != nil {
    68  			return false, err
    69  		}
    70  		s.permissionContract = permission
    71  		s.stop = make(chan struct{})
    72  		go s.runPermissionVerifyNotify()
    73  		go s.WatchNetworkInitComplete()
    74  		time.Sleep(time.Second)
    75  	}
    76  	if !s.watching {
    77  		s.permissionAddr = addr
    78  		permission, err := NewPermission(s.permissionAddr, s.ethClient)
    79  		if err != nil {
    80  			return false, err
    81  		}
    82  		s.permissionContract = permission
    83  		s.stop = make(chan struct{})
    84  		go s.runPermissionVerifyNotify()
    85  		go s.WatchNetworkInitComplete()
    86  		time.Sleep(time.Second)
    87  	}
    88  	//将权限合约地址写入数据库中
    89  	err := storeContractAddress(permissionKey, addr, s.GetCommonDb())
    90  	if err != nil {
    91  		return false, err
    92  	}
    93  	log.Info("show syncNodeId in SetContractAddress")
    94  	s.syncNodeId()
    95  	return true, nil
    96  }
    97  func (s *Service) APIs() []rpc.API {
    98  	return []rpc.API{
    99  		{
   100  			Namespace: "permission",
   101  			Version:   "1.0",
   102  			Service:   NewQuorumControlsAPI(s),
   103  			Public:    true,
   104  		},
   105  	}
   106  }
   107  
   108  // GetPermissionContract 获取权限合约实例
   109  func (s *Service) GetPermissionContract() (*Permission, error) {
   110  	if s.permissionContract == nil && s.permissionAddr != (common.Address{}) && s.ethClient != nil {
   111  		permission, err := NewPermission(s.permissionAddr, s.ethClient)
   112  		if err != nil {
   113  			return nil, err
   114  		}
   115  		s.permissionContract = permission
   116  	}
   117  	if s.permissionContract == nil {
   118  		return nil, errors.New("no permission contract")
   119  	}
   120  	return s.permissionContract, nil
   121  }
   122  
   123  func (s *Service) Protocols() []p2p.Protocol {
   124  	return []p2p.Protocol{}
   125  }
   126  
   127  func (s *Service) Stop() error {
   128  	log.Info("permission service: stopping")
   129  	close(s.stop)
   130  	log.Info("permission service: stopped")
   131  	return nil
   132  }
   133  
   134  func NewQuorumControlsAPI(s *Service) *QuorumControlsAPI {
   135  	return &QuorumControlsAPI{s}
   136  }
   137  func NewPermissionService(stack *node.Node, ethereum *eth.SimpleService) (*Service, error) {
   138  	s := &Service{
   139  		node: stack,
   140  		eth:  ethereum,
   141  	}
   142  	return s, nil
   143  }
   144  func (s *Service) getAuth(from common.Address) (*bind.TransactOpts, error) {
   145  	privateKey, err := s.getPrivateKey(from)
   146  	if err != nil {
   147  		return nil, err
   148  	}
   149  	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, s.eth.ChainConfig().ChainID)
   150  	if err != nil {
   151  		return nil, err
   152  	}
   153  	auth.From = from
   154  	return auth, nil
   155  }
   156  
   157  func (s *Service) GetAccountManager() *accounts.Manager {
   158  	return s.eth.AccountManager()
   159  }
   160  
   161  func (s *Service) GetCommonDb() ethdb.Database {
   162  	return s.eth.CommonDb()
   163  }
   164  func (s *Service) getPrivateKey(addr common.Address) (*ecdsa.PrivateKey, error) {
   165  	account := accounts.Account{Address: addr}
   166  	am := s.GetAccountManager()
   167  	keyStore, err := fetchKeystore(am, account)
   168  	if err != nil {
   169  		return nil, err
   170  	}
   171  	privateKey, err := keyStore.GetPrivateKey(account)
   172  	if err != nil {
   173  		return nil, err
   174  	}
   175  	return privateKey, nil
   176  }
   177  func (s *Service) getPublicKey(addr common.Address) (string, error) {
   178  	account := accounts.Account{Address: addr}
   179  	am := s.GetAccountManager()
   180  	ks, err := fetchKeystore(am, account)
   181  	if err != nil {
   182  		return "", err
   183  	}
   184  	publicKey, err := ks.GetPublicKey(account)
   185  	if err != nil {
   186  		return "", err
   187  	}
   188  	return publicKey, nil
   189  }
   190  
   191  // Exit 自己退出网络
   192  // leave from network by self
   193  func (s *Service) Exit(from common.Address) (string, error) {
   194  	result := ""
   195  	if s.permissionContract == nil {
   196  		return result, permissionContractNotSet
   197  	}
   198  	fullNodeId := s.node.Server().NodeInfo().Enode
   199  	auth, err := s.getAuth(from)
   200  	if err != nil {
   201  		return result, err
   202  	}
   203  	tx, err := s.permissionContract.Exit(auth, fullNodeId)
   204  	if err != nil {
   205  		return result, err
   206  	}
   207  	result = tx.Hash().String()
   208  	return result, err
   209  }
   210  
   211  func (s *Service) Prepare() error {
   212  	log.Debug("permission service: binding contracts")
   213  	client, err := s.node.Attach()
   214  	if err != nil {
   215  		log.Error("Service Prepare", "err", err)
   216  		return err
   217  	}
   218  	s.ethClient = ethclient.NewClient(client)
   219  	//read from common db
   220  	addr, err := loadContractAddress(permissionKey, s.GetCommonDb())
   221  	if err != nil {
   222  		log.Error("load permission contract address", "err", err)
   223  		return err
   224  	}
   225  	//if contract address exist ,then use it as permission contract address.
   226  	if addr != (common.Address{}) {
   227  		log.Info("use permission contract", "contract address", addr.String())
   228  		s.permissionAddr = addr
   229  		permission, err := NewPermission(s.permissionAddr, s.ethClient)
   230  		if err != nil {
   231  			return err
   232  		}
   233  		s.permissionContract = permission
   234  		go s.runPermissionVerifyNotify()
   235  		go s.WatchNetworkInitComplete()
   236  
   237  		// add peer if node is in network
   238  		if s.eth != nil && s.eth.ChainConfig().Clique != nil {
   239  			go s.tryConnectNode()
   240  		}
   241  		log.Info("call syncNodeId in Prepare")
   242  		s.syncNodeId()
   243  		log.Info("permission service is now ready")
   244  	}
   245  	addr, err = loadContractAddress(storeAbiKey, s.GetCommonDb())
   246  	if err != nil {
   247  		log.Error("load store contract address", "err", err)
   248  		return err
   249  	}
   250  	if addr != (common.Address{}) {
   251  		s.storeAbiAddr = addr
   252  		storeAbi, err := NewStoreAbi(s.storeAbiAddr, s.ethClient)
   253  		if err != nil {
   254  			return err
   255  		}
   256  		s.storeAbiContract = storeAbi
   257  		log.Info("storeAbi service is now ready")
   258  	}
   259  	return nil
   260  }
   261  
   262  func (s *Service) unlockFirstAccount() {
   263  	am := s.GetAccountManager()
   264  	ks := am.Backends(keystore.KeyStoreType)[0].(*keystore.KeyStore)
   265  	if len(am.Accounts()) == 0 {
   266  		return
   267  	}
   268  	if err := ks.TimedUnlock(accounts.Account{Address: am.Accounts()[0]}, "", 0); err != nil {
   269  		log.Warn("when start sipe, use empty passwd to unlock first account but fail", "error", err)
   270  		return
   271  	}
   272  	log.Info("unlock first account success!")
   273  }
   274  func (s *Service) tryConnectNode() {
   275  	if !s.isInitFinished() {
   276  		//网络初始化还没有完成,不需要
   277  		return
   278  	}
   279  	//本节点
   280  	localNode := strings.Split(s.node.Server().NodeInfo().Enode, "@")[0]
   281  	callOpts := &bind.CallOpts{
   282  		Pending: true,
   283  	}
   284  	//从合约上查询一下自己
   285  	nodeId, _, _, _, _, role, _, _, err := s.permissionContract.GetNodeMap(callOpts, localNode)
   286  	if err != nil {
   287  		log.Error("query contract failed", "err", err)
   288  		return
   289  	}
   290  	//自己不在联盟中
   291  	if nodeId == "" {
   292  		log.Info("local node is not in network")
   293  		return
   294  	}
   295  	//自己是管理节点或普通节点就可以主动去连接其他节点
   296  	if role.Cmp(big.NewInt(int64(Normal))) == 0 || role.Cmp(big.NewInt(int64(Admin))) == 0 {
   297  		log.Info("try connect with others")
   298  		//query normal node and admin node in contract to connect
   299  		nodes := s.getAvailableNodes()
   300  		s.connectNode(nodes)
   301  	}
   302  }
   303  
   304  // 连接节点
   305  func (s *Service) connectNode(nodes string) {
   306  	nodeArray := strings.Split(nodes, ",")
   307  	callOpts := &bind.CallOpts{
   308  		Pending: true,
   309  	}
   310  	for _, v := range nodeArray {
   311  		if v == "" {
   312  			continue
   313  		}
   314  		nodeId, ip, port, _, _, _, _, _, err := s.permissionContract.GetNodeMap(callOpts, v)
   315  		if err != nil {
   316  			log.Error("connect with node failed", "err", err, "nodeId", nodeId, "ip", ip, "port", port)
   317  			continue
   318  		}
   319  		if nodeId == "" {
   320  			continue
   321  		}
   322  		url := fmt.Sprintf("%s@%s:%s", nodeId, ip, port)
   323  		chainNode, err := enode.Parse(enode.ValidSchemes, url)
   324  		if err != nil {
   325  			log.Error("enode.Parse failed", "error", err, "url", url)
   326  			continue
   327  		}
   328  		s.node.Server().AddPeer(chainNode)
   329  	}
   330  }
   331  
   332  // 获取可以连接的节点(包括普通节点和管理员节点)
   333  func (s *Service) getAvailableNodes() string {
   334  	var ret string
   335  	callOpts := &bind.CallOpts{
   336  		Pending: true,
   337  	}
   338  	//获取普通节点
   339  	normalNodes, err := s.permissionContract.GetNodeByRole(callOpts, big.NewInt(int64(Normal)))
   340  	if err != nil {
   341  		log.Error("get normal node from contract failed", "error", err)
   342  	}
   343  	ret += normalNodes
   344  	//获取管理节点
   345  	adminNodes, err := s.permissionContract.GetNodeByRole(callOpts, big.NewInt(int64(Admin)))
   346  	if err != nil {
   347  		log.Error("get admin node from contract failed", "error", err)
   348  	}
   349  	ret += adminNodes
   350  	return ret
   351  }
   352  
   353  func (s *Service) runPermissionVerifyNotify() {
   354  	sink := make(chan *PermissionVerifyNotify, 1)
   355  	var start uint64 = 1
   356  	opts := &bind.WatchOpts{
   357  		Start: &start,
   358  	}
   359  	filter, err := s.permissionContract.WatchVerifyNotify(opts, sink)
   360  	if err != nil {
   361  		log.Error(err.Error())
   362  		return
   363  	}
   364  	s.watching = true
   365  	go s.isAdminRoleEvent()
   366  	go s.isVotedEvent()
   367  	defer func() {
   368  		s.watching = false
   369  	}()
   370  	defer filter.Unsubscribe()
   371  	for {
   372  		select {
   373  		case eventObject := <-sink:
   374  			log.Info("call syncNodeId in runPermissionVerifyNotify")
   375  			s.syncNodeId()
   376  			log.Info("eventObject", "nodeId", eventObject.EnodeId, "opCode", eventObject.OpCode)
   377  			result, err := s.onPermissionNotify(eventObject)
   378  			if err != nil || !result {
   379  				log.Error("operate failed.", "result", result, "err", err)
   380  			}
   381  		case <-s.stop:
   382  			log.Info("quit permission contract watch")
   383  			return
   384  		case err := <-filter.Err():
   385  			if err != nil {
   386  				log.Info("permission contract watch exits")
   387  				return
   388  			}
   389  		}
   390  	}
   391  }
   392  
   393  func (s *Service) opAllNodeOnChain(server *p2p.Server, opType int) {
   394  	log.Info("opAllNodeOnChain", "opType", opType)
   395  	ret1, err := s.permissionContract.GetNodeByRole(&bind.CallOpts{
   396  		Pending: true,
   397  	}, big.NewInt(int64(Admin)))
   398  	if err != nil {
   399  		log.Error("query failed", "err", err)
   400  	}
   401  	tmp := strings.Split(ret1, ",")
   402  	ret2, err := s.permissionContract.GetNodeByRole(&bind.CallOpts{
   403  		Pending: true,
   404  	}, big.NewInt(int64(Normal)))
   405  	if err != nil {
   406  		log.Error("query failed", "err", err)
   407  	}
   408  	tmp1 := strings.Split(ret2, ",")
   409  	tmp = append(tmp, tmp1...)
   410  	for _, nodeId := range tmp {
   411  		returnNodeId, ip, port, _, _, _, _, _, err := s.permissionContract.GetNodeMap(&bind.CallOpts{
   412  			Pending: true,
   413  		}, nodeId)
   414  		if err != nil || returnNodeId == "" {
   415  			log.Error("query failed", "err", err, "nodeId response", returnNodeId)
   416  			continue
   417  		}
   418  		remoteNodeURL := fmt.Sprintf("%v@%v:%v", returnNodeId, ip, port)
   419  		nodeObject, err := enode.Parse(enode.ValidSchemes, remoteNodeURL)
   420  		if err != nil {
   421  			log.Error("eNode.Parse failed", "error", err)
   422  			return
   423  		}
   424  		if opType == Join {
   425  			server.AddPeer(nodeObject)
   426  		}
   427  		if opType == Remove {
   428  			server.RemovePeer(nodeObject)
   429  		}
   430  	}
   431  }
   432  
   433  func (s *Service) onPermissionNotify(verifyNotify *PermissionVerifyNotify) (bool, error) {
   434  	defer func() {
   435  		if err := recover(); err != nil {
   436  			log.Error("onPermissionNotify", "err", err)
   437  		}
   438  	}()
   439  	// Make sure the server is running, fail otherwise
   440  	server := s.node.Server()
   441  	if server == nil {
   442  		return false, fmt.Errorf("node not started")
   443  	}
   444  
   445  	url := fmt.Sprintf("%s@%s:%s", verifyNotify.EnodeId, verifyNotify.Ip, verifyNotify.Port)
   446  
   447  	localeNode := s.node.Server().NodeInfo().Enode
   448  	localeNodeId, _, _, err := splitENode(localeNode)
   449  	if err != nil {
   450  		return false, err
   451  	}
   452  	//退出联盟
   453  	if verifyNotify.OpCode.Cmp(big.NewInt(int64(Remove))) == 0 {
   454  		//remove from network
   455  		// Try to remove the url as a static peer and return
   456  		nodeObject, err := enode.Parse(enode.ValidSchemes, url)
   457  		if err != nil {
   458  			return false, fmt.Errorf("invalid eNode: %v", err)
   459  		}
   460  		server.RemovePeer(nodeObject)
   461  		if localeNodeId == verifyNotify.EnodeId {
   462  			s.opAllNodeOnChain(server, Remove)
   463  		}
   464  	}
   465  	//成功加入联盟
   466  	if verifyNotify.OpCode.Cmp(big.NewInt(int64(Join))) == 0 {
   467  		// Try to add the url as a static peer and return
   468  		nodeObject, err := enode.Parse(enode.ValidSchemes, url)
   469  		if err != nil {
   470  			return false, fmt.Errorf("invalid eNode: %v", err)
   471  		}
   472  		server.AddPeer(nodeObject)
   473  		if localeNodeId == verifyNotify.EnodeId {
   474  			s.opAllNodeOnChain(server, Join)
   475  		}
   476  		log.Info("onPermissionNotify before syncNodeId")
   477  	}
   478  	return true, nil
   479  }
   480  
   481  // InitFinish 完成联盟网络初始化
   482  func (s *Service) InitFinish(from common.Address) (string, error) {
   483  	result := ""
   484  	if s.permissionContract == nil {
   485  		return result, permissionContractNotSet
   486  	}
   487  	auth, err := s.getAuth(from)
   488  	if err != nil {
   489  		return result, err
   490  	}
   491  	tx, err := s.permissionContract.InitFinish(auth)
   492  	if err != nil {
   493  		return result, err
   494  	}
   495  	result = tx.Hash().String()
   496  	return result, nil
   497  }
   498  
   499  // SetAdminNode 设置管理员节点
   500  func (s *Service) SetAdminNode(fullNodeId string, nodeName string, address common.Address, from common.Address) (string, error) {
   501  	result := ""
   502  	if s.permissionContract == nil {
   503  		return result, permissionContractNotSet
   504  	}
   505  	auth, err := s.getAuth(from)
   506  	if err != nil {
   507  		return result, err
   508  	}
   509  	nodeId, ip, port, err := splitENode(fullNodeId)
   510  	if err != nil {
   511  		return result, err
   512  	}
   513  	//todo verify ip and port
   514  	tx, err := s.permissionContract.SetAdminNode(auth, nodeId, ip, port, nodeName, address)
   515  	if err != nil {
   516  		return result, err
   517  	}
   518  	log.Debug("permission:set a new admin node", "nodeId", nodeId, "nodeName", nodeName)
   519  	result = tx.Hash().String()
   520  	return result, nil
   521  }
   522  
   523  // MakeProposalForAdmin 申请成为管理节点
   524  func (s *Service) MakeProposalForAdmin(fullNodeId string, from common.Address) (string, error) {
   525  	result := ""
   526  	if s.permissionContract == nil {
   527  		return result, permissionContractNotSet
   528  	}
   529  	localFullNodeId := s.node.Server().NodeInfo().Enode
   530  	temp := strings.Split(localFullNodeId, "@")
   531  	localNodeId := temp[0]
   532  	nodeId, _, _, err := splitENode(fullNodeId)
   533  	if err != nil {
   534  		return result, err
   535  	}
   536  	auth, err := s.getAuth(from)
   537  	if err != nil {
   538  		return result, err
   539  	}
   540  	opAdmin := "2"
   541  	tx, err := s.permissionContract.MakeProposeForRoleChange(auth, nodeId, opAdmin, localNodeId)
   542  	if err != nil {
   543  		return result, err
   544  	}
   545  	log.Debug("permission:proposal to make an admin node", "nodeId", nodeId, "txHash", tx.Hash().String())
   546  	result = tx.Hash().String()
   547  	return result, err
   548  }
   549  
   550  // AcceptProposalForAdmin 节点升级投赞成票
   551  func (s *Service) AcceptProposalForAdmin(fullNodeId string, from common.Address) (string, error) {
   552  	result := ""
   553  	localFullNodeId := s.node.Server().NodeInfo().Enode
   554  	temp := strings.Split(localFullNodeId, "@")
   555  	localNodeId := temp[0]
   556  	nodeId, _, _, err := splitENode(fullNodeId)
   557  	if err != nil {
   558  		return result, err
   559  	}
   560  	auth, err := s.getAuth(from)
   561  	if err != nil {
   562  		return result, err
   563  	}
   564  	//2 升级为管理节点
   565  	opAdmin := "2"
   566  	tx, err := s.permissionContract.VoteForRoleChange(auth, nodeId, localNodeId, opAdmin)
   567  	if err != nil {
   568  		return result, err
   569  	}
   570  	log.Debug("permission:voting for node upgrading to admin", "nodeId", nodeId, "txHash", tx.Hash().String())
   571  	result = tx.Hash().String()
   572  	return result, err
   573  }
   574  
   575  // MakeProposalForCommon 申请成为普通节点
   576  func (s *Service) MakeProposalForCommon(fullNodeId string, from common.Address) (string, error) {
   577  	result := ""
   578  	if s.permissionContract == nil {
   579  		return result, permissionContractNotSet
   580  	}
   581  	localFullNodeId := s.node.Server().NodeInfo().Enode
   582  	temp := strings.Split(localFullNodeId, "@")
   583  	localNodeId := temp[0]
   584  	nodeId, _, _, err := splitENode(fullNodeId)
   585  	if err != nil {
   586  		return result, err
   587  	}
   588  	auth, err := s.getAuth(from)
   589  	if err != nil {
   590  		return result, err
   591  	}
   592  	// 3 降级成普通节点
   593  	opCommon := "3"
   594  	tx, err := s.permissionContract.MakeProposeForRoleChange(auth, nodeId, opCommon, localNodeId)
   595  	if err != nil {
   596  		return result, err
   597  	}
   598  	log.Debug("permission:proposal to make a normal node", "nodeId", nodeId, "txHash", tx.Hash().String())
   599  	result = tx.Hash().String()
   600  	return result, err
   601  }
   602  
   603  // AcceptProposalForCommon 节点降级投票
   604  // 使用fullNodeId和nodeAddress绑定组成一个节点的唯一标识
   605  func (s *Service) AcceptProposalForCommon(fullNodeId string, from common.Address) (string, error) {
   606  	result := ""
   607  	//本节点
   608  	localFullNodeId := s.node.Server().NodeInfo().Enode
   609  	temp := strings.Split(localFullNodeId, "@")
   610  	localNodeId := temp[0]
   611  	nodeId, _, _, err := splitENode(fullNodeId)
   612  	if err != nil {
   613  		return result, err
   614  	}
   615  	auth, err := s.getAuth(from)
   616  	if err != nil {
   617  		return result, err
   618  	}
   619  	// 3 降级成普通节点
   620  	var opCommon string = "3"
   621  	tx, err := s.permissionContract.VoteForRoleChange(auth, nodeId, localNodeId, opCommon)
   622  	if err != nil {
   623  		return result, err
   624  	}
   625  	log.Debug("permission:voting for node degrading to normal", "nodeId", nodeId, "txHash", tx.Hash().String())
   626  	result = tx.Hash().String()
   627  	return result, err
   628  }
   629  
   630  // MakeProposalForExit 发起退出联盟提案
   631  func (s *Service) MakeProposalForExit(fullNodeId string, from common.Address) (string, error) {
   632  	result := ""
   633  	if s.permissionContract == nil {
   634  		return result, permissionContractNotSet
   635  	}
   636  	localFullNodeId := s.node.Server().NodeInfo().Enode
   637  	temp := strings.Split(localFullNodeId, "@")
   638  	localNodeId := temp[0]
   639  	nodeId, _, _, err := splitENode(fullNodeId)
   640  	if err != nil {
   641  		return result, err
   642  	}
   643  	auth, err := s.getAuth(from)
   644  	if err != nil {
   645  		return result, err
   646  	}
   647  	opExit := "1"
   648  	tx, err := s.permissionContract.MakeProposeForRoleChange(auth, nodeId, opExit, localNodeId)
   649  	if err != nil {
   650  		return result, err
   651  	}
   652  	log.Debug("permission:proposal to exclude a node", "nodeId", nodeId, "txHash", tx.Hash().String())
   653  	result = tx.Hash().String()
   654  	return result, err
   655  }
   656  
   657  // AcceptProposalForExit 变成游离节点(退出联盟)
   658  func (s *Service) AcceptProposalForExit(fullNodeId string, from common.Address) (string, error) {
   659  	result := ""
   660  	if s.permissionContract == nil {
   661  		return result, permissionContractNotSet
   662  	}
   663  	localFullNodeId := s.node.Server().NodeInfo().Enode
   664  	temp := strings.Split(localFullNodeId, "@")
   665  	localNodeId := temp[0]
   666  	nodeId, _, _, err := splitENode(fullNodeId)
   667  	if err != nil {
   668  		return result, err
   669  	}
   670  	auth, err := s.getAuth(from)
   671  	if err != nil {
   672  		return result, err
   673  	}
   674  	// 1 退出联盟,也就是变成游离节点
   675  	opExit := "1"
   676  	tx, err := s.permissionContract.VoteForRoleChange(auth, nodeId, localNodeId, opExit)
   677  	if err != nil {
   678  		return result, err
   679  	}
   680  	log.Debug("permission:voting for excluding node", "nodeId", nodeId, "txHash", tx.Hash().String())
   681  	result = tx.Hash().String()
   682  	return result, err
   683  }
   684  
   685  // MakeProposalForJoin 申请加入联盟
   686  // add new node application
   687  func (s *Service) MakeProposalForJoin(fullNodeId string, nodeName string, nodeAddress common.Address, from common.Address) (string, error) {
   688  	result := ""
   689  	if s.permissionContract == nil {
   690  		return result, permissionContractNotSet
   691  	}
   692  	localFullNodeId := s.node.Server().NodeInfo().Enode
   693  	temp := strings.Split(localFullNodeId, "@")
   694  	localNodeId := temp[0]
   695  	nodeId, ip, port, err := splitENode(fullNodeId)
   696  	if err != nil {
   697  		return result, err
   698  	}
   699  	auth, err := s.getAuth(from)
   700  	if err != nil {
   701  		return result, err
   702  	}
   703  	tx, err := s.permissionContract.MakeProposeForAddNewNode(auth, nodeId, ip, port, nodeName, nodeAddress, localNodeId)
   704  	if err != nil {
   705  		return result, err
   706  	}
   707  	log.Debug("permission:proposal to add a node", "nodeId", nodeId, "txHash", tx.Hash().String())
   708  	return tx.Hash().String(), err
   709  }
   710  
   711  // AcceptProposalForJoin 对申请加入联盟进行投赞成票
   712  // AcceptProposalForJoin
   713  func (s *Service) AcceptProposalForJoin(fullNodeId string, from common.Address) (string, error) {
   714  	result := ""
   715  	if s.permissionContract == nil {
   716  		return result, permissionContractNotSet
   717  	}
   718  	localFullNodeId := s.node.Server().NodeInfo().Enode
   719  	temp := strings.Split(localFullNodeId, "@")
   720  	localNodeId := temp[0]
   721  	nodeId, _, _, err := splitENode(fullNodeId)
   722  	if err != nil {
   723  		return result, err
   724  	}
   725  	auth, err := s.getAuth(from)
   726  	if err != nil {
   727  		return result, err
   728  	}
   729  	tx, err := s.permissionContract.VoteForNewNodeApply(auth, nodeId, localNodeId)
   730  	if err != nil {
   731  		return result, err
   732  	}
   733  	result = tx.Hash().String()
   734  	log.Debug("permission:voting for node adding", "nodeId", nodeId, "txHash", tx.Hash().String())
   735  	return result, err
   736  }
   737  
   738  // UpdateNodeInfo 更新节点信息
   739  // 只能自己更新
   740  // update node info
   741  func (s *Service) UpdateNodeInfo(from common.Address, ip, port string) (string, error) {
   742  	result := ""
   743  	if s.permissionContract == nil {
   744  		return result, permissionContractNotSet
   745  	}
   746  	localFullNodeId := s.node.Server().NodeInfo().Enode
   747  	temp := strings.Split(localFullNodeId, "@")
   748  	localNodeId := temp[0]
   749  	auth, err := s.getAuth(from)
   750  	if err != nil {
   751  		return result, err
   752  	}
   753  	tx, err := s.permissionContract.UpdateNodeInfo(auth, localNodeId, ip, port)
   754  	if err != nil {
   755  		return result, err
   756  	}
   757  	result = tx.Hash().String()
   758  	return result, err
   759  }
   760  func (s *Service) UpdateNodeName(fullNodeId string, nodeName string, from common.Address) (string, error) {
   761  	result := ""
   762  	if s.permissionContract == nil {
   763  		return result, permissionContractNotSet
   764  	}
   765  	temp := strings.Split(fullNodeId, "@")
   766  	nodeId := temp[0]
   767  	auth, err := s.getAuth(from)
   768  	if err != nil {
   769  		return result, err
   770  	}
   771  	tx, err := s.permissionContract.UpdateNodeName(auth, nodeId, nodeName)
   772  	if err != nil {
   773  		return result, err
   774  	}
   775  	result = tx.Hash().String()
   776  	return result, err
   777  }
   778  
   779  // Disagree 投反对票
   780  // 包括加入,升级,降级
   781  func (s *Service) Disagree(fullNodeId string, opCode int, from common.Address) (string, error) {
   782  	result := ""
   783  	if s.permissionContract == nil {
   784  		return result, permissionContractNotSet
   785  	}
   786  	localFullNodeId := s.node.Server().NodeInfo().Enode
   787  	temp := strings.Split(localFullNodeId, "@")
   788  	localNodeId := temp[0]
   789  	auth, err := s.getAuth(from)
   790  	if err != nil {
   791  		return result, err
   792  	}
   793  	nodeId, _, _, err := splitENode(fullNodeId)
   794  	if err != nil {
   795  		return result, err
   796  	}
   797  	tx, err := s.permissionContract.Disagree(auth, nodeId, localNodeId, fmt.Sprintf("%d", opCode))
   798  	if err != nil {
   799  		return result, err
   800  	}
   801  	result = tx.Hash().String()
   802  	return result, err
   803  }
   804  
   805  // GetNodeByRole 根据角色类型获取节点
   806  func (s *Service) GetNodeByRole(role *big.Int, from common.Address) (string, error) {
   807  	result := ""
   808  	if s.permissionContract == nil {
   809  		return result, permissionContractNotSet
   810  	}
   811  	opts := &bind.CallOpts{From: from}
   812  	ret, err := s.permissionContract.GetNodeByRole(opts, role)
   813  	if err != nil {
   814  		return result, err
   815  	}
   816  	return ret, nil
   817  }
   818  
   819  // GetNodeRole 获取节点的角色
   820  //
   821  //	//管理节点
   822  //	uint admin=2;
   823  //	//普通节点
   824  //	uint common=0;
   825  //	//游离节点
   826  //	uint isolated=1;
   827  func (s *Service) GetNodeRole(fullNodeId string, from common.Address) (*big.Int, error) {
   828  	result := big.NewInt(0)
   829  	if s.permissionContract == nil {
   830  		return result, permissionContractNotSet
   831  	}
   832  	nodeId := strings.Split(fullNodeId, "@")[0]
   833  	opts := &bind.CallOpts{From: from}
   834  	eNodeRet, _, _, _, _, role, _, _, err := s.permissionContract.GetNodeMap(opts, nodeId)
   835  	if err != nil || eNodeRet == "" {
   836  		if err != nil {
   837  			log.Error("Service GetNodeRole", "eNodeId err", err.Error())
   838  			return big.NewInt(3), fmt.Errorf("GetNodeRole query failed %s", err.Error())
   839  		}
   840  		return big.NewInt(3), fmt.Errorf("GetNodeRole query failed")
   841  	}
   842  	return role, nil
   843  }
   844  
   845  // GetNodeInfoByName 通过节点名称获取节点信息
   846  func (s *Service) GetNodeInfoByName(nodeName string, from common.Address) (string, error) {
   847  	result := ""
   848  	if s.permissionContract == nil {
   849  		return result, permissionContractNotSet
   850  	}
   851  	opts := &bind.CallOpts{From: from}
   852  	nodeId, ip, port, _, address, role, ifMiner, createdAt, err := s.permissionContract.GetInfoByName(opts, nodeName)
   853  	if err != nil {
   854  		return result, err
   855  	}
   856  	if nodeId == "" {
   857  		return result, errors.New("node not exists")
   858  	}
   859  	return fmt.Sprintf("%v,%v,%v,%v,%v,%v,%v,%v", nodeId, ip, port, nodeName, address.String(), role, ifMiner, createdAt), nil
   860  }
   861  
   862  func (s *Service) GetStateMap(fullNodeId string, opCode string, from common.Address) (string, error) {
   863  	result := ""
   864  	if s.permissionContract == nil {
   865  		return result, permissionContractNotSet
   866  	}
   867  	opts := &bind.CallOpts{From: from}
   868  
   869  	nodeId := strings.Split(fullNodeId, "@")[0]
   870  
   871  	agree, disagree, proposeNodeId, opCode, status, err := s.permissionContract.GetLastStatistics(opts, nodeId, opCode)
   872  
   873  	if err != nil || proposeNodeId == "" {
   874  		return "", fmt.Errorf("GetStateMap query failed")
   875  	}
   876  	return fmt.Sprintf("%v,%v,%v,%v,%v", agree, disagree, proposeNodeId, opCode, status), nil
   877  }
   878  
   879  func (s *Service) GetNodeInfo(fullNodeId string, from common.Address) (string, error) {
   880  	result := ""
   881  	if s.permissionContract == nil {
   882  		return result, permissionContractNotSet
   883  	}
   884  	opts := &bind.CallOpts{From: from}
   885  	nodeId := strings.Split(fullNodeId, "@")[0]
   886  	returnNodeId, ip, port, nodeName, eNodeAddress, role, ifMiner, createdAt, err := s.permissionContract.GetNodeMap(opts, nodeId)
   887  	if err != nil {
   888  		return result, fmt.Errorf("GetNodeInfo query failed")
   889  	}
   890  	if returnNodeId == "" {
   891  		result = "the node is not a member of the alliance"
   892  		return result, nil
   893  	}
   894  	return fmt.Sprintf("%s,%s,%s,%s,%s,%v,%v,%v", returnNodeId, ip, port, nodeName, eNodeAddress.String(), role, ifMiner, createdAt), nil
   895  }
   896  func (s *Service) GetAllStatingRecord(from common.Address) (string, error) {
   897  	result := ""
   898  	if s.permissionContract == nil {
   899  		return result, permissionContractNotSet
   900  	}
   901  	opts := &bind.CallOpts{From: from}
   902  	stateKeys, err := s.permissionContract.GetAllStatingRecord(opts)
   903  	if err != nil {
   904  		return result, err
   905  	}
   906  	return stateKeys, nil
   907  }
   908  
   909  func (s *Service) IsAdmin(fullNodeId string, from common.Address) (bool, error) {
   910  	if s.permissionContract == nil {
   911  		return false, permissionContractNotSet
   912  	}
   913  	nodeId := strings.Split(fullNodeId, "@")[0]
   914  	opts := &bind.CallOpts{From: from}
   915  	h := crypto.Keccak256Hash([]byte(nodeId))
   916  	flag, err := s.permissionContract.IsAdmin(opts, h)
   917  	if err != nil {
   918  		return false, err
   919  	}
   920  	return flag, nil
   921  }
   922  
   923  // AddPeer 添加节点
   924  func (s *Service) AddPeer(url string, from common.Address) (bool, error) {
   925  	//本节点
   926  	localNode := s.node.Server().NodeInfo().Enode
   927  	if s.node.Config().EnableNodePermission {
   928  		available, err := s.verifyPermission(url, from)
   929  		if err != nil {
   930  			log.Error("verify permission failed", "url", url, "err", err)
   931  			return false, err
   932  		}
   933  		if !available {
   934  			return false, errors.New(fmt.Sprintf("the node %s does not join the network", url))
   935  		}
   936  		available, err = s.verifyPermission(localNode, from)
   937  		if err != nil {
   938  			log.Error("verify permission failed", "url", localNode, "err", err)
   939  			return false, err
   940  		}
   941  		if !available {
   942  			return false, errors.New(fmt.Sprintf("local %s does not join the network", localNode))
   943  		}
   944  	}
   945  	if s.eth != nil && s.eth.ChainConfig().Clique != nil {
   946  		// Make sure the server is running, fail otherwise
   947  		server := s.node.Server()
   948  		if server == nil {
   949  			return false, fmt.Errorf("node not started")
   950  		}
   951  		// Try to add the url as a static peer and return
   952  		nodeObject, err := enode.Parse(enode.ValidSchemes, url)
   953  		if err != nil {
   954  			return false, fmt.Errorf("invalid enode: %v", err)
   955  		}
   956  		server.AddPeer(nodeObject)
   957  	}
   958  	return true, nil
   959  }
   960  
   961  func (s *Service) RemovePeer(url string) (bool, error) {
   962  	// Make sure the server is running, fail otherwise
   963  	if s.eth.ChainConfig().Clique != nil { //poa
   964  		server := s.node.Server()
   965  		if server == nil {
   966  			return false, fmt.Errorf("node not started")
   967  		}
   968  		// Try to remove the url as a static peer and return
   969  		nodeObject, err := enode.Parse(enode.ValidSchemes, url)
   970  		if err != nil {
   971  			return false, fmt.Errorf("invalid enode: %v", err)
   972  		}
   973  		server.RemovePeer(nodeObject)
   974  	}
   975  	return true, nil
   976  }
   977  
   978  func (s *Service) verifyPermission(url string, from common.Address) (bool, error) {
   979  	nodeId, _, _, err := splitENode(url)
   980  	if err != nil {
   981  		return false, err
   982  	}
   983  	if s.permissionContract == nil {
   984  		return false, permissionContractNotSet
   985  	}
   986  
   987  	opts := &bind.CallOpts{From: from}
   988  	returnNodeId, _, _, _, _, role, _, _, err := s.permissionContract.GetNodeMap(opts, nodeId)
   989  	if err != nil {
   990  		return false, err
   991  	}
   992  	if returnNodeId == "" {
   993  		return false, errors.New("the node is isolated node")
   994  	}
   995  	if role.Cmp(big.NewInt(int64(Isolated))) == 0 {
   996  		return false, errors.New("the node can not join network")
   997  	}
   998  	return true, nil
   999  }
  1000  func (s *Service) WatchNetworkInitComplete() {
  1001  	sink := make(chan *PermissionNetworkInitComplete, 1)
  1002  	var start uint64 = 1
  1003  	opts := &bind.WatchOpts{
  1004  		Start: &start,
  1005  	}
  1006  	filter, err := s.permissionContract.WatchNetworkInitComplete(opts, sink)
  1007  	if err != nil {
  1008  		log.Error(err.Error())
  1009  		return
  1010  	}
  1011  	defer filter.Unsubscribe()
  1012  	for {
  1013  		select {
  1014  		case initCompleteEvent := <-sink:
  1015  			log.Info("WatchNetworkInitComplete", "block number", initCompleteEvent.Number)
  1016  			log.Info("call syncNodeId in WatchNetworkInitComplete")
  1017  			s.syncNodeId()
  1018  			s.CacheManager()
  1019  		case <-s.stop:
  1020  			log.Info("quit permission contract watch")
  1021  			return
  1022  		case err := <-filter.Err():
  1023  			if err != nil {
  1024  				log.Error("permission contract watch exits", "error", err)
  1025  				return
  1026  			}
  1027  		}
  1028  	}
  1029  }
  1030  
  1031  func (s *Service) CacheManager() {
  1032  	//获取管理员节点
  1033  	role := big.NewInt(0).SetInt64(int64(Admin))
  1034  	am := s.GetAccountManager()
  1035  	//获取所有的管理员节点
  1036  	nodeIdStr, err := s.GetNodeByRole(role, am.Accounts()[0])
  1037  	if err != nil {
  1038  		log.Error("GetAllNode", "err", err)
  1039  		return
  1040  	}
  1041  	nodeIds := strings.Split(nodeIdStr, ",")
  1042  	for _, nodeId := range nodeIds {
  1043  		callOpts := &bind.CallOpts{
  1044  			Pending: true,
  1045  		}
  1046  		_, _, _, _, addr, _, isOriginator, _, err := s.permissionContract.GetNodeMap(callOpts, nodeId)
  1047  		if err != nil {
  1048  			log.Error("GetNodeMap", "error", err)
  1049  			continue
  1050  		}
  1051  		//缓存所有的创世管理员
  1052  		if addr != (common.Address{}) && isOriginator {
  1053  			log.Debug("CacheManager", "addr", addr.String())
  1054  			s.eth.GetSuperManager().AddManager(addr)
  1055  		}
  1056  	}
  1057  }
  1058  func (s *Service) isInitFinished() bool {
  1059  	if s.permissionContract == nil {
  1060  		return false
  1061  	}
  1062  	finish, err := s.permissionContract.IsInitFinished(&bind.CallOpts{
  1063  		Pending: true,
  1064  	})
  1065  	if err != nil {
  1066  		log.Error("Service IsInitFinished", "err", err.Error())
  1067  		return false
  1068  	}
  1069  	return finish
  1070  }
  1071  func (s *Service) GetAdminCount() (*big.Int, error) {
  1072  	if s.permissionContract == nil {
  1073  		return big.NewInt(0), errors.New("permission Contract is nil")
  1074  	}
  1075  	count, err := s.permissionContract.GetAdminCount(&bind.CallOpts{
  1076  		Pending: true,
  1077  	})
  1078  	if err != nil {
  1079  		log.Error("Service GetAdminCount", "err", err.Error())
  1080  		return big.NewInt(0), err
  1081  	}
  1082  	return count, nil
  1083  }
  1084  func (s *Service) nodeExists(fullNodeId string) bool {
  1085  	if s.permissionContract == nil {
  1086  		return false
  1087  	}
  1088  	nodeId := strings.Split(fullNodeId, "@")[0]
  1089  	opts := &bind.CallOpts{Pending: true}
  1090  	exists, err := s.permissionContract.NodeExists(opts, nodeId)
  1091  	if err != nil {
  1092  		log.Error("Service nodeExists", "err", err.Error())
  1093  		return false
  1094  	}
  1095  	return exists
  1096  }
  1097  func (s *Service) SetInitFinishedFlag(db ethdb.Database) error {
  1098  	return db.Put([]byte(common.PermissionInitFinished), []byte("true"))
  1099  }
  1100  
  1101  func (s *Service) cacheNodeId(nodeId string, db ethdb.Database) error {
  1102  	log.Info("cacheNodeId", "nodeId", nodeId)
  1103  	return db.Put([]byte(nodeId), []byte("true"))
  1104  }
  1105  
  1106  // filterNodeId nodeId形如 "enode://217d5b...928b@101.68.74.170:30303"
  1107  // 取 217d5b...928b
  1108  func (s *Service) filterNodeId(nodeId string) string {
  1109  	if strings.Contains(nodeId, "enode://") {
  1110  		nodeId = strings.ReplaceAll(nodeId, "enode://", "")
  1111  	}
  1112  	if strings.Contains(nodeId, "@") {
  1113  		strArr := strings.Split(nodeId, "@")
  1114  		nodeId = strArr[0]
  1115  	}
  1116  	return nodeId
  1117  }
  1118  
  1119  // 同步节点
  1120  func (s *Service) syncNodeId() {
  1121  	if s.isInitFinished() {
  1122  		err := s.SetInitFinishedFlag(s.GetCommonDb())
  1123  		if err != nil {
  1124  			log.Error("SetInitFinishedFlag", "err", err.Error())
  1125  		}
  1126  		//游离节点要删除
  1127  		nodeString := s.dissociateNodes()
  1128  		if nodeString != "" {
  1129  			log.Info("syncNodeId", "dissociateNodes", nodeString)
  1130  			nodeArr := strings.Split(nodeString, ",")
  1131  			for _, v := range nodeArr {
  1132  				if v == "" {
  1133  					continue
  1134  				}
  1135  				err := s.removeNodeId(s.filterNodeId(v), s.GetCommonDb())
  1136  				if err != nil {
  1137  					log.Error("removeNodeId", "err", err.Error())
  1138  				}
  1139  			}
  1140  		}
  1141  		//正常节点要缓存
  1142  		nodeStr := s.getAvailableNodes()
  1143  		if nodeStr != "" {
  1144  			log.Info("syncNodeId", "availableNodes", nodeStr)
  1145  			nodeArray := strings.Split(nodeStr, ",")
  1146  			for _, v := range nodeArray {
  1147  				if v == "" {
  1148  					continue
  1149  				}
  1150  				err := s.cacheNodeId(s.filterNodeId(v), s.GetCommonDb())
  1151  				if err != nil {
  1152  					log.Error("CacheNodeId", "err", err.Error())
  1153  				}
  1154  			}
  1155  		}
  1156  	}
  1157  }
  1158  
  1159  // 从db中删除节点id
  1160  func (s *Service) removeNodeId(nodeId string, db ethdb.Database) error {
  1161  	return db.Delete([]byte(nodeId))
  1162  }
  1163  
  1164  // 获取游离节点
  1165  func (s *Service) dissociateNodes() string {
  1166  	var ret string
  1167  	callOpts := &bind.CallOpts{
  1168  		Pending: true,
  1169  	}
  1170  	//获取游离节点
  1171  	normalNodes, err := s.permissionContract.GetNodeByRole(callOpts, big.NewInt(int64(Isolated)))
  1172  	if err != nil {
  1173  		log.Error("get normal node from contract failed", "error", err)
  1174  	}
  1175  	ret += normalNodes
  1176  	return ret
  1177  }
  1178  func (s *Service) isAdminRoleEvent() {
  1179  	log.Info(" isAdminRoleEvent enter")
  1180  	sink := make(chan *PermissionIsAdminRoleEvent, 1)
  1181  	var start uint64 = 1
  1182  	opts := &bind.WatchOpts{
  1183  		Start: &start,
  1184  	}
  1185  	filter, err := s.permissionContract.WatchIsAdminRoleEvent(opts, sink)
  1186  	if err != nil {
  1187  		log.Error(err.Error())
  1188  		return
  1189  	}
  1190  	defer filter.Unsubscribe()
  1191  	for {
  1192  		select {
  1193  		case eventObject := <-sink:
  1194  			log.Info("call isAdminRoleEvent")
  1195  			log.Info("eventObject", "voteNodeId", eventObject.NodeId, "sender", eventObject.Sender)
  1196  
  1197  		case <-s.stop:
  1198  			log.Info("quit permission contract watch")
  1199  			return
  1200  		case err := <-filter.Err():
  1201  			if err != nil {
  1202  				log.Info("permission contract watch exits")
  1203  				return
  1204  			}
  1205  		}
  1206  	}
  1207  }
  1208  
  1209  func (s *Service) isVotedEvent() {
  1210  	log.Info(" isVotedEvent enter")
  1211  	sink := make(chan *PermissionIsVotedEvent, 1)
  1212  	var start uint64 = 1
  1213  	opts := &bind.WatchOpts{
  1214  		Start: &start,
  1215  	}
  1216  	filter, err := s.permissionContract.WatchIsVotedEvent(opts, sink)
  1217  	if err != nil {
  1218  		log.Error(err.Error())
  1219  		return
  1220  	}
  1221  
  1222  	defer filter.Unsubscribe()
  1223  	for {
  1224  		select {
  1225  		case eventObject := <-sink:
  1226  			log.Info("call isVotedEvent")
  1227  			log.Info("eventObject", "nodeId", eventObject.NodeId, "voteId", eventObject.VoterNodeId)
  1228  		case <-s.stop:
  1229  			log.Info("quit permission contract watch")
  1230  			return
  1231  		case err := <-filter.Err():
  1232  			if err != nil {
  1233  				log.Info("permission contract watch exits")
  1234  				return
  1235  			}
  1236  		}
  1237  	}
  1238  }