pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-14 00:31:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Revert "FRAME: Create TransactionExtension as a replacement for SignedExtension (#2280)" (#3665)

Browse Source 
This PR reverts #2280 which introduced `TransactionExtension` to replace
`SignedExtension`.

As a result of the discussion
[here](https://github.com/paritytech/polkadot-sdk/pull/3623#issuecomment-1986789700),
the changes will be reverted for now with plans to reintroduce the
concept in the future.

---------

Signed-off-by: georgepisaltu <george.pisaltu@parity.io>
This commit is contained in:
georgepisaltu
2024-03-13 16:10:59 +02:00
committed by GitHub
parent 60ac5a723c
commit bbd51ce867
350 changed files with 15826 additions and 24304 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/client/api/src/notifications/tests.rs
+2 -5
View File
@@ -18,10 +18,7 @@
use super::*;
use sp_runtime::{
generic::UncheckedExtrinsic,
testing::{Block as RawBlock, H256 as Hash},
};
use sp_runtime::testing::{Block as RawBlock, ExtrinsicWrapper, H256 as Hash};
use std::iter::{empty, Empty};
type TestChangeSet = (
@@ -53,7 +50,7 @@ impl PartialEq for StorageChangeSet {
}
}
type Block = RawBlock<UncheckedExtrinsic<u64, substrate_test_runtime::RuntimeCall, (), ()>>;
type Block = RawBlock<ExtrinsicWrapper<Hash>>;
#[test]
fn triggering_change_should_notify_wildcard_listeners() {
substrate/client/db/benches/state_access.rs
+2 -3
View File
@@ -22,13 +22,12 @@ use sc_client_api::{Backend as _, BlockImportOperation, NewBlockState, StateBack
use sc_client_db::{Backend, BlocksPruning, DatabaseSettings, DatabaseSource, PruningMode};
use sp_core::H256;
use sp_runtime::{
generic::UncheckedExtrinsic,
testing::{Block as RawBlock, Header, MockCallU64},
testing::{Block as RawBlock, ExtrinsicWrapper, Header},
StateVersion, Storage,
};
use tempfile::TempDir;
pub(crate) type Block = RawBlock<UncheckedExtrinsic<u64, MockCallU64, (), ()>>;
pub(crate) type Block = RawBlock<ExtrinsicWrapper<u64>>;
fn insert_blocks(db: &Backend<Block>, storage: Vec<(Vec<u8>, Vec<u8>)>) -> H256 {
let mut op = db.begin_operation().unwrap();
substrate/client/db/src/lib.rs
+62 -200
View File
@@ -2573,8 +2573,7 @@ pub(crate) mod tests {
use sp_blockchain::{lowest_common_ancestor, tree_route};
use sp_core::H256;
use sp_runtime::{
generic::UncheckedExtrinsic,
testing::{Block as RawBlock, Header, MockCallU64},
testing::{Block as RawBlock, ExtrinsicWrapper, Header},
traits::{BlakeTwo256, Hash},
ConsensusEngineId, StateVersion,
};
@@ -2582,8 +2581,7 @@ pub(crate) mod tests {
const CONS0_ENGINE_ID: ConsensusEngineId = *b"CON0";
const CONS1_ENGINE_ID: ConsensusEngineId = *b"CON1";
type UncheckedXt = UncheckedExtrinsic<u64, MockCallU64, (), ()>;
pub(crate) type Block = RawBlock<UncheckedXt>;
pub(crate) type Block = RawBlock<ExtrinsicWrapper<u64>>;
pub fn insert_header(
backend: &Backend<Block>,
@@ -2602,7 +2600,7 @@ pub(crate) mod tests {
parent_hash: H256,
_changes: Option<Vec<(Vec<u8>, Vec<u8>)>>,
extrinsics_root: H256,
body: Vec<UncheckedXt>,
body: Vec<ExtrinsicWrapper<u64>>,
transaction_index: Option<Vec<IndexOperation>>,
) -> Result<H256, sp_blockchain::Error> {
use sp_runtime::testing::Digest;
@@ -3416,7 +3414,7 @@ pub(crate) mod tests {
prev_hash,
None,
Default::default(),
vec![UncheckedXt::new_transaction(i.into(), ())],
vec![i.into()],
None,
)
.unwrap();
@@ -3438,20 +3436,11 @@ pub(crate) mod tests {
assert_eq!(None, bc.body(blocks[0]).unwrap());
assert_eq!(None, bc.body(blocks[1]).unwrap());
assert_eq!(None, bc.body(blocks[2]).unwrap());
assert_eq!(
Some(vec![UncheckedXt::new_transaction(3.into(), ())]),
bc.body(blocks[3]).unwrap()
);
assert_eq!(
Some(vec![UncheckedXt::new_transaction(4.into(), ())]),
bc.body(blocks[4]).unwrap()
);
assert_eq!(Some(vec![3.into()]), bc.body(blocks[3]).unwrap());
assert_eq!(Some(vec![4.into()]), bc.body(blocks[4]).unwrap());
} else {
for i in 0..5 {
assert_eq!(
Some(vec![UncheckedXt::new_transaction((i as u64).into(), ())]),
bc.body(blocks[i]).unwrap()
);
assert_eq!(Some(vec![(i as u64).into()]), bc.body(blocks[i]).unwrap());
}
}
}
@@ -3475,7 +3464,7 @@ pub(crate) mod tests {
prev_hash,
None,
Default::default(),
vec![UncheckedXt::new_transaction(i.into(), ())],
vec![i.into()],
None,
)
.unwrap();
@@ -3484,26 +3473,16 @@ pub(crate) mod tests {
}
// insert a fork at block 2
let fork_hash_root = insert_block(
&backend,
2,
blocks[1],
None,
H256::random(),
vec![UncheckedXt::new_transaction(2.into(), ())],
None,
)
.unwrap();
let fork_hash_root =
insert_block(&backend, 2, blocks[1], None, H256::random(), vec![2.into()], None)
.unwrap();
insert_block(
&backend,
3,
fork_hash_root,
None,
H256::random(),
vec![
UncheckedXt::new_transaction(3.into(), ()),
UncheckedXt::new_transaction(11.into(), ()),
],
vec![3.into(), 11.into()],
None,
)
.unwrap();
@@ -3513,10 +3492,7 @@ pub(crate) mod tests {
backend.commit_operation(op).unwrap();
let bc = backend.blockchain();
assert_eq!(
Some(vec![UncheckedXt::new_transaction(2.into(), ())]),
bc.body(fork_hash_root).unwrap()
);
assert_eq!(Some(vec![2.into()]), bc.body(fork_hash_root).unwrap());
for i in 1..5 {
let mut op = backend.begin_operation().unwrap();
@@ -3530,28 +3506,16 @@ pub(crate) mod tests {
assert_eq!(None, bc.body(blocks[1]).unwrap());
assert_eq!(None, bc.body(blocks[2]).unwrap());
assert_eq!(
Some(vec![UncheckedXt::new_transaction(3.into(), ())]),
bc.body(blocks[3]).unwrap()
);
assert_eq!(
Some(vec![UncheckedXt::new_transaction(4.into(), ())]),
bc.body(blocks[4]).unwrap()
);
assert_eq!(Some(vec![3.into()]), bc.body(blocks[3]).unwrap());
assert_eq!(Some(vec![4.into()]), bc.body(blocks[4]).unwrap());
} else {
for i in 0..5 {
assert_eq!(
Some(vec![UncheckedXt::new_transaction((i as u64).into(), ())]),
bc.body(blocks[i]).unwrap()
);
assert_eq!(Some(vec![(i as u64).into()]), bc.body(blocks[i]).unwrap());
}
}
if matches!(pruning, BlocksPruning::KeepAll) {
assert_eq!(
Some(vec![UncheckedXt::new_transaction(2.into(), ())]),
bc.body(fork_hash_root).unwrap()
);
assert_eq!(Some(vec![2.into()]), bc.body(fork_hash_root).unwrap());
} else {
assert_eq!(None, bc.body(fork_hash_root).unwrap());
}
@@ -3572,16 +3536,8 @@ pub(crate) mod tests {
let backend = Backend::<Block>::new_test_with_tx_storage(BlocksPruning::Some(10), 10);
let make_block = |index, parent, val: u64| {
insert_block(
&backend,
index,
parent,
None,
H256::random(),
vec![UncheckedXt::new_transaction(val.into(), ())],
None,
)
.unwrap()
insert_block(&backend, index, parent, None, H256::random(), vec![val.into()], None)
.unwrap()
};
let block_0 = make_block(0, Default::default(), 0x00);
@@ -3609,30 +3565,18 @@ pub(crate) mod tests {
let bc = backend.blockchain();
assert_eq!(None, bc.body(block_1b).unwrap());
assert_eq!(None, bc.body(block_2b).unwrap());
assert_eq!(
Some(vec![UncheckedXt::new_transaction(0x00.into(), ())]),
bc.body(block_0).unwrap()
);
assert_eq!(
Some(vec![UncheckedXt::new_transaction(0x1a.into(), ())]),
bc.body(block_1a).unwrap()
);
assert_eq!(
Some(vec![UncheckedXt::new_transaction(0x2a.into(), ())]),
bc.body(block_2a).unwrap()
);
assert_eq!(
Some(vec![UncheckedXt::new_transaction(0x3a.into(), ())]),
bc.body(block_3a).unwrap()
);
assert_eq!(Some(vec![0x00.into()]), bc.body(block_0).unwrap());
assert_eq!(Some(vec![0x1a.into()]), bc.body(block_1a).unwrap());
assert_eq!(Some(vec![0x2a.into()]), bc.body(block_2a).unwrap());
assert_eq!(Some(vec![0x3a.into()]), bc.body(block_3a).unwrap());
}
#[test]
fn indexed_data_block_body() {
let backend = Backend::<Block>::new_test_with_tx_storage(BlocksPruning::Some(1), 10);
let x0 = UncheckedXt::new_transaction(0.into(), ()).encode();
let x1 = UncheckedXt::new_transaction(1.into(), ()).encode();
let x0 = ExtrinsicWrapper::from(0u64).encode();
let x1 = ExtrinsicWrapper::from(1u64).encode();
let x0_hash = <HashingFor<Block> as sp_core::Hasher>::hash(&x0[1..]);
let x1_hash = <HashingFor<Block> as sp_core::Hasher>::hash(&x1[1..]);
let index = vec![
@@ -3653,10 +3597,7 @@ pub(crate) mod tests {
Default::default(),
None,
Default::default(),
vec![
UncheckedXt::new_transaction(0.into(), ()),
UncheckedXt::new_transaction(1.into(), ()),
],
vec![0u64.into(), 1u64.into()],
Some(index),
)
.unwrap();
@@ -3678,9 +3619,8 @@ pub(crate) mod tests {
fn index_invalid_size() {
let backend = Backend::<Block>::new_test_with_tx_storage(BlocksPruning::Some(1), 10);
let x0 = UncheckedXt::new_transaction(0.into(), ()).encode();
let x1 = UncheckedXt::new_transaction(1.into(), ()).encode();
let x0 = ExtrinsicWrapper::from(0u64).encode();
let x1 = ExtrinsicWrapper::from(1u64).encode();
let x0_hash = <HashingFor<Block> as sp_core::Hasher>::hash(&x0[..]);
let x1_hash = <HashingFor<Block> as sp_core::Hasher>::hash(&x1[..]);
let index = vec![
@@ -3701,10 +3641,7 @@ pub(crate) mod tests {
Default::default(),
None,
Default::default(),
vec![
UncheckedXt::new_transaction(0.into(), ()),
UncheckedXt::new_transaction(1.into(), ()),
],
vec![0u64.into(), 1u64.into()],
Some(index),
)
.unwrap();
@@ -3718,7 +3655,7 @@ pub(crate) mod tests {
let backend = Backend::<Block>::new_test_with_tx_storage(BlocksPruning::Some(2), 10);
let mut blocks = Vec::new();
let mut prev_hash = Default::default();
let x1 = UncheckedXt::new_transaction(0.into(), ()).encode();
let x1 = ExtrinsicWrapper::from(0u64).encode();
let x1_hash = <HashingFor<Block> as sp_core::Hasher>::hash(&x1[1..]);
for i in 0..10 {
let mut index = Vec::new();
@@ -3738,7 +3675,7 @@ pub(crate) mod tests {
prev_hash,
None,
Default::default(),
vec![UncheckedXt::new_transaction(i.into(), ())],
vec![i.into()],
Some(index),
)
.unwrap();
@@ -3772,7 +3709,7 @@ pub(crate) mod tests {
prev_hash,
None,
Default::default(),
vec![UncheckedXt::new_transaction(i.into(), ())],
vec![i.into()],
None,
)
.unwrap();
@@ -3787,7 +3724,7 @@ pub(crate) mod tests {
blocks[1],
None,
sp_core::H256::random(),
vec![UncheckedXt::new_transaction(i.into(), ())],
vec![i.into()],
None,
)
.unwrap();
@@ -3801,7 +3738,7 @@ pub(crate) mod tests {
blocks[0],
None,
sp_core::H256::random(),
vec![UncheckedXt::new_transaction(42.into(), ())],
vec![42.into()],
None,
)
.unwrap();
@@ -4274,7 +4211,7 @@ pub(crate) mod tests {
prev_hash,
None,
Default::default(),
vec![UncheckedXt::new_transaction(i.into(), ())],
vec![i.into()],
None,
)
.unwrap();
@@ -4289,10 +4226,7 @@ pub(crate) mod tests {
// Check that we can properly access values when there is reference count
// but no value.
assert_eq!(
Some(vec![UncheckedXt::new_transaction(1.into(), ())]),
bc.body(blocks[1]).unwrap()
);
assert_eq!(Some(vec![1.into()]), bc.body(blocks[1]).unwrap());
// Block 1 gets pinned three times
backend.pin_block(blocks[1]).unwrap();
@@ -4309,42 +4243,27 @@ pub(crate) mod tests {
// Block 0, 1, 2, 3 are pinned, so all values should be cached.
// Block 4 is inside the pruning window, its value is in db.
assert_eq!(
Some(vec![UncheckedXt::new_transaction(0.into(), ())]),
bc.body(blocks[0]).unwrap()
);
assert_eq!(Some(vec![0.into()]), bc.body(blocks[0]).unwrap());
assert_eq!(
Some(vec![UncheckedXt::new_transaction(1.into(), ())]),
bc.body(blocks[1]).unwrap()
);
assert_eq!(Some(vec![1.into()]), bc.body(blocks[1]).unwrap());
assert_eq!(
Some(Justifications::from(build_justification(1))),
bc.justifications(blocks[1]).unwrap()
);
assert_eq!(
Some(vec![UncheckedXt::new_transaction(2.into(), ())]),
bc.body(blocks[2]).unwrap()
);
assert_eq!(Some(vec![2.into()]), bc.body(blocks[2]).unwrap());
assert_eq!(
Some(Justifications::from(build_justification(2))),
bc.justifications(blocks[2]).unwrap()
);
assert_eq!(
Some(vec![UncheckedXt::new_transaction(3.into(), ())]),
bc.body(blocks[3]).unwrap()
);
assert_eq!(Some(vec![3.into()]), bc.body(blocks[3]).unwrap());
assert_eq!(
Some(Justifications::from(build_justification(3))),
bc.justifications(blocks[3]).unwrap()
);
assert_eq!(
Some(vec![UncheckedXt::new_transaction(4.into(), ())]),
bc.body(blocks[4]).unwrap()
);
assert_eq!(Some(vec![4.into()]), bc.body(blocks[4]).unwrap());
assert_eq!(
Some(Justifications::from(build_justification(4))),
bc.justifications(blocks[4]).unwrap()
@@ -4375,10 +4294,7 @@ pub(crate) mod tests {
assert!(bc.justifications(blocks[1]).unwrap().is_none());
// Block 4 is inside the pruning window and still kept
assert_eq!(
Some(vec![UncheckedXt::new_transaction(4.into(), ())]),
bc.body(blocks[4]).unwrap()
);
assert_eq!(Some(vec![4.into()]), bc.body(blocks[4]).unwrap());
assert_eq!(
Some(Justifications::from(build_justification(4))),
bc.justifications(blocks[4]).unwrap()
@@ -4386,16 +4302,9 @@ pub(crate) mod tests {
// Block tree:
// 0 -> 1 -> 2 -> 3 -> 4 -> 5
let hash = insert_block(
&backend,
5,
prev_hash,
None,
Default::default(),
vec![UncheckedXt::new_transaction(5.into(), ())],
None,
)
.unwrap();
let hash =
insert_block(&backend, 5, prev_hash, None, Default::default(), vec![5.into()], None)
.unwrap();
blocks.push(hash);
backend.pin_block(blocks[4]).unwrap();
@@ -4410,18 +4319,12 @@ pub(crate) mod tests {
assert!(bc.body(blocks[2]).unwrap().is_none());
assert!(bc.body(blocks[3]).unwrap().is_none());
assert_eq!(
Some(vec![UncheckedXt::new_transaction(4.into(), ())]),
bc.body(blocks[4]).unwrap()
);
assert_eq!(Some(vec![4.into()]), bc.body(blocks[4]).unwrap());
assert_eq!(
Some(Justifications::from(build_justification(4))),
bc.justifications(blocks[4]).unwrap()
);
assert_eq!(
Some(vec![UncheckedXt::new_transaction(5.into(), ())]),
bc.body(blocks[5]).unwrap()
);
assert_eq!(Some(vec![5.into()]), bc.body(blocks[5]).unwrap());
assert!(bc.header(blocks[5]).ok().flatten().is_some());
backend.unpin_block(blocks[4]);
@@ -4431,16 +4334,9 @@ pub(crate) mod tests {
// Append a justification to block 5.
backend.append_justification(blocks[5], ([0, 0, 0, 1], vec![42])).unwrap();
let hash = insert_block(
&backend,
6,
blocks[5],
None,
Default::default(),
vec![UncheckedXt::new_transaction(6.into(), ())],
None,
)
.unwrap();
let hash =
insert_block(&backend, 6, blocks[5], None, Default::default(), vec![6.into()], None)
.unwrap();
blocks.push(hash);
// Pin block 5 so it gets loaded into the cache on prune
@@ -4453,10 +4349,7 @@ pub(crate) mod tests {
op.mark_finalized(blocks[6], None).unwrap();
backend.commit_operation(op).unwrap();
assert_eq!(
Some(vec![UncheckedXt::new_transaction(5.into(), ())]),
bc.body(blocks[5]).unwrap()
);
assert_eq!(Some(vec![5.into()]), bc.body(blocks[5]).unwrap());
assert!(bc.header(blocks[5]).ok().flatten().is_some());
let mut expected = Justifications::from(build_justification(5));
expected.append(([0, 0, 0, 1], vec![42]));
@@ -4478,7 +4371,7 @@ pub(crate) mod tests {
prev_hash,
None,
Default::default(),
vec![UncheckedXt::new_transaction(i.into(), ())],
vec![i.into()],
None,
)
.unwrap();
@@ -4494,26 +4387,16 @@ pub(crate) mod tests {
// Block tree:
// 0 -> 1 -> 2 -> 3 -> 4
// \ -> 2 -> 3
let fork_hash_root = insert_block(
&backend,
2,
blocks[1],
None,
H256::random(),
vec![UncheckedXt::new_transaction(2.into(), ())],
None,
)
.unwrap();
let fork_hash_root =
insert_block(&backend, 2, blocks[1], None, H256::random(), vec![2.into()], None)
.unwrap();
let fork_hash_3 = insert_block(
&backend,
3,
fork_hash_root,
None,
H256::random(),
vec![
UncheckedXt::new_transaction(3.into(), ()),
UncheckedXt::new_transaction(11.into(), ()),
],
vec![3.into(), 11.into()],
None,
)
.unwrap();
@@ -4534,35 +4417,14 @@ pub(crate) mod tests {
}
let bc = backend.blockchain();
assert_eq!(
Some(vec![UncheckedXt::new_transaction(0.into(), ())]),
bc.body(blocks[0]).unwrap()
);
assert_eq!(
Some(vec![UncheckedXt::new_transaction(1.into(), ())]),
bc.body(blocks[1]).unwrap()
);
assert_eq!(
Some(vec![UncheckedXt::new_transaction(2.into(), ())]),
bc.body(blocks[2]).unwrap()
);
assert_eq!(
Some(vec![UncheckedXt::new_transaction(3.into(), ())]),
bc.body(blocks[3]).unwrap()
);
assert_eq!(
Some(vec![UncheckedXt::new_transaction(4.into(), ())]),
bc.body(blocks[4]).unwrap()
);
assert_eq!(Some(vec![0.into()]), bc.body(blocks[0]).unwrap());
assert_eq!(Some(vec![1.into()]), bc.body(blocks[1]).unwrap());
assert_eq!(Some(vec![2.into()]), bc.body(blocks[2]).unwrap());
assert_eq!(Some(vec![3.into()]), bc.body(blocks[3]).unwrap());
assert_eq!(Some(vec![4.into()]), bc.body(blocks[4]).unwrap());
// Check the fork hashes.
assert_eq!(None, bc.body(fork_hash_root).unwrap());
assert_eq!(
Some(vec![
UncheckedXt::new_transaction(3.into(), ()),
UncheckedXt::new_transaction(11.into(), ())
]),
bc.body(fork_hash_3).unwrap()
);
assert_eq!(Some(vec![3.into(), 11.into()]), bc.body(fork_hash_3).unwrap());
// Unpin all blocks, except the forked one.
for block in &blocks {
substrate/client/db/src/utils.rs
+3 -8
View File
@@ -582,19 +582,14 @@ impl<'a, 'b> codec::Input for JoinInput<'a, 'b> {
mod tests {
use super::*;
use codec::Input;
use sp_runtime::{
generic::UncheckedExtrinsic,
testing::{Block as RawBlock, MockCallU64},
};
pub type UncheckedXt = UncheckedExtrinsic<u64, MockCallU64, (), ()>;
type Block = RawBlock<UncheckedXt>;
use sp_runtime::testing::{Block as RawBlock, ExtrinsicWrapper};
type Block = RawBlock<ExtrinsicWrapper<u32>>;
#[cfg(feature = "rocksdb")]
#[test]
fn database_type_subdir_migration() {
use std::path::PathBuf;
type Block = RawBlock<UncheckedXt>;
type Block = RawBlock<ExtrinsicWrapper<u64>>;
fn check_dir_for_db_type(
db_type: DatabaseType,
substrate/client/network-gossip/src/state_machine.rs
+2 -3
View File
@@ -550,8 +550,7 @@ mod tests {
NotificationSenderError, NotificationSenderT as NotificationSender, ReputationChange,
};
use sp_runtime::{
generic::UncheckedExtrinsic,
testing::{Block as RawBlock, MockCallU64, H256},
testing::{Block as RawBlock, ExtrinsicWrapper, H256},
traits::NumberFor,
};
use std::{
@@ -560,7 +559,7 @@ mod tests {
sync::{Arc, Mutex},
};
type Block = RawBlock<UncheckedExtrinsic<u64, MockCallU64, (), ()>>;
type Block = RawBlock<ExtrinsicWrapper<u64>>;
macro_rules! push_msg {
($consensus:expr, $topic:expr, $hash: expr, $m:expr) => {
substrate/client/network/sync/src/blocks.rs
+2 -5
View File
@@ -265,12 +265,9 @@ mod test {
use libp2p::PeerId;
use sc_network_common::sync::message;
use sp_core::H256;
use sp_runtime::{
generic::UncheckedExtrinsic,
testing::{Block as RawBlock, MockCallU64},
};
use sp_runtime::testing::{Block as RawBlock, ExtrinsicWrapper};
type Block = RawBlock<UncheckedExtrinsic<u64, MockCallU64, (), ()>>;
type Block = RawBlock<ExtrinsicWrapper<u64>>;
fn is_empty(bc: &BlockCollection<Block>) -> bool {
bc.blocks.is_empty() && bc.peer_requests.is_empty()
substrate/client/transaction-pool/src/lib.rs
+2 -7
View File
@@ -659,13 +659,8 @@ where
})
.unwrap_or_default()
.into_iter()
// TODO [#2415]: This isn't really what we mean - we really want a
// `tx.is_transaction`, since bare transactions may be gossipped as in the case
// of Frontier txs or claims. This will be sorted once we dispense with the
// concept of bare transactions and make inherents the only possible type of
// extrinsics which are bare. At this point we can change this to
// `tx.is_transaction()`.
.filter(|tx| !tx.is_bare());
.filter(|tx| tx.is_signed().unwrap_or(true));
let mut resubmitted_to_report = 0;
resubmit_transactions.extend(block_transactions.into_iter().filter(|tx| {