feat(weights): RV13 — los 19 estaban subdeclarados, los 19

Primera medicion real de los weights con frame-omni-bencher sobre el
propio blob WASM. El resultado no es un ajuste fino: los 19 extrinsics
de los 5 pallets custom declaraban MENOS de lo que cuestan.

EL PATRON SISTEMATICO. Se costeo el storage del pallet y se olvido el
que cuesta emitir un evento — System::Events, EventCount, ExecutionPhase
y Number son reads y writes reales en cada extrinsic que deposita
evento. Ejemplos medidos: attest_asset declaraba 4 reads / 1 write y
cuesta 7/3; submit_proposal declaraba 12 us y cuesta 62; register_agent_did
declaraba 3/2 y cuesta 6/4.

EL PEOR, Y ES UN ERROR MIO DOCUMENTADO AL REVES. proof_size valia 0 en
los 19. La cabecera de los interinos afirmaba que T::DbWeight "puebla
tanto ref_time como proof_size ... cerrando el hueco". Es falso y se
comprueba en la fuente: sp_weights::RuntimeDbWeight solo tiene los
campos read y write, y reads(r) devuelve from_parts(read * r, 0). Los
interinos arreglaron reads/writes y dejaron el proof_size exactamente
donde estaba. Un proof_size en cero miente al block-builder sobre el
peso PoV: es el vector de DoS que la nota decia haber cerrado. La
afirmacion sobrevivio mas de un mes sin que ninguna lectura la
desmintiera; la desmintio una medicion.

Cada fichero generado lleva ahora un guard GENERADO desde la lista real
de benchmarks que reprueba cualquier proof_size = 0 o ref_time = 0.
Verificado que sabe reprobar: contra los weights anteriores se pone rojo
con "`attest_asset` declara proof_size = 0".

ADVERTENCIA QUE VA EN EL CODIGO, NO SOLO AQUI: son numeros de un
MacBook Pro M3 Max, NO del banco de referencia BM V2. La forma
(reads/writes/proof_size) no depende del hardware y es correcta; el
ref_time si, y en un Pi 5 sera mayor. Un caso lo enseña solo:
attest_asset BAJA de 50 a 44 us, y es el extrinsic dominado por el
verify Ed25519, el mas sensible al silicio. Antes de mainnet hay que
regenerar en el Pi 5 con governor y aislamiento declarados — peticion
abierta a Laurha (request:66f500d54e28a80c) con el blob, el comando y
la version exacta del bencher.

RV12 -> RV13 (weights = consenso). TRANSACTION_VERSION intacto.
295 tests verde.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

crates/origin-chain-agent-identity/src/weights.rs

@@ -1,44 +1,134 @@
-//! # Weights para `pallet-agent-identity`
-//!
-//! ## Estado: INTERIM hand-derived (DB-aware, DoS-safe) — pendiente regeneración HW
-//!
-//! Ver `origin-chain-provenance/src/weights.rs` §Estado para el racional completo.
-//! Números conservadores DB-aware vía `T::DbWeight` (cierran el DoS de proof_size=0
-//! del placeholder); `benchmarking.rs` es la fuente de verdad de la forma.
+// SPDX-License-Identifier: Apache-2.0
+// Origin Chain — Pilar 4 · Charon
+//
+// ATENCION AL LEER ESTOS NUMEROS: un weight es una LATENCIA, y una latencia sin
+// el hardware y el perfil de potencia que la produjeron no se puede reproducir.
+// La cabecera dice HOSTNAME y CPU: creele a eso y a nada mas. Un weight medido
+// en un portatil y cobrado en un Pi 5 es mispricing estructural, solo que
+// invisible. Los numeros CANONICOS de mainnet salen del banco de referencia
+// (Pi 5, governor y aislamiento declarados), no de la maquina de quien compila.
 
+//! Weights AUTOGENERADOS para `origin_chain_agent_identity` — NO editar a mano.
+//!
+//! Regenerar: `scripts/bench/regen-weights.sh` (ver ese script para el
+//! procedimiento completo y el hardware al que hay que creerle).
+//!
+//! GENERADO POR SUBSTRATE BENCHMARK CLI VERSION 51.0.0
+//! FECHA: 2026-09-09, STEPS: `50`, REPEAT: `20`
+//! HOSTNAME: `MacBookProM3Max.local`, CPU: `<UNKNOWN>`
+//! WASM-EXECUTION: `Compiled`, DB CACHE: 1024
+
+// Comando ejecutado:
+// /Users/davidherran/.cargo/bin/frame-omni-bencher
+// v1
+// benchmark
+// pallet
+// --runtime
+// /Users/davidherran/originmetaverse/artifacts/origin-chain/origin_chain_runtime_rv12_bench.compact.compressed.wasm
+// --genesis-builder-preset
+// development
+// --pallet
+// origin_chain_agent_identity
+// --extrinsic
+// 
+// --steps
+// 50
+// --repeat
+// 20
+// --template
+// /Users/davidherran/originmetaverse/external/arkhe-origin-chain/scripts/bench/origin-weights-template.hbs
+// --header
+// /Users/davidherran/originmetaverse/external/arkhe-origin-chain/scripts/bench/HEADER.txt
+// --output
+// /Users/davidherran/originmetaverse/external/arkhe-origin-chain/crates/origin-chain-agent-identity/src/weights.rs
+
+#![cfg_attr(rustfmt, rustfmt_skip)]
 #![allow(unused_parens)]
 #![allow(unused_imports)]
-#![allow(clippy::unnecessary_cast)]
+#![allow(missing_docs)]
 
 use core::marker::PhantomData;
 use frame_support::{traits::Get, weights::constants::RocksDbWeight, weights::Weight};
 
-/// Trait de weights para los extrinsics de `pallet-agent-identity`.
+/// Trait de weights para los extrinsics de `origin_chain_agent_identity`.
 pub trait WeightInfo {
-    /// Peso de `register_agent_did` — 2-3 reads + verify Ed25519 + derive_did + 2 writes.
-    fn register_agent_did() -> Weight;
+	/// Peso de `register_agent_did` — MEDIDO sobre el WASM, no estimado a mano.
+	fn register_agent_did() -> Weight;
 }
 
-/// Weights parametrizados por el `DbWeight` del runtime.
+/// Weights parametrizados por el `DbWeight` real del runtime.
 pub struct SubstrateWeight<T>(PhantomData<T>);
-
 impl<T: frame_system::Config> WeightInfo for SubstrateWeight<T> {
-    fn register_agent_did() -> Weight {
-        // Compute: Ed25519 verify (dominante) + derive_did (BLAKE3) + decode +
-        // build BoundedVec agent_chain. Storage: contains_key(Identities) +
-        // contains_key(DidToAccount) + block_number = 3 reads; insert(Identities)
-        // + insert(DidToAccount) = 2 writes.
-        Weight::from_parts(50_000_000, 0)
-            .saturating_add(T::DbWeight::get().reads(3_u64))
-            .saturating_add(T::DbWeight::get().writes(2_u64))
-    }
+	/// Storage: `AgentIdentity::Identities` (r:1 w:1)
+	/// Proof: `AgentIdentity::Identities` (`max_values`: None, `max_size`: Some(475), added: 2950, mode: `MaxEncodedLen`)
+	/// Storage: `AgentIdentity::DidToAccount` (r:1 w:1)
+	/// Proof: `AgentIdentity::DidToAccount` (`max_values`: None, `max_size`: Some(80), added: 2555, mode: `MaxEncodedLen`)
+	/// Storage: `System::Number` (r:1 w:0)
+	/// Proof: `System::Number` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `System::ExecutionPhase` (r:1 w:0)
+	/// Proof: `System::ExecutionPhase` (`max_values`: Some(1), `max_size`: Some(5), added: 500, mode: `MaxEncodedLen`)
+	/// Storage: `System::EventCount` (r:1 w:1)
+	/// Proof: `System::EventCount` (`max_values`: Some(1), `max_size`: Some(4), added: 499, mode: `MaxEncodedLen`)
+	/// Storage: `System::Events` (r:1 w:1)
+	/// Proof: `System::Events` (`max_values`: Some(1), `max_size`: None, mode: `Measured`)
+	fn register_agent_did() -> Weight {
+		// Proof size en bytes:
+		//  Medido:    `25`
+		//  Estimado:  `3940`
+		// Tiempo minimo de ejecucion: 41_000_000 picosegundos.
+		Weight::from_parts(43_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 3940))
+			.saturating_add(T::DbWeight::get().reads(6_u64))
+			.saturating_add(T::DbWeight::get().writes(4_u64))
+	}
 }
 
-/// Impl no-op para mocks / tests.
+/// Impl para mocks y tests — `RocksDbWeight` directo, sin necesitar `T`.
 impl WeightInfo for () {
-    fn register_agent_did() -> Weight {
-        Weight::from_parts(50_000_000, 0)
-            .saturating_add(RocksDbWeight::get().reads(3_u64))
-            .saturating_add(RocksDbWeight::get().writes(2_u64))
-    }
+	fn register_agent_did() -> Weight {
+		Weight::from_parts(43_000_000, 0)
+			.saturating_add(Weight::from_parts(0, 3940))
+			.saturating_add(RocksDbWeight::get().reads(6_u64))
+			.saturating_add(RocksDbWeight::get().writes(4_u64))
+	}
+}
+
+#[cfg(test)]
+mod guard {
+	use super::*;
+
+	/// NINGUN EXTRINSIC PUEDE DECLARAR `proof_size = 0`.
+	///
+	/// El `proof_size` es lo que el block-builder usa para no pasarse del limite
+	/// de PoV. Un cero no dice «este extrinsic no toca storage»: dice «miento
+	/// sobre lo que va a ocupar la prueba», y con eso entra en un bloque mucho
+	/// mas de lo que cabe.
+	///
+	/// El test nace de un error propio y de la peor clase: la cabecera de los
+	/// weights interinos afirmaba que `T::DbWeight` «puebla tanto ref_time como
+	/// proof_size … cerrando el hueco». Es falso y se comprueba en la fuente —
+	/// `sp_weights::RuntimeDbWeight` solo tiene los campos `read` y `write`, y
+	/// `reads(r)` devuelve `Weight::from_parts(read * r, 0)`. Los interinos
+	/// arreglaron reads/writes y dejaron el proof_size donde estaba: en 0. La
+	/// afirmacion de haberlo cerrado sobrevivio mas de un mes sin que ninguna
+	/// lectura la desmintiera; la desmintio una medicion.
+	///
+	/// Esta lista la GENERA la plantilla a partir de los benchmarks reales, asi
+	/// que no puede quedarse corta cuando se anada un extrinsic nuevo.
+	#[test]
+	fn ningun_weight_declara_proof_size_cero() {
+		let casos: &[(&str, Weight)] = &[
+			("register_agent_did", <() as WeightInfo>::register_agent_did()),
+		];
+		for (nombre, w) in casos {
+			assert!(
+				w.proof_size() > 0,
+				"`{nombre}` declara proof_size = 0: miente al block-builder sobre el peso PoV"
+			);
+			assert!(
+				w.ref_time() > 0,
+				"`{nombre}` declara ref_time = 0: el extrinsic saldria gratis"
+			);
+		}
+	}
 }