2025-09-14 21:40:11 +00:00
200 changed files with 7847 additions and 12349 deletions
--- a/.github/workflows/deploy.yaml
+++ b/.github/workflows/deploy.yaml
@ -17,12 +17,13 @@ jobs:
        run: git config --global core.autocrlf false

      - name: Check out code into the Go module directory
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
+

      - name: Setup Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v2
        with:
-          go-version: 1.21
+          go-version: 1.18

      - name: Build on Linux
        if: runner.os == 'Linux'
@ -30,7 +31,7 @@ jobs:
        # `-tags netgo,osusergo` means use pure go replacements for "os/user" and "net"
        # `-s -w` strips the binary to produce smaller size binaries
        run: |
-          go build -v -ldflags="-s -w -extldflags=-static" -tags netgo,osusergo -o ./bin/ ./cmd/...
+          go build -v -ldflags="-s -w -extldflags=-static" -tags netgo,osusergo -o ./bin/ . ./cmd/...
          archive="bin/kaspad-${{ github.event.release.tag_name }}-linux.zip"
          asset_name="kaspad-${{ github.event.release.tag_name }}-linux.zip"
          zip -r "${archive}" ./bin/*
@ -41,7 +42,7 @@ jobs:
        if: runner.os == 'Windows'
        shell: bash
        run: |
-          go build -v -ldflags="-s -w" -o bin/ ./cmd/...
+          go build -v -ldflags="-s -w" -o bin/ . ./cmd/...
          archive="bin/kaspad-${{ github.event.release.tag_name }}-win64.zip"
          asset_name="kaspad-${{ github.event.release.tag_name }}-win64.zip"
          powershell "Compress-Archive bin/* \"${archive}\""
@ -51,13 +52,14 @@ jobs:
      - name: Build on MacOS
        if: runner.os == 'macOS'
        run: |
-          go build -v -ldflags="-s -w" -o ./bin/ ./cmd/...
+          go build -v -ldflags="-s -w" -o ./bin/ . ./cmd/...
          archive="bin/kaspad-${{ github.event.release.tag_name }}-osx.zip"
          asset_name="kaspad-${{ github.event.release.tag_name }}-osx.zip"
          zip -r "${archive}" ./bin/*
          echo "archive=${archive}" >> $GITHUB_ENV
          echo "asset_name=${asset_name}" >> $GITHUB_ENV

+
      - name: Upload release asset
        uses: actions/upload-release-asset@v1
        env:
--- a/.github/workflows/race.yaml
+++ b/.github/workflows/race.yaml
@ -15,14 +15,14 @@ jobs:
    name: Race detection on ${{ matrix.branch }}
    steps:
      - name: Check out code into the Go module directory
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
        with:
          fetch-depth: 0

      - name: Setup Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v2
        with:
-          go-version: 1.23
+          go-version: 1.18

      - name: Set scheduled branch name
        shell: bash
--- a/.github/workflows/tests.yaml
+++ b/.github/workflows/tests.yaml
@ -8,6 +8,7 @@ on:
    types: [opened, synchronize, edited]

 jobs:
+
  build:
    runs-on: ${{ matrix.os }}
    strategy:
@ -16,12 +17,13 @@ jobs:
        os: [ ubuntu-latest, macos-latest ]
    name: Tests, ${{ matrix.os }}
    steps:
+
      - name: Fix CRLF on Windows
        if: runner.os == 'Windows'
        run: git config --global core.autocrlf false

      - name: Check out code into the Go module directory
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2

      # Increase the pagefile size on Windows to aviod running out of memory
      - name: Increase pagefile size on Windows
@ -29,13 +31,14 @@ jobs:
        run: powershell -command .github\workflows\SetPageFileSize.ps1

      - name: Setup Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v2
        with:
-          go-version: 1.23
+          go-version: 1.18
+

      # Source: https://github.com/actions/cache/blob/main/examples.md#go---modules
      - name: Go Cache
-        uses: actions/cache@v4
+        uses: actions/cache@v2
        with:
          path: ~/go/pkg/mod
          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
@ -46,17 +49,19 @@ jobs:
        shell: bash
        run: ./build_and_test.sh -v

+
  stability-test-fast:
    runs-on: ubuntu-latest
    name: Fast stability tests, ${{ github.head_ref }}
    steps:
+
      - name: Setup Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v2
        with:
-          go-version: 1.23
+          go-version: 1.18

      - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2
        with:
          fetch-depth: 0

@ -70,17 +75,18 @@ jobs:
        working-directory: stability-tests
        run: ./install_and_test.sh

+
  coverage:
    runs-on: ubuntu-latest
    name: Produce code coverage
    steps:
      - name: Check out code into the Go module directory
-        uses: actions/checkout@v4
+        uses: actions/checkout@v2

      - name: Setup Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v2
        with:
-          go-version: 1.23
+          go-version: 1.18

      - name: Delete the stability tests from coverage
        run: rm -r stability-tests
--- a/.gitignore
+++ b/.gitignore
@ -53,7 +53,6 @@ _testmain.go
 debug
 debug.test
 __debug_bin
-*__debug_*

 # CI
 version.txt
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@ -1,43 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project maintainers on this [Google form][gform]. The project maintainers will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project maintainers are obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
-
-[gform]: https://forms.gle/dnKXMJL7VxdUjt3x5
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/
--- a/README.md
+++ b/README.md
@ -1,15 +1,13 @@
-# DEPRECATED

-The full node reference implementation was [rewritten in Rust](https://github.com/kaspanet/rusty-kaspa), as a result, the Go implementation is now deprecated.
-
-PLEASE NOTE: Any pull requests or issues that will be opened in this repository will be closed without treatment, except for issues or pull requests related to the kaspawallet, which remains maintained. In any other case, please use the [Rust implementation](https://github.com/kaspanet/rusty-kaspa) instead.
-
-# Kaspad
+Kaspad
+====

 [![ISC License](http://img.shields.io/badge/license-ISC-blue.svg)](https://choosealicense.com/licenses/isc/)
 [![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg)](http://godoc.org/github.com/kaspanet/kaspad)

-Kaspad was the reference full node Kaspa implementation written in Go (golang).
+Kaspad is the reference full node Kaspa implementation written in Go (golang).
+
+This project is currently under active development and is in Beta state.

 ## What is kaspa

@ -17,7 +15,7 @@ Kaspa is an attempt at a proof-of-work cryptocurrency with instant confirmations

 ## Requirements

-Go 1.23 or later.
+Go 1.18 or later.

 ## Installation

@ -44,6 +42,7 @@ $ go install . ./cmd/...
  not already add the bin directory to your system path during Go installation,
  you are encouraged to do so now.

+
 ## Getting Started

 Kaspad has several configuration options available to tweak how it runs, but all
@ -54,7 +53,6 @@ $ kaspad
 ```

 ## Discord
-
 Join our discord server using the following link: https://discord.gg/YNYnNN5Pf2

 ## Issue Tracker
--- a/app/appmessage/doc.go
+++ b/app/appmessage/doc.go
@ -6,7 +6,7 @@ supported kaspa messages to and from the appmessage. This package does not deal
 with the specifics of message handling such as what to do when a message is
 received. This provides the caller with a high level of flexibility.

-# Kaspa Message Overview
+Kaspa Message Overview

 The kaspa protocol consists of exchanging messages between peers. Each
 message is preceded by a header which identifies information about it such as
@ -22,7 +22,7 @@ messages, all of the details of marshalling and unmarshalling to and from the
 appmessage using kaspa encoding are handled so the caller doesn't have to concern
 themselves with the specifics.

-# Message Interaction
+Message Interaction

 The following provides a quick summary of how the kaspa messages are intended
 to interact with one another. As stated above, these interactions are not
@ -45,13 +45,13 @@ interactions in no particular order.
 	                                        notfound message (MsgNotFound)
 	ping message (MsgPing)                  pong message (MsgPong)

-# Common Parameters
+Common Parameters

 There are several common parameters that arise when using this package to read
 and write kaspa messages. The following sections provide a quick overview of
 these parameters so the next sections can build on them.

-# Protocol Version
+Protocol Version

 The protocol version should be negotiated with the remote peer at a higher
 level than this package via the version (MsgVersion) message exchange, however,
@ -60,7 +60,7 @@ latest protocol version this package supports and is typically the value to use
 for all outbound connections before a potentially lower protocol version is
 negotiated.

-# Kaspa Network
+Kaspa Network

 The kaspa network is a magic number which is used to identify the start of a
 message and which kaspa network the message applies to. This package provides
@ -71,7 +71,7 @@ the following constants:
    appmessage.Simnet  (Simulation test network)
    appmessage.Devnet  (Development network)

-# Determining Message Type
+Determining Message Type

 As discussed in the kaspa message overview section, this package reads
 and writes kaspa messages using a generic interface named Message. In
@ -89,7 +89,7 @@ switch or type assertion. An example of a type switch follows:
 		fmt.Printf("Number of tx in block: %d", msg.Header.TxnCount)
 	}

-# Reading Messages
+Reading Messages

 In order to unmarshall kaspa messages from the appmessage, use the ReadMessage
 function. It accepts any io.Reader, but typically this will be a net.Conn to
@ -104,7 +104,7 @@ a remote node running a kaspa peer. Example syntax is:
 		// Log and handle the error
 	}

-# Writing Messages
+Writing Messages

 In order to marshall kaspa messages to the appmessage, use the WriteMessage
 function. It accepts any io.Writer, but typically this will be a net.Conn to
@ -122,7 +122,7 @@ from a remote peer is:
 		// Log and handle the error
 	}

-# Errors
+Errors

 Errors returned by this package are either the raw errors provided by underlying
 calls to read/write from streams such as io.EOF, io.ErrUnexpectedEOF, and
--- a/app/appmessage/domainconverters.go
+++ b/app/appmessage/domainconverters.go
@ -2,9 +2,8 @@ package appmessage

 import (
 	"encoding/hex"
-	"math/big"
-
 	"github.com/pkg/errors"
+	"math/big"

 	"github.com/kaspanet/kaspad/domain/consensus/utils/blockheader"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
@ -219,8 +218,7 @@ func RPCTransactionToDomainTransaction(rpcTransaction *RPCTransaction) (*externa
 		Outputs:      outputs,
 		LockTime:     rpcTransaction.LockTime,
 		SubnetworkID: *subnetworkID,
-		Gas:            rpcTransaction.Gas,
-		MassCommitment: rpcTransaction.Mass,
+		Gas:          rpcTransaction.LockTime,
 		Payload:      payload,
 	}, nil
 }
@ -288,8 +286,7 @@ func DomainTransactionToRPCTransaction(transaction *externalapi.DomainTransactio
 		Outputs:      outputs,
 		LockTime:     transaction.LockTime,
 		SubnetworkID: subnetworkID,
-		Gas:          transaction.Gas,
-		Mass:         transaction.MassCommitment,
+		Gas:          transaction.LockTime,
 		Payload:      payload,
 	}
 }
--- a/app/appmessage/message.go
+++ b/app/appmessage/message.go
@ -163,10 +163,6 @@ const (
 	CmdGetMempoolEntriesByAddressesResponseMessage
 	CmdGetCoinSupplyRequestMessage
 	CmdGetCoinSupplyResponseMessage
-	CmdGetFeeEstimateRequestMessage
-	CmdGetFeeEstimateResponseMessage
-	CmdSubmitTransactionReplacementRequestMessage
-	CmdSubmitTransactionReplacementResponseMessage
 )

 // ProtocolMessageCommandToString maps all MessageCommands to their string representation
@ -304,10 +300,6 @@ var RPCMessageCommandToString = map[MessageCommand]string{
 	CmdGetMempoolEntriesByAddressesResponseMessage:                "GetMempoolEntriesByAddressesResponse",
 	CmdGetCoinSupplyRequestMessage:                                "GetCoinSupplyRequest",
 	CmdGetCoinSupplyResponseMessage:                               "GetCoinSupplyResponse",
-	CmdGetFeeEstimateRequestMessage:                               "GetFeeEstimateRequest",
-	CmdGetFeeEstimateResponseMessage:                              "GetFeeEstimateResponse",
-	CmdSubmitTransactionReplacementRequestMessage:                 "SubmitTransactionReplacementRequest",
-	CmdSubmitTransactionReplacementResponseMessage:                "SubmitTransactionReplacementResponse",
 }

 // Message is an interface that describes a kaspa message. A type that
--- a/app/appmessage/p2p_msgtx_test.go
+++ b/app/appmessage/p2p_msgtx_test.go
@ -133,8 +133,8 @@ func TestTx(t *testing.T) {

 // TestTxHash tests the ability to generate the hash of a transaction accurately.
 func TestTxHashAndID(t *testing.T) {
-	txHash1Str := "b06f8b650115b5cf4d59499e10764a9312742930cb43c9b4ff6495d76f332ed7"
-	txID1Str := "e20225c3d065ee41743607ee627db44d01ef396dc9779b05b2caf55bac50e12d"
+	txHash1Str := "93663e597f6c968d32d229002f76408edf30d6a0151ff679fc729812d8cb2acc"
+	txID1Str := "24079c6d2bdf602fc389cc307349054937744a9c8dc0f07c023e6af0e949a4e7"
 	wantTxID1, err := transactionid.FromString(txID1Str)
 	if err != nil {
 		t.Fatalf("NewTxIDFromStr: %v", err)
@ -185,7 +185,7 @@ func TestTxHashAndID(t *testing.T) {
 			spew.Sprint(tx1ID), spew.Sprint(wantTxID1))
 	}

-	hash2Str := "fa16a8ce88d52ca1ff45187bbba0d33044e9f5fe309e8d0b22d4812dcf1782b7"
+	hash2Str := "8dafd1bec24527d8e3b443ceb0a3b92fffc0d60026317f890b2faf5e9afc177a"
 	wantHash2, err := externalapi.NewDomainHashFromString(hash2Str)
 	if err != nil {
 		t.Errorf("NewTxIDFromStr: %v", err)
--- a/app/appmessage/rpc_fee_estimate.go
+++ b/app/appmessage/rpc_fee_estimate.go
@ -1,47 +0,0 @@
-package appmessage
-
-// GetFeeEstimateRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type GetFeeEstimateRequestMessage struct {
-	baseMessage
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetFeeEstimateRequestMessage) Command() MessageCommand {
-	return CmdGetFeeEstimateRequestMessage
-}
-
-// NewGetFeeEstimateRequestMessage returns a instance of the message
-func NewGetFeeEstimateRequestMessage() *GetFeeEstimateRequestMessage {
-	return &GetFeeEstimateRequestMessage{}
-}
-
-type RPCFeeRateBucket struct {
-	Feerate          float64
-	EstimatedSeconds float64
-}
-
-type RPCFeeEstimate struct {
-	PriorityBucket RPCFeeRateBucket
-	NormalBuckets  []RPCFeeRateBucket
-	LowBuckets     []RPCFeeRateBucket
-}
-
-// GetCoinSupplyResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type GetFeeEstimateResponseMessage struct {
-	baseMessage
-	Estimate RPCFeeEstimate
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *GetFeeEstimateResponseMessage) Command() MessageCommand {
-	return CmdGetFeeEstimateResponseMessage
-}
-
-// NewGetFeeEstimateResponseMessage returns a instance of the message
-func NewGetFeeEstimateResponseMessage() *GetFeeEstimateResponseMessage {
-	return &GetFeeEstimateResponseMessage{}
-}
--- a/app/appmessage/rpc_submit_transaction.go
+++ b/app/appmessage/rpc_submit_transaction.go
@ -52,7 +52,6 @@ type RPCTransaction struct {
 	SubnetworkID string
 	Gas          uint64
 	Payload      string
-	Mass         uint64
 	VerboseData  *RPCTransactionVerboseData
 }

--- a/app/appmessage/rpc_submit_transaction_replacement.go
+++ b/app/appmessage/rpc_submit_transaction_replacement.go
@ -1,42 +0,0 @@
-package appmessage
-
-// SubmitTransactionReplacementRequestMessage is an appmessage corresponding to
-// its respective RPC message
-type SubmitTransactionReplacementRequestMessage struct {
-	baseMessage
-	Transaction *RPCTransaction
-}
-
-// Command returns the protocol command string for the message
-func (msg *SubmitTransactionReplacementRequestMessage) Command() MessageCommand {
-	return CmdSubmitTransactionReplacementRequestMessage
-}
-
-// NewSubmitTransactionReplacementRequestMessage returns a instance of the message
-func NewSubmitTransactionReplacementRequestMessage(transaction *RPCTransaction) *SubmitTransactionReplacementRequestMessage {
-	return &SubmitTransactionReplacementRequestMessage{
-		Transaction: transaction,
-	}
-}
-
-// SubmitTransactionReplacementResponseMessage is an appmessage corresponding to
-// its respective RPC message
-type SubmitTransactionReplacementResponseMessage struct {
-	baseMessage
-	TransactionID       string
-	ReplacedTransaction *RPCTransaction
-
-	Error *RPCError
-}
-
-// Command returns the protocol command string for the message
-func (msg *SubmitTransactionReplacementResponseMessage) Command() MessageCommand {
-	return CmdSubmitTransactionReplacementResponseMessage
-}
-
-// NewSubmitTransactionReplacementResponseMessage returns a instance of the message
-func NewSubmitTransactionReplacementResponseMessage(transactionID string) *SubmitTransactionReplacementResponseMessage {
-	return &SubmitTransactionReplacementResponseMessage{
-		TransactionID: transactionID,
-	}
-}
--- a/app/protocol/flows/v5/blockrelay/handle_ibd_block_requests.go
+++ b/app/protocol/flows/v5/blockrelay/handle_ibd_block_requests.go
@ -27,15 +27,18 @@ func HandleIBDBlockRequests(context HandleIBDBlockRequestsContext, incomingRoute
 		log.Debugf("Got request for %d ibd blocks", len(msgRequestIBDBlocks.Hashes))
 		for i, hash := range msgRequestIBDBlocks.Hashes {
 			// Fetch the block from the database.
-			block, found, err := context.Domain().Consensus().GetBlock(hash)
+			blockInfo, err := context.Domain().Consensus().GetBlockInfo(hash)
+			if err != nil {
+				return err
+			}
+			if !blockInfo.HasBody() {
+				return protocolerrors.Errorf(true, "block %s not found (v5)", hash)
+			}
+			block, err := context.Domain().Consensus().GetBlock(hash)
 			if err != nil {
 				return errors.Wrapf(err, "unable to fetch requested block hash %s", hash)
 			}

-			if !found {
-				return protocolerrors.Errorf(false, "IBD block %s not found", hash)
-			}
-
 			// TODO (Partial nodes): Convert block to partial block if needed

 			blockMessage := appmessage.DomainBlockToMsgBlock(block)
--- a/app/protocol/flows/v5/blockrelay/handle_pruning_point_and_its_anticone_requests.go
+++ b/app/protocol/flows/v5/blockrelay/handle_pruning_point_and_its_anticone_requests.go
@ -119,15 +119,11 @@ func HandlePruningPointAndItsAnticoneRequests(context PruningPointAndItsAnticone
 			}

 			for i, blockHash := range pointAndItsAnticone {
-				block, found, err := context.Domain().Consensus().GetBlock(blockHash)
+				block, err := context.Domain().Consensus().GetBlock(blockHash)
 				if err != nil {
 					return err
 				}

-				if !found {
-					return protocolerrors.Errorf(false, "pruning point anticone block %s not found", blockHash)
-				}
-
 				err = outgoingRoute.Enqueue(appmessage.DomainBlockWithTrustedDataToBlockWithTrustedDataV4(block, trustedDataDAABlockIndexes[*blockHash], trustedDataGHOSTDAGDataIndexes[*blockHash]))
 				if err != nil {
 					return err
--- a/app/protocol/flows/v5/blockrelay/handle_relay_block_requests.go
+++ b/app/protocol/flows/v5/blockrelay/handle_relay_block_requests.go
@ -28,15 +28,18 @@ func HandleRelayBlockRequests(context RelayBlockRequestsContext, incomingRoute *
 		log.Debugf("Got request for relay blocks with hashes %s", getRelayBlocksMessage.Hashes)
 		for _, hash := range getRelayBlocksMessage.Hashes {
 			// Fetch the block from the database.
-			block, found, err := context.Domain().Consensus().GetBlock(hash)
+			blockInfo, err := context.Domain().Consensus().GetBlockInfo(hash)
+			if err != nil {
+				return err
+			}
+			if !blockInfo.HasBody() {
+				return protocolerrors.Errorf(true, "block %s not found", hash)
+			}
+			block, err := context.Domain().Consensus().GetBlock(hash)
 			if err != nil {
 				return errors.Wrapf(err, "unable to fetch requested block hash %s", hash)
 			}

-			if !found {
-				return protocolerrors.Errorf(false, "Relay block %s not found", hash)
-			}
-
 			// TODO (Partial nodes): Convert block to partial block if needed

 			err = outgoingRoute.Enqueue(appmessage.DomainBlockToMsgBlock(block))
--- a/app/protocol/flows/v5/blockrelay/handle_relay_invs.go
+++ b/app/protocol/flows/v5/blockrelay/handle_relay_invs.go
@ -211,14 +211,10 @@ func (flow *handleRelayInvsFlow) start() error {
 				continue
 			}
 			virtualHasNewParents = true
-			block, found, err := flow.Domain().Consensus().GetBlock(parent)
+			block, err := flow.Domain().Consensus().GetBlock(parent)
 			if err != nil {
 				return err
 			}
-
-			if !found {
-				return protocolerrors.Errorf(false, "Virtual parent %s not found", parent)
-			}
 			blockHash := consensushashing.BlockHash(block)
 			log.Debugf("Relaying block %s", blockHash)
 			err = flow.relayBlock(block)
--- a/app/protocol/flows/v5/blockrelay/ibd.go
+++ b/app/protocol/flows/v5/blockrelay/ibd.go
@ -1,7 +1,6 @@
 package blockrelay

 import (
-	"fmt"
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/common"
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
@ -71,17 +70,16 @@ func (flow *handleIBDFlow) runIBDIfNotRunning(block *externalapi.DomainBlock) er
 	}

 	isFinishedSuccessfully := false
-	var err error
 	defer func() {
 		flow.UnsetIBDRunning()
-		flow.logIBDFinished(isFinishedSuccessfully, err)
+		flow.logIBDFinished(isFinishedSuccessfully)
 	}()

 	relayBlockHash := consensushashing.BlockHash(block)

-	log.Infof("IBD started with peer %s and relayBlockHash %s", flow.peer, relayBlockHash)
-	log.Infof("Syncing blocks up to %s", relayBlockHash)
-	log.Infof("Trying to find highest known syncer chain block from peer %s with relay hash %s", flow.peer, relayBlockHash)
+	log.Debugf("IBD started with peer %s and relayBlockHash %s", flow.peer, relayBlockHash)
+	log.Debugf("Syncing blocks up to %s", relayBlockHash)
+	log.Debugf("Trying to find highest known syncer chain block from peer %s with relay hash %s", flow.peer, relayBlockHash)

 	syncerHeaderSelectedTipHash, highestKnownSyncerChainHash, err := flow.negotiateMissingSyncerChainSegment()
 	if err != nil {
@ -100,7 +98,7 @@ func (flow *handleIBDFlow) runIBDIfNotRunning(block *externalapi.DomainBlock) er

 	if shouldDownloadHeadersProof {
 		log.Infof("Starting IBD with headers proof")
-		err = flow.ibdWithHeadersProof(syncerHeaderSelectedTipHash, relayBlockHash, block.Header.DAAScore())
+		err := flow.ibdWithHeadersProof(syncerHeaderSelectedTipHash, relayBlockHash, block.Header.DAAScore())
 		if err != nil {
 			return err
 		}
@ -175,11 +173,6 @@ func (flow *handleIBDFlow) negotiateMissingSyncerChainSegment() (*externalapi.Do
 	chainNegotiationRestartCounter := 0
 	chainNegotiationZoomCounts := 0
 	initialLocatorLen := len(locatorHashes)
-	pruningPoint, err := flow.Domain().Consensus().PruningPoint()
-	if err != nil {
-		return nil, nil, err
-	}
-
 	for {
 		var lowestUnknownSyncerChainHash, currentHighestKnownSyncerChainHash *externalapi.DomainHash
 		for _, syncerChainHash := range locatorHashes {
@ -188,26 +181,9 @@ func (flow *handleIBDFlow) negotiateMissingSyncerChainSegment() (*externalapi.Do
 				return nil, nil, err
 			}
 			if info.Exists {
-				if info.BlockStatus == externalapi.StatusInvalid {
-					return nil, nil, protocolerrors.Errorf(true, "Sent invalid chain block %s", syncerChainHash)
-				}
-
-				isPruningPointOnSyncerChain, err := flow.Domain().Consensus().IsInSelectedParentChainOf(pruningPoint, syncerChainHash)
-				if err != nil {
-					log.Errorf("Error checking isPruningPointOnSyncerChain: %s", err)
-				}
-
-				// We're only interested in syncer chain blocks that have our pruning
-				// point in their selected chain. Otherwise, it means one of the following:
-				// 1) We will not switch the virtual selected chain to the syncers chain since it will violate finality
-				//    (hence we can ignore it unless merged by others).
-				// 2) syncerChainHash is actually in the past of our pruning point so there's no
-				//    point in syncing from it.
-				if err == nil && isPruningPointOnSyncerChain {
 				currentHighestKnownSyncerChainHash = syncerChainHash
 				break
 			}
-			}
 			lowestUnknownSyncerChainHash = syncerChainHash
 		}
 		// No unknown blocks, break. Note this can only happen in the first iteration
@ -285,7 +261,7 @@ func (flow *handleIBDFlow) negotiateMissingSyncerChainSegment() (*externalapi.Do
 		}
 	}

-	log.Infof("Found highest known syncer chain block %s from peer %s",
+	log.Debugf("Found highest known syncer chain block %s from peer %s",
 		highestKnownSyncerChainHash, flow.peer)

 	return syncerHeaderSelectedTipHash, highestKnownSyncerChainHash, nil
@ -300,14 +276,10 @@ func (flow *handleIBDFlow) isGenesisVirtualSelectedParent() (bool, error) {
 	return virtualSelectedParent.Equal(flow.Config().NetParams().GenesisHash), nil
 }

-func (flow *handleIBDFlow) logIBDFinished(isFinishedSuccessfully bool, err error) {
+func (flow *handleIBDFlow) logIBDFinished(isFinishedSuccessfully bool) {
 	successString := "successfully"
 	if !isFinishedSuccessfully {
-		if err != nil {
-			successString = fmt.Sprintf("(interrupted: %s)", err)
-		} else {
-			successString = fmt.Sprintf("(interrupted)")
-		}
+		successString = "(interrupted)"
 	}
 	log.Infof("IBD with peer %s finished %s", flow.peer, successString)
 }
@ -646,12 +618,6 @@ func (flow *handleIBDFlow) syncMissingBlockBodies(highHash *externalapi.DomainHa
 	progressReporter := newIBDProgressReporter(lowBlockHeader.DAAScore(), highBlockHeader.DAAScore(), "blocks")
 	highestProcessedDAAScore := lowBlockHeader.DAAScore()

-	// If the IBD is small, we want to update the virtual after each block in order to avoid complications and possible bugs.
-	updateVirtual, err := flow.Domain().Consensus().IsNearlySynced()
-	if err != nil {
-		return err
-	}
-
 	for offset := 0; offset < len(hashes); offset += ibdBatchSize {
 		var hashesToRequest []*externalapi.DomainHash
 		if offset+ibdBatchSize < len(hashes) {
@ -688,7 +654,7 @@ func (flow *handleIBDFlow) syncMissingBlockBodies(highHash *externalapi.DomainHa
 				return err
 			}

-			err = flow.Domain().Consensus().ValidateAndInsertBlock(block, updateVirtual)
+			err = flow.Domain().Consensus().ValidateAndInsertBlock(block, false)
 			if err != nil {
 				if errors.Is(err, ruleerrors.ErrDuplicateBlock) {
 					log.Debugf("Skipping IBD Block %s as it has already been added to the DAG", blockHash)
@ -707,15 +673,7 @@ func (flow *handleIBDFlow) syncMissingBlockBodies(highHash *externalapi.DomainHa
 		progressReporter.reportProgress(len(hashesToRequest), highestProcessedDAAScore)
 	}

-	// We need to resolve virtual only if it wasn't updated while syncing block bodies
-	if !updateVirtual {
-		err := flow.resolveVirtual(highestProcessedDAAScore)
-		if err != nil {
-			return err
-		}
-	}
-
-	return flow.OnNewBlockTemplate()
+	return flow.resolveVirtual(highestProcessedDAAScore)
 }

 func (flow *handleIBDFlow) banIfBlockIsHeaderOnly(block *externalapi.DomainBlock) error {
@ -747,5 +705,9 @@ func (flow *handleIBDFlow) resolveVirtual(estimatedVirtualDAAScoreTarget uint64)
 	}

 	log.Infof("Resolved virtual")
+	err = flow.OnNewBlockTemplate()
+	if err != nil {
+		return err
+	}
 	return nil
 }
--- a/app/protocol/flows/v5/blockrelay/ibd_with_headers_proof.go
+++ b/app/protocol/flows/v5/blockrelay/ibd_with_headers_proof.go
@ -25,7 +25,7 @@ func (flow *handleIBDFlow) ibdWithHeadersProof(
 			return err
 		}

-		log.Infof("IBD with pruning proof from %s was unsuccessful. Deleting the staging consensus. (%s)", flow.peer, err)
+		log.Infof("IBD with pruning proof from %s was unsuccessful. Deleting the staging consensus.", flow.peer)
 		deleteStagingConsensusErr := flow.Domain().DeleteStagingConsensus()
 		if deleteStagingConsensusErr != nil {
 			return deleteStagingConsensusErr
@ -55,12 +55,7 @@ func (flow *handleIBDFlow) shouldSyncAndShouldDownloadHeadersProof(

 	var highestSharedBlockFound, isPruningPointInSharedBlockChain bool
 	if highestKnownSyncerChainHash != nil {
-		blockInfo, err := flow.Domain().Consensus().GetBlockInfo(highestKnownSyncerChainHash)
-		if err != nil {
-			return false, false, err
-		}
-
-		highestSharedBlockFound = blockInfo.HasBody()
+		highestSharedBlockFound = true
 		pruningPoint, err := flow.Domain().Consensus().PruningPoint()
 		if err != nil {
 			return false, false, err
@ -85,33 +80,28 @@ func (flow *handleIBDFlow) shouldSyncAndShouldDownloadHeadersProof(
 			return true, true, nil
 		}

-		if highestKnownSyncerChainHash == nil {
-			log.Infof("Stopping IBD since IBD from this node will cause a finality conflict")
 		return false, false, nil
 	}

 	return false, true, nil
 }

-	return false, true, nil
-}
-
 func (flow *handleIBDFlow) checkIfHighHashHasMoreBlueWorkThanSelectedTipAndPruningDepthMoreBlueScore(relayBlock *externalapi.DomainBlock) (bool, error) {
-	virtualSelectedParent, err := flow.Domain().Consensus().GetVirtualSelectedParent()
+	headersSelectedTip, err := flow.Domain().Consensus().GetHeadersSelectedTip()
 	if err != nil {
 		return false, err
 	}

-	virtualSelectedTipInfo, err := flow.Domain().Consensus().GetBlockInfo(virtualSelectedParent)
+	headersSelectedTipInfo, err := flow.Domain().Consensus().GetBlockInfo(headersSelectedTip)
 	if err != nil {
 		return false, err
 	}

-	if relayBlock.Header.BlueScore() < virtualSelectedTipInfo.BlueScore+flow.Config().NetParams().PruningDepth() {
+	if relayBlock.Header.BlueScore() < headersSelectedTipInfo.BlueScore+flow.Config().NetParams().PruningDepth() {
 		return false, nil
 	}

-	return relayBlock.Header.BlueWork().Cmp(virtualSelectedTipInfo.BlueWork) > 0, nil
+	return relayBlock.Header.BlueWork().Cmp(headersSelectedTipInfo.BlueWork) > 0, nil
 }

 func (flow *handleIBDFlow) syncAndValidatePruningPointProof() (*externalapi.DomainHash, error) {
@ -291,14 +281,8 @@ func (flow *handleIBDFlow) processBlockWithTrustedData(
 	}

 	err := consensus.ValidateAndInsertBlockWithTrustedData(blockWithTrustedData, false)
-	if err != nil {
-		if errors.As(err, &ruleerrors.RuleError{}) {
-			return protocolerrors.Wrapf(true, err, "failed validating block with trusted data")
-		}
 	return err
 }
-	return nil
-}

 func (flow *handleIBDFlow) receiveBlockWithTrustedData() (*appmessage.MsgBlockWithTrustedDataV4, bool, error) {
 	message, err := flow.incomingRoute.DequeueWithTimeout(common.DefaultTimeout)
--- a/app/protocol/flows/v5/transactionrelay/handle_relayed_transactions.go
+++ b/app/protocol/flows/v5/transactionrelay/handle_relayed_transactions.go
@ -102,7 +102,7 @@ func (flow *handleRelayedTransactionsFlow) requestInvTransactions(
 func (flow *handleRelayedTransactionsFlow) isKnownTransaction(txID *externalapi.DomainTransactionID) bool {
 	// Ask the transaction memory pool if the transaction is known
 	// to it in any form (main pool or orphan).
-	if _, _, ok := flow.Domain().MiningManager().GetTransaction(txID, true, true); ok {
+	if _, ok := flow.Domain().MiningManager().GetTransaction(txID); ok {
 		return true
 	}

--- a/app/protocol/flows/v5/transactionrelay/handle_requested_transactions.go
+++ b/app/protocol/flows/v5/transactionrelay/handle_requested_transactions.go
@ -30,7 +30,7 @@ func (flow *handleRequestedTransactionsFlow) start() error {
 		}

 		for _, transactionID := range msgRequestTransactions.IDs {
-			tx, _, ok := flow.Domain().MiningManager().GetTransaction(transactionID, true, false)
+			tx, ok := flow.Domain().MiningManager().GetTransaction(transactionID)

 			if !ok {
 				msgTransactionNotFound := appmessage.NewMsgTransactionNotFound(transactionID)
@ -40,6 +40,7 @@ func (flow *handleRequestedTransactionsFlow) start() error {
 				}
 				continue
 			}
+
 			err := flow.outgoingRoute.Enqueue(appmessage.DomainTransactionToMsgTx(tx))
 			if err != nil {
 				return err
--- a/app/rpc/manager.go
+++ b/app/rpc/manager.go
@ -223,9 +223,18 @@ func (m *Manager) notifyVirtualSelectedParentChainChanged(virtualChangeSet *exte
 	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyVirtualSelectedParentChainChanged")
 	defer onEnd()

-	hasListeners, includeAcceptedTransactionIDs := m.context.NotificationManager.HasListenersThatPropagateVirtualSelectedParentChainChanged()
+	listenersThatPropagateSelectedParentChanged :=
+		m.context.NotificationManager.AllListenersThatPropagateVirtualSelectedParentChainChanged()
+	if len(listenersThatPropagateSelectedParentChanged) > 0 {
+		// Generating acceptedTransactionIDs is a heavy operation, so we check if it's needed by any listener.
+		includeAcceptedTransactionIDs := false
+		for _, listener := range listenersThatPropagateSelectedParentChanged {
+			if listener.IncludeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications() {
+				includeAcceptedTransactionIDs = true
+				break
+			}
+		}

-	if hasListeners {
 		notification, err := m.context.ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage(
 			virtualChangeSet.VirtualSelectedParentChainChanges, includeAcceptedTransactionIDs)
 		if err != nil {
--- a/app/rpc/rpccontext/notificationmanager.go
+++ b/app/rpc/rpccontext/notificationmanager.go
@ -5,7 +5,6 @@ import (

 	"github.com/kaspanet/kaspad/domain/dagconfig"

-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"

 	"github.com/kaspanet/kaspad/app/appmessage"
@ -142,29 +141,16 @@ func (nm *NotificationManager) NotifyVirtualSelectedParentChainChanged(
 	return nil
 }

-// HasListenersThatPropagateVirtualSelectedParentChainChanged returns whether there's any listener that is
-// subscribed to VirtualSelectedParentChainChanged notifications as well as checks if any such listener requested
-// to include AcceptedTransactionIDs.
-func (nm *NotificationManager) HasListenersThatPropagateVirtualSelectedParentChainChanged() (hasListeners, hasListenersThatRequireAcceptedTransactionIDs bool) {
-
-	nm.RLock()
-	defer nm.RUnlock()
-
-	hasListeners = false
-	hasListenersThatRequireAcceptedTransactionIDs = false
-
+// AllListenersThatPropagateVirtualSelectedParentChainChanged returns true if there's any listener that is
+// subscribed to VirtualSelectedParentChainChanged notifications.
+func (nm *NotificationManager) AllListenersThatPropagateVirtualSelectedParentChainChanged() []*NotificationListener {
+	var listenersThatPropagate []*NotificationListener
 	for _, listener := range nm.listeners {
 		if listener.propagateVirtualSelectedParentChainChangedNotifications {
-			hasListeners = true
-			// Generating acceptedTransactionIDs is a heavy operation, so we check if it's needed by any listener.
-			if listener.includeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications {
-				hasListenersThatRequireAcceptedTransactionIDs = true
-				break
+			listenersThatPropagate = append(listenersThatPropagate, listener)
 		}
 	}
-	}
-
-	return hasListeners, hasListenersThatRequireAcceptedTransactionIDs
+	return listenersThatPropagate
 }

 // NotifyFinalityConflict notifies the notification manager that there's a finality conflict in the DAG
@ -351,11 +337,7 @@ func (nl *NotificationListener) PropagateFinalityConflictResolvedNotifications()
 // to the remote listener for the given addresses. Subsequent calls instruct the listener to
 // send UTXOs changed notifications for those addresses along with the old ones. Duplicate addresses
 // are ignored.
-func (nm *NotificationManager) PropagateUTXOsChangedNotifications(nl *NotificationListener, addresses []*UTXOsChangedNotificationAddress) {
-	// Apply a write-lock since the internal listener address map is modified
-	nm.Lock()
-	defer nm.Unlock()
-
+func (nl *NotificationListener) PropagateUTXOsChangedNotifications(addresses []*UTXOsChangedNotificationAddress) {
 	if !nl.propagateUTXOsChangedNotifications {
 		nl.propagateUTXOsChangedNotifications = true
 		nl.propagateUTXOsChangedNotificationAddresses =
@ -370,11 +352,7 @@ func (nm *NotificationManager) PropagateUTXOsChangedNotifications(nl *Notificati
 // StopPropagatingUTXOsChangedNotifications instructs the listener to stop sending UTXOs
 // changed notifications to the remote listener for the given addresses. Addresses for which
 // notifications are not currently sent are ignored.
-func (nm *NotificationManager) StopPropagatingUTXOsChangedNotifications(nl *NotificationListener, addresses []*UTXOsChangedNotificationAddress) {
-	// Apply a write-lock since the internal listener address map is modified
-	nm.Lock()
-	defer nm.Unlock()
-
+func (nl *NotificationListener) StopPropagatingUTXOsChangedNotifications(addresses []*UTXOsChangedNotificationAddress) {
 	if !nl.propagateUTXOsChangedNotifications {
 		return
 	}
@ -443,7 +421,7 @@ func (nl *NotificationListener) convertUTXOChangesToUTXOsChangedNotification(
 }

 func (nl *NotificationListener) scriptPubKeyStringToAddressString(scriptPublicKeyString utxoindex.ScriptPublicKeyString) (string, error) {
-	scriptPubKey := externalapi.NewScriptPublicKeyFromString(string(scriptPublicKeyString))
+	scriptPubKey := utxoindex.ConvertStringToScriptPublicKey(scriptPublicKeyString)

 	// ignore error because it is often returned when the script is of unknown type
 	scriptType, address, err := txscript.ExtractScriptPubKeyAddress(scriptPubKey, nl.params)
--- a/app/rpc/rpccontext/utxos_by_addresses.go
+++ b/app/rpc/rpccontext/utxos_by_addresses.go
@ -32,6 +32,22 @@ func ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(address string, pair
 	return utxosByAddressesEntries
 }

+// convertUTXOOutpointsToUTXOsByAddressesEntries converts
+// UTXOOutpoints to a slice of UTXOsByAddressesEntry
+func convertUTXOOutpointsToUTXOsByAddressesEntries(address string, outpoints utxoindex.UTXOOutpoints) []*appmessage.UTXOsByAddressesEntry {
+	utxosByAddressesEntries := make([]*appmessage.UTXOsByAddressesEntry, 0, len(outpoints))
+	for outpoint := range outpoints {
+		utxosByAddressesEntries = append(utxosByAddressesEntries, &appmessage.UTXOsByAddressesEntry{
+			Address: address,
+			Outpoint: &appmessage.RPCOutpoint{
+				TransactionID: outpoint.TransactionID.String(),
+				Index:         outpoint.Index,
+			},
+		})
+	}
+	return utxosByAddressesEntries
+}
+
 // ConvertAddressStringsToUTXOsChangedNotificationAddresses converts address strings
 // to UTXOsChangedNotificationAddresses
 func (ctx *Context) ConvertAddressStringsToUTXOsChangedNotificationAddresses(
@ -47,7 +63,7 @@ func (ctx *Context) ConvertAddressStringsToUTXOsChangedNotificationAddresses(
 		if err != nil {
 			return nil, errors.Errorf("Could not create a scriptPublicKey for address '%s': %s", addressString, err)
 		}
-		scriptPublicKeyString := utxoindex.ScriptPublicKeyString(scriptPublicKey.String())
+		scriptPublicKeyString := utxoindex.ConvertScriptPublicKeyToString(scriptPublicKey)
 		addresses[i] = &UTXOsChangedNotificationAddress{
 			Address:               addressString,
 			ScriptPublicKeyString: scriptPublicKeyString,
--- a/app/rpc/rpccontext/verbosedata.go
+++ b/app/rpc/rpccontext/verbosedata.go
@ -81,6 +81,10 @@ func (ctx *Context) PopulateBlockWithVerboseData(block *appmessage.RPCBlock, dom
 		block.VerboseData.SelectedParentHash = blockInfo.SelectedParent.String()
 	}

+	if blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
+		return nil
+	}
+
 	// Get the block if we didn't receive it previously
 	if domainBlock == nil {
 		domainBlock, err = ctx.Domain.Consensus().GetBlockEvenIfHeaderOnly(blockHash)
@ -89,10 +93,6 @@ func (ctx *Context) PopulateBlockWithVerboseData(block *appmessage.RPCBlock, dom
 		}
 	}

-	if len(domainBlock.Transactions) == 0 {
-		return nil
-	}
-
 	transactionIDs := make([]string, len(domainBlock.Transactions))
 	for i, transaction := range domainBlock.Transactions {
 		transactionIDs[i] = consensushashing.TransactionID(transaction).String()
@ -122,7 +122,6 @@ func (ctx *Context) PopulateTransactionWithVerboseData(
 	}

 	ctx.Domain.Consensus().PopulateMass(domainTransaction)
-
 	transaction.VerboseData = &appmessage.RPCTransactionVerboseData{
 		TransactionID: consensushashing.TransactionID(domainTransaction).String(),
 		Hash:          consensushashing.TransactionHash(domainTransaction).String(),
--- a/app/rpc/rpchandlers/get_blocks.go
+++ b/app/rpc/rpchandlers/get_blocks.go
@ -37,7 +37,7 @@ func HandleGetBlocks(context *rpccontext.Context, _ *router.Router, request appm
 			return nil, err
 		}

-		if !blockInfo.HasHeader() {
+		if !blockInfo.Exists {
 			return &appmessage.GetBlocksResponseMessage{
 				Error: appmessage.RPCErrorf("Could not find lowHash %s", getBlocksRequest.LowHash),
 			}, nil
--- a/app/rpc/rpchandlers/get_info.go
+++ b/app/rpc/rpchandlers/get_info.go
@ -16,7 +16,7 @@ func HandleGetInfo(context *rpccontext.Context, _ *router.Router, _ appmessage.M

 	response := appmessage.NewGetInfoResponseMessage(
 		context.NetAdapter.ID().String(),
-		uint64(context.Domain.MiningManager().TransactionCount(true, false)),
+		uint64(context.Domain.MiningManager().TransactionCount()),
 		version.Version(),
 		context.Config.UTXOIndex,
 		context.ProtocolManager.Context().HasPeers() && isNearlySynced,
--- a/app/rpc/rpchandlers/get_mempool_entries.go
+++ b/app/rpc/rpchandlers/get_mempool_entries.go
@ -12,10 +12,30 @@ func HandleGetMempoolEntries(context *rpccontext.Context, _ *router.Router, requ

 	entries := make([]*appmessage.MempoolEntry, 0)

-	transactionPoolTransactions, orphanPoolTransactions := context.Domain.MiningManager().AllTransactions(!getMempoolEntriesRequest.FilterTransactionPool, getMempoolEntriesRequest.IncludeOrphanPool)
-
 	if !getMempoolEntriesRequest.FilterTransactionPool {
-		for _, transaction := range transactionPoolTransactions {
+		transactionPoolEntries, err := getTransactionPoolMempoolEntries(context)
+		if err != nil {
+			return nil, err
+		}
+
+		entries = append(entries, transactionPoolEntries...)
+	}
+
+	if getMempoolEntriesRequest.IncludeOrphanPool {
+		orphanPoolEntries, err := getOrphanPoolMempoolEntries(context)
+		if err != nil {
+			return nil, err
+		}
+		entries = append(entries, orphanPoolEntries...)
+	}
+
+	return appmessage.NewGetMempoolEntriesResponseMessage(entries), nil
+}
+
+func getTransactionPoolMempoolEntries(context *rpccontext.Context) ([]*appmessage.MempoolEntry, error) {
+	transactions := context.Domain.MiningManager().AllTransactions()
+	entries := make([]*appmessage.MempoolEntry, 0, len(transactions))
+	for _, transaction := range transactions {
 		rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
 		err := context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
 		if err != nil {
@ -27,21 +47,23 @@ func HandleGetMempoolEntries(context *rpccontext.Context, _ *router.Router, requ
 			IsOrphan:    false,
 		})
 	}
+	return entries, nil
 }
-	if getMempoolEntriesRequest.IncludeOrphanPool {
-		for _, transaction := range orphanPoolTransactions {
-			rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
+
+func getOrphanPoolMempoolEntries(context *rpccontext.Context) ([]*appmessage.MempoolEntry, error) {
+	orphanTransactions := context.Domain.MiningManager().AllOrphanTransactions()
+	entries := make([]*appmessage.MempoolEntry, 0, len(orphanTransactions))
+	for _, orphanTransaction := range orphanTransactions {
+		rpcTransaction := appmessage.DomainTransactionToRPCTransaction(orphanTransaction)
 		err := context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
 		if err != nil {
 			return nil, err
 		}
 		entries = append(entries, &appmessage.MempoolEntry{
-				Fee:         transaction.Fee,
+			Fee:         orphanTransaction.Fee,
 			Transaction: rpcTransaction,
 			IsOrphan:    true,
 		})
 	}
-	}
-
-	return appmessage.NewGetMempoolEntriesResponseMessage(entries), nil
+	return entries, nil
 }
--- a/app/rpc/rpchandlers/get_mempool_entries_by_addresses.go
+++ b/app/rpc/rpchandlers/get_mempool_entries_by_addresses.go
@ -1,10 +1,14 @@
 package rpchandlers

 import (
+	"errors"
+
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"

+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 	"github.com/kaspanet/kaspad/util"
 )
@ -16,101 +20,125 @@ func HandleGetMempoolEntriesByAddresses(context *rpccontext.Context, _ *router.R

 	mempoolEntriesByAddresses := make([]*appmessage.MempoolEntryByAddress, 0)

-	sendingInTransactionPool, receivingInTransactionPool, sendingInOrphanPool, receivingInOrphanPool, err := context.Domain.MiningManager().GetTransactionsByAddresses(!getMempoolEntriesByAddressesRequest.FilterTransactionPool, getMempoolEntriesByAddressesRequest.IncludeOrphanPool)
+	if !getMempoolEntriesByAddressesRequest.FilterTransactionPool {
+		transactionPoolTransactions := context.Domain.MiningManager().AllTransactions()
+		transactionPoolEntriesByAddresses, err := extractMempoolEntriesByAddressesFromTransactions(
+			context,
+			getMempoolEntriesByAddressesRequest.Addresses,
+			transactionPoolTransactions,
+			false,
+		)
 		if err != nil {
+			rpcError := &appmessage.RPCError{}
+			if !errors.As(err, &rpcError) {
 				return nil, err
 			}
-
-	for _, addressString := range getMempoolEntriesByAddressesRequest.Addresses {
-
-		address, err := util.DecodeAddress(addressString, context.Config.NetParams().Prefix)
-		if err != nil {
-			errorMessage := &appmessage.GetMempoolEntriesByAddressesResponseMessage{}
-			errorMessage.Error = appmessage.RPCErrorf("Could not decode address '%s': %s", addressString, err)
+			errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}
+			errorMessage.Error = rpcError
 			return errorMessage, nil
 		}
+		mempoolEntriesByAddresses = append(mempoolEntriesByAddresses, transactionPoolEntriesByAddresses...)
+	}
+
+	if getMempoolEntriesByAddressesRequest.IncludeOrphanPool {
+
+		orphanPoolTransactions := context.Domain.MiningManager().AllOrphanTransactions()
+		orphanPoolEntriesByAddress, err := extractMempoolEntriesByAddressesFromTransactions(
+			context,
+			getMempoolEntriesByAddressesRequest.Addresses,
+			orphanPoolTransactions,
+			true,
+		)
+		if err != nil {
+			rpcError := &appmessage.RPCError{}
+			if !errors.As(err, &rpcError) {
+				return nil, err
+			}
+			errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}
+			errorMessage.Error = rpcError
+			return errorMessage, nil
+		}
+
+		mempoolEntriesByAddresses = append(mempoolEntriesByAddresses, orphanPoolEntriesByAddress...)
+	}
+
+	return appmessage.NewGetMempoolEntriesByAddressesResponseMessage(mempoolEntriesByAddresses), nil
+}
+
+//TO DO: optimize extractMempoolEntriesByAddressesFromTransactions
+func extractMempoolEntriesByAddressesFromTransactions(context *rpccontext.Context, addresses []string, transactions []*externalapi.DomainTransaction, areOrphans bool) ([]*appmessage.MempoolEntryByAddress, error) {
+	mempoolEntriesByAddresses := make([]*appmessage.MempoolEntryByAddress, 0)
+	for _, addressString := range addresses {
+		_, err := util.DecodeAddress(addressString, context.Config.ActiveNetParams.Prefix)
+		if err != nil {
+			return nil, appmessage.RPCErrorf("Could not decode address '%s': %s", addressString, err)
+		}

 		sending := make([]*appmessage.MempoolEntry, 0)
 		receiving := make([]*appmessage.MempoolEntry, 0)

-		scriptPublicKey, err := txscript.PayToAddrScript(address)
-		if err != nil {
-			errorMessage := &appmessage.GetMempoolEntriesByAddressesResponseMessage{}
-			errorMessage.Error = appmessage.RPCErrorf("Could not extract scriptPublicKey from address '%s': %s", addressString, err)
-			return errorMessage, nil
+		for _, transaction := range transactions {
+
+			for i, input := range transaction.Inputs {
+				if input.UTXOEntry == nil {
+					if !areOrphans { // Orphans can legitimately have `input.UTXOEntry == nil`
+						// TODO: Fix the underlying cause of the bug for non-orphan entries
+						log.Debugf(
+							"Couldn't find UTXO entry for input %d in mempool transaction %s. This is a bug and should be fixed.",
+							i, consensushashing.TransactionID(transaction))
+					}
+					continue
 				}

-		if !getMempoolEntriesByAddressesRequest.FilterTransactionPool {
-
-			if transaction, found := sendingInTransactionPool[scriptPublicKey.String()]; found {
-				rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
-				err := context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
+				_, transactionSendingAddress, err := txscript.ExtractScriptPubKeyAddress(
+					input.UTXOEntry.ScriptPublicKey(),
+					context.Config.ActiveNetParams)
 				if err != nil {
 					return nil, err
 				}
-
-				sending = append(sending, &appmessage.MempoolEntry{
+				if addressString == transactionSendingAddress.String() {
+					rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
+					sending = append(
+						sending,
+						&appmessage.MempoolEntry{
 							Fee:         transaction.Fee,
 							Transaction: rpcTransaction,
-					IsOrphan:    false,
+							IsOrphan:    areOrphans,
 						},
 					)
+					break //one input is enough
+				}
 			}

-			if transaction, found := receivingInTransactionPool[scriptPublicKey.String()]; found {
-				rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
-				err := context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
+			for _, output := range transaction.Outputs {
+				_, transactionReceivingAddress, err := txscript.ExtractScriptPubKeyAddress(
+					output.ScriptPublicKey,
+					context.Config.ActiveNetParams,
+				)
 				if err != nil {
 					return nil, err
 				}
-
-				receiving = append(receiving, &appmessage.MempoolEntry{
-					Fee:         transaction.Fee,
-					Transaction: rpcTransaction,
-					IsOrphan:    false,
-				},
-				)
-			}
-		}
-		if getMempoolEntriesByAddressesRequest.IncludeOrphanPool {
-
-			if transaction, found := sendingInOrphanPool[scriptPublicKey.String()]; found {
+				if addressString == transactionReceivingAddress.String() {
 					rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
-				err := context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
-				if err != nil {
-					return nil, err
-				}
-
-				sending = append(sending, &appmessage.MempoolEntry{
+					receiving = append(
+						receiving,
+						&appmessage.MempoolEntry{
 							Fee:         transaction.Fee,
 							Transaction: rpcTransaction,
-					IsOrphan:    true,
+							IsOrphan:    areOrphans,
 						},
 					)
+					break //one output is enough
+				}
 			}

-			if transaction, found := receivingInOrphanPool[scriptPublicKey.String()]; found {
-				rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
-				err := context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
-				if err != nil {
-					return nil, err
-				}
-
-				receiving = append(receiving, &appmessage.MempoolEntry{
-					Fee:         transaction.Fee,
-					Transaction: rpcTransaction,
-					IsOrphan:    true,
-				},
-				)
-			}
-
-		}
-
+			//Only append mempoolEntriesByAddress, if at least 1 mempoolEntry for the address is found.
+			//This mimics the behaviour of GetUtxosByAddresses RPC call.
 			if len(sending) > 0 || len(receiving) > 0 {
 				mempoolEntriesByAddresses = append(
 					mempoolEntriesByAddresses,
 					&appmessage.MempoolEntryByAddress{
-					Address:   address.String(),
+						Address:   addressString,
 						Sending:   sending,
 						Receiving: receiving,
 					},
@ -118,5 +146,6 @@ func HandleGetMempoolEntriesByAddresses(context *rpccontext.Context, _ *router.R
 			}
 		}

-	return appmessage.NewGetMempoolEntriesByAddressesResponseMessage(mempoolEntriesByAddresses), nil
+	}
+	return mempoolEntriesByAddresses, nil
 }
--- a/app/rpc/rpchandlers/get_mempool_entry.go
+++ b/app/rpc/rpchandlers/get_mempool_entry.go
@ -24,7 +24,14 @@ func HandleGetMempoolEntry(context *rpccontext.Context, _ *router.Router, reques
 		return errorMessage, nil
 	}

-	mempoolTransaction, isOrphan, found := context.Domain.MiningManager().GetTransaction(transactionID, !getMempoolEntryRequest.FilterTransactionPool, getMempoolEntryRequest.IncludeOrphanPool)
+	if !getMempoolEntryRequest.FilterTransactionPool {
+		transaction, found = context.Domain.MiningManager().GetTransaction(transactionID)
+	}
+
+	if getMempoolEntryRequest.IncludeOrphanPool && !found {
+		transaction, found = context.Domain.MiningManager().GetOrphanTransaction(transactionID)
+		isOrphan = true
+	}

 	if !found {
 		errorMessage := &appmessage.GetMempoolEntryResponseMessage{}
@ -32,7 +39,7 @@ func HandleGetMempoolEntry(context *rpccontext.Context, _ *router.Router, reques
 		return errorMessage, nil
 	}

-	rpcTransaction := appmessage.DomainTransactionToRPCTransaction(mempoolTransaction)
+	rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
 	err = context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
 	if err != nil {
 		return nil, err
--- a/app/rpc/rpchandlers/notify_utxos_changed.go
+++ b/app/rpc/rpchandlers/notify_utxos_changed.go
@ -26,7 +26,7 @@ func HandleNotifyUTXOsChanged(context *rpccontext.Context, router *router.Router
 	if err != nil {
 		return nil, err
 	}
-	context.NotificationManager.PropagateUTXOsChangedNotifications(listener, addresses)
+	listener.PropagateUTXOsChangedNotifications(addresses)

 	response := appmessage.NewNotifyUTXOsChangedResponseMessage()
 	return response, nil
--- a/app/rpc/rpchandlers/stop_notifying_utxos_changed.go
+++ b/app/rpc/rpchandlers/stop_notifying_utxos_changed.go
@ -26,7 +26,7 @@ func HandleStopNotifyingUTXOsChanged(context *rpccontext.Context, router *router
 	if err != nil {
 		return nil, err
 	}
-	context.NotificationManager.StopPropagatingUTXOsChangedNotifications(listener, addresses)
+	listener.StopPropagatingUTXOsChangedNotifications(addresses)

 	response := appmessage.NewStopNotifyingUTXOsChangedResponseMessage()
 	return response, nil
--- a/app/rpc/rpchandlers/submit_transaction.go
+++ b/app/rpc/rpchandlers/submit_transaction.go
@ -28,8 +28,7 @@ func HandleSubmitTransaction(context *rpccontext.Context, _ *router.Router, requ
 		}

 		log.Debugf("Rejected transaction %s: %s", transactionID, err)
-		// Return the ID also in the case of error, so that clients can match the response to the correct transaction submit request
-		errorMessage := appmessage.NewSubmitTransactionResponseMessage(transactionID.String())
+		errorMessage := &appmessage.SubmitTransactionResponseMessage{}
 		errorMessage.Error = appmessage.RPCErrorf("Rejected transaction %s: %s", transactionID, err)
 		return errorMessage, nil
 	}
--- a/build_and_test.sh
+++ b/build_and_test.sh
@ -5,10 +5,13 @@ FLAGS=$@
 go version

 go get $FLAGS -t -d ./...
+GO111MODULE=off go get $FLAGS golang.org/x/lint/golint
 go install $FLAGS honnef.co/go/tools/cmd/staticcheck@latest

 test -z "$(go fmt ./...)"

+golint -set_exit_status ./...
+
 staticcheck -checks SA4006,SA4008,SA4009,SA4010,SA5003,SA1004,SA1014,SA1021,SA1023,SA1024,SA1025,SA1026,SA1027,SA1028,SA2000,SA2001,SA2003,SA4000,SA4001,SA4003,SA4004,SA4011,SA4012,SA4013,SA4014,SA4015,SA4016,SA4017,SA4018,SA4019,SA4020,SA4021,SA4022,SA4023,SA5000,SA5002,SA5004,SA5005,SA5007,SA5008,SA5009,SA5010,SA5011,SA5012,SA6001,SA6002,SA9001,SA9002,SA9003,SA9004,SA9005,SA9006,ST1019 ./...

 go build $FLAGS -o kaspad .
--- a/changelog.txt
+++ b/changelog.txt
@ -1,119 +1,3 @@
-Kaspad v0.12.17 - 2024-02-19
-===========================
-
-* Wallet-related improvements and fixes (#2253, #2257, #2258, #2262)
-
-Kaspad v0.12.16 - 2023-12-25
-===========================
-
-* Adapt wallet UTXO selection to dust patch (#2254)
-
-Kaspad v0.12.15 - 2023-12-16
-===========================
-
-* Update ECDSA address test to use a valid public key (#2202)
-* Fix off by small amounts in sent amount kaspa (#2220)
-* Use removeRedeemers correctly by (#2235)
-* Fix windows asset building by increasing go version (#2245)
-* Added a mainnet dnsseeder (#2247)
-* Fix extract atomic swap data pushes (#2203)
-* Adapt kaspawallet to support testnet 11 (#2211)
-* Fix type detection in RemoveInvalidTransactions (#2252)
-
-Kaspad v0.12.14 - 2023-09-26
-===========================
-
-* Anti-spam measurements against dust attack (#2223)
-
-Kaspad v0.12.13 - 2023-03-06
-===========================
-
-* Bump golang.org/x/crypto from 0.0.0-20210513164829-c07d793c2f9a to 0.1.0 (#2195)
-* Bump golang.org/x/net from 0.0.0-20210405180319-a5a99cb37ef4 to 0.7.0 (#2194)
-* Avoid sending transactions with no funds (#2193)
-
-Kaspad v0.12.12 - 2023-03-06
-===========================
-
-* Rename last references to blockheight (#2089)
-* Add code of conduct (#2183)
-* Extend TestGetPreciseSigOps with more tests (#2188)
-* Add Dockerfile to kaspawallet (#2187)
-* Add `--send-all` to `kaspawallet send` command (#2181)
-* Bump golang.org/x/text from 0.3.5 to 0.3.8 (#2190)
-* Upgrade to go 1.19 (#2191)
-
-Kaspad v0.12.11 - 2022-12-1
-===========================
-
-* Fix IBD sync conditions (#2174)
-
-Kaspad v0.12.10 - 2022-11-23
-===========================
-
-* Increase devnet's initial difficulty (#2167)
-
-Bug fixes:
-* Check rule errors when validating blocks with trusted data (#2171)
-* Compare blue score with selected tip when checking if a pruning point proof is needed (#2169)
-* Add found to GetBlock (#2165)
-
-Wallet new features:
-* Use one of the From addresses as a change address (#2164)
-
-Kaspad v0.12.9 - 2022-10-23
-===========================
-
-* Create directory before locking lock file (#2160)
-
-Kaspad v0.12.8 - 2022-10-23
-===========================
-
-* Remove hard fork activation rules (#2152)
-* Add lock file to kaspawallet (#2154)
-* Add a new testnet DNS seeder (#2156)
-* Use utxo diff algo for pruning point move and use acceptance data method only as a fall-back (#2157)
-* Make more checks if status is invalid even if the block exists (#2158)
-
-
-Kaspad v0.12.7 - 2022-09-21
-===========================
-
-* Security Fix + Hard fork - Full details can be seen here: https://medium.com/@michaelsuttonil/kaspa-security-patch-and-hard-fork-september-2022-12da617b0094
-
-Kaspad v0.12.6 - 2022-09-09
-===========================
-
-* Remove tests from docker files (#2133)
-
-Wallet new features:
-* Optionally show serialized transactions on send (#2135)
-
-Bug fixes:
-* Update virtual on IBD if nearly synced (#2134)
-
-Kaspad v0.12.5 - 2022-08-28
-===========================
-
-* Add tests for hash writers (#2120)
-* Replace daglabs's dnsseeder with Wolfie's (#2119)
-* Change testnet dnsseeder (#2126)
-* Add RPC timeout parameter to wallet daemon (#2104)
-
-Wallet new features:
-* Add UseExistingChangeAddress option to the wallet (#2127)
-
-Bug fixes:
-* Call update pruning point if required on resolve virtual or startup (#2129)
-* Add missing locks to notification listener modifications (#2124)
-* Calculate pruning point utxo set from acceptance data (#2123)
-* Fix RPC client memory/goroutine leak (#2122)
-* Fix a subtle lock sync issue in consensus insert block  (#2121)
-* Mempool: Retrieve stable state of the mempool. Optimze get mempool entries by addresses (#2111)
-* Kaspawallet.send(): Make separate context for Broadcast, to prolong timeout (#2131)
-
-
-
 Kaspad v0.12.4 - 2022-07-17
 ===========================

--- a/cmd/kaspactl/README.md
+++ b/cmd/kaspactl/README.md
@ -4,7 +4,7 @@ kaspactl is an RPC client for kaspad

 ## Requirements

-Go 1.23 or later.
+Go 1.18 or later.

 ## Installation

--- a/cmd/kaspactl/docker/Dockerfile
+++ b/cmd/kaspactl/docker/Dockerfile
@ -1,11 +1,13 @@
 # -- multistage docker build: stage #1: build stage
-FROM golang:1.23-alpine AS build
+FROM golang:1.18-alpine AS build

 RUN mkdir -p /go/src/github.com/kaspanet/kaspad

 WORKDIR /go/src/github.com/kaspanet/kaspad

 RUN apk add --no-cache curl git openssh binutils gcc musl-dev
+RUN go get -u golang.org/x/lint/golint \
+              honnef.co/go/tools/cmd/staticcheck 

 COPY go.mod .
 COPY go.sum .
@ -16,6 +18,10 @@ COPY . .

 WORKDIR /go/src/github.com/kaspanet/kaspad/cmd/kaspactl

+RUN GOFMT_RESULT=`go fmt ./...`; echo $GOFMT_RESULT; test -z "$GOFMT_RESULT"
+RUN go vet ./...
+RUN golint -set_exit_status ./...
+RUN staticcheck -checks SA4006 ./...
 RUN GOOS=linux go build -a -installsuffix cgo -o kaspactl .

 # --- multistage docker build: stage #2: runtime image
--- a/cmd/kaspaminer/README.md
+++ b/cmd/kaspaminer/README.md
@ -4,7 +4,7 @@ Kaspaminer is a CPU-based miner for kaspad

 ## Requirements

-Go 1.23 or later.
+Go 1.18 or later.

 ## Installation

@ -40,7 +40,6 @@ $ kaspaminer --help
 ```

 But the minimum configuration needed to run it is:
-
 ```bash
 $ kaspaminer --miningaddr=<YOUR_MINING_ADDRESS>
 ```
--- a/cmd/kaspaminer/docker/Dockerfile
+++ b/cmd/kaspaminer/docker/Dockerfile
@ -1,11 +1,13 @@
 # -- multistage docker build: stage #1: build stage
-FROM golang:1.23-alpine AS build
+FROM golang:1.18-alpine AS build

 RUN mkdir -p /go/src/github.com/kaspanet/kaspad

 WORKDIR /go/src/github.com/kaspanet/kaspad

 RUN apk add --no-cache curl git openssh binutils gcc musl-dev
+RUN go get -u golang.org/x/lint/golint \
+              honnef.co/go/tools/cmd/staticcheck 

 COPY go.mod .
 COPY go.sum .
@ -15,6 +17,11 @@ RUN go mod download
 COPY . .

 WORKDIR /go/src/github.com/kaspanet/kaspad/cmd/kaspaminer
+
+RUN GOFMT_RESULT=`go fmt ./...`; echo $GOFMT_RESULT; test -z "$GOFMT_RESULT"
+RUN go vet ./...
+RUN golint -set_exit_status ./...
+RUN staticcheck -checks SA4006 ./...
 RUN GOOS=linux go build -a -installsuffix cgo -o kaspaminer .

 # --- multistage docker build: stage #2: runtime image
--- a/cmd/kaspawallet/broadcast.go
+++ b/cmd/kaspawallet/broadcast.go
@ -8,7 +8,6 @@ import (

 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/client"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/server"
 	"github.com/pkg/errors"
 )

@ -38,7 +37,7 @@ func broadcast(conf *broadcastConfig) error {
 		transactionsHex = strings.TrimSpace(string(transactionHexBytes))
 	}

-	transactions, err := server.DecodeTransactionsFromHex(transactionsHex)
+	transactions, err := decodeTransactionsFromHex(transactionsHex)
 	if err != nil {
 		return err
 	}
--- a/cmd/kaspawallet/broadcast_replacement.go
+++ b/cmd/kaspawallet/broadcast_replacement.go
@ -1,57 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"io/ioutil"
-	"strings"
-
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/client"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/server"
-	"github.com/pkg/errors"
-)
-
-func broadcastReplacement(conf *broadcastConfig) error {
-	daemonClient, tearDown, err := client.Connect(conf.DaemonAddress)
-	if err != nil {
-		return err
-	}
-	defer tearDown()
-
-	ctx, cancel := context.WithTimeout(context.Background(), daemonTimeout)
-	defer cancel()
-
-	if conf.Transactions == "" && conf.TransactionsFile == "" {
-		return errors.Errorf("Either --transaction or --transaction-file is required")
-	}
-	if conf.Transactions != "" && conf.TransactionsFile != "" {
-		return errors.Errorf("Both --transaction and --transaction-file cannot be passed at the same time")
-	}
-
-	transactionsHex := conf.Transactions
-	if conf.TransactionsFile != "" {
-		transactionHexBytes, err := ioutil.ReadFile(conf.TransactionsFile)
-		if err != nil {
-			return errors.Wrapf(err, "Could not read hex from %s", conf.TransactionsFile)
-		}
-		transactionsHex = strings.TrimSpace(string(transactionHexBytes))
-	}
-
-	transactions, err := server.DecodeTransactionsFromHex(transactionsHex)
-	if err != nil {
-		return err
-	}
-
-	response, err := daemonClient.BroadcastReplacement(ctx, &pb.BroadcastRequest{Transactions: transactions})
-	if err != nil {
-		return err
-	}
-	fmt.Println("Transactions were sent successfully")
-	fmt.Println("Transaction ID(s): ")
-	for _, txID := range response.TxIDs {
-		fmt.Printf("\t%s\n", txID)
-	}
-
-	return nil
-}
--- a/cmd/kaspawallet/bump_fee.go
+++ b/cmd/kaspawallet/bump_fee.go
@ -1,117 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"strings"
-
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/client"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/keys"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
-	"github.com/pkg/errors"
-)
-
-func bumpFee(conf *bumpFeeConfig) error {
-	keysFile, err := keys.ReadKeysFile(conf.NetParams(), conf.KeysFile)
-	if err != nil {
-		return err
-	}
-
-	if len(keysFile.ExtendedPublicKeys) > len(keysFile.EncryptedMnemonics) {
-		return errors.Errorf("Cannot use 'bump-fee' command for multisig wallet without all of the keys")
-	}
-
-	daemonClient, tearDown, err := client.Connect(conf.DaemonAddress)
-	if err != nil {
-		return err
-	}
-	defer tearDown()
-
-	ctx, cancel := context.WithTimeout(context.Background(), daemonTimeout)
-	defer cancel()
-
-	var feePolicy *pb.FeePolicy
-	if conf.FeeRate > 0 {
-		feePolicy = &pb.FeePolicy{
-			FeePolicy: &pb.FeePolicy_ExactFeeRate{
-				ExactFeeRate: conf.FeeRate,
-			},
-		}
-	} else if conf.MaxFeeRate > 0 {
-		feePolicy = &pb.FeePolicy{
-			FeePolicy: &pb.FeePolicy_MaxFeeRate{MaxFeeRate: conf.MaxFeeRate},
-		}
-	} else if conf.MaxFee > 0 {
-		feePolicy = &pb.FeePolicy{
-			FeePolicy: &pb.FeePolicy_MaxFee{MaxFee: conf.MaxFee},
-		}
-	}
-
-	createUnsignedTransactionsResponse, err :=
-		daemonClient.BumpFee(ctx, &pb.BumpFeeRequest{
-			TxID:                     conf.TxID,
-			From:                     conf.FromAddresses,
-			UseExistingChangeAddress: conf.UseExistingChangeAddress,
-			FeePolicy:                feePolicy,
-		})
-	if err != nil {
-		return err
-	}
-
-	if len(conf.Password) == 0 {
-		conf.Password = keys.GetPassword("Password:")
-	}
-	mnemonics, err := keysFile.DecryptMnemonics(conf.Password)
-	if err != nil {
-		if strings.Contains(err.Error(), "message authentication failed") {
-			fmt.Fprintf(os.Stderr, "Password decryption failed. Sometimes this is a result of not "+
-				"specifying the same keys file used by the wallet daemon process.\n")
-		}
-		return err
-	}
-
-	signedTransactions := make([][]byte, len(createUnsignedTransactionsResponse.Transactions))
-	for i, unsignedTransaction := range createUnsignedTransactionsResponse.Transactions {
-		signedTransaction, err := libkaspawallet.Sign(conf.NetParams(), mnemonics, unsignedTransaction, keysFile.ECDSA)
-		if err != nil {
-			return err
-		}
-		signedTransactions[i] = signedTransaction
-	}
-
-	fmt.Printf("Broadcasting %d transaction(s)\n", len(signedTransactions))
-	// Since we waited for user input when getting the password, which could take unbound amount of time -
-	// create a new context for broadcast, to reset the timeout.
-	broadcastCtx, broadcastCancel := context.WithTimeout(context.Background(), daemonTimeout)
-	defer broadcastCancel()
-
-	const chunkSize = 100 // To avoid sending a message bigger than the gRPC max message size, we split it to chunks
-	for offset := 0; offset < len(signedTransactions); offset += chunkSize {
-		end := len(signedTransactions)
-		if offset+chunkSize <= len(signedTransactions) {
-			end = offset + chunkSize
-		}
-
-		chunk := signedTransactions[offset:end]
-		response, err := daemonClient.BroadcastReplacement(broadcastCtx, &pb.BroadcastRequest{Transactions: chunk})
-		if err != nil {
-			return err
-		}
-		fmt.Printf("Broadcasted %d transaction(s) (broadcasted %.2f%% of the transactions so far)\n", len(chunk), 100*float64(end)/float64(len(signedTransactions)))
-		fmt.Println("Broadcasted Transaction ID(s): ")
-		for _, txID := range response.TxIDs {
-			fmt.Printf("\t%s\n", txID)
-		}
-	}
-
-	if conf.Verbose {
-		fmt.Println("Serialized Transaction(s) (can be parsed via the `parse` command or resent via `broadcast`): ")
-		for _, signedTx := range signedTransactions {
-			fmt.Printf("\t%x\n\n", signedTx)
-		}
-	}
-
-	return nil
-}
--- a/cmd/kaspawallet/bump_fee_unsigned.go
+++ b/cmd/kaspawallet/bump_fee_unsigned.go
@ -1,58 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"os"
-
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/client"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/server"
-)
-
-func bumpFeeUnsigned(conf *bumpFeeUnsignedConfig) error {
-	daemonClient, tearDown, err := client.Connect(conf.DaemonAddress)
-	if err != nil {
-		return err
-	}
-	defer tearDown()
-
-	ctx, cancel := context.WithTimeout(context.Background(), daemonTimeout)
-	defer cancel()
-
-	if err != nil {
-		return err
-	}
-
-	var feePolicy *pb.FeePolicy
-	if conf.FeeRate > 0 {
-		feePolicy = &pb.FeePolicy{
-			FeePolicy: &pb.FeePolicy_ExactFeeRate{
-				ExactFeeRate: conf.FeeRate,
-			},
-		}
-	} else if conf.MaxFeeRate > 0 {
-		feePolicy = &pb.FeePolicy{
-			FeePolicy: &pb.FeePolicy_MaxFeeRate{MaxFeeRate: conf.MaxFeeRate},
-		}
-	} else if conf.MaxFee > 0 {
-		feePolicy = &pb.FeePolicy{
-			FeePolicy: &pb.FeePolicy_MaxFee{MaxFee: conf.MaxFee},
-		}
-	}
-
-	response, err := daemonClient.BumpFee(ctx, &pb.BumpFeeRequest{
-		TxID:                     conf.TxID,
-		From:                     conf.FromAddresses,
-		UseExistingChangeAddress: conf.UseExistingChangeAddress,
-		FeePolicy:                feePolicy,
-	})
-	if err != nil {
-		return err
-	}
-
-	fmt.Fprintln(os.Stderr, "Created unsigned transaction")
-	fmt.Println(server.EncodeTransactionsToHex(response.Transactions))
-
-	return nil
-}
--- a/cmd/kaspawallet/config.go
+++ b/cmd/kaspawallet/config.go
@ -22,11 +22,6 @@ const (
 	newAddressSubCmd                = "new-address"
 	dumpUnencryptedDataSubCmd       = "dump-unencrypted-data"
 	startDaemonSubCmd               = "start-daemon"
-	versionSubCmd                   = "version"
-	getDaemonVersionSubCmd          = "get-daemon-version"
-	bumpFeeSubCmd                   = "bump-fee"
-	bumpFeeUnsignedSubCmd           = "bump-fee-unsigned"
-	broadcastReplacementSubCmd      = "broadcast-replacement"
 )

 const (
@ -35,7 +30,6 @@ const (
 )

 type configFlags struct {
-	ShowVersion bool `short:"V" long:"version" description:"Display version information and exit"`
 	config.NetworkFlags
 }

@ -62,14 +56,8 @@ type sendConfig struct {
 	Password      string   `long:"password" short:"p" description:"Wallet password"`
 	DaemonAddress string   `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to"`
 	ToAddress     string   `long:"to-address" short:"t" description:"The public address to send Kaspa to" required:"true"`
-	FromAddresses            []string `long:"from-address" short:"a" description:"Specific public address to send Kaspa from. Repeat multiple times (adding -a before each) to accept several addresses" required:"false"`
-	SendAmount               string   `long:"send-amount" short:"v" description:"An amount to send in Kaspa (e.g. 1234.12345678)"`
-	IsSendAll                bool     `long:"send-all" description:"Send all the Kaspa in the wallet (mutually exclusive with --send-amount). If --from-address was used, will send all only from the specified addresses."`
-	UseExistingChangeAddress bool     `long:"use-existing-change-address" short:"u" description:"Will use an existing change address (in case no change address was ever used, it will use a new one)"`
-	MaxFeeRate               float64  `long:"max-fee-rate" short:"m" description:"Maximum fee rate in Sompi/gram to use for the transaction. The wallet will take the minimum between the fee rate estimate from the connected node and this value."`
-	FeeRate                  float64  `long:"fee-rate" short:"r" description:"Fee rate in Sompi/gram to use for the transaction. This option will override any fee estimate from the connected node."`
-	MaxFee                   uint64   `long:"max-fee" short:"x" description:"Maximum fee in Sompi (not Sompi/gram) to use for the transaction. The wallet will take the minimum between the fee estimate from the connected node and this value. If no other fee policy is specified, it will set the max fee to 1 KAS"`
-	Verbose                  bool     `long:"show-serialized" short:"s" description:"Show a list of hex encoded sent transactions"`
+	FromAddresses []string `long:"from-address" short:"a" description:"Specific public address to send Kaspa from. Use multiple times to accept several addresses" required:"false"`
+	SendAmount    float64  `long:"send-amount" short:"v" description:"An amount to send in Kaspa (e.g. 1234.12345678)" required:"true"`
 	config.NetworkFlags
 }

@ -83,12 +71,7 @@ type createUnsignedTransactionConfig struct {
 	DaemonAddress string   `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to"`
 	ToAddress     string   `long:"to-address" short:"t" description:"The public address to send Kaspa to" required:"true"`
 	FromAddresses []string `long:"from-address" short:"a" description:"Specific public address to send Kaspa from. Use multiple times to accept several addresses" required:"false"`
-	SendAmount               string   `long:"send-amount" short:"v" description:"An amount to send in Kaspa (e.g. 1234.12345678)"`
-	IsSendAll                bool     `long:"send-all" description:"Send all the Kaspa in the wallet (mutually exclusive with --send-amount)"`
-	UseExistingChangeAddress bool     `long:"use-existing-change-address" short:"u" description:"Will use an existing change address (in case no change address was ever used, it will use a new one)"`
-	MaxFeeRate               float64  `long:"max-fee-rate" short:"m" description:"Maximum fee rate in Sompi/gram to use for the transaction. The wallet will take the minimum between the fee rate estimate from the connected node and this value."`
-	FeeRate                  float64  `long:"fee-rate" short:"r" description:"Fee rate in Sompi/gram to use for the transaction. This option will override any fee estimate from the connected node."`
-	MaxFee                   uint64   `long:"max-fee" short:"x" description:"Maximum fee in Sompi (not Sompi/gram) to use for the transaction. The wallet will take the minimum between the fee estimate from the connected node and this value. If no other fee policy is specified, it will set the max fee to 1 KAS"`
+	SendAmount    float64  `long:"send-amount" short:"v" description:"An amount to send in Kaspa (e.g. 1234.12345678)" required:"true"`
 	config.NetworkFlags
 }

@ -108,7 +91,6 @@ type broadcastConfig struct {
 }

 type parseConfig struct {
-	KeysFile        string `long:"keys-file" short:"f" description:"Keys file location (default: ~/.kaspawallet/keys.json (*nix), %USERPROFILE%\\AppData\\Local\\Kaspawallet\\key.json (Windows))"`
 	Transaction     string `long:"transaction" short:"t" description:"The transaction to parse (encoded in hex)"`
 	TransactionFile string `long:"transaction-file" short:"F" description:"The file containing the transaction to parse (encoded in hex)"`
 	Verbose         bool   `long:"verbose" short:"v" description:"Verbose: show transaction inputs"`
@ -129,8 +111,7 @@ type startDaemonConfig struct {
 	KeysFile  string `long:"keys-file" short:"f" description:"Keys file location (default: ~/.kaspawallet/keys.json (*nix), %USERPROFILE%\\AppData\\Local\\Kaspawallet\\key.json (Windows))"`
 	Password  string `long:"password" short:"p" description:"Wallet password"`
 	RPCServer string `long:"rpcserver" short:"s" description:"RPC server to connect to"`
-	Listen    string `long:"listen" short:"l" description:"Address to listen on (default: 0.0.0.0:8082)"`
-	Timeout   uint32 `long:"wait-timeout" short:"w" description:"Waiting timeout for RPC calls, seconds (default: 30 s)"`
+	Listen    string `short:"l" long:"listen" description:"Address to listen on (default: 0.0.0.0:8082)"`
 	Profile   string `long:"profile" description:"Enable HTTP profiling on given port -- NOTE port must be between 1024 and 65536"`
 	config.NetworkFlags
 }
@ -142,38 +123,6 @@ type dumpUnencryptedDataConfig struct {
 	config.NetworkFlags
 }

-type bumpFeeUnsignedConfig struct {
-	TxID                     string   `long:"txid" short:"i" description:"The transaction ID to bump the fee for"`
-	DaemonAddress            string   `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to"`
-	FromAddresses            []string `long:"from-address" short:"a" description:"Specific public address to send Kaspa from. Use multiple times to accept several addresses" required:"false"`
-	UseExistingChangeAddress bool     `long:"use-existing-change-address" short:"u" description:"Will use an existing change address (in case no change address was ever used, it will use a new one)"`
-	MaxFeeRate               float64  `long:"max-fee-rate" short:"m" description:"Maximum fee rate in Sompi/gram to use for the transaction. The wallet will take the minimum between the fee rate estimate from the connected node and this value."`
-	FeeRate                  float64  `long:"fee-rate" short:"r" description:"Fee rate in Sompi/gram to use for the transaction. This option will override any fee estimate from the connected node."`
-	MaxFee                   uint64   `long:"max-fee" short:"x" description:"Maximum fee in Sompi (not Sompi/gram) to use for the transaction. The wallet will take the minimum between the fee estimate from the connected node and this value. If no other fee policy is specified, it will set the max fee to 1 KAS"`
-	config.NetworkFlags
-}
-
-type bumpFeeConfig struct {
-	TxID                     string   `long:"txid" short:"i" description:"The transaction ID to bump the fee for"`
-	KeysFile                 string   `long:"keys-file" short:"f" description:"Keys file location (default: ~/.kaspawallet/keys.json (*nix), %USERPROFILE%\\AppData\\Local\\Kaspawallet\\key.json (Windows))"`
-	Password                 string   `long:"password" short:"p" description:"Wallet password"`
-	DaemonAddress            string   `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to"`
-	FromAddresses            []string `long:"from-address" short:"a" description:"Specific public address to send Kaspa from. Repeat multiple times (adding -a before each) to accept several addresses" required:"false"`
-	UseExistingChangeAddress bool     `long:"use-existing-change-address" short:"u" description:"Will use an existing change address (in case no change address was ever used, it will use a new one)"`
-	MaxFeeRate               float64  `long:"max-fee-rate" short:"m" description:"Maximum fee rate in Sompi/gram to use for the transaction. The wallet will take the minimum between the fee rate estimate from the connected node and this value."`
-	FeeRate                  float64  `long:"fee-rate" short:"r" description:"Fee rate in Sompi/gram to use for the transaction. This option will override any fee estimate from the connected node."`
-	MaxFee                   uint64   `long:"max-fee" short:"x" description:"Maximum fee in Sompi (not Sompi/gram) to use for the transaction. The wallet will take the minimum between the fee estimate from the connected node and this value. If no other fee policy is specified, it will set the max fee to 1 KAS"`
-	Verbose                  bool     `long:"show-serialized" short:"s" description:"Show a list of hex encoded sent transactions"`
-	config.NetworkFlags
-}
-
-type versionConfig struct {
-}
-
-type getDaemonVersionConfig struct {
-	DaemonAddress string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to"`
-}
-
 func parseCommandLine() (subCommand string, config interface{}) {
 	cfg := &configFlags{}
 	parser := flags.NewParser(cfg, flags.PrintErrors|flags.HelpFlag)
@ -230,17 +179,9 @@ func parseCommandLine() (subCommand string, config interface{}) {
 		Listen:    defaultListen,
 	}
 	parser.AddCommand(startDaemonSubCmd, "Start the wallet daemon", "Start the wallet daemon", startDaemonConf)
-	parser.AddCommand(versionSubCmd, "Get the wallet version", "Get the wallet version", &versionConfig{})
-	getDaemonVersionConf := &getDaemonVersionConfig{DaemonAddress: defaultListen}
-	parser.AddCommand(getDaemonVersionSubCmd, "Get the wallet daemon version", "Get the wallet daemon version", getDaemonVersionConf)
-	bumpFeeConf := &bumpFeeConfig{DaemonAddress: defaultListen}
-	parser.AddCommand(bumpFeeSubCmd, "Bump transaction fee (with signing and broadcast)", "Bump transaction fee (with signing and broadcast)", bumpFeeConf)
-	bumpFeeUnsignedConf := &bumpFeeUnsignedConfig{DaemonAddress: defaultListen}
-	parser.AddCommand(bumpFeeUnsignedSubCmd, "Bump transaction fee (without signing)", "Bump transaction fee (without signing)", bumpFeeUnsignedConf)
-	parser.AddCommand(broadcastReplacementSubCmd, "Broadcast the given transaction replacement",
-		"Broadcast the given transaction replacement", broadcastConf)

 	_, err := parser.Parse()
+
 	if err != nil {
 		var flagsErr *flags.Error
 		if ok := errors.As(err, &flagsErr); ok && flagsErr.Type == flags.ErrHelp {
@ -272,10 +213,6 @@ func parseCommandLine() (subCommand string, config interface{}) {
 		if err != nil {
 			printErrorAndExit(err)
 		}
-		err = validateSendConfig(sendConf)
-		if err != nil {
-			printErrorAndExit(err)
-		}
 		config = sendConf
 	case sweepSubCmd:
 		combineNetworkFlags(&sweepConf.NetworkFlags, &cfg.NetworkFlags)
@ -290,10 +227,6 @@ func parseCommandLine() (subCommand string, config interface{}) {
 		if err != nil {
 			printErrorAndExit(err)
 		}
-		err = validateCreateUnsignedTransactionConf(createUnsignedTransactionConf)
-		if err != nil {
-			printErrorAndExit(err)
-		}
 		config = createUnsignedTransactionConf
 	case signSubCmd:
 		combineNetworkFlags(&signConf.NetworkFlags, &cfg.NetworkFlags)
@ -309,13 +242,6 @@ func parseCommandLine() (subCommand string, config interface{}) {
 			printErrorAndExit(err)
 		}
 		config = broadcastConf
-	case broadcastReplacementSubCmd:
-		combineNetworkFlags(&broadcastConf.NetworkFlags, &cfg.NetworkFlags)
-		err := broadcastConf.ResolveNetwork(parser)
-		if err != nil {
-			printErrorAndExit(err)
-		}
-		config = broadcastConf
 	case parseSubCmd:
 		combineNetworkFlags(&parseConf.NetworkFlags, &cfg.NetworkFlags)
 		err := parseConf.ResolveNetwork(parser)
@ -351,123 +277,11 @@ func parseCommandLine() (subCommand string, config interface{}) {
 			printErrorAndExit(err)
 		}
 		config = startDaemonConf
-	case versionSubCmd:
-	case getDaemonVersionSubCmd:
-		config = getDaemonVersionConf
-	case bumpFeeSubCmd:
-		combineNetworkFlags(&bumpFeeConf.NetworkFlags, &cfg.NetworkFlags)
-		err := bumpFeeConf.ResolveNetwork(parser)
-		if err != nil {
-			printErrorAndExit(err)
-		}
-
-		err = validateBumpFeeConfig(bumpFeeConf)
-		if err != nil {
-			printErrorAndExit(err)
-		}
-
-		config = bumpFeeConf
-	case bumpFeeUnsignedSubCmd:
-		combineNetworkFlags(&bumpFeeUnsignedConf.NetworkFlags, &cfg.NetworkFlags)
-		err := bumpFeeUnsignedConf.ResolveNetwork(parser)
-		if err != nil {
-			printErrorAndExit(err)
-		}
-
-		err = validateBumpFeeUnsignedConfig(bumpFeeUnsignedConf)
-		if err != nil {
-			printErrorAndExit(err)
-		}
-
-		config = bumpFeeUnsignedConf
 	}

 	return parser.Command.Active.Name, config
 }

-func validateCreateUnsignedTransactionConf(conf *createUnsignedTransactionConfig) error {
-	if (!conf.IsSendAll && conf.SendAmount == "") ||
-		(conf.IsSendAll && conf.SendAmount != "") {
-
-		return errors.New("exactly one of '--send-amount' or '--all' must be specified")
-	}
-
-	if conf.MaxFeeRate < 0 {
-		return errors.New("--max-fee-rate must be a positive number")
-	}
-
-	if conf.FeeRate < 0 {
-		return errors.New("--fee-rate must be a positive number")
-	}
-
-	if boolToUint8(conf.MaxFeeRate > 0)+boolToUint8(conf.FeeRate > 0)+boolToUint8(conf.MaxFee > 0) > 1 {
-		return errors.New("at most one of '--max-fee-rate', '--fee-rate' or '--max-fee' can be specified")
-	}
-
-	return nil
-}
-
-func validateSendConfig(conf *sendConfig) error {
-	if (!conf.IsSendAll && conf.SendAmount == "") ||
-		(conf.IsSendAll && conf.SendAmount != "") {
-
-		return errors.New("exactly one of '--send-amount' or '--all' must be specified")
-	}
-
-	if conf.MaxFeeRate < 0 {
-		return errors.New("--max-fee-rate must be a positive number")
-	}
-
-	if conf.FeeRate < 0 {
-		return errors.New("--fee-rate must be a positive number")
-	}
-
-	if boolToUint8(conf.MaxFeeRate > 0)+boolToUint8(conf.FeeRate > 0)+boolToUint8(conf.MaxFee > 0) > 1 {
-		return errors.New("at most one of '--max-fee-rate', '--fee-rate' or '--max-fee' can be specified")
-	}
-
-	return nil
-}
-
-func validateBumpFeeConfig(conf *bumpFeeConfig) error {
-	if conf.MaxFeeRate < 0 {
-		return errors.New("--max-fee-rate must be a positive number")
-	}
-
-	if conf.FeeRate < 0 {
-		return errors.New("--fee-rate must be a positive number")
-	}
-
-	if boolToUint8(conf.MaxFeeRate > 0)+boolToUint8(conf.FeeRate > 0)+boolToUint8(conf.MaxFee > 0) > 1 {
-		return errors.New("at most one of '--max-fee-rate', '--fee-rate' or '--max-fee' can be specified")
-	}
-
-	return nil
-}
-
-func validateBumpFeeUnsignedConfig(conf *bumpFeeUnsignedConfig) error {
-	if conf.MaxFeeRate < 0 {
-		return errors.New("--max-fee-rate must be a positive number")
-	}
-
-	if conf.FeeRate < 0 {
-		return errors.New("--fee-rate must be a positive number")
-	}
-
-	if boolToUint8(conf.MaxFeeRate > 0)+boolToUint8(conf.FeeRate > 0)+boolToUint8(conf.MaxFee > 0) > 1 {
-		return errors.New("at most one of '--max-fee-rate', '--fee-rate' or '--max-fee' can be specified")
-	}
-
-	return nil
-}
-
-func boolToUint8(b bool) uint8 {
-	if b {
-		return 1
-	}
-	return 0
-}
-
 func combineNetworkFlags(dst, src *config.NetworkFlags) {
 	dst.Testnet = dst.Testnet || src.Testnet
 	dst.Simnet = dst.Simnet || src.Simnet
--- a/cmd/kaspawallet/create.go
+++ b/cmd/kaspawallet/create.go
@ -78,11 +78,6 @@ func create(conf *createConfig) error {
 		return err
 	}

-	err = file.TryLock()
-	if err != nil {
-		return err
-	}
-
 	err = file.Save()
 	if err != nil {
 		return err
--- a/cmd/kaspawallet/create_unsigned_tx.go
+++ b/cmd/kaspawallet/create_unsigned_tx.go
@ -7,8 +7,7 @@ import (

 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/client"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/server"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/utils"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
 )

 func createUnsignedTransaction(conf *createUnsignedTransactionConfig) error {
@ -21,46 +20,18 @@ func createUnsignedTransaction(conf *createUnsignedTransactionConfig) error {
 	ctx, cancel := context.WithTimeout(context.Background(), daemonTimeout)
 	defer cancel()

-	var sendAmountSompi uint64
-
-	if !conf.IsSendAll {
-		sendAmountSompi, err = utils.KasToSompi(conf.SendAmount)
-		if err != nil {
-			return err
-		}
-	}
-
-	var feePolicy *pb.FeePolicy
-	if conf.FeeRate > 0 {
-		feePolicy = &pb.FeePolicy{
-			FeePolicy: &pb.FeePolicy_ExactFeeRate{
-				ExactFeeRate: conf.FeeRate,
-			},
-		}
-	} else if conf.MaxFeeRate > 0 {
-		feePolicy = &pb.FeePolicy{
-			FeePolicy: &pb.FeePolicy_MaxFeeRate{MaxFeeRate: conf.MaxFeeRate},
-		}
-	} else if conf.MaxFee > 0 {
-		feePolicy = &pb.FeePolicy{
-			FeePolicy: &pb.FeePolicy_MaxFee{MaxFee: conf.MaxFee},
-		}
-	}
-
+	sendAmountSompi := uint64(conf.SendAmount * constants.SompiPerKaspa)
 	response, err := daemonClient.CreateUnsignedTransactions(ctx, &pb.CreateUnsignedTransactionsRequest{
 		From:    conf.FromAddresses,
 		Address: conf.ToAddress,
 		Amount:  sendAmountSompi,
-		IsSendAll:                conf.IsSendAll,
-		UseExistingChangeAddress: conf.UseExistingChangeAddress,
-		FeePolicy:                feePolicy,
 	})
 	if err != nil {
 		return err
 	}

 	fmt.Fprintln(os.Stderr, "Created unsigned transaction")
-	fmt.Println(server.EncodeTransactionsToHex(response.UnsignedTransactions))
+	fmt.Println(encodeTransactionsToHex(response.UnsignedTransactions))

 	return nil
 }
--- a/cmd/kaspawallet/daemon/client/client.go
+++ b/cmd/kaspawallet/daemon/client/client.go
@ -4,8 +4,6 @@ import (
 	"context"
 	"time"

-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/server"
-
 	"github.com/pkg/errors"

 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
@ -18,7 +16,7 @@ func Connect(address string) (pb.KaspawalletdClient, func(), error) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
 	defer cancel()

-	conn, err := grpc.DialContext(ctx, address, grpc.WithInsecure(), grpc.WithBlock(), grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(server.MaxDaemonSendMsgSize)))
+	conn, err := grpc.DialContext(ctx, address, grpc.WithInsecure(), grpc.WithBlock())
 	if err != nil {
 		if errors.Is(err, context.DeadlineExceeded) {
 			return nil, nil, errors.New("kaspawallet daemon is not running, start it with `kaspawallet start-daemon`")
--- a/cmd/kaspawallet/daemon/pb/kaspawalletd.pb.go
+++ b/cmd/kaspawallet/daemon/pb/kaspawalletd.pb.go
--- a/cmd/kaspawallet/daemon/pb/kaspawalletd.proto
+++ b/cmd/kaspawallet/daemon/pb/kaspawalletd.proto
@ -5,27 +5,20 @@ package kaspawalletd;

 service kaspawalletd {
  rpc GetBalance (GetBalanceRequest) returns (GetBalanceResponse) {}
-  rpc GetExternalSpendableUTXOs(GetExternalSpendableUTXOsRequest)
-      returns (GetExternalSpendableUTXOsResponse) {}
-  rpc CreateUnsignedTransactions(CreateUnsignedTransactionsRequest)
-      returns (CreateUnsignedTransactionsResponse) {}
+  rpc GetExternalSpendableUTXOs (GetExternalSpendableUTXOsRequest) returns (GetExternalSpendableUTXOsResponse) {}
+  rpc CreateUnsignedTransactions (CreateUnsignedTransactionsRequest) returns (CreateUnsignedTransactionsResponse) {}
  rpc ShowAddresses (ShowAddressesRequest) returns (ShowAddressesResponse) {}
  rpc NewAddress (NewAddressRequest) returns (NewAddressResponse) {}
  rpc Shutdown (ShutdownRequest) returns (ShutdownResponse) {}
  rpc Broadcast (BroadcastRequest) returns (BroadcastResponse) {}
-  // BroadcastReplacement assumes that all transactions depend on the first one
-  rpc BroadcastReplacement(BroadcastRequest) returns (BroadcastResponse) {}
-  // Since SendRequest contains a password - this command should only be used on
-  // a trusted or secure connection
+  // Since SendRequest contains a password - this command should only be used on a trusted or secure connection
  rpc Send(SendRequest) returns (SendResponse) {}
-  // Since SignRequest contains a password - this command should only be used on
-  // a trusted or secure connection
+  // Since SignRequest contains a password - this command should only be used on a trusted or secure connection
  rpc Sign(SignRequest) returns (SignResponse) {}
-  rpc GetVersion(GetVersionRequest) returns (GetVersionResponse) {}
-  rpc BumpFee(BumpFeeRequest) returns (BumpFeeResponse) {}
 }

-message GetBalanceRequest {}
+message GetBalanceRequest {
+}

 message GetBalanceResponse {
  uint64 available = 1;
@ -39,45 +32,44 @@ message AddressBalances {
  uint64 pending = 3;
 }

-message FeePolicy {
-  oneof feePolicy {
-    double maxFeeRate = 6;
-    double exactFeeRate = 7;
-    uint64 maxFee = 8;
-  }
-}
-
 message CreateUnsignedTransactionsRequest {
  string address = 1;
  uint64 amount = 2;
  repeated string from = 3;
-  bool useExistingChangeAddress = 4;
-  bool isSendAll = 5;
-  FeePolicy feePolicy = 6;
 }

 message CreateUnsignedTransactionsResponse {
  repeated bytes unsignedTransactions = 1;
 }

-message ShowAddressesRequest {}
+message ShowAddressesRequest {
+}

-message ShowAddressesResponse { repeated string address = 1; }
+message ShowAddressesResponse {
+  repeated string address = 1;
+}

-message NewAddressRequest {}
+message NewAddressRequest {
+}

-message NewAddressResponse { string address = 1; }
+message NewAddressResponse {
+  string address = 1;
+}

 message BroadcastRequest {
        bool isDomain = 1;  
        repeated bytes transactions = 2;
 }

-message BroadcastResponse { repeated string txIDs = 1; }
+message BroadcastResponse {
+  repeated string txIDs = 1;
+}

-message ShutdownRequest {}
+message ShutdownRequest {
+}

-message ShutdownResponse {}
+message ShutdownResponse {
+}

 message Outpoint {
  string transactionId = 1;
@ -102,50 +94,31 @@ message UtxoEntry {
  bool isCoinbase = 4;
 }

-message GetExternalSpendableUTXOsRequest { string address = 1; }
+message GetExternalSpendableUTXOsRequest{
+  string address = 1;
+}

 message GetExternalSpendableUTXOsResponse{
  repeated UtxosByAddressesEntry Entries = 1;
 }
-// Since SendRequest contains a password - this command should only be used on a
-// trusted or secure connection
+// Since SendRequest contains a password - this command should only be used on a trusted or secure connection
 message SendRequest{
  string toAddress = 1;
  uint64 amount = 2;
  string password = 3;
  repeated string from = 4;
-  bool useExistingChangeAddress = 5;
-  bool isSendAll = 6;
-  FeePolicy feePolicy = 7;
 }

 message SendResponse{
  repeated string txIDs = 1;
-  repeated bytes signedTransactions = 2;
 }

-// Since SignRequest contains a password - this command should only be used on a
-// trusted or secure connection
+// Since SignRequest contains a password - this command should only be used on a trusted or secure connection
 message SignRequest{
  repeated bytes unsignedTransactions = 1;
  string password = 2;
 }

-message SignResponse { repeated bytes signedTransactions = 1; }
-
-message GetVersionRequest {}
-
-message GetVersionResponse { string version = 1; }
-
-message BumpFeeRequest {
-  string password = 1;
-  repeated string from = 2;
-  bool useExistingChangeAddress = 3;
-  FeePolicy feePolicy = 4;
-  string txID = 5;
-}
-
-message BumpFeeResponse {
-  repeated bytes transactions = 1;
-  repeated string txIDs = 2;
+message SignResponse{
+  repeated bytes signedTransactions = 1;
 }
--- a/cmd/kaspawallet/daemon/pb/kaspawalletd_grpc.pb.go
+++ b/cmd/kaspawallet/daemon/pb/kaspawalletd_grpc.pb.go
@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
 // versions:
 // - protoc-gen-go-grpc v1.2.0
-// - protoc             v3.12.3
+// - protoc             v3.17.2
 // source: kaspawalletd.proto

 package pb
@ -29,16 +29,10 @@ type KaspawalletdClient interface {
 	NewAddress(ctx context.Context, in *NewAddressRequest, opts ...grpc.CallOption) (*NewAddressResponse, error)
 	Shutdown(ctx context.Context, in *ShutdownRequest, opts ...grpc.CallOption) (*ShutdownResponse, error)
 	Broadcast(ctx context.Context, in *BroadcastRequest, opts ...grpc.CallOption) (*BroadcastResponse, error)
-	// BroadcastReplacement assumes that all transactions depend on the first one
-	BroadcastReplacement(ctx context.Context, in *BroadcastRequest, opts ...grpc.CallOption) (*BroadcastResponse, error)
-	// Since SendRequest contains a password - this command should only be used on
-	// a trusted or secure connection
+	// Since SendRequest contains a password - this command should only be used on a trusted or secure connection
 	Send(ctx context.Context, in *SendRequest, opts ...grpc.CallOption) (*SendResponse, error)
-	// Since SignRequest contains a password - this command should only be used on
-	// a trusted or secure connection
+	// Since SignRequest contains a password - this command should only be used on a trusted or secure connection
 	Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error)
-	GetVersion(ctx context.Context, in *GetVersionRequest, opts ...grpc.CallOption) (*GetVersionResponse, error)
-	BumpFee(ctx context.Context, in *BumpFeeRequest, opts ...grpc.CallOption) (*BumpFeeResponse, error)
 }

 type kaspawalletdClient struct {
@ -112,15 +106,6 @@ func (c *kaspawalletdClient) Broadcast(ctx context.Context, in *BroadcastRequest
 	return out, nil
 }

-func (c *kaspawalletdClient) BroadcastReplacement(ctx context.Context, in *BroadcastRequest, opts ...grpc.CallOption) (*BroadcastResponse, error) {
-	out := new(BroadcastResponse)
-	err := c.cc.Invoke(ctx, "/kaspawalletd.kaspawalletd/BroadcastReplacement", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
 func (c *kaspawalletdClient) Send(ctx context.Context, in *SendRequest, opts ...grpc.CallOption) (*SendResponse, error) {
 	out := new(SendResponse)
 	err := c.cc.Invoke(ctx, "/kaspawalletd.kaspawalletd/Send", in, out, opts...)
@ -139,24 +124,6 @@ func (c *kaspawalletdClient) Sign(ctx context.Context, in *SignRequest, opts ...
 	return out, nil
 }

-func (c *kaspawalletdClient) GetVersion(ctx context.Context, in *GetVersionRequest, opts ...grpc.CallOption) (*GetVersionResponse, error) {
-	out := new(GetVersionResponse)
-	err := c.cc.Invoke(ctx, "/kaspawalletd.kaspawalletd/GetVersion", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-func (c *kaspawalletdClient) BumpFee(ctx context.Context, in *BumpFeeRequest, opts ...grpc.CallOption) (*BumpFeeResponse, error) {
-	out := new(BumpFeeResponse)
-	err := c.cc.Invoke(ctx, "/kaspawalletd.kaspawalletd/BumpFee", in, out, opts...)
-	if err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
 // KaspawalletdServer is the server API for Kaspawalletd service.
 // All implementations must embed UnimplementedKaspawalletdServer
 // for forward compatibility
@ -168,16 +135,10 @@ type KaspawalletdServer interface {
 	NewAddress(context.Context, *NewAddressRequest) (*NewAddressResponse, error)
 	Shutdown(context.Context, *ShutdownRequest) (*ShutdownResponse, error)
 	Broadcast(context.Context, *BroadcastRequest) (*BroadcastResponse, error)
-	// BroadcastReplacement assumes that all transactions depend on the first one
-	BroadcastReplacement(context.Context, *BroadcastRequest) (*BroadcastResponse, error)
-	// Since SendRequest contains a password - this command should only be used on
-	// a trusted or secure connection
+	// Since SendRequest contains a password - this command should only be used on a trusted or secure connection
 	Send(context.Context, *SendRequest) (*SendResponse, error)
-	// Since SignRequest contains a password - this command should only be used on
-	// a trusted or secure connection
+	// Since SignRequest contains a password - this command should only be used on a trusted or secure connection
 	Sign(context.Context, *SignRequest) (*SignResponse, error)
-	GetVersion(context.Context, *GetVersionRequest) (*GetVersionResponse, error)
-	BumpFee(context.Context, *BumpFeeRequest) (*BumpFeeResponse, error)
 	mustEmbedUnimplementedKaspawalletdServer()
 }

@ -206,21 +167,12 @@ func (UnimplementedKaspawalletdServer) Shutdown(context.Context, *ShutdownReques
 func (UnimplementedKaspawalletdServer) Broadcast(context.Context, *BroadcastRequest) (*BroadcastResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Broadcast not implemented")
 }
-func (UnimplementedKaspawalletdServer) BroadcastReplacement(context.Context, *BroadcastRequest) (*BroadcastResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method BroadcastReplacement not implemented")
-}
 func (UnimplementedKaspawalletdServer) Send(context.Context, *SendRequest) (*SendResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Send not implemented")
 }
 func (UnimplementedKaspawalletdServer) Sign(context.Context, *SignRequest) (*SignResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Sign not implemented")
 }
-func (UnimplementedKaspawalletdServer) GetVersion(context.Context, *GetVersionRequest) (*GetVersionResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method GetVersion not implemented")
-}
-func (UnimplementedKaspawalletdServer) BumpFee(context.Context, *BumpFeeRequest) (*BumpFeeResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method BumpFee not implemented")
-}
 func (UnimplementedKaspawalletdServer) mustEmbedUnimplementedKaspawalletdServer() {}

 // UnsafeKaspawalletdServer may be embedded to opt out of forward compatibility for this service.
@ -360,24 +312,6 @@ func _Kaspawalletd_Broadcast_Handler(srv interface{}, ctx context.Context, dec f
 	return interceptor(ctx, in, info, handler)
 }

-func _Kaspawalletd_BroadcastReplacement_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(BroadcastRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(KaspawalletdServer).BroadcastReplacement(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/kaspawalletd.kaspawalletd/BroadcastReplacement",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(KaspawalletdServer).BroadcastReplacement(ctx, req.(*BroadcastRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
 func _Kaspawalletd_Send_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(SendRequest)
 	if err := dec(in); err != nil {
@ -414,42 +348,6 @@ func _Kaspawalletd_Sign_Handler(srv interface{}, ctx context.Context, dec func(i
 	return interceptor(ctx, in, info, handler)
 }

-func _Kaspawalletd_GetVersion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(GetVersionRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(KaspawalletdServer).GetVersion(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/kaspawalletd.kaspawalletd/GetVersion",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(KaspawalletdServer).GetVersion(ctx, req.(*GetVersionRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
-func _Kaspawalletd_BumpFee_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(BumpFeeRequest)
-	if err := dec(in); err != nil {
-		return nil, err
-	}
-	if interceptor == nil {
-		return srv.(KaspawalletdServer).BumpFee(ctx, in)
-	}
-	info := &grpc.UnaryServerInfo{
-		Server:     srv,
-		FullMethod: "/kaspawalletd.kaspawalletd/BumpFee",
-	}
-	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(KaspawalletdServer).BumpFee(ctx, req.(*BumpFeeRequest))
-	}
-	return interceptor(ctx, in, info, handler)
-}
-
 // Kaspawalletd_ServiceDesc is the grpc.ServiceDesc for Kaspawalletd service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@ -485,10 +383,6 @@ var Kaspawalletd_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "Broadcast",
 			Handler:    _Kaspawalletd_Broadcast_Handler,
 		},
-		{
-			MethodName: "BroadcastReplacement",
-			Handler:    _Kaspawalletd_BroadcastReplacement_Handler,
-		},
 		{
 			MethodName: "Send",
 			Handler:    _Kaspawalletd_Send_Handler,
@ -497,14 +391,6 @@ var Kaspawalletd_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "Sign",
 			Handler:    _Kaspawalletd_Sign_Handler,
 		},
-		{
-			MethodName: "GetVersion",
-			Handler:    _Kaspawalletd_GetVersion_Handler,
-		},
-		{
-			MethodName: "BumpFee",
-			Handler:    _Kaspawalletd_BumpFee_Handler,
-		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "kaspawalletd.proto",
--- a/cmd/kaspawallet/daemon/server/address.go
+++ b/cmd/kaspawallet/daemon/server/address.go
@ -10,13 +10,7 @@ import (
 	"github.com/pkg/errors"
 )

-func (s *server) changeAddress(useExisting bool, fromAddresses []*walletAddress) (util.Address, *walletAddress, error) {
-	var walletAddr *walletAddress
-	if len(fromAddresses) != 0 && useExisting {
-		walletAddr = fromAddresses[0]
-	} else {
-		internalIndex := uint32(0)
-		if !useExisting {
+func (s *server) changeAddress() (util.Address, *walletAddress, error) {
 	err := s.keysFile.SetLastUsedInternalIndex(s.keysFile.LastUsedInternalIndex() + 1)
 	if err != nil {
 		return nil, nil, err
@ -27,16 +21,11 @@ func (s *server) changeAddress(useExisting bool, fromAddresses []*walletAddress)
 		return nil, nil, err
 	}

-			internalIndex = s.keysFile.LastUsedInternalIndex()
-		}
-
-		walletAddr = &walletAddress{
-			index:         internalIndex,
+	walletAddr := &walletAddress{
+		index:         s.keysFile.LastUsedInternalIndex(),
 		cosignerIndex: s.keysFile.CosignerIndex,
 		keyChain:      libkaspawallet.InternalKeychain,
 	}
-	}
-
 	path := s.walletAddressPath(walletAddr)
 	address, err := libkaspawallet.Address(s.params, s.keysFile.ExtendedPublicKeys, s.keysFile.MinimumSignatures, path, s.keysFile.ECDSA)
 	if err != nil {
--- a/cmd/kaspawallet/daemon/server/balance.go
+++ b/cmd/kaspawallet/daemon/server/balance.go
@ -2,7 +2,6 @@ package server

 import (
 	"context"
-	"github.com/pkg/errors"

 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
@ -15,15 +14,13 @@ func (s *server) GetBalance(_ context.Context, _ *pb.GetBalanceRequest) (*pb.Get
 	s.lock.RLock()
 	defer s.lock.RUnlock()

-	if !s.isSynced() {
-		return nil, errors.Errorf("wallet daemon is not synced yet, %s", s.formatSyncStateReport())
-	}
-
 	dagInfo, err := s.rpcClient.GetBlockDAGInfo()
 	if err != nil {
 		return nil, err
 	}
 	daaScore := dagInfo.VirtualDAAScore
+	maturity := s.params.BlockCoinbaseMaturity
+
 	balancesMap := make(balancesMapType, 0)
 	for _, entry := range s.utxosSortedByAmount {
 		amount := entry.UTXOEntry.Amount()
@ -33,7 +30,7 @@ func (s *server) GetBalance(_ context.Context, _ *pb.GetBalanceRequest) (*pb.Get
 			balances = new(balancesType)
 			balancesMap[address] = balances
 		}
-		if s.isUTXOSpendable(entry, daaScore) {
+		if isUTXOSpendable(entry, daaScore, maturity) {
 			balances.available += amount
 		} else {
 			balances.pending += amount
@ -58,8 +55,6 @@ func (s *server) GetBalance(_ context.Context, _ *pb.GetBalanceRequest) (*pb.Get
 		pending += balances.pending
 	}

-	log.Infof("GetBalance request scanned %d UTXOs overall over %d addresses", len(s.utxosSortedByAmount), len(balancesMap))
-
 	return &pb.GetBalanceResponse{
 		Available:       available,
 		Pending:         pending,
@ -67,9 +62,9 @@ func (s *server) GetBalance(_ context.Context, _ *pb.GetBalanceRequest) (*pb.Get
 	}, nil
 }

-func (s *server) isUTXOSpendable(entry *walletUTXO, virtualDAAScore uint64) bool {
+func isUTXOSpendable(entry *walletUTXO, virtualDAAScore uint64, coinbaseMaturity uint64) bool {
 	if !entry.UTXOEntry.IsCoinbase() {
 		return true
 	}
-	return entry.UTXOEntry.BlockDAAScore()+s.coinbaseMaturity < virtualDAAScore
+	return entry.UTXOEntry.BlockDAAScore()+coinbaseMaturity < virtualDAAScore
 }
--- a/cmd/kaspawallet/daemon/server/broadcast.go
+++ b/cmd/kaspawallet/daemon/server/broadcast.go
@ -2,16 +2,14 @@ package server

 import (
 	"context"
-	"time"
-
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet/serialization"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/kaspanet/kaspad/infrastructure/network/rpcclient"
 	"github.com/pkg/errors"
+	"time"
 )

 func (s *server) Broadcast(_ context.Context, request *pb.BroadcastRequest) (*pb.BroadcastResponse, error) {
@ -56,12 +54,16 @@ func (s *server) broadcast(transactions [][]byte, isDomain bool) ([]string, erro
 		}
 	}

-	s.forceSync()
+	err = s.refreshUTXOs()
+	if err != nil {
+		return nil, err
+	}
+
 	return txIDs, nil
 }

 func sendTransaction(client *rpcclient.RPCClient, tx *externalapi.DomainTransaction) (string, error) {
-	submitTransactionResponse, err := client.SubmitTransaction(appmessage.DomainTransactionToRPCTransaction(tx), consensushashing.TransactionID(tx).String(), false)
+	submitTransactionResponse, err := client.SubmitTransaction(appmessage.DomainTransactionToRPCTransaction(tx), false)
 	if err != nil {
 		return "", errors.Wrapf(err, "error submitting transaction")
 	}
--- a/cmd/kaspawallet/daemon/server/broadcast_replacement.go
+++ b/cmd/kaspawallet/daemon/server/broadcast_replacement.go
@ -1,81 +0,0 @@
-package server
-
-import (
-	"context"
-	"time"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet/serialization"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
-	"github.com/kaspanet/kaspad/infrastructure/network/rpcclient"
-	"github.com/pkg/errors"
-)
-
-func (s *server) BroadcastReplacement(_ context.Context, request *pb.BroadcastRequest) (*pb.BroadcastResponse, error) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	txIDs, err := s.broadcastReplacement(request.Transactions, request.IsDomain)
-	if err != nil {
-		return nil, err
-	}
-
-	return &pb.BroadcastResponse{TxIDs: txIDs}, nil
-}
-
-// broadcastReplacement assumes that all transactions depend on the first one
-func (s *server) broadcastReplacement(transactions [][]byte, isDomain bool) ([]string, error) {
-
-	txIDs := make([]string, len(transactions))
-	var tx *externalapi.DomainTransaction
-	var err error
-
-	for i, transaction := range transactions {
-
-		if isDomain {
-			tx, err = serialization.DeserializeDomainTransaction(transaction)
-			if err != nil {
-				return nil, err
-			}
-		} else if !isDomain { //default in proto3 is false
-			tx, err = libkaspawallet.ExtractTransaction(transaction, s.keysFile.ECDSA)
-			if err != nil {
-				return nil, err
-			}
-		}
-
-		// Once the first transaction is added to the mempool, the transactions that depend
-		// on the replaced transaction will be removed, so there's no need to submit them
-		// as RBF transactions.
-		if i == 0 {
-			txIDs[i], err = sendTransactionRBF(s.rpcClient, tx)
-			if err != nil {
-				return nil, err
-			}
-		} else {
-			txIDs[i], err = sendTransaction(s.rpcClient, tx)
-			if err != nil {
-				return nil, err
-			}
-
-		}
-
-		for _, input := range tx.Inputs {
-			s.usedOutpoints[input.PreviousOutpoint] = time.Now()
-		}
-	}
-
-	s.forceSync()
-	return txIDs, nil
-}
-
-func sendTransactionRBF(client *rpcclient.RPCClient, tx *externalapi.DomainTransaction) (string, error) {
-	submitTransactionResponse, err := client.SubmitTransactionReplacement(appmessage.DomainTransactionToRPCTransaction(tx), consensushashing.TransactionID(tx).String())
-	if err != nil {
-		return "", errors.Wrapf(err, "error submitting transaction replacement")
-	}
-	return submitTransactionResponse.TransactionID, nil
-}
--- a/cmd/kaspawallet/daemon/server/bump_fee.go
+++ b/cmd/kaspawallet/daemon/server/bump_fee.go
@ -1,156 +0,0 @@
-package server
-
-import (
-	"context"
-
-	"github.com/kaspanet/kaspad/app/appmessage"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
-	"github.com/pkg/errors"
-)
-
-func (s *server) BumpFee(_ context.Context, request *pb.BumpFeeRequest) (*pb.BumpFeeResponse, error) {
-	s.lock.Lock()
-	defer s.lock.Unlock()
-
-	entry, err := s.rpcClient.GetMempoolEntry(request.TxID, false, false)
-	if err != nil {
-		return nil, err
-	}
-
-	domainTx, err := appmessage.RPCTransactionToDomainTransaction(entry.Entry.Transaction)
-	if err != nil {
-		return nil, err
-	}
-
-	outpointsToInputs := make(map[externalapi.DomainOutpoint]*externalapi.DomainTransactionInput)
-	var maxUTXO *walletUTXO
-	for _, input := range domainTx.Inputs {
-		outpointsToInputs[input.PreviousOutpoint] = input
-		utxo, ok := s.mempoolExcludedUTXOs[input.PreviousOutpoint]
-		if !ok {
-			continue
-		}
-
-		input.UTXOEntry = utxo.UTXOEntry
-		if maxUTXO == nil || utxo.UTXOEntry.Amount() > maxUTXO.UTXOEntry.Amount() {
-			maxUTXO = utxo
-		}
-	}
-
-	if maxUTXO == nil {
-		// If we got here it means for some reason s.mempoolExcludedUTXOs is not up to date and we need to search for the UTXOs in s.utxosSortedByAmount
-		for _, utxo := range s.utxosSortedByAmount {
-			input, ok := outpointsToInputs[*utxo.Outpoint]
-			if !ok {
-				continue
-			}
-
-			input.UTXOEntry = utxo.UTXOEntry
-			if maxUTXO == nil || utxo.UTXOEntry.Amount() > maxUTXO.UTXOEntry.Amount() {
-				maxUTXO = utxo
-			}
-		}
-	}
-
-	if maxUTXO == nil {
-		return nil, errors.Errorf("no UTXOs were found for transaction %s. This probably means the transaction is already accepted", request.TxID)
-	}
-
-	mass := s.txMassCalculator.CalculateTransactionOverallMass(domainTx)
-	feeRate := float64(entry.Entry.Fee) / float64(mass)
-	newFeeRate, maxFee, err := s.calculateFeeLimits(request.FeePolicy)
-	if err != nil {
-		return nil, err
-	}
-
-	if feeRate >= newFeeRate {
-		return nil, errors.Errorf("new fee rate (%f) is not higher than the current fee rate (%f)", newFeeRate, feeRate)
-	}
-
-	if len(domainTx.Outputs) == 0 || len(domainTx.Outputs) > 2 {
-		return nil, errors.Errorf("kaspawallet supports only transactions with 1 or 2 outputs in transaction %s, but this transaction got %d", request.TxID, len(domainTx.Outputs))
-	}
-
-	var fromAddresses []*walletAddress
-	for _, from := range request.From {
-		fromAddress, exists := s.addressSet[from]
-		if !exists {
-			return nil, errors.Errorf("specified from address %s does not exists", from)
-		}
-		fromAddresses = append(fromAddresses, fromAddress)
-	}
-
-	allowUsed := make(map[externalapi.DomainOutpoint]struct{})
-	for outpoint := range outpointsToInputs {
-		allowUsed[outpoint] = struct{}{}
-	}
-	selectedUTXOs, spendValue, changeSompi, err := s.selectUTXOsWithPreselected([]*walletUTXO{maxUTXO}, allowUsed, domainTx.Outputs[0].Value, false, newFeeRate, maxFee, fromAddresses)
-	if err != nil {
-		return nil, err
-	}
-
-	_, toAddress, err := txscript.ExtractScriptPubKeyAddress(domainTx.Outputs[0].ScriptPublicKey, s.params)
-	if err != nil {
-		return nil, err
-	}
-
-	changeAddress, changeWalletAddress, err := s.changeAddress(request.UseExistingChangeAddress, fromAddresses)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(selectedUTXOs) == 0 {
-		return nil, errors.Errorf("couldn't find funds to spend")
-	}
-
-	payments := []*libkaspawallet.Payment{{
-		Address: toAddress,
-		Amount:  spendValue,
-	}}
-	if changeSompi > 0 {
-		changeAddress, _, err := s.changeAddress(request.UseExistingChangeAddress, fromAddresses)
-		if err != nil {
-			return nil, err
-		}
-
-		payments = append(payments, &libkaspawallet.Payment{
-			Address: changeAddress,
-			Amount:  changeSompi,
-		})
-	}
-	unsignedTransaction, err := libkaspawallet.CreateUnsignedTransaction(s.keysFile.ExtendedPublicKeys,
-		s.keysFile.MinimumSignatures,
-		payments, selectedUTXOs)
-	if err != nil {
-		return nil, err
-	}
-
-	unsignedTransactions, err := s.maybeAutoCompoundTransaction(unsignedTransaction, toAddress, changeAddress, changeWalletAddress, newFeeRate, maxFee)
-	if err != nil {
-		return nil, err
-	}
-
-	if request.Password == "" {
-		return &pb.BumpFeeResponse{
-			Transactions: unsignedTransactions,
-		}, nil
-	}
-
-	signedTransactions, err := s.signTransactions(unsignedTransactions, request.Password)
-	if err != nil {
-		return nil, err
-	}
-
-	txIDs, err := s.broadcastReplacement(signedTransactions, false)
-	if err != nil {
-		return nil, err
-	}
-
-	return &pb.BumpFeeResponse{
-		TxIDs:        txIDs,
-		Transactions: signedTransactions,
-	}, nil
-}
--- a/cmd/kaspawallet/daemon/server/create_unsigned_transaction.go
+++ b/cmd/kaspawallet/daemon/server/create_unsigned_transaction.go
@ -3,36 +3,24 @@ package server
 import (
 	"context"
 	"fmt"
-	"math"
-
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/pkg/errors"
+	"golang.org/x/exp/slices"
+	"time"
 )

-// The minimal change amount to target in order to avoid large storage mass (see KIP9 for more details).
-// By having at least 10KAS in the change output we make sure that the storage mass charged for change is
-// at most 1000 gram. Generally, if the payment is above 10KAS as well, the resulting storage mass will be
-// in the order of magnitude of compute mass and wil not incur additional charges.
-// Additionally, every transaction with send value > ~0.1 KAS should succeed (at most ~99K storage mass for payment
-// output, thus overall lower than standard mass upper bound which is 100K gram)
-const minChangeTarget = constants.SompiPerKaspa * 10
-
-// The current minimal fee rate according to mempool standards
-const minFeeRate = 1.0
+// TODO: Implement a better fee estimation mechanism
+const feePerInput = 10000

 func (s *server) CreateUnsignedTransactions(_ context.Context, request *pb.CreateUnsignedTransactionsRequest) (
-	*pb.CreateUnsignedTransactionsResponse, error,
-) {
+	*pb.CreateUnsignedTransactionsResponse, error) {
 	s.lock.Lock()
 	defer s.lock.Unlock()

-	unsignedTransactions, err := s.createUnsignedTransactions(request.Address, request.Amount, request.IsSendAll,
-		request.From, request.UseExistingChangeAddress, request.FeePolicy)
+	unsignedTransactions, err := s.createUnsignedTransactions(request.Address, request.Amount, request.From)
 	if err != nil {
 		return nil, err
 	}
@ -40,61 +28,16 @@ func (s *server) CreateUnsignedTransactions(_ context.Context, request *pb.Creat
 	return &pb.CreateUnsignedTransactionsResponse{UnsignedTransactions: unsignedTransactions}, nil
 }

-func (s *server) calculateFeeLimits(requestFeePolicy *pb.FeePolicy) (feeRate float64, maxFee uint64, err error) {
-	feeRate = minFeeRate
-	maxFee = math.MaxUint64
-
-	if requestFeePolicy == nil {
-		requestFeePolicy = &pb.FeePolicy{}
-	}
-
-	switch requestFeePolicy := requestFeePolicy.FeePolicy.(type) {
-	case *pb.FeePolicy_ExactFeeRate:
-		feeRate = requestFeePolicy.ExactFeeRate
-		if feeRate < minFeeRate {
-			return 0, 0, errors.Errorf("requested fee rate %f is too low, minimum fee rate is %f", feeRate, minFeeRate)
-		}
-	case *pb.FeePolicy_MaxFeeRate:
-		estimate, err := s.rpcClient.GetFeeEstimate()
-		if err != nil {
-			return 0, 0, err
-		}
-		if requestFeePolicy.MaxFeeRate < minFeeRate {
-			return 0, 0, errors.Errorf("requested max fee rate %f is too low, minimum fee rate is %f", requestFeePolicy.MaxFeeRate, minFeeRate)
-		}
-		feeRate = math.Min(estimate.Estimate.NormalBuckets[0].Feerate, requestFeePolicy.MaxFeeRate)
-	case *pb.FeePolicy_MaxFee:
-		estimate, err := s.rpcClient.GetFeeEstimate()
-		if err != nil {
-			return 0, 0, err
-		}
-		feeRate = estimate.Estimate.NormalBuckets[0].Feerate
-		maxFee = requestFeePolicy.MaxFee
-	case nil:
-		estimate, err := s.rpcClient.GetFeeEstimate()
-		if err != nil {
-			return 0, 0, err
-		}
-		feeRate = estimate.Estimate.NormalBuckets[0].Feerate
-		// Default to a bound of max 1 KAS as fee
-		maxFee = constants.SompiPerKaspa
-	}
-
-	return feeRate, maxFee, nil
-}
-
-func (s *server) createUnsignedTransactions(address string, amount uint64, isSendAll bool, fromAddressesString []string, useExistingChangeAddress bool, requestFeePolicy *pb.FeePolicy) ([][]byte, error) {
+func (s *server) createUnsignedTransactions(address string, amount uint64, fromAddressesString []string) ([][]byte, error) {
 	if !s.isSynced() {
 		return nil, errors.Errorf("wallet daemon is not synced yet, %s", s.formatSyncStateReport())
 	}

-	feeRate, maxFee, err := s.calculateFeeLimits(requestFeePolicy)
+	err := s.refreshUTXOs()
 	if err != nil {
 		return nil, err
 	}

-	// make sure address string is correct before proceeding to a
-	// potentially long UTXO refreshment operation
 	toAddress, err := util.DecodeAddress(address, s.params.Prefix)
 	if err != nil {
 		return nil, err
@ -104,28 +47,24 @@ func (s *server) createUnsignedTransactions(address string, amount uint64, isSen
 	for _, from := range fromAddressesString {
 		fromAddress, exists := s.addressSet[from]
 		if !exists {
-			return nil, fmt.Errorf("specified from address %s does not exists", from)
+			return nil, fmt.Errorf("Specified from address %s does not exists", from)
 		}
 		fromAddresses = append(fromAddresses, fromAddress)
 	}

-	changeAddress, changeWalletAddress, err := s.changeAddress(useExistingChangeAddress, fromAddresses)
+	selectedUTXOs, changeSompi, err := s.selectUTXOs(amount, feePerInput, fromAddresses)
 	if err != nil {
 		return nil, err
 	}

-	selectedUTXOs, spendValue, changeSompi, err := s.selectUTXOs(amount, isSendAll, feeRate, maxFee, fromAddresses)
+	changeAddress, changeWalletAddress, err := s.changeAddress()
 	if err != nil {
 		return nil, err
 	}

-	if len(selectedUTXOs) == 0 {
-		return nil, errors.Errorf("couldn't find funds to spend")
-	}
-
 	payments := []*libkaspawallet.Payment{{
 		Address: toAddress,
-		Amount:  spendValue,
+		Amount:  amount,
 	}}
 	if changeSompi > 0 {
 		payments = append(payments, &libkaspawallet.Payment{
@ -140,52 +79,35 @@ func (s *server) createUnsignedTransactions(address string, amount uint64, isSen
 		return nil, err
 	}

-	unsignedTransactions, err := s.maybeAutoCompoundTransaction(unsignedTransaction, toAddress, changeAddress, changeWalletAddress, feeRate, maxFee)
+	unsignedTransactions, err := s.maybeAutoCompoundTransaction(unsignedTransaction, toAddress, changeAddress, changeWalletAddress)
 	if err != nil {
 		return nil, err
 	}
 	return unsignedTransactions, nil
 }

-func (s *server) selectUTXOs(spendAmount uint64, isSendAll bool, feeRate float64, maxFee uint64, fromAddresses []*walletAddress) (
-	selectedUTXOs []*libkaspawallet.UTXO, totalReceived uint64, changeSompi uint64, err error) {
-	return s.selectUTXOsWithPreselected(nil, map[externalapi.DomainOutpoint]struct{}{}, spendAmount, isSendAll, feeRate, maxFee, fromAddresses)
-}
+func (s *server) selectUTXOs(spendAmount uint64, feePerInput uint64, fromAddresses []*walletAddress) (
+	selectedUTXOs []*libkaspawallet.UTXO, changeSompi uint64, err error) {

-func (s *server) selectUTXOsWithPreselected(preSelectedUTXOs []*walletUTXO, allowUsed map[externalapi.DomainOutpoint]struct{}, spendAmount uint64, isSendAll bool, feeRate float64, maxFee uint64, fromAddresses []*walletAddress) (
-	selectedUTXOs []*libkaspawallet.UTXO, totalReceived uint64, changeSompi uint64, err error) {
-
-	preSelectedSet := make(map[externalapi.DomainOutpoint]struct{})
-	for _, utxo := range preSelectedUTXOs {
-		preSelectedSet[*utxo.Outpoint] = struct{}{}
-	}
+	selectedUTXOs = []*libkaspawallet.UTXO{}
 	totalValue := uint64(0)

 	dagInfo, err := s.rpcClient.GetBlockDAGInfo()
 	if err != nil {
-		return nil, 0, 0, err
+		return nil, 0, err
 	}

-	var fee uint64
-	iteration := func(utxo *walletUTXO, avoidPreselected bool) (bool, error) {
-		if (fromAddresses != nil && !walletAddressesContain(fromAddresses, utxo.address)) ||
-			!s.isUTXOSpendable(utxo, dagInfo.VirtualDAAScore) {
-			return true, nil
+	for _, utxo := range s.utxosSortedByAmount {
+		if (fromAddresses != nil && !slices.Contains(fromAddresses, utxo.address)) ||
+			!isUTXOSpendable(utxo, dagInfo.VirtualDAAScore, s.params.BlockCoinbaseMaturity) {
+			continue
 		}

 		if broadcastTime, ok := s.usedOutpoints[*utxo.Outpoint]; ok {
-			if _, ok := allowUsed[*utxo.Outpoint]; !ok {
-				if s.usedOutpointHasExpired(broadcastTime) {
+			if time.Since(broadcastTime) > time.Minute {
 				delete(s.usedOutpoints, *utxo.Outpoint)
 			} else {
-					return true, nil
-				}
-			}
-		}
-
-		if avoidPreselected {
-			if _, ok := preSelectedSet[*utxo.Outpoint]; ok {
-				return true, nil
+				continue
 			}
 		}

@ -194,171 +116,21 @@ func (s *server) selectUTXOsWithPreselected(preSelectedUTXOs []*walletUTXO, allo
 			UTXOEntry:      utxo.UTXOEntry,
 			DerivationPath: s.walletAddressPath(utxo.address),
 		})
-
 		totalValue += utxo.UTXOEntry.Amount()
-		estimatedRecipientValue := spendAmount
-		if isSendAll {
-			estimatedRecipientValue = totalValue
-		}
-
-		fee, err = s.estimateFee(selectedUTXOs, feeRate, maxFee, estimatedRecipientValue)
-		if err != nil {
-			return false, err
-		}

+		fee := feePerInput * uint64(len(selectedUTXOs))
 		totalSpend := spendAmount + fee
-		// Two break cases (if not send all):
-		// 		1. totalValue == totalSpend, so there's no change needed -> number of outputs = 1, so a single input is sufficient
-		// 		2. totalValue > totalSpend, so there will be change and 2 outputs, therefor in order to not struggle with --
-		//		   2.1 go-nodes dust patch we try and find at least 2 inputs (even though the next one is not necessary in terms of spend value)
-		// 		   2.2 KIP9 we try and make sure that the change amount is not too small
-		if !isSendAll && (totalValue == totalSpend || (totalValue >= totalSpend+minChangeTarget && len(selectedUTXOs) > 1)) {
-			return false, nil
-		}
-
-		return true, nil
-	}
-
-	shouldContinue := true
-	for _, utxo := range preSelectedUTXOs {
-		shouldContinue, err = iteration(utxo, false)
-		if err != nil {
-			return nil, 0, 0, err
-		}
-
-		if !shouldContinue {
+		if totalValue >= totalSpend {
 			break
 		}
 	}

-	if shouldContinue {
-		for _, utxo := range s.utxosSortedByAmount {
-			shouldContinue, err := iteration(utxo, true)
-			if err != nil {
-				return nil, 0, 0, err
-			}
-
-			if !shouldContinue {
-				break
-			}
-		}
-	}
-
-	var totalSpend uint64
-	if isSendAll {
-		totalSpend = totalValue
-		totalReceived = totalValue - fee
-	} else {
-		totalSpend = spendAmount + fee
-		totalReceived = spendAmount
-	}
+	fee := feePerInput * uint64(len(selectedUTXOs))
+	totalSpend := spendAmount + fee
 	if totalValue < totalSpend {
-		return nil, 0, 0, errors.Errorf("Insufficient funds for send: %f required, while only %f available",
+		return nil, 0, errors.Errorf("Insufficient funds for send: %f required, while only %f available",
 			float64(totalSpend)/constants.SompiPerKaspa, float64(totalValue)/constants.SompiPerKaspa)
 	}

-	return selectedUTXOs, totalReceived, totalValue - totalSpend, nil
-}
-
-func (s *server) estimateFee(selectedUTXOs []*libkaspawallet.UTXO, feeRate float64, maxFee uint64, recipientValue uint64) (uint64, error) {
-	fakePubKey := [util.PublicKeySizeECDSA]byte{}
-	fakeAddr, err := util.NewAddressPublicKeyECDSA(fakePubKey[:], s.params.Prefix) // We assume the worst case where the recipient address is ECDSA. In this case the scriptPubKey will be the longest.
-	if err != nil {
-		return 0, err
-	}
-
-	totalValue := uint64(0)
-	for _, utxo := range selectedUTXOs {
-		totalValue += utxo.UTXOEntry.Amount()
-	}
-
-	// This is an approximation for the distribution of value between the recipient output and the change output.
-	var mockPayments []*libkaspawallet.Payment
-	if totalValue > recipientValue {
-		mockPayments = []*libkaspawallet.Payment{
-			{
-				Address: fakeAddr,
-				Amount:  recipientValue,
-			},
-			{
-				Address: fakeAddr,
-				Amount:  totalValue - recipientValue, // We ignore the fee since we expect it to be insignificant in mass calculation.
-			},
-		}
-	} else {
-		mockPayments = []*libkaspawallet.Payment{
-			{
-				Address: fakeAddr,
-				Amount:  totalValue,
-			},
-		}
-	}
-
-	mockTx, err := libkaspawallet.CreateUnsignedTransaction(s.keysFile.ExtendedPublicKeys,
-		s.keysFile.MinimumSignatures,
-		mockPayments, selectedUTXOs)
-	if err != nil {
-		return 0, err
-	}
-
-	mass, err := s.estimateMassAfterSignatures(mockTx)
-	if err != nil {
-		return 0, err
-	}
-
-	return min(uint64(math.Ceil(float64(mass)*feeRate)), maxFee), nil
-}
-
-func (s *server) estimateFeePerInput(feeRate float64) (uint64, error) {
-	mockUTXO := &libkaspawallet.UTXO{
-		Outpoint: &externalapi.DomainOutpoint{
-			TransactionID: externalapi.DomainTransactionID{},
-			Index:         0,
-		},
-		UTXOEntry: utxo.NewUTXOEntry(1, &externalapi.ScriptPublicKey{
-			Script:  nil,
-			Version: 0,
-		}, false, 0),
-		DerivationPath: "m",
-	}
-
-	mockTx, err := libkaspawallet.CreateUnsignedTransaction(s.keysFile.ExtendedPublicKeys,
-		s.keysFile.MinimumSignatures,
-		nil, []*libkaspawallet.UTXO{mockUTXO})
-	if err != nil {
-		return 0, err
-	}
-
-	// Here we use compute mass to avoid dividing by zero. This is ok since `s.estimateFeePerInput` is only used
-	// in the case of compound transactions that have a compute mass higher than its storage mass.
-	mass, err := s.estimateComputeMassAfterSignatures(mockTx)
-	if err != nil {
-		return 0, err
-	}
-
-	mockTxWithoutUTXO, err := libkaspawallet.CreateUnsignedTransaction(s.keysFile.ExtendedPublicKeys,
-		s.keysFile.MinimumSignatures,
-		nil, nil)
-	if err != nil {
-		return 0, err
-	}
-
-	massWithoutUTXO, err := s.estimateComputeMassAfterSignatures(mockTxWithoutUTXO)
-	if err != nil {
-		return 0, err
-	}
-
-	inputMass := mass - massWithoutUTXO
-
-	return uint64(float64(inputMass) * feeRate), nil
-}
-
-func walletAddressesContain(addresses []*walletAddress, contain *walletAddress) bool {
-	for _, address := range addresses {
-		if *address == *contain {
-			return true
-		}
-	}
-
-	return false
+	return selectedUTXOs, totalValue - totalSpend, nil
 }
--- a/cmd/kaspawallet/daemon/server/external_spendable_utxos.go
+++ b/cmd/kaspawallet/daemon/server/external_spendable_utxos.go
@ -21,15 +21,7 @@ func (s *server) GetExternalSpendableUTXOs(_ context.Context, request *pb.GetExt
 	if err != nil {
 		return nil, err
 	}
-
-	estimate, err := s.rpcClient.GetFeeEstimate()
-	if err != nil {
-		return nil, err
-	}
-
-	feeRate := estimate.Estimate.NormalBuckets[0].Feerate
-
-	selectedUTXOs, err := s.selectExternalSpendableUTXOs(externalUTXOs, feeRate)
+	selectedUTXOs, err := s.selectExternalSpendableUTXOs(externalUTXOs, request.Address)
 	if err != nil {
 		return nil, err
 	}
@ -38,7 +30,7 @@ func (s *server) GetExternalSpendableUTXOs(_ context.Context, request *pb.GetExt
 	}, nil
 }

-func (s *server) selectExternalSpendableUTXOs(externalUTXOs *appmessage.GetUTXOsByAddressesResponseMessage, feeRate float64) ([]*pb.UtxosByAddressesEntry, error) {
+func (s *server) selectExternalSpendableUTXOs(externalUTXOs *appmessage.GetUTXOsByAddressesResponseMessage, address string) ([]*pb.UtxosByAddressesEntry, error) {
 	dagInfo, err := s.rpcClient.GetBlockDAGInfo()
 	if err != nil {
 		return nil, err
@ -50,13 +42,8 @@ func (s *server) selectExternalSpendableUTXOs(externalUTXOs *appmessage.GetUTXOs
 	//we do not make because we do not know size, because of unspendable utxos
 	var selectedExternalUtxos []*pb.UtxosByAddressesEntry

-	feePerInput, err := s.estimateFeePerInput(feeRate)
-	if err != nil {
-		return nil, err
-	}
-
 	for _, entry := range externalUTXOs.Entries {
-		if !isExternalUTXOSpendable(entry, daaScore, maturity, feePerInput) {
+		if !isExternalUTXOSpendable(entry, daaScore, maturity) {
 			continue
 		}
 		selectedExternalUtxos = append(selectedExternalUtxos, libkaspawallet.AppMessageUTXOToKaspawalletdUTXO(entry))
@ -65,7 +52,7 @@ func (s *server) selectExternalSpendableUTXOs(externalUTXOs *appmessage.GetUTXOs
 	return selectedExternalUtxos, nil
 }

-func isExternalUTXOSpendable(entry *appmessage.UTXOsByAddressesEntry, virtualDAAScore uint64, coinbaseMaturity uint64, feePerInput uint64) bool {
+func isExternalUTXOSpendable(entry *appmessage.UTXOsByAddressesEntry, virtualDAAScore uint64, coinbaseMaturity uint64) bool {
 	if !entry.UTXOEntry.IsCoinbase {
 		return true
 	} else if entry.UTXOEntry.Amount <= feePerInput {
--- a/cmd/kaspawallet/daemon/server/rpc.go
+++ b/cmd/kaspawallet/daemon/server/rpc.go
@ -1,26 +1,15 @@
 package server

 import (
-	"time"
-
 	"github.com/kaspanet/kaspad/domain/dagconfig"
 	"github.com/kaspanet/kaspad/infrastructure/network/rpcclient"
 )

-func connectToRPC(params *dagconfig.Params, rpcServer string, timeout uint32) (*rpcclient.RPCClient, error) {
+func connectToRPC(params *dagconfig.Params, rpcServer string) (*rpcclient.RPCClient, error) {
 	rpcAddress, err := params.NormalizeRPCServerAddress(rpcServer)
 	if err != nil {
 		return nil, err
 	}

-	rpcClient, err := rpcclient.NewRPCClient(rpcAddress)
-	if err != nil {
-		return nil, err
-	}
-
-	if timeout != 0 {
-		rpcClient.SetTimeout(time.Duration(timeout) * time.Second)
-	}
-
-	return rpcClient, err
+	return rpcclient.NewRPCClient(rpcAddress)
 }
--- a/cmd/kaspawallet/daemon/server/send.go
+++ b/cmd/kaspawallet/daemon/server/send.go
@ -4,16 +4,13 @@ import (
 	"context"

 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
-	"github.com/pkg/errors"
 )

 func (s *server) Send(_ context.Context, request *pb.SendRequest) (*pb.SendResponse, error) {
 	s.lock.Lock()
 	defer s.lock.Unlock()

-	unsignedTransactions, err := s.createUnsignedTransactions(request.ToAddress, request.Amount, request.IsSendAll,
-		request.From, request.UseExistingChangeAddress, request.FeePolicy)
-
+	unsignedTransactions, err := s.createUnsignedTransactions(request.ToAddress, request.Amount, request.From)
 	if err != nil {
 		return nil, err
 	}
@ -25,8 +22,8 @@ func (s *server) Send(_ context.Context, request *pb.SendRequest) (*pb.SendRespo

 	txIDs, err := s.broadcast(signedTransactions, false)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error broadcasting transactions %s", EncodeTransactionsToHex(signedTransactions))
+		return nil, err
 	}

-	return &pb.SendResponse{TxIDs: txIDs, SignedTransactions: signedTransactions}, nil
+	return &pb.SendResponse{TxIDs: txIDs}, nil
 }
--- a/cmd/kaspawallet/daemon/server/server.go
+++ b/cmd/kaspawallet/daemon/server/server.go
@ -5,11 +5,8 @@ import (
 	"net"
 	"os"
 	"sync"
-	"sync/atomic"
 	"time"

-	"github.com/kaspanet/kaspad/version"
-
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"

 	"github.com/kaspanet/kaspad/util/txmass"
@ -30,35 +27,25 @@ import (
 type server struct {
 	pb.UnimplementedKaspawalletdServer

-	rpcClient           *rpcclient.RPCClient // RPC client for ongoing user requests
-	backgroundRPCClient *rpcclient.RPCClient // RPC client dedicated for address and UTXO background fetching
+	rpcClient *rpcclient.RPCClient
 	params    *dagconfig.Params
-	coinbaseMaturity    uint64 // Different from go-kaspad default following Crescendo

 	lock                sync.RWMutex
 	utxosSortedByAmount []*walletUTXO
-	mempoolExcludedUTXOs            map[externalapi.DomainOutpoint]*walletUTXO
 	nextSyncStartIndex  uint32
 	keysFile            *keys.File
 	shutdown            chan struct{}
-	forceSyncChan                   chan struct{}
-	startTimeOfLastCompletedRefresh time.Time
 	addressSet          walletAddressSet
 	txMassCalculator    *txmass.Calculator
 	usedOutpoints       map[externalapi.DomainOutpoint]time.Time
-	firstSyncDone                   atomic.Bool

 	isLogFinalProgressLineShown bool
 	maxUsedAddressesForLog      uint32
 	maxProcessedAddressesForLog uint32
 }

-// MaxDaemonSendMsgSize is the max send message size used for the daemon server.
-// Currently, set to 100MB
-const MaxDaemonSendMsgSize = 100_000_000
-
 // Start starts the kaspawalletd server
-func Start(params *dagconfig.Params, listen, rpcServer string, keysFilePath string, profile string, timeout uint32) error {
+func Start(params *dagconfig.Params, listen, rpcServer string, keysFilePath string, profile string) error {
 	initLog(defaultLogFile, defaultErrLogFile)

 	defer panics.HandlePanic(log, "MAIN", nil)
@ -68,7 +55,6 @@ func Start(params *dagconfig.Params, listen, rpcServer string, keysFilePath stri
 		profiling.Start(profile, log)
 	}

-	log.Infof("Version %s", version.Version())
 	listener, err := net.Listen("tcp", listen)
 	if err != nil {
 		return (errors.Wrapf(err, "Error listening to TCP on %s", listen))
@ -76,14 +62,10 @@ func Start(params *dagconfig.Params, listen, rpcServer string, keysFilePath stri
 	log.Infof("Listening to TCP on %s", listen)

 	log.Infof("Connecting to a node at %s...", rpcServer)
-	rpcClient, err := connectToRPC(params, rpcServer, timeout)
+	rpcClient, err := connectToRPC(params, rpcServer)
 	if err != nil {
 		return (errors.Wrapf(err, "Error connecting to RPC server %s", rpcServer))
 	}
-	backgroundRPCClient, err := connectToRPC(params, rpcServer, timeout)
-	if err != nil {
-		return (errors.Wrapf(err, "Error making a second connection to RPC server %s", rpcServer))
-	}

 	log.Infof("Connected, reading keys file %s...", keysFilePath)
 	keysFile, err := keys.ReadKeysFile(params, keysFilePath)
@ -91,25 +73,13 @@ func Start(params *dagconfig.Params, listen, rpcServer string, keysFilePath stri
 		return (errors.Wrapf(err, "Error reading keys file %s", keysFilePath))
 	}

-	err = keysFile.TryLock()
-	if err != nil {
-		return err
-	}
-
-	// Post-Crescendo coinbase maturity
-	coinbaseMaturity := uint64(1000)
-
 	serverInstance := &server{
 		rpcClient:                   rpcClient,
-		backgroundRPCClient:         backgroundRPCClient,
 		params:                      params,
-		coinbaseMaturity:            coinbaseMaturity,
 		utxosSortedByAmount:         []*walletUTXO{},
-		mempoolExcludedUTXOs:        map[externalapi.DomainOutpoint]*walletUTXO{},
 		nextSyncStartIndex:          0,
 		keysFile:                    keysFile,
 		shutdown:                    make(chan struct{}),
-		forceSyncChan:               make(chan struct{}),
 		addressSet:                  make(walletAddressSet),
 		txMassCalculator:            txmass.NewCalculator(params.MassPerTxByte, params.MassPerScriptPubKeyByte, params.MassPerSigOp),
 		usedOutpoints:               map[externalapi.DomainOutpoint]time.Time{},
@ -119,14 +89,14 @@ func Start(params *dagconfig.Params, listen, rpcServer string, keysFilePath stri
 	}

 	log.Infof("Read, syncing the wallet...")
-	spawn("serverInstance.syncLoop", func() {
-		err := serverInstance.syncLoop()
+	spawn("serverInstance.sync", func() {
+		err := serverInstance.sync()
 		if err != nil {
 			printErrorAndExit(errors.Wrap(err, "error syncing the wallet"))
 		}
 	})

-	grpcServer := grpc.NewServer(grpc.MaxSendMsgSize(MaxDaemonSendMsgSize))
+	grpcServer := grpc.NewServer()
 	pb.RegisterKaspawalletdServer(grpcServer, serverInstance)

 	spawn("grpcServer.Serve", func() {
--- a/cmd/kaspawallet/daemon/server/split_transaction.go
+++ b/cmd/kaspawallet/daemon/server/split_transaction.go
@ -12,7 +12,6 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
 	"github.com/kaspanet/kaspad/domain/miningmanager/mempool"
 	"github.com/kaspanet/kaspad/util"
-	"github.com/kaspanet/kaspad/util/txmass"
 )

 // maybeAutoCompoundTransaction checks if a transaction's mass is higher that what is allowed for a standard
@ -21,10 +20,14 @@ import (
 // into a change address.
 // An additional `mergeTransaction` is generated - which merges the outputs of the above splits into a single output
 // paying to the original transaction's payee.
-func (s *server) maybeAutoCompoundTransaction(transaction *serialization.PartiallySignedTransaction, toAddress util.Address,
-	changeAddress util.Address, changeWalletAddress *walletAddress, feeRate float64, maxFee uint64) ([][]byte, error) {
+func (s *server) maybeAutoCompoundTransaction(transactionBytes []byte, toAddress util.Address,
+	changeAddress util.Address, changeWalletAddress *walletAddress) ([][]byte, error) {
+	transaction, err := serialization.DeserializePartiallySignedTransaction(transactionBytes)
+	if err != nil {
+		return nil, err
+	}

-	splitTransactions, err := s.maybeSplitAndMergeTransaction(transaction, toAddress, changeAddress, changeWalletAddress, feeRate, maxFee)
+	splitTransactions, err := s.maybeSplitAndMergeTransaction(transaction, toAddress, changeAddress, changeWalletAddress)
 	if err != nil {
 		return nil, err
 	}
@ -44,8 +47,6 @@ func (s *server) mergeTransaction(
 	toAddress util.Address,
 	changeAddress util.Address,
 	changeWalletAddress *walletAddress,
-	feeRate float64,
-	maxFee uint64,
 ) (*serialization.PartiallySignedTransaction, error) {
 	numOutputs := len(originalTransaction.Tx.Outputs)
 	if numOutputs > 2 || numOutputs == 0 {
@ -70,19 +71,13 @@ func (s *server) mergeTransaction(
 			DerivationPath: s.walletAddressPath(changeWalletAddress),
 		}
 		totalValue += output.Value
+		totalValue -= feePerInput
 	}
-	// We're overestimating a bit by assuming that any transaction will have a change output
-	fee, err := s.estimateFee(utxos, feeRate, maxFee, sentValue)
-	if err != nil {
-		return nil, err
-	}
-
-	totalValue -= fee

 	if totalValue < sentValue {
 		// sometimes the fees from compound transactions make the total output higher than what's available from selected
 		// utxos, in such cases - find one more UTXO and use it.
-		additionalUTXOs, totalValueAdded, err := s.moreUTXOsForMergeTransaction(utxos, sentValue-totalValue, feeRate)
+		additionalUTXOs, totalValueAdded, err := s.moreUTXOsForMergeTransaction(utxos, sentValue-totalValue)
 		if err != nil {
 			return nil, err
 		}
@ -101,54 +96,19 @@ func (s *server) mergeTransaction(
 		})
 	}

-	return libkaspawallet.CreateUnsignedTransaction(s.keysFile.ExtendedPublicKeys,
+	mergeTransactionBytes, err := libkaspawallet.CreateUnsignedTransaction(s.keysFile.ExtendedPublicKeys,
 		s.keysFile.MinimumSignatures, payments, utxos)
-}
-
-func (s *server) transactionFeeRate(psTx *serialization.PartiallySignedTransaction) (float64, error) {
-	totalOuts := 0
-	for _, output := range psTx.Tx.Outputs {
-		totalOuts += int(output.Value)
-	}
-
-	totalIns := 0
-	for _, input := range psTx.PartiallySignedInputs {
-		totalIns += int(input.PrevOutput.Value)
-	}
-
-	if totalIns < totalOuts {
-		return 0, errors.Errorf("Transaction don't have enough funds to pay for the outputs")
-	}
-	fee := totalIns - totalOuts
-	mass, err := s.estimateComputeMassAfterSignatures(psTx)
-	if err != nil {
-		return 0, err
-	}
-	return float64(fee) / float64(mass), nil
-}
-
-func (s *server) checkTransactionFeeRate(psTx *serialization.PartiallySignedTransaction, maxFee uint64) error {
-	feeRate, err := s.transactionFeeRate(psTx)
-	if err != nil {
-		return err
-	}
-
-	if feeRate < 1 {
-		return errors.Errorf("setting --max-fee to %d results in a fee rate of %f, which is below the minimum allowed fee rate of 1 sompi/gram", maxFee, feeRate)
-	}
-
-	return nil
-}
-
-func (s *server) maybeSplitAndMergeTransaction(transaction *serialization.PartiallySignedTransaction, toAddress util.Address,
-	changeAddress util.Address, changeWalletAddress *walletAddress, feeRate float64, maxFee uint64) ([]*serialization.PartiallySignedTransaction, error) {
-
-	err := s.checkTransactionFeeRate(transaction, maxFee)
 	if err != nil {
 		return nil, err
 	}

-	transactionMass, err := s.estimateComputeMassAfterSignatures(transaction)
+	return serialization.DeserializePartiallySignedTransaction(mergeTransactionBytes)
+}
+
+func (s *server) maybeSplitAndMergeTransaction(transaction *serialization.PartiallySignedTransaction, toAddress util.Address,
+	changeAddress util.Address, changeWalletAddress *walletAddress) ([]*serialization.PartiallySignedTransaction, error) {
+
+	transactionMass, err := s.estimateMassAfterSignatures(transaction)
 	if err != nil {
 		return nil, err
 	}
@ -157,7 +117,7 @@ func (s *server) maybeSplitAndMergeTransaction(transaction *serialization.Partia
 		return []*serialization.PartiallySignedTransaction{transaction}, nil
 	}

-	splitCount, inputCountPerSplit, err := s.splitAndInputPerSplitCounts(transaction, transactionMass, changeAddress, feeRate, maxFee)
+	splitCount, inputCountPerSplit, err := s.splitAndInputPerSplitCounts(transaction, transactionMass, changeAddress)
 	if err != nil {
 		return nil, err
 	}
@ -167,24 +127,19 @@ func (s *server) maybeSplitAndMergeTransaction(transaction *serialization.Partia
 		startIndex := i * inputCountPerSplit
 		endIndex := startIndex + inputCountPerSplit
 		var err error
-		splitTransactions[i], err = s.createSplitTransaction(transaction, changeAddress, startIndex, endIndex, feeRate, maxFee)
-		if err != nil {
-			return nil, err
-		}
-
-		err = s.checkTransactionFeeRate(splitTransactions[i], maxFee)
+		splitTransactions[i], err = s.createSplitTransaction(transaction, changeAddress, startIndex, endIndex)
 		if err != nil {
 			return nil, err
 		}
 	}

 	if len(splitTransactions) > 1 {
-		mergeTransaction, err := s.mergeTransaction(splitTransactions, transaction, toAddress, changeAddress, changeWalletAddress, feeRate, maxFee)
+		mergeTransaction, err := s.mergeTransaction(splitTransactions, transaction, toAddress, changeAddress, changeWalletAddress)
 		if err != nil {
 			return nil, err
 		}
 		// Recursion will be 2-3 iterations deep even in the rarest` cases, so considered safe..
-		splitMergeTransaction, err := s.maybeSplitAndMergeTransaction(mergeTransaction, toAddress, changeAddress, changeWalletAddress, feeRate, maxFee)
+		splitMergeTransaction, err := s.maybeSplitAndMergeTransaction(mergeTransaction, toAddress, changeAddress, changeWalletAddress)
 		if err != nil {
 			return nil, err
 		}
@ -197,7 +152,7 @@ func (s *server) maybeSplitAndMergeTransaction(transaction *serialization.Partia

 // splitAndInputPerSplitCounts calculates the number of splits to create, and the number of inputs to assign per split.
 func (s *server) splitAndInputPerSplitCounts(transaction *serialization.PartiallySignedTransaction, transactionMass uint64,
-	changeAddress util.Address, feeRate float64, maxFee uint64) (splitCount, inputsPerSplitCount int, err error) {
+	changeAddress util.Address) (splitCount, inputsPerSplitCount int, err error) {

 	// Create a dummy transaction which is a clone of the original transaction, but without inputs,
 	// to calculate how much mass do all the inputs have
@ -217,7 +172,7 @@ func (s *server) splitAndInputPerSplitCounts(transaction *serialization.Partiall

 	// Create another dummy transaction, this time one similar to the split transactions we wish to generate,
 	// but with 0 inputs, to calculate how much mass for inputs do we have available in the split transactions
-	splitTransactionWithoutInputs, err := s.createSplitTransaction(transaction, changeAddress, 0, 0, feeRate, maxFee)
+	splitTransactionWithoutInputs, err := s.createSplitTransaction(transaction, changeAddress, 0, 0)
 	if err != nil {
 		return 0, 0, err
 	}
@ -235,7 +190,7 @@ func (s *server) splitAndInputPerSplitCounts(transaction *serialization.Partiall
 }

 func (s *server) createSplitTransaction(transaction *serialization.PartiallySignedTransaction,
-	changeAddress util.Address, startIndex int, endIndex int, feeRate float64, maxFee uint64) (*serialization.PartiallySignedTransaction, error) {
+	changeAddress util.Address, startIndex int, endIndex int) (*serialization.PartiallySignedTransaction, error) {

 	selectedUTXOs := make([]*libkaspawallet.UTXO, 0, endIndex-startIndex)
 	totalSompi := uint64(0)
@ -251,36 +206,25 @@ func (s *server) createSplitTransaction(transaction *serialization.PartiallySign
 		})

 		totalSompi += selectedUTXOs[i-startIndex].UTXOEntry.Amount()
+		totalSompi -= feePerInput
 	}
-	if len(selectedUTXOs) != 0 {
-		fee, err := s.estimateFee(selectedUTXOs, feeRate, maxFee, totalSompi)
-		if err != nil {
-			return nil, err
-		}
-
-		totalSompi -= fee
-	}
-
-	return libkaspawallet.CreateUnsignedTransaction(s.keysFile.ExtendedPublicKeys,
+	unsignedTransactionBytes, err := libkaspawallet.CreateUnsignedTransaction(s.keysFile.ExtendedPublicKeys,
 		s.keysFile.MinimumSignatures,
 		[]*libkaspawallet.Payment{{
 			Address: changeAddress,
 			Amount:  totalSompi,
 		}}, selectedUTXOs)
+	if err != nil {
+		return nil, err
+	}
+
+	return serialization.DeserializePartiallySignedTransaction(unsignedTransactionBytes)
 }

 func (s *server) estimateMassAfterSignatures(transaction *serialization.PartiallySignedTransaction) (uint64, error) {
-	return EstimateMassAfterSignatures(transaction, s.keysFile.ECDSA, s.keysFile.MinimumSignatures, s.txMassCalculator)
-}
-
-func (s *server) estimateComputeMassAfterSignatures(transaction *serialization.PartiallySignedTransaction) (uint64, error) {
-	return estimateComputeMassAfterSignatures(transaction, s.keysFile.ECDSA, s.keysFile.MinimumSignatures, s.txMassCalculator)
-}
-
-func createTransactionWithJunkFieldsForMassCalculation(transaction *serialization.PartiallySignedTransaction, ecdsa bool, minimumSignatures uint32, txMassCalculator *txmass.Calculator) (*externalapi.DomainTransaction, error) {
 	transaction = transaction.Clone()
 	var signatureSize uint64
-	if ecdsa {
+	if s.keysFile.ECDSA {
 		signatureSize = secp256k1.SerializedECDSASignatureSize
 	} else {
 		signatureSize = secp256k1.SerializedSchnorrSignatureSize
@ -288,7 +232,7 @@ func createTransactionWithJunkFieldsForMassCalculation(transaction *serializatio

 	for i, input := range transaction.PartiallySignedInputs {
 		for j, pubKeyPair := range input.PubKeySignaturePairs {
-			if uint32(j) >= minimumSignatures {
+			if uint32(j) >= s.keysFile.MinimumSignatures {
 				break
 			}
 			pubKeyPair.Signature = make([]byte, signatureSize+1) // +1 for SigHashType
@ -296,28 +240,15 @@ func createTransactionWithJunkFieldsForMassCalculation(transaction *serializatio
 		transaction.Tx.Inputs[i].SigOpCount = byte(len(input.PubKeySignaturePairs))
 	}

-	return libkaspawallet.ExtractTransactionDeserialized(transaction, ecdsa)
-}
-
-func estimateComputeMassAfterSignatures(transaction *serialization.PartiallySignedTransaction, ecdsa bool, minimumSignatures uint32, txMassCalculator *txmass.Calculator) (uint64, error) {
-	transactionWithSignatures, err := createTransactionWithJunkFieldsForMassCalculation(transaction, ecdsa, minimumSignatures, txMassCalculator)
+	transactionWithSignatures, err := libkaspawallet.ExtractTransactionDeserialized(transaction, s.keysFile.ECDSA)
 	if err != nil {
 		return 0, err
 	}

-	return txMassCalculator.CalculateTransactionMass(transactionWithSignatures), nil
+	return s.txMassCalculator.CalculateTransactionMass(transactionWithSignatures), nil
 }

-func EstimateMassAfterSignatures(transaction *serialization.PartiallySignedTransaction, ecdsa bool, minimumSignatures uint32, txMassCalculator *txmass.Calculator) (uint64, error) {
-	transactionWithSignatures, err := createTransactionWithJunkFieldsForMassCalculation(transaction, ecdsa, minimumSignatures, txMassCalculator)
-	if err != nil {
-		return 0, err
-	}
-
-	return txMassCalculator.CalculateTransactionOverallMass(transactionWithSignatures), nil
-}
-
-func (s *server) moreUTXOsForMergeTransaction(alreadySelectedUTXOs []*libkaspawallet.UTXO, requiredAmount uint64, feeRate float64) (
+func (s *server) moreUTXOsForMergeTransaction(alreadySelectedUTXOs []*libkaspawallet.UTXO, requiredAmount uint64) (
 	additionalUTXOs []*libkaspawallet.UTXO, totalValueAdded uint64, err error) {

 	dagInfo, err := s.rpcClient.GetBlockDAGInfo()
@ -329,16 +260,11 @@ func (s *server) moreUTXOsForMergeTransaction(alreadySelectedUTXOs []*libkaspawa
 		alreadySelectedUTXOsMap[*alreadySelectedUTXO.Outpoint] = struct{}{}
 	}

-	feePerInput, err := s.estimateFeePerInput(feeRate)
-	if err != nil {
-		return nil, 0, err
-	}
-
 	for _, utxo := range s.utxosSortedByAmount {
 		if _, ok := alreadySelectedUTXOsMap[*utxo.Outpoint]; ok {
 			continue
 		}
-		if !s.isUTXOSpendable(utxo, dagInfo.VirtualDAAScore) {
+		if !isUTXOSpendable(utxo, dagInfo.VirtualDAAScore, s.params.BlockCoinbaseMaturity) {
 			continue
 		}
 		additionalUTXOs = append(additionalUTXOs, &libkaspawallet.UTXO{
--- a/cmd/kaspawallet/daemon/server/split_transaction_test.go
+++ b/cmd/kaspawallet/daemon/server/split_transaction_test.go
@ -20,9 +20,9 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
 )

-func TestEstimateComputeMassAfterSignatures(t *testing.T) {
+func TestEstimateMassAfterSignatures(t *testing.T) {
 	testutils.ForAllNets(t, true, func(t *testing.T, consensusConfig *consensus.Config) {
-		unsignedTransaction, mnemonics, params, teardown := testEstimateMassIncreaseForSignaturesSetUp(t, consensusConfig)
+		unsignedTransactionBytes, mnemonics, params, teardown := testEstimateMassIncreaseForSignaturesSetUp(t, consensusConfig)
 		defer teardown(false)

 		serverInstance := &server{
@ -33,16 +33,16 @@ func TestEstimateComputeMassAfterSignatures(t *testing.T) {
 			txMassCalculator: txmass.NewCalculator(params.MassPerTxByte, params.MassPerScriptPubKeyByte, params.MassPerSigOp),
 		}

-		estimatedMassAfterSignatures, err := serverInstance.estimateComputeMassAfterSignatures(unsignedTransaction)
-		if err != nil {
-			t.Fatalf("Error from estimateComputeMassAfterSignatures: %s", err)
-		}
-
-		unsignedTransactionBytes, err := serialization.SerializePartiallySignedTransaction(unsignedTransaction)
+		unsignedTransaction, err := serialization.DeserializePartiallySignedTransaction(unsignedTransactionBytes)
 		if err != nil {
 			t.Fatalf("Error deserializing unsignedTransaction: %s", err)
 		}

+		estimatedMassAfterSignatures, err := serverInstance.estimateMassAfterSignatures(unsignedTransaction)
+		if err != nil {
+			t.Fatalf("Error from estimateMassAfterSignatures: %s", err)
+		}
+
 		signedTxStep1Bytes, err := libkaspawallet.Sign(params, mnemonics[:1], unsignedTransactionBytes, false)
 		if err != nil {
 			t.Fatalf("Sign: %+v", err)
@ -67,67 +67,8 @@ func TestEstimateComputeMassAfterSignatures(t *testing.T) {
 	})
 }

-func TestEstimateMassAfterSignatures(t *testing.T) {
-	testutils.ForAllNets(t, true, func(t *testing.T, consensusConfig *consensus.Config) {
-		unsignedTransaction, mnemonics, params, teardown := testEstimateMassIncreaseForSignaturesSetUp(t, consensusConfig)
-		defer teardown(false)
-
-		for i := range unsignedTransaction.Tx.Inputs {
-			unsignedTransaction.Tx.Inputs[i].UTXOEntry = utxo.NewUTXOEntry(1, &externalapi.ScriptPublicKey{}, false, 0)
-			unsignedTransaction.PartiallySignedInputs[i].PrevOutput = &externalapi.DomainTransactionOutput{
-				Value:           1,
-				ScriptPublicKey: &externalapi.ScriptPublicKey{},
-			}
-		}
-
-		serverInstance := &server{
-			params:           params,
-			keysFile:         &keys.File{MinimumSignatures: 2},
-			shutdown:         make(chan struct{}),
-			addressSet:       make(walletAddressSet),
-			txMassCalculator: txmass.NewCalculator(params.MassPerTxByte, params.MassPerScriptPubKeyByte, params.MassPerSigOp),
-		}
-
-		estimatedMassAfterSignatures, err := serverInstance.estimateMassAfterSignatures(unsignedTransaction)
-		if err != nil {
-			t.Fatalf("Error from estimateMassAfterSignatures: %s", err)
-		}
-
-		unsignedTransactionBytes, err := serialization.SerializePartiallySignedTransaction(unsignedTransaction)
-		if err != nil {
-			t.Fatalf("Error deserializing unsignedTransaction: %s", err)
-		}
-
-		signedTxStep1Bytes, err := libkaspawallet.Sign(params, mnemonics[:1], unsignedTransactionBytes, false)
-		if err != nil {
-			t.Fatalf("Sign: %+v", err)
-		}
-
-		signedTxStep2Bytes, err := libkaspawallet.Sign(params, mnemonics[1:2], signedTxStep1Bytes, false)
-		if err != nil {
-			t.Fatalf("Sign: %+v", err)
-		}
-
-		extractedSignedTx, err := libkaspawallet.ExtractTransaction(signedTxStep2Bytes, false)
-		if err != nil {
-			t.Fatalf("ExtractTransaction: %+v", err)
-		}
-
-		for i := range extractedSignedTx.Inputs {
-			extractedSignedTx.Inputs[i].UTXOEntry = utxo.NewUTXOEntry(1, &externalapi.ScriptPublicKey{}, false, 0)
-		}
-
-		actualMassAfterSignatures := serverInstance.txMassCalculator.CalculateTransactionOverallMass(extractedSignedTx)
-
-		if estimatedMassAfterSignatures != actualMassAfterSignatures {
-			t.Errorf("Estimated mass after signatures: %d but actually got %d",
-				estimatedMassAfterSignatures, actualMassAfterSignatures)
-		}
-	})
-}
-
 func testEstimateMassIncreaseForSignaturesSetUp(t *testing.T, consensusConfig *consensus.Config) (
-	*serialization.PartiallySignedTransaction, []string, *dagconfig.Params, func(keepDataDir bool)) {
+	[]byte, []string, *dagconfig.Params, func(keepDataDir bool)) {

 	consensusConfig.BlockCoinbaseMaturity = 0
 	params := &consensusConfig.Params
@ -180,7 +121,7 @@ func testEstimateMassIncreaseForSignaturesSetUp(t *testing.T, consensusConfig *c
 		t.Fatalf("AddBlock: %+v", err)
 	}

-	block1, _, err := tc.GetBlock(block1Hash)
+	block1, err := tc.GetBlock(block1Hash)
 	if err != nil {
 		t.Fatalf("GetBlock: %+v", err)
 	}
--- a/cmd/kaspawallet/daemon/server/sync.go
+++ b/cmd/kaspawallet/daemon/server/sync.go
@ -6,7 +6,6 @@ import (
 	"time"

 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"

 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/pkg/errors"
@ -24,7 +23,7 @@ func (was walletAddressSet) strings() []string {
 	return addresses
 }

-func (s *server) syncLoop() error {
+func (s *server) sync() error {
 	ticker := time.NewTicker(time.Second)
 	defer ticker.Stop()

@ -33,29 +32,13 @@ func (s *server) syncLoop() error {
 		return err
 	}

-	err = s.refreshUTXOs()
+	err = s.refreshExistingUTXOsWithLock()
 	if err != nil {
 		return err
 	}

-	s.firstSyncDone.Store(true)
-	log.Infof("Wallet is synced and ready for operation")
-
-	for {
-		select {
-		case <-ticker.C:
-		case <-s.forceSyncChan:
-		}
-
-		err := s.sync()
-		if err != nil {
-			return err
-		}
-	}
-}
-
-func (s *server) sync() error {
-	err := s.collectFarAddresses()
+	for range ticker.C {
+		err = s.collectFarAddresses()
 		if err != nil {
 			return err
 		}
@ -65,7 +48,13 @@ func (s *server) sync() error {
 			return err
 		}

-	return s.refreshUTXOs()
+		err = s.refreshExistingUTXOsWithLock()
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
 }

 const (
@ -169,7 +158,7 @@ func (s *server) collectAddresses(start, end uint32) error {
 		return err
 	}

-	getBalancesByAddressesResponse, err := s.backgroundRPCClient.GetBalancesByAddresses(addressSet.strings())
+	getBalancesByAddressesResponse, err := s.rpcClient.GetBalancesByAddresses(addressSet.strings())
 	if err != nil {
 		return err
 	}
@ -219,17 +208,15 @@ func (s *server) updateAddressesAndLastUsedIndexes(requestedAddressSet walletAdd
 	return s.keysFile.SetLastUsedInternalIndex(lastUsedInternalIndex)
 }

-func (s *server) usedOutpointHasExpired(outpointBroadcastTime time.Time) bool {
-	// If the node returns a UTXO we previously attempted to spend and enough time has passed, we assume
-	// that the network rejected or lost the previous transaction and allow a reuse. We set this time
-	// interval to a minute.
-	// We also verify that a full refresh UTXO operation started after this time point and has already
-	// completed, in order to make sure that indeed this state reflects a state obtained following the required wait time.
-	return s.startTimeOfLastCompletedRefresh.After(outpointBroadcastTime.Add(time.Minute))
+func (s *server) refreshExistingUTXOsWithLock() error {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	return s.refreshUTXOs()
 }

 // updateUTXOSet clears the current UTXO set, and re-fills it with the given entries
-func (s *server) updateUTXOSet(entries []*appmessage.UTXOsByAddressesEntry, mempoolEntries []*appmessage.MempoolEntryByAddress, refreshStart time.Time) error {
+func (s *server) updateUTXOSet(entries []*appmessage.UTXOsByAddressesEntry, mempoolEntries []*appmessage.MempoolEntryByAddress) error {
 	utxos := make([]*walletUTXO, 0, len(entries))

 	exclude := make(map[appmessage.RPCOutpoint]struct{})
@ -241,8 +228,11 @@ func (s *server) updateUTXOSet(entries []*appmessage.UTXOsByAddressesEntry, memp
 		}
 	}

-	mempoolExcludedUTXOs := make(map[externalapi.DomainOutpoint]*walletUTXO)
 	for _, entry := range entries {
+		if _, ok := exclude[*entry.Outpoint]; ok {
+			continue
+		}
+
 		outpoint, err := appmessage.RPCOutpointToDomainOutpoint(entry.Outpoint)
 		if err != nil {
 			return err
@ -253,82 +243,45 @@ func (s *server) updateUTXOSet(entries []*appmessage.UTXOsByAddressesEntry, memp
 			return err
 		}

-		// No need to lock for reading since the only writer of this set is on `syncLoop` on the same goroutine.
 		address, ok := s.addressSet[entry.Address]
 		if !ok {
 			return errors.Errorf("Got result from address %s even though it wasn't requested", entry.Address)
 		}
-
-		utxo := &walletUTXO{
-			Outpoint:  outpoint,
-			UTXOEntry: utxoEntry,
-			address:   address,
-		}
-
-		if _, ok := exclude[*entry.Outpoint]; ok {
-			mempoolExcludedUTXOs[*outpoint] = utxo
-		} else {
 		utxos = append(utxos, &walletUTXO{
 			Outpoint:  outpoint,
 			UTXOEntry: utxoEntry,
 			address:   address,
 		})
 	}
-	}

 	sort.Slice(utxos, func(i, j int) bool { return utxos[i].UTXOEntry.Amount() > utxos[j].UTXOEntry.Amount() })

-	s.lock.Lock()
-	s.startTimeOfLastCompletedRefresh = refreshStart
 	s.utxosSortedByAmount = utxos
-	s.mempoolExcludedUTXOs = mempoolExcludedUTXOs
-
-	// Cleanup expired used outpoints to avoid a memory leak
-	for outpoint, broadcastTime := range s.usedOutpoints {
-		if s.usedOutpointHasExpired(broadcastTime) {
-			delete(s.usedOutpoints, outpoint)
-		}
-	}
-	s.lock.Unlock()

 	return nil
 }

 func (s *server) refreshUTXOs() error {
-	refreshStart := time.Now()
-
-	// No need to lock for reading since the only writer of this set is on `syncLoop` on the same goroutine.
-	addresses := s.addressSet.strings()
 	// It's important to check the mempool before calling `GetUTXOsByAddresses`:
 	// If we would do it the other way around an output can be spent in the mempool
 	// and not in consensus, and between the calls its spending transaction will be
 	// added to consensus and removed from the mempool, so `getUTXOsByAddressesResponse`
 	// will include an obsolete output.
-	mempoolEntriesByAddresses, err := s.backgroundRPCClient.GetMempoolEntriesByAddresses(addresses, true, true)
+	mempoolEntriesByAddresses, err := s.rpcClient.GetMempoolEntriesByAddresses(s.addressSet.strings(), true, true)
 	if err != nil {
 		return err
 	}

-	getUTXOsByAddressesResponse, err := s.backgroundRPCClient.GetUTXOsByAddresses(addresses)
+	getUTXOsByAddressesResponse, err := s.rpcClient.GetUTXOsByAddresses(s.addressSet.strings())
 	if err != nil {
 		return err
 	}

-	return s.updateUTXOSet(getUTXOsByAddressesResponse.Entries, mempoolEntriesByAddresses.Entries, refreshStart)
-}
-
-func (s *server) forceSync() {
-	// Technically if two callers check the `if` simultaneously they will both spawn a
-	// goroutine, but we don't care about the small redundancy in such a rare case.
-	if len(s.forceSyncChan) == 0 {
-		go func() {
-			s.forceSyncChan <- struct{}{}
-		}()
-	}
+	return s.updateUTXOSet(getUTXOsByAddressesResponse.Entries, mempoolEntriesByAddresses.Entries)
 }

 func (s *server) isSynced() bool {
-	return s.nextSyncStartIndex > s.maxUsedIndex() && s.firstSyncDone.Load()
+	return s.nextSyncStartIndex > s.maxUsedIndex()
 }

 func (s *server) formatSyncStateReport() string {
@ -338,12 +291,9 @@ func (s *server) formatSyncStateReport() string {
 		maxUsedIndex = s.nextSyncStartIndex
 	}

-	if s.nextSyncStartIndex < s.maxUsedIndex() {
 	return fmt.Sprintf("scanned %d out of %d addresses (%.2f%%)",
 		s.nextSyncStartIndex, maxUsedIndex, float64(s.nextSyncStartIndex)*100.0/float64(maxUsedIndex))
 }
-	return "loading the wallet UTXO set"
-}

 func (s *server) updateSyncingProgressLog(currProcessedAddresses, currMaxUsedAddresses uint32) {
 	if currMaxUsedAddresses > s.maxUsedAddressesForLog {
@ -361,7 +311,7 @@ func (s *server) updateSyncingProgressLog(currProcessedAddresses, currMaxUsedAdd

 	if s.maxProcessedAddressesForLog >= s.maxUsedAddressesForLog {
 		if !s.isLogFinalProgressLineShown {
-			log.Infof("Finished scanning recent addresses")
+			log.Infof("Wallet is synced, ready for queries")
 			s.isLogFinalProgressLineShown = true
 		}
 	} else {
--- a/cmd/kaspawallet/daemon/server/version.go
+++ b/cmd/kaspawallet/daemon/server/version.go
@ -1,16 +0,0 @@
-package server
-
-import (
-	"context"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
-	"github.com/kaspanet/kaspad/version"
-)
-
-func (s *server) GetVersion(_ context.Context, _ *pb.GetVersionRequest) (*pb.GetVersionResponse, error) {
-	s.lock.RLock()
-	defer s.lock.RUnlock()
-
-	return &pb.GetVersionResponse{
-		Version: version.Version(),
-	}, nil
-}
--- a/cmd/kaspawallet/docker/Dockerfile
+++ b/cmd/kaspawallet/docker/Dockerfile
@ -1,29 +0,0 @@
-# -- multistage docker build: stage #1: build stage
-FROM golang:1.23-alpine AS build
-
-RUN mkdir -p /go/src/github.com/kaspanet/kaspad
-
-WORKDIR /go/src/github.com/kaspanet/kaspad
-
-RUN apk add --no-cache curl git openssh binutils gcc musl-dev
-
-COPY go.mod .
-COPY go.sum .
-
-RUN go mod download
-
-COPY . .
-
-WORKDIR /go/src/github.com/kaspanet/kaspad/cmd/kaspawallet
-RUN GOOS=linux go build -a -installsuffix cgo -o kaspawallet .
-
-# --- multistage docker build: stage #2: runtime image
-FROM alpine
-WORKDIR /app
-
-RUN apk add --no-cache ca-certificates tini
-
-COPY --from=build /go/src/github.com/kaspanet/kaspad/cmd/kaspawallet/kaspawallet /app/
-
-USER nobody
-ENTRYPOINT [ "/sbin/tini", "--" ]
--- a/cmd/kaspawallet/get_daemon_version.go
+++ b/cmd/kaspawallet/get_daemon_version.go
@ -1,26 +0,0 @@
-package main
-
-import (
-	"context"
-	"fmt"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/client"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
-)
-
-func getDaemonVersion(conf *getDaemonVersionConfig) error {
-	daemonClient, tearDown, err := client.Connect(conf.DaemonAddress)
-	if err != nil {
-		return err
-	}
-	defer tearDown()
-
-	ctx, cancel := context.WithTimeout(context.Background(), daemonTimeout)
-	defer cancel()
-	response, err := daemonClient.GetVersion(ctx, &pb.GetVersionRequest{})
-	if err != nil {
-		return err
-	}
-	fmt.Println(response.Version)
-
-	return nil
-}
--- a/cmd/kaspawallet/keys/keys.go
+++ b/cmd/kaspawallet/keys/keys.go
@ -6,7 +6,6 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
-	"github.com/gofrs/flock"
 	"os"
 	"path/filepath"
 	"runtime"
@ -401,33 +400,3 @@ func decryptMnemonic(numThreads uint8, encryptedPrivateKey *EncryptedMnemonic, p

 	return string(decrypted), nil
 }
-
-// flockMap is a map that holds all lock file handlers. This map guarantees that
-// the associated locked file handler will never get cleaned by the GC, because
-// once they are cleaned the associated file will be unlocked.
-var flockMap = make(map[string]*flock.Flock)
-
-// TryLock tries to acquire an exclusive lock for the file.
-func (d *File) TryLock() error {
-	if _, ok := flockMap[d.path]; ok {
-		return errors.Errorf("file %s is already locked", d.path)
-	}
-
-	lockFile := flock.New(d.path + ".lock")
-	err := createFileDirectoryIfDoesntExist(lockFile.Path())
-	if err != nil {
-		return err
-	}
-
-	flockMap[d.path] = lockFile
-
-	success, err := lockFile.TryLock()
-	if err != nil {
-		return err
-	}
-
-	if !success {
-		return errors.Errorf("%s is locked and cannot be used. Make sure that no other active wallet command is using it.", d.path)
-	}
-	return nil
-}
--- a/cmd/kaspawallet/libkaspawallet/bip32/base58/doc.go
+++ b/cmd/kaspawallet/libkaspawallet/bip32/base58/doc.go
@ -6,7 +6,7 @@
 Package base58 provides an API for working with modified base58 and Base58Check
 encodings.

-# Modified Base58 Encoding
+Modified Base58 Encoding

 Standard base58 encoding is similar to standard base64 encoding except, as the
 name implies, it uses a 58 character alphabet which results in an alphanumeric
@ -17,7 +17,7 @@ The modified base58 alphabet used by Bitcoin, and hence this package, omits the
 0, O, I, and l characters that look the same in many fonts and are therefore
 hard to humans to distinguish.

-# Base58Check Encoding Scheme
+Base58Check Encoding Scheme

 The Base58Check encoding scheme is primarily used for Bitcoin addresses at the
 time of this writing, however it can be used to generically encode arbitrary
--- a/cmd/kaspawallet/libkaspawallet/serialization/protoserialization/wallet.pb.go
+++ b/cmd/kaspawallet/libkaspawallet/serialization/protoserialization/wallet.pb.go
@ -1,7 +1,7 @@
 // Code generated by protoc-gen-go. DO NOT EDIT.
 // versions:
-// 	protoc-gen-go v1.26.0
-// 	protoc        v3.21.12
+// 	protoc-gen-go v1.28.0
+// 	protoc        v3.17.2
 // source: wallet.proto

 package protoserialization
--- a/cmd/kaspawallet/libkaspawallet/transaction.go
+++ b/cmd/kaspawallet/libkaspawallet/transaction.go
@ -7,7 +7,6 @@ import (
 	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
 	"github.com/kaspanet/kaspad/util"
 	"github.com/pkg/errors"
 )
@ -32,10 +31,15 @@ func CreateUnsignedTransaction(
 	extendedPublicKeys []string,
 	minimumSignatures uint32,
 	payments []*Payment,
-	selectedUTXOs []*UTXO) (*serialization.PartiallySignedTransaction, error) {
+	selectedUTXOs []*UTXO) ([]byte, error) {

 	sortPublicKeys(extendedPublicKeys)
-	return createUnsignedTransaction(extendedPublicKeys, minimumSignatures, payments, selectedUTXOs)
+	unsignedTransaction, err := createUnsignedTransaction(extendedPublicKeys, minimumSignatures, payments, selectedUTXOs)
+	if err != nil {
+		return nil, err
+	}
+
+	return serialization.SerializePartiallySignedTransaction(unsignedTransaction)
 }

 func multiSigRedeemScript(extendedPublicKeys []string, minimumSignatures uint32, path string, ecdsa bool) ([]byte, error) {
@ -243,12 +247,6 @@ func ExtractTransactionDeserialized(partiallySignedTransaction *serialization.Pa
 			}
 			partiallySignedTransaction.Tx.Inputs[i].SignatureScript = sigScript
 		}
-		partiallySignedTransaction.Tx.Inputs[i].UTXOEntry = utxo.NewUTXOEntry(
-			input.PrevOutput.Value,
-			input.PrevOutput.ScriptPublicKey,
-			false, // This is a fake value
-			0,     // This is a fake value
-		)
 	}
 	return partiallySignedTransaction.Tx, nil
 }
--- a/cmd/kaspawallet/libkaspawallet/transaction_test.go
+++ b/cmd/kaspawallet/libkaspawallet/transaction_test.go
@ -2,7 +2,6 @@ package libkaspawallet_test

 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet/serialization"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
 	"strings"
 	"testing"
@ -27,20 +26,6 @@ func forSchnorrAndECDSA(t *testing.T, testFunc func(t *testing.T, ecdsa bool)) {
 	})
 }

-func createUnsignedTransactionSerialized(
-	extendedPublicKeys []string,
-	minimumSignatures uint32,
-	payments []*libkaspawallet.Payment,
-	selectedUTXOs []*libkaspawallet.UTXO) ([]byte, error) {
-
-	tx, err := libkaspawallet.CreateUnsignedTransaction(extendedPublicKeys, minimumSignatures, payments, selectedUTXOs)
-	if err != nil {
-		return nil, err
-	}
-
-	return serialization.SerializePartiallySignedTransaction(tx)
-}
-
 func TestMultisig(t *testing.T) {
 	testutils.ForAllNets(t, true, func(t *testing.T, consensusConfig *consensus.Config) {
 		params := &consensusConfig.Params
@ -99,7 +84,7 @@ func TestMultisig(t *testing.T) {
 				t.Fatalf("AddBlock: %+v", err)
 			}

-			block1, _, err := tc.GetBlock(block1Hash)
+			block1, err := tc.GetBlock(block1Hash)
 			if err != nil {
 				t.Fatalf("GetBlock: %+v", err)
 			}
@ -117,7 +102,7 @@ func TestMultisig(t *testing.T) {
 				},
 			}

-			unsignedTransaction, err := createUnsignedTransactionSerialized(publicKeys, minimumSignatures,
+			unsignedTransaction, err := libkaspawallet.CreateUnsignedTransaction(publicKeys, minimumSignatures,
 				[]*libkaspawallet.Payment{{
 					Address: address,
 					Amount:  10,
@ -260,7 +245,7 @@ func TestP2PK(t *testing.T) {
 				t.Fatalf("AddBlock: %+v", err)
 			}

-			block1, _, err := tc.GetBlock(block1Hash)
+			block1, err := tc.GetBlock(block1Hash)
 			if err != nil {
 				t.Fatalf("GetBlock: %+v", err)
 			}
@ -278,7 +263,7 @@ func TestP2PK(t *testing.T) {
 				},
 			}

-			unsignedTransaction, err := createUnsignedTransactionSerialized(publicKeys, minimumSignatures,
+			unsignedTransaction, err := libkaspawallet.CreateUnsignedTransaction(publicKeys, minimumSignatures,
 				[]*libkaspawallet.Payment{{
 					Address: address,
 					Amount:  10,
@ -392,17 +377,17 @@ func TestMaxSompi(t *testing.T) {
 			t.Fatalf("AddBlock: %+v", err)
 		}

-		fundingBlock2, _, err := tc.GetBlock(fundingBlock2Hash)
+		fundingBlock2, err := tc.GetBlock(fundingBlock2Hash)
 		if err != nil {
 			t.Fatalf("GetBlock: %+v", err)
 		}

-		fundingBlock3, _, err := tc.GetBlock(fundingBlock3Hash)
+		fundingBlock3, err := tc.GetBlock(fundingBlock3Hash)
 		if err != nil {
 			t.Fatalf("GetBlock: %+v", err)
 		}

-		fundingBlock4, _, err := tc.GetBlock(fundingBlock4Hash)
+		fundingBlock4, err := tc.GetBlock(fundingBlock4Hash)
 		if err != nil {
 			t.Fatalf("GetBlock: %+v", err)
 		}
@ -412,7 +397,7 @@ func TestMaxSompi(t *testing.T) {
 			t.Fatalf("AddBlock: %+v", err)
 		}

-		block1, _, err := tc.GetBlock(block1Hash)
+		block1, err := tc.GetBlock(block1Hash)
 		if err != nil {
 			t.Fatalf("GetBlock: %+v", err)
 		}
@ -440,7 +425,7 @@ func TestMaxSompi(t *testing.T) {
 			},
 		}

-		unsignedTxWithLargeInputAmount, err := createUnsignedTransactionSerialized(publicKeys, minimumSignatures,
+		unsignedTxWithLargeInputAmount, err := libkaspawallet.CreateUnsignedTransaction(publicKeys, minimumSignatures,
 			[]*libkaspawallet.Payment{{
 				Address: address,
 				Amount:  10,
@ -491,7 +476,7 @@ func TestMaxSompi(t *testing.T) {
 			},
 		}

-		unsignedTxWithLargeInputAndOutputAmount, err := createUnsignedTransactionSerialized(publicKeys, minimumSignatures,
+		unsignedTxWithLargeInputAndOutputAmount, err := libkaspawallet.CreateUnsignedTransaction(publicKeys, minimumSignatures,
 			[]*libkaspawallet.Payment{{
 				Address: address,
 				Amount:  22e6 * constants.SompiPerKaspa,
--- a/cmd/kaspawallet/main.go
+++ b/cmd/kaspawallet/main.go
@ -1,11 +1,10 @@
 package main

-import (
-	"github.com/pkg/errors"
-)
+import "github.com/pkg/errors"

 func main() {
 	subCmd, config := parseCommandLine()
+
 	var err error
 	switch subCmd {
 	case createSubCmd:
@ -20,8 +19,6 @@ func main() {
 		err = sign(config.(*signConfig))
 	case broadcastSubCmd:
 		err = broadcast(config.(*broadcastConfig))
-	case broadcastReplacementSubCmd:
-		err = broadcastReplacement(config.(*broadcastConfig))
 	case parseSubCmd:
 		err = parse(config.(*parseConfig))
 	case showAddressesSubCmd:
@ -34,14 +31,6 @@ func main() {
 		err = startDaemon(config.(*startDaemonConfig))
 	case sweepSubCmd:
 		err = sweep(config.(*sweepConfig))
-	case versionSubCmd:
-		showVersion()
-	case getDaemonVersionSubCmd:
-		err = getDaemonVersion(config.(*getDaemonVersionConfig))
-	case bumpFeeSubCmd:
-		err = bumpFee(config.(*bumpFeeConfig))
-	case bumpFeeUnsignedSubCmd:
-		err = bumpFeeUnsigned(config.(*bumpFeeUnsignedConfig))
 	default:
 		err = errors.Errorf("Unknown sub-command '%s'\n", subCmd)
 	}
--- a/cmd/kaspawallet/parse.go
+++ b/cmd/kaspawallet/parse.go
@ -3,17 +3,13 @@ package main
 import (
 	"encoding/hex"
 	"fmt"
-	"io/ioutil"
-	"strings"
-
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/server"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/keys"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet/serialization"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/txscript"
-	"github.com/kaspanet/kaspad/util/txmass"
 	"github.com/pkg/errors"
+	"io/ioutil"
+	"strings"
 )

 func parse(conf *parseConfig) error {
@ -24,11 +20,6 @@ func parse(conf *parseConfig) error {
 		return errors.Errorf("Both --transaction and --transaction-file cannot be passed at the same time")
 	}

-	keysFile, err := keys.ReadKeysFile(conf.NetParams(), conf.KeysFile)
-	if err != nil {
-		return err
-	}
-
 	transactionHex := conf.Transaction
 	if conf.TransactionFile != "" {
 		transactionHexBytes, err := ioutil.ReadFile(conf.TransactionFile)
@ -38,12 +29,10 @@ func parse(conf *parseConfig) error {
 		transactionHex = strings.TrimSpace(string(transactionHexBytes))
 	}

-	transactions, err := server.DecodeTransactionsFromHex(transactionHex)
+	transactions, err := decodeTransactionsFromHex(transactionHex)
 	if err != nil {
 		return err
 	}
-
-	txMassCalculator := txmass.NewCalculator(conf.NetParams().MassPerTxByte, conf.NetParams().MassPerScriptPubKeyByte, conf.NetParams().MassPerSigOp)
 	for i, transaction := range transactions {

 		partiallySignedTransaction, err := serialization.DeserializePartiallySignedTransaction(transaction)
@ -89,16 +78,7 @@ func parse(conf *parseConfig) error {
 		}
 		fmt.Println()

-		fee := allInputSompi - allOutputSompi
-		fmt.Printf("Fee:\t%d Sompi (%f KAS)\n", fee, float64(fee)/float64(constants.SompiPerKaspa))
-		mass, err := server.EstimateMassAfterSignatures(partiallySignedTransaction, keysFile.ECDSA, keysFile.MinimumSignatures, txMassCalculator)
-		if err != nil {
-			return err
-		}
-
-		fmt.Printf("Mass: %d grams\n", mass)
-		feeRate := float64(fee) / float64(mass)
-		fmt.Printf("Fee rate: %.2f Sompi/Gram\n", feeRate)
+		fmt.Printf("Fee:\t%d Sompi\n\n", allInputSompi-allOutputSompi)
 	}

 	return nil
--- a/cmd/kaspawallet/send.go
+++ b/cmd/kaspawallet/send.go
@ -3,14 +3,12 @@ package main
 import (
 	"context"
 	"fmt"
-	"os"
-	"strings"

 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/client"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/keys"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
-	"github.com/kaspanet/kaspad/cmd/kaspawallet/utils"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
 	"github.com/pkg/errors"
 )

@ -33,40 +31,13 @@ func send(conf *sendConfig) error {
 	ctx, cancel := context.WithTimeout(context.Background(), daemonTimeout)
 	defer cancel()

-	var sendAmountSompi uint64
-	if !conf.IsSendAll {
-		sendAmountSompi, err = utils.KasToSompi(conf.SendAmount)
-
-		if err != nil {
-			return err
-		}
-	}
-
-	var feePolicy *pb.FeePolicy
-	if conf.FeeRate > 0 {
-		feePolicy = &pb.FeePolicy{
-			FeePolicy: &pb.FeePolicy_ExactFeeRate{
-				ExactFeeRate: conf.FeeRate,
-			},
-		}
-	} else if conf.MaxFeeRate > 0 {
-		feePolicy = &pb.FeePolicy{
-			FeePolicy: &pb.FeePolicy_MaxFeeRate{MaxFeeRate: conf.MaxFeeRate},
-		}
-	} else if conf.MaxFee > 0 {
-		feePolicy = &pb.FeePolicy{
-			FeePolicy: &pb.FeePolicy_MaxFee{MaxFee: conf.MaxFee},
-		}
-	}
+	sendAmountSompi := uint64(conf.SendAmount * constants.SompiPerKaspa)

 	createUnsignedTransactionsResponse, err :=
 		daemonClient.CreateUnsignedTransactions(ctx, &pb.CreateUnsignedTransactionsRequest{
 			From:    conf.FromAddresses,
 			Address: conf.ToAddress,
 			Amount:  sendAmountSompi,
-			IsSendAll:                conf.IsSendAll,
-			UseExistingChangeAddress: conf.UseExistingChangeAddress,
-			FeePolicy:                feePolicy,
 		})
 	if err != nil {
 		return err
@ -77,10 +48,6 @@ func send(conf *sendConfig) error {
 	}
 	mnemonics, err := keysFile.DecryptMnemonics(conf.Password)
 	if err != nil {
-		if strings.Contains(err.Error(), "message authentication failed") {
-			fmt.Fprintf(os.Stderr, "Password decryption failed. Sometimes this is a result of not "+
-				"specifying the same keys file used by the wallet daemon process.\n")
-		}
 		return err
 	}

@ -93,37 +60,19 @@ func send(conf *sendConfig) error {
 		signedTransactions[i] = signedTransaction
 	}

-	fmt.Printf("Broadcasting %d transaction(s)\n", len(signedTransactions))
-	// Since we waited for user input when getting the password, which could take unbound amount of time -
-	// create a new context for broadcast, to reset the timeout.
-	broadcastCtx, broadcastCancel := context.WithTimeout(context.Background(), daemonTimeout)
-	defer broadcastCancel()
-
-	const chunkSize = 100 // To avoid sending a message bigger than the gRPC max message size, we split it to chunks
-	for offset := 0; offset < len(signedTransactions); offset += chunkSize {
-		end := len(signedTransactions)
-		if offset+chunkSize <= len(signedTransactions) {
-			end = offset + chunkSize
+	if len(signedTransactions) > 1 {
+		fmt.Printf("Broadcasting %d transactions\n", len(signedTransactions))
 	}

-		chunk := signedTransactions[offset:end]
-		response, err := daemonClient.Broadcast(broadcastCtx, &pb.BroadcastRequest{Transactions: chunk})
+	response, err := daemonClient.Broadcast(ctx, &pb.BroadcastRequest{Transactions: signedTransactions})
 	if err != nil {
 		return err
 	}
-		fmt.Printf("Broadcasted %d transaction(s) (broadcasted %.2f%% of the transactions so far)\n", len(chunk), 100*float64(end)/float64(len(signedTransactions)))
-		fmt.Println("Broadcasted Transaction ID(s): ")
+	fmt.Println("Transactions were sent successfully")
+	fmt.Println("Transaction ID(s): ")
 	for _, txID := range response.TxIDs {
 		fmt.Printf("\t%s\n", txID)
 	}
-	}
-
-	if conf.Verbose {
-		fmt.Println("Serialized Transaction(s) (can be parsed via the `parse` command or resent via `broadcast`): ")
-		for _, signedTx := range signedTransactions {
-			fmt.Printf("\t%x\n\n", signedTx)
-		}
-	}

 	return nil
 }
--- a/cmd/kaspawallet/show_addresses.go
+++ b/cmd/kaspawallet/show_addresses.go
@ -26,8 +26,5 @@ func showAddresses(conf *showAddressesConfig) error {
 	for _, address := range response.Address {
 		fmt.Println(address)
 	}
-
-	fmt.Printf("\nNote: the above are only addresses that were manually created by the 'new-address' command. If you want to see a list of all addresses, including change addresses, " +
-		"that have a positive balance, use the command 'balance -v'\n")
 	return nil
 }
--- a/cmd/kaspawallet/sign.go
+++ b/cmd/kaspawallet/sign.go
@ -6,7 +6,6 @@ import (
 	"os"
 	"strings"

-	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/server"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/keys"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
 	"github.com/pkg/errors"
@ -41,7 +40,7 @@ func sign(conf *signConfig) error {
 		}
 		transactionsHex = strings.TrimSpace(string(transactionHexBytes))
 	}
-	partiallySignedTransactions, err := server.DecodeTransactionsFromHex(transactionsHex)
+	partiallySignedTransactions, err := decodeTransactionsFromHex(transactionsHex)
 	if err != nil {
 		return err
 	}
@ -73,6 +72,6 @@ func sign(conf *signConfig) error {
 		fmt.Fprintln(os.Stderr, "Successfully signed transaction")
 	}

-	fmt.Println(server.EncodeTransactionsToHex(updatedPartiallySignedTransactions))
+	fmt.Println(encodeTransactionsToHex(updatedPartiallySignedTransactions))
 	return nil
 }
--- a/cmd/kaspawallet/start_daemon.go
+++ b/cmd/kaspawallet/start_daemon.go
@ -3,5 +3,5 @@ package main
 import "github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/server"

 func startDaemon(conf *startDaemonConfig) error {
-	return server.Start(conf.NetParams(), conf.Listen, conf.RPCServer, conf.KeysFile, conf.Profile, conf.Timeout)
+	return server.Start(conf.NetParams(), conf.Listen, conf.RPCServer, conf.KeysFile, conf.Profile)
 }
--- a/cmd/kaspawallet/daemon/server/transactions_hex_encoding.go
+++ b/cmd/kaspawallet/daemon/server/transactions_hex_encoding.go
@ -1,4 +1,4 @@
-package server
+package main

 import (
 	"encoding/hex"
@ -9,7 +9,7 @@ import (
 // We use a separator that is not in the hex alphabet, but which will not split selection with a double click
 const hexTransactionsSeparator = "_"

-func EncodeTransactionsToHex(transactions [][]byte) string {
+func encodeTransactionsToHex(transactions [][]byte) string {
 	transactionsInHex := make([]string, len(transactions))
 	for i, transaction := range transactions {
 		transactionsInHex[i] = hex.EncodeToString(transaction)
@ -17,7 +17,7 @@ func EncodeTransactionsToHex(transactions [][]byte) string {
 	return strings.Join(transactionsInHex, hexTransactionsSeparator)
 }

-func DecodeTransactionsFromHex(transactionsHex string) ([][]byte, error) {
+func decodeTransactionsFromHex(transactionsHex string) ([][]byte, error) {
 	splitTransactionsHexes := strings.Split(transactionsHex, hexTransactionsSeparator)
 	transactions := make([][]byte, len(splitTransactionsHexes))

--- a/cmd/kaspawallet/utils/format_kas.go
+++ b/cmd/kaspawallet/utils/format_kas.go
@ -2,13 +2,8 @@ package utils

 import (
 	"fmt"
-	"math"
-	"regexp"
-	"strconv"
-	"strings"

 	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
-	"github.com/pkg/errors"
 )

 // FormatKas takes the amount of sompis as uint64, and returns amount of KAS with 8  decimal places
@ -19,50 +14,3 @@ func FormatKas(amount uint64) string {
 	}
 	return res
 }
-
-// KasToSompi takes in a string representation of the Kas value to convert to Sompi
-func KasToSompi(amount string) (uint64, error) {
-	err := validateKASAmountFormat(amount)
-
-	if err != nil {
-		return 0, err
-	}
-
-	// after validation, amount can only be either an int OR
-	// a float with an int component and decimal places
-	parts := strings.Split(amount, ".")
-	amountStr := ""
-
-	if constants.SompiPerKaspa%10 != 0 {
-		return 0, errors.Errorf("Unable to convert to sompi when SompiPerKaspa is not a multiple of 10")
-	}
-
-	decimalPlaces := int(math.Log10(constants.SompiPerKaspa))
-	decimalStr := ""
-
-	if len(parts) == 2 {
-		decimalStr = parts[1]
-	}
-
-	amountStr = fmt.Sprintf("%s%-*s", parts[0], decimalPlaces, decimalStr) // Padded with spaces at the end to fill for missing decimals: Sample "0.01234    "
-	amountStr = strings.ReplaceAll(amountStr, " ", "0")                    // Make the spaces be 0s. Sample "0.012340000"
-
-	convertedAmount, err := strconv.ParseUint(amountStr, 10, 64)
-
-	return convertedAmount, err
-}
-
-func validateKASAmountFormat(amount string) error {
-	// Check whether it's an integer, or a float with max 8 digits
-	match, err := regexp.MatchString("^([1-9]\\d{0,11}|0)(\\.\\d{0,8})?$", amount)
-
-	if !match {
-		return errors.Errorf("Invalid amount")
-	}
-
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
--- a/cmd/kaspawallet/utils/format_kas_test.go
+++ b/cmd/kaspawallet/utils/format_kas_test.go
@ -1,90 +0,0 @@
-package utils
-
-import "testing"
-
-// Takes in a string representation of the Kas value to convert to Sompi
-func TestKasToSompi(t *testing.T) {
-	type testVector struct {
-		originalAmount  string
-		convertedAmount uint64
-	}
-
-	validCases := []testVector{
-		{originalAmount: "0", convertedAmount: 0},
-		{originalAmount: "1", convertedAmount: 100000000},
-		{originalAmount: "33184.1489732", convertedAmount: 3318414897320},
-		{originalAmount: "21.35808032", convertedAmount: 2135808032},
-		{originalAmount: "184467440737.09551615", convertedAmount: 18446744073709551615},
-	}
-
-	for _, currentTestVector := range validCases {
-		convertedAmount, err := KasToSompi(currentTestVector.originalAmount)
-
-		if err != nil {
-			t.Error(err)
-		} else if convertedAmount != currentTestVector.convertedAmount {
-			t.Errorf("Expected %s, to convert to %d. Got: %d", currentTestVector.originalAmount, currentTestVector.convertedAmount, convertedAmount)
-		}
-	}
-
-	invalidCases := []string{
-		"184467440737.09551616", // Bigger than max uint64
-		"-1",
-		"a",
-		"",
-	}
-
-	for _, currentTestVector := range invalidCases {
-		_, err := KasToSompi(currentTestVector)
-
-		if err == nil {
-			t.Errorf("Expected an error but succeeded validation for test case %s", currentTestVector)
-		}
-	}
-}
-
-func TestValidateAmountFormat(t *testing.T) {
-	validCases := []string{
-		"0",
-		"1",
-		"1.0",
-		"0.1",
-		"0.12345678",
-		"111111111111.11111111", // 12 digits to the left of decimal, 8 digits to the right
-		"184467440737.09551615", // Maximum input that can be represented in sompi later
-		"184467440737.09551616", // Cannot be represented in sompi, but we'll acccept for "correct format"
-		"999999999999.99999999", // Cannot be represented in sompi, but we'll acccept for "correct format"
-	}
-
-	for _, testCase := range validCases {
-		err := validateKASAmountFormat(testCase)
-
-		if err != nil {
-			t.Error(err)
-		}
-	}
-
-	invalidCases := []string{
-		"",
-		"a",
-		"-1",
-		"0.123456789",           // 9 decimal digits
-		".1",                    // decimal but no integer component
-		"0a",                    // Extra character
-		"0000000000000",         // 13 zeros
-		"012",                   // Int padded with zero
-		"00.1",                  // Decimal padded with zeros
-		"111111111111111111111", // all digits
-		"111111111111A11111111", // non-period/non-digit where decimal would be
-		"000000000000.00000000", // all zeros
-		"kaspa",                 // all text
-	}
-
-	for _, testCase := range invalidCases {
-		err := validateKASAmountFormat(testCase)
-
-		if err == nil {
-			t.Errorf("Expected an error but succeeded validation for test case %s", testCase)
-		}
-	}
-}
--- a/cmd/kaspawallet/version.go
+++ b/cmd/kaspawallet/version.go
@ -1,15 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"github.com/kaspanet/kaspad/version"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-func showVersion() {
-	appName := filepath.Base(os.Args[0])
-	appName = strings.TrimSuffix(appName, filepath.Ext(appName))
-	fmt.Println(appName, "version", version.Version())
-}
--- a/doc.go
+++ b/doc.go
@ -13,11 +13,9 @@ the box' for most users. However, there are also a wide variety of flags that
 can be used to control it.

 Usage:
-
  kaspad [OPTIONS]

 For an up-to-date help message:
-
  kaspad --help

 The long form of all option flags (except -C) can be specified in a configuration
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@ -1,5 +1,5 @@
 # -- multistage docker build: stage #1: build stage
-FROM golang:1.23-alpine AS build
+FROM golang:1.18-alpine AS build

 RUN mkdir -p /go/src/github.com/kaspanet/kaspad

@ -10,13 +10,19 @@ RUN apk add --no-cache curl git openssh binutils gcc musl-dev
 COPY go.mod .
 COPY go.sum .

+RUN go get -u golang.org/x/lint/golint \
+      github.com/kisielk/errcheck \
+      github.com/opennota/check/cmd/aligncheck \
+      github.com/opennota/check/cmd/structcheck \
+      github.com/opennota/check/cmd/varcheck \
+      honnef.co/go/tools/cmd/staticcheck

 # Cache kaspad dependencies
 RUN go mod download

 COPY . .

-RUN go build $FLAGS -o kaspad .
+RUN ./build_and_test.sh

 # --- multistage docker build: stage #2: runtime image
 FROM alpine
--- a/domain/consensus/consensus.go
+++ b/domain/consensus/consensus.go
@ -64,12 +64,6 @@ type consensus struct {
 	virtualNotUpdated   bool
 }

-// In order to prevent a situation that the consensus lock is held for too much time, we
-// release the lock each time we resolve 100 blocks.
-// Note: `virtualResolveChunk` should be smaller than `params.FinalityDuration` in order to avoid a situation
-// where UpdatePruningPointByVirtual skips a pruning point.
-const virtualResolveChunk = 100
-
 func (s *consensus) ValidateAndInsertBlockWithTrustedData(block *externalapi.BlockWithTrustedData, validateUTXO bool) error {
 	s.lock.Lock()
 	defer s.lock.Unlock()
@ -204,32 +198,15 @@ func (s *consensus) ValidateAndInsertBlock(block *externalapi.DomainBlock, updat
 	if updateVirtual {
 		s.lock.Lock()
 		if s.virtualNotUpdated {
-			// We enter the loop in locked state
-			for {
-				_, isCompletelyResolved, err := s.resolveVirtualChunkNoLock(virtualResolveChunk)
-				if err != nil {
-					s.lock.Unlock()
-					return err
-				}
-				if isCompletelyResolved {
-					// Make sure we enter the block insertion function w/o releasing the lock.
-					// Otherwise, we might actually enter it in `s.virtualNotUpdated == true` state
-					_, err = s.validateAndInsertBlockNoLock(block, updateVirtual)
-					// Finally, unlock for the last iteration and return
 			s.lock.Unlock()
+			err := s.ResolveVirtual(nil)
 			if err != nil {
 				return err
 			}
-					return nil
-				}
-				// Unlock to allow other threads to enter consensus
-				s.lock.Unlock()
-				// Lock for the next iteration
-				s.lock.Lock()
-			}
+			return s.validateAndInsertBlockWithLock(block, updateVirtual)
 		}
+		defer s.lock.Unlock()
 		_, err := s.validateAndInsertBlockNoLock(block, updateVirtual)
-		s.lock.Unlock()
 		if err != nil {
 			return err
 		}
@ -357,7 +334,7 @@ func (s *consensus) ValidateTransactionAndPopulateWithConsensusData(transaction
 		stagingArea, transaction, model.VirtualBlockHash)
 }

-func (s *consensus) GetBlock(blockHash *externalapi.DomainHash) (*externalapi.DomainBlock, bool, error) {
+func (s *consensus) GetBlock(blockHash *externalapi.DomainHash) (*externalapi.DomainBlock, error) {
 	s.lock.Lock()
 	defer s.lock.Unlock()

@ -366,11 +343,11 @@ func (s *consensus) GetBlock(blockHash *externalapi.DomainHash) (*externalapi.Do
 	block, err := s.blockStore.Block(s.databaseContext, stagingArea, blockHash)
 	if err != nil {
 		if errors.Is(err, database.ErrNotFound) {
-			return nil, false, nil
+			return nil, errors.Wrapf(err, "block %s does not exist", blockHash)
 		}
-		return nil, false, err
+		return nil, err
 	}
-	return block, true, nil
+	return block, nil
 }

 func (s *consensus) GetBlockEvenIfHeaderOnly(blockHash *externalapi.DomainHash) (*externalapi.DomainBlock, error) {
@ -853,16 +830,12 @@ func (s *consensus) GetVirtualSelectedParentChainFromBlock(blockHash *externalap
 }

 func (s *consensus) validateBlockHashExists(stagingArea *model.StagingArea, blockHash *externalapi.DomainHash) error {
-	status, err := s.blockStatusStore.Get(s.databaseContext, stagingArea, blockHash)
-	if database.IsNotFoundError(err) {
-		return errors.Errorf("block %s does not exist", blockHash)
-	}
+	exists, err := s.blockStatusStore.Exists(s.databaseContext, stagingArea, blockHash)
 	if err != nil {
 		return err
 	}
-
-	if status == externalapi.StatusInvalid {
-		return errors.Errorf("block %s is invalid", blockHash)
+	if !exists {
+		return errors.Errorf("block %s does not exist", blockHash)
 	}
 	return nil
 }
@ -939,7 +912,11 @@ func (s *consensus) ResolveVirtual(progressReportCallback func(uint64, uint64))
 			progressReportCallback(virtualDAAScoreStart, virtualDAAScore)
 		}

-		_, isCompletelyResolved, err := s.resolveVirtualChunkWithLock(virtualResolveChunk)
+		// In order to prevent a situation that the consensus lock is held for too much time, we
+		// release the lock each time we resolve 100 blocks.
+		// Note: maxBlocksToResolve should be smaller than `params.FinalityDuration` in order to avoid a situation
+		// where UpdatePruningPointByVirtual skips a pruning point.
+		_, isCompletelyResolved, err := s.resolveVirtualChunkWithLock(100)
 		if err != nil {
 			return err
 		}
@ -976,11 +953,6 @@ func (s *consensus) resolveVirtualChunkNoLock(maxBlocksToResolve uint64) (*exter
 		return nil, false, err
 	}

-	err = s.pruningManager.UpdatePruningPointIfRequired()
-	if err != nil {
-		return nil, false, err
-	}
-
 	err = s.sendVirtualChangedEvent(virtualChangeSet, true)
 	if err != nil {
 		return nil, false, err
--- a/domain/consensus/factory.go
+++ b/domain/consensus/factory.go
@ -216,8 +216,6 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 	transactionValidator := transactionvalidator.New(config.BlockCoinbaseMaturity,
 		config.EnableNonNativeSubnetworks,
 		config.MaxCoinbasePayloadLength,
-		config.K,
-		config.CoinbasePayloadScriptPublicKeyMaxLength,
 		dbManager,
 		pastMedianTimeManager,
 		ghostdagDataStore,
@ -239,14 +237,12 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		config.GenesisBlock.Header.Bits())
 	coinbaseManager := coinbasemanager.New(
 		dbManager,
-
 		config.SubsidyGenesisReward,
 		config.PreDeflationaryPhaseBaseSubsidy,
 		config.CoinbasePayloadScriptPublicKeyMaxLength,
 		config.GenesisHash,
 		config.DeflationaryPhaseDaaScore,
 		config.DeflationaryPhaseBaseSubsidy,
-
 		dagTraversalManager,
 		ghostdagDataStore,
 		acceptanceDataStore,
@ -544,8 +540,6 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		return nil, false, err
 	}

-	// If the virtual moved before shutdown but the pruning point hasn't, we
-	// move it if needed.
 	stagingArea := model.NewStagingArea()
 	err = pruningManager.UpdatePruningPointByVirtual(stagingArea)
 	if err != nil {
@ -557,11 +551,6 @@ func (f *factory) NewConsensus(config *Config, db infrastructuredatabase.Databas
 		return nil, false, err
 	}

-	err = pruningManager.UpdatePruningPointIfRequired()
-	if err != nil {
-		return nil, false, err
-	}
-
 	return c, false, nil
 }

--- a/domain/consensus/finality_test.go
+++ b/domain/consensus/finality_test.go
@ -263,7 +263,7 @@ func TestBoundedMergeDepth(t *testing.T) {
 					continue
 				}

-				block, _, err := tcSyncer.GetBlock(blocksHash)
+				block, err := tcSyncer.GetBlock(blocksHash)
 				if err != nil {
 					t.Fatalf("GetBlockHeader: %+v", err)
 				}
--- a/domain/consensus/model/acceptancedata_equal_clone_test.go
+++ b/domain/consensus/model/acceptancedata_equal_clone_test.go
@ -329,7 +329,6 @@ func initTestBlockAcceptanceDataForClone() []*externalapi.BlockAcceptanceData {
 					[]byte{0x01},
 					0,
 					1,
-					0,
 					externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
 						0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 						0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -378,7 +377,6 @@ func iniBlockAcceptanceDataForEqual() []testBlockAcceptanceDataStruct {
 				[]byte{0x01},
 				0,
 				1,
-				0,
 				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -412,7 +410,6 @@ func iniBlockAcceptanceDataForEqual() []testBlockAcceptanceDataStruct {
 				[]byte{0x01},
 				0,
 				1,
-				0,
 				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -446,7 +443,6 @@ func iniBlockAcceptanceDataForEqual() []testBlockAcceptanceDataStruct {
 				[]byte{0x01},
 				0,
 				1,
-				0,
 				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -480,7 +476,6 @@ func iniBlockAcceptanceDataForEqual() []testBlockAcceptanceDataStruct {
 				[]byte{0x01},
 				0,
 				1,
-				0,
 				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -515,7 +510,6 @@ func iniBlockAcceptanceDataForEqual() []testBlockAcceptanceDataStruct {
 				[]byte{0x01},
 				0,
 				1,
-				0,
 				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -620,7 +614,6 @@ func initTestAcceptanceDataForClone() []externalapi.AcceptanceData {
 					[]byte{0x01},
 					0,
 					1,
-					0,
 					externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
 						0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 						0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -671,7 +664,6 @@ func initAcceptanceDataForEqual() []testAcceptanceDataStruct {
 					[]byte{0x01},
 					0,
 					1,
-					0,
 					externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
 						0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 						0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -705,7 +697,6 @@ func initAcceptanceDataForEqual() []testAcceptanceDataStruct {
 					[]byte{0x01},
 					0,
 					1,
-					0,
 					externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
 						0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 						0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -739,7 +730,6 @@ func initAcceptanceDataForEqual() []testAcceptanceDataStruct {
 					[]byte{0x01},
 					0,
 					1,
-					0,
 					externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
 						0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 						0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -773,7 +763,6 @@ func initAcceptanceDataForEqual() []testAcceptanceDataStruct {
 					[]byte{0x01},
 					0,
 					1,
-					0,
 					externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
 						0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 						0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
--- a/domain/consensus/model/externalapi/blocklocator.go
+++ b/domain/consensus/model/externalapi/blocklocator.go
@ -10,11 +10,9 @@ package externalapi
 //
 // For example, assume a selected parent chain with IDs as depicted below, and the
 // stop block is genesis:
-//
 // 	genesis -> 1 -> 2 -> ... -> 15 -> 16  -> 17  -> 18
 //
 // The block locator for block 17 would be the hashes of blocks:
-//
 //  [17 16 14 11 7 2 genesis]
 type BlockLocator []*DomainHash

--- a/domain/consensus/model/externalapi/consensus.go
+++ b/domain/consensus/model/externalapi/consensus.go
@ -13,7 +13,7 @@ type Consensus interface {
 	ValidatePruningPointProof(pruningPointProof *PruningPointProof) error
 	ApplyPruningPointProof(pruningPointProof *PruningPointProof) error

-	GetBlock(blockHash *DomainHash) (*DomainBlock, bool, error)
+	GetBlock(blockHash *DomainHash) (*DomainBlock, error)
 	GetBlockEvenIfHeaderOnly(blockHash *DomainHash) (*DomainBlock, error)
 	GetBlockHeader(blockHash *DomainHash) (BlockHeader, error)
 	GetBlockInfo(blockHash *DomainHash) (*BlockInfo, error)
--- a/domain/consensus/model/externalapi/transaction.go
+++ b/domain/consensus/model/externalapi/transaction.go
@ -2,7 +2,6 @@ package externalapi

 import (
 	"bytes"
-	"encoding/binary"
 	"fmt"

 	"github.com/pkg/errors"
@ -20,7 +19,6 @@ type DomainTransaction struct {

 	Fee  uint64
 	Mass uint64
-	MassCommitment uint64

 	// ID is a field that is used to cache the transaction ID.
 	// Always use consensushashing.TransactionID instead of accessing this field directly
@ -57,7 +55,6 @@ func (tx *DomainTransaction) Clone() *DomainTransaction {
 		Payload:      payloadClone,
 		Fee:          tx.Fee,
 		Mass:         tx.Mass,
-		MassCommitment: tx.MassCommitment,
 		ID:           idClone,
 	}
 }
@ -65,7 +62,7 @@ func (tx *DomainTransaction) Clone() *DomainTransaction {
 // If this doesn't compile, it means the type definition has been changed, so it's
 // an indication to update Equal and Clone accordingly.
 var _ = DomainTransaction{0, []*DomainTransactionInput{}, []*DomainTransactionOutput{}, 0,
-	DomainSubnetworkID{}, 0, []byte{}, 0, 0, 0,
+	DomainSubnetworkID{}, 0, []byte{}, 0, 0,
 	&DomainTransactionID{}}

 // Equal returns whether tx equals to other
@ -114,10 +111,6 @@ func (tx *DomainTransaction) Equal(other *DomainTransaction) bool {
 		return false
 	}

-	if tx.MassCommitment != other.MassCommitment {
-		return false
-	}
-
 	if tx.Fee != 0 && other.Fee != 0 && tx.Fee != other.Fee {
 		panic(errors.New("identical transactions should always have the same fee"))
 	}
@ -249,23 +242,6 @@ func (spk *ScriptPublicKey) Equal(other *ScriptPublicKey) bool {
 	return bytes.Equal(spk.Script, other.Script)
 }

-// String stringifies a ScriptPublicKey.
-func (spk *ScriptPublicKey) String() string {
-	var versionBytes = make([]byte, 2) // uint16
-	binary.LittleEndian.PutUint16(versionBytes, spk.Version)
-	versionString := string(versionBytes)
-	scriptString := string(spk.Script)
-	return versionString + scriptString
-}
-
-// NewScriptPublicKeyFromString converts the given string to a scriptPublicKey
-func NewScriptPublicKeyFromString(ScriptPublicKeyString string) *ScriptPublicKey {
-	bytes := []byte(ScriptPublicKeyString)
-	version := binary.LittleEndian.Uint16(bytes[:2])
-	script := bytes[2:]
-	return &ScriptPublicKey{Script: script, Version: version}
-}
-
 // DomainTransactionOutput represents a Kaspad transaction output
 type DomainTransactionOutput struct {
 	Value           uint64
--- a/domain/consensus/model/externalapi/transaction_equal_clone_test.go
+++ b/domain/consensus/model/externalapi/transaction_equal_clone_test.go
@ -83,7 +83,6 @@ func initTestBaseTransaction() *externalapi.DomainTransaction {
 		[]byte{0x01},
 		0,
 		1,
-		0,
 		externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 			0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -113,7 +112,6 @@ func initTestTransactionToCompare() []*transactionToCompare {
 			[]byte{0x01},
 			0,
 			1,
-			0,
 			externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -139,7 +137,6 @@ func initTestTransactionToCompare() []*transactionToCompare {
 			[]byte{0x01},
 			0,
 			1,
-			0,
 			externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -165,7 +162,6 @@ func initTestTransactionToCompare() []*transactionToCompare {
 			[]byte{0x01, 0x02}, //Changed
 			0,
 			1,
-			0,
 			externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -190,7 +186,6 @@ func initTestTransactionToCompare() []*transactionToCompare {
 			[]byte{0x01},
 			0,
 			1,
-			0,
 			externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 				0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -218,7 +213,6 @@ func initTestTransactionToCompare() []*transactionToCompare {
 				[]byte{0x01},
 				0,
 				1,
-				0,
 				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -245,7 +239,6 @@ func initTestTransactionToCompare() []*transactionToCompare {
 				[]byte{0x01},
 				1000000000, //Changed
 				1,
-				0,
 				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -270,7 +263,6 @@ func initTestTransactionToCompare() []*transactionToCompare {
 				[]byte{0x01},
 				0,
 				1,
-				0,
 				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -295,7 +287,6 @@ func initTestTransactionToCompare() []*transactionToCompare {
 				[]byte{0x01},
 				0,
 				2, //Changed
-				0,
 				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -320,7 +311,6 @@ func initTestTransactionToCompare() []*transactionToCompare {
 				[]byte{0x01},
 				0,
 				1,
-				0,
 				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -351,7 +341,6 @@ func initTestTransactionToCompare() []*transactionToCompare {
 				[]byte{0x01},
 				0,
 				1,
-				0,
 				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -377,7 +366,6 @@ func initTestTransactionToCompare() []*transactionToCompare {
 				[]byte{0x01},
 				0,
 				1,
-				0,
 				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -402,7 +390,6 @@ func initTestTransactionToCompare() []*transactionToCompare {
 				[]byte{0x01},
 				0,
 				1,
-				0,
 				nil, //changed
 			},
 			expectedResult: true,
@ -424,7 +411,6 @@ func initTestTransactionToCompare() []*transactionToCompare {
 				[]byte{0x01},
 				0,
 				1,
-				0,
 				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -449,7 +435,6 @@ func initTestTransactionToCompare() []*transactionToCompare {
 				[]byte{0x01},
 				0,
 				1,
-				0,
 				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -476,34 +461,6 @@ func initTestTransactionToCompare() []*transactionToCompare {
 				[]byte{0x01},
 				0,
 				1,
-				0,
-				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02}),
-			},
-			expectedResult: false,
-		},
-		{
-			tx: &externalapi.DomainTransaction{
-				1,
-				[]*externalapi.DomainTransactionInput{{externalapi.DomainOutpoint{
-					*externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x01}), 0xFFFF},
-					[]byte{1, 2, 3},
-					uint64(0xFFFFFFFF),
-					1,
-					utxo.NewUTXOEntry(1, &externalapi.ScriptPublicKey{Script: []byte{0, 1, 2, 3}, Version: 0}, true, 2)}},
-				[]*externalapi.DomainTransactionOutput{{uint64(0xFFFF),
-					&externalapi.ScriptPublicKey{Script: []byte{1, 2}, Version: 0}},
-					{uint64(0xFFFF),
-						&externalapi.ScriptPublicKey{Script: []byte{1, 3}, Version: 0}}},
-				1,
-				externalapi.DomainSubnetworkID{0x01},
-				1,
-				[]byte{0x01},
-				0,
-				1,
-				1, // Changed
 				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -579,7 +536,6 @@ func initTestDomainTransactionForEqual() []testDomainTransactionStruct {
 				[]byte{0x01},
 				1,
 				1,
-				0,
 				externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 					0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -599,7 +555,6 @@ func initTestDomainTransactionForEqual() []testDomainTransactionStruct {
 					[]byte{0x01},
 					1,
 					1,
-					0,
 					nil,
 				},
 				expectedResult: false,
@ -614,7 +569,6 @@ func initTestDomainTransactionForEqual() []testDomainTransactionStruct {
 					[]byte{0x01},
 					1,
 					1,
-					0,
 					nil,
 				},
 				expectedResult: true,
@ -629,7 +583,6 @@ func initTestDomainTransactionForEqual() []testDomainTransactionStruct {
 					[]byte{0x01},
 					2, // Changed fee
 					1,
-					0,
 					nil,
 				},
 				expectsPanic: true,
--- a/domain/consensus/model/interface_processes_mergedepthmanager.go
+++ b/domain/consensus/model/interface_processes_mergedepthmanager.go
@ -7,4 +7,5 @@ type MergeDepthManager interface {
 	CheckBoundedMergeDepth(stagingArea *StagingArea, blockHash *externalapi.DomainHash, isBlockWithTrustedData bool) error
 	NonBoundedMergeDepthViolatingBlues(stagingArea *StagingArea, blockHash, mergeDepthRoot *externalapi.DomainHash) ([]*externalapi.DomainHash, error)
 	VirtualMergeDepthRoot(stagingArea *StagingArea) (*externalapi.DomainHash, error)
+	MergeDepthRoot(stagingArea *StagingArea, blockHash *externalapi.DomainHash, isBlockWithTrustedData bool) (*externalapi.DomainHash, error)
 }
--- a/domain/consensus/model/testapi/test_consensus.go
+++ b/domain/consensus/model/testapi/test_consensus.go
@ -43,9 +43,6 @@ type TestConsensus interface {
 	AddBlock(parentHashes []*externalapi.DomainHash, coinbaseData *externalapi.DomainCoinbaseData,
 		transactions []*externalapi.DomainTransaction) (*externalapi.DomainHash, *externalapi.VirtualChangeSet, error)

-	AddBlockOnTips(coinbaseData *externalapi.DomainCoinbaseData,
-		transactions []*externalapi.DomainTransaction) (*externalapi.DomainHash, *externalapi.VirtualChangeSet, error)
-
 	AddUTXOInvalidHeader(parentHashes []*externalapi.DomainHash) (*externalapi.DomainHash, *externalapi.VirtualChangeSet, error)

 	AddUTXOInvalidBlock(parentHashes []*externalapi.DomainHash) (*externalapi.DomainHash,
--- a/domain/consensus/processes/blockbuilder/block_builder.go
+++ b/domain/consensus/processes/blockbuilder/block_builder.go
@ -131,12 +131,11 @@ func (bb *blockBuilder) validateTransactions(stagingArea *model.StagingArea,
 	for _, transaction := range transactions {
 		err := bb.validateTransaction(stagingArea, transaction)
 		if err != nil {
-			ruleError := ruleerrors.RuleError{}
-			if !errors.As(err, &ruleError) {
+			if !errors.As(err, &ruleerrors.RuleError{}) {
 				return err
 			}
 			invalidTransactions = append(invalidTransactions,
-				ruleerrors.InvalidTransaction{Transaction: transaction, Error: &ruleError})
+				ruleerrors.InvalidTransaction{Transaction: transaction, Error: err})
 		}
 	}

--- a/domain/consensus/processes/blockprocessor/validate_and_insert_imported_pruning_point_test.go
+++ b/domain/consensus/processes/blockprocessor/validate_and_insert_imported_pruning_point_test.go
@ -93,7 +93,7 @@ func TestValidateAndInsertImportedPruningPoint(t *testing.T) {
 			}

 			for _, blockHash := range pruningPointAndItsAnticone {
-				block, _, err := tcSyncer.GetBlock(blockHash)
+				block, err := tcSyncer.GetBlock(blockHash)
 				if err != nil {
 					t.Fatalf("GetBlock: %+v", err)
 				}
@ -268,7 +268,7 @@ func TestValidateAndInsertImportedPruningPoint(t *testing.T) {
 			}

 			for _, blocksHash := range missingBlockHashes {
-				block, _, err := tcSyncer.GetBlock(blocksHash)
+				block, err := tcSyncer.GetBlock(blocksHash)
 				if err != nil {
 					t.Fatalf("GetBlock: %+v", err)
 				}
@ -294,7 +294,7 @@ func TestValidateAndInsertImportedPruningPoint(t *testing.T) {
 			}

 			tipHash := addBlock(tcSyncer, syncerTips, t)
-			tip, _, err := tcSyncer.GetBlock(tipHash)
+			tip, err := tcSyncer.GetBlock(tipHash)
 			if err != nil {
 				t.Fatalf("GetBlock: %+v", err)
 			}
@ -341,7 +341,7 @@ func TestValidateAndInsertImportedPruningPoint(t *testing.T) {
 		tipHash := consensusConfig.GenesisHash
 		for i := 0; i < numSharedBlocks; i++ {
 			tipHash = addBlock(tcSyncer, []*externalapi.DomainHash{tipHash}, t)
-			block, _, err := tcSyncer.GetBlock(tipHash)
+			block, err := tcSyncer.GetBlock(tipHash)
 			if err != nil {
 				t.Fatalf("GetBlock: %+v", err)
 			}
--- a/domain/consensus/processes/blockvalidator/block_body_in_context_test.go
+++ b/domain/consensus/processes/blockvalidator/block_body_in_context_test.go
@ -41,7 +41,7 @@ func TestCheckBlockIsNotPruned(t *testing.T) {
 			t.Fatalf("AddBlock: %+v", err)
 		}

-		beforePruningBlock, _, err := tc.GetBlock(tipHash)
+		beforePruningBlock, err := tc.GetBlock(tipHash)
 		if err != nil {
 			t.Fatalf("beforePruningBlock: %+v", err)
 		}
@ -199,7 +199,7 @@ func TestIsFinalizedTransaction(t *testing.T) {
 			t.Fatalf("Error getting block DAA score : %+v", err)
 		}
 		blockParents := block.Header.DirectParents()
-		parentToSpend, _, err := tc.GetBlock(blockParents[0])
+		parentToSpend, err := tc.GetBlock(blockParents[0])
 		if err != nil {
 			t.Fatalf("Error getting block1: %+v", err)
 		}
--- a/domain/consensus/processes/blockvalidator/block_body_in_isolation_test.go
+++ b/domain/consensus/processes/blockvalidator/block_body_in_isolation_test.go
@ -70,7 +70,7 @@ func TestChainedTransactions(t *testing.T) {
 			t.Fatalf("AddBlock: %+v", err)
 		}

-		block1, _, err := tc.GetBlock(block1Hash)
+		block1, err := tc.GetBlock(block1Hash)
 		if err != nil {
 			t.Fatalf("Error getting block1: %+v", err)
 		}
@ -97,7 +97,7 @@ func TestChainedTransactions(t *testing.T) {
 			t.Fatalf("unexpected error %+v", err)
 		}

-		block2, _, err := tc.GetBlock(block2Hash)
+		block2, err := tc.GetBlock(block2Hash)
 		if err != nil {
 			t.Fatalf("Error getting block2: %+v", err)
 		}
@ -169,10 +169,10 @@ var unOrderedParentsBlock = externalapi.DomainBlock{
 			}),
 		}},
 		externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{
-			0x7e, 0xe2, 0x10, 0x4e, 0x21, 0x2f, 0x2a, 0xb1,
-			0x7d, 0x22, 0xf5, 0xe8, 0xa0, 0x98, 0xef, 0x53,
-			0x83, 0xae, 0x59, 0x1f, 0x83, 0xf3, 0x78, 0x5d,
-			0x30, 0xae, 0x3e, 0xb3, 0x06, 0x08, 0x6f, 0x79,
+			0x31, 0x33, 0x37, 0x72, 0x5c, 0xde, 0x1c, 0xdf,
+			0xf5, 0x9f, 0xde, 0x16, 0x74, 0xbf, 0x0c, 0x64,
+			0x37, 0x40, 0x49, 0xdf, 0x02, 0x05, 0xca, 0x6d,
+			0x52, 0x23, 0x6f, 0xc2, 0x2b, 0xec, 0xad, 0x42,
 		}),
 		externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{
 			0x80, 0xf7, 0x00, 0xe3, 0x16, 0x3d, 0x04, 0x95,
@ -202,7 +202,20 @@ var unOrderedParentsBlock = externalapi.DomainBlock{
 	Transactions: []*externalapi.DomainTransaction{
 		{
 			Version: 0,
-			Inputs:  nil,
+			Inputs: []*externalapi.DomainTransactionInput{
+				{
+					PreviousOutpoint: externalapi.DomainOutpoint{
+						TransactionID: *externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{}),
+						Index:         0xffffffff,
+					},
+					SignatureScript: []byte{
+						0x02, 0x10, 0x27, 0x08, 0xac, 0x29, 0x2f, 0x2f,
+						0xcf, 0x70, 0xb0, 0x7e, 0x0b, 0x2f, 0x50, 0x32,
+						0x53, 0x48, 0x2f, 0x62, 0x74, 0x63, 0x64, 0x2f,
+					},
+					Sequence: math.MaxUint64,
+				},
+			},
 			Outputs: []*externalapi.DomainTransactionOutput{
 				{
 					Value: 0x12a05f200, // 5000000000
@ -433,10 +446,10 @@ var exampleValidBlock = externalapi.DomainBlock{
 			}),
 		}},
 		externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{
-			0x46, 0xec, 0xf4, 0x5b, 0xe3, 0xba, 0xca, 0x34,
-			0x9d, 0xfe, 0x8a, 0x78, 0xde, 0xaf, 0x05, 0x3b,
-			0x0a, 0xa6, 0xd5, 0x38, 0x97, 0x4d, 0xa5, 0x0f,
-			0xd6, 0xef, 0xb4, 0xd2, 0x66, 0xbc, 0x8d, 0x21,
+			0x86, 0x8b, 0x73, 0xcd, 0x20, 0x51, 0x23, 0x60,
+			0xea, 0x62, 0x99, 0x9b, 0x87, 0xf6, 0xdd, 0x8d,
+			0xa4, 0x0b, 0xd7, 0xcf, 0xc6, 0x32, 0x38, 0xee,
+			0xd9, 0x68, 0x72, 0x1f, 0xa2, 0x51, 0xe4, 0x28,
 		}),
 		externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{
 			0x8a, 0xb7, 0xd6, 0x73, 0x1b, 0xe6, 0xc5, 0xd3,
@ -461,7 +474,21 @@ var exampleValidBlock = externalapi.DomainBlock{
 	Transactions: []*externalapi.DomainTransaction{
 		{
 			Version: 0,
-			Inputs:  nil,
+			Inputs: []*externalapi.DomainTransactionInput{
+				{
+					PreviousOutpoint: externalapi.DomainOutpoint{
+						TransactionID: *externalapi.NewDomainTransactionIDFromByteArray(&[externalapi.DomainHashSize]byte{
+							0x9b, 0x22, 0x59, 0x44, 0x66, 0xf0, 0xbe, 0x50,
+							0x7c, 0x1c, 0x8a, 0xf6, 0x06, 0x27, 0xe6, 0x33,
+							0x38, 0x7e, 0xd1, 0xd5, 0x8c, 0x42, 0x59, 0x1a,
+							0x31, 0xac, 0x9a, 0xa6, 0x2e, 0xd5, 0x2b, 0x0f,
+						}),
+						Index: 0xffffffff,
+					},
+					SignatureScript: nil,
+					Sequence:        math.MaxUint64,
+				},
+			},
 			Outputs: []*externalapi.DomainTransactionOutput{
 				{
 					Value: 0x12a05f200, // 5000000000
@ -724,10 +751,10 @@ var blockWithWrongTxOrder = externalapi.DomainBlock{
 			}),
 		}},
 		externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{
-			0xd5, 0xd2, 0x32, 0xe4, 0xbe, 0x9c, 0x33, 0xbd,
-			0xf1, 0x0a, 0xd2, 0x9d, 0x0c, 0xbd, 0xe5, 0xae,
-			0xcb, 0x1a, 0xf9, 0x5a, 0x3e, 0xfb, 0xf3, 0xc7,
-			0x2b, 0x4d, 0x10, 0xa6, 0xbd, 0x5f, 0x07, 0xe7,
+			0x7b, 0x25, 0x8b, 0xfa, 0xfb, 0x49, 0xe4, 0x94,
+			0x48, 0x2c, 0xf9, 0x74, 0xdd, 0xad, 0x9d, 0x6f,
+			0x98, 0x8f, 0xfb, 0x01, 0x9d, 0x49, 0x29, 0xbe,
+			0x3c, 0xec, 0x90, 0xfe, 0xa5, 0x0c, 0xaf, 0x6b,
 		}),
 		externalapi.NewDomainHashFromByteArray(&[externalapi.DomainHashSize]byte{
 			0xa0, 0x69, 0x2d, 0x16, 0xb5, 0xd7, 0xe4, 0xf3,
--- a/domain/consensus/processes/coinbasemanager/coinbasemanager_external_test.go
+++ b/domain/consensus/processes/coinbasemanager/coinbasemanager_external_test.go
@ -1,57 +0,0 @@
-package coinbasemanager_test
-
-import (
-	"github.com/kaspanet/kaspad/domain/consensus"
-	"github.com/kaspanet/kaspad/domain/consensus/model"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/testutils"
-	"testing"
-)
-
-func TestExtractCoinbaseDataBlueScoreAndSubsidy(t *testing.T) {
-	testutils.ForAllNets(t, true, func(t *testing.T, consensusConfig *consensus.Config) {
-		factory := consensus.NewFactory()
-		tc, teardown, err := factory.NewTestConsensus(consensusConfig, "TestBlockStatus")
-		if err != nil {
-			t.Fatalf("Error setting up consensus: %+v", err)
-		}
-		defer teardown(false)
-
-		tests := []struct {
-			name                   string
-			scriptPublicKeyVersion uint16
-		}{
-			{
-				name:                   "below 255",
-				scriptPublicKeyVersion: 100,
-			},
-			{
-				name:                   "above 255",
-				scriptPublicKeyVersion: 300,
-			},
-		}
-
-		for _, test := range tests {
-			coinbaseTx, _, err := tc.CoinbaseManager().ExpectedCoinbaseTransaction(model.NewStagingArea(), model.VirtualBlockHash, &externalapi.DomainCoinbaseData{
-				ScriptPublicKey: &externalapi.ScriptPublicKey{
-					Script:  nil,
-					Version: test.scriptPublicKeyVersion,
-				},
-				ExtraData: nil,
-			})
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			_, cbData, _, err := tc.CoinbaseManager().ExtractCoinbaseDataBlueScoreAndSubsidy(coinbaseTx)
-			if err != nil {
-				t.Fatal(err)
-			}
-
-			if cbData.ScriptPublicKey.Version != test.scriptPublicKeyVersion {
-				t.Fatalf("test %s post HF expected %d but got %d", test.name, test.scriptPublicKeyVersion, cbData.ScriptPublicKey.Version)
-			}
-		}
-
-	})
-}
--- a/domain/consensus/processes/coinbasemanager/payload.go
+++ b/domain/consensus/processes/coinbasemanager/payload.go
@ -28,7 +28,7 @@ func (c *coinbaseManager) serializeCoinbasePayload(blueScore uint64,
 	binary.LittleEndian.PutUint64(payload[:uint64Len], blueScore)
 	binary.LittleEndian.PutUint64(payload[uint64Len:], subsidy)

-	binary.LittleEndian.PutUint16(payload[uint64Len+lengthOfSubsidy:], coinbaseData.ScriptPublicKey.Version)
+	payload[uint64Len+lengthOfSubsidy] = uint8(coinbaseData.ScriptPublicKey.Version)
 	payload[uint64Len+lengthOfSubsidy+lengthOfVersionScriptPubKey] = uint8(len(coinbaseData.ScriptPublicKey.Script))
 	copy(payload[uint64Len+lengthOfSubsidy+lengthOfVersionScriptPubKey+lengthOfScriptPubKeyLength:], coinbaseData.ScriptPublicKey.Script)
 	copy(payload[uint64Len+lengthOfSubsidy+lengthOfVersionScriptPubKey+lengthOfScriptPubKeyLength+scriptLengthOfScriptPubKey:], coinbaseData.ExtraData)
@ -52,7 +52,7 @@ func ModifyCoinbasePayload(payload []byte, coinbaseData *externalapi.DomainCoinb
 		payload = newPayload
 	}

-	binary.LittleEndian.PutUint16(payload[uint64Len+lengthOfSubsidy:uint64Len+lengthOfSubsidy+lengthOfVersionScriptPubKey], coinbaseData.ScriptPublicKey.Version)
+	payload[uint64Len+lengthOfSubsidy] = uint8(coinbaseData.ScriptPublicKey.Version)
 	payload[uint64Len+lengthOfSubsidy+lengthOfVersionScriptPubKey] = uint8(len(coinbaseData.ScriptPublicKey.Script))
 	copy(payload[uint64Len+lengthOfSubsidy+lengthOfVersionScriptPubKey+lengthOfScriptPubKeyLength:], coinbaseData.ScriptPublicKey.Script)
 	copy(payload[uint64Len+lengthOfSubsidy+lengthOfVersionScriptPubKey+lengthOfScriptPubKeyLength+scriptLengthOfScriptPubKey:], coinbaseData.ExtraData)
@ -73,8 +73,7 @@ func (c *coinbaseManager) ExtractCoinbaseDataBlueScoreAndSubsidy(coinbaseTx *ext
 	blueScore = binary.LittleEndian.Uint64(coinbaseTx.Payload[:uint64Len])
 	subsidy = binary.LittleEndian.Uint64(coinbaseTx.Payload[uint64Len:])

-	scriptPubKeyVersion := binary.LittleEndian.Uint16(coinbaseTx.Payload[uint64Len+lengthOfSubsidy : uint64Len+lengthOfSubsidy+uint16Len])
-
+	scriptPubKeyVersion := uint16(coinbaseTx.Payload[uint64Len+lengthOfSubsidy])
 	scriptPubKeyScriptLength := coinbaseTx.Payload[uint64Len+lengthOfSubsidy+lengthOfVersionScriptPubKey]

 	if scriptPubKeyScriptLength > c.coinbasePayloadScriptPublicKeyMaxLength {
--- a/domain/consensus/processes/consensusstatemanager/calculate_past_utxo_test.go
+++ b/domain/consensus/processes/consensusstatemanager/calculate_past_utxo_test.go
@ -40,7 +40,7 @@ func TestUTXOCommitment(t *testing.T) {
 		if err != nil {
 			t.Fatalf("Error creating block B: %+v", err)
 		}
-		blockB, _, err := consensus.GetBlock(blockBHash)
+		blockB, err := consensus.GetBlock(blockBHash)
 		if err != nil {
 			t.Fatalf("Error getting block B: %+v", err)
 		}
@ -73,7 +73,7 @@ func TestUTXOCommitment(t *testing.T) {
 }

 func checkBlockUTXOCommitment(t *testing.T, consensus testapi.TestConsensus, blockHash *externalapi.DomainHash, blockName string) {
-	block, _, err := consensus.GetBlock(blockHash)
+	block, err := consensus.GetBlock(blockHash)
 	if err != nil {
 		t.Fatalf("Error getting block %s: %+v", blockName, err)
 	}
--- a/Show More
+++ b/Show More