github.com/cranelv/ethereum_mpc@v0.0.0-20191031014521-23aeb1415092/core/vm/Deposit.go

package vm

import (
	"encoding/binary"
	"errors"
	"strings"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/common/math"
	"github.com/ethereum/go-ethereum/p2p/discover"
	"github.com/ethereum/go-ethereum/params"
	"github.com/ethereum/go-ethereum/accounts/abi"
	"math/big"
)
var (
	man				= new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)
	minerThreshold	= new(big.Int).Mul(big.NewInt(10),man)
	validatorThreshold	= new(big.Int).Mul(big.NewInt(10000),man)
	withdrawState   = big.NewInt(1)
	errParameters   = errors.New("error parameters")
	errMethodId     = errors.New("error method id")
	errDeposit      = errors.New("Deposit is not found")
	errWithdraw     = errors.New("withdraw is not set")
	errOverflow     = errors.New("Deposit is overflow")
	errDepositEmpty = errors.New("DepositList is Empty")

	depositDef = ` [{"constant": true,"inputs": [],"name": "getDepositList","outputs": [{"name": "","type": "address[]"}],"payable": false,"stateMutability": "view","type": "function"},
    		{"constant": true,"inputs": [{"name": "addr","type": "address"}],"name": "getDepositInfo","outputs": [{"name": "","type": "uint256"},{"name": "","type": "bytes"},{"name": "","type": "uint256"}],"payable": false,"stateMutability": "view","type": "function"},
    		{"constant": false,"inputs": [{"name": "nodeID","type": "bytes"}],"name": "valiDeposit","outputs": [],"payable": true,"stateMutability": "payable","type": "function"},
    		{"constant": false,"inputs": [{"name": "nodeID","type": "bytes"}],"name": "minerDeposit","outputs": [],"payable": true,"stateMutability": "payable","type": "function"},
    		{"constant": false,"inputs": [],"name": "withdraw","outputs": [],"payable": false,"stateMutability": "nonpayable","type": "function"},
    		{"constant": false,"inputs": [],"name": "refund","outputs": [],"payable": false,"stateMutability": "nonpayable","type": "function"}]`

	depositAbi,Abierr = abi.JSON(strings.NewReader(depositDef))
	valiDepositArr,minerDepositIdArr, withdrawIdArr, refundIdArr,getDepositListArr,getDepositInfoArr [4]byte
	emptyHash                                = common.Hash{}
)
func init() {
	if Abierr != nil {
		panic("err in deposit sc initialize")
	}

	copy(valiDepositArr[:], depositAbi.Methods["valiDeposit"].Id())
	copy(minerDepositIdArr[:], depositAbi.Methods["minerDeposit"].Id())
	copy(withdrawIdArr[:], depositAbi.Methods["withdraw"].Id())
	copy(refundIdArr[:], depositAbi.Methods["refund"].Id())
	copy(getDepositListArr[:], depositAbi.Methods["getDepositList"].Id())
	copy(getDepositInfoArr[:], depositAbi.Methods["getDepositInfo"].Id())
}


type MatrixDeposit struct {
}

func (md *MatrixDeposit) RequiredGas(input []byte) uint64 {
	if len(input) < 4 {
		return 0
	}

	return params.SstoreSetGas * 2
}

func (md *MatrixDeposit) Run(in []byte, contract *Contract, evm *EVM) ([]byte, error) {
	if len(in) < 4 {
		return nil, errParameters
	}

	var methodIdArr [4]byte
	copy(methodIdArr[:], in[:4])

	if methodIdArr == valiDepositArr {
		return md.valiDeposit(in[4:], contract, evm)
	}else if methodIdArr == minerDepositIdArr {
		return md.minerDeposit(in[4:], contract, evm)
	} else if methodIdArr == withdrawIdArr {
		return md.withdraw(in[4:], contract, evm)
	} else if methodIdArr == refundIdArr {
		return md.refund(in[4:], contract, evm)
	}else if methodIdArr == getDepositListArr {
		return md.getDepositList(in[4:], contract, evm)
	}else if methodIdArr == getDepositInfoArr {
		return md.getDepositInfo(in[4:], contract, evm)
	}

	return nil, errParameters
}
func (md *MatrixDeposit) valiDeposit(in []byte, contract *Contract, evm *EVM) ([]byte, error) {
	return md.deposit(in,contract,evm,validatorThreshold)
}
//deposit(uint nodeID-x, uint nodeID-y)
func (md *MatrixDeposit) minerDeposit(in []byte, contract *Contract, evm *EVM) ([]byte, error) {
	return md.deposit(in,contract,evm,minerThreshold)
}
func (md *MatrixDeposit) deposit(in []byte, contract *Contract, evm *EVM,threshold *big.Int) ([]byte, error) {
	if len(in) < 4 {
		return nil, errParameters
	}
	var nodeID []byte
	err := depositAbi.Methods["deposit"].Inputs.Unpack(&nodeID,in)

	if err != nil || len(nodeID)!=64 {
		return nil, errDeposit
	}
	deposit := md.getDeposit(contract, evm.StateDB,contract.CallerAddress)
	if deposit == nil{
		deposit = big.NewInt(0)
	}
	deposit.Add(deposit,contract.value)
	if deposit.Cmp(threshold)<0 {
		return nil,errDeposit
	}
	addrSrc := contract.CallerAddress
	if(contract.value.Sign()>0){
		if !evm.CanTransfer(evm.StateDB, addrSrc, contract.value) {
			return nil, ErrInsufficientBalance
		}
		evm.Transfer(evm.StateDB, contract.CallerAddress, contract.Address(), contract.value)
	}
	var discoverId discover.NodeID
	copy(discoverId[:],nodeID)
	md.modifyDepositState(contract, evm, discoverId)
	/*
	evm.StateDB.AddLog(&types.Log{
		Address: contract.Address(),
		Topics:  topics,
		Data:    d,
		// This is a non-consensus field, but assigned here because
		// core/state doesn't know the current block number.
		BlockNumber: evm.BlockNumber.Uint64(),
	})
	*/
	return []byte{1}, nil
}
func (md *MatrixDeposit) withdraw(in []byte, contract *Contract, evm *EVM) ([]byte, error) {
	err := md.modifyWithdrawState(contract, evm)
	if err != nil {
		return nil, err
	}

	return []byte{1}, nil
}
func (md *MatrixDeposit) refund(in []byte, contract *Contract, evm *EVM) ([]byte, error) {
	value, err := md.modifyRefundState(contract, evm)
	if err != nil {
		return nil, err
	}
	if !evm.CanTransfer(evm.StateDB, contract.Address(), value) {
		return nil, ErrInsufficientBalance
	}
	evm.Transfer(evm.StateDB, contract.Address(), contract.CallerAddress, value)
	return []byte{1}, nil
}

func (md *MatrixDeposit) getOnlineTime(contract *Contract, stateDB StateDB,addr common.Address) *big.Int {
	onlineKey := append(addr[:], 'O', 'T')
	info := stateDB.GetState(contract.Address(), common.BytesToHash(onlineKey))
	if info != emptyHash {
		return info.Big()
	}
	return nil
}
func (md *MatrixDeposit) addOnlineTime(contract *Contract, stateDB StateDB, tm *big.Int) error {
	onlineKey := append(contract.CallerAddress[:], 'O', 'T')
	info := stateDB.GetState(contract.Address(), common.BytesToHash(onlineKey))
	dep := info.Big()
	dep.Add(dep, tm)
	if len(dep.Bytes()) > 32 {
		return errOverflow
	}
	stateDB.SetState(contract.Address(), common.BytesToHash(onlineKey), common.BigToHash(dep))
	return nil
}
func (md *MatrixDeposit) setOnlineTime(contract *Contract, stateDB StateDB, tm *big.Int) error {
	onlineKey := append(contract.CallerAddress[:], 'O', 'T')
	stateDB.SetState(contract.Address(), common.BytesToHash(onlineKey), common.BigToHash(tm))
	return nil
}
func (md *MatrixDeposit) getDeposit(contract *Contract, stateDB StateDB,addr common.Address) *big.Int {
	depositKey := append(addr[:], 'D')
	info := stateDB.GetState(contract.Address(), common.BytesToHash(depositKey))
	if info != emptyHash {
		return info.Big()
	}
	return big.NewInt(0)
}
func (md *MatrixDeposit) addDeposit(contract *Contract, stateDB StateDB) error {
	depositKey := append(contract.CallerAddress[:], 'D')
	info := stateDB.GetState(contract.Address(), common.BytesToHash(depositKey))
	dep := info.Big()
	dep.Add(dep, contract.value)
	if len(dep.Bytes()) > 32 {
		return errOverflow
	}
	stateDB.SetState(contract.Address(), common.BytesToHash(depositKey), common.BigToHash(dep))
	return nil
}
func (md *MatrixDeposit) setDeposit(contract *Contract, stateDB StateDB, dep *big.Int) error {
	depositKey := append(contract.CallerAddress[:], 'D')
	stateDB.SetState(contract.Address(), common.BytesToHash(depositKey), common.BigToHash(dep))
	return nil
}
func (md *MatrixDeposit) getNodeID(contract *Contract, stateDB StateDB,addr common.Address) *discover.NodeID {
	nodeXKey := append(addr[:], 'N', 'X')
	nodeX := stateDB.GetState(contract.Address(), common.BytesToHash(nodeXKey))
	if nodeX == emptyHash {
		return &discover.NodeID{}
	}
	nodeYKey := append(addr[:], 'N', 'Y')
	nodeY := stateDB.GetState(contract.Address(), common.BytesToHash(nodeYKey))
	if nodeY == emptyHash {
		return &discover.NodeID{}
	}
	var nodeID discover.NodeID
	copy(nodeID[:32], nodeX[:])
	copy(nodeID[32:], nodeY[:])
	return &nodeID
}
func (md *MatrixDeposit) setNodeID(contract *Contract, stateDB StateDB, nodeID discover.NodeID) error {
	if (nodeID == discover.NodeID{}) {
		return nil
	}
	nodeXKey := append(contract.CallerAddress[:], 'N', 'X')
	stateDB.SetState(contract.Address(), common.BytesToHash(nodeXKey), common.BytesToHash(nodeID[:32]))
	nodeYKey := append(contract.CallerAddress[:], 'N', 'Y')
	stateDB.SetState(contract.Address(), common.BytesToHash(nodeYKey), common.BytesToHash(nodeID[32:]))
	return nil
}
func (md *MatrixDeposit) getWithdrawHeight(contract *Contract, stateDB StateDB,addr common.Address) *big.Int {
	nodeXKey := append(addr[:], 'W', 'H')
	withdraw := stateDB.GetState(contract.Address(), common.BytesToHash(nodeXKey))
	if withdraw == emptyHash {
		return big.NewInt(0)
	}
	return withdraw.Big()
}
func (md *MatrixDeposit) setWithdrawHeight(contract *Contract, stateDB StateDB, height *big.Int) error {
	withdrawKey := append(contract.CallerAddress[:], 'W', 'H')
	stateDB.SetState(contract.Address(), common.BytesToHash(withdrawKey), common.BigToHash(height))
	return nil
}
type DepositDetail struct {
	Address common.Address
	NodeID discover.NodeID
	Deposit *big.Int
	WithdrawH *big.Int
	OnlineTime *big.Int
}
func (md *MatrixDeposit) getValidatorDepositList(in []byte,contract *Contract, stateDB StateDB)  []DepositDetail {
	var detailList []DepositDetail
	contractAddr := contract.Address()
	numKey := append(contractAddr[:], 'D', 'N', 'U', 'M')
	numHash := stateDB.GetState(contract.Address(), common.BytesToHash(numKey))
	num := numHash.Big()
	if num.Sign() != 0 {
		count := num.Uint64()
		for i := uint64(0); i < count; i++ {
			addr := md.getDepositListItem(contract, stateDB, i)
			detail,err := md.getDepositDetail(addr,contract,stateDB)
			if err != nil && detail.WithdrawH.Sign() == 0 && detail.Deposit.Cmp(validatorThreshold)>=0 {
				detailList = append(detailList,*detail)
			}
		}
	}
	return detailList
}
func (md *MatrixDeposit) getMinerDepositList(in []byte,contract *Contract, stateDB StateDB)  []DepositDetail {
	var detailList []DepositDetail
	contractAddr := contract.Address()
	numKey := append(contractAddr[:], 'D', 'N', 'U', 'M')
	numHash := stateDB.GetState(contract.Address(), common.BytesToHash(numKey))
	num := numHash.Big()
	if num.Sign() != 0 {
		count := num.Uint64()
		for i := uint64(0); i < count; i++ {
			addr := md.getDepositListItem(contract, stateDB, i)
			detail,err := md.getDepositDetail(addr,contract,stateDB)
			if err != nil && detail.WithdrawH.Sign() == 0 && detail.Deposit.Cmp(validatorThreshold)<0 {
				detailList = append(detailList,*detail)
			}
		}
	}
	return detailList
}
func (md *MatrixDeposit) getDepositDetail(addr common.Address,contract *Contract, stateDB StateDB)  (*DepositDetail, error) {
	detail := DepositDetail{Address : addr}
	detail.Deposit = md.getDeposit(contract, stateDB,addr)
	if detail.Deposit == nil || detail.Deposit.Sign() == 0 {
		return nil, errDepositEmpty
	}
	detail.NodeID = *(md.getNodeID(contract, stateDB,addr))
	detail.WithdrawH = md.getWithdrawHeight(contract, stateDB,addr)
	detail.OnlineTime = md.getOnlineTime(contract, stateDB,addr)
	return &detail,nil
}

func (md *MatrixDeposit) getDepositList(in []byte,contract *Contract, evm *EVM)  ([]byte, error) {
	var addrList []common.Address
	contractAddr := contract.Address()
	numKey := append(contractAddr[:], 'D', 'N', 'U', 'M')
	numHash := evm.StateDB.GetState(contract.Address(), common.BytesToHash(numKey))
	num := numHash.Big()
	if num.Sign() != 0 {
		count := num.Uint64()
		addrList = make([]common.Address, count)
		for i := uint64(0); i < count; i++ {
			addrList[i] = md.getDepositListItem(contract, evm.StateDB, i)
		}
	}
	return depositAbi.Methods["getDepositList"].Outputs.Pack(addrList)
}

func (md *MatrixDeposit) getDepositListNum(contract *Contract, stateDB StateDB) *big.Int {
	contractAddr := contract.Address()
	numKey := append(contractAddr[:], 'D', 'N', 'U', 'M')
	num := stateDB.GetState(contract.Address(), common.BytesToHash(numKey))
	if num == emptyHash {
		return nil
	}
	return num.Big()
}
func (md *MatrixDeposit) setDepositListNum(contract *Contract, stateDB StateDB, num *big.Int) {
	contractAddr := contract.Address()
	numKey := append(contractAddr[:], 'D', 'N', 'U', 'M')
	stateDB.SetState(contract.Address(), common.BytesToHash(numKey), common.BigToHash(num))
}
func (md *MatrixDeposit) getDepositListItem(contract *Contract, stateDB StateDB, index uint64) common.Address {
	contractAddr := contract.Address()
	key := make([]byte, 8)
	binary.BigEndian.PutUint64(key, index)
	depKey := append(contractAddr[:], 'D', 'I')
	depKey = append(depKey, key...)
	addrHash := stateDB.GetState(contract.Address(), common.BytesToHash(depKey))
	return common.BytesToAddress(addrHash[:])
}
func (md *MatrixDeposit) SetDepositListItem(contract *Contract, stateDB StateDB, index uint64, addr common.Address) {
	key := make([]byte, 8)
	binary.BigEndian.PutUint64(key, index)
	contractAddr := contract.Address()
	depKey := append(contractAddr[:], 'D', 'I')
	depKey = append(depKey, key...)
	stateDB.SetState(contract.Address(), common.BytesToHash(depKey), common.BytesToHash(addr[:]))
}
func (md *MatrixDeposit) insertDepositList(contract *Contract, stateDB StateDB) {
	num := md.getDepositListNum(contract, stateDB)
	var count uint64
	if num != nil {
		count = num.Uint64()
		num.Add(num, big.NewInt(1))
	}else{
		num = big.NewInt(1)
	}
	md.setDepositListNum(contract, stateDB, num)
	md.SetDepositListItem(contract, stateDB, count, contract.CallerAddress)
}
func (md *MatrixDeposit) removeDepositList(contract *Contract, stateDB StateDB) error {
	num := md.getDepositListNum(contract, stateDB)
	if num == nil {
		return errDepositEmpty
	}
	count := num.Uint64()
	insert := uint64(math.MaxUint64)
	for i := uint64(0); i < count; i++ {
		addr := md.getDepositListItem(contract, stateDB, i)
		if addr == contract.CallerAddress {
			insert = i
			break
		}
	}
	if insert != math.MaxUint64 {
		addr := md.getDepositListItem(contract, stateDB, count-1)
		md.SetDepositListItem(contract, stateDB, insert, addr)
		num.Sub(num, big.NewInt(1))
		md.setDepositListNum(contract, stateDB, num)
		return nil
	} else {
		return errDeposit
	}
}

func (md *MatrixDeposit) getDepositInfo(in []byte,contract *Contract, evm *EVM) ([]byte, error) {
	var addr common.Address
	err := depositAbi.Methods["getDepositInfo"].Inputs.Unpack(&addr,in)
	if err != nil{
		return nil,err
	}
	deposit := md.getDeposit(contract, evm.StateDB,addr)
	if deposit == nil || deposit.Sign() == 0 {
		return nil, errDepositEmpty
	}
	nodeID := md.getNodeID(contract, evm.StateDB,addr)
	withdraw := md.getWithdrawHeight(contract, evm.StateDB,addr)
	return depositAbi.Methods["getDepositInfo"].Outputs.Pack(deposit, nodeID[:], withdraw)
}
func (md *MatrixDeposit) modifyDepositState(contract *Contract, evm *EVM, nodeID discover.NodeID) error {
	deposit := md.getDeposit(contract, evm.StateDB,contract.CallerAddress)
	bNew := deposit == nil || deposit.Sign() == 0
	err := md.addDeposit(contract, evm.StateDB)
	if err != nil {
		return err
	}
	md.setNodeID(contract, evm.StateDB, nodeID)
	if bNew {
		md.insertDepositList(contract, evm.StateDB)
	}
	return nil
}
func (md *MatrixDeposit) modifyWithdrawState(contract *Contract, evm *EVM) error {
	deposit := md.getDeposit(contract, evm.StateDB,contract.CallerAddress)
	if deposit == nil || deposit.Sign() == 0 {
		return errDeposit
	}
	md.setWithdrawHeight(contract, evm.StateDB, evm.BlockNumber)
	return nil
}
func (md *MatrixDeposit) modifyRefundState(contract *Contract, evm *EVM) (*big.Int, error) {
	deposit := md.getDeposit(contract, evm.StateDB,contract.CallerAddress)
	if deposit == nil || deposit.Sign() == 0 {
		return nil, errDeposit
	}
	withdrawHeight := md.getWithdrawHeight(contract, evm.StateDB,contract.CallerAddress)
	if withdrawHeight == nil || withdrawHeight.Sign() == 0 {
		return nil, errDeposit
	}
	withdrawHeight.Add(withdrawHeight, big.NewInt(600))
	if withdrawHeight.Cmp(evm.BlockNumber) > 0 {
		return nil, errDeposit
	}

	md.setDeposit(contract, evm.StateDB, big.NewInt(0))
	md.setNodeID(contract, evm.StateDB, discover.NodeID{})
	md.setWithdrawHeight(contract, evm.StateDB, big.NewInt(0))
	md.setOnlineTime(contract, evm.StateDB, big.NewInt(0))
	md.removeDepositList(contract, evm.StateDB)
	return deposit, nil
}