Struct PurgeContractsChildTries

pub struct PurgeContractsChildTries<T, P, W>(/* private fields */);

Purges the child tries owned by the decommissioned pallet-contracts, and hands back the consumer references it took on contract accounts.

pallet-contracts keeps the storage of every instantiated contract in a child trie addressed by that contract’s trie_id, and holds only a pointer to it in its own (top level) storage. Wiping the pallet prefix therefore does not free the bulk of the data, it merely orphans it: the trie_ids needed to address those child tries would be gone for good.

This migration walks the two places where trie_ids are recorded and empties the corresponding child tries before dropping the top level entry pointing at them:

• Contracts::DeletionQueue - tries of already terminated contracts, awaiting lazy deletion.
• Contracts::ContractInfoOf - tries of contracts that are still alive.

It MUST be scheduled before RemovePalletStepped for the same pallet, otherwise the trie_ids are deleted first and the child tries become unreachable forever.

Consumer references

pallet-contracts calls inc_consumers on the contract account at instantiation and only gives that reference back from seal_terminate. ContractInfoOf is the last on-chain record of which accounts are contracts, so purging it is the final opportunity to hand the reference back - leave it and every live contract account keeps a dangling consumer forever, and can never be reaped even once its balance is gone. DeletionQueue entries are terminated contracts, which already gave theirs back, hence the distinction below.

Storage layout coupling

Values are decoded structurally rather than via pallet-contracts types, since the pallet is no longer a dependency of the runtimes. Verified against polkadot-sdk stable2512:

• DeletionQueue: StorageMap<_, Twox64Concat, u32, TrieId> - the value is a TrieId.
• ContractInfoOf: StorageMap<_, Twox64Concat, AccountId, ContractInfo<T>>, and ContractInfo’s first field is pub trie_id: TrieId, so it decodes off the front.

A TrieId is a length prefixed byte blob; decoding it as a TrieId (rather than a plain Vec<u8>) makes a garbage value fail loudly instead of producing a bogus multi kilobyte id.

Trait Implementations

impl<T, P, W> SteppedMigration for PurgeContractsChildTries<T, P, W>

where T: Config, P: Get<&'static str>, W: WeightInfo,

type Cursor = ()

Progress lives in storage itself: every step restarts from the first remaining entry, and an entry is only dropped once its child trie has been fully emptied. Restarting is cheap because the number of contracts is small - the child tries themselves, which are not, are walked with a local cursor.

type Identifier = [u8; 32]

Derived from the pallet name so that two instances never collide.

fn id() -> Self::Identifier

The unique identifier of this migration.

fn step( cursor: Option<Self::Cursor>, meter: &mut WeightMeter, ) -> Result<Option<Self::Cursor>, SteppedMigrationError>

Try to migrate as much as possible with the given weight.

fn max_steps() -> Option<u32>

The maximum number of steps that this migration can take.

fn transactional_step( cursor: Option<Self::Cursor>, meter: &mut WeightMeter, ) -> Result<Option<Self::Cursor>, SteppedMigrationError>

Same as [Self::step], but rolls back pending changes in the error case.