github.com/nnlgsakib/mind-dpos@v0.0.0-20230606105614-f3c8ca06f808/tests/sc/sc.go (about)

     1  package main
     2  
     3  import (
     4  	"fmt"
     5  	"math/big"
     6  	"os"
     7  	"strconv"
     8  
     9  	"github.com/TTCECO/gttc/common"
    10  	"github.com/TTCECO/gttc/core/types"
    11  	"github.com/TTCECO/gttc/crypto"
    12  	"github.com/TTCECO/gttc/rlp"
    13  	"github.com/TTCECO/gttc/rpc"
    14  )
    15  
    16  var scAddressList = []string{}
    17  var nodeAddressList = []string{}
    18  var pkList = []string{}
    19  
    20  func main() {
    21  	if len(scAddressList) < 36 || len(nodeAddressList) < 36 || len(pkList) < 36 {
    22  		fmt.Println(" set nodeList ")
    23  		return
    24  	}
    25  
    26  	if len(os.Args) < 5 {
    27  		fmt.Println("arg missing ")
    28  		return
    29  	}
    30  
    31  	ip := string(os.Args[1])
    32  	fmt.Println("ip : ", ip)
    33  
    34  	port, err := strconv.ParseInt(os.Args[2], 10, 64)
    35  	if err != nil {
    36  		fmt.Println("port err", err)
    37  		return
    38  	}
    39  	fmt.Println("port : ", port)
    40  
    41  	operType := 0
    42  	if string(os.Args[3]) == "del" {
    43  		operType = 5
    44  	} else if string(os.Args[3]) == "add" {
    45  		operType = 4
    46  	} else {
    47  		fmt.Println("operType err ")
    48  		return
    49  	}
    50  	fmt.Println("operType : ", operType)
    51  
    52  	scHash := string(os.Args[4])
    53  	fmt.Println("scHash : ", scHash)
    54  
    55  	client, err := rpc.Dial(fmt.Sprintf("http://%s:%d", ip, port))
    56  	if err != nil {
    57  		fmt.Println("rpc.Dial err", err)
    58  		return
    59  	}
    60  	var result string
    61  	err = client.Call(&result, "net_version")
    62  	if err != nil {
    63  		fmt.Println("get chain id fail", err)
    64  		return
    65  	}
    66  	fmt.Printf("chainId: %s\n", result)
    67  	chainID, err := strconv.ParseInt(result, 10, 64)
    68  	if err != nil {
    69  		fmt.Println("parse chain id fail", err)
    70  		return
    71  	}
    72  	if operType == 5 {
    73  		// remove side chain
    74  		amount := big.NewInt(0)
    75  		fromAddress := nodeAddressList[1]
    76  		toAddress := scAddressList[0]
    77  		pKey := pkList[1]
    78  
    79  		dataStr := "ufo:1:event:proposal:proposal_type:5:vlcnt:2:schash:"
    80  		dataStr += scHash
    81  		txhash := sendTx(client, chainID, fromAddress, pKey, toAddress, amount, []byte(dataStr))
    82  
    83  		amount = big.NewInt(0)
    84  		fromAddress = nodeAddressList[0]
    85  		toAddress = scAddressList[0]
    86  		pKey = pkList[0]
    87  		// here only need one declare, because the tally of this address is larger than 2/3 +1
    88  		dataStr = "ufo:1:event:declare:decision:yes:hash:"
    89  		dataStr += txhash
    90  		txhash = sendTx(client, chainID, fromAddress, pKey, toAddress, amount, []byte(dataStr))
    91  		fmt.Println("declare res hash : ", txhash)
    92  	} else if operType == 4 {
    93  		// add side chain
    94  		amount := big.NewInt(0)
    95  		fromAddress := nodeAddressList[1]
    96  		toAddress := scAddressList[0]
    97  		pKey := pkList[1]
    98  
    99  		dataStr := "ufo:1:event:proposal:proposal_type:4:vlcnt:2:sccount:1:screward:50:schash:"
   100  		dataStr += scHash
   101  		txhash := sendTx(client, chainID, fromAddress, pKey, toAddress, amount, []byte(dataStr))
   102  
   103  		amount = big.NewInt(0)
   104  		fromAddress = nodeAddressList[0]
   105  		toAddress = scAddressList[0]
   106  		pKey = pkList[0]
   107  
   108  		dataStr = "ufo:1:event:declare:decision:yes:hash:"
   109  		dataStr += txhash
   110  		txhash = sendTx(client, chainID, fromAddress, pKey, toAddress, amount, []byte(dataStr))
   111  
   112  		fmt.Println("declare res hash : ", txhash)
   113  		// set side chain coinbase
   114  		for i := 0; i < 36; i++ {
   115  
   116  			amount = big.NewInt(10)
   117  			fromAddress = nodeAddressList[i]
   118  			toAddress = scAddressList[i]
   119  			pKey = pkList[i]
   120  			dataStr = "ufo:1:sc:setcb:"
   121  			dataStr += scHash
   122  
   123  			txhash = sendTx(client, chainID, fromAddress, pKey, toAddress, amount, []byte(dataStr))
   124  
   125  		}
   126  
   127  	}
   128  }
   129  
   130  func sendTx(client *rpc.Client, chainID int64, fromAddress string, pKey string, toAddress string, amount *big.Int, data []byte) string {
   131  	var result string
   132  
   133  	// start to send transaction
   134  	// get nonce
   135  	err := client.Call(&result, "eth_getTransactionCount", fromAddress, "latest")
   136  	if err != nil {
   137  		fmt.Println("client.nonce err", err)
   138  		return ""
   139  	}
   140  	fmt.Printf("nonce : %s\n", result)
   141  	nonce, err := strconv.ParseInt(result[2:], 16, 64)
   142  	if err != nil {
   143  		fmt.Println("nonce parse fail", err)
   144  		return ""
   145  	}
   146  	fmt.Printf("nonce : %d\n", nonce)
   147  
   148  	to := common.HexToAddress(toAddress)
   149  	privateKey, err := crypto.HexToECDSA(pKey)
   150  	if err != nil {
   151  		fmt.Println("create private key err :", err)
   152  		return ""
   153  	}
   154  
   155  	value := new(big.Int).Mul(big.NewInt(1e+18), amount)
   156  	fmt.Println("value :", value)
   157  	tx := types.NewTransaction(uint64(nonce), to, value, uint64(2000000), big.NewInt(2010000), data)
   158  
   159  	signedTx, err := types.SignTx(tx, types.NewEIP155Signer(big.NewInt(chainID)), privateKey)
   160  	txData, err := rlp.EncodeToBytes(signedTx)
   161  	if err != nil {
   162  		fmt.Println("rlp Encode fail", err)
   163  		return ""
   164  	}
   165  	err = client.Call(&result, "eth_sendRawTransaction", common.ToHex(txData))
   166  	if err != nil {
   167  		fmt.Println("send Transaction fail", err)
   168  		return ""
   169  	}
   170  	fmt.Println("result txHash:", result)
   171  	return result
   172  }