Реализовать отправку и получение блоков между нодами

.gitignore

@@ -23,4 +23,4 @@ go.work
 
 node_modules/
 .DS_Store
-chain_storage/
+chain_storage*/

README.md

@@ -11,7 +11,7 @@ go run cmd/blockchain/main.go -address localhost:8080 -http localhost:8090 -stor
 
 go run cmd/blockchain/main.go -address localhost:8081 -peers localhost:8080 -http localhost:8091 -storage chain_storage_2
 
-go run cmd/blockchain/main.goo -address localhost:8082 -peers localhost:8080,localhost:8081 -http localhost:8092 -storage chain_storage_3
+go run cmd/blockchain/main.go -address localhost:8082 -peers localhost:8080,localhost:8081 -http localhost:8092 -storage chain_storage_3
 ```
 
 ### Generate private key for testing

api/api.go

@@ -78,17 +78,19 @@ func (h *Handler) MineBlock(w http.ResponseWriter, r *http.Request) {
 		h.StatusesRWLock.Lock()
 		h.MiningStatuses[id] = MineStatusResponse{Status: StatusPending}
 		h.StatusesRWLock.Unlock()
-		err := h.Blockchain.MinePendingTransactions("")
+		block, err := h.Blockchain.MinePendingTransactions("")
 		if err != nil {
 			h.StatusesRWLock.Lock()
 			h.MiningStatuses[id] = MineStatusResponse{
 				Status:  StatusFailed,
 				Details: fmt.Sprintf("Error: %v", err),
 			}
 			h.StatusesRWLock.Unlock()
+			return
 		}
 		h.StatusesRWLock.Lock()
 		h.MiningStatuses[id] = MineStatusResponse{Status: StatusSuccessful}
+		go h.Node.BroadcastBlock(block)
 		h.StatusesRWLock.Unlock()
 	}()
 	err := json.NewEncoder(w).Encode(MineResponse{Id: id.String()})

chain/chain.go

@@ -273,16 +273,28 @@ func (chain *Blockchain) IsValid() bool {
 	return true
 }
 
-func (chain *Blockchain) MinePendingTransactions(minerAddress string) error {
+func (chain *Blockchain) MinePendingTransactions(minerAddress string) (Block, error) {
 	currentPoolSize := len(chain.PendingTransactions)
+	if currentPoolSize == 0 {
+		return Block{}, errors.New("Transaction pool is empty")
+	}
+
 	var transactions []Transaction
 
 	if currentPoolSize < chain.MaxBlockSize {
 		transactions = chain.PendingTransactions[0:currentPoolSize]
 		chain.PendingTransactions = chain.PendingTransactions[currentPoolSize:]
+		err := chain.Storage.DequeueTransactions(currentPoolSize)
+		if err != nil {
+			fmt.Println("Could not dequeue transactions from storage")
+		}
 	} else {
 		transactions = chain.PendingTransactions[0 : chain.MaxBlockSize-1]
 		chain.PendingTransactions = chain.PendingTransactions[chain.MaxBlockSize-1:]
+		err := chain.Storage.DequeueTransactions(chain.MaxBlockSize - 1)
+		if err != nil {
+			fmt.Println("Could not dequeue transactions from storage")
+		}
 	}
 
 	rewardTx := Transaction{
@@ -302,20 +314,23 @@ func (chain *Blockchain) MinePendingTransactions(minerAddress string) error {
 	}
 	block.Hash = block.CalculateHash()
 
+	// TODO: sync transaction removal between nodes
+	// TODO: recover if mining failed
 	block.MineBlock(chain.Difficulty)
 	chain.AddBlock(block)
 	err := chain.Storage.AddBlock(block)
 	if err != nil {
-		return err
+		return Block{}, err
 	}
-	return nil
+	return block, nil
 }
 
 type Storage interface {
 	Load(difficulty, maxBlockSize int, miningReward float64) (*Blockchain, error)
 	AddBlock(b Block) error
 	AddTransaction(t Transaction) error
 	Reset(chain *Blockchain) error
+	DequeueTransactions(n int) error
 }
 
 func InitBlockchain(difficulty, maxBlockSize int, miningReward float64, s Storage) *Blockchain {

cmd/private_key_generator/main.go

@@ -9,6 +9,7 @@ func main() {
 	wallet := chain.Wallet{}
 	wallet.KeyGen()
 	fmt.Println(wallet.PrivateKey)
+	fmt.Println(wallet.PublicKey)
 	t := chain.Transaction{}
 	err := t.Sign(wallet.PrivateKey)
 	if err != nil {

frontend/src/AddTransactionModalButton.tsx

@@ -12,14 +12,23 @@ import {
 
 import AddTransactionForm from './AddTransactionForm'
 
-export default function AddTransactionsModalButton() {
-    const { isOpen, onOpen, onClose } = useDisclosure()
+interface AddTransactionsModalButtonProps {
+    onClose: () => void;
+  }
+
+export default function AddTransactionsModalButton({ onClose }: AddTransactionsModalButtonProps) {
+    const { isOpen, onOpen, onClose: closeModal } = useDisclosure()
+
+    const handleClose = () => {
+        closeModal();
+        onClose();
+      };
 
     return (
         <>
             <Button onClick={onOpen}>Add Transaction</Button>
 
-            <Modal isOpen={isOpen} onClose={onClose} size={'full'}>
+            <Modal isOpen={isOpen} onClose={handleClose} size={'full'}>
                 <ModalOverlay />
                 <ModalContent>
                     <ModalCloseButton />
@@ -39,7 +48,7 @@ export default function AddTransactionsModalButton() {
                     </ModalBody>
 
                     <ModalFooter>
-                        <Button colorScheme='blue' mr={3} onClick={onClose}>
+                        <Button colorScheme='blue' mr={3} onClick={handleClose}>
                             Close
                         </Button>
                     </ModalFooter>

frontend/src/TransactionsPage.tsx

@@ -12,17 +12,21 @@ async function fetchTransactions(): Promise<TransactionProps[]> {
 }
 
 export default function TransactionsPage({ caption }: { caption: string }) {
-  const { isPending, error, data } = useQuery({
+  const { isPending, error, data, refetch } = useQuery({
     queryKey: ["transactions"],
     queryFn: fetchTransactions,
   });
 
+  const handleRefetch = () => {
+    refetch();
+  };
+
   if (!data || !data.length) {
     return (
       <>
         <>No transactions yet.</>
         <Flex justifyContent={"flex-end"} my={6}>
-          <AddTransactionsModalButton />
+          <AddTransactionsModalButton onClose={handleRefetch} />
         </Flex>
       </>
     );
@@ -34,7 +38,7 @@ export default function TransactionsPage({ caption }: { caption: string }) {
     <>
       <TransactionsTable caption={caption} transactions={data} />
       <Flex justifyContent={"flex-end"} my={6}>
-        <AddTransactionsModalButton />
+        <AddTransactionsModalButton onClose={handleRefetch} />
       </Flex>
     </>
   );

storage/badger.go

@@ -158,6 +158,33 @@ func (bs *Storage) AddTransaction(t chain.Transaction) error {
 	return err
 }
 
+func (bs *Storage) DequeueTransactions(n int) error {
+	return bs.db.Update(func(txn *badger.Txn) error {
+		opts := badger.DefaultIteratorOptions
+		opts.PrefetchValues = false
+		it := txn.NewIterator(opts)
+		defer it.Close()
+
+		prefix := []byte(transactionPrefix)
+		count := 0
+
+		for it.Seek(prefix); it.ValidForPrefix(prefix); it.Next() {
+			if count >= n {
+				break
+			}
+
+			key := it.Item().Key()
+			if err := txn.Delete(key); err != nil {
+				return err
+			}
+
+			count++
+		}
+
+		return nil
+	})
+}
+
 func (storage *Storage) deleteByPrefix(prefix []byte) error {
 	deleteKeys := func(keysForDelete [][]byte) error {
 		if err := storage.db.Update(func(txn *badger.Txn) error {