Bump version to 0.12.22 (#2307)

* Fix block verbosedata population from skipping transaction verbosedata population when BlockInfo errorenously reports block as Header only, but domainBlock is still fount with GetBlockEvenIfHeaderOnly.

* Update app/rpc/rpccontext/verbosedata.go

---------

Co-authored-by: Toni Lukkaroinen <toni.lukkaroinen@hoosat.fi>
Co-authored-by: Michael Sutton <mikisiton2@gmail.com>
Co-authored-by: Ori Newman <orinewman1@gmail.com>

.github/workflows/deploy.yaml

@@ -1,7 +1,7 @@
 name: Build and upload assets
 on:
   release:
-    types: [ published ]
+    types: [published]
 
 jobs:
   build:
@@ -9,7 +9,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ ubuntu-latest, windows-latest, macos-latest ]
+        os: [ubuntu-latest, windows-latest, macos-latest]
     name: Building, ${{ matrix.os }}
     steps:
       - name: Fix CRLF on Windows
@@ -17,13 +17,12 @@ jobs:
         run: git config --global core.autocrlf false
 
       - name: Check out code into the Go module directory
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
-
 
       - name: Setup Go
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v5
         with:
-          go-version: 1.18
+          go-version: 1.21
 
       - name: Build on Linux
         if: runner.os == 'Linux'
@@ -31,7 +30,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/*
@@ -42,7 +41,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}\""
@@ -52,14 +51,13 @@ 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:

.github/workflows/race.yaml

@@ -11,18 +11,18 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        branch: [ master, latest ]
+        branch: [master, latest]
     name: Race detection on ${{ matrix.branch }}
     steps:
       - name: Check out code into the Go module directory
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
       - name: Setup Go
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v5
         with:
-          go-version: 1.18
+          go-version: 1.23
 
       - name: Set scheduled branch name
         shell: bash

.github/workflows/tests.yaml

@@ -8,22 +8,20 @@ on:
     types: [opened, synchronize, edited]
 
 jobs:
-
   build:
     runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
-        os: [ ubuntu-latest, macos-latest ]
+        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@v2
+        uses: actions/checkout@v4
 
       # Increase the pagefile size on Windows to aviod running out of memory
       - name: Increase pagefile size on Windows
@@ -31,14 +29,13 @@ jobs:
         run: powershell -command .github\workflows\SetPageFileSize.ps1
 
       - name: Setup Go
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v5
         with:
-          go-version: 1.18
+          go-version: 1.23
-
 
       # Source: https://github.com/actions/cache/blob/main/examples.md#go---modules
       - name: Go Cache
-        uses: actions/cache@v2
+        uses: actions/cache@v4
         with:
           path: ~/go/pkg/mod
           key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
@@ -49,19 +46,17 @@ 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@v2
+        uses: actions/setup-go@v5
         with:
-          go-version: 1.18
+          go-version: 1.23
 
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v4
         with:
           fetch-depth: 0
 
@@ -75,18 +70,17 @@ 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@v2
+        uses: actions/checkout@v4
 
       - name: Setup Go
-        uses: actions/setup-go@v2
+        uses: actions/setup-go@v5
         with:
-          go-version: 1.18
+          go-version: 1.23
 
       - name: Delete the stability tests from coverage
         run: rm -r stability-tests

.gitignore

@@ -53,6 +53,7 @@ _testmain.go
 debug
 debug.test
 __debug_bin
+*__debug_*
 
 # CI
 version.txt

CODE_OF_CONDUCT.md

@@ -0,0 +1,43 @@
+# 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/

README.md

@@ -1,13 +1,15 @@
+# DEPRECATED
 
-Kaspad
+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
 
 [![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 is the reference full node Kaspa implementation written in Go (golang).
+Kaspad was 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
 
@@ -15,7 +17,7 @@ Kaspa is an attempt at a proof-of-work cryptocurrency with instant confirmations
 
 ## Requirements
 
-Go 1.18 or later.
+Go 1.23 or later.
 
 ## Installation
 
@@ -42,7 +44,6 @@ $ 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
@@ -53,6 +54,7 @@ $ kaspad
 ```
 
 ## Discord
+
 Join our discord server using the following link: https://discord.gg/YNYnNN5Pf2
 
 ## Issue Tracker

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,18 +60,18 @@ 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
 the following constants:
 
-    appmessage.Mainnet
+	appmessage.Mainnet
-    appmessage.Testnet (Test network)
+	appmessage.Testnet (Test network)
-    appmessage.Simnet  (Simulation test network)
+	appmessage.Simnet  (Simulation test network)
-    appmessage.Devnet  (Development 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

app/appmessage/domainconverters.go

@@ -2,9 +2,10 @@ package appmessage
 
 import (
 	"encoding/hex"
-	"github.com/pkg/errors"
 	"math/big"
 
+	"github.com/pkg/errors"
+
 	"github.com/kaspanet/kaspad/domain/consensus/utils/blockheader"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
@@ -213,13 +214,14 @@ func RPCTransactionToDomainTransaction(rpcTransaction *RPCTransaction) (*externa
 	}
 
 	return &externalapi.DomainTransaction{
-		Version:      rpcTransaction.Version,
+		Version:        rpcTransaction.Version,
-		Inputs:       inputs,
+		Inputs:         inputs,
-		Outputs:      outputs,
+		Outputs:        outputs,
-		LockTime:     rpcTransaction.LockTime,
+		LockTime:       rpcTransaction.LockTime,
-		SubnetworkID: *subnetworkID,
+		SubnetworkID:   *subnetworkID,
-		Gas:          rpcTransaction.LockTime,
+		Gas:            rpcTransaction.Gas,
-		Payload:      payload,
+		MassCommitment: rpcTransaction.Mass,
+		Payload:        payload,
 	}, nil
 }
 
@@ -286,7 +288,8 @@ func DomainTransactionToRPCTransaction(transaction *externalapi.DomainTransactio
 		Outputs:      outputs,
 		LockTime:     transaction.LockTime,
 		SubnetworkID: subnetworkID,
-		Gas:          transaction.LockTime,
+		Gas:          transaction.Gas,
+		Mass:         transaction.MassCommitment,
 		Payload:      payload,
 	}
 }

app/appmessage/message.go

@@ -159,6 +159,14 @@ const (
 	CmdNotifyNewBlockTemplateRequestMessage
 	CmdNotifyNewBlockTemplateResponseMessage
 	CmdNewBlockTemplateNotificationMessage
+	CmdGetMempoolEntriesByAddressesRequestMessage
+	CmdGetMempoolEntriesByAddressesResponseMessage
+	CmdGetCoinSupplyRequestMessage
+	CmdGetCoinSupplyResponseMessage
+	CmdGetFeeEstimateRequestMessage
+	CmdGetFeeEstimateResponseMessage
+	CmdSubmitTransactionReplacementRequestMessage
+	CmdSubmitTransactionReplacementResponseMessage
 )
 
 // ProtocolMessageCommandToString maps all MessageCommands to their string representation
@@ -292,6 +300,14 @@ var RPCMessageCommandToString = map[MessageCommand]string{
 	CmdNotifyNewBlockTemplateRequestMessage:                       "NotifyNewBlockTemplateRequest",
 	CmdNotifyNewBlockTemplateResponseMessage:                      "NotifyNewBlockTemplateResponse",
 	CmdNewBlockTemplateNotificationMessage:                        "NewBlockTemplateNotification",
+	CmdGetMempoolEntriesByAddressesRequestMessage:                 "GetMempoolEntriesByAddressesRequest",
+	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

app/appmessage/p2p_msgblock_test.go

@@ -132,7 +132,7 @@ func TestConvertToPartial(t *testing.T) {
 	}
 }
 
-//blockOne is the first block in the mainnet block DAG.
+// blockOne is the first block in the mainnet block DAG.
 var blockOne = MsgBlock{
 	Header: MsgBlockHeader{
 		Version:              0,

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 := "93663e597f6c968d32d229002f76408edf30d6a0151ff679fc729812d8cb2acc"
+	txHash1Str := "b06f8b650115b5cf4d59499e10764a9312742930cb43c9b4ff6495d76f332ed7"
-	txID1Str := "24079c6d2bdf602fc389cc307349054937744a9c8dc0f07c023e6af0e949a4e7"
+	txID1Str := "e20225c3d065ee41743607ee627db44d01ef396dc9779b05b2caf55bac50e12d"
 	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 := "8dafd1bec24527d8e3b443ceb0a3b92fffc0d60026317f890b2faf5e9afc177a"
+	hash2Str := "fa16a8ce88d52ca1ff45187bbba0d33044e9f5fe309e8d0b22d4812dcf1782b7"
 	wantHash2, err := externalapi.NewDomainHashFromString(hash2Str)
 	if err != nil {
 		t.Errorf("NewTxIDFromStr: %v", err)

app/appmessage/rpc_fee_estimate.go

@@ -0,0 +1,47 @@
+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{}
+}

app/appmessage/rpc_get_coin_supply.go

@@ -0,0 +1,40 @@
+package appmessage
+
+// GetCoinSupplyRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetCoinSupplyRequestMessage struct {
+	baseMessage
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetCoinSupplyRequestMessage) Command() MessageCommand {
+	return CmdGetCoinSupplyRequestMessage
+}
+
+// NewGetCoinSupplyRequestMessage returns a instance of the message
+func NewGetCoinSupplyRequestMessage() *GetCoinSupplyRequestMessage {
+	return &GetCoinSupplyRequestMessage{}
+}
+
+// GetCoinSupplyResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetCoinSupplyResponseMessage struct {
+	baseMessage
+	MaxSompi         uint64
+	CirculatingSompi uint64
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetCoinSupplyResponseMessage) Command() MessageCommand {
+	return CmdGetCoinSupplyResponseMessage
+}
+
+// NewGetCoinSupplyResponseMessage returns a instance of the message
+func NewGetCoinSupplyResponseMessage(maxSompi uint64, circulatingSompi uint64) *GetCoinSupplyResponseMessage {
+	return &GetCoinSupplyResponseMessage{
+		MaxSompi:         maxSompi,
+		CirculatingSompi: circulatingSompi,
+	}
+}

app/appmessage/rpc_get_info.go

@@ -23,6 +23,8 @@ type GetInfoResponseMessage struct {
 	P2PID         string
 	MempoolSize   uint64
 	ServerVersion string
+	IsUtxoIndexed bool
+	IsSynced      bool
 
 	Error *RPCError
 }
@@ -33,10 +35,12 @@ func (msg *GetInfoResponseMessage) Command() MessageCommand {
 }
 
 // NewGetInfoResponseMessage returns a instance of the message
-func NewGetInfoResponseMessage(p2pID string, mempoolSize uint64, serverVersion string) *GetInfoResponseMessage {
+func NewGetInfoResponseMessage(p2pID string, mempoolSize uint64, serverVersion string, isUtxoIndexed bool, isSynced bool) *GetInfoResponseMessage {
 	return &GetInfoResponseMessage{
 		P2PID:         p2pID,
 		MempoolSize:   mempoolSize,
 		ServerVersion: serverVersion,
+		IsUtxoIndexed: isUtxoIndexed,
+		IsSynced:      isSynced,
 	}
 }

app/appmessage/rpc_get_mempool_entries.go

@@ -4,6 +4,8 @@ package appmessage
 // its respective RPC message
 type GetMempoolEntriesRequestMessage struct {
 	baseMessage
+	IncludeOrphanPool     bool
+	FilterTransactionPool bool
 }
 
 // Command returns the protocol command string for the message
@@ -12,8 +14,11 @@ func (msg *GetMempoolEntriesRequestMessage) Command() MessageCommand {
 }
 
 // NewGetMempoolEntriesRequestMessage returns a instance of the message
-func NewGetMempoolEntriesRequestMessage() *GetMempoolEntriesRequestMessage {
+func NewGetMempoolEntriesRequestMessage(includeOrphanPool bool, filterTransactionPool bool) *GetMempoolEntriesRequestMessage {
-	return &GetMempoolEntriesRequestMessage{}
+	return &GetMempoolEntriesRequestMessage{
+		IncludeOrphanPool:     includeOrphanPool,
+		FilterTransactionPool: filterTransactionPool,
+	}
 }
 
 // GetMempoolEntriesResponseMessage is an appmessage corresponding to

app/appmessage/rpc_get_mempool_entries_by_addresses.go

@@ -0,0 +1,52 @@
+package appmessage
+
+// MempoolEntryByAddress represents MempoolEntries associated with some address
+type MempoolEntryByAddress struct {
+	Address   string
+	Receiving []*MempoolEntry
+	Sending   []*MempoolEntry
+}
+
+// GetMempoolEntriesByAddressesRequestMessage is an appmessage corresponding to
+// its respective RPC message
+type GetMempoolEntriesByAddressesRequestMessage struct {
+	baseMessage
+	Addresses             []string
+	IncludeOrphanPool     bool
+	FilterTransactionPool bool
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetMempoolEntriesByAddressesRequestMessage) Command() MessageCommand {
+	return CmdGetMempoolEntriesByAddressesRequestMessage
+}
+
+// NewGetMempoolEntriesByAddressesRequestMessage returns a instance of the message
+func NewGetMempoolEntriesByAddressesRequestMessage(addresses []string, includeOrphanPool bool, filterTransactionPool bool) *GetMempoolEntriesByAddressesRequestMessage {
+	return &GetMempoolEntriesByAddressesRequestMessage{
+		Addresses:             addresses,
+		IncludeOrphanPool:     includeOrphanPool,
+		FilterTransactionPool: filterTransactionPool,
+	}
+}
+
+// GetMempoolEntriesByAddressesResponseMessage is an appmessage corresponding to
+// its respective RPC message
+type GetMempoolEntriesByAddressesResponseMessage struct {
+	baseMessage
+	Entries []*MempoolEntryByAddress
+
+	Error *RPCError
+}
+
+// Command returns the protocol command string for the message
+func (msg *GetMempoolEntriesByAddressesResponseMessage) Command() MessageCommand {
+	return CmdGetMempoolEntriesByAddressesResponseMessage
+}
+
+// NewGetMempoolEntriesByAddressesResponseMessage returns a instance of the message
+func NewGetMempoolEntriesByAddressesResponseMessage(entries []*MempoolEntryByAddress) *GetMempoolEntriesByAddressesResponseMessage {
+	return &GetMempoolEntriesByAddressesResponseMessage{
+		Entries: entries,
+	}
+}

app/appmessage/rpc_get_mempool_entry.go

@@ -4,7 +4,9 @@ package appmessage
 // its respective RPC message
 type GetMempoolEntryRequestMessage struct {
 	baseMessage
-	TxID string
+	TxID                  string
+	IncludeOrphanPool     bool
+	FilterTransactionPool bool
 }
 
 // Command returns the protocol command string for the message
@@ -13,8 +15,12 @@ func (msg *GetMempoolEntryRequestMessage) Command() MessageCommand {
 }
 
 // NewGetMempoolEntryRequestMessage returns a instance of the message
-func NewGetMempoolEntryRequestMessage(txID string) *GetMempoolEntryRequestMessage {
+func NewGetMempoolEntryRequestMessage(txID string, includeOrphanPool bool, filterTransactionPool bool) *GetMempoolEntryRequestMessage {
-	return &GetMempoolEntryRequestMessage{TxID: txID}
+	return &GetMempoolEntryRequestMessage{
+		TxID:                  txID,
+		IncludeOrphanPool:     includeOrphanPool,
+		FilterTransactionPool: filterTransactionPool,
+	}
 }
 
 // GetMempoolEntryResponseMessage is an appmessage corresponding to
@@ -30,6 +36,7 @@ type GetMempoolEntryResponseMessage struct {
 type MempoolEntry struct {
 	Fee         uint64
 	Transaction *RPCTransaction
+	IsOrphan    bool
 }
 
 // Command returns the protocol command string for the message
@@ -38,11 +45,12 @@ func (msg *GetMempoolEntryResponseMessage) Command() MessageCommand {
 }
 
 // NewGetMempoolEntryResponseMessage returns a instance of the message
-func NewGetMempoolEntryResponseMessage(fee uint64, transaction *RPCTransaction) *GetMempoolEntryResponseMessage {
+func NewGetMempoolEntryResponseMessage(fee uint64, transaction *RPCTransaction, isOrphan bool) *GetMempoolEntryResponseMessage {
 	return &GetMempoolEntryResponseMessage{
 		Entry: &MempoolEntry{
 			Fee:         fee,
 			Transaction: transaction,
+			IsOrphan:    isOrphan,
 		},
 	}
 }

app/appmessage/rpc_get_virtual_selected_parent_chain_from_block.go

@@ -4,7 +4,8 @@ package appmessage
 // its respective RPC message
 type GetVirtualSelectedParentChainFromBlockRequestMessage struct {
 	baseMessage
-	StartHash string
+	StartHash                     string
+	IncludeAcceptedTransactionIDs bool
 }
 
 // Command returns the protocol command string for the message
@@ -13,18 +14,29 @@ func (msg *GetVirtualSelectedParentChainFromBlockRequestMessage) Command() Messa
 }
 
 // NewGetVirtualSelectedParentChainFromBlockRequestMessage returns a instance of the message
-func NewGetVirtualSelectedParentChainFromBlockRequestMessage(startHash string) *GetVirtualSelectedParentChainFromBlockRequestMessage {
+func NewGetVirtualSelectedParentChainFromBlockRequestMessage(
+	startHash string, includeAcceptedTransactionIDs bool) *GetVirtualSelectedParentChainFromBlockRequestMessage {
+
 	return &GetVirtualSelectedParentChainFromBlockRequestMessage{
-		StartHash: startHash,
+		StartHash:                     startHash,
+		IncludeAcceptedTransactionIDs: includeAcceptedTransactionIDs,
 	}
 }
 
+// AcceptedTransactionIDs is a part of the GetVirtualSelectedParentChainFromBlockResponseMessage and
+// VirtualSelectedParentChainChangedNotificationMessage appmessages
+type AcceptedTransactionIDs struct {
+	AcceptingBlockHash     string
+	AcceptedTransactionIDs []string
+}
+
 // GetVirtualSelectedParentChainFromBlockResponseMessage is an appmessage corresponding to
 // its respective RPC message
 type GetVirtualSelectedParentChainFromBlockResponseMessage struct {
 	baseMessage
 	RemovedChainBlockHashes []string
 	AddedChainBlockHashes   []string
+	AcceptedTransactionIDs  []*AcceptedTransactionIDs
 
 	Error *RPCError
 }
@@ -36,10 +48,11 @@ func (msg *GetVirtualSelectedParentChainFromBlockResponseMessage) Command() Mess
 
 // NewGetVirtualSelectedParentChainFromBlockResponseMessage returns a instance of the message
 func NewGetVirtualSelectedParentChainFromBlockResponseMessage(removedChainBlockHashes,
-	addedChainBlockHashes []string) *GetVirtualSelectedParentChainFromBlockResponseMessage {
+	addedChainBlockHashes []string, acceptedTransactionIDs []*AcceptedTransactionIDs) *GetVirtualSelectedParentChainFromBlockResponseMessage {
 
 	return &GetVirtualSelectedParentChainFromBlockResponseMessage{
 		RemovedChainBlockHashes: removedChainBlockHashes,
 		AddedChainBlockHashes:   addedChainBlockHashes,
+		AcceptedTransactionIDs:  acceptedTransactionIDs,
 	}
 }

app/appmessage/rpc_notify_virtual_selected_parent_chain_changed.go

@@ -4,6 +4,7 @@ package appmessage
 // its respective RPC message
 type NotifyVirtualSelectedParentChainChangedRequestMessage struct {
 	baseMessage
+	IncludeAcceptedTransactionIDs bool
 }
 
 // Command returns the protocol command string for the message
@@ -11,9 +12,13 @@ func (msg *NotifyVirtualSelectedParentChainChangedRequestMessage) Command() Mess
 	return CmdNotifyVirtualSelectedParentChainChangedRequestMessage
 }
 
-// NewNotifyVirtualSelectedParentChainChangedRequestMessage returns a instance of the message
+// NewNotifyVirtualSelectedParentChainChangedRequestMessage returns an instance of the message
-func NewNotifyVirtualSelectedParentChainChangedRequestMessage() *NotifyVirtualSelectedParentChainChangedRequestMessage {
+func NewNotifyVirtualSelectedParentChainChangedRequestMessage(
-	return &NotifyVirtualSelectedParentChainChangedRequestMessage{}
+	includeAcceptedTransactionIDs bool) *NotifyVirtualSelectedParentChainChangedRequestMessage {
+
+	return &NotifyVirtualSelectedParentChainChangedRequestMessage{
+		IncludeAcceptedTransactionIDs: includeAcceptedTransactionIDs,
+	}
 }
 
 // NotifyVirtualSelectedParentChainChangedResponseMessage is an appmessage corresponding to
@@ -39,6 +44,7 @@ type VirtualSelectedParentChainChangedNotificationMessage struct {
 	baseMessage
 	RemovedChainBlockHashes []string
 	AddedChainBlockHashes   []string
+	AcceptedTransactionIDs  []*AcceptedTransactionIDs
 }
 
 // Command returns the protocol command string for the message
@@ -48,10 +54,11 @@ func (msg *VirtualSelectedParentChainChangedNotificationMessage) Command() Messa
 
 // NewVirtualSelectedParentChainChangedNotificationMessage returns a instance of the message
 func NewVirtualSelectedParentChainChangedNotificationMessage(removedChainBlockHashes,
-	addedChainBlocks []string) *VirtualSelectedParentChainChangedNotificationMessage {
+	addedChainBlocks []string, acceptedTransactionIDs []*AcceptedTransactionIDs) *VirtualSelectedParentChainChangedNotificationMessage {
 
 	return &VirtualSelectedParentChainChangedNotificationMessage{
 		RemovedChainBlockHashes: removedChainBlockHashes,
 		AddedChainBlockHashes:   addedChainBlocks,
+		AcceptedTransactionIDs:  acceptedTransactionIDs,
 	}
 }

app/appmessage/rpc_submit_transaction.go

@@ -52,6 +52,7 @@ type RPCTransaction struct {
 	SubnetworkID string
 	Gas          uint64
 	Payload      string
+	Mass         uint64
 	VerboseData  *RPCTransactionVerboseData
 }
 

app/appmessage/rpc_submit_transaction_replacement.go

@@ -0,0 +1,42 @@
+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,
+	}
+}

app/component_manager.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"sync/atomic"
 
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+
 	"github.com/kaspanet/kaspad/domain/miningmanager/mempool"
 
 	"github.com/kaspanet/kaspad/app/protocol"
@@ -67,6 +69,7 @@ func (a *ComponentManager) Stop() {
 	}
 
 	a.protocolManager.Close()
+	close(a.protocolManager.Context().Domain().ConsensusEventsChannel())
 
 	return
 }
@@ -118,7 +121,7 @@ func NewComponentManager(cfg *config.Config, db infrastructuredatabase.Database,
 	if err != nil {
 		return nil, err
 	}
-	rpcManager := setupRPC(cfg, domain, netAdapter, protocolManager, connectionManager, addressManager, utxoIndex, interrupt)
+	rpcManager := setupRPC(cfg, domain, netAdapter, protocolManager, connectionManager, addressManager, utxoIndex, domain.ConsensusEventsChannel(), interrupt)
 
 	return &ComponentManager{
 		cfg:               cfg,
@@ -139,6 +142,7 @@ func setupRPC(
 	connectionManager *connmanager.ConnectionManager,
 	addressManager *addressmanager.AddressManager,
 	utxoIndex *utxoindex.UTXOIndex,
+	consensusEventsChan chan externalapi.ConsensusEvent,
 	shutDownChan chan<- struct{},
 ) *rpc.Manager {
 
@@ -150,11 +154,10 @@ func setupRPC(
 		connectionManager,
 		addressManager,
 		utxoIndex,
+		consensusEventsChan,
 		shutDownChan,
 	)
-	protocolManager.SetOnVirtualChange(rpcManager.NotifyVirtualChange)
 	protocolManager.SetOnNewBlockTemplateHandler(rpcManager.NotifyNewBlockTemplate)
-	protocolManager.SetOnBlockAddedToDAGHandler(rpcManager.NotifyBlockAddedToDAG)
 	protocolManager.SetOnPruningPointUTXOSetOverrideHandler(rpcManager.NotifyPruningPointUTXOSetOverride)
 
 	return rpcManager

app/protocol/flowcontext/blocks.go

@@ -16,60 +16,40 @@ import (
 // OnNewBlock updates the mempool after a new block arrival, and
 // relays newly unorphaned transactions and possibly rebroadcast
 // manually added transactions when not in IBD.
-func (f *FlowContext) OnNewBlock(block *externalapi.DomainBlock,
+func (f *FlowContext) OnNewBlock(block *externalapi.DomainBlock) error {
-	virtualChangeSet *externalapi.VirtualChangeSet) error {
 
 	hash := consensushashing.BlockHash(block)
 	log.Tracef("OnNewBlock start for block %s", hash)
 	defer log.Tracef("OnNewBlock end for block %s", hash)
 
-	unorphaningResults, err := f.UnorphanBlocks(block)
+	unorphanedBlocks, err := f.UnorphanBlocks(block)
 	if err != nil {
 		return err
 	}
 
-	log.Debugf("OnNewBlock: block %s unorphaned %d blocks", hash, len(unorphaningResults))
+	log.Debugf("OnNewBlock: block %s unorphaned %d blocks", hash, len(unorphanedBlocks))
 
 	newBlocks := []*externalapi.DomainBlock{block}
-	newVirtualChangeSets := []*externalapi.VirtualChangeSet{virtualChangeSet}
+	newBlocks = append(newBlocks, unorphanedBlocks...)
-	for _, unorphaningResult := range unorphaningResults {
-		newBlocks = append(newBlocks, unorphaningResult.block)
-		newVirtualChangeSets = append(newVirtualChangeSets, unorphaningResult.virtualChangeSet)
-	}
 
 	allAcceptedTransactions := make([]*externalapi.DomainTransaction, 0)
-	for i, newBlock := range newBlocks {
+	for _, newBlock := range newBlocks {
 		log.Debugf("OnNewBlock: passing block %s transactions to mining manager", hash)
 		acceptedTransactions, err := f.Domain().MiningManager().HandleNewBlockTransactions(newBlock.Transactions)
 		if err != nil {
 			return err
 		}
 		allAcceptedTransactions = append(allAcceptedTransactions, acceptedTransactions...)
-
-		if f.onBlockAddedToDAGHandler != nil {
-			log.Debugf("OnNewBlock: calling f.onBlockAddedToDAGHandler for block %s", hash)
-			virtualChangeSet = newVirtualChangeSets[i]
-			err := f.onBlockAddedToDAGHandler(newBlock, virtualChangeSet)
-			if err != nil {
-				return err
-			}
-		}
 	}
 
 	return f.broadcastTransactionsAfterBlockAdded(newBlocks, allAcceptedTransactions)
 }
 
-// OnVirtualChange calls the handler function whenever the virtual block changes.
-func (f *FlowContext) OnVirtualChange(virtualChangeSet *externalapi.VirtualChangeSet) error {
-	if f.onVirtualChangeHandler != nil && virtualChangeSet != nil {
-		return f.onVirtualChangeHandler(virtualChangeSet)
-	}
-
-	return nil
-}
-
 // OnNewBlockTemplate calls the handler function whenever a new block template is available for miners.
 func (f *FlowContext) OnNewBlockTemplate() error {
+	// Clear current template cache. Note we call this even if the handler is nil, in order to keep the
+	// state consistent without dependency on external event registration
+	f.Domain().MiningManager().ClearBlockTemplate()
 	if f.onNewBlockTemplateHandler != nil {
 		return f.onNewBlockTemplateHandler()
 	}
@@ -127,7 +107,7 @@ func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
 		return protocolerrors.Errorf(false, "cannot add header only block")
 	}
 
-	virtualChangeSet, err := f.Domain().Consensus().ValidateAndInsertBlock(block, true)
+	err := f.Domain().Consensus().ValidateAndInsertBlock(block, true)
 	if err != nil {
 		if errors.As(err, &ruleerrors.RuleError{}) {
 			log.Warnf("Validation failed for block %s: %s", consensushashing.BlockHash(block), err)
@@ -138,7 +118,7 @@ func (f *FlowContext) AddBlock(block *externalapi.DomainBlock) error {
 	if err != nil {
 		return err
 	}
-	err = f.OnNewBlock(block, virtualChangeSet)
+	err = f.OnNewBlock(block)
 	if err != nil {
 		return err
 	}

app/protocol/flowcontext/flow_context.go

@@ -18,13 +18,6 @@ import (
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/id"
 )
 
-// OnBlockAddedToDAGHandler is a handler function that's triggered
-// when a block is added to the DAG
-type OnBlockAddedToDAGHandler func(block *externalapi.DomainBlock, virtualChangeSet *externalapi.VirtualChangeSet) error
-
-// OnVirtualChangeHandler is a handler function that's triggered when the virtual changes
-type OnVirtualChangeHandler func(virtualChangeSet *externalapi.VirtualChangeSet) error
-
 // OnNewBlockTemplateHandler is a handler function that's triggered when a new block template is available
 type OnNewBlockTemplateHandler func() error
 
@@ -47,15 +40,12 @@ type FlowContext struct {
 
 	timeStarted int64
 
-	onVirtualChangeHandler               OnVirtualChangeHandler
-	onBlockAddedToDAGHandler             OnBlockAddedToDAGHandler
 	onNewBlockTemplateHandler            OnNewBlockTemplateHandler
 	onPruningPointUTXOSetOverrideHandler OnPruningPointUTXOSetOverrideHandler
 	onTransactionAddedToMempoolHandler   OnTransactionAddedToMempoolHandler
 
-	expectedDAAWindowDurationInMilliseconds int64
+	lastRebroadcastTime         time.Time
-	lastRebroadcastTime                     time.Time
+	sharedRequestedTransactions *SharedRequestedTransactions
-	sharedRequestedTransactions             *SharedRequestedTransactions
 
 	sharedRequestedBlocks *SharedRequestedBlocks
 
@@ -93,8 +83,6 @@ func New(cfg *config.Config, domain domain.Domain, addressManager *addressmanage
 		transactionIDsToPropagate:        []*externalapi.DomainTransactionID{},
 		lastTransactionIDPropagationTime: time.Now(),
 		shutdownChan:                     make(chan struct{}),
-		expectedDAAWindowDurationInMilliseconds: cfg.NetParams().TargetTimePerBlock.Milliseconds() *
-			int64(cfg.NetParams().DifficultyAdjustmentWindowSize),
 	}
 }
 
@@ -109,14 +97,9 @@ func (f *FlowContext) ShutdownChan() <-chan struct{} {
 	return f.shutdownChan
 }
 
-// SetOnVirtualChangeHandler sets the onVirtualChangeHandler handler
+// IsNearlySynced returns whether current consensus is considered synced or close to being synced.
-func (f *FlowContext) SetOnVirtualChangeHandler(onVirtualChangeHandler OnVirtualChangeHandler) {
+func (f *FlowContext) IsNearlySynced() (bool, error) {
-	f.onVirtualChangeHandler = onVirtualChangeHandler
+	return f.Domain().Consensus().IsNearlySynced()
-}
-
-// SetOnBlockAddedToDAGHandler sets the onBlockAddedToDAG handler
-func (f *FlowContext) SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler OnBlockAddedToDAGHandler) {
-	f.onBlockAddedToDAGHandler = onBlockAddedToDAGHandler
 }
 
 // SetOnNewBlockTemplateHandler sets the onNewBlockTemplateHandler handler

app/protocol/flowcontext/network.go

@@ -72,3 +72,10 @@ func (f *FlowContext) Peers() []*peerpkg.Peer {
 	}
 	return peers
 }
+
+// HasPeers returns whether there are currently active peers
+func (f *FlowContext) HasPeers() bool {
+	f.peersMutex.RLock()
+	defer f.peersMutex.RUnlock()
+	return len(f.peers) > 0
+}

app/protocol/flowcontext/orphans.go

@@ -15,12 +15,6 @@ import (
 // on: 2^orphanResolutionRange * PHANTOM K.
 const maxOrphans = 600
 
-// UnorphaningResult is the result of unorphaning a block
-type UnorphaningResult struct {
-	block            *externalapi.DomainBlock
-	virtualChangeSet *externalapi.VirtualChangeSet
-}
-
 // AddOrphan adds the block to the orphan set
 func (f *FlowContext) AddOrphan(orphanBlock *externalapi.DomainBlock) {
 	f.orphansMutex.Lock()
@@ -57,7 +51,7 @@ func (f *FlowContext) IsOrphan(blockHash *externalapi.DomainHash) bool {
 }
 
 // UnorphanBlocks removes the block from the orphan set, and remove all of the blocks that are not orphans anymore.
-func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*UnorphaningResult, error) {
+func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*externalapi.DomainBlock, error) {
 	f.orphansMutex.Lock()
 	defer f.orphansMutex.Unlock()
 
@@ -66,7 +60,7 @@ func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*Uno
 	rootBlockHash := consensushashing.BlockHash(rootBlock)
 	processQueue := f.addChildOrphansToProcessQueue(rootBlockHash, []externalapi.DomainHash{})
 
-	var unorphaningResults []*UnorphaningResult
+	var unorphanedBlocks []*externalapi.DomainBlock
 	for len(processQueue) > 0 {
 		var orphanHash externalapi.DomainHash
 		orphanHash, processQueue = processQueue[0], processQueue[1:]
@@ -90,21 +84,18 @@ func (f *FlowContext) UnorphanBlocks(rootBlock *externalapi.DomainBlock) ([]*Uno
 			}
 		}
 		if canBeUnorphaned {
-			virtualChangeSet, unorphaningSucceeded, err := f.unorphanBlock(orphanHash)
+			unorphaningSucceeded, err := f.unorphanBlock(orphanHash)
 			if err != nil {
 				return nil, err
 			}
 			if unorphaningSucceeded {
-				unorphaningResults = append(unorphaningResults, &UnorphaningResult{
+				unorphanedBlocks = append(unorphanedBlocks, orphanBlock)
-					block:            orphanBlock,
-					virtualChangeSet: virtualChangeSet,
-				})
 				processQueue = f.addChildOrphansToProcessQueue(&orphanHash, processQueue)
 			}
 		}
 	}
 
-	return unorphaningResults, nil
+	return unorphanedBlocks, nil
 }
 
 // addChildOrphansToProcessQueue finds all child orphans of `blockHash`
@@ -143,24 +134,24 @@ func (f *FlowContext) findChildOrphansOfBlock(blockHash *externalapi.DomainHash)
 	return childOrphans
 }
 
-func (f *FlowContext) unorphanBlock(orphanHash externalapi.DomainHash) (*externalapi.VirtualChangeSet, bool, error) {
+func (f *FlowContext) unorphanBlock(orphanHash externalapi.DomainHash) (bool, error) {
 	orphanBlock, ok := f.orphans[orphanHash]
 	if !ok {
-		return nil, false, errors.Errorf("attempted to unorphan a non-orphan block %s", orphanHash)
+		return false, errors.Errorf("attempted to unorphan a non-orphan block %s", orphanHash)
 	}
 	delete(f.orphans, orphanHash)
 
-	virtualChangeSet, err := f.domain.Consensus().ValidateAndInsertBlock(orphanBlock, true)
+	err := f.domain.Consensus().ValidateAndInsertBlock(orphanBlock, true)
 	if err != nil {
 		if errors.As(err, &ruleerrors.RuleError{}) {
 			log.Warnf("Validation failed for orphan block %s: %s", orphanHash, err)
-			return nil, false, nil
+			return false, nil
 		}
-		return nil, false, err
+		return false, err
 	}
 
 	log.Infof("Unorphaned block %s", orphanHash)
-	return virtualChangeSet, true, nil
+	return true, nil
 }
 
 // GetOrphanRoots returns the roots of the missing ancestors DAG of the given orphan

app/protocol/flowcontext/should_mine.go

@@ -1,40 +0,0 @@
-package flowcontext
-
-import "github.com/kaspanet/kaspad/util/mstime"
-
-// IsNearlySynced returns whether this node is considered synced or close to being synced. This info
-// is used to determine if it's ok to use a block template from this node for mining purposes.
-func (f *FlowContext) IsNearlySynced() (bool, error) {
-	peers := f.Peers()
-	if len(peers) == 0 {
-		log.Debugf("The node is not connected to peers, so IsNearlySynced returns false")
-		return false, nil
-	}
-
-	virtualSelectedParent, err := f.domain.Consensus().GetVirtualSelectedParent()
-	if err != nil {
-		return false, err
-	}
-
-	if virtualSelectedParent.Equal(f.Config().NetParams().GenesisHash) {
-		return false, nil
-	}
-
-	virtualSelectedParentHeader, err := f.domain.Consensus().GetBlockHeader(virtualSelectedParent)
-	if err != nil {
-		return false, err
-	}
-
-	now := mstime.Now().UnixMilliseconds()
-	// As a heuristic, we allow the node to mine if he is likely to be within the current DAA window of fully synced nodes.
-	// Such blocks contribute to security by maintaining the current difficulty despite possibly being slightly out of sync.
-	if now-virtualSelectedParentHeader.TimeInMilliseconds() < f.expectedDAAWindowDurationInMilliseconds {
-		log.Debugf("The selected tip timestamp is recent (%d), so IsNearlySynced returns true",
-			virtualSelectedParentHeader.TimeInMilliseconds())
-		return true, nil
-	}
-
-	log.Debugf("The selected tip timestamp is old (%d), so IsNearlySynced returns false",
-		virtualSelectedParentHeader.TimeInMilliseconds())
-	return false, nil
-}

app/protocol/flows/v5/blockrelay/block_locator.go

@@ -21,7 +21,7 @@ func (flow *handleRelayInvsFlow) receiveBlockLocator() (blockLocatorHashes []*ex
 
 		switch message := message.(type) {
 		case *appmessage.MsgInvRelayBlock:
-			flow.invsQueue = append(flow.invsQueue, message)
+			flow.invsQueue = append(flow.invsQueue, invRelayBlock{Hash: message.Hash, IsOrphanRoot: false})
 		case *appmessage.MsgBlockLocator:
 			return message.BlockLocatorHashes, nil
 		default:

app/protocol/flows/v5/blockrelay/handle_ibd_block_locator.go

@@ -5,7 +5,6 @@ import (
 	"github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
@@ -34,7 +33,7 @@ func HandleIBDBlockLocator(context HandleIBDBlockLocatorContext, incomingRoute *
 		if err != nil {
 			return err
 		}
-		if !blockInfo.Exists {
+		if !blockInfo.HasHeader() {
 			return protocolerrors.Errorf(true, "received IBDBlockLocator "+
 				"with an unknown targetHash %s", targetHash)
 		}
@@ -47,7 +46,7 @@ func HandleIBDBlockLocator(context HandleIBDBlockLocatorContext, incomingRoute *
 			}
 
 			// The IBD block locator is checking only existing blocks with bodies.
-			if !blockInfo.Exists || blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
+			if !blockInfo.HasBody() {
 				continue
 			}
 

app/protocol/flows/v5/blockrelay/handle_ibd_block_requests.go

@@ -4,7 +4,6 @@ import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 	"github.com/pkg/errors"
 )
@@ -28,18 +27,15 @@ 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.
-			blockInfo, err := context.Domain().Consensus().GetBlockInfo(hash)
+			block, found, err := context.Domain().Consensus().GetBlock(hash)
-			if err != nil {
-				return err
-			}
-			if !blockInfo.Exists || blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
-				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)

app/protocol/flows/v5/blockrelay/handle_pruning_point_and_its_anticone_requests.go

@@ -119,11 +119,15 @@ func HandlePruningPointAndItsAnticoneRequests(context PruningPointAndItsAnticone
 			}
 
 			for i, blockHash := range pointAndItsAnticone {
-				block, err := context.Domain().Consensus().GetBlock(blockHash)
+				block, found, 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

app/protocol/flows/v5/blockrelay/handle_relay_block_requests.go

@@ -5,7 +5,6 @@ import (
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/domain"
-	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 	"github.com/pkg/errors"
 )
@@ -29,18 +28,15 @@ 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.
-			blockInfo, err := context.Domain().Consensus().GetBlockInfo(hash)
+			block, found, err := context.Domain().Consensus().GetBlock(hash)
-			if err != nil {
-				return err
-			}
-			if !blockInfo.Exists || blockInfo.BlockStatus == externalapi.StatusHeaderOnly {
-				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))

app/protocol/flows/v5/blockrelay/handle_relay_invs.go

@@ -7,6 +7,7 @@ import (
 	peerpkg "github.com/kaspanet/kaspad/app/protocol/peer"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/domain"
+	"github.com/kaspanet/kaspad/domain/consensus/model"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/ruleerrors"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
@@ -25,8 +26,7 @@ var orphanResolutionRange uint32 = 5
 type RelayInvsContext interface {
 	Domain() domain.Domain
 	Config() *config.Config
-	OnNewBlock(block *externalapi.DomainBlock, virtualChangeSet *externalapi.VirtualChangeSet) error
+	OnNewBlock(block *externalapi.DomainBlock) error
-	OnVirtualChange(virtualChangeSet *externalapi.VirtualChangeSet) error
 	OnNewBlockTemplate() error
 	OnPruningPointUTXOSetOverride() error
 	SharedRequestedBlocks() *flowcontext.SharedRequestedBlocks
@@ -39,11 +39,16 @@ type RelayInvsContext interface {
 	IsNearlySynced() (bool, error)
 }
 
+type invRelayBlock struct {
+	Hash         *externalapi.DomainHash
+	IsOrphanRoot bool
+}
+
 type handleRelayInvsFlow struct {
 	RelayInvsContext
 	incomingRoute, outgoingRoute *router.Route
 	peer                         *peerpkg.Peer
-	invsQueue                    []*appmessage.MsgInvRelayBlock
+	invsQueue                    []invRelayBlock
 }
 
 // HandleRelayInvs listens to appmessage.MsgInvRelayBlock messages, requests their corresponding blocks if they
@@ -56,7 +61,7 @@ func HandleRelayInvs(context RelayInvsContext, incomingRoute *router.Route, outg
 		incomingRoute:    incomingRoute,
 		outgoingRoute:    outgoingRoute,
 		peer:             peer,
-		invsQueue:        make([]*appmessage.MsgInvRelayBlock, 0),
+		invsQueue:        make([]invRelayBlock, 0),
 	}
 	err := flow.start()
 	// Currently, HandleRelayInvs flow is the only place where IBD is triggered, so the channel can be closed now
@@ -139,12 +144,36 @@ func (flow *handleRelayInvsFlow) start() error {
 			continue
 		}
 
+		// Note we do not apply the heuristic below if inv was queued as an orphan root, since
+		// that means the process started by a proper and relevant relay block
+		if !inv.IsOrphanRoot {
+			// Check bounded merge depth to avoid requesting irrelevant data which cannot be merged under virtual
+			virtualMergeDepthRoot, err := flow.Domain().Consensus().VirtualMergeDepthRoot()
+			if err != nil {
+				return err
+			}
+			if !virtualMergeDepthRoot.Equal(model.VirtualGenesisBlockHash) {
+				mergeDepthRootHeader, err := flow.Domain().Consensus().GetBlockHeader(virtualMergeDepthRoot)
+				if err != nil {
+					return err
+				}
+				// Since `BlueWork` respects topology, this condition means that the relay
+				// block is not in the future of virtual's merge depth root, and thus cannot be merged unless
+				// other valid blocks Kosherize it, in which case it will be obtained once the merger is relayed
+				if block.Header.BlueWork().Cmp(mergeDepthRootHeader.BlueWork()) <= 0 {
+					log.Debugf("Block %s has lower blue work than virtual's merge root %s (%d <= %d), hence we are skipping it",
+						inv.Hash, virtualMergeDepthRoot, block.Header.BlueWork(), mergeDepthRootHeader.BlueWork())
+					continue
+				}
+			}
+		}
+
 		log.Debugf("Processing block %s", inv.Hash)
 		oldVirtualInfo, err := flow.Domain().Consensus().GetVirtualInfo()
 		if err != nil {
 			return err
 		}
-		missingParents, virtualChangeSet, err := flow.processBlock(block)
+		missingParents, err := flow.processBlock(block)
 		if err != nil {
 			if errors.Is(err, ruleerrors.ErrPrunedBlock) {
 				log.Infof("Ignoring pruned block %s", inv.Hash)
@@ -182,10 +211,14 @@ func (flow *handleRelayInvsFlow) start() error {
 				continue
 			}
 			virtualHasNewParents = true
-			block, err := flow.Domain().Consensus().GetBlock(parent)
+			block, found, 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)
@@ -203,7 +236,7 @@ func (flow *handleRelayInvsFlow) start() error {
 		}
 
 		log.Infof("Accepted block %s via relay", inv.Hash)
-		err = flow.OnNewBlock(block, virtualChangeSet)
+		err = flow.OnNewBlock(block)
 		if err != nil {
 			return err
 		}
@@ -219,24 +252,24 @@ func (flow *handleRelayInvsFlow) banIfBlockIsHeaderOnly(block *externalapi.Domai
 	return nil
 }
 
-func (flow *handleRelayInvsFlow) readInv() (*appmessage.MsgInvRelayBlock, error) {
+func (flow *handleRelayInvsFlow) readInv() (invRelayBlock, error) {
 	if len(flow.invsQueue) > 0 {
-		var inv *appmessage.MsgInvRelayBlock
+		var inv invRelayBlock
 		inv, flow.invsQueue = flow.invsQueue[0], flow.invsQueue[1:]
 		return inv, nil
 	}
 
 	msg, err := flow.incomingRoute.Dequeue()
 	if err != nil {
-		return nil, err
+		return invRelayBlock{}, err
 	}
 
-	inv, ok := msg.(*appmessage.MsgInvRelayBlock)
+	msgInv, ok := msg.(*appmessage.MsgInvRelayBlock)
 	if !ok {
-		return nil, protocolerrors.Errorf(true, "unexpected %s message in the block relay handleRelayInvsFlow while "+
+		return invRelayBlock{}, protocolerrors.Errorf(true, "unexpected %s message in the block relay handleRelayInvsFlow while "+
 			"expecting an inv message", msg.Command())
 	}
-	return inv, nil
+	return invRelayBlock{Hash: msgInv.Hash, IsOrphanRoot: false}, nil
 }
 
 func (flow *handleRelayInvsFlow) requestBlock(requestHash *externalapi.DomainHash) (*externalapi.DomainBlock, bool, error) {
@@ -281,7 +314,7 @@ func (flow *handleRelayInvsFlow) readMsgBlock() (msgBlock *appmessage.MsgBlock,
 
 		switch message := message.(type) {
 		case *appmessage.MsgInvRelayBlock:
-			flow.invsQueue = append(flow.invsQueue, message)
+			flow.invsQueue = append(flow.invsQueue, invRelayBlock{Hash: message.Hash, IsOrphanRoot: false})
 		case *appmessage.MsgBlock:
 			return message, nil
 		default:
@@ -290,25 +323,25 @@ func (flow *handleRelayInvsFlow) readMsgBlock() (msgBlock *appmessage.MsgBlock,
 	}
 }
 
-func (flow *handleRelayInvsFlow) processBlock(block *externalapi.DomainBlock) ([]*externalapi.DomainHash, *externalapi.VirtualChangeSet, error) {
+func (flow *handleRelayInvsFlow) processBlock(block *externalapi.DomainBlock) ([]*externalapi.DomainHash, error) {
 	blockHash := consensushashing.BlockHash(block)
-	virtualChangeSet, err := flow.Domain().Consensus().ValidateAndInsertBlock(block, true)
+	err := flow.Domain().Consensus().ValidateAndInsertBlock(block, true)
 	if err != nil {
 		if !errors.As(err, &ruleerrors.RuleError{}) {
-			return nil, nil, errors.Wrapf(err, "failed to process block %s", blockHash)
+			return nil, errors.Wrapf(err, "failed to process block %s", blockHash)
 		}
 
 		missingParentsError := &ruleerrors.ErrMissingParents{}
 		if errors.As(err, missingParentsError) {
-			return missingParentsError.MissingParentHashes, nil, nil
+			return missingParentsError.MissingParentHashes, nil
 		}
 		// A duplicate block should not appear to the user as a warning and is already reported in the calling function
 		if !errors.Is(err, ruleerrors.ErrDuplicateBlock) {
 			log.Warnf("Rejected block %s from %s: %s", blockHash, flow.peer, err)
 		}
-		return nil, nil, protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
+		return nil, protocolerrors.Wrapf(true, err, "got invalid block %s from relay", blockHash)
 	}
-	return nil, virtualChangeSet, nil
+	return nil, nil
 }
 
 func (flow *handleRelayInvsFlow) relayBlock(block *externalapi.DomainBlock) error {
@@ -422,10 +455,10 @@ func (flow *handleRelayInvsFlow) AddOrphanRootsToQueue(orphan *externalapi.Domai
 	}
 	log.Infof("Block %s has %d missing ancestors. Adding them to the invs queue...", orphan, len(orphanRoots))
 
-	invMessages := make([]*appmessage.MsgInvRelayBlock, len(orphanRoots))
+	invMessages := make([]invRelayBlock, len(orphanRoots))
 	for i, root := range orphanRoots {
 		log.Debugf("Adding block %s missing ancestor %s to the invs queue", orphan, root)
-		invMessages[i] = appmessage.NewMsgInvBlock(root)
+		invMessages[i] = invRelayBlock{Hash: root, IsOrphanRoot: true}
 	}
 
 	flow.invsQueue = append(invMessages, flow.invsQueue...)

app/protocol/flows/v5/blockrelay/handle_request_anticone.go

@@ -47,9 +47,9 @@ func (flow *handleRequestAnticoneFlow) start() error {
 
 		// GetAnticone is expected to be called by the syncee for getting the anticone of the header selected tip
 		// intersected by past of relayed block, and is thus expected to be bounded by mergeset limit since
-		// we relay blocks only if they enter virtual's mergeset. We add 2 for a small margin error.
+		// we relay blocks only if they enter virtual's mergeset. We add a 2 factor for possible sync gaps.
 		blockHashes, err := flow.Domain().Consensus().GetAnticone(blockHash, contextHash,
-			flow.Config().ActiveNetParams.MergeSetSizeLimit+2)
+			flow.Config().ActiveNetParams.MergeSetSizeLimit*2)
 		if err != nil {
 			return protocolerrors.Wrap(true, err, "Failed querying anticone")
 		}

app/protocol/flows/v5/blockrelay/handle_request_headers.go

@@ -46,7 +46,25 @@ func (flow *handleRequestHeadersFlow) start() error {
 		}
 		log.Debugf("Received requestHeaders with lowHash: %s, highHash: %s", lowHash, highHash)
 
-		isLowSelectedAncestorOfHigh, err := flow.Domain().Consensus().IsInSelectedParentChainOf(lowHash, highHash)
+		consensus := flow.Domain().Consensus()
+
+		lowHashInfo, err := consensus.GetBlockInfo(lowHash)
+		if err != nil {
+			return err
+		}
+		if !lowHashInfo.HasHeader() {
+			return protocolerrors.Errorf(true, "Block %s does not exist", lowHash)
+		}
+
+		highHashInfo, err := consensus.GetBlockInfo(highHash)
+		if err != nil {
+			return err
+		}
+		if !highHashInfo.HasHeader() {
+			return protocolerrors.Errorf(true, "Block %s does not exist", highHash)
+		}
+
+		isLowSelectedAncestorOfHigh, err := consensus.IsInSelectedParentChainOf(lowHash, highHash)
 		if err != nil {
 			return err
 		}
@@ -62,7 +80,7 @@ func (flow *handleRequestHeadersFlow) start() error {
 			// in order to avoid locking the consensus for too long
 			// maxBlocks MUST be >= MergeSetSizeLimit + 1
 			const maxBlocks = 1 << 10
-			blockHashes, _, err := flow.Domain().Consensus().GetHashesBetween(lowHash, highHash, maxBlocks)
+			blockHashes, _, err := consensus.GetHashesBetween(lowHash, highHash, maxBlocks)
 			if err != nil {
 				return err
 			}
@@ -70,7 +88,7 @@ func (flow *handleRequestHeadersFlow) start() error {
 
 			blockHeaders := make([]*appmessage.MsgBlockHeader, len(blockHashes))
 			for i, blockHash := range blockHashes {
-				blockHeader, err := flow.Domain().Consensus().GetBlockHeader(blockHash)
+				blockHeader, err := consensus.GetBlockHeader(blockHash)
 				if err != nil {
 					return err
 				}

app/protocol/flows/v5/blockrelay/ibd.go

@@ -1,6 +1,7 @@
 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"
@@ -20,8 +21,7 @@ import (
 type IBDContext interface {
 	Domain() domain.Domain
 	Config() *config.Config
-	OnNewBlock(block *externalapi.DomainBlock, virtualChangeSet *externalapi.VirtualChangeSet) error
+	OnNewBlock(block *externalapi.DomainBlock) error
-	OnVirtualChange(virtualChangeSet *externalapi.VirtualChangeSet) error
 	OnNewBlockTemplate() error
 	OnPruningPointUTXOSetOverride() error
 	IsIBDRunning() bool
@@ -71,16 +71,17 @@ func (flow *handleIBDFlow) runIBDIfNotRunning(block *externalapi.DomainBlock) er
 	}
 
 	isFinishedSuccessfully := false
+	var err error
 	defer func() {
 		flow.UnsetIBDRunning()
-		flow.logIBDFinished(isFinishedSuccessfully)
+		flow.logIBDFinished(isFinishedSuccessfully, err)
 	}()
 
 	relayBlockHash := consensushashing.BlockHash(block)
 
-	log.Debugf("IBD started with peer %s and relayBlockHash %s", flow.peer, relayBlockHash)
+	log.Infof("IBD started with peer %s and relayBlockHash %s", flow.peer, relayBlockHash)
-	log.Debugf("Syncing blocks up to %s", relayBlockHash)
+	log.Infof("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)
+	log.Infof("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 {
@@ -99,7 +100,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
 		}
@@ -174,6 +175,11 @@ 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 {
@@ -182,8 +188,25 @@ func (flow *handleIBDFlow) negotiateMissingSyncerChainSegment() (*externalapi.Do
 				return nil, nil, err
 			}
 			if info.Exists {
-				currentHighestKnownSyncerChainHash = syncerChainHash
+				if info.BlockStatus == externalapi.StatusInvalid {
-				break
+					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
 		}
@@ -262,7 +285,7 @@ func (flow *handleIBDFlow) negotiateMissingSyncerChainSegment() (*externalapi.Do
 		}
 	}
 
-	log.Debugf("Found highest known syncer chain block %s from peer %s",
+	log.Infof("Found highest known syncer chain block %s from peer %s",
 		highestKnownSyncerChainHash, flow.peer)
 
 	return syncerHeaderSelectedTipHash, highestKnownSyncerChainHash, nil
@@ -277,10 +300,14 @@ func (flow *handleIBDFlow) isGenesisVirtualSelectedParent() (bool, error) {
 	return virtualSelectedParent.Equal(flow.Config().NetParams().GenesisHash), nil
 }
 
-func (flow *handleIBDFlow) logIBDFinished(isFinishedSuccessfully bool) {
+func (flow *handleIBDFlow) logIBDFinished(isFinishedSuccessfully bool, err error) {
 	successString := "successfully"
 	if !isFinishedSuccessfully {
-		successString = "(interrupted)"
+		if err != nil {
+			successString = fmt.Sprintf("(interrupted: %s)", err)
+		} else {
+			successString = fmt.Sprintf("(interrupted)")
+		}
 	}
 	log.Infof("IBD with peer %s finished %s", flow.peer, successString)
 }
@@ -489,7 +516,7 @@ func (flow *handleIBDFlow) processHeader(consensus externalapi.Consensus, msgBlo
 		log.Debugf("Block header %s is already in the DAG. Skipping...", blockHash)
 		return nil
 	}
-	_, err = consensus.ValidateAndInsertBlock(block, false)
+	err = consensus.ValidateAndInsertBlock(block, false)
 	if err != nil {
 		if !errors.As(err, &ruleerrors.RuleError{}) {
 			return errors.Wrapf(err, "failed to process header %s during IBD", blockHash)
@@ -567,7 +594,7 @@ func (flow *handleIBDFlow) receiveAndInsertPruningPointUTXOSet(
 
 			receivedChunkCount++
 			if receivedChunkCount%ibdBatchSize == 0 {
-				log.Debugf("Received %d UTXO set chunks so far, totaling in %d UTXOs",
+				log.Infof("Received %d UTXO set chunks so far, totaling in %d UTXOs",
 					receivedChunkCount, receivedUTXOCount)
 
 				requestNextPruningPointUTXOSetChunkMessage := appmessage.NewMsgRequestNextPruningPointUTXOSetChunk()
@@ -619,6 +646,12 @@ 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) {
@@ -655,7 +688,7 @@ func (flow *handleIBDFlow) syncMissingBlockBodies(highHash *externalapi.DomainHa
 				return err
 			}
 
-			virtualChangeSet, err := flow.Domain().Consensus().ValidateAndInsertBlock(block, false)
+			err = flow.Domain().Consensus().ValidateAndInsertBlock(block, updateVirtual)
 			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)
@@ -663,7 +696,7 @@ func (flow *handleIBDFlow) syncMissingBlockBodies(highHash *externalapi.DomainHa
 				}
 				return protocolerrors.ConvertToBanningProtocolErrorIfRuleError(err, "invalid block %s", blockHash)
 			}
-			err = flow.OnNewBlock(block, virtualChangeSet)
+			err = flow.OnNewBlock(block)
 			if err != nil {
 				return err
 			}
@@ -674,7 +707,15 @@ func (flow *handleIBDFlow) syncMissingBlockBodies(highHash *externalapi.DomainHa
 		progressReporter.reportProgress(len(hashesToRequest), highestProcessedDAAScore)
 	}
 
-	return flow.resolveVirtual(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()
 }
 
 func (flow *handleIBDFlow) banIfBlockIsHeaderOnly(block *externalapi.DomainBlock) error {
@@ -687,42 +728,24 @@ func (flow *handleIBDFlow) banIfBlockIsHeaderOnly(block *externalapi.DomainBlock
 }
 
 func (flow *handleIBDFlow) resolveVirtual(estimatedVirtualDAAScoreTarget uint64) error {
-	virtualDAAScoreStart, err := flow.Domain().Consensus().GetVirtualDAAScore()
+	err := flow.Domain().Consensus().ResolveVirtual(func(virtualDAAScoreStart uint64, virtualDAAScore uint64) {
+		var percents int
+		if estimatedVirtualDAAScoreTarget-virtualDAAScoreStart <= 0 {
+			percents = 100
+		} else {
+			percents = int(float64(virtualDAAScore-virtualDAAScoreStart) / float64(estimatedVirtualDAAScoreTarget-virtualDAAScoreStart) * 100)
+		}
+		if percents < 0 {
+			percents = 0
+		} else if percents > 100 {
+			percents = 100
+		}
+		log.Infof("Resolving virtual. Estimated progress: %d%%", percents)
+	})
 	if err != nil {
 		return err
 	}
 
-	for i := 0; ; i++ {
+	log.Infof("Resolved virtual")
-		if i%10 == 0 {
+	return nil
-			virtualDAAScore, err := flow.Domain().Consensus().GetVirtualDAAScore()
-			if err != nil {
-				return err
-			}
-			var percents int
-			if estimatedVirtualDAAScoreTarget-virtualDAAScoreStart <= 0 {
-				percents = 100
-			} else {
-				percents = int(float64(virtualDAAScore-virtualDAAScoreStart) / float64(estimatedVirtualDAAScoreTarget-virtualDAAScoreStart) * 100)
-			}
-			log.Infof("Resolving virtual. Estimated progress: %d%%", percents)
-		}
-		virtualChangeSet, isCompletelyResolved, err := flow.Domain().Consensus().ResolveVirtual()
-		if err != nil {
-			return err
-		}
-
-		err = flow.OnVirtualChange(virtualChangeSet)
-		if err != nil {
-			return err
-		}
-
-		if isCompletelyResolved {
-			log.Infof("Resolved virtual")
-			err = flow.OnNewBlockTemplate()
-			if err != nil {
-				return err
-			}
-			return nil
-		}
-	}
 }

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.", flow.peer)
+		log.Infof("IBD with pruning proof from %s was unsuccessful. Deleting the staging consensus. (%s)", flow.peer, err)
 		deleteStagingConsensusErr := flow.Domain().DeleteStagingConsensus()
 		if deleteStagingConsensusErr != nil {
 			return deleteStagingConsensusErr
@@ -55,7 +55,12 @@ func (flow *handleIBDFlow) shouldSyncAndShouldDownloadHeadersProof(
 
 	var highestSharedBlockFound, isPruningPointInSharedBlockChain bool
 	if highestKnownSyncerChainHash != nil {
-		highestSharedBlockFound = true
+		blockInfo, err := flow.Domain().Consensus().GetBlockInfo(highestKnownSyncerChainHash)
+		if err != nil {
+			return false, false, err
+		}
+
+		highestSharedBlockFound = blockInfo.HasBody()
 		pruningPoint, err := flow.Domain().Consensus().PruningPoint()
 		if err != nil {
 			return false, false, err
@@ -80,28 +85,33 @@ func (flow *handleIBDFlow) shouldSyncAndShouldDownloadHeadersProof(
 			return true, true, nil
 		}
 
-		return false, false, 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) {
-	headersSelectedTip, err := flow.Domain().Consensus().GetHeadersSelectedTip()
+	virtualSelectedParent, err := flow.Domain().Consensus().GetVirtualSelectedParent()
 	if err != nil {
 		return false, err
 	}
 
-	headersSelectedTipInfo, err := flow.Domain().Consensus().GetBlockInfo(headersSelectedTip)
+	virtualSelectedTipInfo, err := flow.Domain().Consensus().GetBlockInfo(virtualSelectedParent)
 	if err != nil {
 		return false, err
 	}
 
-	if relayBlock.Header.BlueScore() < headersSelectedTipInfo.BlueScore+flow.Config().NetParams().PruningDepth() {
+	if relayBlock.Header.BlueScore() < virtualSelectedTipInfo.BlueScore+flow.Config().NetParams().PruningDepth() {
 		return false, nil
 	}
 
-	return relayBlock.Header.BlueWork().Cmp(headersSelectedTipInfo.BlueWork) > 0, nil
+	return relayBlock.Header.BlueWork().Cmp(virtualSelectedTipInfo.BlueWork) > 0, nil
 }
 
 func (flow *handleIBDFlow) syncAndValidatePruningPointProof() (*externalapi.DomainHash, error) {
@@ -280,8 +290,14 @@ func (flow *handleIBDFlow) processBlockWithTrustedData(
 		blockWithTrustedData.GHOSTDAGData = append(blockWithTrustedData.GHOSTDAGData, appmessage.GHOSTDAGHashPairToDomainGHOSTDAGHashPair(data.GHOSTDAGData[index]))
 	}
 
-	_, err := consensus.ValidateAndInsertBlockWithTrustedData(blockWithTrustedData, false)
+	err := consensus.ValidateAndInsertBlockWithTrustedData(blockWithTrustedData, false)
-	return err
+	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) {

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); ok {
+	if _, _, ok := flow.Domain().MiningManager().GetTransaction(txID, true, true); ok {
 		return true
 	}
 

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)
+			tx, _, ok := flow.Domain().MiningManager().GetTransaction(transactionID, true, false)
 
 			if !ok {
 				msgTransactionNotFound := appmessage.NewMsgTransactionNotFound(transactionID)
@@ -40,7 +40,6 @@ func (flow *handleRequestedTransactionsFlow) start() error {
 				}
 				continue
 			}
-
 			err := flow.outgoingRoute.Enqueue(appmessage.DomainTransactionToMsgTx(tx))
 			if err != nil {
 				return err

app/protocol/manager.go

@@ -2,10 +2,11 @@ package protocol
 
 import (
 	"fmt"
-	"github.com/kaspanet/kaspad/app/protocol/common"
 	"sync"
 	"sync/atomic"
 
+	"github.com/kaspanet/kaspad/app/protocol/common"
+
 	"github.com/pkg/errors"
 
 	"github.com/kaspanet/kaspad/domain"
@@ -90,16 +91,6 @@ func (m *Manager) runFlows(flows []*common.Flow, peer *peerpkg.Peer, errChan <-c
 	return <-errChan
 }
 
-// SetOnVirtualChange sets the onVirtualChangeHandler handler
-func (m *Manager) SetOnVirtualChange(onVirtualChangeHandler flowcontext.OnVirtualChangeHandler) {
-	m.context.SetOnVirtualChangeHandler(onVirtualChangeHandler)
-}
-
-// SetOnBlockAddedToDAGHandler sets the onBlockAddedToDAG handler
-func (m *Manager) SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler flowcontext.OnBlockAddedToDAGHandler) {
-	m.context.SetOnBlockAddedToDAGHandler(onBlockAddedToDAGHandler)
-}
-
 // SetOnNewBlockTemplateHandler sets the onNewBlockTemplate handler
 func (m *Manager) SetOnNewBlockTemplateHandler(onNewBlockTemplateHandler flowcontext.OnNewBlockTemplateHandler) {
 	m.context.SetOnNewBlockTemplateHandler(onNewBlockTemplateHandler)
@@ -115,12 +106,6 @@ func (m *Manager) SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMemp
 	m.context.SetOnTransactionAddedToMempoolHandler(onTransactionAddedToMempoolHandler)
 }
 
-// ShouldMine returns whether it's ok to use block template from this node
-// for mining purposes.
-func (m *Manager) ShouldMine() (bool, error) {
-	return m.context.IsNearlySynced()
-}
-
 // IsIBDRunning returns true if IBD is currently marked as running
 func (m *Manager) IsIBDRunning() bool {
 	return m.context.IsIBDRunning()

app/protocol/protocol.go

@@ -23,7 +23,7 @@ func (m *Manager) routerInitializer(router *routerpkg.Router, netConnection *net
 	// errChan is used by the flow goroutines to return to runFlows when an error occurs.
 	// They are both initialized here and passed to register flows.
 	isStopping := uint32(0)
-	errChan := make(chan error)
+	errChan := make(chan error, 1)
 
 	receiveVersionRoute, sendVersionRoute, receiveReadyRoute := registerHandshakeRoutes(router)
 

app/rpc/manager.go

@@ -12,6 +12,7 @@ import (
 	"github.com/kaspanet/kaspad/infrastructure/network/addressmanager"
 	"github.com/kaspanet/kaspad/infrastructure/network/connmanager"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter"
+	"github.com/pkg/errors"
 )
 
 // Manager is an RPC manager
@@ -28,6 +29,7 @@ func NewManager(
 	connectionManager *connmanager.ConnectionManager,
 	addressManager *addressmanager.AddressManager,
 	utxoIndex *utxoindex.UTXOIndex,
+	consensusEventsChan chan externalapi.ConsensusEvent,
 	shutDownChan chan<- struct{}) *Manager {
 
 	manager := Manager{
@@ -44,50 +46,90 @@ func NewManager(
 	}
 	netAdapter.SetRPCRouterInitializer(manager.routerInitializer)
 
+	manager.initConsensusEventsHandler(consensusEventsChan)
+
 	return &manager
 }
 
-// NotifyBlockAddedToDAG notifies the manager that a block has been added to the DAG
+func (m *Manager) initConsensusEventsHandler(consensusEventsChan chan externalapi.ConsensusEvent) {
-func (m *Manager) NotifyBlockAddedToDAG(block *externalapi.DomainBlock, virtualChangeSet *externalapi.VirtualChangeSet) error {
+	spawn("consensusEventsHandler", func() {
-	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyBlockAddedToDAG")
+		for {
+			consensusEvent, ok := <-consensusEventsChan
+			if !ok {
+				return
+			}
+			switch event := consensusEvent.(type) {
+			case *externalapi.VirtualChangeSet:
+				err := m.notifyVirtualChange(event)
+				if err != nil {
+					panic(err)
+				}
+			case *externalapi.BlockAdded:
+				err := m.notifyBlockAddedToDAG(event.Block)
+				if err != nil {
+					panic(err)
+				}
+			default:
+				panic(errors.Errorf("Got event of unsupported type %T", consensusEvent))
+			}
+		}
+	})
+}
+
+// notifyBlockAddedToDAG notifies the manager that a block has been added to the DAG
+func (m *Manager) notifyBlockAddedToDAG(block *externalapi.DomainBlock) error {
+	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.notifyBlockAddedToDAG")
 	defer onEnd()
 
-	err := m.NotifyVirtualChange(virtualChangeSet)
+	// Before converting the block and populating it, we check if any listeners are interested.
-	if err != nil {
+	// This is done since most nodes do not use this event.
-		return err
+	if !m.context.NotificationManager.HasBlockAddedListeners() {
+		return nil
 	}
 
 	rpcBlock := appmessage.DomainBlockToRPCBlock(block)
-	err = m.context.PopulateBlockWithVerboseData(rpcBlock, block.Header, block, false)
+	err := m.context.PopulateBlockWithVerboseData(rpcBlock, block.Header, block, true)
 	if err != nil {
 		return err
 	}
 	blockAddedNotification := appmessage.NewBlockAddedNotificationMessage(rpcBlock)
-	return m.context.NotificationManager.NotifyBlockAdded(blockAddedNotification)
+	err = m.context.NotificationManager.NotifyBlockAdded(blockAddedNotification)
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
-// NotifyVirtualChange notifies the manager that the virtual block has been changed.
+// notifyVirtualChange notifies the manager that the virtual block has been changed.
-func (m *Manager) NotifyVirtualChange(virtualChangeSet *externalapi.VirtualChangeSet) error {
+func (m *Manager) notifyVirtualChange(virtualChangeSet *externalapi.VirtualChangeSet) error {
 	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyVirtualChange")
 	defer onEnd()
 
-	if m.context.Config.UTXOIndex {
+	if m.context.Config.UTXOIndex && virtualChangeSet.VirtualUTXODiff != nil {
 		err := m.notifyUTXOsChanged(virtualChangeSet)
 		if err != nil {
 			return err
 		}
 	}
 
-	err := m.notifyVirtualSelectedParentBlueScoreChanged()
+	err := m.notifyVirtualSelectedParentBlueScoreChanged(virtualChangeSet.VirtualSelectedParentBlueScore)
 	if err != nil {
 		return err
 	}
 
-	err = m.notifyVirtualDaaScoreChanged()
+	err = m.notifyVirtualDaaScoreChanged(virtualChangeSet.VirtualDAAScore)
 	if err != nil {
 		return err
 	}
 
+	if virtualChangeSet.VirtualSelectedParentChainChanges == nil ||
+		(len(virtualChangeSet.VirtualSelectedParentChainChanges.Added) == 0 &&
+			len(virtualChangeSet.VirtualSelectedParentChainChanges.Removed) == 0) {
+
+		return nil
+	}
+
 	err = m.notifyVirtualSelectedParentChainChanged(virtualChangeSet)
 	if err != nil {
 		return err
@@ -145,6 +187,7 @@ func (m *Manager) notifyUTXOsChanged(virtualChangeSet *externalapi.VirtualChange
 	if err != nil {
 		return err
 	}
+
 	return m.context.NotificationManager.NotifyUTXOsChanged(utxoIndexChanges)
 }
 
@@ -160,33 +203,18 @@ func (m *Manager) notifyPruningPointUTXOSetOverride() error {
 	return m.context.NotificationManager.NotifyPruningPointUTXOSetOverride()
 }
 
-func (m *Manager) notifyVirtualSelectedParentBlueScoreChanged() error {
+func (m *Manager) notifyVirtualSelectedParentBlueScoreChanged(virtualSelectedParentBlueScore uint64) error {
 	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyVirtualSelectedParentBlueScoreChanged")
 	defer onEnd()
 
-	virtualSelectedParent, err := m.context.Domain.Consensus().GetVirtualSelectedParent()
+	notification := appmessage.NewVirtualSelectedParentBlueScoreChangedNotificationMessage(virtualSelectedParentBlueScore)
-	if err != nil {
-		return err
-	}
-
-	blockInfo, err := m.context.Domain.Consensus().GetBlockInfo(virtualSelectedParent)
-	if err != nil {
-		return err
-	}
-
-	notification := appmessage.NewVirtualSelectedParentBlueScoreChangedNotificationMessage(blockInfo.BlueScore)
 	return m.context.NotificationManager.NotifyVirtualSelectedParentBlueScoreChanged(notification)
 }
 
-func (m *Manager) notifyVirtualDaaScoreChanged() error {
+func (m *Manager) notifyVirtualDaaScoreChanged(virtualDAAScore uint64) error {
 	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyVirtualDaaScoreChanged")
 	defer onEnd()
 
-	virtualDAAScore, err := m.context.Domain.Consensus().GetVirtualDAAScore()
-	if err != nil {
-		return err
-	}
-
 	notification := appmessage.NewVirtualDaaScoreChangedNotificationMessage(virtualDAAScore)
 	return m.context.NotificationManager.NotifyVirtualDaaScoreChanged(notification)
 }
@@ -195,10 +223,16 @@ func (m *Manager) notifyVirtualSelectedParentChainChanged(virtualChangeSet *exte
 	onEnd := logger.LogAndMeasureExecutionTime(log, "RPCManager.NotifyVirtualSelectedParentChainChanged")
 	defer onEnd()
 
-	notification, err := m.context.ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage(
+	hasListeners, includeAcceptedTransactionIDs := m.context.NotificationManager.HasListenersThatPropagateVirtualSelectedParentChainChanged()
-		virtualChangeSet.VirtualSelectedParentChainChanges)
+
-	if err != nil {
+	if hasListeners {
-		return err
+		notification, err := m.context.ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage(
+			virtualChangeSet.VirtualSelectedParentChainChanges, includeAcceptedTransactionIDs)
+		if err != nil {
+			return err
+		}
+		return m.context.NotificationManager.NotifyVirtualSelectedParentChainChanged(notification)
 	}
-	return m.context.NotificationManager.NotifyVirtualSelectedParentChainChanged(notification)
+
+	return nil
 }

app/rpc/rpc.go

@@ -49,6 +49,8 @@ var handlers = map[appmessage.MessageCommand]handler{
 	appmessage.CmdEstimateNetworkHashesPerSecondRequestMessage:              rpchandlers.HandleEstimateNetworkHashesPerSecond,
 	appmessage.CmdNotifyVirtualDaaScoreChangedRequestMessage:                rpchandlers.HandleNotifyVirtualDaaScoreChanged,
 	appmessage.CmdNotifyNewBlockTemplateRequestMessage:                      rpchandlers.HandleNotifyNewBlockTemplate,
+	appmessage.CmdGetCoinSupplyRequestMessage:                               rpchandlers.HandleGetCoinSupply,
+	appmessage.CmdGetMempoolEntriesByAddressesRequestMessage:                rpchandlers.HandleGetMempoolEntriesByAddresses,
 }
 
 func (m *Manager) routerInitializer(router *router.Router, netConnection *netadapter.NetConnection) {

app/rpc/rpccontext/chain_changed.go

@@ -3,12 +3,14 @@ package rpccontext
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/consensushashing"
 )
 
 // ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage converts
 // VirtualSelectedParentChainChanges to VirtualSelectedParentChainChangedNotificationMessage
 func (ctx *Context) ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage(
-	selectedParentChainChanges *externalapi.SelectedChainPath) (*appmessage.VirtualSelectedParentChainChangedNotificationMessage, error) {
+	selectedParentChainChanges *externalapi.SelectedChainPath, includeAcceptedTransactionIDs bool) (
+	*appmessage.VirtualSelectedParentChainChangedNotificationMessage, error) {
 
 	removedChainBlockHashes := make([]string, len(selectedParentChainChanges.Removed))
 	for i, removed := range selectedParentChainChanges.Removed {
@@ -20,5 +22,58 @@ func (ctx *Context) ConvertVirtualSelectedParentChainChangesToChainChangedNotifi
 		addedChainBlocks[i] = added.String()
 	}
 
-	return appmessage.NewVirtualSelectedParentChainChangedNotificationMessage(removedChainBlockHashes, addedChainBlocks), nil
+	var acceptedTransactionIDs []*appmessage.AcceptedTransactionIDs
+	if includeAcceptedTransactionIDs {
+		var err error
+		acceptedTransactionIDs, err = ctx.getAndConvertAcceptedTransactionIDs(selectedParentChainChanges)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return appmessage.NewVirtualSelectedParentChainChangedNotificationMessage(
+		removedChainBlockHashes, addedChainBlocks, acceptedTransactionIDs), nil
+}
+
+func (ctx *Context) getAndConvertAcceptedTransactionIDs(selectedParentChainChanges *externalapi.SelectedChainPath) (
+	[]*appmessage.AcceptedTransactionIDs, error) {
+
+	acceptedTransactionIDs := make([]*appmessage.AcceptedTransactionIDs, len(selectedParentChainChanges.Added))
+
+	const chunk = 1000
+	position := 0
+
+	for position < len(selectedParentChainChanges.Added) {
+		var chainBlocksChunk []*externalapi.DomainHash
+		if position+chunk > len(selectedParentChainChanges.Added) {
+			chainBlocksChunk = selectedParentChainChanges.Added[position:]
+		} else {
+			chainBlocksChunk = selectedParentChainChanges.Added[position : position+chunk]
+		}
+		// We use chunks in order to avoid blocking consensus for too long
+		chainBlocksAcceptanceData, err := ctx.Domain.Consensus().GetBlocksAcceptanceData(chainBlocksChunk)
+		if err != nil {
+			return nil, err
+		}
+
+		for i, addedChainBlock := range chainBlocksChunk {
+			chainBlockAcceptanceData := chainBlocksAcceptanceData[i]
+			acceptedTransactionIDs[position+i] = &appmessage.AcceptedTransactionIDs{
+				AcceptingBlockHash:     addedChainBlock.String(),
+				AcceptedTransactionIDs: nil,
+			}
+			for _, blockAcceptanceData := range chainBlockAcceptanceData {
+				for _, transactionAcceptanceData := range blockAcceptanceData.TransactionAcceptanceData {
+					if transactionAcceptanceData.IsAccepted {
+						acceptedTransactionIDs[position+i].AcceptedTransactionIDs =
+							append(acceptedTransactionIDs[position+i].AcceptedTransactionIDs,
+								consensushashing.TransactionID(transactionAcceptanceData.Transaction).String())
+					}
+				}
+			}
+		}
+		position += chunk
+	}
+
+	return acceptedTransactionIDs, nil
 }

app/rpc/rpccontext/context.go

@@ -44,7 +44,7 @@ func NewContext(cfg *config.Config,
 		UTXOIndex:         utxoIndex,
 		ShutDownChan:      shutDownChan,
 	}
-	context.NotificationManager = NewNotificationManager()
+	context.NotificationManager = NewNotificationManager(cfg.ActiveNetParams)
 
 	return context
 }

app/rpc/rpccontext/notificationmanager.go

@@ -3,6 +3,11 @@ package rpccontext
 import (
 	"sync"
 
+	"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"
 	"github.com/kaspanet/kaspad/domain/utxoindex"
 	routerpkg "github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
@@ -13,6 +18,7 @@ import (
 type NotificationManager struct {
 	sync.RWMutex
 	listeners map[*routerpkg.Router]*NotificationListener
+	params    *dagconfig.Params
 }
 
 // UTXOsChangedNotificationAddress represents a kaspad address.
@@ -24,6 +30,8 @@ type UTXOsChangedNotificationAddress struct {
 
 // NotificationListener represents a registered RPC notification listener
 type NotificationListener struct {
+	params *dagconfig.Params
+
 	propagateBlockAddedNotifications                            bool
 	propagateVirtualSelectedParentChainChangedNotifications     bool
 	propagateFinalityConflictNotifications                      bool
@@ -34,12 +42,14 @@ type NotificationListener struct {
 	propagatePruningPointUTXOSetOverrideNotifications           bool
 	propagateNewBlockTemplateNotifications                      bool
 
-	propagateUTXOsChangedNotificationAddresses map[utxoindex.ScriptPublicKeyString]*UTXOsChangedNotificationAddress
+	propagateUTXOsChangedNotificationAddresses                                    map[utxoindex.ScriptPublicKeyString]*UTXOsChangedNotificationAddress
+	includeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications bool
 }
 
 // NewNotificationManager creates a new NotificationManager
-func NewNotificationManager() *NotificationManager {
+func NewNotificationManager(params *dagconfig.Params) *NotificationManager {
 	return &NotificationManager{
+		params:    params,
 		listeners: make(map[*routerpkg.Router]*NotificationListener),
 	}
 }
@@ -49,7 +59,7 @@ func (nm *NotificationManager) AddListener(router *routerpkg.Router) {
 	nm.Lock()
 	defer nm.Unlock()
 
-	listener := newNotificationListener()
+	listener := newNotificationListener(nm.params)
 	nm.listeners[router] = listener
 }
 
@@ -73,6 +83,19 @@ func (nm *NotificationManager) Listener(router *routerpkg.Router) (*Notification
 	return listener, nil
 }
 
+// HasBlockAddedListeners indicates if the notification manager has any listeners for `BlockAdded` events
+func (nm *NotificationManager) HasBlockAddedListeners() bool {
+	nm.RLock()
+	defer nm.RUnlock()
+
+	for _, listener := range nm.listeners {
+		if listener.propagateBlockAddedNotifications {
+			return true
+		}
+	}
+	return false
+}
+
 // NotifyBlockAdded notifies the notification manager that a block has been added to the DAG
 func (nm *NotificationManager) NotifyBlockAdded(notification *appmessage.BlockAddedNotificationMessage) error {
 	nm.RLock()
@@ -80,10 +103,8 @@ func (nm *NotificationManager) NotifyBlockAdded(notification *appmessage.BlockAd
 
 	for router, listener := range nm.listeners {
 		if listener.propagateBlockAddedNotifications {
-			err := router.OutgoingRoute().Enqueue(notification)
+			err := router.OutgoingRoute().MaybeEnqueue(notification)
-			if errors.Is(err, routerpkg.ErrRouteClosed) {
+			if err != nil {
-				log.Warnf("Couldn't send notification: %s", err)
-			} else if err != nil {
 				return err
 			}
 		}
@@ -92,13 +113,27 @@ func (nm *NotificationManager) NotifyBlockAdded(notification *appmessage.BlockAd
 }
 
 // NotifyVirtualSelectedParentChainChanged notifies the notification manager that the DAG's selected parent chain has changed
-func (nm *NotificationManager) NotifyVirtualSelectedParentChainChanged(notification *appmessage.VirtualSelectedParentChainChangedNotificationMessage) error {
+func (nm *NotificationManager) NotifyVirtualSelectedParentChainChanged(
+	notification *appmessage.VirtualSelectedParentChainChangedNotificationMessage) error {
+
 	nm.RLock()
 	defer nm.RUnlock()
 
+	notificationWithoutAcceptedTransactionIDs := &appmessage.VirtualSelectedParentChainChangedNotificationMessage{
+		RemovedChainBlockHashes: notification.RemovedChainBlockHashes,
+		AddedChainBlockHashes:   notification.AddedChainBlockHashes,
+	}
+
 	for router, listener := range nm.listeners {
 		if listener.propagateVirtualSelectedParentChainChangedNotifications {
-			err := router.OutgoingRoute().Enqueue(notification)
+			var err error
+
+			if listener.includeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications {
+				err = router.OutgoingRoute().MaybeEnqueue(notification)
+			} else {
+				err = router.OutgoingRoute().MaybeEnqueue(notificationWithoutAcceptedTransactionIDs)
+			}
+
 			if err != nil {
 				return err
 			}
@@ -107,6 +142,31 @@ func (nm *NotificationManager) NotifyVirtualSelectedParentChainChanged(notificat
 	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
+
+	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
+			}
+		}
+	}
+
+	return hasListeners, hasListenersThatRequireAcceptedTransactionIDs
+}
+
 // NotifyFinalityConflict notifies the notification manager that there's a finality conflict in the DAG
 func (nm *NotificationManager) NotifyFinalityConflict(notification *appmessage.FinalityConflictNotificationMessage) error {
 	nm.RLock()
@@ -147,7 +207,10 @@ func (nm *NotificationManager) NotifyUTXOsChanged(utxoChanges *utxoindex.UTXOCha
 	for router, listener := range nm.listeners {
 		if listener.propagateUTXOsChangedNotifications {
 			// Filter utxoChanges and create a notification
-			notification := listener.convertUTXOChangesToUTXOsChangedNotification(utxoChanges)
+			notification, err := listener.convertUTXOChangesToUTXOsChangedNotification(utxoChanges)
+			if err != nil {
+				return err
+			}
 
 			// Don't send the notification if it's empty
 			if len(notification.Added) == 0 && len(notification.Removed) == 0 {
@@ -155,7 +218,7 @@ func (nm *NotificationManager) NotifyUTXOsChanged(utxoChanges *utxoindex.UTXOCha
 			}
 
 			// Enqueue the notification
-			err := router.OutgoingRoute().Enqueue(notification)
+			err = router.OutgoingRoute().MaybeEnqueue(notification)
 			if err != nil {
 				return err
 			}
@@ -174,7 +237,7 @@ func (nm *NotificationManager) NotifyVirtualSelectedParentBlueScoreChanged(
 
 	for router, listener := range nm.listeners {
 		if listener.propagateVirtualSelectedParentBlueScoreChangedNotifications {
-			err := router.OutgoingRoute().Enqueue(notification)
+			err := router.OutgoingRoute().MaybeEnqueue(notification)
 			if err != nil {
 				return err
 			}
@@ -193,7 +256,7 @@ func (nm *NotificationManager) NotifyVirtualDaaScoreChanged(
 
 	for router, listener := range nm.listeners {
 		if listener.propagateVirtualDaaScoreChangedNotifications {
-			err := router.OutgoingRoute().Enqueue(notification)
+			err := router.OutgoingRoute().MaybeEnqueue(notification)
 			if err != nil {
 				return err
 			}
@@ -238,8 +301,10 @@ func (nm *NotificationManager) NotifyPruningPointUTXOSetOverride() error {
 	return nil
 }
 
-func newNotificationListener() *NotificationListener {
+func newNotificationListener(params *dagconfig.Params) *NotificationListener {
 	return &NotificationListener{
+		params: params,
+
 		propagateBlockAddedNotifications:                            false,
 		propagateVirtualSelectedParentChainChangedNotifications:     false,
 		propagateFinalityConflictNotifications:                      false,
@@ -251,6 +316,12 @@ func newNotificationListener() *NotificationListener {
 	}
 }
 
+// IncludeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications returns true if this listener
+// includes accepted transaction IDs in it's virtual-selected-parent-chain-changed notifications
+func (nl *NotificationListener) IncludeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications() bool {
+	return nl.includeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications
+}
+
 // PropagateBlockAddedNotifications instructs the listener to send block added notifications
 // to the remote listener
 func (nl *NotificationListener) PropagateBlockAddedNotifications() {
@@ -259,8 +330,9 @@ func (nl *NotificationListener) PropagateBlockAddedNotifications() {
 
 // PropagateVirtualSelectedParentChainChangedNotifications instructs the listener to send chain changed notifications
 // to the remote listener
-func (nl *NotificationListener) PropagateVirtualSelectedParentChainChangedNotifications() {
+func (nl *NotificationListener) PropagateVirtualSelectedParentChainChangedNotifications(includeAcceptedTransactionIDs bool) {
 	nl.propagateVirtualSelectedParentChainChangedNotifications = true
+	nl.includeAcceptedTransactionIDsInVirtualSelectedParentChainChangedNotifications = includeAcceptedTransactionIDs
 }
 
 // PropagateFinalityConflictNotifications instructs the listener to send finality conflict notifications
@@ -279,7 +351,11 @@ 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 (nl *NotificationListener) PropagateUTXOsChangedNotifications(addresses []*UTXOsChangedNotificationAddress) {
+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()
+
 	if !nl.propagateUTXOsChangedNotifications {
 		nl.propagateUTXOsChangedNotifications = true
 		nl.propagateUTXOsChangedNotificationAddresses =
@@ -294,7 +370,11 @@ func (nl *NotificationListener) PropagateUTXOsChangedNotifications(addresses []*
 // 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 (nl *NotificationListener) StopPropagatingUTXOsChangedNotifications(addresses []*UTXOsChangedNotificationAddress) {
+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()
+
 	if !nl.propagateUTXOsChangedNotifications {
 		return
 	}
@@ -305,7 +385,7 @@ func (nl *NotificationListener) StopPropagatingUTXOsChangedNotifications(address
 }
 
 func (nl *NotificationListener) convertUTXOChangesToUTXOsChangedNotification(
-	utxoChanges *utxoindex.UTXOChanges) *appmessage.UTXOsChangedNotificationMessage {
+	utxoChanges *utxoindex.UTXOChanges) (*appmessage.UTXOsChangedNotificationMessage, error) {
 
 	// As an optimization, we iterate over the smaller set (O(n)) among the two below
 	// and check existence over the larger set (O(1))
@@ -320,27 +400,64 @@ func (nl *NotificationListener) convertUTXOChangesToUTXOsChangedNotification(
 				notification.Added = append(notification.Added, utxosByAddressesEntries...)
 			}
 		}
-		for scriptPublicKeyString, removedOutpoints := range utxoChanges.Removed {
+		for scriptPublicKeyString, removedPairs := range utxoChanges.Removed {
 			if listenerAddress, ok := nl.propagateUTXOsChangedNotificationAddresses[scriptPublicKeyString]; ok {
-				utxosByAddressesEntries := convertUTXOOutpointsToUTXOsByAddressesEntries(listenerAddress.Address, removedOutpoints)
+				utxosByAddressesEntries := ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(listenerAddress.Address, removedPairs)
 				notification.Removed = append(notification.Removed, utxosByAddressesEntries...)
 			}
 		}
-	} else {
+	} else if addressesSize > 0 {
 		for _, listenerAddress := range nl.propagateUTXOsChangedNotificationAddresses {
 			listenerScriptPublicKeyString := listenerAddress.ScriptPublicKeyString
 			if addedPairs, ok := utxoChanges.Added[listenerScriptPublicKeyString]; ok {
 				utxosByAddressesEntries := ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(listenerAddress.Address, addedPairs)
 				notification.Added = append(notification.Added, utxosByAddressesEntries...)
 			}
-			if removedOutpoints, ok := utxoChanges.Removed[listenerScriptPublicKeyString]; ok {
+			if removedPairs, ok := utxoChanges.Removed[listenerScriptPublicKeyString]; ok {
-				utxosByAddressesEntries := convertUTXOOutpointsToUTXOsByAddressesEntries(listenerAddress.Address, removedOutpoints)
+				utxosByAddressesEntries := ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(listenerAddress.Address, removedPairs)
 				notification.Removed = append(notification.Removed, utxosByAddressesEntries...)
 			}
 		}
+	} else {
+		for scriptPublicKeyString, addedPairs := range utxoChanges.Added {
+			addressString, err := nl.scriptPubKeyStringToAddressString(scriptPublicKeyString)
+			if err != nil {
+				return nil, err
+			}
+
+			utxosByAddressesEntries := ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(addressString, addedPairs)
+			notification.Added = append(notification.Added, utxosByAddressesEntries...)
+		}
+		for scriptPublicKeyString, removedPAirs := range utxoChanges.Removed {
+			addressString, err := nl.scriptPubKeyStringToAddressString(scriptPublicKeyString)
+			if err != nil {
+				return nil, err
+			}
+
+			utxosByAddressesEntries := ConvertUTXOOutpointEntryPairsToUTXOsByAddressesEntries(addressString, removedPAirs)
+			notification.Removed = append(notification.Removed, utxosByAddressesEntries...)
+		}
 	}
 
-	return notification
+	return notification, nil
+}
+
+func (nl *NotificationListener) scriptPubKeyStringToAddressString(scriptPublicKeyString utxoindex.ScriptPublicKeyString) (string, error) {
+	scriptPubKey := externalapi.NewScriptPublicKeyFromString(string(scriptPublicKeyString))
+
+	// ignore error because it is often returned when the script is of unknown type
+	scriptType, address, err := txscript.ExtractScriptPubKeyAddress(scriptPubKey, nl.params)
+	if err != nil {
+		return "", err
+	}
+
+	var addressString string
+	if scriptType == txscript.NonStandardTy {
+		addressString = ""
+	} else {
+		addressString = address.String()
+	}
+	return addressString, nil
 }
 
 // PropagateVirtualSelectedParentBlueScoreChangedNotifications instructs the listener to send

app/rpc/rpccontext/utxos_by_addresses.go

@@ -32,22 +32,6 @@ 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(
@@ -63,7 +47,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.ConvertScriptPublicKeyToString(scriptPublicKey)
+		scriptPublicKeyString := utxoindex.ScriptPublicKeyString(scriptPublicKey.String())
 		addresses[i] = &UTXOsChangedNotificationAddress{
 			Address:               addressString,
 			ScriptPublicKeyString: scriptPublicKeyString,

app/rpc/rpccontext/verbosedata.go

@@ -81,10 +81,6 @@ 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)
@@ -93,6 +89,10 @@ 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,6 +122,7 @@ func (ctx *Context) PopulateTransactionWithVerboseData(
 	}
 
 	ctx.Domain.Consensus().PopulateMass(domainTransaction)
+
 	transaction.VerboseData = &appmessage.RPCTransactionVerboseData{
 		TransactionID: consensushashing.TransactionID(domainTransaction).String(),
 		Hash:          consensushashing.TransactionHash(domainTransaction).String(),

app/rpc/rpchandlers/add_peer.go

@@ -9,6 +9,14 @@ import (
 
 // HandleAddPeer handles the respectively named RPC command
 func HandleAddPeer(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	if context.Config.SafeRPC {
+		log.Warn("AddPeer RPC command called while node in safe RPC mode -- ignoring.")
+		response := appmessage.NewAddPeerResponseMessage()
+		response.Error =
+			appmessage.RPCErrorf("AddPeer RPC command called while node in safe RPC mode")
+		return response, nil
+	}
+
 	AddPeerRequest := request.(*appmessage.AddPeerRequestMessage)
 	address, err := network.NormalizeAddress(AddPeerRequest.Address, context.Config.ActiveNetParams.DefaultPort)
 	if err != nil {

app/rpc/rpchandlers/ban.go

@@ -9,6 +9,14 @@ import (
 
 // HandleBan handles the respectively named RPC command
 func HandleBan(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	if context.Config.SafeRPC {
+		log.Warn("Ban RPC command called while node in safe RPC mode -- ignoring.")
+		response := appmessage.NewBanResponseMessage()
+		response.Error =
+			appmessage.RPCErrorf("Ban RPC command called while node in safe RPC mode")
+		return response, nil
+	}
+
 	banRequest := request.(*appmessage.BanRequestMessage)
 	ip := net.ParseIP(banRequest.IP)
 	if ip == nil {

app/rpc/rpchandlers/estimate_network_hashes_per_second.go

@@ -27,6 +27,27 @@ func HandleEstimateNetworkHashesPerSecond(
 		}
 	}
 
+	if context.Config.SafeRPC {
+		const windowSizeLimit = 10000
+		if windowSize > windowSizeLimit {
+			response := &appmessage.EstimateNetworkHashesPerSecondResponseMessage{}
+			response.Error =
+				appmessage.RPCErrorf(
+					"Requested window size %d is larger than max allowed in RPC safe mode (%d)",
+					windowSize, windowSizeLimit)
+			return response, nil
+		}
+	}
+
+	if uint64(windowSize) > context.Config.ActiveNetParams.PruningDepth() {
+		response := &appmessage.EstimateNetworkHashesPerSecondResponseMessage{}
+		response.Error =
+			appmessage.RPCErrorf(
+				"Requested window size %d is larger than pruning point depth %d",
+				windowSize, context.Config.ActiveNetParams.PruningDepth())
+		return response, nil
+	}
+
 	networkHashesPerSecond, err := context.Domain.Consensus().EstimateNetworkHashesPerSecond(startHash, windowSize)
 	if err != nil {
 		response := &appmessage.EstimateNetworkHashesPerSecondResponseMessage{}

app/rpc/rpchandlers/get_balance_by_address.go

@@ -22,7 +22,7 @@ func HandleGetBalanceByAddress(context *rpccontext.Context, _ *router.Router, re
 	balance, err := getBalanceByAddress(context, getBalanceByAddressRequest.Address)
 	if err != nil {
 		rpcError := &appmessage.RPCError{}
-		if !errors.As(err, rpcError) {
+		if !errors.As(err, &rpcError) {
 			return nil, err
 		}
 		errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}

app/rpc/rpchandlers/get_balances_by_addresses.go

@@ -23,7 +23,7 @@ func HandleGetBalancesByAddresses(context *rpccontext.Context, _ *router.Router,
 
 		if err != nil {
 			rpcError := &appmessage.RPCError{}
-			if !errors.As(err, rpcError) {
+			if !errors.As(err, &rpcError) {
 				return nil, err
 			}
 			errorMessage := &appmessage.GetUTXOsByAddressesResponseMessage{}

app/rpc/rpchandlers/get_block_template.go

@@ -28,7 +28,8 @@ func HandleGetBlockTemplate(context *rpccontext.Context, _ *router.Router, reque
 	}
 
 	coinbaseData := &externalapi.DomainCoinbaseData{ScriptPublicKey: scriptPublicKey, ExtraData: []byte(version.Version() + "/" + getBlockTemplateRequest.ExtraData)}
-	templateBlock, err := context.Domain.MiningManager().GetBlockTemplate(coinbaseData)
+
+	templateBlock, isNearlySynced, err := context.Domain.MiningManager().GetBlockTemplate(coinbaseData)
 	if err != nil {
 		return nil, err
 	}
@@ -41,10 +42,5 @@ func HandleGetBlockTemplate(context *rpccontext.Context, _ *router.Router, reque
 
 	rpcBlock := appmessage.DomainBlockToRPCBlock(templateBlock)
 
-	isSynced, err := context.ProtocolManager.ShouldMine()
+	return appmessage.NewGetBlockTemplateResponseMessage(rpcBlock, context.ProtocolManager.Context().HasPeers() && isNearlySynced), nil
-	if err != nil {
-		return nil, err
-	}
-
-	return appmessage.NewGetBlockTemplateResponseMessage(rpcBlock, isSynced), nil
 }

app/rpc/rpchandlers/get_blocks.go

@@ -37,7 +37,7 @@ func HandleGetBlocks(context *rpccontext.Context, _ *router.Router, request appm
 			return nil, err
 		}
 
-		if !blockInfo.Exists {
+		if !blockInfo.HasHeader() {
 			return &appmessage.GetBlocksResponseMessage{
 				Error: appmessage.RPCErrorf("Could not find lowHash %s", getBlocksRequest.LowHash),
 			}, nil

app/rpc/rpchandlers/get_blocks_test.go

@@ -23,6 +23,10 @@ type fakeDomain struct {
 	testapi.TestConsensus
 }
 
+func (d fakeDomain) ConsensusEventsChannel() chan externalapi.ConsensusEvent {
+	panic("implement me")
+}
+
 func (d fakeDomain) DeleteStagingConsensus() error {
 	panic("implement me")
 }

app/rpc/rpchandlers/get_coin_supply.go

@@ -0,0 +1,29 @@
+package rpchandlers
+
+import (
+	"github.com/kaspanet/kaspad/app/appmessage"
+	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
+	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
+)
+
+// HandleGetCoinSupply handles the respectively named RPC command
+func HandleGetCoinSupply(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+	if !context.Config.UTXOIndex {
+		errorMessage := &appmessage.GetCoinSupplyResponseMessage{}
+		errorMessage.Error = appmessage.RPCErrorf("Method unavailable when kaspad is run without --utxoindex")
+		return errorMessage, nil
+	}
+
+	circulatingSompiSupply, err := context.UTXOIndex.GetCirculatingSompiSupply()
+	if err != nil {
+		return nil, err
+	}
+
+	response := appmessage.NewGetCoinSupplyResponseMessage(
+		constants.MaxSompi,
+		circulatingSompiSupply,
+	)
+
+	return response, nil
+}

app/rpc/rpchandlers/get_info.go

@@ -9,10 +9,17 @@ import (
 
 // HandleGetInfo handles the respectively named RPC command
 func HandleGetInfo(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+	isNearlySynced, err := context.Domain.Consensus().IsNearlySynced()
+	if err != nil {
+		return nil, err
+	}
+
 	response := appmessage.NewGetInfoResponseMessage(
 		context.NetAdapter.ID().String(),
-		uint64(context.Domain.MiningManager().TransactionCount()),
+		uint64(context.Domain.MiningManager().TransactionCount(true, false)),
 		version.Version(),
+		context.Config.UTXOIndex,
+		context.ProtocolManager.Context().HasPeers() && isNearlySynced,
 	)
 
 	return response, nil

app/rpc/rpchandlers/get_mempool_entries.go

@@ -7,19 +7,40 @@ import (
 )
 
 // HandleGetMempoolEntries handles the respectively named RPC command
-func HandleGetMempoolEntries(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+func HandleGetMempoolEntries(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
-	transactions := context.Domain.MiningManager().AllTransactions()
+	getMempoolEntriesRequest := request.(*appmessage.GetMempoolEntriesRequestMessage)
-	entries := make([]*appmessage.MempoolEntry, 0, len(transactions))
+
-	for _, transaction := range transactions {
+	entries := make([]*appmessage.MempoolEntry, 0)
-		rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
+
-		err := context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
+	transactionPoolTransactions, orphanPoolTransactions := context.Domain.MiningManager().AllTransactions(!getMempoolEntriesRequest.FilterTransactionPool, getMempoolEntriesRequest.IncludeOrphanPool)
-		if err != nil {
+
-			return nil, err
+	if !getMempoolEntriesRequest.FilterTransactionPool {
+		for _, transaction := range transactionPoolTransactions {
+			rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
+			err := context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
+			if err != nil {
+				return nil, err
+			}
+			entries = append(entries, &appmessage.MempoolEntry{
+				Fee:         transaction.Fee,
+				Transaction: rpcTransaction,
+				IsOrphan:    false,
+			})
+		}
+	}
+	if getMempoolEntriesRequest.IncludeOrphanPool {
+		for _, transaction := range orphanPoolTransactions {
+			rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
+			err := context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
+			if err != nil {
+				return nil, err
+			}
+			entries = append(entries, &appmessage.MempoolEntry{
+				Fee:         transaction.Fee,
+				Transaction: rpcTransaction,
+				IsOrphan:    true,
+			})
 		}
-		entries = append(entries, &appmessage.MempoolEntry{
-			Fee:         transaction.Fee,
-			Transaction: rpcTransaction,
-		})
 	}
 
 	return appmessage.NewGetMempoolEntriesResponseMessage(entries), nil

app/rpc/rpchandlers/get_mempool_entries_by_addresses.go

@@ -0,0 +1,122 @@
+package rpchandlers
+
+import (
+	"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/infrastructure/network/netadapter/router"
+	"github.com/kaspanet/kaspad/util"
+)
+
+// HandleGetMempoolEntriesByAddresses handles the respectively named RPC command
+func HandleGetMempoolEntriesByAddresses(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+
+	getMempoolEntriesByAddressesRequest := request.(*appmessage.GetMempoolEntriesByAddressesRequestMessage)
+
+	mempoolEntriesByAddresses := make([]*appmessage.MempoolEntryByAddress, 0)
+
+	sendingInTransactionPool, receivingInTransactionPool, sendingInOrphanPool, receivingInOrphanPool, err := context.Domain.MiningManager().GetTransactionsByAddresses(!getMempoolEntriesByAddressesRequest.FilterTransactionPool, getMempoolEntriesByAddressesRequest.IncludeOrphanPool)
+	if err != nil {
+		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)
+			return errorMessage, nil
+		}
+
+		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
+		}
+
+		if !getMempoolEntriesByAddressesRequest.FilterTransactionPool {
+
+			if transaction, found := sendingInTransactionPool[scriptPublicKey.String()]; found {
+				rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
+				err := context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
+				if err != nil {
+					return nil, err
+				}
+
+				sending = append(sending, &appmessage.MempoolEntry{
+					Fee:         transaction.Fee,
+					Transaction: rpcTransaction,
+					IsOrphan:    false,
+				},
+				)
+			}
+
+			if transaction, found := receivingInTransactionPool[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:    false,
+				},
+				)
+			}
+		}
+		if getMempoolEntriesByAddressesRequest.IncludeOrphanPool {
+
+			if transaction, found := sendingInOrphanPool[scriptPublicKey.String()]; found {
+				rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
+				err := context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
+				if err != nil {
+					return nil, err
+				}
+
+				sending = append(sending, &appmessage.MempoolEntry{
+					Fee:         transaction.Fee,
+					Transaction: rpcTransaction,
+					IsOrphan:    true,
+				},
+				)
+			}
+
+			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,
+				},
+				)
+			}
+
+		}
+
+		if len(sending) > 0 || len(receiving) > 0 {
+			mempoolEntriesByAddresses = append(
+				mempoolEntriesByAddresses,
+				&appmessage.MempoolEntryByAddress{
+					Address:   address.String(),
+					Sending:   sending,
+					Receiving: receiving,
+				},
+			)
+		}
+	}
+
+	return appmessage.NewGetMempoolEntriesByAddressesResponseMessage(mempoolEntriesByAddresses), nil
+}

app/rpc/rpchandlers/get_mempool_entry.go

@@ -3,12 +3,18 @@ package rpchandlers
 import (
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
+	"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
 	"github.com/kaspanet/kaspad/domain/consensus/utils/transactionid"
 	"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
 )
 
 // HandleGetMempoolEntry handles the respectively named RPC command
 func HandleGetMempoolEntry(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+
+	transaction := &externalapi.DomainTransaction{}
+	var found bool
+	var isOrphan bool
+
 	getMempoolEntryRequest := request.(*appmessage.GetMempoolEntryRequestMessage)
 
 	transactionID, err := transactionid.FromString(getMempoolEntryRequest.TxID)
@@ -18,17 +24,18 @@ func HandleGetMempoolEntry(context *rpccontext.Context, _ *router.Router, reques
 		return errorMessage, nil
 	}
 
-	transaction, ok := context.Domain.MiningManager().GetTransaction(transactionID)
+	mempoolTransaction, isOrphan, found := context.Domain.MiningManager().GetTransaction(transactionID, !getMempoolEntryRequest.FilterTransactionPool, getMempoolEntryRequest.IncludeOrphanPool)
-	if !ok {
+
+	if !found {
 		errorMessage := &appmessage.GetMempoolEntryResponseMessage{}
 		errorMessage.Error = appmessage.RPCErrorf("Transaction %s was not found", transactionID)
 		return errorMessage, nil
 	}
-	rpcTransaction := appmessage.DomainTransactionToRPCTransaction(transaction)
+
+	rpcTransaction := appmessage.DomainTransactionToRPCTransaction(mempoolTransaction)
 	err = context.PopulateTransactionWithVerboseData(rpcTransaction, nil)
 	if err != nil {
 		return nil, err
 	}
-
+	return appmessage.NewGetMempoolEntryResponseMessage(transaction.Fee, rpcTransaction, isOrphan), nil
-	return appmessage.NewGetMempoolEntryResponseMessage(transaction.Fee, rpcTransaction), nil
 }

app/rpc/rpchandlers/get_virtual_selected_parent_chain_from_block.go

@@ -26,12 +26,14 @@ func HandleGetVirtualSelectedParentChainFromBlock(context *rpccontext.Context, _
 		return response, nil
 	}
 
-	chainChangedNotification, err := context.ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage(virtualSelectedParentChain)
+	chainChangedNotification, err := context.ConvertVirtualSelectedParentChainChangesToChainChangedNotificationMessage(
+		virtualSelectedParentChain, getVirtualSelectedParentChainFromBlockRequest.IncludeAcceptedTransactionIDs)
 	if err != nil {
 		return nil, err
 	}
 
 	response := appmessage.NewGetVirtualSelectedParentChainFromBlockResponseMessage(
-		chainChangedNotification.RemovedChainBlockHashes, chainChangedNotification.AddedChainBlockHashes)
+		chainChangedNotification.RemovedChainBlockHashes, chainChangedNotification.AddedChainBlockHashes,
+		chainChangedNotification.AcceptedTransactionIDs)
 	return response, nil
 }

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
 	}
-	listener.PropagateUTXOsChangedNotifications(addresses)
+	context.NotificationManager.PropagateUTXOsChangedNotifications(listener, addresses)
 
 	response := appmessage.NewNotifyUTXOsChangedResponseMessage()
 	return response, nil

app/rpc/rpchandlers/notify_virtual_selected_parent_chain_changed.go

@@ -7,12 +7,17 @@ import (
 )
 
 // HandleNotifyVirtualSelectedParentChainChanged handles the respectively named RPC command
-func HandleNotifyVirtualSelectedParentChainChanged(context *rpccontext.Context, router *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+func HandleNotifyVirtualSelectedParentChainChanged(context *rpccontext.Context, router *router.Router,
+	request appmessage.Message) (appmessage.Message, error) {
+
+	notifyVirtualSelectedParentChainChangedRequest := request.(*appmessage.NotifyVirtualSelectedParentChainChangedRequestMessage)
+
 	listener, err := context.NotificationManager.Listener(router)
 	if err != nil {
 		return nil, err
 	}
-	listener.PropagateVirtualSelectedParentChainChangedNotifications()
+	listener.PropagateVirtualSelectedParentChainChangedNotifications(
+		notifyVirtualSelectedParentChainChangedRequest.IncludeAcceptedTransactionIDs)
 
 	response := appmessage.NewNotifyVirtualSelectedParentChainChangedResponseMessage()
 	return response, nil

app/rpc/rpchandlers/resolve_finality_conflict.go

@@ -8,6 +8,14 @@ import (
 
 // HandleResolveFinalityConflict handles the respectively named RPC command
 func HandleResolveFinalityConflict(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	if context.Config.SafeRPC {
+		log.Warn("ResolveFinalityConflict RPC command called while node in safe RPC mode -- ignoring.")
+		response := &appmessage.ResolveFinalityConflictResponseMessage{}
+		response.Error =
+			appmessage.RPCErrorf("ResolveFinalityConflict RPC command called while node in safe RPC mode")
+		return response, nil
+	}
+
 	response := &appmessage.ResolveFinalityConflictResponseMessage{}
 	response.Error = appmessage.RPCErrorf("not implemented")
 	return response, nil

app/rpc/rpchandlers/shut_down.go

@@ -12,6 +12,14 @@ const pauseBeforeShutDown = time.Second
 
 // HandleShutDown handles the respectively named RPC command
 func HandleShutDown(context *rpccontext.Context, _ *router.Router, _ appmessage.Message) (appmessage.Message, error) {
+	if context.Config.SafeRPC {
+		log.Warn("ShutDown RPC command called while node in safe RPC mode -- ignoring.")
+		response := appmessage.NewShutDownResponseMessage()
+		response.Error =
+			appmessage.RPCErrorf("ShutDown RPC command called while node in safe RPC mode")
+		return response, nil
+	}
+
 	log.Warn("ShutDown RPC called.")
 
 	// Wait a second before shutting down, to allow time to return the response to the caller

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
 	}
-	listener.StopPropagatingUTXOsChangedNotifications(addresses)
+	context.NotificationManager.StopPropagatingUTXOsChangedNotifications(listener, addresses)
 
 	response := appmessage.NewStopNotifyingUTXOsChangedResponseMessage()
 	return response, nil

app/rpc/rpchandlers/submit_block.go

@@ -1,6 +1,7 @@
 package rpchandlers
 
 import (
+	"encoding/json"
 	"github.com/kaspanet/kaspad/app/appmessage"
 	"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
 	"github.com/kaspanet/kaspad/app/rpc/rpccontext"
@@ -14,9 +15,14 @@ import (
 func HandleSubmitBlock(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
 	submitBlockRequest := request.(*appmessage.SubmitBlockRequestMessage)
 
-	isSynced, err := context.ProtocolManager.ShouldMine()
+	var err error
-	if err != nil {
+	isSynced := false
-		return nil, err
+	// The node is considered synced if it has peers and consensus state is nearly synced
+	if context.ProtocolManager.Context().HasPeers() {
+		isSynced, err = context.ProtocolManager.Context().IsNearlySynced()
+		if err != nil {
+			return nil, err
+		}
 	}
 
 	if !context.Config.AllowSubmitBlockWhenNotSynced && !isSynced {
@@ -58,6 +64,12 @@ func HandleSubmitBlock(context *rpccontext.Context, _ *router.Router, request ap
 			return nil, err
 		}
 
+		jsonBytes, _ := json.MarshalIndent(submitBlockRequest.Block.Header, "", "    ")
+		if jsonBytes != nil {
+			log.Warnf("The RPC submitted block triggered a rule/protocol error (%s), printing "+
+				"the full header for debug purposes: \n%s", err, string(jsonBytes))
+		}
+
 		return &appmessage.SubmitBlockResponseMessage{
 			Error:        appmessage.RPCErrorf("Block rejected. Reason: %s", err),
 			RejectReason: appmessage.RejectReasonBlockInvalid,

app/rpc/rpchandlers/submit_transaction.go

@@ -28,7 +28,8 @@ func HandleSubmitTransaction(context *rpccontext.Context, _ *router.Router, requ
 		}
 
 		log.Debugf("Rejected transaction %s: %s", transactionID, err)
-		errorMessage := &appmessage.SubmitTransactionResponseMessage{}
+		// 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.Error = appmessage.RPCErrorf("Rejected transaction %s: %s", transactionID, err)
 		return errorMessage, nil
 	}

app/rpc/rpchandlers/unban.go

@@ -9,6 +9,14 @@ import (
 
 // HandleUnban handles the respectively named RPC command
 func HandleUnban(context *rpccontext.Context, _ *router.Router, request appmessage.Message) (appmessage.Message, error) {
+	if context.Config.SafeRPC {
+		log.Warn("Unban RPC command called while node in safe RPC mode -- ignoring.")
+		response := appmessage.NewUnbanResponseMessage()
+		response.Error =
+			appmessage.RPCErrorf("Unban RPC command called while node in safe RPC mode")
+		return response, nil
+	}
+
 	unbanRequest := request.(*appmessage.UnbanRequestMessage)
 	ip := net.ParseIP(unbanRequest.IP)
 	if ip == nil {

build_and_test.sh

@@ -5,13 +5,10 @@ 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 .

changelog.txt

@@ -1,3 +1,219 @@
+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
+===========================
+
+* Crucial fix for the UTXO difference mechanism (#2114)
+* Implement multi-layer auto-compound (#2115)
+
+Kaspad v0.12.3 - 2022-06-29
+===========================
+
+* Fixes a few bugs which can lead to node crashes or out-of-memory errors
+
+Kaspad v0.12.2 - 2022-06-17
+===========================
+
+* Clarify wallet message concerning a wallet daemon sync state  (#2045)
+* Change the way the miner executable reports execution errors (closes issue #1677) (#2048)
+* Fix kaspawallet help messages, clarify sweep command help string (#2067)
+* Wallet parse/send/create commands improvement (#2024)
+* Use chunks for `GetBlocksAcceptanceData` calls in order to avoid blocking consensus for too long (#2075)
+* Unite multiple `GetBlockAcceptanceData` consensus calls to one (#2074)
+* Update many-small-chains-and-one-big-chain DAG to not fail merge depth limit (#2072)
+
+RPC API Changes:
+* RPC: include orphans into mempool entries (#2046)
+* RPC & UtxoIndex: keep track of, query and test circulating supply. (#2070)
+
+Bug Fixes:
+* Fix RPC connections counting (#2026)
+* Fix UTXO diff child error  (#2084)
+* Fix `not in selected chain` crash  (#2082)
+
+Kaspad v0.12.1 - 2022-05-31
+===========================
+
+* Fix utxoindex synchronization bug which resulted in kaspawallet orphan tx errors (#2052, #2056, #2059)
+* Add a channel mechanism for consensus events to be processed in the order they were produced (#2052, #2056, #2059)
+* Block template cache improvement (#2023)
+* Improved staging shard performance (#2034)
+* Add finality check to ResolveVirtual (#2041)
+* Update Dockerfile for go 1.18 (#2038)
+* Remove HF1 activation code (#2042)
+
+Kaspa wallet:
+* Various kaspawallet text fixes and log additions (#2032, #2047, #2062)
+* Wallet address synchronization improvement (#2025)
+* Add support for `from` address in `kaspawallet send` (#1964)
+* Make kaspawallet ignore outputs that exist in the mempool (#2053)
+* Wrap the entire wallet send operation with a lock (#2063)
+
+RPC API:
+* Add "GetMempoolEntriesByAddresses" to kaspad RPC (#2022)
+* Make sure RPCErrors are returned and do not crash the system (#2039)
+* Add AcceptedTransactionIDs to ChainChanged notification and VirtualSelectedParentChain RPC (#2036, for exchanges to track tx confirmations)
+* Allow blank address in NotifyUTXOsChanged to get all updates (#2027)
+* Include isSynced and isUtxoIndexed in GetInfoResponse (#2068)
+
+Kaspad v0.12.0 - 2022-04-14
+===========================
+Breaking changes:
+    Hard-fork at DAA score 14687583 (estimated to be on 28/04 16:38 UTC) which includes:
+    * Using separate depth than finality depth for merge set calculations (#2013)
+    * Not counting the header size as part of the block mass (#2013)
+    * Increasing block version to 1 (#2013)
+    * Removing the limit on amount of KAS that can be sent in one transaction (#2013)
+
+Bug fixes:
+* Making a workaround for the UTXO diff child bug (#2020)
+* Use cosigner index 0 for read only wallets (#2014)
+
+Non-breaking changes:
+* Adding a "sweep" command to `kaspawallet` (#2018)
+* Use `blue work` heuristic to skip irrelevant relay blocks
+* Kaspawallet daemon: Add Send and Sign commands (#2016)
+
+Kaspad v0.11.17 - 2022-04-06
+===========================
+* Decrement estimatedHeaderUpperBound from mempool's MaxBlockMass (#2009)
+
+Kaspad v0.11.16 - 2022-04-05
+===========================
+* Don't skip wallet address with different cosigner index (#2007)
+
+Kaspad v0.11.15 - 2022-04-05
+===========================
+* Add support for auto-compound in `kaspawallet send` (#1951)
+* Unite reachability stores (#1963, #1993, #2001)
+* Add names to nameless routes (#1986)
+* Optimize the miner-kaspad flow and latency (#1988)
+* Upgrade to go 1.18 (#1992)
+* Add package name to kaspawalletd .proto file (#1991)
+* Block template cache  (#1994)
+* Add extra data to GetBlockTemplate request (#1995, #1997)
+* New definition for "out of sync"  (#1996)
+* Remove v4 p2p version (#1998)
+* Remove increase pagefile from deploy.yaml (#2000)
+* Cache the pruning point anticone (#2002)
+* Add DB compaction after the deletion of a DB prefix (#2003)
+* Fixed a bug in staging of pruning point by index (#2005)
+* Clean up debug log level by moving many frequent logs to trace level (#2004)
+
 Kaspad v0.11.14 - 2022-03-20
 ===========================
 * Fix a bug in the new p2p v5 IBD chain negotiation (#1981)

cmd/kaspactl/README.md

@@ -4,7 +4,7 @@ kaspactl is an RPC client for kaspad
 
 ## Requirements
 
-Go 1.18 or later.
+Go 1.23 or later.
 
 ## Installation
 

cmd/kaspactl/commands.go

@@ -31,10 +31,13 @@ var commandTypes = []reflect.Type{
 
 	reflect.TypeOf(protowire.KaspadMessage_GetMempoolEntryRequest{}),
 	reflect.TypeOf(protowire.KaspadMessage_GetMempoolEntriesRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_GetMempoolEntriesByAddressesRequest{}),
+
 	reflect.TypeOf(protowire.KaspadMessage_SubmitTransactionRequest{}),
 
 	reflect.TypeOf(protowire.KaspadMessage_GetUtxosByAddressesRequest{}),
 	reflect.TypeOf(protowire.KaspadMessage_GetBalanceByAddressRequest{}),
+	reflect.TypeOf(protowire.KaspadMessage_GetCoinSupplyRequest{}),
 
 	reflect.TypeOf(protowire.KaspadMessage_BanRequest{}),
 	reflect.TypeOf(protowire.KaspadMessage_UnbanRequest{}),

cmd/kaspactl/docker/Dockerfile

@@ -1,13 +1,11 @@
 # -- multistage docker build: stage #1: build stage
-FROM golang:1.18-alpine AS build
+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
-RUN go get -u golang.org/x/lint/golint \
-              honnef.co/go/tools/cmd/staticcheck 
 
 COPY go.mod .
 COPY go.sum .
@@ -18,10 +16,6 @@ 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

cmd/kaspaminer/README.md

@@ -4,7 +4,7 @@ Kaspaminer is a CPU-based miner for kaspad
 
 ## Requirements
 
-Go 1.18 or later.
+Go 1.23 or later.
 
 ## Installation
 
@@ -40,6 +40,7 @@ $ kaspaminer --help
 ```
 
 But the minimum configuration needed to run it is:
+
 ```bash
 $ kaspaminer --miningaddr=<YOUR_MINING_ADDRESS>
 ```

cmd/kaspaminer/docker/Dockerfile

@@ -1,13 +1,11 @@
 # -- multistage docker build: stage #1: build stage
-FROM golang:1.18-alpine AS build
+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
-RUN go get -u golang.org/x/lint/golint \
-              honnef.co/go/tools/cmd/staticcheck 
 
 COPY go.mod .
 COPY go.sum .
@@ -17,11 +15,6 @@ 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

cmd/kaspaminer/main.go

@@ -23,8 +23,7 @@ func main() {
 
 	cfg, err := parseConfig()
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error parsing command-line arguments: %s\n", err)
+		printErrorAndExit(errors.Errorf("Error parsing command-line arguments: %s", err))
-		os.Exit(1)
 	}
 	defer backendLog.Close()
 
@@ -44,7 +43,7 @@ func main() {
 
 	miningAddr, err := util.DecodeAddress(cfg.MiningAddr, cfg.ActiveNetParams.Prefix)
 	if err != nil {
-		panic(errors.Wrap(err, "error decoding mining address"))
+		printErrorAndExit(errors.Errorf("Error decoding mining address: %s", err))
 	}
 
 	doneChan := make(chan struct{})
@@ -61,3 +60,8 @@ func main() {
 	case <-interrupt:
 	}
 }
+
+func printErrorAndExit(err error) {
+	fmt.Fprintf(os.Stderr, "%+v\n", err)
+	os.Exit(1)
+}

cmd/kaspawallet/balance.go

@@ -3,19 +3,12 @@ package main
 import (
 	"context"
 	"fmt"
+
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/client"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
-	"github.com/kaspanet/kaspad/domain/consensus/utils/constants"
+	"github.com/kaspanet/kaspad/cmd/kaspawallet/utils"
 )
 
-func formatKas(amount uint64) string {
-	res := "                   "
-	if amount > 0 {
-		res = fmt.Sprintf("%19.8f", float64(amount)/constants.SompiPerKaspa)
-	}
-	return res
-}
-
 func balance(conf *balanceConfig) error {
 	daemonClient, tearDown, err := client.Connect(conf.DaemonAddress)
 	if err != nil {
@@ -39,12 +32,12 @@ func balance(conf *balanceConfig) error {
 		println("Address                                                                       Available             Pending")
 		println("-----------------------------------------------------------------------------------------------------------")
 		for _, addressBalance := range response.AddressBalances {
-			fmt.Printf("%s %s %s\n", addressBalance.Address, formatKas(addressBalance.Available), formatKas(addressBalance.Pending))
+			fmt.Printf("%s %s %s\n", addressBalance.Address, utils.FormatKas(addressBalance.Available), utils.FormatKas(addressBalance.Pending))
 		}
 		println("-----------------------------------------------------------------------------------------------------------")
 		print("                                                 ")
 	}
-	fmt.Printf("Total balance, KAS %s %s%s\n", formatKas(response.Available), formatKas(response.Pending), pendingSuffix)
+	fmt.Printf("Total balance, KAS %s %s%s\n", utils.FormatKas(response.Available), utils.FormatKas(response.Pending), pendingSuffix)
 
 	return nil
 }

cmd/kaspawallet/broadcast.go

@@ -8,6 +8,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/pkg/errors"
 )
 
@@ -37,23 +38,19 @@ func broadcast(conf *broadcastConfig) error {
 		transactionsHex = strings.TrimSpace(string(transactionHexBytes))
 	}
 
-	transactions, err := decodeTransactionsFromHex(transactionsHex)
+	transactions, err := server.DecodeTransactionsFromHex(transactionsHex)
 	if err != nil {
 		return err
 	}
 
-	transactionsCount := len(transactions)
+	response, err := daemonClient.Broadcast(ctx, &pb.BroadcastRequest{Transactions: transactions})
-	for i, transaction := range transactions {
+	if err != nil {
-		response, err := daemonClient.Broadcast(ctx, &pb.BroadcastRequest{Transaction: transaction})
+		return err
-		if err != nil {
+	}
-			return err
+	fmt.Println("Transactions were sent successfully")
-		}
+	fmt.Println("Transaction ID(s): ")
-		if transactionsCount == 1 {
+	for _, txID := range response.TxIDs {
-			fmt.Println("Transaction was sent successfully")
+		fmt.Printf("\t%s\n", txID)
-		} else {
-			fmt.Printf("Transaction %d (out of %d) was sent successfully\n", i+1, transactionsCount)
-		}
-		fmt.Printf("Transaction ID: \t%s\n", response.TxID)
 	}
 
 	return nil

cmd/kaspawallet/broadcast_replacement.go

@@ -0,0 +1,57 @@
+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
+}

cmd/kaspawallet/bump_fee.go

@@ -0,0 +1,117 @@
+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
+}

cmd/kaspawallet/bump_fee_unsigned.go

@@ -0,0 +1,58 @@
+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
+}

cmd/kaspawallet/config.go

@@ -13,6 +13,7 @@ const (
 	createSubCmd                    = "create"
 	balanceSubCmd                   = "balance"
 	sendSubCmd                      = "send"
+	sweepSubCmd                     = "sweep"
 	createUnsignedTransactionSubCmd = "create-unsigned-transaction"
 	signSubCmd                      = "sign"
 	broadcastSubCmd                 = "broadcast"
@@ -21,6 +22,11 @@ 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 (
@@ -29,6 +35,7 @@ const (
 )
 
 type configFlags struct {
+	ShowVersion bool `short:"V" long:"version" description:"Display version information and exit"`
 	config.NetworkFlags
 }
 
@@ -45,24 +52,43 @@ type createConfig struct {
 }
 
 type balanceConfig struct {
-	DaemonAddress string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
+	DaemonAddress string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to"`
 	Verbose       bool   `long:"verbose" short:"v" description:"Verbose: show addresses with balance"`
 	config.NetworkFlags
 }
 
 type sendConfig struct {
-	KeysFile      string  `long:"keys-file" short:"f" description:"Keys file location (default: ~/.kaspawallet/keys.json (*nix), %USERPROFILE%\\AppData\\Local\\Kaspawallet\\key.json (Windows))"`
+	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"`
+	Password                 string   `long:"password" short:"p" description:"Wallet password"`
-	DaemonAddress string  `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
+	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"`
+	ToAddress                string   `long:"to-address" short:"t" description:"The public address to send Kaspa to" required:"true"`
-	SendAmount    float64 `long:"send-amount" short:"v" description:"An amount to send in Kaspa (e.g. 1234.12345678)" 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"`
+	config.NetworkFlags
+}
+
+type sweepConfig struct {
+	PrivateKey    string `long:"private-key" short:"k" description:"Private key in hex format"`
+	DaemonAddress string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to"`
 	config.NetworkFlags
 }
 
 type createUnsignedTransactionConfig struct {
-	DaemonAddress string  `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
+	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"`
+	ToAddress                string   `long:"to-address" short:"t" description:"The public address to send Kaspa to" required:"true"`
-	SendAmount    float64 `long:"send-amount" short:"v" description:"An amount to send in Kaspa (e.g. 1234.12345678)" 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"`
 	config.NetworkFlags
 }
 
@@ -75,13 +101,14 @@ type signConfig struct {
 }
 
 type broadcastConfig struct {
-	DaemonAddress    string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
+	DaemonAddress    string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to"`
 	Transactions     string `long:"transaction" short:"t" description:"The signed transaction to broadcast (encoded in hex)"`
 	TransactionsFile string `long:"transaction-file" short:"F" description:"The file containing the unsigned transaction to sign on (encoded in hex)"`
 	config.NetworkFlags
 }
 
 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"`
@@ -89,12 +116,12 @@ type parseConfig struct {
 }
 
 type showAddressesConfig struct {
-	DaemonAddress string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
+	DaemonAddress string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to"`
 	config.NetworkFlags
 }
 
 type newAddressConfig struct {
-	DaemonAddress string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to (default: localhost:8082)"`
+	DaemonAddress string `long:"daemonaddress" short:"d" description:"Wallet daemon server to connect to"`
 	config.NetworkFlags
 }
 
@@ -102,7 +129,8 @@ 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 `short:"l" long:"listen" description:"Address to listen on (default: 0.0.0.0:8082)"`
+	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)"`
 	Profile   string `long:"profile" description:"Enable HTTP profiling on given port -- NOTE port must be between 1024 and 65536"`
 	config.NetworkFlags
 }
@@ -114,6 +142,38 @@ 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)
@@ -130,6 +190,12 @@ func parseCommandLine() (subCommand string, config interface{}) {
 	parser.AddCommand(sendSubCmd, "Sends a Kaspa transaction to a public address",
 		"Sends a Kaspa transaction to a public address", sendConf)
 
+	sweepConf := &sweepConfig{DaemonAddress: defaultListen}
+	parser.AddCommand(sweepSubCmd, "Sends all funds associated with the given schnorr private key to a new address of the current wallet",
+		"Sends all funds associated with the given schnorr private key to a newly created external (i.e. not a change) address of the "+
+			"keyfile that is under the daemon's contol. Can be used with a private key generated with the genkeypair utilily "+
+			"to send funds to your main wallet.", sweepConf)
+
 	createUnsignedTransactionConf := &createUnsignedTransactionConfig{DaemonAddress: defaultListen}
 	parser.AddCommand(createUnsignedTransactionSubCmd, "Create an unsigned Kaspa transaction",
 		"Create an unsigned Kaspa transaction", createUnsignedTransactionConf)
@@ -164,9 +230,17 @@ 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 {
@@ -198,13 +272,28 @@ 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)
+		err := sweepConf.ResolveNetwork(parser)
+		if err != nil {
+			printErrorAndExit(err)
+		}
+		config = sweepConf
 	case createUnsignedTransactionSubCmd:
 		combineNetworkFlags(&createUnsignedTransactionConf.NetworkFlags, &cfg.NetworkFlags)
 		err := createUnsignedTransactionConf.ResolveNetwork(parser)
 		if err != nil {
 			printErrorAndExit(err)
 		}
+		err = validateCreateUnsignedTransactionConf(createUnsignedTransactionConf)
+		if err != nil {
+			printErrorAndExit(err)
+		}
 		config = createUnsignedTransactionConf
 	case signSubCmd:
 		combineNetworkFlags(&signConf.NetworkFlags, &cfg.NetworkFlags)
@@ -220,6 +309,13 @@ 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)
@@ -255,11 +351,123 @@ 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

cmd/kaspawallet/create.go

@@ -3,11 +3,12 @@ package main
 import (
 	"bufio"
 	"fmt"
+	"os"
+
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet/bip32"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/utils"
 	"github.com/pkg/errors"
-	"os"
 
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/keys"
 )
@@ -30,6 +31,10 @@ func create(conf *createConfig) error {
 		fmt.Printf("Extended public key of mnemonic #%d:\n%s\n\n", i+1, extendedPublicKey)
 	}
 
+	fmt.Printf("Notice the above is neither a secret key to your wallet " +
+		"(use \"kaspawallet dump-unencrypted-data\" to see a secret seed phrase) " +
+		"nor a wallet public address (use \"kaspawallet new-address\" to create and see one)\n\n")
+
 	extendedPublicKeys := make([]string, conf.NumPrivateKeys, conf.NumPublicKeys)
 	copy(extendedPublicKeys, signerExtendedPublicKeys)
 	reader := bufio.NewReader(os.Stdin)
@@ -50,9 +55,13 @@ func create(conf *createConfig) error {
 		extendedPublicKeys = append(extendedPublicKeys, string(extendedPublicKey))
 	}
 
-	cosignerIndex, err := libkaspawallet.MinimumCosignerIndex(signerExtendedPublicKeys, extendedPublicKeys)
+	// For a read only wallet the cosigner index is 0
-	if err != nil {
+	cosignerIndex := uint32(0)
-		return err
+	if len(signerExtendedPublicKeys) > 0 {
+		cosignerIndex, err = libkaspawallet.MinimumCosignerIndex(signerExtendedPublicKeys, extendedPublicKeys)
+		if err != nil {
+			return err
+		}
 	}
 
 	file := keys.File{
@@ -69,6 +78,11 @@ func create(conf *createConfig) error {
 		return err
 	}
 
+	err = file.TryLock()
+	if err != nil {
+		return err
+	}
+
 	err = file.Save()
 	if err != nil {
 		return err

cmd/kaspawallet/create_unsigned_tx.go

@@ -3,10 +3,12 @@ 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/domain/consensus/utils/constants"
+	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/server"
+	"github.com/kaspanet/kaspad/cmd/kaspawallet/utils"
 )
 
 func createUnsignedTransaction(conf *createUnsignedTransactionConfig) error {
@@ -19,16 +21,46 @@ func createUnsignedTransaction(conf *createUnsignedTransactionConfig) error {
 	ctx, cancel := context.WithTimeout(context.Background(), daemonTimeout)
 	defer cancel()
 
-	sendAmountSompi := uint64(conf.SendAmount * constants.SompiPerKaspa)
+	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},
+		}
+	}
+
 	response, err := daemonClient.CreateUnsignedTransactions(ctx, &pb.CreateUnsignedTransactionsRequest{
-		Address: conf.ToAddress,
+		From:                     conf.FromAddresses,
-		Amount:  sendAmountSompi,
+		Address:                  conf.ToAddress,
+		Amount:                   sendAmountSompi,
+		IsSendAll:                conf.IsSendAll,
+		UseExistingChangeAddress: conf.UseExistingChangeAddress,
+		FeePolicy:                feePolicy,
 	})
 	if err != nil {
 		return err
 	}
 
-	fmt.Println("Created unsigned transaction")
+	fmt.Fprintln(os.Stderr, "Created unsigned transaction")
-	fmt.Println(encodeTransactionsToHex(response.UnsignedTransactions))
+	fmt.Println(server.EncodeTransactionsToHex(response.UnsignedTransactions))
+
 	return nil
 }

cmd/kaspawallet/daemon/client/client.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"time"
 
+	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/server"
+
 	"github.com/pkg/errors"
 
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
@@ -16,7 +18,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())
+	conn, err := grpc.DialContext(ctx, address, grpc.WithInsecure(), grpc.WithBlock(), grpc.WithDefaultCallOptions(grpc.MaxCallRecvMsgSize(server.MaxDaemonSendMsgSize)))
 	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`")

cmd/kaspawallet/daemon/pb/kaspawalletd.proto

@@ -4,16 +4,28 @@ option go_package = "github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb";
 package kaspawalletd;
 
 service kaspawalletd {
-  rpc GetBalance (GetBalanceRequest) returns (GetBalanceResponse) {}
+  rpc GetBalance(GetBalanceRequest) returns (GetBalanceResponse) {}
-  rpc CreateUnsignedTransactions (CreateUnsignedTransactionsRequest) returns (CreateUnsignedTransactionsResponse) {}
+  rpc GetExternalSpendableUTXOs(GetExternalSpendableUTXOsRequest)
-  rpc ShowAddresses (ShowAddressesRequest) returns (ShowAddressesResponse) {}
+      returns (GetExternalSpendableUTXOsResponse) {}
-  rpc NewAddress (NewAddressRequest) returns (NewAddressResponse) {}
+  rpc CreateUnsignedTransactions(CreateUnsignedTransactionsRequest)
-  rpc Shutdown (ShutdownRequest) returns (ShutdownResponse) {}
+      returns (CreateUnsignedTransactionsResponse) {}
-  rpc Broadcast (BroadcastRequest) returns (BroadcastResponse) {}
+  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
+  rpc Send(SendRequest) returns (SendResponse) {}
+  // 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;
@@ -22,44 +34,118 @@ message GetBalanceResponse {
 }
 
 message AddressBalances {
-    string address = 1;
+  string address = 1;
-    uint64 available = 2;
+  uint64 available = 2;
-    uint64 pending = 3;
+  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 {
+message ShowAddressesResponse { repeated string address = 1; }
-  repeated string address = 1;
-}
 
-message NewAddressRequest {
+message NewAddressRequest {}
-}
 
-message NewAddressResponse {
+message NewAddressResponse { string address = 1; }
-  string address = 1;
-}
 
 message BroadcastRequest {
-  bytes transaction = 1;
+  bool isDomain = 1;
+  repeated bytes transactions = 2;
 }
 
-message BroadcastResponse {
+message BroadcastResponse { repeated string txIDs = 1; }
-  string txID = 1;
+
+message ShutdownRequest {}
+
+message ShutdownResponse {}
+
+message Outpoint {
+  string transactionId = 1;
+  uint32 index = 2;
 }
 
-message ShutdownRequest {
+message UtxosByAddressesEntry {
+  string address = 1;
+  Outpoint outpoint = 2;
+  UtxoEntry utxoEntry = 3;
 }
 
-message ShutdownResponse {
+message ScriptPublicKey {
+  uint32 version = 1;
+  string scriptPublicKey = 2;
+}
+
+message UtxoEntry {
+  uint64 amount = 1;
+  ScriptPublicKey scriptPublicKey = 2;
+  uint64 blockDaaScore = 3;
+  bool isCoinbase = 4;
+}
+
+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
+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
+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;
 }

cmd/kaspawallet/daemon/pb/kaspawalletd_grpc.pb.go

@@ -1,4 +1,8 @@
 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
+// versions:
+// - protoc-gen-go-grpc v1.2.0
+// - protoc             v3.12.3
+// source: kaspawalletd.proto
 
 package pb
 
@@ -19,11 +23,22 @@ const _ = grpc.SupportPackageIsVersion7
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
 type KaspawalletdClient interface {
 	GetBalance(ctx context.Context, in *GetBalanceRequest, opts ...grpc.CallOption) (*GetBalanceResponse, error)
+	GetExternalSpendableUTXOs(ctx context.Context, in *GetExternalSpendableUTXOsRequest, opts ...grpc.CallOption) (*GetExternalSpendableUTXOsResponse, error)
 	CreateUnsignedTransactions(ctx context.Context, in *CreateUnsignedTransactionsRequest, opts ...grpc.CallOption) (*CreateUnsignedTransactionsResponse, error)
 	ShowAddresses(ctx context.Context, in *ShowAddressesRequest, opts ...grpc.CallOption) (*ShowAddressesResponse, error)
 	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
+	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
+	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 {
@@ -43,6 +58,15 @@ func (c *kaspawalletdClient) GetBalance(ctx context.Context, in *GetBalanceReque
 	return out, nil
 }
 
+func (c *kaspawalletdClient) GetExternalSpendableUTXOs(ctx context.Context, in *GetExternalSpendableUTXOsRequest, opts ...grpc.CallOption) (*GetExternalSpendableUTXOsResponse, error) {
+	out := new(GetExternalSpendableUTXOsResponse)
+	err := c.cc.Invoke(ctx, "/kaspawalletd.kaspawalletd/GetExternalSpendableUTXOs", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *kaspawalletdClient) CreateUnsignedTransactions(ctx context.Context, in *CreateUnsignedTransactionsRequest, opts ...grpc.CallOption) (*CreateUnsignedTransactionsResponse, error) {
 	out := new(CreateUnsignedTransactionsResponse)
 	err := c.cc.Invoke(ctx, "/kaspawalletd.kaspawalletd/CreateUnsignedTransactions", in, out, opts...)
@@ -88,16 +112,72 @@ 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...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *kaspawalletdClient) Sign(ctx context.Context, in *SignRequest, opts ...grpc.CallOption) (*SignResponse, error) {
+	out := new(SignResponse)
+	err := c.cc.Invoke(ctx, "/kaspawalletd.kaspawalletd/Sign", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	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
 type KaspawalletdServer interface {
 	GetBalance(context.Context, *GetBalanceRequest) (*GetBalanceResponse, error)
+	GetExternalSpendableUTXOs(context.Context, *GetExternalSpendableUTXOsRequest) (*GetExternalSpendableUTXOsResponse, error)
 	CreateUnsignedTransactions(context.Context, *CreateUnsignedTransactionsRequest) (*CreateUnsignedTransactionsResponse, error)
 	ShowAddresses(context.Context, *ShowAddressesRequest) (*ShowAddressesResponse, error)
 	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
+	Send(context.Context, *SendRequest) (*SendResponse, error)
+	// 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()
 }
 
@@ -108,6 +188,9 @@ type UnimplementedKaspawalletdServer struct {
 func (UnimplementedKaspawalletdServer) GetBalance(context.Context, *GetBalanceRequest) (*GetBalanceResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method GetBalance not implemented")
 }
+func (UnimplementedKaspawalletdServer) GetExternalSpendableUTXOs(context.Context, *GetExternalSpendableUTXOsRequest) (*GetExternalSpendableUTXOsResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetExternalSpendableUTXOs not implemented")
+}
 func (UnimplementedKaspawalletdServer) CreateUnsignedTransactions(context.Context, *CreateUnsignedTransactionsRequest) (*CreateUnsignedTransactionsResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method CreateUnsignedTransactions not implemented")
 }
@@ -123,6 +206,21 @@ 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.
@@ -154,6 +252,24 @@ func _Kaspawalletd_GetBalance_Handler(srv interface{}, ctx context.Context, dec
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Kaspawalletd_GetExternalSpendableUTXOs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetExternalSpendableUTXOsRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(KaspawalletdServer).GetExternalSpendableUTXOs(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/kaspawalletd.kaspawalletd/GetExternalSpendableUTXOs",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(KaspawalletdServer).GetExternalSpendableUTXOs(ctx, req.(*GetExternalSpendableUTXOsRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _Kaspawalletd_CreateUnsignedTransactions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(CreateUnsignedTransactionsRequest)
 	if err := dec(in); err != nil {
@@ -244,6 +360,96 @@ 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 {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(KaspawalletdServer).Send(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/kaspawalletd.kaspawalletd/Send",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(KaspawalletdServer).Send(ctx, req.(*SendRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Kaspawalletd_Sign_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(SignRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(KaspawalletdServer).Sign(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/kaspawalletd.kaspawalletd/Sign",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(KaspawalletdServer).Sign(ctx, req.(*SignRequest))
+	}
+	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)
@@ -255,6 +461,10 @@ var Kaspawalletd_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "GetBalance",
 			Handler:    _Kaspawalletd_GetBalance_Handler,
 		},
+		{
+			MethodName: "GetExternalSpendableUTXOs",
+			Handler:    _Kaspawalletd_GetExternalSpendableUTXOs_Handler,
+		},
 		{
 			MethodName: "CreateUnsignedTransactions",
 			Handler:    _Kaspawalletd_CreateUnsignedTransactions_Handler,
@@ -275,6 +485,26 @@ var Kaspawalletd_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "Broadcast",
 			Handler:    _Kaspawalletd_Broadcast_Handler,
 		},
+		{
+			MethodName: "BroadcastReplacement",
+			Handler:    _Kaspawalletd_BroadcastReplacement_Handler,
+		},
+		{
+			MethodName: "Send",
+			Handler:    _Kaspawalletd_Send_Handler,
+		},
+		{
+			MethodName: "Sign",
+			Handler:    _Kaspawalletd_Sign_Handler,
+		},
+		{
+			MethodName: "GetVersion",
+			Handler:    _Kaspawalletd_GetVersion_Handler,
+		},
+		{
+			MethodName: "BumpFee",
+			Handler:    _Kaspawalletd_BumpFee_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "kaspawalletd.proto",

cmd/kaspawallet/daemon/server/address.go

@@ -10,22 +10,33 @@ import (
 	"github.com/pkg/errors"
 )
 
-func (s *server) changeAddress() (util.Address, *walletAddress, error) {
+func (s *server) changeAddress(useExisting bool, fromAddresses []*walletAddress) (util.Address, *walletAddress, error) {
-	err := s.keysFile.SetLastUsedInternalIndex(s.keysFile.LastUsedInternalIndex() + 1)
+	var walletAddr *walletAddress
-	if err != nil {
+	if len(fromAddresses) != 0 && useExisting {
-		return nil, nil, err
+		walletAddr = fromAddresses[0]
+	} else {
+		internalIndex := uint32(0)
+		if !useExisting {
+			err := s.keysFile.SetLastUsedInternalIndex(s.keysFile.LastUsedInternalIndex() + 1)
+			if err != nil {
+				return nil, nil, err
+			}
+
+			err = s.keysFile.Save()
+			if err != nil {
+				return nil, nil, err
+			}
+
+			internalIndex = s.keysFile.LastUsedInternalIndex()
+		}
+
+		walletAddr = &walletAddress{
+			index:         internalIndex,
+			cosignerIndex: s.keysFile.CosignerIndex,
+			keyChain:      libkaspawallet.InternalKeychain,
+		}
 	}
 
-	err = s.keysFile.Save()
-	if err != nil {
-		return nil, nil, err
-	}
-
-	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 {
@@ -39,10 +50,10 @@ func (s *server) ShowAddresses(_ context.Context, request *pb.ShowAddressesReque
 	defer s.lock.Unlock()
 
 	if !s.isSynced() {
-		return nil, errors.New("server is not synced")
+		return nil, errors.Errorf("wallet daemon is not synced yet, %s", s.formatSyncStateReport())
 	}
 
-	addresses := make([]string, 0)
+	addresses := make([]string, s.keysFile.LastUsedExternalIndex())
 	for i := uint32(1); i <= s.keysFile.LastUsedExternalIndex(); i++ {
 		walletAddr := &walletAddress{
 			index:         i,
@@ -54,7 +65,7 @@ func (s *server) ShowAddresses(_ context.Context, request *pb.ShowAddressesReque
 		if err != nil {
 			return nil, err
 		}
-		addresses = append(addresses, address.String())
+		addresses[i-1] = address.String()
 	}
 
 	return &pb.ShowAddressesResponse{Address: addresses}, nil
@@ -65,7 +76,7 @@ func (s *server) NewAddress(_ context.Context, request *pb.NewAddressRequest) (*
 	defer s.lock.Unlock()
 
 	if !s.isSynced() {
-		return nil, errors.New("server is not synced")
+		return nil, errors.Errorf("wallet daemon is not synced yet, %s", s.formatSyncStateReport())
 	}
 
 	err := s.keysFile.SetLastUsedExternalIndex(s.keysFile.LastUsedExternalIndex() + 1)

cmd/kaspawallet/daemon/server/balance.go

@@ -2,6 +2,7 @@ package server
 
 import (
 	"context"
+	"github.com/pkg/errors"
 
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/daemon/pb"
 	"github.com/kaspanet/kaspad/cmd/kaspawallet/libkaspawallet"
@@ -14,13 +15,15 @@ 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()
@@ -30,7 +33,7 @@ func (s *server) GetBalance(_ context.Context, _ *pb.GetBalanceRequest) (*pb.Get
 			balances = new(balancesType)
 			balancesMap[address] = balances
 		}
-		if isUTXOSpendable(entry, daaScore, maturity) {
+		if s.isUTXOSpendable(entry, daaScore) {
 			balances.available += amount
 		} else {
 			balances.pending += amount
@@ -55,6 +58,8 @@ 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,
@@ -62,9 +67,9 @@ func (s *server) GetBalance(_ context.Context, _ *pb.GetBalanceRequest) (*pb.Get
 	}, nil
 }
 
-func isUTXOSpendable(entry *walletUTXO, virtualDAAScore uint64, coinbaseMaturity uint64) bool {
+func (s *server) isUTXOSpendable(entry *walletUTXO, virtualDAAScore uint64) bool {
 	if !entry.UTXOEntry.IsCoinbase() {
 		return true
 	}
-	return entry.UTXOEntry.BlockDAAScore()+coinbaseMaturity < virtualDAAScore
+	return entry.UTXOEntry.BlockDAAScore()+s.coinbaseMaturity < virtualDAAScore
 }

cmd/kaspawallet/daemon/server/broadcast.go

@@ -2,31 +2,66 @@ 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) Broadcast(_ context.Context, request *pb.BroadcastRequest) (*pb.BroadcastResponse, error) {
-	tx, err := libkaspawallet.ExtractTransaction(request.Transaction, s.keysFile.ECDSA)
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	txIDs, err := s.broadcast(request.Transactions, request.IsDomain)
 	if err != nil {
 		return nil, err
 	}
 
-	txID, err := sendTransaction(s.rpcClient, tx)
+	return &pb.BroadcastResponse{TxIDs: txIDs}, nil
-	if err != nil {
+}
-		return nil, err
+
+func (s *server) broadcast(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
+			}
+		}
+
+		txIDs[i], err = sendTransaction(s.rpcClient, tx)
+		if err != nil {
+			return nil, err
+		}
+
+		for _, input := range tx.Inputs {
+			s.usedOutpoints[input.PreviousOutpoint] = time.Now()
+		}
 	}
 
-	return &pb.BroadcastResponse{TxID: txID}, nil
+	s.forceSync()
+	return txIDs, nil
 }
 
 func sendTransaction(client *rpcclient.RPCClient, tx *externalapi.DomainTransaction) (string, error) {
-	submitTransactionResponse, err := client.SubmitTransaction(appmessage.DomainTransactionToRPCTransaction(tx), false)
+	submitTransactionResponse, err := client.SubmitTransaction(appmessage.DomainTransactionToRPCTransaction(tx), consensushashing.TransactionID(tx).String(), false)
 	if err != nil {
 		return "", errors.Wrapf(err, "error submitting transaction")
 	}

cmd/kaspawallet/daemon/server/broadcast_replacement.go

@@ -0,0 +1,81 @@
+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
+}

cmd/kaspawallet/daemon/server/bump_fee.go

@@ -0,0 +1,156 @@
+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
+}

cmd/kaspawallet/daemon/server/create_unsigned_transaction.go

@@ -2,60 +2,37 @@ 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"
 )
 
-// TODO: Implement a better fee estimation mechanism
+// The minimal change amount to target in order to avoid large storage mass (see KIP9 for more details).
-const feePerInput = 10000
+// 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
 
 func (s *server) CreateUnsignedTransactions(_ context.Context, request *pb.CreateUnsignedTransactionsRequest) (
-	*pb.CreateUnsignedTransactionsResponse, error) {
+	*pb.CreateUnsignedTransactionsResponse, error,
+) {
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
-	if !s.isSynced() {
+	unsignedTransactions, err := s.createUnsignedTransactions(request.Address, request.Amount, request.IsSendAll,
-		return nil, errors.New("server is not synced")
+		request.From, request.UseExistingChangeAddress, request.FeePolicy)
-	}
-
-	err := s.refreshUTXOs()
-	if err != nil {
-		return nil, err
-	}
-
-	toAddress, err := util.DecodeAddress(request.Address, s.params.Prefix)
-	if err != nil {
-		return nil, err
-	}
-
-	selectedUTXOs, changeSompi, err := s.selectUTXOs(request.Amount, feePerInput)
-	if err != nil {
-		return nil, err
-	}
-
-	changeAddress, changeWalletAddress, err := s.changeAddress()
-	if err != nil {
-		return nil, err
-	}
-
-	unsignedTransaction, err := libkaspawallet.CreateUnsignedTransaction(s.keysFile.ExtendedPublicKeys,
-		s.keysFile.MinimumSignatures,
-		[]*libkaspawallet.Payment{{
-			Address: toAddress,
-			Amount:  request.Amount,
-		}, {
-			Address: changeAddress,
-			Amount:  changeSompi,
-		}}, selectedUTXOs)
-	if err != nil {
-		return nil, err
-	}
-
-	unsignedTransactions, err := s.maybeAutoCompoundTransaction(unsignedTransaction, toAddress, changeAddress, changeWalletAddress)
 	if err != nil {
 		return nil, err
 	}
@@ -63,20 +40,153 @@ func (s *server) CreateUnsignedTransactions(_ context.Context, request *pb.Creat
 	return &pb.CreateUnsignedTransactionsResponse{UnsignedTransactions: unsignedTransactions}, nil
 }
 
-func (s *server) selectUTXOs(spendAmount uint64, feePerInput uint64) (
+func (s *server) calculateFeeLimits(requestFeePolicy *pb.FeePolicy) (feeRate float64, maxFee uint64, err error) {
-	selectedUTXOs []*libkaspawallet.UTXO, changeSompi uint64, err error) {
+	feeRate = minFeeRate
+	maxFee = math.MaxUint64
 
-	selectedUTXOs = []*libkaspawallet.UTXO{}
+	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) {
+	if !s.isSynced() {
+		return nil, errors.Errorf("wallet daemon is not synced yet, %s", s.formatSyncStateReport())
+	}
+
+	feeRate, maxFee, err := s.calculateFeeLimits(requestFeePolicy)
+	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
+	}
+
+	var fromAddresses []*walletAddress
+	for _, from := range fromAddressesString {
+		fromAddress, exists := s.addressSet[from]
+		if !exists {
+			return nil, fmt.Errorf("specified from address %s does not exists", from)
+		}
+		fromAddresses = append(fromAddresses, fromAddress)
+	}
+
+	changeAddress, changeWalletAddress, err := s.changeAddress(useExistingChangeAddress, fromAddresses)
+	if err != nil {
+		return nil, err
+	}
+
+	selectedUTXOs, spendValue, changeSompi, err := s.selectUTXOs(amount, isSendAll, feeRate, maxFee, 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 {
+		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, feeRate, maxFee)
+	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) 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{}{}
+	}
 	totalValue := uint64(0)
 
 	dagInfo, err := s.rpcClient.GetBlockDAGInfo()
 	if err != nil {
-		return nil, 0, err
+		return nil, 0, 0, err
 	}
 
-	for _, utxo := range s.utxosSortedByAmount {
+	var fee uint64
-		if !isUTXOSpendable(utxo, dagInfo.VirtualDAAScore, s.params.BlockCoinbaseMaturity) {
+	iteration := func(utxo *walletUTXO, avoidPreselected bool) (bool, error) {
-			continue
+		if (fromAddresses != nil && !walletAddressesContain(fromAddresses, utxo.address)) ||
+			!s.isUTXOSpendable(utxo, dagInfo.VirtualDAAScore) {
+			return true, nil
+		}
+
+		if broadcastTime, ok := s.usedOutpoints[*utxo.Outpoint]; ok {
+			if _, ok := allowUsed[*utxo.Outpoint]; !ok {
+				if s.usedOutpointHasExpired(broadcastTime) {
+					delete(s.usedOutpoints, *utxo.Outpoint)
+				} else {
+					return true, nil
+				}
+			}
+		}
+
+		if avoidPreselected {
+			if _, ok := preSelectedSet[*utxo.Outpoint]; ok {
+				return true, nil
+			}
 		}
 
 		selectedUTXOs = append(selectedUTXOs, &libkaspawallet.UTXO{
@@ -84,21 +194,171 @@ func (s *server) selectUTXOs(spendAmount uint64, feePerInput uint64) (
 			UTXOEntry:      utxo.UTXOEntry,
 			DerivationPath: s.walletAddressPath(utxo.address),
 		})
-		totalValue += utxo.UTXOEntry.Amount()
 
-		fee := feePerInput * uint64(len(selectedUTXOs))
+		totalValue += utxo.UTXOEntry.Amount()
+		estimatedRecipientValue := spendAmount
+		if isSendAll {
+			estimatedRecipientValue = totalValue
+		}
+
+		fee, err = s.estimateFee(selectedUTXOs, feeRate, maxFee, estimatedRecipientValue)
+		if err != nil {
+			return false, err
+		}
+
 		totalSpend := spendAmount + fee
-		if totalValue >= totalSpend {
+		// 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 {
 			break
 		}
 	}
 
-	fee := feePerInput * uint64(len(selectedUTXOs))
+	if shouldContinue {
-	totalSpend := spendAmount + fee
+		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
+	}
 	if totalValue < totalSpend {
-		return nil, 0, errors.Errorf("Insufficient funds for send: %f required, while only %f available",
+		return nil, 0, 0, errors.Errorf("Insufficient funds for send: %f required, while only %f available",
 			float64(totalSpend)/constants.SompiPerKaspa, float64(totalValue)/constants.SompiPerKaspa)
 	}
 
-	return selectedUTXOs, totalValue - totalSpend, nil
+	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
 }

cmd/kaspawallet/daemon/server/external_spendable_utxos.go

@@ -0,0 +1,75 @@
+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/util"
+)
+
+func (s *server) GetExternalSpendableUTXOs(_ context.Context, request *pb.GetExternalSpendableUTXOsRequest) (*pb.GetExternalSpendableUTXOsResponse, error) {
+	s.lock.RLock()
+	defer s.lock.RUnlock()
+
+	_, err := util.DecodeAddress(request.Address, s.params.Prefix)
+	if err != nil {
+		return nil, err
+	}
+	externalUTXOs, err := s.rpcClient.GetUTXOsByAddresses([]string{request.Address})
+	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)
+	if err != nil {
+		return nil, err
+	}
+	return &pb.GetExternalSpendableUTXOsResponse{
+		Entries: selectedUTXOs,
+	}, nil
+}
+
+func (s *server) selectExternalSpendableUTXOs(externalUTXOs *appmessage.GetUTXOsByAddressesResponseMessage, feeRate float64) ([]*pb.UtxosByAddressesEntry, error) {
+	dagInfo, err := s.rpcClient.GetBlockDAGInfo()
+	if err != nil {
+		return nil, err
+	}
+
+	daaScore := dagInfo.VirtualDAAScore
+	maturity := s.params.BlockCoinbaseMaturity
+
+	//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) {
+			continue
+		}
+		selectedExternalUtxos = append(selectedExternalUtxos, libkaspawallet.AppMessageUTXOToKaspawalletdUTXO(entry))
+	}
+
+	return selectedExternalUtxos, nil
+}
+
+func isExternalUTXOSpendable(entry *appmessage.UTXOsByAddressesEntry, virtualDAAScore uint64, coinbaseMaturity uint64, feePerInput uint64) bool {
+	if !entry.UTXOEntry.IsCoinbase {
+		return true
+	} else if entry.UTXOEntry.Amount <= feePerInput {
+		return false
+	}
+	return entry.UTXOEntry.BlockDAAScore+coinbaseMaturity < virtualDAAScore
+}

cmd/kaspawallet/daemon/server/rpc.go

@@ -1,15 +1,26 @@
 package server
 
 import (
+	"time"
+
 	"github.com/kaspanet/kaspad/domain/dagconfig"
 	"github.com/kaspanet/kaspad/infrastructure/network/rpcclient"
 )
 
-func connectToRPC(params *dagconfig.Params, rpcServer string) (*rpcclient.RPCClient, error) {
+func connectToRPC(params *dagconfig.Params, rpcServer string, timeout uint32) (*rpcclient.RPCClient, error) {
 	rpcAddress, err := params.NormalizeRPCServerAddress(rpcServer)
 	if err != nil {
 		return nil, err
 	}
 
-	return rpcclient.NewRPCClient(rpcAddress)
+	rpcClient, err := rpcclient.NewRPCClient(rpcAddress)
+	if err != nil {
+		return nil, err
+	}
+
+	if timeout != 0 {
+		rpcClient.SetTimeout(time.Duration(timeout) * time.Second)
+	}
+
+	return rpcClient, err
 }

cmd/kaspawallet/daemon/server/send.go

@@ -0,0 +1,32 @@
+package server
+
+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)
+
+	if err != nil {
+		return nil, err
+	}
+
+	signedTransactions, err := s.signTransactions(unsignedTransactions, request.Password)
+	if err != nil {
+		return nil, err
+	}
+
+	txIDs, err := s.broadcast(signedTransactions, false)
+	if err != nil {
+		return nil, errors.Wrapf(err, "error broadcasting transactions %s", EncodeTransactionsToHex(signedTransactions))
+	}
+
+	return &pb.SendResponse{TxIDs: txIDs, SignedTransactions: signedTransactions}, nil
+}

cmd/kaspawallet/daemon/server/server.go

@@ -5,8 +5,13 @@ 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"
 
 	"github.com/kaspanet/kaspad/util/profiling"
@@ -25,20 +30,35 @@ import (
 type server struct {
 	pb.UnimplementedKaspawalletdServer
 
-	rpcClient *rpcclient.RPCClient
+	rpcClient           *rpcclient.RPCClient // RPC client for ongoing user requests
-	params    *dagconfig.Params
+	backgroundRPCClient *rpcclient.RPCClient // RPC client dedicated for address and UTXO background fetching
+	params              *dagconfig.Params
+	coinbaseMaturity    uint64 // Different from go-kaspad default following Crescendo
 
-	lock                sync.RWMutex
+	lock                            sync.RWMutex
-	utxosSortedByAmount []*walletUTXO
+	utxosSortedByAmount             []*walletUTXO
-	nextSyncStartIndex  uint32
+	mempoolExcludedUTXOs            map[externalapi.DomainOutpoint]*walletUTXO
-	keysFile            *keys.File
+	nextSyncStartIndex              uint32
-	shutdown            chan struct{}
+	keysFile                        *keys.File
-	addressSet          walletAddressSet
+	shutdown                        chan struct{}
-	txMassCalculator    *txmass.Calculator
+	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) error {
+func Start(params *dagconfig.Params, listen, rpcServer string, keysFilePath string, profile string, timeout uint32) error {
 	initLog(defaultLogFile, defaultErrLogFile)
 
 	defer panics.HandlePanic(log, "MAIN", nil)
@@ -48,41 +68,65 @@ 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 at %s", listen))
+		return (errors.Wrapf(err, "Error listening to TCP on %s", listen))
 	}
-	log.Infof("Listening on %s", listen)
+	log.Infof("Listening to TCP on %s", listen)
 
-	rpcClient, err := connectToRPC(params, rpcServer)
+	log.Infof("Connecting to a node at %s...", rpcServer)
+	rpcClient, err := connectToRPC(params, rpcServer, timeout)
 	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)
 	if err != nil {
-		return (errors.Wrapf(err, "Error connecting to RPC server %s", rpcServer))
+		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,
+		rpcClient:                   rpcClient,
-		params:              params,
+		backgroundRPCClient:         backgroundRPCClient,
-		utxosSortedByAmount: []*walletUTXO{},
+		params:                      params,
-		nextSyncStartIndex:  0,
+		coinbaseMaturity:            coinbaseMaturity,
-		keysFile:            keysFile,
+		utxosSortedByAmount:         []*walletUTXO{},
-		shutdown:            make(chan struct{}),
+		mempoolExcludedUTXOs:        map[externalapi.DomainOutpoint]*walletUTXO{},
-		addressSet:          make(walletAddressSet),
+		nextSyncStartIndex:          0,
-		txMassCalculator:    txmass.NewCalculator(params.MassPerTxByte, params.MassPerScriptPubKeyByte, params.MassPerSigOp),
+		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{},
+		isLogFinalProgressLineShown: false,
+		maxUsedAddressesForLog:      0,
+		maxProcessedAddressesForLog: 0,
 	}
 
-	spawn("serverInstance.sync", func() {
+	log.Infof("Read, syncing the wallet...")
-		err := serverInstance.sync()
+	spawn("serverInstance.syncLoop", func() {
+		err := serverInstance.syncLoop()
 		if err != nil {
 			printErrorAndExit(errors.Wrap(err, "error syncing the wallet"))
 		}
 	})
 
-	grpcServer := grpc.NewServer()
+	grpcServer := grpc.NewServer(grpc.MaxSendMsgSize(MaxDaemonSendMsgSize))
 	pb.RegisterKaspawalletdServer(grpcServer, serverInstance)
 
 	spawn("grpcServer.Serve", func() {