示例#1
0
func TestBlockchainTail_03(t *testing.T) {

	bq := BlockchainTail{}
	bq.Init()

	h1 := cipher.SumSHA256(secp256k1.RandByte(888))
	b1 := BlockBase{Hash: h1, Seqno: 1} // OK to leave '.sig' empty

	r1 := bq.try_append_to_BlockchainTail(&b1)
	if r1 != 0 {
		t.Log("BlockchainTail::try_append_to_BlockchainTail(): initial insert failed.")
		t.Fail()
	}
	if bq.GetNextSeqNo() != b1.Seqno+1 {
		t.Log("BlockchainTail::GetNextSeqNo() failed.")
		t.Fail()
	}

	r1dup := bq.try_append_to_BlockchainTail(&b1)
	if r1dup != 1 {
		t.Log("BlockchainTail::try_append_to_BlockchainTail(): duplicate hash not detected.")
		t.Fail()
	}

	h2 := cipher.SumSHA256(secp256k1.RandByte(888))
	b2 := BlockBase{Hash: h2, Seqno: 2} // OK to leave '.sig' empty

	r2 := bq.try_append_to_BlockchainTail(&b2)
	if r2 != 0 {
		t.Log("BlockchainTail::try_append_to_BlockchainTail(): next insert failed.")
		t.Fail()
	}
	if bq.GetNextSeqNo() != b2.Seqno+1 {
		t.Log("BlockchainTail::GetNextSeqNo() failed.")
		t.Fail()
	}

	h3 := cipher.SumSHA256(secp256k1.RandByte(888))
	b3 := BlockBase{Hash: h3, Seqno: 0} // OK to leave '.sig' empty

	r3 := bq.try_append_to_BlockchainTail(&b3)
	if r3 != 2 {
		t.Log("BlockchainTail::try_append_to_BlockchainTail(): low seqno not detected. ret=", r3)
		t.Fail()
	}

	b3.Seqno = 4
	r4 := bq.try_append_to_BlockchainTail(&b3)
	if r4 != 3 {
		t.Log("BlockchainTail::try_append_to_BlockchainTail(): high seqno not detected.")
		t.Fail()
	}

}
示例#2
0
文件: chain.go 项目: skycoin/skycoin
//applies block against the current head
func (bc *BlockChain) ApplyBlock(block Block) error {
	//do time check
	//do prevhash check
	//check body hash
	//check BkSeq

	if block.Head.BkSeq != bc.Head().Head.BkSeq+1 {
		return errors.New("block sequence is out of order")
	}
	if block.Head.PrevHash != bc.Head().Head.Hash() {
		return errors.New("block PrevHash does not match current head")
	}
	if block.Head.Time < bc.Head().Head.Time {
		return errors.New("block time invalid")
	}
	if block.Head.BodyHash != cipher.SumSHA256(block.Body) {
		return errors.New("block body hash is wrong")
	}

	if err := bc.VerifyBlockSignature(block); err != nil {
		return errors.New("block signature check failed")
	}

	//block is valid, apply
	bc.Blocks = append(bc.Blocks, block)
	return nil
}
示例#3
0
//test signatures
func TestCrypto2(t *testing.T) {
	a := "5a42c0643bdb465d90bf673b99c14f5fa02db71513249d904573d2b8b63d353d"
	b, err := hex.DecodeString(a)
	if err != nil {
		t.Fatal(err)
	}

	if len(b) != 32 {
		t.Fatal()
	}

	seckey := cipher.NewSecKey(b)
	pubkey := cipher.PubKeyFromSecKey(seckey)

	addr := cipher.AddressFromPubKey(pubkey)
	_ = addr

	test := []byte("test message")
	hash := cipher.SumSHA256(test)
	err = cipher.TestSecKeyHash(seckey, hash)
	if err != nil {
		t.Fatal()
	}

}
示例#4
0
func TestBlockchainTail_02(t *testing.T) {

	bq := BlockchainTail{}
	bq.Init()

	// Use more than configured length to ensure some elements are
	// removed:
	n := Cfg_blockchain_tail_length * 2

	for i := 0; i < n; i++ {
		x := secp256k1.RandByte(888) // Random data.
		h := cipher.SumSHA256(x)     // Its hash.

		b := BlockBase{Hash: h, Seqno: uint64(i)} // OK to leave '.sig' empty

		bq.append_nocheck(&b)
	}

	if len(bq.blockPtr_slice) != Cfg_blockchain_tail_length {
		t.Log("BlockchainTail::append_nocheck() incorrect append or remove.")
		t.Fail()
	}

	if !bq.is_consistent() {
		t.Log("BlockchainTail::is_consistent()")
		t.Fail()
	}
}
示例#5
0
func TestBlockStat_01(t *testing.T) {
	bs := BlockStat{}
	bs.Init()

	_, seckey := cipher.GenerateKeyPair()
	hash := cipher.SumSHA256(secp256k1.RandByte(888))
	sig := cipher.SignHash(hash, seckey)

	var r int = -1

	r = bs.try_add_hash_and_sig(hash, cipher.Sig{})
	if r != 4 {
		t.Log("BlockStat::try_add_hash_and_sig() failed to detect invalid signature.")
		t.Fail()
	}
	r = bs.try_add_hash_and_sig(cipher.SHA256{}, sig)
	if r != 4 {
		t.Log("BlockStat::try_add_hash_and_sig() failed to detect invalid hash and signature.")
		t.Fail()
	}
	r = bs.try_add_hash_and_sig(cipher.SHA256{}, cipher.Sig{})
	if r != 4 {
		t.Log("BlockStat::try_add_hash_and_sig() failed to detect invalid hash and signature.")
		t.Fail()
	}

	//signer_pubkey, err := cipher.PubKeyFromSig(cipher.Sig{}, cipher.SHA256{})
	//if err != nil {
	//fmt.Printf("Got pubkey='%s' from all-zero sig and all-zero hash.\n", signer_pubkey.Hex())
	//}

	bs.frozen = true
	r2 := bs.try_add_hash_and_sig(hash, sig)
	if r2 != 3 {
		t.Log("BlockStat::try_add_hash_and_sig() failed to detect frozen.")
		t.Fail()
	}
	bs.frozen = false

	r3 := bs.try_add_hash_and_sig(hash, sig)
	if r3 != 0 {
		t.Log("BlockStat::try_add_hash_and_sig() failed to add.")
		t.Fail()
	}

	sig2 := cipher.SignHash(hash, seckey) // Redo signing.
	r4 := bs.try_add_hash_and_sig(hash, sig2)
	if r4 != 1 {
		t.Log("BlockStat::try_add_hash_and_sig() failed to detect duplicate (hash,pubkey).")
		t.Fail()
	}

	r5 := bs.try_add_hash_and_sig(hash, sig)
	if r5 != 1 {
		t.Log("BlockStat::try_add_hash_and_sig() failed to detect duplicate (hash,sig).")
		t.Fail()
	}

}
示例#6
0
func makeUxBodyWithSecret(t *testing.T) (coin.UxBody, cipher.SecKey) {
	p, s := cipher.GenerateKeyPair()
	return coin.UxBody{
		SrcTransaction: cipher.SumSHA256(randBytes(t, 128)),
		Address:        cipher.AddressFromPubKey(p),
		Coins:          10e6,
		Hours:          100,
	}, s
}
示例#7
0
func NewEmptySimpleWallet() Wallet {
	idHash := cipher.SumSHA256(secp256k1.RandByte(256))
	id := WalletID(hex.EncodeToString(idHash[:16]))
	return &SimpleWallet{
		Filename: NewWalletFilename(id),
		Entries:  WalletEntries{},
		ID:       id,
	}
}
示例#8
0
文件: chain.go 项目: skycoin/skycoin
//creates new block
func (bc *BlockChain) NewBlock(seckey cipher.SecKey, blockTime uint64, data []byte) Block {
	var b Block
	b.Head.Time = blockTime
	b.Head.BkSeq = bc.Head().Head.BkSeq + 1
	b.Head.PrevHash = bc.Head().Head.Hash()
	b.Head.BodyHash = cipher.SumSHA256(data)
	b.Body = data
	bc.SignBlock(seckey, &b)
	return b
}
示例#9
0
func createUnconfirmedTxn() visor.UnconfirmedTxn {
	now := util.Now()
	return visor.UnconfirmedTxn{
		Txn: coin.Transaction{
			Head: coin.TransactionHeader{
				Hash: cipher.SumSHA256([]byte("cascas")),
			},
		},
		Received:  now,
		Checked:   now,
		Announced: util.ZeroTime(),
	}
}
示例#10
0
func TestBlockStat_02(t *testing.T) {
	bs := BlockStat{}
	bs.Init()

	hash1 := cipher.SumSHA256(secp256k1.RandByte(888))
	n1 := 3

	for i := 0; i < n1; i++ {
		_, seckey := cipher.GenerateKeyPair()
		sig := cipher.SignHash(hash1, seckey)
		bs.try_add_hash_and_sig(hash1, sig)
	}

	hash2 := cipher.SumSHA256(secp256k1.RandByte(888))
	n2 := 2

	for i := 0; i < n2; i++ {
		_, seckey := cipher.GenerateKeyPair()
		sig := cipher.SignHash(hash2, seckey)
		bs.try_add_hash_and_sig(hash2, sig)
	}

	hash3 := cipher.SumSHA256(secp256k1.RandByte(888))
	n3 := 1

	for i := 0; i < n3; i++ {
		_, seckey := cipher.GenerateKeyPair()
		sig := cipher.SignHash(hash3, seckey)
		bs.try_add_hash_and_sig(hash3, sig)
	}

	best_hash, _, _ := bs.GetBestHashPubkeySig()
	if best_hash != hash1 {
		t.Log("BlockStat::try_add_hash_and_sig() or BlockStat::GetBestHashPubkeySig() issue.")
		t.Fail()
	}
}
示例#11
0
//Generate Deterministic Wallet
//generates a random seed if seed is ""
func NewWallet(seed string) Wallet {

	//if seed is blank, generate a new seed
	if seed == "" {
		seed_raw := cipher.SumSHA256(secp256k1.RandByte(64))
		seed = hex.EncodeToString(seed_raw[:])
	}

	pub, sec := cipher.GenerateDeterministicKeyPair([]byte(seed[:]))
	return Wallet{
		Meta: map[string]string{
			"filename": NewWalletFilename(),
			"seed":     seed,
			"type":     "deterministic",
			"coin":     "sky"},
		Entry: NewWalletEntryFromKeypair(pub, sec),
	}
}
示例#12
0
func TestGetTxnsMessageProcess(t *testing.T) {
	v, _ := setupVisor()
	d, _ := newVisorDaemon(v)
	defer shutdown(d)
	gc := setupExistingPool(d.Pool)
	p := d.Pool
	go p.Pool.ConnectionWriteLoop(gc)
	tx := createUnconfirmedTxn()
	tx.Txn.Head.Hash = cipher.SumSHA256([]byte("asdadwadwada"))
	txns := []cipher.SHA256{tx.Txn.Hash()}
	m := NewGetTxnsMessage(txns)
	m.c = messageContext(addr)
	go p.Pool.ConnectionWriteLoop(m.c.Conn)
	defer m.c.Conn.Close()

	// We don't have any to reply with
	assert.NotPanics(t, func() { m.Process(d) })
	assert.True(t, m.c.Conn.LastSent.IsZero())

	// Disabled, nothing should happen
	d.Visor.Visor.Unconfirmed.Txns[tx.Txn.Hash()] = tx
	d.Visor.Config.Disabled = true
	assert.NotPanics(t, func() { m.Process(d) })
	assert.True(t, m.c.Conn.LastSent.IsZero())

	// We have some to reply with
	d.Visor.Config.Disabled = false
	assert.NotPanics(t, func() { m.Process(d) })
	wait()
	assert.Equal(t, len(p.Pool.SendResults), 1)
	if len(p.Pool.SendResults) == 0 {
		t.Fatal("SendResults empty, would block")
	}
	sr := <-p.Pool.SendResults
	assert.Equal(t, sr.Connection, m.c.Conn)
	assert.Nil(t, sr.Error)
	_, ok := sr.Message.(*GiveTxnsMessage)
	assert.True(t, ok)
	assert.False(t, m.c.Conn.LastSent.IsZero())
	// Should not be broadcast to others
	assert.True(t, gc.LastSent.IsZero())
}
示例#13
0
// NewWallet generates Deterministic Wallet
// generates a random seed if seed is ""
func NewWallet(wltName string, opts ...Option) Wallet {
	seedRaw := cipher.SumSHA256(secp256k1.RandByte(64))
	seed := hex.EncodeToString(seedRaw[:])

	w := Wallet{
		Meta: map[string]string{
			"filename": wltName,
			"version":  version,
			"label":    "",
			"seed":     seed,
			"lastSeed": seed,
			"tm":       fmt.Sprintf("%v", time.Now().Unix()),
			"type":     "deterministic",
			"coin":     "sky"},
	}

	for _, opt := range opts {
		opt(&w)
	}

	return w
}
示例#14
0
func main() {
	registerFlags()
	parseFlags()

	w := Wallet{
		Meta:    make(map[string]string), //map[string]string
		Entries: make([]KeyEntry, genCount),
	}

	if BitcoinAddress == false {
		w.Meta = map[string]string{"coin": "skycoin"}
	} else {
		w.Meta = map[string]string{"coin": "bitcoin"}
	}

	if seed == "" { //generate a new seed, as hex string
		seed = cipher.SumSHA256(cipher.RandByte(1024)).Hex()
	}

	w.Meta["seed"] = seed

	seckeys := cipher.GenerateDeterministicKeyPairs([]byte(seed), genCount)

	for i, sec := range seckeys {
		pub := cipher.PubKeyFromSecKey(sec)
		w.Entries[i] = getKeyEntry(pub, sec)
	}

	output, err := json.MarshalIndent(w, "", "    ")
	if err != nil {
		fmt.Printf("Error formating wallet to JSON. Error : %s\n", err.Error())
		return
	}
	fmt.Printf("%s\n", string(output))

}
示例#15
0
// Hashes only the Transaction Inputs & Outputs
// This is what is signed
// Client hashes the inner hash with hash of output being spent and signs it with private key
func (self *Transaction) HashInner() cipher.SHA256 {
	b1 := encoder.Serialize(self.In)
	b2 := encoder.Serialize(self.Out)
	b3 := append(b1, b2...)
	return cipher.SumSHA256(b3)
}
示例#16
0
// Returns the encoded size and the hash of it (avoids duplicate encoding)
func (self *Transaction) SizeHash() (int, cipher.SHA256) {
	b := self.Serialize()
	return len(b), cipher.SumSHA256(b)
}
示例#17
0
// Hashes an entire Transaction struct, including the TransactionHeader
func (self *Transaction) Hash() cipher.SHA256 {
	b := self.Serialize()
	return cipher.SumSHA256(b)
}
示例#18
0
func randSHA256() cipher.SHA256 {
	b := make([]byte, 128)
	rand.Read(b)
	return cipher.SumSHA256(b)
}
示例#19
0
func (self *DeterministicWalletSeed) toWalletID() WalletID {
	// Uses the first 16 bytes of SHA256(seed) as id
	shaid := cipher.SumSHA256(self[:])
	return WalletID(hex.EncodeToString(shaid[:16]))
}
示例#20
0
func randSHA256(t *testing.T) cipher.SHA256 {
	return cipher.SumSHA256(randBytes(t, 128))
}
示例#21
0
func TestVisorResendTransaction(t *testing.T) {
	defer cleanupVisor()
	defer gnet.EraseMessages()
	p, gc := setupPool()
	go p.Pool.ConnectionWriteLoop(gc)
	vc, mv := setupVisor()
	v := NewVisor(vc)
	assert.Equal(t, len(v.Visor.Unconfirmed.Txns), 0)

	// Nothing should happen if txn unknown
	v.ResendTransaction(cipher.SumSHA256([]byte("garbage")), p)
	wait()
	assert.Equal(t, len(p.Pool.SendResults), 0)
	assert.Equal(t, len(p.Pool.SendResults), 0)
	assert.Equal(t, len(v.Visor.Unconfirmed.Txns), 0)
	assert.True(t, gc.LastSent.IsZero())

	// give the visor some coins, and make a spend to add a txn
	assert.Nil(t, transferCoins(mv, v.Visor))
	tx, err := v.Spend(v.Visor.Wallets[0].GetID(), wallet.Balance{10e6, 0}, 0,
		mv.Wallets[0].GetAddresses()[0], p)
	assert.Nil(t, err)
	wait()
	assert.Equal(t, len(p.Pool.SendResults), 1)
	if len(p.Pool.SendResults) == 0 {
		t.Fatal("SendResults empty, would block")
	}
	<-p.Pool.SendResults
	assert.Equal(t, len(v.Visor.Unconfirmed.Txns), 1)
	h := tx.Hash()
	ut := v.Visor.Unconfirmed.Txns[h]
	ut.Announced = util.ZeroTime()
	v.Visor.Unconfirmed.Txns[h] = ut
	assert.True(t, v.Visor.Unconfirmed.Txns[h].Announced.IsZero())
	// Reset the sent timer since we made a successful spend
	gc.LastSent = util.ZeroTime()

	// Nothing should send if disabled
	v.Config.Disabled = true
	v.ResendTransaction(h, p)
	wait()
	assert.Equal(t, len(p.Pool.SendResults), 0)
	ann := v.Visor.Unconfirmed.Txns[h].Announced
	assert.True(t, ann.IsZero())
	assert.True(t, gc.LastSent.IsZero())

	// Should have resent
	v.Config.Disabled = false
	gc.Conn = NewDummyConn(addr)
	v.ResendTransaction(h, p)
	wait()
	assert.Equal(t, len(p.Pool.SendResults), 1)
	if len(p.Pool.SendResults) == 0 {
		t.Fatal("SendResults empty, would block")
	}
	sr := <-p.Pool.SendResults
	assert.Nil(t, sr.Error)
	assert.Equal(t, sr.Connection, gc)
	_, ok := sr.Message.(*GiveTxnsMessage)
	assert.True(t, ok)
	ann = v.Visor.Unconfirmed.Txns[h].Announced
	// Announced state should not be updated until we process it
	assert.True(t, ann.IsZero())
	assert.False(t, gc.LastSent.IsZero())
}
示例#22
0
// Returns hash of UxBody + UxHead
func (self *UxOut) SnapshotHash() cipher.SHA256 {
	b1 := encoder.Serialize(self.Body) //body
	b2 := encoder.Serialize(self.Head) //time, bkseq
	b3 := append(b1, b2...)
	return cipher.SumSHA256(b3)
}
示例#23
0
func (self *BlockHeader) Hash() cipher.SHA256 {
	b1 := encoder.Serialize(*self)
	return cipher.SumSHA256(b1)
}
示例#24
0
////////////////////////////////////////////////////////////////////////////////
//
// main
//
////////////////////////////////////////////////////////////////////////////////
func main() {

	cmd_line_args_process()

	// PERFORMANCE:
	cipher.DebugLevel1 = false
	cipher.DebugLevel2 = false

	var X []*MinimalConnectionManager

	var hack_global_seqno uint64 = 0

	seed := "hdhdhdkjashfy7273"
	_, SecKeyArray :=
		cipher.GenerateDeterministicKeyPairsSeed([]byte(seed), Cfg_simu_num_node)

	for i := 0; i < Cfg_simu_num_node; i++ {
		cm := MinimalConnectionManager{}
		// Reason for mutual registration: (1) when conn man receives
		// messages, it needs to notify the node; (2) when node has
		// processed a mesage, it might need to use conn man to send
		// some data out.
		nodePtr := consensus.NewConsensusParticipantPtr(&cm)
		s := SecKeyArray[i]
		nodePtr.SetPubkeySeckey(cipher.PubKeyFromSecKey(s), s)

		cm.theNodePtr = nodePtr

		X = append(X, &cm)
	}
	if false {
		fmt.Printf("Got %d nodes\n", len(X))
	}

	if Cfg_simu_topology_is_random {

		fmt.Printf("CONFIG Topology: connecting %d nodes randomly with approx"+
			" %d  nearest-neighbors in and approx %d nearest-neighbors out.\n",
			Cfg_simu_num_node, Cfg_simu_fanout_per_node,
			Cfg_simu_fanout_per_node)

		for i, _ := range X {
			cm := X[i]
			for g := 0; g < Cfg_simu_fanout_per_node; g++ {
				j := mathrand.Intn(Cfg_simu_num_node)
				if i != j {
					cm.RegisterPublisher(X[j])
				}
			}
		}
	} else {

		fmt.Printf("CONFIG Topology: connecting %d nodes via one (thick)"+
			" circle with approx %d  nearest-neighbors in and approx %d "+
			"nearest-neighbors out.\n",
			Cfg_simu_num_node, Cfg_simu_fanout_per_node,
			Cfg_simu_fanout_per_node)

		n := len(X)
		for i := 0; i < n; i++ {

			cm := X[i]

			c_left := int(Cfg_simu_fanout_per_node / 2)
			c_right := Cfg_simu_fanout_per_node - c_left

			for c := 0; c < c_left; c++ {
				j := (i - 1 - c + n) % n
				cm.RegisterPublisher(X[j])
			}

			for c := 0; c < c_right; c++ {
				j := (i + 1 + c) % n
				cm.RegisterPublisher(X[j])
			}
		}
	}

	// Connect. PROD: This should request connections. The
	// connections can be accepted, rejected or never answered. Such
	// replies are asynchronous. SIMU: we connect synchronously.
	for i, _ := range X {
		X[i].RequestConnectionToAllMyPublisher()
	}

	global_seqno2h := make(map[uint64]cipher.SHA256)
	global_seqno2h_alt := make(map[uint64]cipher.SHA256)

	iter := 0
	block_round := 0
	done_processing_messages := false
	for ; iter < Cfg_simu_num_iter; iter++ {

		if true {
			if block_round < Cfg_simu_num_block_round {

				// NOTE: Propagating blocks from here is a
				// simplification/HACK: it implies that we have
				// knowledge of when messaging due to previous
				// activity (blocks and connections) has
				// stopped. Again, we make blocks from here for
				// debugging and testing only.

				//x := secp256k1.RandByte(888) // Random data in SIMU.
				x := make([]byte, 888)
				mathrand.Read(x)

				h := cipher.SumSHA256(x) // Its hash.

				//x_alt := secp256k1.RandByte(888) // Random data in SIMU.
				x_alt := make([]byte, 888)
				mathrand.Read(x)
				h_alt := cipher.SumSHA256(x_alt) // Its hash.

				global_seqno2h[hack_global_seqno] = h
				global_seqno2h_alt[hack_global_seqno] = h_alt

				indices := get_random_index_subset(Cfg_simu_num_node,
					Cfg_simu_num_blockmaker)

				if Cfg_debug_show_block_maker {
					fmt.Printf("block_round=%d, Random indices of block-"+
						"makers: %v\n", block_round, indices)
				}

				n_forkers := int(Cfg_simu_prob_malicious * float64(len(indices)))

				for i := 0; i < len(indices); i++ {
					// TODO: Have many nodes send same block, and a few nodes
					// send a different block. Research the conditions under
					// which the block published by the majority would
					// dominate the other one.
					index := indices[i]
					nodePtr := X[index].GetNode()

					malicious := (i < n_forkers)
					duplicate := (mathrand.Float64() < Cfg_simu_prob_duplicate)

					ph := &h
					if malicious {
						ph = &h_alt
					}

					rep := 1
					if duplicate {
						rep = 2
					}

					//
					// WARNING: In a reslistic simulation, one would
					// need to remove the assumption of knowing global
					// properties such as 'hack_global_seqno'
					//
					if malicious {
						fmt.Printf(">>>>>> NODE (index,pubkey)=(%d,%s) is"+
							" publishing ALTERNATIVE block\n", index,
							nodePtr.Pubkey.Hex()[:8])
					}

					for j := 0; j < rep; j++ {
						// Signing same hash multipe times produces different
						// signatures (for a good reason). We do it
						// here to test if malicious re-publishing is
						// detected properly.
						propagate_hash_from_node(*ph, nodePtr, true,
							hack_global_seqno)
					}
				}

				hack_global_seqno += 1
				block_round += 1
			} else {
				done_processing_messages = true
				break // <<<<<<<<
			}
		}
	}

	zzz := "done"
	if !done_processing_messages {
		zzz = "***NOT done***"
	}

	fmt.Printf("Done (i) making Blocks, %s (ii) processing responses."+
		" See stats on the next few lines. Used iterations=%d, unused"+
		" iterations=%d. Exiting the event loop now.\n",
		zzz, iter, Cfg_simu_num_iter-iter)

	print_stat(X, iter)

	if Cfg_debug_node_final_state {
		for i, _ := range X {
			fmt.Printf("FILE_FinalState.txt|NODE i=%d ", i)
			X[i].GetNode().Print()
			fmt.Printf("\n")
		}
	}

	if Cfg_debug_node_summary {
		Simulate_compare_node_StateQueue(X, global_seqno2h, global_seqno2h_alt)
	}
}
示例#25
0
////////////////////////////////////////////////////////////////////////////////
//
// main
//
////////////////////////////////////////////////////////////////////////////////
func main() {

	var X []*MinimalConnectionManager

	// Create nodes
	for i := 0; i < Cfg_simu_num_node; i++ {
		cm := MinimalConnectionManager{}
		// Reason for mutual registration: (1) when conn man receives
		// messages, it needs to notify the node; (2) when node has
		// processed a mesage, it might need to use conn man to send
		// some data out.
		nodePtr := consensus.NewConsensusParticipantPtr(&cm)
		cm.theNodePtr = nodePtr

		X = append(X, &cm)
	}

	// Contemplate connecting nodes into a thick circle:
	n := len(X)
	for i := 0; i < n; i++ {

		cm := X[i]

		c_left := int(Cfg_simu_fanout_per_node / 2)
		c_right := Cfg_simu_fanout_per_node - c_left

		for c := 0; c < c_left; c++ {
			j := (i - 1 - c + n) % n
			cm.RegisterPublisher(X[j])
		}

		for c := 0; c < c_right; c++ {
			j := (i + 1 + c) % n
			cm.RegisterPublisher(X[j])
		}
	}

	//
	// Request connections
	//
	for i := 0; i < n; i++ {
		X[i].RequestConnectionToAllMyPublisher()
	}

	{
		//
		// Choose a node to be a block-maker
		//
		index := mathrand.Intn(Cfg_simu_num_node)
		nodePtr := X[index].GetNode()

		//
		// Make a block (actually, only a header)
		//
		x := secp256k1.RandByte(888) // Random data.
		h := cipher.SumSHA256(x)     // Its hash.
		b := consensus.BlockBase{}
		b.Init(
			nodePtr.SignatureOf(h),
			h,
			0)

		//
		// Send it to subscribers. The subscribers are also publishers;
		// they send (forward, to be exact) the header to thire respective
		// listeners etc.
		//
		nodePtr.OnBlockHeaderArrived(&b)
	}

	//
	// Print the state of each node for a review or debugging.
	//
	for i, _ := range X {
		fmt.Printf("FILE_FinalState.txt|NODE i=%d ", i)
		X[i].GetNode().Print()
		fmt.Printf("\n")
	}

}
示例#26
0
func (self *UxBody) Hash() cipher.SHA256 {
	return cipher.SumSHA256(encoder.Serialize(self))
}
示例#27
0
func NewDeterministicWalletSeed() DeterministicWalletSeed {
	seed := cipher.SumSHA256(secp256k1.RandByte(DeterministicSeedLength))
	return DeterministicWalletSeed(seed)
}
示例#28
0
文件: chain.go 项目: skycoin/skycoin
func PubKeyHash(pubkey cipher.PubKey) cipher.SHA256 {
	return cipher.SumSHA256(pubkey[:])
}
示例#29
0
文件: block.go 项目: skycoin/skycoin
// Hash return hash of block header
func (bh BlockHeader) Hash() cipher.SHA256 {
	b1 := encoder.Serialize(bh)
	return cipher.SumSHA256(b1)
}