feat!: state sync

.mockery.yaml

@@ -53,6 +53,7 @@ packages:
   github.com/dashpay/tenderdash/internal/statesync:
     interfaces:
       StateProvider:
+      ConsensusStateProvider:
   github.com/dashpay/tenderdash/libs/store:
     interfaces:
       Store:

abci/client/grpc_client.go

@@ -255,6 +255,10 @@ func (cli *grpcClient) ApplySnapshotChunk(ctx context.Context, params *types.Req
 	return cli.client.ApplySnapshotChunk(ctx, types.ToRequestApplySnapshotChunk(params).GetApplySnapshotChunk(), grpc.WaitForReady(true))
 }
 
+func (cli *grpcClient) FinalizeSnapshot(ctx context.Context, params *types.RequestFinalizeSnapshot) (*types.ResponseFinalizeSnapshot, error) {
+	return cli.client.FinalizeSnapshot(ctx, types.ToRequestFinalizeSnapshot(params).GetFinalizeSnapshot(), grpc.WaitForReady(true))
+}
+
 func (cli *grpcClient) PrepareProposal(ctx context.Context, params *types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error) {
 	return cli.client.PrepareProposal(ctx, types.ToRequestPrepareProposal(params).GetPrepareProposal(), grpc.WaitForReady(true))
 }

abci/client/routed_client.go

@@ -351,6 +351,11 @@ func (cli *routedClient) ApplySnapshotChunk(ctx context.Context, req *types.Requ
 	return result.(*types.ResponseApplySnapshotChunk), err
 }
 
+func (cli *routedClient) FinalizeSnapshot(ctx context.Context, req *types.RequestFinalizeSnapshot) (*types.ResponseFinalizeSnapshot, error) {
+	result, err := cli.delegate(ctx, req)
+	return result.(*types.ResponseFinalizeSnapshot), err
+}
+
 func (cli *routedClient) PrepareProposal(ctx context.Context, req *types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error) {
 	result, err := cli.delegate(ctx, req)
 	return result.(*types.ResponsePrepareProposal), err

abci/client/socket_client.go

@@ -357,6 +357,14 @@ func (cli *socketClient) ApplySnapshotChunk(ctx context.Context, req *types.Requ
 	return res.GetApplySnapshotChunk(), nil
 }
 
+func (cli *socketClient) FinalizeSnapshot(ctx context.Context, req *types.RequestFinalizeSnapshot) (*types.ResponseFinalizeSnapshot, error) {
+	res, err := cli.doRequest(ctx, types.ToRequestFinalizeSnapshot(req))
+	if err != nil {
+		return nil, err
+	}
+	return res.GetFinalizeSnapshot(), nil
+}
+
 func (cli *socketClient) PrepareProposal(ctx context.Context, req *types.RequestPrepareProposal) (*types.ResponsePrepareProposal, error) {
 	res, err := cli.doRequest(ctx, types.ToRequestPrepareProposal(req))
 	if err != nil {
@@ -429,6 +437,8 @@ func resMatchesReq(req *types.Request, res *types.Response) (ok bool) {
 		_, ok = res.Value.(*types.Response_ListSnapshots)
 	case *types.Request_OfferSnapshot:
 		_, ok = res.Value.(*types.Response_OfferSnapshot)
+	case *types.Request_FinalizeSnapshot:
+		_, ok = res.Value.(*types.Response_FinalizeSnapshot)
 	case *types.Request_FinalizeBlock:
 		_, ok = res.Value.(*types.Response_FinalizeBlock)
 	}

abci/example/kvstore/kvstore.go

@@ -579,6 +579,31 @@ func (app *Application) ApplySnapshotChunk(_ context.Context, req *abci.RequestA
 	app.logger.Debug("ApplySnapshotChunk", "resp", resp)
 	return resp, nil
 }
+
+func (app *Application) FinalizeSnapshot(_ctx context.Context, req *abci.RequestFinalizeSnapshot) (*abci.ResponseFinalizeSnapshot, error) {
+	app.mu.Lock()
+	defer app.mu.Unlock()
+
+	// we only run some verifications here
+
+	if app.LastCommittedState.GetHeight() != req.SnapshotBlock.SignedHeader.Header.Height {
+		return &abci.ResponseFinalizeSnapshot{}, fmt.Errorf("snapshot height mismatch during state sync finalization: expected %d, got %d",
+			app.LastCommittedState.GetHeight(), req.SnapshotBlock.SignedHeader.Header.Height)
+	}
+
+	if !app.LastCommittedState.GetAppHash().Equal(req.SnapshotBlock.SignedHeader.Header.AppHash) {
+		return &abci.ResponseFinalizeSnapshot{}, fmt.Errorf("snapshot apphash mismatch during state sync finalization: expected %x, got %x",
+			app.LastCommittedState.GetAppHash(), req.SnapshotBlock.SignedHeader.Header.AppHash)
+	}
+
+	if app.initialHeight != req.GenesisBlock.SignedHeader.Header.Height {
+		return &abci.ResponseFinalizeSnapshot{}, fmt.Errorf("genesis height mismatch during state sync finalization: expected %d, got %d",
+			app.initialHeight, req.GenesisBlock.SignedHeader.Header.Height)
+	}
+
+	app.logger.Debug("FinalizeSnapshot finished successfully", "req", req)
+	return &abci.ResponseFinalizeSnapshot{}, nil
+}
 func (app *Application) appVersionForHeight(height int64) uint64 {
 	if app.appVersion == 0 {
 		return uint64(height)

abci/types/application.go

@@ -16,6 +16,8 @@ type StateSyncer interface {
 	LoadSnapshotChunk(context.Context, *RequestLoadSnapshotChunk) (*ResponseLoadSnapshotChunk, error)
 	// ApplySnapshotChunk applies a chunk of snapshot
 	ApplySnapshotChunk(context.Context, *RequestApplySnapshotChunk) (*ResponseApplySnapshotChunk, error)
+	// FinalizeSnapshot sends light block to ABCI app after successful state sync
+	FinalizeSnapshot(context.Context, *RequestFinalizeSnapshot) (*ResponseFinalizeSnapshot, error)
 }
 
 // Application is an interface that enables any finite, deterministic state machine
@@ -97,6 +99,11 @@ func (BaseApplication) ApplySnapshotChunk(_ context.Context, _req *RequestApplyS
 	return &ResponseApplySnapshotChunk{}, nil
 }
 
+// FinalizeSnapshot provides a no-op implementation for the StateSyncer interface
+func (BaseApplication) FinalizeSnapshot(_ context.Context, _req *RequestFinalizeSnapshot) (*ResponseFinalizeSnapshot, error) {
+	return &ResponseFinalizeSnapshot{}, nil
+}
+
 func (BaseApplication) PrepareProposal(_ context.Context, req *RequestPrepareProposal) (*ResponsePrepareProposal, error) {
 	trs := make([]*TxRecord, 0, len(req.Txs))
 	var totalBytes int64

abci/types/messages.go

@@ -87,6 +87,12 @@ func ToRequestApplySnapshotChunk(req *RequestApplySnapshotChunk) *Request {
 	}
 }
 
+func ToRequestFinalizeSnapshot(req *RequestFinalizeSnapshot) *Request {
+	return &Request{
+		Value: &Request_FinalizeSnapshot{req},
+	}
+}
+
 func ToRequestExtendVote(req *RequestExtendVote) *Request {
 	return &Request{
 		Value: &Request_ExtendVote{req},