Repository: alesforz/cometbft
Pull request #3: feat(abci): Add `blob` field to `PrepareProposalResponse`
Author: login: alesforz
Created: 2025-03-11T14:59:53Z | Merged: 2025-03-13T14:48:56Z

Part of the work of https://github.com/berachain/cometbft/pull/26.

### Context
CometBFT calls `PrepareProposal` if the peer is the proposer for this height/round. The application responds with the transactions to be included in the block, as well as the blob for this block. 
In Berachain's current implementation, the list of transactions always contains exactly 2 transactions: `Tx[0]` contains data cryptographically linked to the block’s blob; `Tx[1]` contains the blob itself.

As we want to avoid storing the blob into CometBFT storage, the ABCI application will no longer include it in the list of transactions. Rather, the application will include the blob in a separate field of `PrepareProposalResponse` so that CometBFT can gossip it separately from the block.
 
### Changes
This PR adds a new field `blob` to `PrepareProposalResponse` into which the application will store the blob. Note that this field can be empty, that is, not all blocks will have a corresponding blob.



Diff:
diff --git a/api/cometbft/abci/v1/types.pb.go b/api/cometbft/abci/v1/types.pb.go
index f3146b72df2..7d8880ca4e5 100644
--- a/api/cometbft/abci/v1/types.pb.go
+++ b/api/cometbft/abci/v1/types.pb.go
@@ -2633,9 +2633,12 @@ func (m *ApplySnapshotChunkResponse) GetRejectSenders() []string {
 	return nil
 }
 
-// PrepareProposalResponse contains a list of transactions, which will form a block.
+// PrepareProposalResponse contains a list of transactions which will form a block.
 type PrepareProposalResponse struct {
 	Txs [][]byte `protobuf:"bytes,1,rep,name=txs,proto3" json:"txs,omitempty"`
+	// A blob (see EIP-4844) is a piece of temporary data attached to a blob
+	// transaction. CometBFT will gossip this blob separately from the block.
+	Blob []byte `protobuf:"bytes,2,opt,name=blob,proto3" json:"blob,omitempty"`
 }
 
 func (m *PrepareProposalResponse) Reset()         { *m = PrepareProposalResponse{} }
@@ -2678,6 +2681,13 @@ func (m *PrepareProposalResponse) GetTxs() [][]byte {
 	return nil
 }
 
+func (m *PrepareProposalResponse) GetBlob() []byte {
+	if m != nil {
+		return m.Blob
+	}
+	return nil
+}
+
 // ProcessProposalResponse indicates the ABCI application's decision whenever
 // the given proposal should be accepted or not.
 type ProcessProposalResponse struct {
@@ -3775,208 +3785,209 @@ func init() {
 func init() { proto.RegisterFile("cometbft/abci/v1/types.proto", fileDescriptor_95dd8f7b670b96e3) }
 
 var fileDescriptor_95dd8f7b670b96e3 = []byte{
-	// 3214 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0x4b, 0x6c, 0x1b, 0xd7,
-	0xb9, 0xf6, 0xf0, 0x21, 0x91, 0x3f, 0x49, 0x69, 0x74, 0x24, 0xd9, 0xb4, 0xe2, 0x48, 0xf2, 0x38,
-	0x8e, 0x1d, 0x3b, 0x91, 0xae, 0x9d, 0xdc, 0x3c, 0x6e, 0x6e, 0x12, 0x50, 0x34, 0x15, 0x49, 0x96,
-	0x45, 0x66, 0x48, 0xeb, 0xc6, 0xc6, 0x6d, 0x27, 0x43, 0xf2, 0x90, 0x9c, 0x98, 0xe4, 0x4c, 0x66,
-	0x0e, 0x15, 0xaa, 0x5d, 0xb5, 0x68, 0x8a, 0x22, 0xab, 0x6c, 0x0a, 0x14, 0x45, 0x0b, 0x14, 0x28,
-	0xba, 0x2a, 0xd0, 0x45, 0x57, 0xdd, 0x74, 0x5b, 0x64, 0xd5, 0x66, 0xd9, 0x55, 0x5a, 0x24, 0xbb,
-	0xee, 0x03, 0x74, 0x59, 0x9c, 0xc7, 0xbc, 0xc8, 0x19, 0x49, 0x76, 0xd2, 0x45, 0xd1, 0xee, 0x78,
-	0xce, 0xf9, 0xfe, 0x7f, 0xce, 0xe3, 0x3f, 0xff, 0xe3, 0x3b, 0x84, 0x4b, 0x2d, 0x73, 0x80, 0x49,
-	0xb3, 0x43, 0x36, 0xf5, 0x66, 0xcb, 0xd8, 0x3c, 0xba, 0xb5, 0x49, 0x8e, 0x2d, 0xec, 0x6c, 0x58,
-	0xb6, 0x49, 0x4c, 0x24, 0xbb, 0xa3, 0x1b, 0x74, 0x74, 0xe3, 0xe8, 0xd6, 0xca, 0xaa, 0x87, 0x6f,
-	0xd9, 0xc7, 0x16, 0x31, 0xa9, 0x84, 0x65, 0x9b, 0x66, 0x87, 0x4b, 0x04, 0xc6, 0x99, 0x1e, 0x36,
-	0xac, 0xdb, 0xfa, 0x40, 0x68, 0x5c, 0xb9, 0x3c, 0x3d, 0x7e, 0xa4, 0xf7, 0x8d, 0xb6, 0x4e, 0x4c,
-	0x5b, 0x40, 0x96, 0xba, 0x66, 0xd7, 0x64, 0x3f, 0x37, 0xe9, 0x2f, 0xd1, 0xbb, 0xd6, 0x35, 0xcd,
-	0x6e, 0x1f, 0x6f, 0xb2, 0x56, 0x73, 0xd4, 0xd9, 0x24, 0xc6, 0x00, 0x3b, 0x44, 0x1f, 0x58, 0xee,
-	0x97, 0x27, 0x01, 0xed, 0x91, 0xad, 0x13, 0xc3, 0x1c, 0xf2, 0x71, 0xe5, 0x4f, 0x59, 0x98, 0x55,
-	0xf1, 0x07, 0x23, 0xec, 0x10, 0xf4, 0x22, 0xa4, 0x70, 0xab, 0x67, 0x16, 0xa5, 0x75, 0xe9, 0x7a,
-	0xee, 0xf6, 0xd3, 0x1b, 0x93, 0xcb, 0xdc, 0xa8, 0xb4, 0x7a, 0xa6, 0x00, 0xef, 0x9c, 0x53, 0x19,
-	0x18, 0xbd, 0x0c, 0xe9, 0x4e, 0x7f, 0xe4, 0xf4, 0x8a, 0x09, 0x26, 0xb5, 0x3a, 0x2d, 0xb5, 0x4d,
-	0x87, 0x7d, 0x31, 0x0e, 0xa7, 0x1f, 0x33, 0x86, 0x1d, 0xb3, 0x98, 0x8c, 0xfb, 0xd8, 0xee, 0xb0,
-	0x13, 0xfc, 0x18, 0x05, 0xa3, 0x32, 0x80, 0x31, 0x34, 0x88, 0xd6, 0xea, 0xe9, 0xc6, 0xb0, 0x98,
-	0x66, 0xa2, 0x4a, 0x94, 0xa8, 0x41, 0xca, 0x14, 0xe2, 0xcb, 0x67, 0x0d, 0xb7, 0x8f, 0xce, 0xf8,
-	0x83, 0x11, 0xb6, 0x8f, 0x8b, 0x33, 0x71, 0x33, 0x7e, 0x87, 0x0e, 0x07, 0x66, 0xcc, 0xe0, 0xe8,
-	0x0d, 0xc8, 0xb4, 0x7a, 0xb8, 0xf5, 0x48, 0x23, 0xe3, 0x62, 0x86, 0x89, 0xae, 0x4f, 0x8b, 0x96,
-	0x29, 0xa2, 0x31, 0xf6, 0x85, 0x67, 0x5b, 0xbc, 0x07, 0xbd, 0x06, 0x33, 0x2d, 0x73, 0x30, 0x30,
-	0x48, 0x31, 0xc7, 0x84, 0xd7, 0x22, 0x84, 0xd9, 0xb8, 0x2f, 0x2b, 0x04, 0x50, 0x15, 0xe6, 0xfa,
-	0x86, 0x43, 0x34, 0x67, 0xa8, 0x5b, 0x4e, 0xcf, 0x24, 0x4e, 0x31, 0xcf, 0x54, 0x3c, 0x3b, 0xad,
-	0x62, 0xdf, 0x70, 0x48, 0xdd, 0x85, 0xf9, 0x9a, 0x0a, 0xfd, 0x60, 0x3f, 0x55, 0x68, 0x76, 0x3a,
-	0xd8, 0xf6, 0x34, 0x16, 0x0b, 0x71, 0x0a, 0xab, 0x14, 0xe7, 0x4a, 0x06, 0x14, 0x9a, 0xc1, 0x7e,
-	0xf4, 0xff, 0xb0, 0xd8, 0x37, 0xf5, 0xb6, 0xa7, 0x4f, 0x6b, 0xf5, 0x46, 0xc3, 0x47, 0xc5, 0x39,
-	0xa6, 0xf5, 0x46, 0xc4, 0x34, 0x4d, 0xbd, 0xed, 0x0a, 0x97, 0x29, 0xd4, 0xd7, 0xbc, 0xd0, 0x9f,
-	0x1c, 0x43, 0x1a, 0x2c, 0xe9, 0x96, 0xd5, 0x3f, 0x9e, 0x54, 0x3f, 0xcf, 0xd4, 0xdf, 0x9c, 0x56,
-	0x5f, 0xa2, 0xe8, 0x18, 0xfd, 0x48, 0x9f, 0x1a, 0x44, 0xf7, 0x41, 0xb6, 0x6c, 0x6c, 0xe9, 0x36,
-	0xd6, 0x2c, 0xdb, 0xb4, 0x4c, 0x47, 0xef, 0x17, 0x65, 0xa6, 0xfc, 0xfa, 0xb4, 0xf2, 0x1a, 0x47,
-	0xd6, 0x04, 0xd0, 0xd7, 0x3c, 0x6f, 0x85, 0x47, 0xb8, 0x5a, 0xb3, 0x85, 0x1d, 0xc7, 0x57, 0xbb,
-	0x10, 0xaf, 0x96, 0x21, 0x23, 0xd5, 0x86, 0x46, 0xd0, 0x36, 0xe4, 0xf0, 0x98, 0xe0, 0x61, 0x5b,
-	0x3b, 0x32, 0x09, 0x2e, 0x22, 0xa6, 0xf1, 0x4a, 0xc4, 0x75, 0x65, 0xa0, 0x43, 0x93, 0x60, 0x5f,
-	0x19, 0x60, 0xaf, 0x13, 0x35, 0x61, 0xf9, 0x08, 0xdb, 0x46, 0xe7, 0x98, 0xe9, 0xd1, 0xd8, 0x88,
-	0x63, 0x98, 0xc3, 0xe2, 0x22, 0xd3, 0xf8, 0xfc, 0xb4, 0xc6, 0x43, 0x06, 0xa7, 0xc2, 0x15, 0x17,
-	0xec, 0xab, 0x5e, 0x3c, 0x9a, 0x1e, 0xa5, 0x96, 0xd6, 0x31, 0x86, 0x7a, 0xdf, 0xf8, 0x0e, 0xd6,
-	0x9a, 0x7d, 0xb3, 0xf5, 0xa8, 0xb8, 0x14, 0x67, 0x69, 0xdb, 0x02, 0xb7, 0x45, 0x61, 0x01, 0x4b,
-	0xeb, 0x04, 0xfb, 0xb7, 0x66, 0x21, 0x7d, 0xa4, 0xf7, 0x47, 0x78, 0x2f, 0x95, 0x49, 0xc9, 0xe9,
-	0xbd, 0x54, 0x66, 0x56, 0xce, 0xec, 0xa5, 0x32, 0x59, 0x19, 0xf6, 0x52, 0x19, 0x90, 0x73, 0xca,
-	0x35, 0xc8, 0x05, 0xfc, 0x14, 0x2a, 0xc2, 0xec, 0x00, 0x3b, 0x8e, 0xde, 0xc5, 0xcc, 0xaf, 0x65,
-	0x55, 0xb7, 0xa9, 0xcc, 0x41, 0x3e, 0xe8, 0x9a, 0x94, 0x4f, 0x24, 0xc8, 0x05, 0x9c, 0x0e, 0x95,
-	0x3c, 0xc2, 0x36, 0xdb, 0x10, 0x21, 0x29, 0x9a, 0xe8, 0x0a, 0x14, 0xd8, 0x5a, 0x34, 0x77, 0x9c,
-	0xfa, 0xbe, 0x94, 0x9a, 0x67, 0x9d, 0x87, 0x02, 0xb4, 0x06, 0x39, 0xeb, 0xb6, 0xe5, 0x41, 0x92,
-	0x0c, 0x02, 0xd6, 0x6d, 0xcb, 0x05, 0x5c, 0x86, 0x3c, 0x5d, 0xba, 0x87, 0x48, 0xb1, 0x8f, 0xe4,
-	0x68, 0x9f, 0x80, 0x28, 0x7f, 0x4c, 0x80, 0x3c, 0xe9, 0xcc, 0xd0, 0xab, 0x90, 0xa2, 0x5e, 0x5e,
-	0xb8, 0xe9, 0x95, 0x0d, 0xee, 0xe1, 0x37, 0x5c, 0x0f, 0xbf, 0xd1, 0x70, 0x43, 0xc0, 0x56, 0xe6,
-	0xd3, 0xcf, 0xd7, 0xce, 0x7d, 0xf2, 0x97, 0x35, 0x49, 0x65, 0x12, 0xe8, 0x22, 0xf5, 0x60, 0xba,
-	0x31, 0xd4, 0x8c, 0x36, 0x9b, 0x72, 0x96, 0x7a, 0x27, 0xdd, 0x18, 0xee, 0xb6, 0xd1, 0x3d, 0x90,
-	0x5b, 0xe6, 0xd0, 0xc1, 0x43, 0x67, 0xe4, 0x68, 0x3c, 0x36, 0x09, 0xd7, 0x1c, 0xf0, 0xaf, 0x3c,
-	0x08, 0x32, 0x47, 0x25, 0xa0, 0x35, 0x86, 0x54, 0xe7, 0x5b, 0xe1, 0x0e, 0xf4, 0x36, 0x80, 0x17,
-	0xc0, 0x9c, 0x62, 0x6a, 0x3d, 0x79, 0x3d, 0x77, 0xfb, 0x72, 0x84, 0x3d, 0xb9, 0x98, 0xfb, 0x56,
-	0x5b, 0x27, 0x78, 0x2b, 0x45, 0x27, 0xac, 0x06, 0x44, 0xd1, 0xb3, 0x30, 0xaf, 0x5b, 0x96, 0xe6,
-	0x10, 0x9d, 0x60, 0xad, 0x79, 0x4c, 0xb0, 0xc3, 0xdc, 0x7e, 0x5e, 0x2d, 0xe8, 0x96, 0x55, 0xa7,
-	0xbd, 0x5b, 0xb4, 0x13, 0x5d, 0x85, 0x39, 0xea, 0xe1, 0x0d, 0xbd, 0xaf, 0xf5, 0xb0, 0xd1, 0xed,
-	0x11, 0xe6, 0xdd, 0x93, 0x6a, 0x41, 0xf4, 0xee, 0xb0, 0x4e, 0xa5, 0x0d, 0xf9, 0xa0, 0x73, 0x47,
-	0x08, 0x52, 0x6d, 0x9d, 0xe8, 0x6c, 0x2f, 0xf3, 0x2a, 0xfb, 0x4d, 0xfb, 0x2c, 0x9d, 0xf4, 0xc4,
-	0x0e, 0xb1, 0xdf, 0xe8, 0x3c, 0xcc, 0x08, 0xb5, 0x49, 0xa6, 0x56, 0xb4, 0xd0, 0x12, 0xa4, 0x2d,
-	0xdb, 0x3c, 0xc2, 0xec, 0xf0, 0x32, 0x2a, 0x6f, 0x28, 0x0f, 0x60, 0x2e, 0x1c, 0x07, 0xd0, 0x1c,
-	0x24, 0xc8, 0x58, 0x7c, 0x25, 0x41, 0xc6, 0xe8, 0x16, 0xa4, 0xe8, 0x66, 0x32, 0x6d, 0x73, 0x51,
-	0xd1, 0x4f, 0xc8, 0x37, 0x8e, 0x2d, 0xac, 0x32, 0xe8, 0x5e, 0x2a, 0x93, 0x90, 0x93, 0xca, 0x3c,
-	0x14, 0x42, 0x51, 0x42, 0x39, 0x0f, 0x4b, 0x51, 0x3e, 0x5f, 0x31, 0x60, 0x29, 0xca, 0x75, 0xa3,
-	0x97, 0x21, 0xe3, 0x39, 0x7d, 0xd7, 0x82, 0xa6, 0xbe, 0xee, 0x09, 0x79, 0x58, 0x6a, 0x3b, 0xf4,
-	0x20, 0x7a, 0xba, 0x08, 0xf5, 0x79, 0x75, 0x56, 0xb7, 0xac, 0x1d, 0xdd, 0xe9, 0x29, 0xef, 0x41,
-	0x31, 0xce, 0x9f, 0x07, 0x36, 0x4e, 0x62, 0x17, 0xc0, 0xdd, 0xb8, 0xf3, 0x30, 0xd3, 0x31, 0xed,
-	0x81, 0x4e, 0x98, 0xb2, 0x82, 0x2a, 0x5a, 0x74, 0x43, 0xb9, 0x6f, 0x4f, 0xb2, 0x6e, 0xde, 0x50,
-	0x34, 0xb8, 0x18, 0xeb, 0xd2, 0xa9, 0x88, 0x31, 0x6c, 0x63, 0xbe, 0xbd, 0x05, 0x95, 0x37, 0x7c,
-	0x45, 0x7c, 0xb2, 0xbc, 0x41, 0x3f, 0xeb, 0xe0, 0x61, 0x1b, 0xdb, 0x4c, 0x7f, 0x56, 0x15, 0x2d,
-	0xe5, 0xa7, 0x49, 0x38, 0x1f, 0xed, 0xd7, 0xd1, 0x3a, 0xe4, 0x07, 0xfa, 0x58, 0x23, 0x63, 0x61,
-	0x7e, 0x12, 0x33, 0x00, 0x18, 0xe8, 0xe3, 0xc6, 0x98, 0xdb, 0x9e, 0x0c, 0x49, 0x32, 0x76, 0x8a,
-	0x89, 0xf5, 0xe4, 0xf5, 0xbc, 0x4a, 0x7f, 0xa2, 0x43, 0x58, 0xe8, 0x9b, 0x2d, 0xbd, 0xaf, 0xf5,
-	0x75, 0x87, 0x68, 0x22, 0xec, 0xf3, 0xeb, 0xf4, 0x4c, 0x9c, 0x9f, 0xc6, 0x6d, 0x7e, 0xb0, 0xd4,
-	0x05, 0x89, 0x8b, 0x30, 0xcf, 0x94, 0xec, 0xeb, 0x0e, 0xe1, 0x43, 0xa8, 0x02, 0xb9, 0x81, 0xe1,
-	0x34, 0x71, 0x4f, 0x3f, 0x32, 0x4c, 0x5b, 0xdc, 0xab, 0x08, 0xeb, 0xb9, 0xe7, 0x83, 0x84, 0xaa,
-	0xa0, 0x5c, 0xe0, 0x50, 0xd2, 0x21, 0x6b, 0x76, 0x3d, 0xcb, 0xcc, 0x63, 0x7b, 0x96, 0xff, 0x82,
-	0xa5, 0x21, 0x1e, 0x13, 0xcd, 0xbf, 0xb9, 0xdc, 0x52, 0x66, 0xd9, 0xe6, 0x23, 0x3a, 0xe6, 0xdd,
-	0x75, 0x87, 0x1a, 0x0d, 0x7a, 0x8e, 0xc5, 0x46, 0xcb, 0x74, 0xb0, 0xad, 0xe9, 0xed, 0xb6, 0x8d,
-	0x1d, 0x87, 0x65, 0x55, 0x79, 0x16, 0xef, 0x58, 0x7f, 0x89, 0x77, 0x2b, 0x1f, 0xb3, 0xc3, 0x89,
-	0x8a, 0x8e, 0xee, 0xd6, 0x4b, 0xfe, 0xd6, 0x37, 0x60, 0x49, 0xc8, 0xb7, 0x43, 0xbb, 0xcf, 0xd3,
-	0xd3, 0x4b, 0x71, 0x49, 0x57, 0x60, 0xd7, 0x91, 0x2b, 0x1f, 0xbf, 0xf1, 0xc9, 0x27, 0xdc, 0x78,
-	0x04, 0x29, 0xb6, 0x2d, 0x29, 0xee, 0x6e, 0xe8, 0xef, 0x7f, 0xb5, 0xc3, 0xf8, 0x28, 0x09, 0x0b,
-	0x53, 0x89, 0x85, 0xb7, 0x30, 0x29, 0x72, 0x61, 0x89, 0xc8, 0x85, 0x25, 0x1f, 0x7b, 0x61, 0xe2,
-	0xb4, 0x53, 0xa7, 0x9f, 0x76, 0xfa, 0x9b, 0x3c, 0xed, 0x99, 0x27, 0x3c, 0xed, 0x7f, 0xea, 0x39,
-	0xfc, 0x4c, 0x82, 0x95, 0xf8, 0x74, 0x2c, 0xf2, 0x40, 0x6e, 0xc2, 0x82, 0x37, 0x15, 0x4f, 0x3d,
-	0x77, 0x8f, 0xb2, 0x37, 0x20, 0xf4, 0xc7, 0x46, 0xbc, 0xab, 0x30, 0x37, 0x91, 0x2d, 0x72, 0x63,
-	0x2e, 0x1c, 0x05, 0xa7, 0xa1, 0xfc, 0x36, 0x09, 0x4b, 0x51, 0x09, 0x5d, 0xc4, 0x8d, 0x55, 0x61,
-	0xb1, 0x8d, 0x5b, 0x46, 0xfb, 0x89, 0x2f, 0xec, 0x82, 0x10, 0xff, 0xcf, 0x7d, 0x9d, 0xb6, 0x13,
-	0x74, 0x03, 0x16, 0x9c, 0xe3, 0x61, 0xcb, 0x18, 0x76, 0x35, 0x62, 0xba, 0xb9, 0x51, 0x96, 0xcd,
-	0x7c, 0x5e, 0x0c, 0x34, 0x4c, 0x91, 0x1d, 0xfd, 0x0a, 0x20, 0xa3, 0x62, 0xc7, 0xa2, 0xc9, 0x1c,
-	0x2a, 0x43, 0x16, 0x8f, 0x5b, 0xd8, 0x22, 0x6e, 0x02, 0x1c, 0x53, 0x63, 0x08, 0x88, 0x2b, 0x47,
-	0x6b, 0x6d, 0x4f, 0x0e, 0xbd, 0x24, 0x28, 0x85, 0x58, 0x72, 0x80, 0xa7, 0xea, 0x9e, 0x28, 0xe7,
-	0x14, 0x5e, 0x71, 0x39, 0x85, 0x64, 0x5c, 0xa5, 0x2c, 0x12, 0x77, 0x4f, 0x4e, 0x90, 0x0a, 0x2f,
-	0x09, 0x52, 0x21, 0x15, 0xf7, 0x39, 0x9e, 0xdf, 0xfb, 0x9f, 0x63, 0xac, 0xc2, 0x9d, 0x10, 0xab,
-	0x30, 0x13, 0xb7, 0xd4, 0x40, 0x22, 0xee, 0x2f, 0xd5, 0xa7, 0x15, 0x5e, 0x71, 0x69, 0x85, 0xd9,
-	0xb8, 0x49, 0x8b, 0xcc, 0xd3, 0x9f, 0x34, 0xe7, 0x15, 0xde, 0x0c, 0xf0, 0x0a, 0x59, 0x26, 0x7b,
-	0xf9, 0x04, 0x5e, 0xc1, 0x93, 0xf6, 0x88, 0x85, 0xff, 0xf1, 0x88, 0x85, 0x7c, 0x2c, 0x2b, 0x21,
-	0x52, 0x46, 0x4f, 0xd8, 0x65, 0x16, 0x6a, 0x53, 0xcc, 0x02, 0x27, 0x02, 0xae, 0x9d, 0xca, 0x2c,
-	0x78, 0xaa, 0x26, 0xa8, 0x85, 0xda, 0x14, 0xb5, 0x30, 0x17, 0xa7, 0x71, 0x22, 0x3f, 0xf5, 0x35,
-	0x86, 0xb9, 0x85, 0x6f, 0x45, 0x73, 0x0b, 0xb1, 0xc5, 0x7f, 0x44, 0x2e, 0xea, 0xa9, 0x8e, 0x20,
-	0x17, 0xde, 0x8b, 0x21, 0x17, 0xe4, 0xb8, 0x22, 0x38, 0x2a, 0x13, 0xf5, 0x3e, 0x10, 0xc5, 0x2e,
-	0x1c, 0x46, 0xb0, 0x0b, 0x9c, 0x06, 0x78, 0xee, 0x0c, 0xec, 0x82, 0xa7, 0x7a, 0x8a, 0x5e, 0x38,
-	0x8c, 0xa0, 0x17, 0x50, 0xbc, 0xde, 0x89, 0x04, 0x2a, 0xa8, 0x37, 0xcc, 0x2f, 0xbc, 0x1d, 0xe6,
-	0x17, 0x16, 0x4f, 0xce, 0x5b, 0x79, 0x1a, 0xe0, 0x69, 0x0b, 0x12, 0x0c, 0xad, 0x38, 0x82, 0x81,
-	0x73, 0x00, 0x2f, 0x9c, 0x91, 0x60, 0xf0, 0x74, 0x47, 0x32, 0x0c, 0xb5, 0x29, 0x86, 0x61, 0x39,
-	0xce, 0xe0, 0x26, 0x02, 0x92, 0x6f, 0x70, 0xb1, 0x14, 0x43, 0x5a, 0x9e, 0xd9, 0x4b, 0x65, 0x32,
-	0x72, 0x96, 0x93, 0x0b, 0x7b, 0xa9, 0x4c, 0x4e, 0xce, 0x2b, 0xcf, 0xd1, 0x14, 0x68, 0xc2, 0xef,
-	0xd1, 0x82, 0x03, 0xdb, 0xb6, 0x69, 0x0b, 0xb2, 0x80, 0x37, 0x94, 0xeb, 0x90, 0x0f, 0xba, 0xb8,
-	0x13, 0xe8, 0x88, 0x79, 0x28, 0x84, 0xbc, 0x9a, 0xf2, 0x3b, 0x09, 0xf2, 0x41, 0x7f, 0x15, 0x2a,
-	0x56, 0xb3, 0xa2, 0x58, 0x0d, 0x90, 0x14, 0x89, 0x30, 0x49, 0xb1, 0x06, 0x39, 0x5a, 0xb0, 0x4d,
-	0xf0, 0x0f, 0xba, 0xe5, 0xf1, 0x0f, 0x37, 0x60, 0x81, 0xc5, 0x5b, 0x4e, 0x65, 0x88, 0xc8, 0x90,
-	0xe2, 0x91, 0x81, 0x0e, 0xb0, 0xcd, 0xe0, 0x91, 0x01, 0xbd, 0x00, 0x8b, 0x01, 0xac, 0x57, 0x08,
-	0xf2, 0x52, 0x5c, 0xf6, 0xd0, 0x25, 0x51, 0x11, 0xfe, 0x41, 0x82, 0x85, 0x29, 0x77, 0x19, 0xc9,
-	0x31, 0x48, 0xdf, 0x14, 0xc7, 0x90, 0x78, 0x72, 0x8e, 0x21, 0x58, 0xda, 0x26, 0xc3, 0xa5, 0xed,
-	0xdf, 0x25, 0x28, 0x84, 0xdc, 0x36, 0x3d, 0x84, 0x96, 0xd9, 0xc6, 0xa2, 0xd8, 0x64, 0xbf, 0x69,
-	0x4e, 0xd3, 0x37, 0xbb, 0xa2, 0xa4, 0xa4, 0x3f, 0x29, 0xca, 0x0b, 0x44, 0x59, 0x11, 0x66, 0xbc,
-	0x3a, 0x95, 0xe7, 0x0d, 0xa2, 0x4e, 0x95, 0x21, 0xf9, 0x08, 0x73, 0x2e, 0x3a, 0xaf, 0xd2, 0x9f,
-	0x14, 0xc7, 0xcc, 0x4f, 0xc4, 0x7f, 0xde, 0x40, 0xaf, 0x41, 0x96, 0xbd, 0x28, 0x68, 0xa6, 0xe5,
-	0x08, 0xfa, 0x39, 0x90, 0x1b, 0xf1, 0x67, 0x07, 0x71, 0xcf, 0xcd, 0x4e, 0xd5, 0x72, 0xd4, 0x8c,
-	0x25, 0x7e, 0x05, 0x32, 0x96, 0x6c, 0x28, 0x63, 0xb9, 0x04, 0x59, 0x3a, 0x7d, 0xc7, 0xd2, 0x5b,
-	0xb8, 0x08, 0x6c, 0xa6, 0x7e, 0x87, 0xf2, 0xeb, 0x04, 0xcc, 0x4f, 0x44, 0x9d, 0xc8, 0xc5, 0xbb,
-	0x56, 0x99, 0x08, 0x50, 0x28, 0x67, 0xdb, 0x90, 0x55, 0x80, 0xae, 0xee, 0x68, 0x1f, 0xea, 0x43,
-	0x82, 0xdb, 0x62, 0x57, 0x02, 0x3d, 0x68, 0x05, 0x32, 0xb4, 0x35, 0x72, 0x70, 0x5b, 0xb0, 0x39,
-	0x5e, 0x1b, 0xed, 0xc2, 0x0c, 0x3e, 0xc2, 0x43, 0xe2, 0x14, 0x67, 0xd9, 0xc1, 0x5f, 0x88, 0x70,
-	0x4f, 0x74, 0x7c, 0xab, 0x48, 0x8f, 0xfb, 0x6f, 0x9f, 0xaf, 0xc9, 0x1c, 0xfe, 0xbc, 0x39, 0x30,
-	0x08, 0x1e, 0x58, 0xe4, 0x58, 0x15, 0x0a, 0xc2, 0xdb, 0x90, 0x99, 0xd8, 0x06, 0x46, 0x2d, 0xe6,
-	0x5d, 0x9e, 0x80, 0x6e, 0xaa, 0x61, 0xda, 0x06, 0x39, 0x56, 0x0b, 0x03, 0x3c, 0xb0, 0x4c, 0xb3,
-	0xaf, 0xf1, 0x7b, 0x5e, 0x82, 0xb9, 0x70, 0x90, 0x45, 0x57, 0xa0, 0x60, 0x63, 0xa2, 0x1b, 0x43,
-	0x2d, 0x94, 0x47, 0xe7, 0x79, 0x27, 0xbf, 0x57, 0x7b, 0xa9, 0x8c, 0x24, 0x27, 0x04, 0xb5, 0xf3,
-	0x0e, 0x2c, 0x47, 0xc6, 0x58, 0xf4, 0x2a, 0x64, 0xfd, 0xf8, 0x2c, 0xb1, 0xe5, 0x9e, 0xc4, 0xd9,
-	0xf8, 0x60, 0xe5, 0x10, 0x96, 0x23, 0x83, 0x2c, 0x7a, 0x03, 0x66, 0x6c, 0xec, 0x8c, 0xfa, 0x9c,
-	0x96, 0x99, 0xbb, 0x7d, 0xf5, 0xf4, 0xe8, 0x3c, 0xea, 0x13, 0x55, 0x08, 0x29, 0xb7, 0xe0, 0x62,
-	0x6c, 0x94, 0xf5, 0x99, 0x17, 0x29, 0xc0, 0xbc, 0x28, 0xbf, 0x91, 0x60, 0x25, 0x3e, 0x72, 0xa2,
-	0xad, 0x89, 0x09, 0xdd, 0x38, 0x63, 0xdc, 0x0d, 0xcc, 0x8a, 0x96, 0x26, 0x36, 0xee, 0x60, 0xd2,
-	0xea, 0xf1, 0x10, 0xce, 0x9d, 0x42, 0x41, 0x2d, 0x88, 0x5e, 0x26, 0xe3, 0x70, 0xd8, 0xfb, 0xb8,
-	0x45, 0x34, 0x7e, 0xa8, 0x0e, 0x2b, 0x0f, 0xb2, 0x14, 0x46, 0x7b, 0xeb, 0xbc, 0x53, 0xb9, 0x09,
-	0x17, 0x62, 0x62, 0xf1, 0x74, 0x0d, 0xa3, 0x3c, 0xa4, 0xe0, 0xc8, 0x00, 0x8b, 0xde, 0x82, 0x19,
-	0x87, 0xe8, 0x64, 0xe4, 0x88, 0x95, 0x5d, 0x3b, 0x35, 0x36, 0xd7, 0x19, 0x5c, 0x15, 0x62, 0xca,
-	0xeb, 0x80, 0xa6, 0x23, 0x6d, 0x44, 0x1d, 0x26, 0x45, 0xd5, 0x61, 0x4d, 0x78, 0xea, 0x84, 0x98,
-	0x8a, 0xca, 0x13, 0x93, 0xbb, 0x79, 0xa6, 0x90, 0x3c, 0x31, 0xc1, 0xdf, 0x27, 0x61, 0x39, 0x32,
-	0xb4, 0x06, 0x6e, 0xa9, 0xf4, 0x75, 0x6f, 0xe9, 0x1b, 0x00, 0x64, 0xac, 0xf1, 0x93, 0x76, 0xbd,
-	0x7d, 0x54, 0x3d, 0x31, 0xc6, 0x2d, 0xe6, 0xb0, 0xa8, 0x61, 0x64, 0x89, 0xf8, 0xe5, 0xa0, 0x46,
-	0xb0, 0xf6, 0x1d, 0xb1, 0x48, 0xe0, 0x88, 0xb2, 0xf0, 0xcc, 0x31, 0xc3, 0x2f, 0x92, 0x79, 0xb7,
-	0x83, 0x1e, 0xc2, 0x85, 0x89, 0x88, 0xe6, 0xe9, 0x4e, 0x9d, 0x39, 0xb0, 0x2d, 0x87, 0x03, 0x9b,
-	0xab, 0x3b, 0x18, 0x95, 0xd2, 0xa1, 0xa8, 0x44, 0x03, 0x29, 0x2b, 0x18, 0x79, 0x34, 0x6e, 0xe3,
-	0xbe, 0xee, 0x3e, 0x66, 0x5e, 0x9c, 0x2a, 0x3b, 0xef, 0x88, 0xf7, 0x5e, 0x5e, 0x75, 0xfe, 0x84,
-	0x56, 0x9d, 0x73, 0x54, 0x98, 0x1d, 0xd4, 0x1d, 0x2a, 0xaa, 0x3c, 0x04, 0xf0, 0x6b, 0x6a, 0x7a,
-	0x7d, 0x6d, 0x73, 0x34, 0x6c, 0x33, 0x8b, 0x48, 0xab, 0xbc, 0x81, 0x5e, 0x86, 0x34, 0x35, 0x2c,
-	0x77, 0xe7, 0x23, 0xfc, 0x0f, 0xb5, 0x90, 0x40, 0x51, 0xce, 0xe1, 0xca, 0xfb, 0xae, 0xf1, 0x06,
-	0xe9, 0xcd, 0x98, 0x6f, 0xbc, 0x19, 0xfe, 0x86, 0x12, 0xcf, 0x94, 0x46, 0x7f, 0xeb, 0xbb, 0x90,
-	0x66, 0xd6, 0x44, 0x83, 0x0d, 0x63, 0xd7, 0x45, 0xa2, 0x44, 0x7f, 0xa3, 0x6f, 0x03, 0xe8, 0x84,
-	0xd8, 0x46, 0x73, 0xe4, 0x7f, 0x61, 0x3d, 0xc6, 0x1c, 0x4b, 0x2e, 0x70, 0xeb, 0x92, 0xb0, 0xcb,
-	0x25, 0x5f, 0x36, 0x60, 0x9b, 0x01, 0x8d, 0xca, 0x01, 0xcc, 0x85, 0x65, 0xdd, 0xc8, 0xce, 0x27,
-	0x11, 0x8e, 0xec, 0x3c, 0x55, 0x13, 0x91, 0xdd, 0xcb, 0x0b, 0x92, 0xfc, 0x0d, 0x81, 0x35, 0x94,
-	0xef, 0x25, 0x20, 0x1f, 0x34, 0xe6, 0x7f, 0xc3, 0xd8, 0xab, 0xfc, 0x50, 0x82, 0x8c, 0xb7, 0xfe,
-	0xf0, 0x4b, 0x42, 0xe8, 0x09, 0x86, 0x6f, 0x5f, 0x22, 0x48, 0xff, 0xf3, 0x07, 0x97, 0xa4, 0xf7,
-	0xe0, 0xf2, 0xbf, 0x5e, 0x7c, 0x89, 0xe5, 0x06, 0x82, 0xbb, 0x2d, 0x0c, 0xcb, 0x8d, 0x77, 0xaf,
-	0x43, 0xd6, 0x73, 0x09, 0x34, 0xe5, 0x76, 0x39, 0x17, 0x49, 0xdc, 0x4b, 0xc1, 0xb5, 0x2c, 0x41,
-	0xda, 0x32, 0x3f, 0x14, 0x8f, 0x0b, 0x49, 0x95, 0x37, 0x14, 0x07, 0xe6, 0x27, 0xfc, 0x89, 0x0f,
-	0x4c, 0x04, 0x80, 0x48, 0x81, 0x82, 0x35, 0x6a, 0x6a, 0x8f, 0xf0, 0xb1, 0x78, 0x6a, 0xe0, 0xd3,
-	0xcf, 0x59, 0xa3, 0xe6, 0x5d, 0x7c, 0xcc, 0xdf, 0x1a, 0xd6, 0x21, 0xef, 0x62, 0x98, 0x89, 0xf3,
-	0x33, 0x05, 0x0e, 0x69, 0xf0, 0x77, 0x22, 0x49, 0x4e, 0x28, 0x3f, 0x96, 0x20, 0xe3, 0xde, 0x12,
-	0xf4, 0x16, 0x64, 0x3d, 0xd7, 0x25, 0x32, 0xee, 0xa7, 0x4e, 0x70, 0x7a, 0x62, 0xf1, 0xbe, 0x0c,
-	0xda, 0x72, 0x1f, 0x3c, 0x8d, 0xb6, 0xd6, 0xe9, 0xeb, 0x5d, 0xf1, 0x6e, 0xb5, 0x1a, 0xe1, 0xdd,
-	0x98, 0x5f, 0xd9, 0xbd, 0xb3, 0xdd, 0xd7, 0xbb, 0x6a, 0x8e, 0x09, 0xed, 0xb6, 0x69, 0x43, 0x24,
-	0x39, 0x5f, 0x49, 0x20, 0x4f, 0xde, 0xe2, 0xaf, 0x3f, 0xbf, 0xe9, 0x60, 0x98, 0x8c, 0x08, 0x86,
-	0x68, 0x13, 0x16, 0x3d, 0x84, 0xe6, 0x18, 0xdd, 0xa1, 0x4e, 0x46, 0x36, 0x16, 0xec, 0x1e, 0xf2,
-	0x86, 0xea, 0xee, 0xc8, 0xf4, 0xba, 0xd3, 0x4f, 0xba, 0xee, 0x8f, 0x12, 0x90, 0x0b, 0x90, 0x8d,
-	0xe8, 0xbf, 0x03, 0x2e, 0x6a, 0x2e, 0x2a, 0x04, 0x05, 0xc0, 0xfe, 0x23, 0x60, 0x78, 0xa7, 0x12,
-	0x4f, 0xb0, 0x53, 0x71, 0xb4, 0xae, 0xcb, 0x5e, 0xa6, 0x1e, 0x9b, 0xbd, 0x7c, 0x1e, 0x10, 0x31,
-	0x89, 0xde, 0xa7, 0x35, 0xbe, 0x31, 0xec, 0x6a, 0xdc, 0xb0, 0xb9, 0x47, 0x91, 0xd9, 0xc8, 0x21,
-	0x1b, 0xa8, 0xb1, 0xcb, 0xf0, 0x7d, 0x09, 0x32, 0x1e, 0xb3, 0xf3, 0xb8, 0x8f, 0x83, 0xe7, 0x61,
-	0x46, 0x24, 0x76, 0xfc, 0x75, 0x50, 0xb4, 0x22, 0x69, 0xda, 0x15, 0xc8, 0x0c, 0x30, 0xd1, 0x99,
-	0x7b, 0xe4, 0xe1, 0xd3, 0x6b, 0xdf, 0x68, 0x42, 0x2e, 0xf0, 0xbe, 0x8a, 0x2e, 0xc2, 0x72, 0x79,
-	0xa7, 0x52, 0xbe, 0xab, 0x35, 0xde, 0xd5, 0x1a, 0x0f, 0x6a, 0x15, 0xed, 0xfe, 0xc1, 0xdd, 0x83,
-	0xea, 0xff, 0x1d, 0xc8, 0xe7, 0xa6, 0x87, 0xd4, 0x0a, 0x6b, 0xcb, 0x12, 0xba, 0x00, 0x8b, 0xe1,
-	0x21, 0x3e, 0x90, 0x58, 0x49, 0xfd, 0xe8, 0x97, 0xab, 0xe7, 0x6e, 0x7c, 0x25, 0xc1, 0x62, 0x44,
-	0x0a, 0x8d, 0x2e, 0xc3, 0xd3, 0xd5, 0xed, 0xed, 0x8a, 0xaa, 0xd5, 0x0f, 0x4a, 0xb5, 0xfa, 0x4e,
-	0xb5, 0xa1, 0xa9, 0x95, 0xfa, 0xfd, 0xfd, 0x46, 0xe0, 0xa3, 0xeb, 0x70, 0x29, 0x1a, 0x52, 0x2a,
-	0x97, 0x2b, 0xb5, 0x86, 0x2c, 0xa1, 0x35, 0x78, 0x2a, 0x06, 0xb1, 0x55, 0x55, 0x1b, 0x72, 0x22,
-	0x5e, 0x85, 0x5a, 0xd9, 0xab, 0x94, 0x1b, 0x72, 0x12, 0x5d, 0x83, 0x2b, 0x27, 0x21, 0xb4, 0xed,
-	0xaa, 0x7a, 0xaf, 0xd4, 0x90, 0x53, 0xa7, 0x02, 0xeb, 0x95, 0x83, 0x3b, 0x15, 0x55, 0x4e, 0x8b,
-	0x75, 0xff, 0x22, 0x01, 0xc5, 0xb8, 0x4c, 0x9d, 0xea, 0x2a, 0xd5, 0x6a, 0xfb, 0x0f, 0x7c, 0x5d,
-	0xe5, 0x9d, 0xfb, 0x07, 0x77, 0xa7, 0xb7, 0xe0, 0x59, 0x50, 0x4e, 0x02, 0x7a, 0x1b, 0x71, 0x15,
-	0x2e, 0x9f, 0x88, 0x13, 0xdb, 0x71, 0x0a, 0x4c, 0xad, 0x34, 0xd4, 0x07, 0x72, 0x12, 0x6d, 0xc0,
-	0x8d, 0x53, 0x61, 0xde, 0x98, 0x9c, 0x42, 0x9b, 0x70, 0xf3, 0x64, 0x3c, 0xdf, 0x20, 0x57, 0xc0,
-	0xdd, 0xa2, 0x8f, 0x25, 0x58, 0x8e, 0x4c, 0xf9, 0xd1, 0x15, 0x58, 0xab, 0xa9, 0xd5, 0x72, 0xa5,
-	0x5e, 0xd7, 0x6a, 0x6a, 0xb5, 0x56, 0xad, 0x97, 0xf6, 0xb5, 0x7a, 0xa3, 0xd4, 0xb8, 0x5f, 0x0f,
-	0xec, 0x8d, 0x02, 0xab, 0x71, 0x20, 0x6f, 0x5f, 0x4e, 0xc0, 0x08, 0x0b, 0x70, 0xed, 0xf4, 0xe7,
-	0x12, 0x5c, 0x8c, 0x4d, 0xf1, 0xd1, 0x75, 0x78, 0xe6, 0xb0, 0xa2, 0xee, 0x6e, 0x3f, 0xd0, 0x0e,
-	0xab, 0x8d, 0x8a, 0x56, 0x79, 0xb7, 0x51, 0x39, 0xa8, 0xef, 0x56, 0x0f, 0xa6, 0x67, 0x75, 0x0d,
-	0xae, 0x9c, 0x88, 0xf4, 0xa6, 0x76, 0x1a, 0x70, 0x62, 0x7e, 0x3f, 0x90, 0x60, 0x7e, 0xc2, 0x17,
-	0xa2, 0x4b, 0x50, 0xbc, 0xb7, 0x5b, 0xdf, 0xaa, 0xec, 0x94, 0x0e, 0x77, 0xab, 0xea, 0xe4, 0x9d,
-	0xbd, 0x02, 0x6b, 0x53, 0xa3, 0x77, 0xee, 0xd7, 0xf6, 0x77, 0xcb, 0xa5, 0x46, 0x85, 0x7d, 0x54,
-	0x96, 0xe8, 0xc2, 0xa6, 0x40, 0xfb, 0xbb, 0x6f, 0xef, 0x34, 0xb4, 0xf2, 0xfe, 0x6e, 0xe5, 0xa0,
-	0xa1, 0x95, 0x1a, 0x8d, 0x92, 0x7f, 0x9d, 0xb7, 0xee, 0x7e, 0xfa, 0xc5, 0xaa, 0xf4, 0xd9, 0x17,
-	0xab, 0xd2, 0x5f, 0xbf, 0x58, 0x95, 0x3e, 0xf9, 0x72, 0xf5, 0xdc, 0x67, 0x5f, 0xae, 0x9e, 0xfb,
-	0xf3, 0x97, 0xab, 0xe7, 0x1e, 0xde, 0xea, 0x1a, 0xa4, 0x37, 0x6a, 0x52, 0x2f, 0xbc, 0xe9, 0xff,
-	0x0d, 0xd4, 0xfb, 0xff, 0xa8, 0x65, 0x6c, 0x4e, 0xfe, 0x99, 0xb4, 0x39, 0xc3, 0xdc, 0xea, 0x8b,
-	0xff, 0x08, 0x00, 0x00, 0xff, 0xff, 0xd2, 0x5c, 0x57, 0x37, 0x67, 0x2a, 0x00, 0x00,
+	// 3225 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x5a, 0x4f, 0x6c, 0x1b, 0xc7,
+	0xd5, 0xf7, 0x92, 0x4b, 0x89, 0x7c, 0x24, 0xa5, 0xd5, 0x48, 0xb2, 0x69, 0xc5, 0x91, 0xe4, 0x75,
+	0x1c, 0x3b, 0x76, 0x22, 0x7d, 0x76, 0xf2, 0xe5, 0xcf, 0x97, 0x2f, 0x09, 0x28, 0x9a, 0x8a, 0x24,
+	0xcb, 0x12, 0xb3, 0xa4, 0xf5, 0xc5, 0xc6, 0xd7, 0x6e, 0x96, 0xe4, 0x50, 0xdc, 0x98, 0xe4, 0x6e,
+	0x76, 0x87, 0x0a, 0xd5, 0x9e, 0x5a, 0x34, 0x45, 0x91, 0x53, 0x2e, 0x05, 0x8a, 0xa2, 0x05, 0x0a,
+	0x14, 0x3d, 0x15, 0xe8, 0xa1, 0xa7, 0x5e, 0x7a, 0x2d, 0x72, 0x6a, 0x73, 0xec, 0x29, 0x2d, 0x92,
+	0x5b, 0xef, 0x01, 0x7a, 0x2c, 0xe6, 0xcf, 0xfe, 0x23, 0x77, 0x25, 0xd9, 0x49, 0x0f, 0x45, 0x7b,
+	0xdb, 0x99, 0x79, 0xef, 0xcd, 0xcc, 0x9b, 0x37, 0xef, 0xcf, 0x6f, 0x16, 0x2e, 0xb5, 0xac, 0x3e,
+	0x26, 0xcd, 0x0e, 0x59, 0x37, 0x9a, 0x2d, 0x73, 0xfd, 0xe8, 0xd6, 0x3a, 0x39, 0xb6, 0xb1, 0xbb,
+	0x66, 0x3b, 0x16, 0xb1, 0x90, 0xe2, 0x8d, 0xae, 0xd1, 0xd1, 0xb5, 0xa3, 0x5b, 0x4b, 0xcb, 0x3e,
+	0x7d, 0xcb, 0x39, 0xb6, 0x89, 0x45, 0x39, 0x6c, 0xc7, 0xb2, 0x3a, 0x9c, 0x23, 0x34, 0xce, 0xe4,
+	0xb0, 0x61, 0xc3, 0x31, 0xfa, 0x42, 0xe2, 0xd2, 0xe5, 0xc9, 0xf1, 0x23, 0xa3, 0x67, 0xb6, 0x0d,
+	0x62, 0x39, 0x82, 0x64, 0xe1, 0xd0, 0x3a, 0xb4, 0xd8, 0xe7, 0x3a, 0xfd, 0x12, 0xbd, 0x2b, 0x87,
+	0x96, 0x75, 0xd8, 0xc3, 0xeb, 0xac, 0xd5, 0x1c, 0x76, 0xd6, 0x89, 0xd9, 0xc7, 0x2e, 0x31, 0xfa,
+	0xb6, 0x37, 0xf3, 0x38, 0x41, 0x7b, 0xe8, 0x18, 0xc4, 0xb4, 0x06, 0x7c, 0x5c, 0xfd, 0x53, 0x0e,
+	0xa6, 0x35, 0xfc, 0xc1, 0x10, 0xbb, 0x04, 0xbd, 0x08, 0x32, 0x6e, 0x75, 0xad, 0x92, 0xb4, 0x2a,
+	0x5d, 0xcf, 0xdf, 0x7e, 0x7a, 0x6d, 0x7c, 0x9b, 0x6b, 0xd5, 0x56, 0xd7, 0x12, 0xc4, 0x5b, 0xe7,
+	0x34, 0x46, 0x8c, 0x5e, 0x86, 0x4c, 0xa7, 0x37, 0x74, 0xbb, 0xa5, 0x14, 0xe3, 0x5a, 0x9e, 0xe4,
+	0xda, 0xa4, 0xc3, 0x01, 0x1b, 0x27, 0xa7, 0x93, 0x99, 0x83, 0x8e, 0x55, 0x4a, 0x27, 0x4d, 0xb6,
+	0x3d, 0xe8, 0x84, 0x27, 0xa3, 0xc4, 0xa8, 0x02, 0x60, 0x0e, 0x4c, 0xa2, 0xb7, 0xba, 0x86, 0x39,
+	0x28, 0x65, 0x18, 0xab, 0x1a, 0xc7, 0x6a, 0x92, 0x0a, 0x25, 0x09, 0xf8, 0x73, 0xa6, 0xd7, 0x47,
+	0x57, 0xfc, 0xc1, 0x10, 0x3b, 0xc7, 0xa5, 0xa9, 0xa4, 0x15, 0xbf, 0x43, 0x87, 0x43, 0x2b, 0x66,
+	0xe4, 0xe8, 0x0d, 0xc8, 0xb6, 0xba, 0xb8, 0xf5, 0x48, 0x27, 0xa3, 0x52, 0x96, 0xb1, 0xae, 0x4e,
+	0xb2, 0x56, 0x28, 0x45, 0x63, 0x14, 0x30, 0x4f, 0xb7, 0x78, 0x0f, 0x7a, 0x0d, 0xa6, 0x5a, 0x56,
+	0xbf, 0x6f, 0x92, 0x52, 0x9e, 0x31, 0xaf, 0xc4, 0x30, 0xb3, 0xf1, 0x80, 0x57, 0x30, 0xa0, 0x7d,
+	0x98, 0xe9, 0x99, 0x2e, 0xd1, 0xdd, 0x81, 0x61, 0xbb, 0x5d, 0x8b, 0xb8, 0xa5, 0x02, 0x13, 0xf1,
+	0xec, 0xa4, 0x88, 0x5d, 0xd3, 0x25, 0x75, 0x8f, 0x2c, 0x90, 0x54, 0xec, 0x85, 0xfb, 0xa9, 0x40,
+	0xab, 0xd3, 0xc1, 0x8e, 0x2f, 0xb1, 0x54, 0x4c, 0x12, 0xb8, 0x4f, 0xe9, 0x3c, 0xce, 0x90, 0x40,
+	0x2b, 0xdc, 0x8f, 0xfe, 0x1f, 0xe6, 0x7b, 0x96, 0xd1, 0xf6, 0xe5, 0xe9, 0xad, 0xee, 0x70, 0xf0,
+	0xa8, 0x34, 0xc3, 0xa4, 0xde, 0x88, 0x59, 0xa6, 0x65, 0xb4, 0x3d, 0xe6, 0x0a, 0x25, 0x0d, 0x24,
+	0xcf, 0xf5, 0xc6, 0xc7, 0x90, 0x0e, 0x0b, 0x86, 0x6d, 0xf7, 0x8e, 0xc7, 0xc5, 0xcf, 0x32, 0xf1,
+	0x37, 0x27, 0xc5, 0x97, 0x29, 0x75, 0x82, 0x7c, 0x64, 0x4c, 0x0c, 0xa2, 0xfb, 0xa0, 0xd8, 0x0e,
+	0xb6, 0x0d, 0x07, 0xeb, 0xb6, 0x63, 0xd9, 0x96, 0x6b, 0xf4, 0x4a, 0x0a, 0x13, 0x7e, 0x7d, 0x52,
+	0x78, 0x8d, 0x53, 0xd6, 0x04, 0x61, 0x20, 0x79, 0xd6, 0x8e, 0x8e, 0x70, 0xb1, 0x56, 0x0b, 0xbb,
+	0x6e, 0x20, 0x76, 0x2e, 0x59, 0x2c, 0xa3, 0x8c, 0x15, 0x1b, 0x19, 0x41, 0x9b, 0x90, 0xc7, 0x23,
+	0x82, 0x07, 0x6d, 0xfd, 0xc8, 0x22, 0xb8, 0x84, 0x98, 0xc4, 0x2b, 0x31, 0xd7, 0x95, 0x11, 0x1d,
+	0x58, 0x04, 0x07, 0xc2, 0x00, 0xfb, 0x9d, 0xa8, 0x09, 0x8b, 0x47, 0xd8, 0x31, 0x3b, 0xc7, 0x4c,
+	0x8e, 0xce, 0x46, 0x5c, 0xd3, 0x1a, 0x94, 0xe6, 0x99, 0xc4, 0xe7, 0x27, 0x25, 0x1e, 0x30, 0x72,
+	0xca, 0x5c, 0xf5, 0x88, 0x03, 0xd1, 0xf3, 0x47, 0x93, 0xa3, 0xd4, 0xd2, 0x3a, 0xe6, 0xc0, 0xe8,
+	0x99, 0xdf, 0xc1, 0x7a, 0xb3, 0x67, 0xb5, 0x1e, 0x95, 0x16, 0x92, 0x2c, 0x6d, 0x53, 0xd0, 0x6d,
+	0x50, 0xb2, 0x90, 0xa5, 0x75, 0xc2, 0xfd, 0x1b, 0xd3, 0x90, 0x39, 0x32, 0x7a, 0x43, 0xbc, 0x23,
+	0x67, 0x65, 0x25, 0xb3, 0x23, 0x67, 0xa7, 0x95, 0xec, 0x8e, 0x9c, 0xcd, 0x29, 0xb0, 0x23, 0x67,
+	0x41, 0xc9, 0xab, 0xd7, 0x20, 0x1f, 0xf2, 0x53, 0xa8, 0x04, 0xd3, 0x7d, 0xec, 0xba, 0xc6, 0x21,
+	0x66, 0x7e, 0x2d, 0xa7, 0x79, 0x4d, 0x75, 0x06, 0x0a, 0x61, 0xd7, 0xa4, 0x7e, 0x22, 0x41, 0x3e,
+	0xe4, 0x74, 0x28, 0xe7, 0x11, 0x76, 0x98, 0x42, 0x04, 0xa7, 0x68, 0xa2, 0x2b, 0x50, 0x64, 0x7b,
+	0xd1, 0xbd, 0x71, 0xea, 0xfb, 0x64, 0xad, 0xc0, 0x3a, 0x0f, 0x04, 0xd1, 0x0a, 0xe4, 0xed, 0xdb,
+	0xb6, 0x4f, 0x92, 0x66, 0x24, 0x60, 0xdf, 0xb6, 0x3d, 0x82, 0xcb, 0x50, 0xa0, 0x5b, 0xf7, 0x29,
+	0x64, 0x36, 0x49, 0x9e, 0xf6, 0x09, 0x12, 0xf5, 0x8f, 0x29, 0x50, 0xc6, 0x9d, 0x19, 0x7a, 0x15,
+	0x64, 0xea, 0xe5, 0x85, 0x9b, 0x5e, 0x5a, 0xe3, 0x1e, 0x7e, 0xcd, 0xf3, 0xf0, 0x6b, 0x0d, 0x2f,
+	0x04, 0x6c, 0x64, 0x3f, 0xfd, 0x7c, 0xe5, 0xdc, 0x27, 0x7f, 0x59, 0x91, 0x34, 0xc6, 0x81, 0x2e,
+	0x52, 0x0f, 0x66, 0x98, 0x03, 0xdd, 0x6c, 0xb3, 0x25, 0xe7, 0xa8, 0x77, 0x32, 0xcc, 0xc1, 0x76,
+	0x1b, 0xdd, 0x03, 0xa5, 0x65, 0x0d, 0x5c, 0x3c, 0x70, 0x87, 0xae, 0xce, 0x63, 0x93, 0x70, 0xcd,
+	0x21, 0xff, 0xca, 0x83, 0x20, 0x73, 0x54, 0x82, 0xb4, 0xc6, 0x28, 0xb5, 0xd9, 0x56, 0xb4, 0x03,
+	0xbd, 0x0d, 0xe0, 0x07, 0x30, 0xb7, 0x24, 0xaf, 0xa6, 0xaf, 0xe7, 0x6f, 0x5f, 0x8e, 0xb1, 0x27,
+	0x8f, 0xe6, 0xbe, 0xdd, 0x36, 0x08, 0xde, 0x90, 0xe9, 0x82, 0xb5, 0x10, 0x2b, 0x7a, 0x16, 0x66,
+	0x0d, 0xdb, 0xd6, 0x5d, 0x62, 0x10, 0xac, 0x37, 0x8f, 0x09, 0x76, 0x99, 0xdb, 0x2f, 0x68, 0x45,
+	0xc3, 0xb6, 0xeb, 0xb4, 0x77, 0x83, 0x76, 0xa2, 0xab, 0x30, 0x43, 0x3d, 0xbc, 0x69, 0xf4, 0xf4,
+	0x2e, 0x36, 0x0f, 0xbb, 0x84, 0x79, 0xf7, 0xb4, 0x56, 0x14, 0xbd, 0x5b, 0xac, 0x53, 0x6d, 0x43,
+	0x21, 0xec, 0xdc, 0x11, 0x02, 0xb9, 0x6d, 0x10, 0x83, 0xe9, 0xb2, 0xa0, 0xb1, 0x6f, 0xda, 0x67,
+	0x1b, 0xa4, 0x2b, 0x34, 0xc4, 0xbe, 0xd1, 0x79, 0x98, 0x12, 0x62, 0xd3, 0x4c, 0xac, 0x68, 0xa1,
+	0x05, 0xc8, 0xd8, 0x8e, 0x75, 0x84, 0xd9, 0xe1, 0x65, 0x35, 0xde, 0x50, 0x1f, 0xc0, 0x4c, 0x34,
+	0x0e, 0xa0, 0x19, 0x48, 0x91, 0x91, 0x98, 0x25, 0x45, 0x46, 0xe8, 0x16, 0xc8, 0x54, 0x99, 0x4c,
+	0xda, 0x4c, 0x5c, 0xf4, 0x13, 0xfc, 0x8d, 0x63, 0x1b, 0x6b, 0x8c, 0x74, 0x47, 0xce, 0xa6, 0x94,
+	0xb4, 0x3a, 0x0b, 0xc5, 0x48, 0x94, 0x50, 0xcf, 0xc3, 0x42, 0x9c, 0xcf, 0x57, 0x4d, 0x58, 0x88,
+	0x73, 0xdd, 0xe8, 0x65, 0xc8, 0xfa, 0x4e, 0xdf, 0xb3, 0xa0, 0x89, 0xd9, 0x7d, 0x26, 0x9f, 0x96,
+	0xda, 0x0e, 0x3d, 0x88, 0xae, 0x21, 0x42, 0x7d, 0x41, 0x9b, 0x36, 0x6c, 0x7b, 0xcb, 0x70, 0xbb,
+	0xea, 0x7b, 0x50, 0x4a, 0xf2, 0xe7, 0x21, 0xc5, 0x49, 0xec, 0x02, 0x78, 0x8a, 0x3b, 0x0f, 0x53,
+	0x1d, 0xcb, 0xe9, 0x1b, 0x84, 0x09, 0x2b, 0x6a, 0xa2, 0x45, 0x15, 0xca, 0x7d, 0x7b, 0x9a, 0x75,
+	0xf3, 0x86, 0xaa, 0xc3, 0xc5, 0x44, 0x97, 0x4e, 0x59, 0xcc, 0x41, 0x1b, 0x73, 0xf5, 0x16, 0x35,
+	0xde, 0x08, 0x04, 0xf1, 0xc5, 0xf2, 0x06, 0x9d, 0xd6, 0xc5, 0x83, 0x36, 0x76, 0x98, 0xfc, 0x9c,
+	0x26, 0x5a, 0xea, 0x4f, 0xd3, 0x70, 0x3e, 0xde, 0xaf, 0xa3, 0x55, 0x28, 0xf4, 0x8d, 0x91, 0x4e,
+	0x46, 0xc2, 0xfc, 0x24, 0x66, 0x00, 0xd0, 0x37, 0x46, 0x8d, 0x11, 0xb7, 0x3d, 0x05, 0xd2, 0x64,
+	0xe4, 0x96, 0x52, 0xab, 0xe9, 0xeb, 0x05, 0x8d, 0x7e, 0xa2, 0x03, 0x98, 0xeb, 0x59, 0x2d, 0xa3,
+	0xa7, 0xf7, 0x0c, 0x97, 0xe8, 0x22, 0xec, 0xf3, 0xeb, 0xf4, 0x4c, 0x92, 0x9f, 0xc6, 0x6d, 0x7e,
+	0xb0, 0xd4, 0x05, 0x89, 0x8b, 0x30, 0xcb, 0x84, 0xec, 0x1a, 0x2e, 0xe1, 0x43, 0xa8, 0x0a, 0xf9,
+	0xbe, 0xe9, 0x36, 0x71, 0xd7, 0x38, 0x32, 0x2d, 0x47, 0xdc, 0xab, 0x18, 0xeb, 0xb9, 0x17, 0x10,
+	0x09, 0x51, 0x61, 0xbe, 0xd0, 0xa1, 0x64, 0x22, 0xd6, 0xec, 0x79, 0x96, 0xa9, 0xc7, 0xf6, 0x2c,
+	0xff, 0x05, 0x0b, 0x03, 0x3c, 0x22, 0x7a, 0x70, 0x73, 0xb9, 0xa5, 0x4c, 0x33, 0xe5, 0x23, 0x3a,
+	0xe6, 0xdf, 0x75, 0x97, 0x1a, 0x0d, 0x7a, 0x8e, 0xc5, 0x46, 0xdb, 0x72, 0xb1, 0xa3, 0x1b, 0xed,
+	0xb6, 0x83, 0x5d, 0x97, 0x65, 0x55, 0x05, 0x16, 0xef, 0x58, 0x7f, 0x99, 0x77, 0xab, 0x1f, 0xb3,
+	0xc3, 0x89, 0x8b, 0x8e, 0x9e, 0xea, 0xa5, 0x40, 0xf5, 0x0d, 0x58, 0x10, 0xfc, 0xed, 0x88, 0xf6,
+	0x79, 0x7a, 0x7a, 0x29, 0x29, 0xe9, 0x0a, 0x69, 0x1d, 0x79, 0xfc, 0xc9, 0x8a, 0x4f, 0x3f, 0xa1,
+	0xe2, 0x11, 0xc8, 0x4c, 0x2d, 0x32, 0x77, 0x37, 0xf4, 0xfb, 0x5f, 0xed, 0x30, 0x3e, 0x4a, 0xc3,
+	0xdc, 0x44, 0x62, 0xe1, 0x6f, 0x4c, 0x8a, 0xdd, 0x58, 0x2a, 0x76, 0x63, 0xe9, 0xc7, 0xde, 0x98,
+	0x38, 0x6d, 0xf9, 0xf4, 0xd3, 0xce, 0x7c, 0x93, 0xa7, 0x3d, 0xf5, 0x84, 0xa7, 0xfd, 0x4f, 0x3d,
+	0x87, 0x9f, 0x49, 0xb0, 0x94, 0x9c, 0x8e, 0xc5, 0x1e, 0xc8, 0x4d, 0x98, 0xf3, 0x97, 0xe2, 0x8b,
+	0xe7, 0xee, 0x51, 0xf1, 0x07, 0x84, 0xfc, 0xc4, 0x88, 0x77, 0x15, 0x66, 0xc6, 0xb2, 0x45, 0x6e,
+	0xcc, 0xc5, 0xa3, 0xf0, 0x32, 0xd4, 0xdf, 0xa6, 0x61, 0x21, 0x2e, 0xa1, 0x8b, 0xb9, 0xb1, 0x1a,
+	0xcc, 0xb7, 0x71, 0xcb, 0x6c, 0x3f, 0xf1, 0x85, 0x9d, 0x13, 0xec, 0xff, 0xb9, 0xaf, 0x93, 0x76,
+	0x82, 0x6e, 0xc0, 0x9c, 0x7b, 0x3c, 0x68, 0x99, 0x83, 0x43, 0x9d, 0x58, 0x5e, 0x6e, 0x94, 0x63,
+	0x2b, 0x9f, 0x15, 0x03, 0x0d, 0x4b, 0x64, 0x47, 0xbf, 0x02, 0xc8, 0x6a, 0xd8, 0xb5, 0x69, 0x32,
+	0x87, 0x2a, 0x90, 0xc3, 0xa3, 0x16, 0xb6, 0x89, 0x97, 0x00, 0x27, 0xd4, 0x18, 0x82, 0xc4, 0xe3,
+	0xa3, 0xb5, 0xb6, 0xcf, 0x87, 0x5e, 0x12, 0x90, 0x42, 0x22, 0x38, 0xc0, 0x53, 0x75, 0x9f, 0x95,
+	0x63, 0x0a, 0xaf, 0x78, 0x98, 0x42, 0x3a, 0xa9, 0x52, 0x16, 0x89, 0xbb, 0xcf, 0x27, 0x40, 0x85,
+	0x97, 0x04, 0xa8, 0x20, 0x27, 0x4d, 0xc7, 0xf3, 0xfb, 0x60, 0x3a, 0x86, 0x2a, 0xdc, 0x89, 0xa0,
+	0x0a, 0x53, 0x49, 0x5b, 0x0d, 0x25, 0xe2, 0xc1, 0x56, 0x03, 0x58, 0xe1, 0x15, 0x0f, 0x56, 0x98,
+	0x4e, 0x5a, 0xb4, 0xc8, 0x3c, 0x83, 0x45, 0x73, 0x5c, 0xe1, 0xcd, 0x10, 0xae, 0x90, 0x63, 0xbc,
+	0x97, 0x4f, 0xc0, 0x15, 0x7c, 0x6e, 0x1f, 0x58, 0xf8, 0x1f, 0x1f, 0x58, 0x28, 0x24, 0xa2, 0x12,
+	0x22, 0x65, 0xf4, 0x99, 0x3d, 0x64, 0xa1, 0x36, 0x81, 0x2c, 0x70, 0x20, 0xe0, 0xda, 0xa9, 0xc8,
+	0x82, 0x2f, 0x6a, 0x0c, 0x5a, 0xa8, 0x4d, 0x40, 0x0b, 0x33, 0x49, 0x12, 0xc7, 0xf2, 0xd3, 0x40,
+	0x62, 0x14, 0x5b, 0xf8, 0x56, 0x3c, 0xb6, 0x90, 0x58, 0xfc, 0xc7, 0xe4, 0xa2, 0xbe, 0xe8, 0x18,
+	0x70, 0xe1, 0xbd, 0x04, 0x70, 0x41, 0x49, 0x2a, 0x82, 0xe3, 0x32, 0x51, 0x7f, 0x82, 0x38, 0x74,
+	0xe1, 0x20, 0x06, 0x5d, 0xe0, 0x30, 0xc0, 0x73, 0x67, 0x40, 0x17, 0x7c, 0xd1, 0x13, 0xf0, 0xc2,
+	0x41, 0x0c, 0xbc, 0x80, 0x92, 0xe5, 0x8e, 0x25, 0x50, 0x61, 0xb9, 0x51, 0x7c, 0xe1, 0xed, 0x28,
+	0xbe, 0x30, 0x7f, 0x72, 0xde, 0xca, 0xd3, 0x00, 0x5f, 0x5a, 0x18, 0x60, 0x68, 0x25, 0x01, 0x0c,
+	0x1c, 0x03, 0x78, 0xe1, 0x8c, 0x00, 0x83, 0x2f, 0x3b, 0x16, 0x61, 0xa8, 0x4d, 0x20, 0x0c, 0x8b,
+	0x49, 0x06, 0x37, 0x16, 0x90, 0x02, 0x83, 0x4b, 0x84, 0x18, 0x32, 0xca, 0xd4, 0x8e, 0x9c, 0xcd,
+	0x2a, 0x39, 0x0e, 0x2e, 0xec, 0xc8, 0xd9, 0xbc, 0x52, 0x50, 0x9f, 0xa3, 0x29, 0xd0, 0x98, 0xdf,
+	0xa3, 0x05, 0x07, 0x76, 0x1c, 0xcb, 0x11, 0x60, 0x01, 0x6f, 0xa8, 0xd7, 0xa1, 0x10, 0x76, 0x71,
+	0x27, 0xc0, 0x11, 0xb3, 0x50, 0x8c, 0x78, 0x35, 0xf5, 0x77, 0x12, 0x14, 0xc2, 0xfe, 0x2a, 0x52,
+	0xac, 0xe6, 0x44, 0xb1, 0x1a, 0x02, 0x29, 0x52, 0x51, 0x90, 0x62, 0x05, 0xf2, 0xb4, 0x60, 0x1b,
+	0xc3, 0x1f, 0x0c, 0xdb, 0xc7, 0x1f, 0x6e, 0xc0, 0x1c, 0x8b, 0xb7, 0x1c, 0xca, 0x10, 0x91, 0x41,
+	0xe6, 0x91, 0x81, 0x0e, 0x30, 0x65, 0xf0, 0xc8, 0x80, 0x5e, 0x80, 0xf9, 0x10, 0xad, 0x5f, 0x08,
+	0xf2, 0x52, 0x5c, 0xf1, 0xa9, 0xcb, 0xa2, 0x22, 0xfc, 0x83, 0x04, 0x73, 0x13, 0xee, 0x32, 0x16,
+	0x63, 0x90, 0xbe, 0x29, 0x8c, 0x21, 0xf5, 0xe4, 0x18, 0x43, 0xb8, 0xb4, 0x4d, 0x47, 0x4b, 0xdb,
+	0xbf, 0x4b, 0x50, 0x8c, 0xb8, 0x6d, 0x7a, 0x08, 0x2d, 0xab, 0x8d, 0x45, 0xb1, 0xc9, 0xbe, 0x69,
+	0x4e, 0xd3, 0xb3, 0x0e, 0x45, 0x49, 0x49, 0x3f, 0x29, 0x95, 0x1f, 0x88, 0x72, 0x22, 0xcc, 0xf8,
+	0x75, 0x2a, 0xcf, 0x1b, 0x44, 0x9d, 0xaa, 0x40, 0xfa, 0x11, 0xe6, 0x58, 0x74, 0x41, 0xa3, 0x9f,
+	0x94, 0x8e, 0x99, 0x9f, 0x88, 0xff, 0xbc, 0x81, 0x5e, 0x83, 0x1c, 0x7b, 0x51, 0xd0, 0x2d, 0xdb,
+	0x15, 0xf0, 0x73, 0x28, 0x37, 0xe2, 0xcf, 0x0e, 0xe2, 0x9e, 0x5b, 0x9d, 0x7d, 0xdb, 0xd5, 0xb2,
+	0xb6, 0xf8, 0x0a, 0x65, 0x2c, 0xb9, 0x48, 0xc6, 0x72, 0x09, 0x72, 0x74, 0xf9, 0xae, 0x6d, 0xb4,
+	0x70, 0x09, 0xd8, 0x4a, 0x83, 0x0e, 0xf5, 0xd7, 0x29, 0x98, 0x1d, 0x8b, 0x3a, 0xb1, 0x9b, 0xf7,
+	0xac, 0x32, 0x15, 0x82, 0x50, 0xce, 0xa6, 0x90, 0x65, 0x80, 0x43, 0xc3, 0xd5, 0x3f, 0x34, 0x06,
+	0x04, 0xb7, 0x85, 0x56, 0x42, 0x3d, 0x68, 0x09, 0xb2, 0xb4, 0x35, 0x74, 0x71, 0x5b, 0xa0, 0x39,
+	0x7e, 0x1b, 0x6d, 0xc3, 0x14, 0x3e, 0xc2, 0x03, 0xe2, 0x96, 0xa6, 0xd9, 0xc1, 0x5f, 0x88, 0x71,
+	0x4f, 0x74, 0x7c, 0xa3, 0x44, 0x8f, 0xfb, 0x6f, 0x9f, 0xaf, 0x28, 0x9c, 0xfc, 0x79, 0xab, 0x6f,
+	0x12, 0xdc, 0xb7, 0xc9, 0xb1, 0x26, 0x04, 0x44, 0xd5, 0x90, 0x1d, 0x53, 0x03, 0x83, 0x16, 0x0b,
+	0x1e, 0x4e, 0x40, 0x95, 0x6a, 0x5a, 0x8e, 0x49, 0x8e, 0xb5, 0x62, 0x1f, 0xf7, 0x6d, 0xcb, 0xea,
+	0xe9, 0xfc, 0x9e, 0x97, 0x61, 0x26, 0x1a, 0x64, 0xd1, 0x15, 0x28, 0x3a, 0x98, 0x18, 0xe6, 0x40,
+	0x8f, 0xe4, 0xd1, 0x05, 0xde, 0xc9, 0xef, 0xd5, 0x8e, 0x9c, 0x95, 0x94, 0x94, 0x80, 0x76, 0xde,
+	0x81, 0xc5, 0xd8, 0x18, 0x8b, 0x5e, 0x85, 0x5c, 0x10, 0x9f, 0x25, 0xb6, 0xdd, 0x93, 0x30, 0x9b,
+	0x80, 0x58, 0x3d, 0x80, 0xc5, 0xd8, 0x20, 0x8b, 0xde, 0x80, 0x29, 0x07, 0xbb, 0xc3, 0x1e, 0x87,
+	0x65, 0x66, 0x6e, 0x5f, 0x3d, 0x3d, 0x3a, 0x0f, 0x7b, 0x44, 0x13, 0x4c, 0xea, 0x2d, 0xb8, 0x98,
+	0x18, 0x65, 0x03, 0xe4, 0x45, 0x0a, 0x21, 0x2f, 0xea, 0x6f, 0x24, 0x58, 0x4a, 0x8e, 0x9c, 0x68,
+	0x63, 0x6c, 0x41, 0x37, 0xce, 0x18, 0x77, 0x43, 0xab, 0xa2, 0xa5, 0x89, 0x83, 0x3b, 0x98, 0xb4,
+	0xba, 0x3c, 0x84, 0x73, 0xa7, 0x50, 0xd4, 0x8a, 0xa2, 0x97, 0xf1, 0xb8, 0x9c, 0xec, 0x7d, 0xdc,
+	0x22, 0x3a, 0x3f, 0x54, 0x97, 0x95, 0x07, 0x39, 0x4a, 0x46, 0x7b, 0xeb, 0xbc, 0x53, 0x7d, 0x0b,
+	0x2e, 0x24, 0xc4, 0xe2, 0x98, 0x1a, 0x06, 0x81, 0xdc, 0xec, 0x59, 0x4d, 0xef, 0x12, 0xd0, 0x6f,
+	0xf5, 0x21, 0x15, 0x10, 0x1b, 0x74, 0xd1, 0x5b, 0x30, 0xe5, 0x12, 0x83, 0x0c, 0x5d, 0xb1, 0xdb,
+	0x6b, 0xa7, 0xc6, 0xeb, 0x3a, 0x23, 0xd7, 0x04, 0x9b, 0xfa, 0x3a, 0xa0, 0xc9, 0xe8, 0x1b, 0x53,
+	0x9b, 0x49, 0x71, 0xb5, 0x59, 0x13, 0x9e, 0x3a, 0x21, 0xce, 0xa2, 0xca, 0xd8, 0xe2, 0x6e, 0x9e,
+	0x29, 0x4c, 0x8f, 0x2d, 0xf0, 0xf7, 0x69, 0x58, 0x8c, 0x0d, 0xb7, 0xa1, 0x9b, 0x2b, 0x7d, 0xdd,
+	0x9b, 0xfb, 0x06, 0x00, 0x19, 0xe9, 0xfc, 0xf4, 0xbd, 0x08, 0x10, 0x57, 0x63, 0x8c, 0x70, 0x8b,
+	0x39, 0x31, 0x6a, 0x2c, 0x39, 0x22, 0xbe, 0x5c, 0xd4, 0x08, 0xd7, 0xc3, 0x43, 0x16, 0x1d, 0x5c,
+	0x51, 0x2a, 0x9e, 0x39, 0x8e, 0x04, 0x85, 0x33, 0xef, 0x76, 0xd1, 0x43, 0xb8, 0x30, 0x16, 0xe5,
+	0x7c, 0xd9, 0xf2, 0x99, 0x83, 0xdd, 0x62, 0x34, 0xd8, 0x79, 0xb2, 0xc3, 0x91, 0x2a, 0x13, 0x89,
+	0x54, 0x34, 0xb8, 0xb2, 0x22, 0x92, 0x47, 0xe8, 0x36, 0xee, 0x19, 0xde, 0x03, 0xe7, 0xc5, 0x89,
+	0x52, 0xf4, 0x8e, 0x78, 0x03, 0xe6, 0x95, 0xe8, 0x4f, 0x68, 0x25, 0x3a, 0x43, 0x99, 0xd9, 0x41,
+	0xdd, 0xa1, 0xac, 0xea, 0x43, 0x80, 0xa0, 0xce, 0xa6, 0x57, 0xda, 0xb1, 0x86, 0x83, 0x36, 0xb3,
+	0x88, 0x8c, 0xc6, 0x1b, 0xe8, 0x65, 0xc8, 0x50, 0xc3, 0xf2, 0x34, 0x1f, 0xe3, 0x93, 0xa8, 0x85,
+	0x84, 0x0a, 0x75, 0x4e, 0xae, 0xbe, 0xef, 0x19, 0x6f, 0x18, 0xf2, 0x4c, 0x98, 0xe3, 0xcd, 0xe8,
+	0x1c, 0x6a, 0x32, 0x7a, 0x1a, 0x3f, 0xd7, 0x77, 0x21, 0xc3, 0xac, 0x89, 0xde, 0x50, 0x86, 0xb8,
+	0x8b, 0xe4, 0x89, 0x7e, 0xa3, 0x6f, 0x03, 0x18, 0x84, 0x38, 0x66, 0x73, 0x18, 0xcc, 0xb0, 0x9a,
+	0x60, 0x8e, 0x65, 0x8f, 0x70, 0xe3, 0x92, 0xb0, 0xcb, 0x85, 0x80, 0x37, 0x64, 0x9b, 0x21, 0x89,
+	0xea, 0x1e, 0xcc, 0x44, 0x79, 0xbd, 0x68, 0xcf, 0x17, 0x11, 0x8d, 0xf6, 0x3c, 0x7d, 0x13, 0xd1,
+	0xde, 0xcf, 0x15, 0xd2, 0xfc, 0x5d, 0x81, 0x35, 0xd4, 0xef, 0xa5, 0xa0, 0x10, 0x36, 0xe6, 0x7f,
+	0xc3, 0x78, 0xac, 0xfe, 0x50, 0x82, 0xac, 0xbf, 0xff, 0xe8, 0xeb, 0x42, 0xe4, 0x59, 0x86, 0xab,
+	0x2f, 0x15, 0x7e, 0x12, 0xe0, 0x8f, 0x30, 0x69, 0xff, 0x11, 0xe6, 0x7f, 0xfd, 0x98, 0x93, 0x88,
+	0x17, 0x84, 0xb5, 0x2d, 0x0c, 0xcb, 0x8b, 0x81, 0xaf, 0x43, 0xce, 0x77, 0x09, 0x34, 0x0d, 0xf7,
+	0x70, 0x18, 0x49, 0xdc, 0x4b, 0x81, 0xbf, 0x2c, 0x40, 0xc6, 0xb6, 0x3e, 0x14, 0x0f, 0x0e, 0x69,
+	0x8d, 0x37, 0x54, 0x17, 0x66, 0xc7, 0xfc, 0x49, 0x40, 0x98, 0x0a, 0x11, 0x22, 0x15, 0x8a, 0xf6,
+	0xb0, 0xa9, 0x3f, 0xc2, 0xc7, 0xe2, 0xf9, 0x81, 0x2f, 0x3f, 0x6f, 0x0f, 0x9b, 0x77, 0xf1, 0x31,
+	0x7f, 0x7f, 0x58, 0x85, 0x82, 0x47, 0xc3, 0x4c, 0x9c, 0x9f, 0x29, 0x70, 0x92, 0x06, 0x7f, 0x3b,
+	0x92, 0x94, 0x94, 0xfa, 0x63, 0x09, 0xb2, 0xde, 0x2d, 0x41, 0x6f, 0x41, 0xce, 0x77, 0x5d, 0x22,
+	0x0b, 0x7f, 0xea, 0x04, 0xa7, 0x27, 0x36, 0x1f, 0xf0, 0xa0, 0x0d, 0xef, 0x11, 0xd4, 0x6c, 0xeb,
+	0x9d, 0x9e, 0x71, 0x28, 0xde, 0xb2, 0x96, 0x63, 0xbc, 0x1b, 0xf3, 0x2b, 0xdb, 0x77, 0x36, 0x7b,
+	0xc6, 0xa1, 0x96, 0x67, 0x4c, 0xdb, 0x6d, 0xda, 0x10, 0x89, 0xcf, 0x57, 0x12, 0x28, 0xe3, 0xb7,
+	0xf8, 0xeb, 0xaf, 0x6f, 0x32, 0x18, 0xa6, 0x63, 0x82, 0x21, 0x5a, 0x87, 0x79, 0x9f, 0x42, 0x77,
+	0xcd, 0xc3, 0x81, 0x41, 0x86, 0x0e, 0x16, 0x88, 0x1f, 0xf2, 0x87, 0xea, 0xde, 0xc8, 0xe4, 0xbe,
+	0x33, 0x4f, 0xba, 0xef, 0x8f, 0x52, 0x90, 0x0f, 0x01, 0x90, 0xe8, 0xbf, 0x43, 0x2e, 0x6a, 0x26,
+	0x2e, 0x04, 0x85, 0x88, 0x83, 0x87, 0xc1, 0xa8, 0xa6, 0x52, 0x4f, 0xa0, 0xa9, 0x24, 0xa8, 0xd7,
+	0x43, 0x34, 0xe5, 0xc7, 0x46, 0x34, 0x9f, 0x07, 0x44, 0x2c, 0x62, 0xf4, 0x68, 0xdd, 0x6f, 0x0e,
+	0x0e, 0x75, 0x6e, 0xd8, 0xdc, 0xa3, 0x28, 0x6c, 0xe4, 0x80, 0x0d, 0xd4, 0xd8, 0x65, 0xf8, 0xbe,
+	0x04, 0x59, 0x1f, 0xed, 0x79, 0xdc, 0x07, 0xc3, 0xf3, 0x30, 0x25, 0x92, 0x3d, 0xfe, 0x62, 0x28,
+	0x5a, 0xb1, 0xd0, 0xed, 0x12, 0x64, 0xfb, 0x98, 0x18, 0xcc, 0x3d, 0xf2, 0xf0, 0xe9, 0xb7, 0x6f,
+	0x34, 0x21, 0x1f, 0x7a, 0x73, 0x45, 0x17, 0x61, 0xb1, 0xb2, 0x55, 0xad, 0xdc, 0xd5, 0x1b, 0xef,
+	0xea, 0x8d, 0x07, 0xb5, 0xaa, 0x7e, 0x7f, 0xef, 0xee, 0xde, 0xfe, 0xff, 0xed, 0x29, 0xe7, 0x26,
+	0x87, 0xb4, 0x2a, 0x6b, 0x2b, 0x12, 0xba, 0x00, 0xf3, 0xd1, 0x21, 0x3e, 0x90, 0x5a, 0x92, 0x7f,
+	0xf4, 0xcb, 0xe5, 0x73, 0x37, 0xbe, 0x92, 0x60, 0x3e, 0x26, 0xad, 0x46, 0x97, 0xe1, 0xe9, 0xfd,
+	0xcd, 0xcd, 0xaa, 0xa6, 0xd7, 0xf7, 0xca, 0xb5, 0xfa, 0xd6, 0x7e, 0x43, 0xd7, 0xaa, 0xf5, 0xfb,
+	0xbb, 0x8d, 0xd0, 0xa4, 0xab, 0x70, 0x29, 0x9e, 0xa4, 0x5c, 0xa9, 0x54, 0x6b, 0x0d, 0x45, 0x42,
+	0x2b, 0xf0, 0x54, 0x02, 0xc5, 0xc6, 0xbe, 0xd6, 0x50, 0x52, 0xc9, 0x22, 0xb4, 0xea, 0x4e, 0xb5,
+	0xd2, 0x50, 0xd2, 0xe8, 0x1a, 0x5c, 0x39, 0x89, 0x42, 0xdf, 0xdc, 0xd7, 0xee, 0x95, 0x1b, 0x8a,
+	0x7c, 0x2a, 0x61, 0xbd, 0xba, 0x77, 0xa7, 0xaa, 0x29, 0x19, 0xb1, 0xef, 0x5f, 0xa4, 0xa0, 0x94,
+	0x94, 0xbd, 0x53, 0x59, 0xe5, 0x5a, 0x6d, 0xf7, 0x41, 0x20, 0xab, 0xb2, 0x75, 0x7f, 0xef, 0xee,
+	0xa4, 0x0a, 0x9e, 0x05, 0xf5, 0x24, 0x42, 0x5f, 0x11, 0x57, 0xe1, 0xf2, 0x89, 0x74, 0x42, 0x1d,
+	0xa7, 0x90, 0x69, 0xd5, 0x86, 0xf6, 0x40, 0x49, 0xa3, 0x35, 0xb8, 0x71, 0x2a, 0x99, 0x3f, 0xa6,
+	0xc8, 0x68, 0x1d, 0x6e, 0x9e, 0x4c, 0xcf, 0x15, 0xe4, 0x31, 0x78, 0x2a, 0xfa, 0x58, 0x82, 0xc5,
+	0xd8, 0x94, 0x1f, 0x5d, 0x81, 0x95, 0x9a, 0xb6, 0x5f, 0xa9, 0xd6, 0xeb, 0x7a, 0x4d, 0xdb, 0xaf,
+	0xed, 0xd7, 0xcb, 0xbb, 0x7a, 0xbd, 0x51, 0x6e, 0xdc, 0xaf, 0x87, 0x74, 0xa3, 0xc2, 0x72, 0x12,
+	0x91, 0xaf, 0x97, 0x13, 0x68, 0x84, 0x05, 0x78, 0x76, 0xfa, 0x73, 0x09, 0x2e, 0x26, 0xa6, 0xf8,
+	0xe8, 0x3a, 0x3c, 0x73, 0x50, 0xd5, 0xb6, 0x37, 0x1f, 0xe8, 0x07, 0xfb, 0x8d, 0xaa, 0x5e, 0x7d,
+	0xb7, 0x51, 0xdd, 0xab, 0x6f, 0xef, 0xef, 0x4d, 0xae, 0xea, 0x1a, 0x5c, 0x39, 0x91, 0xd2, 0x5f,
+	0xda, 0x69, 0x84, 0x63, 0xeb, 0xfb, 0x81, 0x04, 0xb3, 0x63, 0xbe, 0x10, 0x5d, 0x82, 0xd2, 0xbd,
+	0xed, 0xfa, 0x46, 0x75, 0xab, 0x7c, 0xb0, 0xbd, 0xaf, 0x8d, 0xdf, 0xd9, 0x2b, 0xb0, 0x32, 0x31,
+	0x7a, 0xe7, 0x7e, 0x6d, 0x77, 0xbb, 0x52, 0x6e, 0x54, 0xd9, 0xa4, 0x8a, 0x44, 0x37, 0x36, 0x41,
+	0xb4, 0xbb, 0xfd, 0xf6, 0x56, 0x43, 0xaf, 0xec, 0x6e, 0x57, 0xf7, 0x1a, 0x7a, 0xb9, 0xd1, 0x28,
+	0x07, 0xd7, 0x79, 0xe3, 0xee, 0xa7, 0x5f, 0x2c, 0x4b, 0x9f, 0x7d, 0xb1, 0x2c, 0xfd, 0xf5, 0x8b,
+	0x65, 0xe9, 0x93, 0x2f, 0x97, 0xcf, 0x7d, 0xf6, 0xe5, 0xf2, 0xb9, 0x3f, 0x7f, 0xb9, 0x7c, 0xee,
+	0xe1, 0xad, 0x43, 0x93, 0x74, 0x87, 0x4d, 0xea, 0x85, 0xd7, 0x83, 0x5f, 0x43, 0xfd, 0x7f, 0x4a,
+	0x6d, 0x73, 0x7d, 0xfc, 0x07, 0xd3, 0xe6, 0x14, 0x73, 0xab, 0x2f, 0xfe, 0x23, 0x00, 0x00, 0xff,
+	0xff, 0x31, 0x8a, 0x7f, 0x7e, 0x7b, 0x2a, 0x00, 0x00,
 }
 
 func (m *Request) Marshal() (dAtA []byte, err error) {
@@ -6157,6 +6168,13 @@ func (m *PrepareProposalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)
 	_ = i
 	var l int
 	_ = l
+	if len(m.Blob) > 0 {
+		i -= len(m.Blob)
+		copy(dAtA[i:], m.Blob)
+		i = encodeVarintTypes(dAtA, i, uint64(len(m.Blob)))
+		i--
+		dAtA[i] = 0x12
+	}
 	if len(m.Txs) > 0 {
 		for iNdEx := len(m.Txs) - 1; iNdEx >= 0; iNdEx-- {
 			i -= len(m.Txs[iNdEx])
@@ -7989,6 +8007,10 @@ func (m *PrepareProposalResponse) Size() (n int) {
 			n += 1 + l + sovTypes(uint64(l))
 		}
 	}
+	l = len(m.Blob)
+	if l > 0 {
+		n += 1 + l + sovTypes(uint64(l))
+	}
 	return n
 }
 
@@ -13888,6 +13910,40 @@ func (m *PrepareProposalResponse) Unmarshal(dAtA []byte) error {
 			m.Txs = append(m.Txs, make([]byte, postIndex-iNdEx))
 			copy(m.Txs[len(m.Txs)-1], dAtA[iNdEx:postIndex])
 			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Blob", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowTypes
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthTypes
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex < 0 {
+				return ErrInvalidLengthTypes
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Blob = append(m.Blob[:0], dAtA[iNdEx:postIndex]...)
+			if m.Blob == nil {
+				m.Blob = []byte{}
+			}
+			iNdEx = postIndex
 		default:
 			iNdEx = preIndex
 			skippy, err := skipTypes(dAtA[iNdEx:])
diff --git a/go.mod b/go.mod
index 16e03f2d3a3..18c75201ccc 100644
--- a/go.mod
+++ b/go.mod
@@ -48,9 +48,9 @@ require (
 	github.com/hashicorp/golang-lru/v2 v2.0.7
 	github.com/mitchellh/mapstructure v1.5.0
 	github.com/oasisprotocol/curve25519-voi v0.0.0-20220708102147-0a8a51822cae
-	github.com/supranational/blst v0.3.13
-	golang.org/x/exp v0.0.0-20250106191152-7588d65b2ba8
-	golang.org/x/sync v0.11.0
+	github.com/supranational/blst v0.3.14
+	golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56
+	golang.org/x/sync v0.10.0
 	gonum.org/v1/gonum v0.15.1
 	google.golang.org/protobuf v1.36.4
 )
diff --git a/go.sum b/go.sum
index d9a84dd91fe..5f4d58804cf 100644
--- a/go.sum
+++ b/go.sum
@@ -365,8 +365,8 @@ github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOf
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
 github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
 github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
-github.com/supranational/blst v0.3.13 h1:AYeSxdOMacwu7FBmpfloBz5pbFXDmJL33RuwnKtmTjk=
-github.com/supranational/blst v0.3.13/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
+github.com/supranational/blst v0.3.14 h1:xNMoHRJOTwMn63ip6qoWJ2Ymgvj7E2b9jY2FAwY+qRo=
+github.com/supranational/blst v0.3.14/go.mod h1:jZJtfjgudtNl4en1tzwPIV3KjUnQUvG3/j+w+fVonLw=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7 h1:epCh84lMvA70Z7CTTCmYQn2CKbY8j86K7/FAIr141uY=
 github.com/syndtr/goleveldb v1.0.1-0.20210819022825-2ae1ddf74ef7/go.mod h1:q4W45IWZaF22tdD+VEXcAWRA037jwmWEB5VWYORlTpc=
 github.com/xanzy/ssh-agent v0.3.3 h1:+/15pJfg/RsTxqYcX6fHqOXZwwMP+2VyYWJeWM2qQFM=
diff --git a/internal/consensus/byzantine_test.go b/internal/consensus/byzantine_test.go
index 146a496222f..257b1becd2e 100644
--- a/internal/consensus/byzantine_test.go
+++ b/internal/consensus/byzantine_test.go
@@ -212,7 +212,7 @@ func TestByzantinePrevoteEquivocation(t *testing.T) {
 		}
 		proposerAddr := lazyProposer.privValidatorPubKey.Address()
 
-		block, err := lazyProposer.blockExec.CreateProposalBlock(
+		block, _, err := lazyProposer.blockExec.CreateProposalBlock(
 			ctx, lazyProposer.Height, lazyProposer.state, extCommit, proposerAddr)
 		require.NoError(t, err)
 		blockParts, err := block.MakePartSet(types.BlockPartSizeBytes)
diff --git a/internal/consensus/common_test.go b/internal/consensus/common_test.go
index 0bef8110ed7..f6ddf30a7b9 100644
--- a/internal/consensus/common_test.go
+++ b/internal/consensus/common_test.go
@@ -235,7 +235,7 @@ func startTestRound(cs *State, height int64, round int32) {
 
 func createProposalBlockWithTime(t *testing.T, cs *State, time time.Time) (*types.Block, *types.PartSet, types.BlockID) {
 	t.Helper()
-	block, err := cs.createProposalBlock(context.Background())
+	block, _, err := cs.createProposalBlock(context.Background())
 	if !time.IsZero() {
 		block.Time = cmttime.Canonical(time)
 	}
diff --git a/internal/consensus/pbts_test.go b/internal/consensus/pbts_test.go
index f59e13e2f35..1d8b57df949 100644
--- a/internal/consensus/pbts_test.go
+++ b/internal/consensus/pbts_test.go
@@ -212,7 +212,7 @@ func (p *pbtsTestHarness) nextHeight(
 
 	ensureNewRound(p.roundCh, p.currentHeight, p.currentRound)
 
-	b, err := p.observedState.createProposalBlock(ctx)
+	b, _, err := p.observedState.createProposalBlock(ctx)
 	require.NoError(t, err)
 	require.Equal(t, b.Height, p.currentHeight)
 	b.Time = proposedTime
diff --git a/internal/consensus/reactor_test.go b/internal/consensus/reactor_test.go
index 86cbe07f986..8d80fc445b0 100644
--- a/internal/consensus/reactor_test.go
+++ b/internal/consensus/reactor_test.go
@@ -363,7 +363,7 @@ func TestSwitchToConsensusVoteExtensions(t *testing.T) {
 			cs.state.LastValidators = cs.state.Validators.Copy()
 			cs.state.ConsensusParams.Feature.VoteExtensionsEnableHeight = testCase.initialRequiredHeight
 
-			propBlock, err := cs.createProposalBlock(ctx)
+			propBlock, _, err := cs.createProposalBlock(ctx)
 			require.NoError(t, err)
 
 			// Consensus is preparing to do the next height after the stored height.
diff --git a/internal/consensus/state.go b/internal/consensus/state.go
index 28659eaf3a8..ffb444fbd5f 100644
--- a/internal/consensus/state.go
+++ b/internal/consensus/state.go
@@ -1235,8 +1235,11 @@ func (cs *State) isProposer(address []byte) bool {
 }
 
 func (cs *State) defaultDecideProposal(height int64, round int32) {
-	var block *types.Block
-	var blockParts *types.PartSet
+	var (
+		block      *types.Block
+		blockParts *types.PartSet
+		blob       types.Blob
+	)
 
 	// Decide on block
 	if cs.ValidBlock != nil {
@@ -1245,7 +1248,7 @@ func (cs *State) defaultDecideProposal(height int64, round int32) {
 	} else {
 		// Create a new proposal block from state/txs from the mempool.
 		var err error
-		block, err = cs.createProposalBlock(context.TODO())
+		block, blob, err = cs.createProposalBlock(context.TODO())
 		if err != nil {
 			cs.Logger.Error("Unable to create proposal block", "error", err)
 			return
@@ -1267,9 +1270,23 @@ func (cs *State) defaultDecideProposal(height int64, round int32) {
 	}
 
 	// Make proposal
-	propBlockID := types.BlockID{Hash: block.Hash(), PartSetHeader: blockParts.Header()}
-	proposal := types.NewProposal(height, round, cs.ValidRound, propBlockID, block.Header.Time)
-	p := proposal.ToProto()
+
+	var (
+		// TODO: create blob parts, BlobID, send blob parts.
+		_           = blob
+		propBlockID = types.BlockID{
+			Hash:          block.Hash(),
+			PartSetHeader: blockParts.Header(),
+		}
+		proposal = types.NewProposal(
+			height,
+			round,
+			cs.ValidRound,
+			propBlockID,
+			block.Header.Time,
+		)
+		p = proposal.ToProto()
+	)
 	if err := cs.privValidator.SignProposal(cs.state.ChainID, p); err == nil {
 		proposal.Signature = p.Signature
 
@@ -1309,13 +1326,17 @@ func (cs *State) isProposalComplete() bool {
 //
 // NOTE: keep it side-effect free for clarity.
 // CONTRACT: cs.privValidator is not nil.
-func (cs *State) createProposalBlock(ctx context.Context) (*types.Block, error) {
+func (cs *State) createProposalBlock(
+	ctx context.Context,
+) (*types.Block, types.Blob, error) {
 	if cs.privValidator == nil {
-		return nil, ErrNilPrivValidator
+		return nil, nil, ErrNilPrivValidator
 	}
 
-	// TODO(sergio): wouldn't it be easier if CreateProposalBlock accepted cs.LastCommit directly?
+	// TODO(sergio): wouldn't it be easier if CreateProposalBlock accepted
+	// cs.LastCommit directly?
 	var lastExtCommit *types.ExtendedCommit
+
 	lastCommitAsVs, ok := cs.LastCommit.(*types.VoteSet)
 	switch {
 	case cs.Height == cs.state.InitialHeight:
@@ -1325,43 +1346,56 @@ func (cs *State) createProposalBlock(ctx context.Context) (*types.Block, error)
 
 	case ok && lastCommitAsVs.HasTwoThirdsMajority():
 		// Make the commit from LastCommit.
-		_, blsKey := cs.privValidatorPubKey.(*bls12381.PubKey)
-		_, blsKey2 := cs.privValidatorPubKey.(bls12381.PubKey)
-		canBeAggregated := (blsKey || blsKey2) &&
-			cs.state.Validators.AllKeysHaveSameType()
+		var (
+			_, blsKey       = cs.privValidatorPubKey.(*bls12381.PubKey)
+			_, blsKey2      = cs.privValidatorPubKey.(bls12381.PubKey)
+			valKeysSameType = cs.state.Validators.AllKeysHaveSameType()
+			canBeAggregated = (blsKey || blsKey2) && valKeysSameType
+		)
 		if canBeAggregated {
 			if !cs.isPBTSEnabled(cs.Height) {
 				panic("Wanted to aggregate LastCommit, but PBTS is not enabled for height " + strconv.FormatInt(cs.Height, 10))
 			}
 			lastExtCommit = lastCommitAsVs.MakeBLSCommit()
 		} else {
-			lastExtCommit = lastCommitAsVs.MakeExtendedCommit(cs.state.ConsensusParams.Feature)
+			featParams := cs.state.ConsensusParams.Feature
+			lastExtCommit = lastCommitAsVs.MakeExtendedCommit(featParams)
 		}
+
 	case !ok:
 		lastCommitAsCommit, ok := cs.LastCommit.(*types.Commit)
 		if !ok {
-			return nil, errors.New("last commit is neither a VoteSet nor a Commit")
+			err := errors.New("last commit is neither a VoteSet nor a Commit")
+			return nil, nil, err
 		}
 		// XXX This will need to be extended to support vote extensions.
 		lastExtCommit = lastCommitAsCommit.WrappedExtendedCommit()
 
 	default: // This shouldn't happen.
-		return nil, ErrProposalWithoutPreviousCommit
+		return nil, nil, ErrProposalWithoutPreviousCommit
 	}
 
 	if cs.privValidatorPubKey == nil {
 		// If this node is a validator & proposer in the current round, it will
 		// miss the opportunity to create a block.
-		return nil, fmt.Errorf("propose step; empty priv validator public key, error: %w", ErrPubKeyIsNotSet)
+		errStr := "propose step; empty priv validator public key, error: %w"
+		return nil, nil, fmt.Errorf(errStr, ErrPubKeyIsNotSet)
 	}
 
 	proposerAddr := cs.privValidatorPubKey.Address()
 
-	ret, err := cs.blockExec.CreateProposalBlock(ctx, cs.Height, cs.state, lastExtCommit, proposerAddr)
+	block, blob, err := cs.blockExec.CreateProposalBlock(
+		ctx,
+		cs.Height,
+		cs.state,
+		lastExtCommit,
+		proposerAddr,
+	)
 	if err != nil {
 		panic(err)
 	}
-	return ret, nil
+
+	return block, blob, nil
 }
 
 // Enter: isProposalComplete() and Step <= RoundStepPropose.
diff --git a/internal/consensus/state_test.go b/internal/consensus/state_test.go
index 76f529d991e..18d29bc7d6a 100644
--- a/internal/consensus/state_test.go
+++ b/internal/consensus/state_test.go
@@ -234,7 +234,7 @@ func TestStateBadProposal(t *testing.T) {
 	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
 	voteCh := subscribe(cs1.eventBus, types.EventQueryVote)
 
-	propBlock, err := cs1.createProposalBlock(ctx) // changeProposer(t, cs1, vs2)
+	propBlock, _, err := cs1.createProposalBlock(ctx) // changeProposer(t, cs1, vs2)
 	require.NoError(t, err)
 
 	// make the second validator the proposer by incrementing round
@@ -1360,7 +1360,7 @@ func TestState_MissingProposalValidBlockReceivedTimeout(t *testing.T) {
 	validBlockCh := subscribe(cs1.eventBus, types.EventQueryValidBlock)
 
 	// Produce a block
-	block, err := cs1.createProposalBlock(ctx)
+	block, _, err := cs1.createProposalBlock(ctx)
 	require.NoError(t, err)
 	blockParts, err := block.MakePartSet(types.BlockPartSizeBytes)
 	require.NoError(t, err)
diff --git a/node/node_test.go b/node/node_test.go
index 3e77bda9c25..2ad68defa6a 100644
--- a/node/node_test.go
+++ b/node/node_test.go
@@ -360,7 +360,7 @@ func TestCreateProposalBlock(t *testing.T) {
 	)
 
 	extCommit := &types.ExtendedCommit{Height: height - 1}
-	block, err := blockExec.CreateProposalBlock(
+	block, _, err := blockExec.CreateProposalBlock(
 		ctx,
 		height,
 		state,
@@ -437,7 +437,7 @@ func TestMaxProposalBlockSize(t *testing.T) {
 	)
 
 	extCommit := &types.ExtendedCommit{Height: height - 1}
-	block, err := blockExec.CreateProposalBlock(
+	block, _, err := blockExec.CreateProposalBlock(
 		ctx,
 		height,
 		state,
diff --git a/proto/cometbft/abci/v1/types.proto b/proto/cometbft/abci/v1/types.proto
index c1ce525e85e..912fada7240 100644
--- a/proto/cometbft/abci/v1/types.proto
+++ b/proto/cometbft/abci/v1/types.proto
@@ -370,9 +370,12 @@ enum ApplySnapshotChunkResult {
   APPLY_SNAPSHOT_CHUNK_RESULT_REJECT_SNAPSHOT = 5;
 }
 
-// PrepareProposalResponse contains a list of transactions, which will form a block.
+// PrepareProposalResponse contains a list of transactions which will form a block.
 message PrepareProposalResponse {
   repeated bytes txs = 1;
+  // A blob (see EIP-4844) is a piece of temporary data attached to a blob
+  // transaction. CometBFT will gossip this blob separately from the block.
+  bytes blob = 2;
 }
 
 // ProcessProposalResponse indicates the ABCI application's decision whenever
diff --git a/state/execution.go b/state/execution.go
index cd50def7243..f800a34b3dd 100644
--- a/state/execution.go
+++ b/state/execution.go
@@ -113,58 +113,82 @@ func (blockExec *BlockExecutor) CreateProposalBlock(
 	state State,
 	lastExtCommit *types.ExtendedCommit,
 	proposerAddr []byte,
-) (*types.Block, error) {
-	maxBytes := state.ConsensusParams.Block.MaxBytes
-	emptyMaxBytes := maxBytes == -1
+) (*types.Block, types.Blob, error) {
+	var (
+		maxBytes      = state.ConsensusParams.Block.MaxBytes
+		emptyMaxBytes = maxBytes == -1
+	)
 	if emptyMaxBytes {
 		maxBytes = int64(types.MaxBlockSizeBytes)
 	}
 
-	maxGas := state.ConsensusParams.Block.MaxGas
-
-	evidence, evSize := blockExec.evpool.PendingEvidence(state.ConsensusParams.Evidence.MaxBytes)
-
-	// Fetch a limited amount of valid txs
-	maxDataBytes := types.MaxDataBytes(maxBytes, evSize, state.Validators.Size())
-	maxReapBytes := maxDataBytes
+	var (
+		evidence, evSize = blockExec.evpool.PendingEvidence(
+			state.ConsensusParams.Evidence.MaxBytes,
+		)
+		// Fetch a limited amount of valid txs
+		maxDataBytes = types.MaxDataBytes(maxBytes, evSize, state.Validators.Size())
+		maxReapBytes = maxDataBytes
+	)
 	if emptyMaxBytes {
 		maxReapBytes = -1
 	}
 
-	txs := blockExec.mempool.ReapMaxBytesMaxGas(maxReapBytes, maxGas)
-	commit := lastExtCommit.ToCommit()
-	block := state.MakeBlock(height, txs, commit, evidence, proposerAddr)
-	rpp, err := blockExec.proxyApp.PrepareProposal(
-		ctx,
-		&abci.PrepareProposalRequest{
+	var (
+		maxGas = state.ConsensusParams.Block.MaxGas
+		txs    = blockExec.mempool.ReapMaxBytesMaxGas(maxReapBytes, maxGas)
+		commit = lastExtCommit.ToCommit()
+
+		block = state.MakeBlock(
+			height,
+			txs,
+			commit,
+			evidence,
+			proposerAddr,
+		)
+
+		localLastCommit = buildExtendedCommitInfoFromStore(
+			lastExtCommit,
+			blockExec.store,
+			state.InitialHeight,
+			state.ConsensusParams.Feature,
+		)
+
+		proposalReq = &abci.PrepareProposalRequest{
 			MaxTxBytes:         maxDataBytes,
 			Txs:                block.Txs.ToSliceOfBytes(),
-			LocalLastCommit:    buildExtendedCommitInfoFromStore(lastExtCommit, blockExec.store, state.InitialHeight, state.ConsensusParams.Feature),
+			LocalLastCommit:    localLastCommit,
 			Misbehavior:        block.Evidence.Evidence.ToABCI(),
 			Height:             block.Height,
 			Time:               block.Time,
 			NextValidatorsHash: block.NextValidatorsHash,
 			ProposerAddress:    block.ProposerAddress,
-		},
+		}
 	)
+	rpp, err := blockExec.proxyApp.PrepareProposal(ctx, proposalReq)
 	if err != nil {
 		// The App MUST ensure that only valid (and hence 'processable') transactions
 		// enter the mempool. Hence, at this point, we can't have any non-processable
 		// transaction causing an error.
 		//
-		// Also, the App can simply skip any transaction that could cause any kind of trouble.
-		// Either way, we cannot recover in a meaningful way, unless we skip proposing
-		// this block, repair what caused the error and try again. Hence, we return an
-		// error for now (the production code calling this function is expected to panic).
-		return nil, err
+		// Also, the App can simply skip any transaction that could cause any kind
+		// of trouble. Either way, we cannot recover in a meaningful way, unless we
+		// skip /proposing this block, repair what caused the error and try again.
+		// Hence, we return an error for now (the production code calling this
+		// function is expected to panic).
+		return nil, nil, err
 	}
 
 	txl := types.ToTxs(rpp.Txs)
 	if err := txl.Validate(maxDataBytes); err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 
-	return state.MakeBlock(height, txl, commit, evidence, proposerAddr), nil
+	var (
+		preparedBlock = state.MakeBlock(height, txl, commit, evidence, proposerAddr)
+		blob          = rpp.Blob
+	)
+	return preparedBlock, blob, nil
 }
 
 func (blockExec *BlockExecutor) ProcessProposal(
diff --git a/state/execution_test.go b/state/execution_test.go
index ebfd047b401..a9a409b908e 100644
--- a/state/execution_test.go
+++ b/state/execution_test.go
@@ -736,7 +736,7 @@ func TestEmptyPrepareProposal(t *testing.T) {
 	pa, _ := state.Validators.GetByIndex(0)
 	commit, err := makeValidCommit(height, types.BlockID{}, state.Validators, privVals)
 	require.NoError(t, err)
-	_, err = blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
+	_, _, err = blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
 	require.NoError(t, err)
 }
 
@@ -781,7 +781,7 @@ func TestPrepareProposalTxsAllIncluded(t *testing.T) {
 	pa, _ := state.Validators.GetByIndex(0)
 	commit, err := makeValidCommit(height, types.BlockID{}, state.Validators, privVals)
 	require.NoError(t, err)
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
+	block, _, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
 	require.NoError(t, err)
 
 	for i, tx := range block.Data.Txs {
@@ -836,7 +836,7 @@ func TestPrepareProposalReorderTxs(t *testing.T) {
 	pa, _ := state.Validators.GetByIndex(0)
 	commit, err := makeValidCommit(height, types.BlockID{}, state.Validators, privVals)
 	require.NoError(t, err)
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
+	block, _, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
 	require.NoError(t, err)
 	for i, tx := range block.Data.Txs {
 		require.Equal(t, txs[i], tx)
@@ -892,7 +892,7 @@ func TestPrepareProposalErrorOnTooManyTxs(t *testing.T) {
 	pa, _ := state.Validators.GetByIndex(0)
 	commit, err := makeValidCommit(height, types.BlockID{}, state.Validators, privVals)
 	require.NoError(t, err)
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
+	block, _, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
 	require.Nil(t, block)
 	require.ErrorContains(t, err, "transaction data size exceeds maximum")
 
@@ -949,7 +949,7 @@ func TestPrepareProposalCountSerializationOverhead(t *testing.T) {
 	pa, _ := state.Validators.GetByIndex(0)
 	commit, err := makeValidCommit(height, types.BlockID{}, state.Validators, privVals)
 	require.NoError(t, err)
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
+	block, _, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
 	require.Nil(t, block)
 	require.ErrorContains(t, err, "transaction data size exceeds maximum")
 
@@ -1003,7 +1003,7 @@ func TestPrepareProposalErrorOnPrepareProposalError(t *testing.T) {
 	pa, _ := state.Validators.GetByIndex(0)
 	commit, err := makeValidCommit(height, types.BlockID{}, state.Validators, privVals)
 	require.NoError(t, err)
-	block, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
+	block, _, err := blockExec.CreateProposalBlock(ctx, height, state, commit, pa)
 	require.Nil(t, block)
 	require.ErrorContains(t, err, "an injected error")
 
@@ -1103,13 +1103,90 @@ func TestCreateProposalAbsentVoteExtensions(t *testing.T) {
 					blockExec.CreateProposalBlock(ctx, testCase.height, state, lastCommit, pa) //nolint:errcheck
 				})
 			} else {
-				_, err = blockExec.CreateProposalBlock(ctx, testCase.height, state, lastCommit, pa)
+				_, _, err = blockExec.CreateProposalBlock(ctx, testCase.height, state, lastCommit, pa)
 				require.NoError(t, err)
 			}
 		})
 	}
 }
 
+func TestCreateProposalWithBlob(t *testing.T) {
+	const height = 2
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	var (
+		app          = &abcimocks.Application{}
+		proposalResp = &abci.PrepareProposalResponse{
+			Blob: []byte("blob"),
+		}
+	)
+	app.On("PrepareProposal", mock.Anything, mock.Anything).Return(proposalResp, nil)
+
+	var (
+		cc       = proxy.NewLocalClientCreator(app)
+		proxyApp = proxy.NewAppConns(cc, proxy.NopMetrics())
+	)
+	err := proxyApp.Start()
+	require.NoError(t, err)
+
+	defer proxyApp.Stop() //nolint:errcheck // ignore for tests
+
+	var (
+		state, stateDB, privVals = makeState(10, height, chainID)
+		storeOpts                = sm.StoreOptions{DiscardABCIResponses: false}
+		stateStore               = sm.NewStore(stateDB, storeOpts)
+		mp                       = &mpmocks.Mempool{}
+	)
+	mp.On("Lock").Return()
+	mp.On("Unlock").Return()
+	mp.On("PreUpdate").Return()
+	mp.On("FlushAppConn", mock.Anything).Return(nil)
+	mp.On(
+		"Update",
+		mock.Anything,
+		mock.Anything,
+		mock.Anything,
+		mock.Anything,
+		mock.Anything,
+		mock.Anything,
+	).Return(nil)
+	mp.On("ReapMaxBytesMaxGas", mock.Anything, mock.Anything).Return(types.Txs{})
+
+	var (
+		blockStore = store.NewBlockStore(dbm.NewMemDB())
+		blockExec  = sm.NewBlockExecutor(
+			stateStore,
+			log.TestingLogger(),
+			proxyApp.Consensus(),
+			mp,
+			sm.EmptyEvidencePool{},
+			blockStore,
+		)
+		proposerAddr, _ = state.Validators.GetByIndex(0)
+	)
+	commit, err := makeValidCommit(
+		height,
+		types.BlockID{},
+		state.Validators,
+		privVals,
+	)
+	require.NoError(t, err)
+
+	_, gotBlob, err := blockExec.CreateProposalBlock(
+		ctx,
+		height,
+		state,
+		commit,
+		proposerAddr,
+	)
+	require.NoError(t, err)
+
+	wantBlob := types.Blob("blob")
+	require.Equal(t, wantBlob, gotBlob)
+}
+
 func stripSignatures(ec *types.ExtendedCommit) {
 	for i, commitSig := range ec.ExtendedSignatures {
 		commitSig.Extension = nil
diff --git a/types/block.go b/types/block.go
index 3fbcfefe373..36fe91e21da 100644
--- a/types/block.go
+++ b/types/block.go
@@ -44,6 +44,24 @@ func init() {
 	cmtjson.RegisterType(&Commit{}, "cometbft/Commit")
 }
 
+// Blob represents an Ethereum blob, a binary data structure introduced in
+// EIP-4844 (Proto-Danksharding).
+// Blobs are primarily used by Layer 2 rollups to post batched transaction data
+// to Ethereum in a cost-efficient manner. Each blob is referenced in a blob
+// transaction via a KZG commitment, which ensures data integrity without
+// requiring full storage in execution clients.
+//
+// A "Blob" is typically an opaque byte slice up to ~128 KB. In our case, however,
+// a single Blob slice can hold multiple blobs, potentially exceeding that size.
+// The exact number of contained blobs is encoded within the block's transactions,
+// but CometBFT neither parses nor uses this information. It simply gossips the
+// blobs alongside their corresponding blocks.
+//
+// We introduce support for blobs in CometBFT to serve use-cases where CometBFT
+// acts purely as a finalization gadget, so storing blobs in CometBFT's storage
+// layer is unnecessary and undesirable.
+type Blob []byte
+
 // Block defines the atomic unit of a CometBFT blockchain.
 type Block struct {
 	mtx cmtsync.Mutex


Reviews:
user: login: melekes
body: looking good so far 👍 
state: APPROVED
author_association: COLLABORATOR
submitted_at: 2025-03-13T06:00:28Z
user: login: alesforz
state: COMMENTED
author_association: OWNER
submitted_at: 2025-03-13T09:23:17Z
user: login: melekes
state: COMMENTED
author_association: COLLABORATOR
submitted_at: 2025-03-13T11:27:35Z

Review comments:
diff_hunk: @@ -370,9 +370,13 @@ enum ApplySnapshotChunkResult {
   APPLY_SNAPSHOT_CHUNK_RESULT_REJECT_SNAPSHOT = 5;
 }
 
-// PrepareProposalResponse contains a list of transactions, which will form a block.
+// PrepareProposalResponse contains a list of transactions which will form a block.
 message PrepareProposalResponse {
   repeated bytes txs = 1;
+  // A blob (see EIP-4844) is a piece of temporary data attached to a blob
+  // transaction. CometBFT will gossip this blob separately from the block.
+  // The ABCI app stores the blob transaction at index 0 of txs field.
path: proto/cometbft/abci/v1/types.proto
user: login: melekes
body: Is this mandatory?
created_at: 2025-03-13T05:51:45Z
author_association: COLLABORATOR
diff_hunk: @@ -370,9 +370,13 @@ enum ApplySnapshotChunkResult {
   APPLY_SNAPSHOT_CHUNK_RESULT_REJECT_SNAPSHOT = 5;
 }
 
-// PrepareProposalResponse contains a list of transactions, which will form a block.
+// PrepareProposalResponse contains a list of transactions which will form a block.
 message PrepareProposalResponse {
   repeated bytes txs = 1;
+  // A blob (see EIP-4844) is a piece of temporary data attached to a blob
+  // transaction. CometBFT will gossip this blob separately from the block.
+  // The ABCI app stores the blob transaction at index 0 of txs field.
path: proto/cometbft/abci/v1/types.proto
user: login: alesforz
body: you mean the comment or the "blob transaction stored at index 0" part?

If it's the latter, this is Berachain's design. 
Do you think we should delete this line in case the design changes? I agree that it's not directly related to the blob and specifically referring to this use case 🤔 
created_at: 2025-03-13T09:23:17Z
author_association: OWNER
diff_hunk: @@ -370,9 +370,13 @@ enum ApplySnapshotChunkResult {
   APPLY_SNAPSHOT_CHUNK_RESULT_REJECT_SNAPSHOT = 5;
 }
 
-// PrepareProposalResponse contains a list of transactions, which will form a block.
+// PrepareProposalResponse contains a list of transactions which will form a block.
 message PrepareProposalResponse {
   repeated bytes txs = 1;
+  // A blob (see EIP-4844) is a piece of temporary data attached to a blob
+  // transaction. CometBFT will gossip this blob separately from the block.
+  // The ABCI app stores the blob transaction at index 0 of txs field.
path: proto/cometbft/abci/v1/types.proto
user: login: melekes
body: > Do you think we should delete this line in case the design changes? I agree that it's not directly related to the blob and specifically referring to this use case 🤔

I would remove it.
created_at: 2025-03-13T11:27:35Z
author_association: COLLABORATOR

PR comments:
user: login: alesforz
created_at: 2025-03-13T13:29:41Z
body: The linter is failing, but that't not a real problem.
It's complaining about not using the `blob` object, but in the next PR(s) the code will use it.
author_association: OWNER