Update llms.txt

Author: 0xLucca

llms.txt

@@ -3959,7 +3959,29 @@ To add a GitHub workflow for building the runtime:
     ??? interface "`basic.yml`"
 
         ```yml
-        Error fetching snippet from https://raw.githubusercontent.com/chevdor/srtool-actions/refs/heads/master/examples/01_basic.yml
+        name: Srtool build
+
+on: push
+
+jobs:
+  srtool:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        chain: ["asset-hub-kusama", "asset-hub-westend"]
+    steps:
+      - uses: actions/checkout@v3
+      - name: Srtool build
+        id: srtool_build
+        uses: chevdor/[email protected]
+        with:
+          chain: ${{ matrix.chain }}
+          runtime_dir: polkadot-parachains/${{ matrix.chain }}-runtime
+      - name: Summary
+        run: |
+          echo '${{ steps.srtool_build.outputs.json }}' | jq . > ${{ matrix.chain }}-srtool-digest.json
+          cat ${{ matrix.chain }}-srtool-digest.json
+          echo "Runtime location: ${{ steps.srtool_build.outputs.wasm }}"
         ```
 
 4. Modify the settings in the sample action
@@ -5555,7 +5577,111 @@ pub struct CurrentAndPreviousValue {
 
 - Migration:
 ```rust
-Error fetching snippet from https://raw.githubusercontent.com/paritytech/polkadot-sdk/refs/tags/polkadot-stable2409-1/substrate/frame/examples/single-block-migrations/src/migrations/v1.rs
+use frame_support::{
+	storage_alias,
+	traits::{Get, UncheckedOnRuntimeUpgrade},
+};
+
+#[cfg(feature = "try-runtime")]
+use alloc::vec::Vec;
+
+/// Collection of storage item formats from the previous storage version.
+///
+/// Required so we can read values in the v0 storage format during the migration.
+mod v0 {
+	use super::*;
+
+	/// V0 type for [`crate::Value`].
+	#[storage_alias]
+	pub type Value<T: crate::Config> = StorageValue<crate::Pallet<T>, u32>;
+}
+
+/// Implements [`UncheckedOnRuntimeUpgrade`], migrating the state of this pallet from V0 to V1.
+///
+/// In V0 of the template [`crate::Value`] is just a `u32`. In V1, it has been upgraded to
+/// contain the struct [`crate::CurrentAndPreviousValue`].
+///
+/// In this migration, update the on-chain storage for the pallet to reflect the new storage
+/// layout.
+pub struct InnerMigrateV0ToV1<T: crate::Config>(core::marker::PhantomData<T>);
+
+impl<T: crate::Config> UncheckedOnRuntimeUpgrade for InnerMigrateV0ToV1<T> {
+	/// Return the existing [`crate::Value`] so we can check that it was correctly set in
+	/// `InnerMigrateV0ToV1::post_upgrade`.
+	#[cfg(feature = "try-runtime")]
+	fn pre_upgrade() -> Result<Vec<u8>, sp_runtime::TryRuntimeError> {
+		use codec::Encode;
+
+		// Access the old value using the `storage_alias` type
+		let old_value = v0::Value::<T>::get();
+		// Return it as an encoded `Vec<u8>`
+		Ok(old_value.encode())
+	}
+
+	/// Migrate the storage from V0 to V1.
+	///
+	/// - If the value doesn't exist, there is nothing to do.
+	/// - If the value exists, it is read and then written back to storage inside a
+	/// [`crate::CurrentAndPreviousValue`].
+	fn on_runtime_upgrade() -> frame_support::weights::Weight {
+		// Read the old value from storage
+		if let Some(old_value) = v0::Value::<T>::take() {
+			// Write the new value to storage
+			let new = crate::CurrentAndPreviousValue { current: old_value, previous: None };
+			crate::Value::<T>::put(new);
+			// One read + write for taking the old value, and one write for setting the new value
+			T::DbWeight::get().reads_writes(1, 2)
+		} else {
+			// No writes since there was no old value, just one read for checking
+			T::DbWeight::get().reads(1)
+		}
+	}
+
+	/// Verifies the storage was migrated correctly.
+	///
+	/// - If there was no old value, the new value should not be set.
+	/// - If there was an old value, the new value should be a [`crate::CurrentAndPreviousValue`].
+	#[cfg(feature = "try-runtime")]
+	fn post_upgrade(state: Vec<u8>) -> Result<(), sp_runtime::TryRuntimeError> {
+		use codec::Decode;
+		use frame_support::ensure;
+
+		let maybe_old_value = Option::<u32>::decode(&mut &state[..]).map_err(|_| {
+			sp_runtime::TryRuntimeError::Other("Failed to decode old value from storage")
+		})?;
+
+		match maybe_old_value {
+			Some(old_value) => {
+				let expected_new_value =
+					crate::CurrentAndPreviousValue { current: old_value, previous: None };
+				let actual_new_value = crate::Value::<T>::get();
+
+				ensure!(actual_new_value.is_some(), "New value not set");
+				ensure!(
+					actual_new_value == Some(expected_new_value),
+					"New value not set correctly"
+				);
+			},
+			None => {
+				ensure!(crate::Value::<T>::get().is_none(), "New value unexpectedly set");
+			},
+		};
+		Ok(())
+	}
+}
+
+/// [`UncheckedOnRuntimeUpgrade`] implementation [`InnerMigrateV0ToV1`] wrapped in a
+/// [`VersionedMigration`](frame_support::migrations::VersionedMigration), which ensures that:
+/// - The migration only runs once when the on-chain storage version is 0
+/// - The on-chain storage version is updated to `1` after the migration executes
+/// - Reads/Writes from checking/settings the on-chain storage version are accounted for
+pub type MigrateV0ToV1<T> = frame_support::migrations::VersionedMigration<
+	0, // The migration will only execute when the on-chain storage version is 0
+	1, // The on-chain storage version will be set to 1 after the migration is complete
+	InnerMigrateV0ToV1<T>,
+	crate::pallet::Pallet<T>,
+	<T as frame_system::Config>::DbWeight,
+>;
 ```
 
 ### Migration Organization