From b1a2c9a8dd741810645fb91b5c26af31c391172c Mon Sep 17 00:00:00 2001 From: gabrielfnayres Date: Tue, 21 May 2024 08:52:55 -0300 Subject: [PATCH 01/10] setting the Block and Blockchain structure also with a simple hash function implemented --- internal/blockchain/block.go | 23 ++++++++++++++++++++++- internal/blockchain/blockchain.go | 5 +++++ 2 files changed, 27 insertions(+), 1 deletion(-) create mode 100644 internal/blockchain/blockchain.go diff --git a/internal/blockchain/block.go b/internal/blockchain/block.go index bcf7467..b04eb7d 100644 --- a/internal/blockchain/block.go +++ b/internal/blockchain/block.go @@ -1 +1,22 @@ -package blockchain +package main + +import ( + "bytes" + "crypto/sha256" + "strconv" +) + +type Block struct { + Timestamp int64 + Data []byte // Transactions + prevBlockHash []byte + Hash []byte + Counter uint64 // Nonce +} + +func (b *Block) SetHash() { + timestamp := []byte(strconv.FormatInt(b.Timestamp, 10)) + headers := bytes.Join([][]byte{b.prevBlockHash, b.Data, timestamp}, []byte{}) + hash := sha256.Sum256(headers) + b.Hash = hash[:] +} diff --git a/internal/blockchain/blockchain.go b/internal/blockchain/blockchain.go new file mode 100644 index 0000000..cd14191 --- /dev/null +++ b/internal/blockchain/blockchain.go @@ -0,0 +1,5 @@ +package main + +type Blockchain struct { + blocks []*Block +} From 0f65aa32c1788531459389d26ddf784c58b42558 Mon Sep 17 00:00:00 2001 From: gabrielfnayres Date: Tue, 21 May 2024 08:54:24 -0300 Subject: [PATCH 02/10] Content Validation Function implemented --- internal/blockchain/proof_of_work.go | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 internal/blockchain/proof_of_work.go diff --git a/internal/blockchain/proof_of_work.go b/internal/blockchain/proof_of_work.go new file mode 100644 index 0000000..d8d5730 --- /dev/null +++ b/internal/blockchain/proof_of_work.go @@ -0,0 +1,20 @@ +package main + +import ( + "math/rand" + "strconv" + "time" +) + +//  T is the target value when using a proof of work algorithm +func GenerateT() string { + rand.New(rand.NewSource(time.Now().UnixNano())) + + prefix := rand.Intn(90) + 10 + + suffix := rand.Intn(10000000) + + T := strconv.Itoa(prefix) + strconv.Itoa(suffix) + + return T +} From 5aae8826285b2925846516365ee1c993ea85dcdb Mon Sep 17 00:00:00 2001 From: gabrielfnayres Date: Tue, 21 May 2024 09:51:54 -0300 Subject: [PATCH 03/10] Input Contribution Function Implemented --- internal/blockchain/proof_of_work.go | 52 +++++++++++++++++++++++----- 1 file changed, 43 insertions(+), 9 deletions(-) diff --git a/internal/blockchain/proof_of_work.go b/internal/blockchain/proof_of_work.go index d8d5730..d140c22 100644 --- a/internal/blockchain/proof_of_work.go +++ b/internal/blockchain/proof_of_work.go @@ -1,20 +1,54 @@ package main import ( - "math/rand" - "strconv" + "fmt" + "math/big" + "reflect" "time" ) -//  T is the target value when using a proof of work algorithm -func GenerateT() string { - rand.New(rand.NewSource(time.Now().UnixNano())) +type Receive func() string +type Input func() string - prefix := rand.Intn(90) + 10 +type ProofOfWork struct { + block *Block + T big.Int +} + +// Simple Content Validation Predicate implementation from backbone protocol +func ContentValidatePredicate(x *Blockchain) bool { + + if len(x.blocks) == 0 { + return false + } + + for i := range x.blocks { + if i == 0 { + continue + } + if reflect.DeepEqual(x.blocks[i].Hash, x.blocks[i-1].Hash) { + return false + } + } + return true +} + +func InputContributionFunction(data []byte, cr *Blockchain, round int, input Input, receive Receive) { + + input_data := input() + receive_data := receive() + + concat_data := input_data + receive_data - suffix := rand.Intn(10000000) + // creating new block - T := strconv.Itoa(prefix) + strconv.Itoa(suffix) + newBlock := &Block{time.Now().Unix(), []byte(concat_data), cr.blocks[len(cr.blocks)-1].Hash, []byte{}, round} + cr.blocks = append(cr.blocks, newBlock) - return T + if !ContentValidatePredicate(cr) { + fmt.Println("Content Validation Failed") + cr.blocks = cr.blocks[:len(cr.blocks)-1] + } else { + fmt.Println("Content Validation Passed") + } } From 2575feea594dddcb5cf8eecafe8540c7428727cb Mon Sep 17 00:00:00 2001 From: gabrielfnayres Date: Tue, 21 May 2024 09:53:06 -0300 Subject: [PATCH 04/10] now target type is int --- internal/blockchain/block.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/blockchain/block.go b/internal/blockchain/block.go index b04eb7d..231563a 100644 --- a/internal/blockchain/block.go +++ b/internal/blockchain/block.go @@ -11,7 +11,7 @@ type Block struct { Data []byte // Transactions prevBlockHash []byte Hash []byte - Counter uint64 // Nonce + Counter int // Nonce } func (b *Block) SetHash() { From 169abe8b0764a1f0728357e01505e10027c76f47 Mon Sep 17 00:00:00 2001 From: gabrielfnayres Date: Tue, 21 May 2024 10:14:51 -0300 Subject: [PATCH 05/10] Chain read function implemented --- internal/blockchain/proof_of_work.go | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/internal/blockchain/proof_of_work.go b/internal/blockchain/proof_of_work.go index d140c22..85fbd58 100644 --- a/internal/blockchain/proof_of_work.go +++ b/internal/blockchain/proof_of_work.go @@ -39,7 +39,6 @@ func InputContributionFunction(data []byte, cr *Blockchain, round int, input Inp receive_data := receive() concat_data := input_data + receive_data - // creating new block newBlock := &Block{time.Now().Unix(), []byte(concat_data), cr.blocks[len(cr.blocks)-1].Hash, []byte{}, round} @@ -52,3 +51,12 @@ func InputContributionFunction(data []byte, cr *Blockchain, round int, input Inp fmt.Println("Content Validation Passed") } } + +// Function to read the chain +func ChainReadFunction(c *Blockchain) string { + data := "" + for i := range c.blocks { + data += string(c.blocks[i].Data) + } + return data +} From 3cc3fbfba2ab25d1783920062600068a46291667 Mon Sep 17 00:00:00 2001 From: gabrielfnayres Date: Tue, 21 May 2024 10:48:23 -0300 Subject: [PATCH 06/10] reorganizing proof_of_work.go and separating it in two files --- internal/blockchain/proof_of_work.go | 52 ---------------------------- 1 file changed, 52 deletions(-) diff --git a/internal/blockchain/proof_of_work.go b/internal/blockchain/proof_of_work.go index 85fbd58..772ed17 100644 --- a/internal/blockchain/proof_of_work.go +++ b/internal/blockchain/proof_of_work.go @@ -1,62 +1,10 @@ package main import ( - "fmt" "math/big" - "reflect" - "time" ) -type Receive func() string -type Input func() string - type ProofOfWork struct { block *Block T big.Int } - -// Simple Content Validation Predicate implementation from backbone protocol -func ContentValidatePredicate(x *Blockchain) bool { - - if len(x.blocks) == 0 { - return false - } - - for i := range x.blocks { - if i == 0 { - continue - } - if reflect.DeepEqual(x.blocks[i].Hash, x.blocks[i-1].Hash) { - return false - } - } - return true -} - -func InputContributionFunction(data []byte, cr *Blockchain, round int, input Input, receive Receive) { - - input_data := input() - receive_data := receive() - - concat_data := input_data + receive_data - // creating new block - - newBlock := &Block{time.Now().Unix(), []byte(concat_data), cr.blocks[len(cr.blocks)-1].Hash, []byte{}, round} - cr.blocks = append(cr.blocks, newBlock) - - if !ContentValidatePredicate(cr) { - fmt.Println("Content Validation Failed") - cr.blocks = cr.blocks[:len(cr.blocks)-1] - } else { - fmt.Println("Content Validation Passed") - } -} - -// Function to read the chain -func ChainReadFunction(c *Blockchain) string { - data := "" - for i := range c.blocks { - data += string(c.blocks[i].Data) - } - return data -} From dfa3158c26d3a853c115872e944965b3014f8aac Mon Sep 17 00:00:00 2001 From: gabrielfnayres Date: Tue, 21 May 2024 10:50:28 -0300 Subject: [PATCH 07/10] validations separated from proof_of_work.go --- internal/blockchain/validantions.go | 67 +++++++++++++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 internal/blockchain/validantions.go diff --git a/internal/blockchain/validantions.go b/internal/blockchain/validantions.go new file mode 100644 index 0000000..708b11e --- /dev/null +++ b/internal/blockchain/validantions.go @@ -0,0 +1,67 @@ +package main + +import ( + "fmt" + "math/rand" + "reflect" + "time" +) + +type Receive func() string +type Input func() string + +// Simple Content Validation Predicate implementation from backbone protocol +func ContentValidatePredicate(x *Blockchain) bool { + + if len(x.blocks) == 0 { + return false + } + + for i := range x.blocks { + if i == 0 { + continue + } + if reflect.DeepEqual(x.blocks[i].Hash, x.blocks[i-1].Hash) { + return false + } + } + return true +} + +func InputContributionFunction(data []byte, cr *Blockchain, round int, input Input, receive Receive) { + + input_data := input() + receive_data := receive() + + concat_data := input_data + receive_data + // creating new block + + newBlock := &Block{time.Now().Unix(), []byte(concat_data), cr.blocks[len(cr.blocks)-1].Hash, []byte{}, round} + cr.blocks = append(cr.blocks, newBlock) + + if !ContentValidatePredicate(cr) { + fmt.Println("Content Validation Failed") + cr.blocks = cr.blocks[:len(cr.blocks)-1] + } else { + fmt.Println("Content Validation Passed") + } +} + +// Function to read the chain +func ChainReadFunction(c *Blockchain) string { + data := "" + for i := range c.blocks { + data += string(c.blocks[i].Data) + } + return data +} + +func ChainValidationPredicate(c *Blockchain) { + b := ContentValidatePredicate(c) + + if b && c != nil { + temp_chain := c + c.blocks[rand.Intn(len(c.blocks))].SetHash() + + } +} From e589afe5bcf4e7efc9d300ec6e19d9aabe655713 Mon Sep 17 00:00:00 2001 From: gabrielfnayres Date: Tue, 21 May 2024 11:47:19 -0300 Subject: [PATCH 08/10] implementing ValidateBlock and Chain Validation --- internal/blockchain/validantions.go | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/internal/blockchain/validantions.go b/internal/blockchain/validantions.go index 708b11e..fe70d26 100644 --- a/internal/blockchain/validantions.go +++ b/internal/blockchain/validantions.go @@ -2,7 +2,6 @@ package main import ( "fmt" - "math/rand" "reflect" "time" ) @@ -10,6 +9,10 @@ import ( type Receive func() string type Input func() string +func ValidateBlockPredicate(b *Block) bool { + +} + // Simple Content Validation Predicate implementation from backbone protocol func ContentValidatePredicate(x *Blockchain) bool { @@ -56,12 +59,18 @@ func ChainReadFunction(c *Blockchain) string { return data } -func ChainValidationPredicate(c *Blockchain) { +/*func ChainValidationPredicate(c *Blockchain) bool { b := ContentValidatePredicate(c) if b && c != nil { + index := rand.Intn(len(c.blocks)) temp_chain := c - c.blocks[rand.Intn(len(c.blocks))].SetHash() + c.blocks[index].SetHash() + for i := true; i; b = false{ + if + } } + return b } +*/ From 3bf75c2f12a5aa5a64103c62c9399c7e480a46a2 Mon Sep 17 00:00:00 2001 From: Nicholas Rodrigues <104515007+NicholasRodrigues@users.noreply.github.com> Date: Tue, 21 May 2024 15:55:46 -0300 Subject: [PATCH 09/10] fix: commenting ValidateBlock func --- internal/blockchain/validantions.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/internal/blockchain/validantions.go b/internal/blockchain/validantions.go index fe70d26..8807d35 100644 --- a/internal/blockchain/validantions.go +++ b/internal/blockchain/validantions.go @@ -9,9 +9,11 @@ import ( type Receive func() string type Input func() string +/* func ValidateBlockPredicate(b *Block) bool { } +*/ // Simple Content Validation Predicate implementation from backbone protocol func ContentValidatePredicate(x *Blockchain) bool { From 7928e71922bc99a92cab242c14cb90dbbf8eb77e Mon Sep 17 00:00:00 2001 From: NicholasRodrigues Date: Mon, 20 May 2024 19:53:24 -0300 Subject: [PATCH 10/10] feat: creating proof of work --- internal/blockchain/proof_of_work.go | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/internal/blockchain/proof_of_work.go b/internal/blockchain/proof_of_work.go index 772ed17..98d1faf 100644 --- a/internal/blockchain/proof_of_work.go +++ b/internal/blockchain/proof_of_work.go @@ -4,7 +4,18 @@ import ( "math/big" ) +const Difficulty = 16 + type ProofOfWork struct { block *Block T big.Int } + +func NewProofOfWork(b *Block) *ProofOfWork { + target := big.NewInt(1) + target.Lsh(target, uint(256-Difficulty)) + + pow := &ProofOfWork{b, *target} + + return pow +}