From de02bdadc97b54ab7c9a0483aaa8295e6e1e034d Mon Sep 17 00:00:00 2001 From: Evan Forbes <42654277+evan-forbes@users.noreply.github.com> Date: Fri, 9 Dec 2022 09:50:09 -0600 Subject: [PATCH] chore!: rename malleatedTx -> indexWrapper (#905) --- mempool/v0/clist_mempool_test.go | 4 +- mempool/v1/mempool_test.go | 4 +- pkg/consts/consts.go | 6 +- proto/tendermint/types/types.pb.go | 249 ++++++++++++++--------------- proto/tendermint/types/types.proto | 7 +- state/txindex/kv/kv_test.go | 2 +- types/event_bus_test.go | 2 +- types/tx.go | 42 ++--- types/tx_test.go | 16 +- 9 files changed, 165 insertions(+), 167 deletions(-) diff --git a/mempool/v0/clist_mempool_test.go b/mempool/v0/clist_mempool_test.go index 3328965573..6feef59258 100644 --- a/mempool/v0/clist_mempool_test.go +++ b/mempool/v0/clist_mempool_test.go @@ -692,7 +692,7 @@ func TestRemoveBlobTx(t *testing.T) { defer cleanup() originalTx := []byte{1, 2, 3, 4} - malleatedTx, err := types.MarshalMalleatedTx(100, originalTx) + indexWrapper, err := types.MarshalIndexWrapper(100, originalTx) require.NoError(t, err) // create the blobTx @@ -707,7 +707,7 @@ func TestRemoveBlobTx(t *testing.T) { err = mp.CheckTx(bTx, nil, mempool.TxInfo{}) require.NoError(t, err) - err = mp.Update(1, []types.Tx{malleatedTx}, abciResponses(1, abci.CodeTypeOK), nil, nil) + err = mp.Update(1, []types.Tx{indexWrapper}, abciResponses(1, abci.CodeTypeOK), nil, nil) require.NoError(t, err) assert.EqualValues(t, 0, mp.Size()) assert.EqualValues(t, 0, mp.SizeBytes()) diff --git a/mempool/v1/mempool_test.go b/mempool/v1/mempool_test.go index b468aa5f79..ac5982704d 100644 --- a/mempool/v1/mempool_test.go +++ b/mempool/v1/mempool_test.go @@ -659,7 +659,7 @@ func TestRemoveBlobTx(t *testing.T) { txmp := setup(t, 500) originalTx := []byte{1, 2, 3, 4} - malleatedTx, err := types.MarshalMalleatedTx(100, originalTx) + indexWrapper, err := types.MarshalIndexWrapper(100, originalTx) require.NoError(t, err) // create the blobTx @@ -674,7 +674,7 @@ func TestRemoveBlobTx(t *testing.T) { err = txmp.CheckTx(bTx, nil, mempool.TxInfo{}) require.NoError(t, err) - err = txmp.Update(1, []types.Tx{malleatedTx}, abciResponses(1, abci.CodeTypeOK), nil, nil) + err = txmp.Update(1, []types.Tx{indexWrapper}, abciResponses(1, abci.CodeTypeOK), nil, nil) require.NoError(t, err) assert.EqualValues(t, 0, txmp.Size()) assert.EqualValues(t, 0, txmp.SizeBytes()) diff --git a/pkg/consts/consts.go b/pkg/consts/consts.go index a29b14f23f..ae832e55eb 100644 --- a/pkg/consts/consts.go +++ b/pkg/consts/consts.go @@ -16,9 +16,9 @@ const ( // decoding binaries that are not actually BlobTxs. ProtoBlobTxTypeID = "BLOB" - // ProtoMalleatedTxTypeID is included in each encoded MalleatedTx to help prevent - // decoding binaries that are not actually MalleatedTxs. - ProtoMalleatedTxTypeID = "MLTD" + // ProtoIndexWrapperTypeID is included in each encoded IndexWrapper to help prevent + // decoding binaries that are not actually IndexWrappers. + ProtoIndexWrapperTypeID = "INDX" ) var ( diff --git a/proto/tendermint/types/types.pb.go b/proto/tendermint/types/types.pb.go index 84ea643726..6cb08b8ae8 100644 --- a/proto/tendermint/types/types.pb.go +++ b/proto/tendermint/types/types.pb.go @@ -1182,27 +1182,26 @@ func (m *TxProof) GetProofs() []*NMTProof { return nil } -// MalleatedTx wraps a transaction that was derived from a different original -// transaction. This allows for tendermint to track malleated and original -// transactions -type MalleatedTx struct { +// IndexWrapper adds index metadata to a transaction. This is used to track +// transactions that pay for blobs, and where the blobs start in the square. +type IndexWrapper struct { Tx []byte `protobuf:"bytes,1,opt,name=tx,proto3" json:"tx,omitempty"` ShareIndex uint32 `protobuf:"varint,2,opt,name=share_index,json=shareIndex,proto3" json:"share_index,omitempty"` TypeId string `protobuf:"bytes,3,opt,name=type_id,json=typeId,proto3" json:"type_id,omitempty"` } -func (m *MalleatedTx) Reset() { *m = MalleatedTx{} } -func (m *MalleatedTx) String() string { return proto.CompactTextString(m) } -func (*MalleatedTx) ProtoMessage() {} -func (*MalleatedTx) Descriptor() ([]byte, []int) { +func (m *IndexWrapper) Reset() { *m = IndexWrapper{} } +func (m *IndexWrapper) String() string { return proto.CompactTextString(m) } +func (*IndexWrapper) ProtoMessage() {} +func (*IndexWrapper) Descriptor() ([]byte, []int) { return fileDescriptor_d3a6e55e2345de56, []int{15} } -func (m *MalleatedTx) XXX_Unmarshal(b []byte) error { +func (m *IndexWrapper) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } -func (m *MalleatedTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { +func (m *IndexWrapper) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { - return xxx_messageInfo_MalleatedTx.Marshal(b, m, deterministic) + return xxx_messageInfo_IndexWrapper.Marshal(b, m, deterministic) } else { b = b[:cap(b)] n, err := m.MarshalToSizedBuffer(b) @@ -1212,33 +1211,33 @@ func (m *MalleatedTx) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) return b[:n], nil } } -func (m *MalleatedTx) XXX_Merge(src proto.Message) { - xxx_messageInfo_MalleatedTx.Merge(m, src) +func (m *IndexWrapper) XXX_Merge(src proto.Message) { + xxx_messageInfo_IndexWrapper.Merge(m, src) } -func (m *MalleatedTx) XXX_Size() int { +func (m *IndexWrapper) XXX_Size() int { return m.Size() } -func (m *MalleatedTx) XXX_DiscardUnknown() { - xxx_messageInfo_MalleatedTx.DiscardUnknown(m) +func (m *IndexWrapper) XXX_DiscardUnknown() { + xxx_messageInfo_IndexWrapper.DiscardUnknown(m) } -var xxx_messageInfo_MalleatedTx proto.InternalMessageInfo +var xxx_messageInfo_IndexWrapper proto.InternalMessageInfo -func (m *MalleatedTx) GetTx() []byte { +func (m *IndexWrapper) GetTx() []byte { if m != nil { return m.Tx } return nil } -func (m *MalleatedTx) GetShareIndex() uint32 { +func (m *IndexWrapper) GetShareIndex() uint32 { if m != nil { return m.ShareIndex } return 0 } -func (m *MalleatedTx) GetTypeId() string { +func (m *IndexWrapper) GetTypeId() string { if m != nil { return m.TypeId } @@ -1409,7 +1408,7 @@ func init() { proto.RegisterType((*LightBlock)(nil), "tendermint.types.LightBlock") proto.RegisterType((*BlockMeta)(nil), "tendermint.types.BlockMeta") proto.RegisterType((*TxProof)(nil), "tendermint.types.TxProof") - proto.RegisterType((*MalleatedTx)(nil), "tendermint.types.MalleatedTx") + proto.RegisterType((*IndexWrapper)(nil), "tendermint.types.IndexWrapper") proto.RegisterType((*BlobTx)(nil), "tendermint.types.BlobTx") proto.RegisterType((*NMTProof)(nil), "tendermint.types.NMTProof") } @@ -1417,105 +1416,105 @@ func init() { func init() { proto.RegisterFile("tendermint/types/types.proto", fileDescriptor_d3a6e55e2345de56) } var fileDescriptor_d3a6e55e2345de56 = []byte{ - // 1566 bytes of a gzipped FileDescriptorProto + // 1567 bytes of a gzipped FileDescriptorProto 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x57, 0xcd, 0x6f, 0xdb, 0xc8, 0x15, 0x37, 0x25, 0xea, 0xeb, 0x49, 0xb2, 0x65, 0xc2, 0x71, 0x14, 0x39, 0x96, 0x55, 0x15, 0x6d, - 0x9d, 0x34, 0x90, 0x53, 0xa7, 0xe8, 0xc7, 0xa1, 0x07, 0xc9, 0x76, 0x12, 0x21, 0x96, 0xac, 0x52, - 0x8a, 0xd3, 0xf6, 0x42, 0x50, 0xe2, 0x58, 0x22, 0x42, 0x91, 0x2c, 0x39, 0x72, 0xe4, 0xdc, 0x7a, - 0x2b, 0x7c, 0xca, 0xa9, 0x37, 0x9f, 0xda, 0x43, 0xef, 0xfd, 0x07, 0x8a, 0x9e, 0x72, 0xcc, 0xad, - 0x7b, 0xd9, 0xec, 0xc2, 0x01, 0x16, 0xfb, 0x67, 0x2c, 0xe6, 0xcd, 0x90, 0xa2, 0x2c, 0x3b, 0xbb, - 0x08, 0x82, 0xbd, 0x08, 0x9c, 0xf7, 0x7e, 0xef, 0xcd, 0xfb, 0x7e, 0x23, 0xb8, 0x4b, 0x89, 0x6d, - 0x10, 0x6f, 0x6c, 0xda, 0x74, 0x87, 0x9e, 0xb9, 0xc4, 0xe7, 0xbf, 0x35, 0xd7, 0x73, 0xa8, 0xa3, - 0x14, 0x66, 0xdc, 0x1a, 0xd2, 0x4b, 0x6b, 0x43, 0x67, 0xe8, 0x20, 0x73, 0x87, 0x7d, 0x71, 0x5c, - 0x69, 0x6b, 0xe8, 0x38, 0x43, 0x8b, 0xec, 0xe0, 0xa9, 0x3f, 0x39, 0xd9, 0xa1, 0xe6, 0x98, 0xf8, - 0x54, 0x1f, 0xbb, 0x02, 0xb0, 0x19, 0xb9, 0x66, 0xe0, 0x9d, 0xb9, 0xd4, 0x61, 0x58, 0xe7, 0x44, - 0xb0, 0xcb, 0x11, 0xf6, 0x29, 0xf1, 0x7c, 0xd3, 0xb1, 0xa3, 0x76, 0x94, 0x2a, 0x0b, 0x56, 0x9e, - 0xea, 0x96, 0x69, 0xe8, 0xd4, 0xf1, 0x38, 0xa2, 0xfa, 0x7b, 0xc8, 0x77, 0x74, 0x8f, 0x76, 0x09, - 0x7d, 0x4a, 0x74, 0x83, 0x78, 0xca, 0x1a, 0x24, 0xa8, 0x43, 0x75, 0xab, 0x28, 0x55, 0xa4, 0xed, - 0xbc, 0xca, 0x0f, 0x8a, 0x02, 0xf2, 0x48, 0xf7, 0x47, 0xc5, 0x58, 0x45, 0xda, 0xce, 0xa9, 0xf8, - 0x5d, 0x1d, 0x81, 0xcc, 0x44, 0x99, 0x84, 0x69, 0x1b, 0x64, 0x1a, 0x48, 0xe0, 0x81, 0x51, 0xfb, - 0x67, 0x94, 0xf8, 0x42, 0x84, 0x1f, 0x94, 0x5f, 0x43, 0x02, 0xed, 0x2f, 0xc6, 0x2b, 0xd2, 0x76, - 0x76, 0xb7, 0x58, 0x8b, 0x04, 0x8a, 0xfb, 0x57, 0xeb, 0x30, 0x7e, 0x43, 0x7e, 0xfb, 0x7e, 0x6b, - 0x49, 0xe5, 0xe0, 0xaa, 0x05, 0xa9, 0x86, 0xe5, 0x0c, 0x5e, 0x36, 0xf7, 0x43, 0x43, 0xa4, 0x99, - 0x21, 0x4a, 0x0b, 0x56, 0x5c, 0xdd, 0xa3, 0x9a, 0x4f, 0xa8, 0x36, 0x42, 0x2f, 0xf0, 0xd2, 0xec, - 0xee, 0x56, 0xed, 0x6a, 0x1e, 0x6a, 0x73, 0xce, 0x8a, 0x5b, 0xf2, 0x6e, 0x94, 0x58, 0xfd, 0x46, - 0x86, 0xa4, 0x08, 0xc6, 0x1f, 0x20, 0x25, 0xc2, 0x8a, 0x17, 0x66, 0x77, 0x37, 0xa3, 0x1a, 0x05, - 0xab, 0xb6, 0xe7, 0xd8, 0x3e, 0xb1, 0xfd, 0x89, 0x2f, 0xf4, 0x05, 0x32, 0xca, 0xcf, 0x21, 0x3d, - 0x18, 0xe9, 0xa6, 0xad, 0x99, 0x06, 0x5a, 0x94, 0x69, 0x64, 0x2f, 0xdf, 0x6f, 0xa5, 0xf6, 0x18, - 0xad, 0xb9, 0xaf, 0xa6, 0x90, 0xd9, 0x34, 0x94, 0x75, 0x48, 0x8e, 0x88, 0x39, 0x1c, 0x51, 0x0c, - 0x4b, 0x5c, 0x15, 0x27, 0xe5, 0x77, 0x20, 0xb3, 0x82, 0x28, 0xca, 0x78, 0x77, 0xa9, 0xc6, 0xab, - 0xa5, 0x16, 0x54, 0x4b, 0xad, 0x17, 0x54, 0x4b, 0x23, 0xcd, 0x2e, 0x7e, 0xf3, 0xd5, 0x96, 0xa4, - 0xa2, 0x84, 0xb2, 0x07, 0x79, 0x4b, 0xf7, 0xa9, 0xd6, 0x67, 0x61, 0x63, 0xd7, 0x27, 0x50, 0xc5, - 0x9d, 0xc5, 0x80, 0x88, 0xc0, 0x0a, 0xd3, 0xb3, 0x4c, 0x8a, 0x93, 0x0c, 0x65, 0x1b, 0x0a, 0xa8, - 0x64, 0xe0, 0x8c, 0xc7, 0x26, 0xd5, 0x30, 0xee, 0x49, 0x8c, 0xfb, 0x32, 0xa3, 0xef, 0x21, 0xf9, - 0x29, 0xcb, 0xc0, 0x06, 0x64, 0x0c, 0x9d, 0xea, 0x1c, 0x92, 0x42, 0x48, 0x9a, 0x11, 0x90, 0xf9, - 0x0b, 0x58, 0x09, 0xab, 0xce, 0xe7, 0x90, 0x34, 0xd7, 0x32, 0x23, 0x23, 0xf0, 0x21, 0xac, 0xd9, - 0x64, 0x4a, 0xb5, 0xab, 0xe8, 0x0c, 0xa2, 0x15, 0xc6, 0x3b, 0x9e, 0x97, 0xf8, 0x19, 0x2c, 0x0f, - 0x82, 0xe0, 0x73, 0x2c, 0x20, 0x36, 0x1f, 0x52, 0x11, 0x76, 0x07, 0xd2, 0xba, 0xeb, 0x72, 0x40, - 0x16, 0x01, 0x29, 0xdd, 0x75, 0x91, 0x75, 0x1f, 0x56, 0xd1, 0x47, 0x8f, 0xf8, 0x13, 0x8b, 0x0a, - 0x25, 0x39, 0xc4, 0xac, 0x30, 0x86, 0xca, 0xe9, 0x88, 0xfd, 0x29, 0xe4, 0xc9, 0xa9, 0x69, 0x10, - 0x7b, 0x40, 0x38, 0x2e, 0x8f, 0xb8, 0x5c, 0x40, 0x44, 0xd0, 0x3d, 0x28, 0xb8, 0x9e, 0xe3, 0x3a, - 0x3e, 0xf1, 0x34, 0xdd, 0x30, 0x3c, 0xe2, 0xfb, 0xc5, 0x65, 0xae, 0x2f, 0xa0, 0xd7, 0x39, 0xb9, - 0xfa, 0x37, 0x09, 0xe4, 0x7d, 0x9d, 0xea, 0x4a, 0x01, 0xe2, 0x74, 0xea, 0x17, 0xa5, 0x4a, 0x7c, - 0x3b, 0xa7, 0xb2, 0x4f, 0x65, 0x17, 0x12, 0x7d, 0xcb, 0xe9, 0xfb, 0x45, 0xb9, 0x12, 0xdf, 0xce, - 0xee, 0xae, 0x5f, 0x9b, 0xb7, 0x7e, 0xd0, 0x25, 0x08, 0x55, 0xb6, 0x20, 0xeb, 0xff, 0x75, 0xa2, - 0x7b, 0x44, 0xf3, 0xcd, 0xd7, 0x04, 0x33, 0x2e, 0xab, 0xc0, 0x49, 0x5d, 0xf3, 0x35, 0x09, 0x7b, - 0x27, 0x19, 0x69, 0xe2, 0x3e, 0xc8, 0x4c, 0x93, 0xf2, 0x13, 0xc8, 0xd9, 0xfa, 0x98, 0xf8, 0xae, - 0x3e, 0x20, 0xac, 0x5e, 0x78, 0x7f, 0x65, 0x43, 0x5a, 0xd3, 0x60, 0xe2, 0x2c, 0xa7, 0xc1, 0x0c, - 0x60, 0xdf, 0x2c, 0x24, 0xfe, 0x88, 0x5d, 0x19, 0xb4, 0x49, 0x1c, 0x67, 0x40, 0x0e, 0x89, 0xc7, - 0x9c, 0x56, 0xfd, 0x13, 0xac, 0x33, 0x37, 0xeb, 0xa7, 0xba, 0x69, 0xe9, 0x7d, 0xd3, 0x32, 0xe9, - 0x99, 0xe8, 0xaf, 0x0d, 0xc8, 0x78, 0xce, 0x2b, 0xcd, 0x73, 0x1c, 0x1a, 0xb8, 0x9f, 0xf6, 0x9c, - 0x57, 0x2a, 0x3b, 0x33, 0x93, 0x06, 0x8e, 0x35, 0x19, 0xdb, 0x82, 0x1f, 0x43, 0x7e, 0x96, 0xd3, - 0x10, 0x52, 0xfd, 0x36, 0x06, 0xf2, 0xb1, 0x43, 0x89, 0xf2, 0x08, 0x64, 0x16, 0x16, 0x34, 0x7b, - 0xf9, 0xba, 0xbe, 0xef, 0x9a, 0x43, 0x9b, 0x18, 0x2d, 0x7f, 0xd8, 0x3b, 0x73, 0x89, 0x8a, 0xe0, - 0x48, 0xdb, 0xc5, 0xe6, 0xda, 0x6e, 0x0d, 0x12, 0x9e, 0x33, 0xb1, 0x0d, 0x74, 0x26, 0xa1, 0xf2, - 0x83, 0x72, 0x00, 0xe9, 0xb0, 0x9b, 0xe4, 0xef, 0xeb, 0xa6, 0x15, 0x96, 0x18, 0xd6, 0xeb, 0x82, - 0xa0, 0xa6, 0xfa, 0xa2, 0xa9, 0x1a, 0x90, 0x09, 0x87, 0xbc, 0xe8, 0xca, 0x1f, 0xd6, 0xd8, 0x33, - 0x31, 0xe5, 0x97, 0xb0, 0x1a, 0xf6, 0x48, 0x58, 0x64, 0x3c, 0xab, 0x85, 0x90, 0x21, 0xaa, 0x6c, - 0xae, 0xfd, 0x34, 0x3e, 0xa8, 0x53, 0xe8, 0xd7, 0xac, 0xfd, 0x9a, 0x38, 0xb1, 0xef, 0x42, 0xc6, - 0x37, 0x87, 0xb6, 0x4e, 0x27, 0x1e, 0x11, 0x1d, 0x3a, 0x23, 0x54, 0xff, 0x2b, 0x41, 0x92, 0x77, - 0x7c, 0x24, 0x6e, 0xd2, 0xf5, 0x71, 0x8b, 0xdd, 0x14, 0xb7, 0xf8, 0xa7, 0xc7, 0xad, 0x0e, 0x10, - 0x1a, 0x13, 0xb4, 0xc5, 0xc6, 0xa2, 0x22, 0x6e, 0x62, 0xd7, 0x1c, 0x8a, 0xde, 0x88, 0x08, 0x55, - 0xbf, 0x94, 0x20, 0x13, 0xf2, 0x95, 0x3a, 0xe4, 0x03, 0xbb, 0xb4, 0x13, 0x4b, 0x1f, 0x8a, 0xda, - 0xd9, 0xbc, 0xd1, 0xb8, 0xc7, 0x96, 0x3e, 0x54, 0xb3, 0xc2, 0x1e, 0x76, 0xb8, 0x3e, 0x0f, 0xb1, - 0x1b, 0xf2, 0x30, 0x97, 0xf8, 0xf8, 0xa7, 0x25, 0x7e, 0x2e, 0x45, 0xf2, 0xd5, 0x14, 0xfd, 0x27, - 0x06, 0xe9, 0x0e, 0xce, 0x18, 0xdd, 0xfa, 0x31, 0x3a, 0x62, 0x03, 0x32, 0xae, 0x63, 0x69, 0x9c, - 0x23, 0x23, 0x27, 0xed, 0x3a, 0x96, 0xba, 0x90, 0xf6, 0xc4, 0x67, 0x6a, 0x97, 0xe4, 0x67, 0x88, - 0x5a, 0xea, 0x6a, 0xd4, 0x3c, 0xc8, 0xf1, 0x50, 0x88, 0x99, 0xf4, 0x90, 0xc5, 0x00, 0x1f, 0x11, - 0xd2, 0xe2, 0x1b, 0x85, 0x9b, 0xcd, 0x91, 0xaa, 0xc0, 0x31, 0x09, 0xbe, 0x22, 0xc5, 0xb3, 0xa3, - 0x78, 0x53, 0x59, 0xaa, 0x02, 0x57, 0xfd, 0x87, 0x04, 0x70, 0xc8, 0x22, 0x8b, 0xfe, 0xb2, 0x6d, - 0xed, 0xa3, 0x09, 0xda, 0xdc, 0xcd, 0xe5, 0x9b, 0x92, 0x26, 0xee, 0xcf, 0xf9, 0x51, 0xbb, 0xf7, - 0x20, 0x3f, 0x2b, 0x46, 0x9f, 0x04, 0xc6, 0x5c, 0xa3, 0x24, 0x5c, 0xa2, 0x5d, 0x42, 0xd5, 0xdc, - 0x69, 0xe4, 0x54, 0xfd, 0x9f, 0x04, 0x19, 0xb4, 0xa9, 0x45, 0xa8, 0x3e, 0x97, 0x43, 0xe9, 0xd3, - 0x73, 0xb8, 0x09, 0xc0, 0xd5, 0xe0, 0x5e, 0xe2, 0x95, 0x95, 0x41, 0x0a, 0xae, 0xa5, 0xdf, 0x84, - 0x01, 0x8f, 0x7f, 0x3c, 0xe0, 0xa2, 0xa5, 0x83, 0xb0, 0xdf, 0x86, 0x94, 0x3d, 0x19, 0x6b, 0x6c, - 0x73, 0xca, 0xbc, 0x5a, 0xed, 0xc9, 0xb8, 0x37, 0xf5, 0xab, 0x36, 0xa4, 0x7a, 0x53, 0x7c, 0x46, - 0x7e, 0x7c, 0xc1, 0xcc, 0x16, 0x5a, 0x3c, 0x5c, 0x68, 0xbb, 0x90, 0xc4, 0x37, 0xa7, 0x5f, 0x8c, - 0xe3, 0x88, 0x29, 0x2d, 0x1a, 0xd3, 0x6e, 0xf5, 0x50, 0xb9, 0x2a, 0x90, 0xd5, 0x17, 0x90, 0x6d, - 0xe9, 0x96, 0x45, 0x74, 0x4a, 0x8c, 0xde, 0x54, 0x59, 0x86, 0x18, 0x9d, 0x8a, 0x05, 0x1a, 0xa3, - 0x53, 0xdc, 0xcb, 0xb8, 0x23, 0xf9, 0xf0, 0x8d, 0xe1, 0x86, 0x04, 0x24, 0xf1, 0xc1, 0x7b, 0x1b, - 0x52, 0x4c, 0x73, 0x30, 0x20, 0x33, 0x6a, 0x92, 0x1d, 0x9b, 0x46, 0x55, 0x83, 0x24, 0x5b, 0xce, - 0xd7, 0xe8, 0x7c, 0x10, 0xbc, 0x0f, 0x62, 0x1f, 0x7b, 0x1f, 0x04, 0x2f, 0x83, 0x1b, 0x2f, 0x20, - 0x90, 0x0e, 0xbc, 0x61, 0x3d, 0xee, 0x53, 0xdd, 0xe3, 0x43, 0x3d, 0xa1, 0xf2, 0x03, 0x7b, 0x9a, - 0x90, 0x70, 0xa2, 0xb3, 0x4f, 0x86, 0xb3, 0x1d, 0x83, 0xf0, 0x00, 0xe5, 0x54, 0x7e, 0x60, 0x81, - 0xb6, 0x88, 0x7e, 0xc2, 0xdf, 0x45, 0x7c, 0x32, 0xa5, 0x19, 0x81, 0xbd, 0x89, 0xee, 0xff, 0x5f, - 0x82, 0x6c, 0x64, 0x88, 0x2a, 0xbf, 0x82, 0x5b, 0x8d, 0xc3, 0xa3, 0xbd, 0x67, 0x5a, 0x73, 0x5f, - 0x7b, 0x7c, 0x58, 0x7f, 0xa2, 0x3d, 0x6f, 0x3f, 0x6b, 0x1f, 0xbd, 0x68, 0x17, 0x96, 0x4a, 0xeb, - 0xe7, 0x17, 0x15, 0x25, 0x82, 0x7d, 0x6e, 0xbf, 0xb4, 0x9d, 0x57, 0xb6, 0xb2, 0x03, 0x6b, 0xf3, - 0x22, 0xf5, 0x46, 0xf7, 0xa0, 0xdd, 0x2b, 0x48, 0xa5, 0x5b, 0xe7, 0x17, 0x95, 0xd5, 0x88, 0x44, - 0xbd, 0xef, 0x13, 0x9b, 0x2e, 0x0a, 0xec, 0x1d, 0xb5, 0x5a, 0xcd, 0x5e, 0x21, 0xb6, 0x20, 0x20, - 0xb6, 0xda, 0x3d, 0x58, 0x9d, 0x17, 0x68, 0x37, 0x0f, 0x0b, 0xf1, 0x92, 0x72, 0x7e, 0x51, 0x59, - 0x8e, 0xa0, 0xdb, 0xa6, 0x55, 0x4a, 0xff, 0xfd, 0x9f, 0xe5, 0xa5, 0x7f, 0xff, 0xab, 0x2c, 0x31, - 0xcf, 0xf2, 0x73, 0x83, 0x54, 0x79, 0x00, 0xb7, 0xbb, 0xcd, 0x27, 0xed, 0x83, 0x7d, 0xad, 0xd5, - 0x7d, 0xa2, 0xf5, 0xfe, 0xdc, 0x39, 0x88, 0x78, 0xb7, 0x72, 0x7e, 0x51, 0xc9, 0x0a, 0x97, 0x6e, - 0x42, 0x77, 0xd4, 0x83, 0xe3, 0xa3, 0xde, 0x41, 0x41, 0xe2, 0xe8, 0x8e, 0x47, 0x4e, 0x1d, 0x4a, - 0x10, 0xfd, 0x10, 0xee, 0x5c, 0x83, 0x0e, 0x1d, 0x5b, 0x3d, 0xbf, 0xa8, 0xe4, 0x3b, 0x1e, 0xe1, - 0x43, 0x06, 0x25, 0x6a, 0x50, 0x5c, 0x94, 0x38, 0xea, 0x1c, 0x75, 0xeb, 0x87, 0x85, 0x4a, 0xa9, - 0x70, 0x7e, 0x51, 0xc9, 0x05, 0x1b, 0x83, 0xe1, 0x67, 0x9e, 0x35, 0xfe, 0xf8, 0xf6, 0xb2, 0x2c, - 0xbd, 0xbb, 0x2c, 0x4b, 0x5f, 0x5f, 0x96, 0xa5, 0x37, 0x1f, 0xca, 0x4b, 0xef, 0x3e, 0x94, 0x97, - 0xbe, 0xf8, 0x50, 0x5e, 0xfa, 0xcb, 0x6f, 0x87, 0x26, 0x1d, 0x4d, 0xfa, 0xb5, 0x81, 0x33, 0xde, - 0x89, 0xfe, 0xbf, 0x9c, 0x7d, 0xf2, 0xff, 0xb9, 0x57, 0xff, 0x7b, 0xf6, 0x93, 0x48, 0x7f, 0xf4, - 0x5d, 0x00, 0x00, 0x00, 0xff, 0xff, 0xac, 0x7f, 0x32, 0x54, 0x3c, 0x0f, 0x00, 0x00, + 0x9d, 0x34, 0x90, 0x53, 0xa7, 0xe8, 0xc7, 0xa1, 0x07, 0xc9, 0x76, 0x12, 0x21, 0xb6, 0xac, 0x52, + 0x8a, 0x93, 0xf6, 0x42, 0x50, 0xe2, 0x58, 0x22, 0x42, 0x91, 0x2c, 0x39, 0x72, 0xe4, 0xdc, 0x7a, + 0x2b, 0x7c, 0xca, 0xa9, 0x37, 0x9f, 0xda, 0xc3, 0xde, 0xf7, 0x1f, 0x58, 0xec, 0x29, 0xc7, 0xdc, + 0x76, 0x2f, 0x9b, 0x5d, 0x38, 0xc0, 0x62, 0xff, 0x8c, 0xc5, 0xbc, 0x19, 0x52, 0x94, 0x65, 0x67, + 0x17, 0x41, 0xb0, 0x17, 0x81, 0xf3, 0xde, 0xef, 0xbd, 0x79, 0xdf, 0x6f, 0x04, 0xb7, 0x29, 0xb1, + 0x0d, 0xe2, 0x8d, 0x4c, 0x9b, 0x6e, 0xd1, 0x53, 0x97, 0xf8, 0xfc, 0xb7, 0xe6, 0x7a, 0x0e, 0x75, + 0x94, 0xc2, 0x94, 0x5b, 0x43, 0x7a, 0x69, 0x65, 0xe0, 0x0c, 0x1c, 0x64, 0x6e, 0xb1, 0x2f, 0x8e, + 0x2b, 0x6d, 0x0c, 0x1c, 0x67, 0x60, 0x91, 0x2d, 0x3c, 0xf5, 0xc6, 0xc7, 0x5b, 0xd4, 0x1c, 0x11, + 0x9f, 0xea, 0x23, 0x57, 0x00, 0xd6, 0x23, 0xd7, 0xf4, 0xbd, 0x53, 0x97, 0x3a, 0x0c, 0xeb, 0x1c, + 0x0b, 0x76, 0x39, 0xc2, 0x3e, 0x21, 0x9e, 0x6f, 0x3a, 0x76, 0xd4, 0x8e, 0x52, 0x65, 0xce, 0xca, + 0x13, 0xdd, 0x32, 0x0d, 0x9d, 0x3a, 0x1e, 0x47, 0x54, 0xff, 0x0a, 0xf9, 0xb6, 0xee, 0xd1, 0x0e, + 0xa1, 0x8f, 0x89, 0x6e, 0x10, 0x4f, 0x59, 0x81, 0x04, 0x75, 0xa8, 0x6e, 0x15, 0xa5, 0x8a, 0xb4, + 0x99, 0x57, 0xf9, 0x41, 0x51, 0x40, 0x1e, 0xea, 0xfe, 0xb0, 0x18, 0xab, 0x48, 0x9b, 0x39, 0x15, + 0xbf, 0xab, 0x43, 0x90, 0x99, 0x28, 0x93, 0x30, 0x6d, 0x83, 0x4c, 0x02, 0x09, 0x3c, 0x30, 0x6a, + 0xef, 0x94, 0x12, 0x5f, 0x88, 0xf0, 0x83, 0xf2, 0x47, 0x48, 0xa0, 0xfd, 0xc5, 0x78, 0x45, 0xda, + 0xcc, 0x6e, 0x17, 0x6b, 0x91, 0x40, 0x71, 0xff, 0x6a, 0x6d, 0xc6, 0x6f, 0xc8, 0x6f, 0xde, 0x6d, + 0x2c, 0xa8, 0x1c, 0x5c, 0xb5, 0x20, 0xd5, 0xb0, 0x9c, 0xfe, 0x8b, 0xe6, 0x6e, 0x68, 0x88, 0x34, + 0x35, 0x44, 0x39, 0x80, 0x25, 0x57, 0xf7, 0xa8, 0xe6, 0x13, 0xaa, 0x0d, 0xd1, 0x0b, 0xbc, 0x34, + 0xbb, 0xbd, 0x51, 0xbb, 0x9c, 0x87, 0xda, 0x8c, 0xb3, 0xe2, 0x96, 0xbc, 0x1b, 0x25, 0x56, 0xbf, + 0x97, 0x21, 0x29, 0x82, 0xf1, 0x37, 0x48, 0x89, 0xb0, 0xe2, 0x85, 0xd9, 0xed, 0xf5, 0xa8, 0x46, + 0xc1, 0xaa, 0xed, 0x38, 0xb6, 0x4f, 0x6c, 0x7f, 0xec, 0x0b, 0x7d, 0x81, 0x8c, 0xf2, 0x5b, 0x48, + 0xf7, 0x87, 0xba, 0x69, 0x6b, 0xa6, 0x81, 0x16, 0x65, 0x1a, 0xd9, 0x8b, 0x77, 0x1b, 0xa9, 0x1d, + 0x46, 0x6b, 0xee, 0xaa, 0x29, 0x64, 0x36, 0x0d, 0x65, 0x15, 0x92, 0x43, 0x62, 0x0e, 0x86, 0x14, + 0xc3, 0x12, 0x57, 0xc5, 0x49, 0xf9, 0x0b, 0xc8, 0xac, 0x20, 0x8a, 0x32, 0xde, 0x5d, 0xaa, 0xf1, + 0x6a, 0xa9, 0x05, 0xd5, 0x52, 0xeb, 0x06, 0xd5, 0xd2, 0x48, 0xb3, 0x8b, 0x5f, 0x7f, 0xbb, 0x21, + 0xa9, 0x28, 0xa1, 0xec, 0x40, 0xde, 0xd2, 0x7d, 0xaa, 0xf5, 0x58, 0xd8, 0xd8, 0xf5, 0x09, 0x54, + 0x71, 0x6b, 0x3e, 0x20, 0x22, 0xb0, 0xc2, 0xf4, 0x2c, 0x93, 0xe2, 0x24, 0x43, 0xd9, 0x84, 0x02, + 0x2a, 0xe9, 0x3b, 0xa3, 0x91, 0x49, 0x35, 0x8c, 0x7b, 0x12, 0xe3, 0xbe, 0xc8, 0xe8, 0x3b, 0x48, + 0x7e, 0xcc, 0x32, 0xb0, 0x06, 0x19, 0x43, 0xa7, 0x3a, 0x87, 0xa4, 0x10, 0x92, 0x66, 0x04, 0x64, + 0xfe, 0x0e, 0x96, 0xc2, 0xaa, 0xf3, 0x39, 0x24, 0xcd, 0xb5, 0x4c, 0xc9, 0x08, 0xbc, 0x0f, 0x2b, + 0x36, 0x99, 0x50, 0xed, 0x32, 0x3a, 0x83, 0x68, 0x85, 0xf1, 0x8e, 0x66, 0x25, 0x7e, 0x03, 0x8b, + 0xfd, 0x20, 0xf8, 0x1c, 0x0b, 0x88, 0xcd, 0x87, 0x54, 0x84, 0xdd, 0x82, 0xb4, 0xee, 0xba, 0x1c, + 0x90, 0x45, 0x40, 0x4a, 0x77, 0x5d, 0x64, 0xdd, 0x85, 0x65, 0xf4, 0xd1, 0x23, 0xfe, 0xd8, 0xa2, + 0x42, 0x49, 0x0e, 0x31, 0x4b, 0x8c, 0xa1, 0x72, 0x3a, 0x62, 0x7f, 0x0d, 0x79, 0x72, 0x62, 0x1a, + 0xc4, 0xee, 0x13, 0x8e, 0xcb, 0x23, 0x2e, 0x17, 0x10, 0x11, 0x74, 0x07, 0x0a, 0xae, 0xe7, 0xb8, + 0x8e, 0x4f, 0x3c, 0x4d, 0x37, 0x0c, 0x8f, 0xf8, 0x7e, 0x71, 0x91, 0xeb, 0x0b, 0xe8, 0x75, 0x4e, + 0xae, 0xfe, 0x5b, 0x02, 0x79, 0x57, 0xa7, 0xba, 0x52, 0x80, 0x38, 0x9d, 0xf8, 0x45, 0xa9, 0x12, + 0xdf, 0xcc, 0xa9, 0xec, 0x53, 0xd9, 0x86, 0x44, 0xcf, 0x72, 0x7a, 0x7e, 0x51, 0xae, 0xc4, 0x37, + 0xb3, 0xdb, 0xab, 0x57, 0xe6, 0xad, 0x17, 0x74, 0x09, 0x42, 0x95, 0x0d, 0xc8, 0xfa, 0xff, 0x1a, + 0xeb, 0x1e, 0xd1, 0x7c, 0xf3, 0x15, 0xc1, 0x8c, 0xcb, 0x2a, 0x70, 0x52, 0xc7, 0x7c, 0x45, 0xc2, + 0xde, 0x49, 0x46, 0x9a, 0xb8, 0x07, 0x32, 0xd3, 0xa4, 0xfc, 0x0a, 0x72, 0xb6, 0x3e, 0x22, 0xbe, + 0xab, 0xf7, 0x09, 0xab, 0x17, 0xde, 0x5f, 0xd9, 0x90, 0xd6, 0x34, 0x98, 0x38, 0xcb, 0x69, 0x30, + 0x03, 0xd8, 0x37, 0x0b, 0x89, 0x3f, 0x64, 0x57, 0x06, 0x6d, 0x12, 0xc7, 0x19, 0x90, 0x43, 0xe2, + 0x11, 0xa7, 0x55, 0x9f, 0xc3, 0x2a, 0x73, 0xb3, 0x7e, 0xa2, 0x9b, 0x96, 0xde, 0x33, 0x2d, 0x93, + 0x9e, 0x8a, 0xfe, 0x5a, 0x83, 0x8c, 0xe7, 0xbc, 0xd4, 0x3c, 0xc7, 0xa1, 0x81, 0xfb, 0x69, 0xcf, + 0x79, 0xa9, 0xb2, 0x33, 0x33, 0xa9, 0xef, 0x58, 0xe3, 0x91, 0x2d, 0xf8, 0x31, 0xe4, 0x67, 0x39, + 0x0d, 0x21, 0xd5, 0x1f, 0x62, 0x20, 0x1f, 0x39, 0x94, 0x28, 0x0f, 0x40, 0x66, 0x61, 0x41, 0xb3, + 0x17, 0xaf, 0xea, 0xfb, 0x8e, 0x39, 0xb0, 0x89, 0x71, 0xe0, 0x0f, 0xba, 0xa7, 0x2e, 0x51, 0x11, + 0x1c, 0x69, 0xbb, 0xd8, 0x4c, 0xdb, 0xad, 0x40, 0xc2, 0x73, 0xc6, 0xb6, 0x81, 0xce, 0x24, 0x54, + 0x7e, 0x50, 0xf6, 0x20, 0x1d, 0x76, 0x93, 0xfc, 0x53, 0xdd, 0xb4, 0xc4, 0x12, 0xc3, 0x7a, 0x5d, + 0x10, 0xd4, 0x54, 0x4f, 0x34, 0x55, 0x03, 0x32, 0xe1, 0x90, 0x17, 0x5d, 0xf9, 0xf3, 0x1a, 0x7b, + 0x2a, 0xa6, 0xfc, 0x1e, 0x96, 0xc3, 0x1e, 0x09, 0x8b, 0x8c, 0x67, 0xb5, 0x10, 0x32, 0x44, 0x95, + 0xcd, 0xb4, 0x9f, 0xc6, 0x07, 0x75, 0x0a, 0xfd, 0x9a, 0xb6, 0x5f, 0x13, 0x27, 0xf6, 0x6d, 0xc8, + 0xf8, 0xe6, 0xc0, 0xd6, 0xe9, 0xd8, 0x23, 0xa2, 0x43, 0xa7, 0x84, 0xea, 0x17, 0x12, 0x24, 0x79, + 0xc7, 0x47, 0xe2, 0x26, 0x5d, 0x1d, 0xb7, 0xd8, 0x75, 0x71, 0x8b, 0x7f, 0x7c, 0xdc, 0xea, 0x00, + 0xa1, 0x31, 0x41, 0x5b, 0xac, 0xcd, 0x2b, 0xe2, 0x26, 0x76, 0xcc, 0x81, 0xe8, 0x8d, 0x88, 0x50, + 0xf5, 0x1b, 0x09, 0x32, 0x21, 0x5f, 0xa9, 0x43, 0x3e, 0xb0, 0x4b, 0x3b, 0xb6, 0xf4, 0x81, 0xa8, + 0x9d, 0xf5, 0x6b, 0x8d, 0x7b, 0x68, 0xe9, 0x03, 0x35, 0x2b, 0xec, 0x61, 0x87, 0xab, 0xf3, 0x10, + 0xbb, 0x26, 0x0f, 0x33, 0x89, 0x8f, 0x7f, 0x5c, 0xe2, 0x67, 0x52, 0x24, 0x5f, 0x4e, 0xd1, 0xe7, + 0x31, 0x48, 0xb7, 0x71, 0xc6, 0xe8, 0xd6, 0x2f, 0xd1, 0x11, 0x6b, 0x90, 0x71, 0x1d, 0x4b, 0xe3, + 0x1c, 0x19, 0x39, 0x69, 0xd7, 0xb1, 0xd4, 0xb9, 0xb4, 0x27, 0x3e, 0x51, 0xbb, 0x24, 0x3f, 0x41, + 0xd4, 0x52, 0x97, 0xa3, 0xe6, 0x41, 0x8e, 0x87, 0x42, 0xcc, 0xa4, 0xfb, 0x2c, 0x06, 0xf8, 0x88, + 0x90, 0xe6, 0xdf, 0x28, 0xdc, 0x6c, 0x8e, 0x54, 0x05, 0x8e, 0x49, 0xf0, 0x15, 0x29, 0x9e, 0x1d, + 0xc5, 0xeb, 0xca, 0x52, 0x15, 0xb8, 0xea, 0x7f, 0x25, 0x80, 0x7d, 0x16, 0x59, 0xf4, 0x97, 0x6d, + 0x6b, 0x1f, 0x4d, 0xd0, 0x66, 0x6e, 0x2e, 0x5f, 0x97, 0x34, 0x71, 0x7f, 0xce, 0x8f, 0xda, 0xbd, + 0x03, 0xf9, 0x69, 0x31, 0xfa, 0x24, 0x30, 0xe6, 0x0a, 0x25, 0xe1, 0x12, 0xed, 0x10, 0xaa, 0xe6, + 0x4e, 0x22, 0xa7, 0xea, 0x97, 0x12, 0x64, 0xd0, 0xa6, 0x03, 0x42, 0xf5, 0x99, 0x1c, 0x4a, 0x1f, + 0x9f, 0xc3, 0x75, 0x00, 0xae, 0x06, 0xf7, 0x12, 0xaf, 0xac, 0x0c, 0x52, 0x70, 0x2d, 0xfd, 0x29, + 0x0c, 0x78, 0xfc, 0xc3, 0x01, 0x17, 0x2d, 0x1d, 0x84, 0xfd, 0x26, 0xa4, 0xec, 0xf1, 0x48, 0x63, + 0x9b, 0x53, 0xe6, 0xd5, 0x6a, 0x8f, 0x47, 0xdd, 0x89, 0x5f, 0xb5, 0x21, 0xd5, 0x9d, 0xe0, 0x33, + 0xf2, 0xc3, 0x0b, 0x66, 0xba, 0xd0, 0xe2, 0xe1, 0x42, 0xdb, 0x86, 0x24, 0xbe, 0x39, 0xfd, 0x62, + 0x1c, 0x47, 0x4c, 0x69, 0xde, 0x98, 0xd6, 0x41, 0x17, 0x95, 0xab, 0x02, 0x59, 0x7d, 0x0e, 0x39, + 0x9c, 0xa0, 0xcf, 0x3c, 0xdd, 0x75, 0x89, 0xa7, 0x2c, 0x42, 0x8c, 0x4e, 0xc4, 0x06, 0x8d, 0xd1, + 0x09, 0x2e, 0x66, 0x5c, 0x92, 0x7c, 0xfa, 0xc6, 0x70, 0x45, 0x02, 0x92, 0xf8, 0xe4, 0xbd, 0x09, + 0x29, 0xa6, 0x3a, 0x98, 0x90, 0x19, 0x35, 0xc9, 0x8e, 0x4d, 0xa3, 0xaa, 0x41, 0x92, 0x6d, 0xe7, + 0xee, 0x64, 0x4e, 0xe7, 0xbd, 0xe0, 0x81, 0x10, 0xfb, 0xd0, 0x03, 0x21, 0x78, 0x1a, 0x5c, 0x7b, + 0x01, 0x81, 0x74, 0xe0, 0x0e, 0x6b, 0x72, 0x9f, 0xea, 0x1e, 0x9f, 0xea, 0x09, 0x95, 0x1f, 0xd8, + 0xdb, 0x84, 0x84, 0x23, 0x9d, 0x7d, 0x32, 0x9c, 0xed, 0x18, 0x84, 0x47, 0x28, 0xa7, 0xf2, 0x03, + 0x8b, 0xb4, 0x45, 0xf4, 0x63, 0xfe, 0x30, 0xe2, 0xa3, 0x29, 0xcd, 0x08, 0xec, 0x51, 0x74, 0xf7, + 0x2b, 0x09, 0xb2, 0x91, 0x29, 0xaa, 0xfc, 0x01, 0x6e, 0x34, 0xf6, 0x0f, 0x77, 0x9e, 0x68, 0xcd, + 0x5d, 0xed, 0xe1, 0x7e, 0xfd, 0x91, 0xf6, 0xb4, 0xf5, 0xa4, 0x75, 0xf8, 0xac, 0x55, 0x58, 0x28, + 0xad, 0x9e, 0x9d, 0x57, 0x94, 0x08, 0xf6, 0xa9, 0xfd, 0xc2, 0x76, 0x5e, 0xda, 0xca, 0x16, 0xac, + 0xcc, 0x8a, 0xd4, 0x1b, 0x9d, 0xbd, 0x56, 0xb7, 0x20, 0x95, 0x6e, 0x9c, 0x9d, 0x57, 0x96, 0x23, + 0x12, 0xf5, 0x9e, 0x4f, 0x6c, 0x3a, 0x2f, 0xb0, 0x73, 0x78, 0x70, 0xd0, 0xec, 0x16, 0x62, 0x73, + 0x02, 0x62, 0xad, 0xdd, 0x81, 0xe5, 0x59, 0x81, 0x56, 0x73, 0xbf, 0x10, 0x2f, 0x29, 0x67, 0xe7, + 0x95, 0xc5, 0x08, 0xba, 0x65, 0x5a, 0xa5, 0xf4, 0x7f, 0xfe, 0x57, 0x5e, 0xf8, 0xec, 0xff, 0x65, + 0x89, 0x79, 0x96, 0x9f, 0x99, 0xa4, 0xca, 0x3d, 0xb8, 0xd9, 0x69, 0x3e, 0x6a, 0xed, 0xed, 0x6a, + 0x07, 0x9d, 0x47, 0x5a, 0xf7, 0x1f, 0xed, 0xbd, 0x88, 0x77, 0x4b, 0x67, 0xe7, 0x95, 0xac, 0x70, + 0xe9, 0x3a, 0x74, 0x5b, 0xdd, 0x3b, 0x3a, 0xec, 0xee, 0x15, 0x24, 0x8e, 0x6e, 0x7b, 0xe4, 0xc4, + 0xa1, 0x04, 0xd1, 0xf7, 0xe1, 0xd6, 0x15, 0xe8, 0xd0, 0xb1, 0xe5, 0xb3, 0xf3, 0x4a, 0xbe, 0xed, + 0x11, 0x3e, 0x65, 0x50, 0xa2, 0x06, 0xc5, 0x79, 0x89, 0xc3, 0xf6, 0x61, 0xa7, 0xbe, 0x5f, 0xa8, + 0x94, 0x0a, 0x67, 0xe7, 0x95, 0x5c, 0xb0, 0x32, 0x18, 0x7e, 0xea, 0x59, 0xe3, 0xef, 0x6f, 0x2e, + 0xca, 0xd2, 0xdb, 0x8b, 0xb2, 0xf4, 0xdd, 0x45, 0x59, 0x7a, 0xfd, 0xbe, 0xbc, 0xf0, 0xf6, 0x7d, + 0x79, 0xe1, 0xeb, 0xf7, 0xe5, 0x85, 0x7f, 0xfe, 0x79, 0x60, 0xd2, 0xe1, 0xb8, 0x57, 0xeb, 0x3b, + 0xa3, 0xad, 0xe8, 0x1f, 0xcc, 0xe9, 0x27, 0xff, 0xa3, 0x7b, 0xf9, 0xcf, 0x67, 0x2f, 0x89, 0xf4, + 0x07, 0x3f, 0x06, 0x00, 0x00, 0xff, 0xff, 0x9a, 0xc9, 0xb8, 0x3f, 0x3d, 0x0f, 0x00, 0x00, } func (m *PartSetHeader) Marshal() (dAtA []byte, err error) { @@ -2357,7 +2356,7 @@ func (m *TxProof) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *MalleatedTx) Marshal() (dAtA []byte, err error) { +func (m *IndexWrapper) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) n, err := m.MarshalToSizedBuffer(dAtA[:size]) @@ -2367,12 +2366,12 @@ func (m *MalleatedTx) Marshal() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *MalleatedTx) MarshalTo(dAtA []byte) (int, error) { +func (m *IndexWrapper) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } -func (m *MalleatedTx) MarshalToSizedBuffer(dAtA []byte) (int, error) { +func (m *IndexWrapper) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int @@ -2873,7 +2872,7 @@ func (m *TxProof) Size() (n int) { return n } -func (m *MalleatedTx) Size() (n int) { +func (m *IndexWrapper) Size() (n int) { if m == nil { return 0 } @@ -5586,7 +5585,7 @@ func (m *TxProof) Unmarshal(dAtA []byte) error { } return nil } -func (m *MalleatedTx) Unmarshal(dAtA []byte) error { +func (m *IndexWrapper) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -5609,10 +5608,10 @@ func (m *MalleatedTx) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MalleatedTx: wiretype end group for non-group") + return fmt.Errorf("proto: IndexWrapper: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MalleatedTx: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: IndexWrapper: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: diff --git a/proto/tendermint/types/types.proto b/proto/tendermint/types/types.proto index 753a5043f5..8bacadca68 100644 --- a/proto/tendermint/types/types.proto +++ b/proto/tendermint/types/types.proto @@ -189,10 +189,9 @@ message TxProof { repeated NMTProof proofs = 3; } -// MalleatedTx wraps a transaction that was derived from a different original -// transaction. This allows for tendermint to track malleated and original -// transactions -message MalleatedTx { +// IndexWrapper adds index metadata to a transaction. This is used to track +// transactions that pay for blobs, and where the blobs start in the square. +message IndexWrapper { bytes tx = 1; uint32 share_index = 2; string type_id = 3; diff --git a/state/txindex/kv/kv_test.go b/state/txindex/kv/kv_test.go index 1877e9399f..03925f56d0 100644 --- a/state/txindex/kv/kv_test.go +++ b/state/txindex/kv/kv_test.go @@ -70,7 +70,7 @@ func TestWrappedTxIndex(t *testing.T) { indexer := NewTxIndex(db.NewMemDB()) tx := types.Tx("HELLO WORLD") - wrappedTx, err := types.MarshalMalleatedTx(11, tx) + wrappedTx, err := types.MarshalIndexWrapper(11, tx) require.NoError(t, err) txResult := &abci.TxResult{ Height: 1, diff --git a/types/event_bus_test.go b/types/event_bus_test.go index c43b8511ea..bb7009ea9a 100644 --- a/types/event_bus_test.go +++ b/types/event_bus_test.go @@ -65,7 +65,7 @@ func TestEventBusPublishEventTx(t *testing.T) { } } -func TestEventBusPublishEventMalleatedTx(t *testing.T) { +func TestEventBusPublishEventIndexWrapper(t *testing.T) { eventBus := NewEventBus() err := eventBus.Start() require.NoError(t, err) diff --git a/types/tx.go b/types/tx.go index 1b8dbeb400..71e83794d4 100644 --- a/types/tx.go +++ b/types/tx.go @@ -29,10 +29,10 @@ type ( ) // Hash computes the TMHASH hash of the wire encoded transaction. It attempts to -// unwrap the transaction if it is a MalleatedTx or a BlobTx. +// unwrap the transaction if it is a IndexWrapper or a BlobTx. func (tx Tx) Hash() []byte { - if malleatedTx, isMalleated := UnmarshalMalleatedTx(tx); isMalleated { - return tmhash.Sum(malleatedTx.Tx) + if indexWrapper, isIndexWrapper := UnmarshalIndexWrapper(tx); isIndexWrapper { + return tmhash.Sum(indexWrapper.Tx) } if blobTx, isBlobTx := UnmarshalBlobTx(tx); isBlobTx { return tmhash.Sum(blobTx.Tx) @@ -41,13 +41,13 @@ func (tx Tx) Hash() []byte { } // Key returns the sha256 hash of the wire encoded transaction. It attempts to -// unwrap the transaction if it is a BlobTx or a MalleatedTx. +// unwrap the transaction if it is a BlobTx or a IndexWrapper. func (tx Tx) Key() TxKey { if blobTx, isBlobTx := UnmarshalBlobTx(tx); isBlobTx { return sha256.Sum256(blobTx.Tx) } - if malleatedTx, isMalleated := UnmarshalMalleatedTx(tx); isMalleated { - return sha256.Sum256(malleatedTx.Tx) + if indexWrapper, isIndexWrapper := UnmarshalIndexWrapper(tx); isIndexWrapper { + return sha256.Sum256(indexWrapper.Tx) } return sha256.Sum256(tx) } @@ -208,36 +208,36 @@ func ComputeProtoSizeForTxs(txs []Tx) int64 { return int64(pdData.Size()) } -// UnmarshalMalleatedTx attempts to unmarshal the provided transaction into a -// malleated transaction. It returns true if the provided transaction is a -// malleated transaction. A malleated transaction is a transaction that contains +// UnmarshalIndexWrapper attempts to unmarshal the provided transaction into an +// IndexWrapper transaction. It returns true if the provided transaction is an +// IndexWrapper transaction. An IndexWrapper transaction is a transaction that contains // a MsgPayForBlob that has been wrapped with a share index. // // NOTE: protobuf sometimes does not throw an error if the transaction passed is -// not a tmproto.MalleatedTx, since the protobuf definition for MsgPayForBlob is +// not a tmproto.IndexWrapper, since the protobuf definition for MsgPayForBlob is // kept in the app, we cannot perform further checks without creating an import // cycle. -func UnmarshalMalleatedTx(tx Tx) (malleatedTx tmproto.MalleatedTx, isMalleated bool) { - // attempt to unmarshal into a a malleated transaction - err := proto.Unmarshal(tx, &malleatedTx) +func UnmarshalIndexWrapper(tx Tx) (indexWrapper tmproto.IndexWrapper, isIndexWrapper bool) { + // attempt to unmarshal into an IndexWrapper transaction + err := proto.Unmarshal(tx, &indexWrapper) if err != nil { - return malleatedTx, false + return indexWrapper, false } - if malleatedTx.TypeId != consts.ProtoMalleatedTxTypeID { - return malleatedTx, false + if indexWrapper.TypeId != consts.ProtoIndexWrapperTypeID { + return indexWrapper, false } - return malleatedTx, true + return indexWrapper, true } -// MarshalMalleatedTx creates a wrapped Tx that includes the original transaction +// MarshalIndexWrapper creates a wrapped Tx that includes the original transaction // and the share index of the start of its blob. // // NOTE: must be unwrapped to be a viable sdk.Tx -func MarshalMalleatedTx(shareIndex uint32, tx Tx) (Tx, error) { - wTx := tmproto.MalleatedTx{ +func MarshalIndexWrapper(shareIndex uint32, tx Tx) (Tx, error) { + wTx := tmproto.IndexWrapper{ Tx: tx, ShareIndex: shareIndex, - TypeId: consts.ProtoMalleatedTxTypeID, + TypeId: consts.ProtoIndexWrapperTypeID, } return proto.Marshal(&wTx) } diff --git a/types/tx_test.go b/types/tx_test.go index 14fe5889e4..5ea0ee262a 100644 --- a/types/tx_test.go +++ b/types/tx_test.go @@ -44,11 +44,11 @@ func TestTxIndexByHash(t *testing.T) { } } -func TestUnmarshalMalleatedTx(t *testing.T) { +func TestUnmarshalIndexWrapper(t *testing.T) { // perform a simple test for being unable to decode a non - // malleated transaction + // IndexWrapper transaction tx := Tx{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0} - _, ok := UnmarshalMalleatedTx(tx) + _, ok := UnmarshalIndexWrapper(tx) require.False(t, ok) data := Data{ @@ -77,19 +77,19 @@ func TestUnmarshalMalleatedTx(t *testing.T) { // due to protobuf not actually requiring type compatibility // we need to make sure that there is some check - _, ok = UnmarshalMalleatedTx(rawBlock) + _, ok = UnmarshalIndexWrapper(rawBlock) require.False(t, ok) - MalleatedTx, err := MarshalMalleatedTx(0, rawBlock) + IndexWrapper, err := MarshalIndexWrapper(0, rawBlock) require.NoError(t, err) // finally, ensure that the unwrapped bytes are identical to the input - malleated, ok := UnmarshalMalleatedTx(MalleatedTx) + indexWrapper, ok := UnmarshalIndexWrapper(IndexWrapper) require.True(t, ok) - require.Equal(t, rawBlock, malleated.Tx) + require.Equal(t, rawBlock, indexWrapper.Tx) } -func TestWrapUnmarshalBlobTx(t *testing.T) { +func TestUnmarshalBlobTx(t *testing.T) { tx := []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7, 8, 9} blob := tmproto.Blob{ NamespaceId: []byte{1, 2, 3, 4, 5, 6, 7, 8},