feat(node): Origin Chain produce su primer bloque — el bloqueo arquitectural era un diagnostico falso

El node nunca habia producido un bloque: service.rs y rpc.rs estaban fuera del
build desde v0.0.49 por un «bloqueo arquitectural» que afirmaba que las crates
publicadas sc-consensus-aura 0.52.0 y sp-consensus-aura 0.45.0 no tenian
standalone::slot_duration_at ni from_timestamp_and_slot_duration. Las dos estan
ahi, en crates.io. La nota guio la decision durante meses.

Causa real, medida con cargo check (362 errores) y cargo tree: el workspace
mezclaba dos releases de polkadot-sdk. Las sc-* del cliente arrastraban
sp-runtime 43 y las frame-* del runtime sp-runtime 44: 36 crates del nucleo
duplicadas y errores de la forma «Block no satisface Block». Cura: alinear diez
versiones del Cargo.toml (sc-cli 0.55, sc-service 0.54, sc-network 0.53,
sc-consensus 0.52, sc-consensus-aura 0.53, sc-consensus-grandpa 0.38,
sc-offchain 48, sp-blockchain 42, substrate-frame-rpc-system 47,
sc-telemetry 30.0.1). El lock solo PIERDE la generacion vieja (1210 -> 1123
entradas); ninguna crate que use el runtime cambia de version.

rpc.rs: el client pasa a ser el FullClient concreto. Nuestro node trabaja sobre
el Block completo del runtime, que lleva dentro ChainAccountId, una proyeccion
(<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId) que rustc
no normaliza dentro de un where-clause generico: 6 errores de «un bound
declarado en la firma no se satisface». Con el generico fallaba, con el
concreto compila.

main.rs: subcomando run (sc_cli::RunCmd), que arranca new_full con litep2p o
libp2p. chain_spec.rs: node_chain_spec construye un GenericChainSpec con el
WASM real del runtime (build-spec sigue con su JSON). run --chain mainnet se
RECHAZA: sus validadores son placeholder sin llave (gate L-3) y un node con ese
genesis no produciria nunca, en silencio. Test con contrafactual: sin el brazo
mainnet el id cae en la rama de ruta y falla como «fichero no encontrado»; el
test exige la razon, y en rojo lo dijo asi.

Medido (build con --features wasm-build, run --dev --tmp):
- bloque #1 importado 2026-09-23 20:04:30, uno cada ~6 s (Aura);
- GRANDPA finaliza: #7 finalizado con best #9 a los 60 s;
- RPC: chain_getHeader, chain_getFinalizedHead, system_accountNextIndex
  (Alice = 0) y system_properties (OGC, 18 decimales, ss58 42) responden;
- «Essential task txpool-background failed» aparece SOLO al SIGINT
  (0 ocurrencias a los 50 s con RPC servido; 1 al segundo del SIGINT).
- cargo test --workspace: 318 passed, 0 failed (igual que RV14) + 1 nuevo.

macOS 27: el build necesita DEVELOPER_DIR=/Library/Developer/CommandLineTools
mientras la licencia de Xcode 27 no este aceptada (exit 69 en cc y git).

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

Cargo.toml

@@ -74,7 +74,7 @@ sp-consensus-aura = { version = "0.45.0", default-features = false, features = [
 sp-consensus-grandpa = { version = "26.0.0", default-features = false, features = ["serde"] }
 # Slice 4 v0.0.49 — node sc-service deps (stable2509-3)
 sp-timestamp = { version = "39.0.0", default-features = false }
-sp-blockchain = { version = "41.0.0" }
+sp-blockchain = { version = "42.0.0" }
 
 # FRAME canonical — runtime composition framework (stable2509-3)
 frame-system = { version = "43.0.1", default-features = false }
@@ -154,25 +154,25 @@ serde_json = { version = "1", default-features = false, features = ["alloc"] }
 substrate-wasm-builder = { version = "29.0.0" }
 
 # Substrate client canonical (Phase 1.6+ node binary service builder, stable2509-3)
-sc-cli = { version = "0.54.0" }
+sc-cli = { version = "0.55.0" }
-sc-service = { version = "0.53.0" }
+sc-service = { version = "0.54.0" }
 # Slice 3 (v0.0.13) canonical — `sc_chain_spec::GenericChainSpec` builder canonical
 # para Phase 1.6+ ChainSpec serialization. Pattern canonical mock-WASM fallback.
 sc-executor = { version = "0.45.0" }
-sc-network = { version = "0.52.0" }
+sc-network = { version = "0.53.0" }
-sc-consensus = { version = "0.51.0" }
+sc-consensus = { version = "0.52.0" }
-sc-consensus-aura = { version = "0.52.0" }
+sc-consensus-aura = { version = "0.53.0" }
-sc-consensus-grandpa = { version = "0.37.0" }
+sc-consensus-grandpa = { version = "0.38.0" }
 sc-transaction-pool = { version = "42.0.0" }
 sc-transaction-pool-api = { version = "42.0.0" }
 sc-client-api = { version = "42.0.0" }
 sc-basic-authorship = { version = "0.52.0" }
-sc-telemetry = { version = "31.0.0" }
+sc-telemetry = { version = "30.0.1" }
-sc-offchain = { version = "47.0.0" }
+sc-offchain = { version = "48.0.0" }
 
 # RPC server canonical (jsonrpsee, stable2509-3)
 jsonrpsee = { version = "0.24.9", features = ["server"] }
-substrate-frame-rpc-system = { version = "46.0.0" }
+substrate-frame-rpc-system = { version = "47.0.0" }
 pallet-transaction-payment-rpc = { version = "46.0.0" }
 
 # CLI + async canonical

crates/origin-chain-node/src/chain_spec.rs

@@ -181,13 +181,71 @@ pub fn load_spec(name: &str) -> Result<Value, String> {
     }
 }
 
+/// El chain spec del node: sin extensiones (sin relay chain ni fork blocks).
+type NodeChainSpec = sc_service::GenericChainSpec;
+
+/// ChainSpec REAL para `origin-chain-node run`: el WASM verdadero del runtime y el
+/// genesis de sus presets, construido con `sc_service::GenericChainSpec`.
+///
+/// Es distinto de [`load_spec`], que sigue sirviendo a `build-spec` con el JSON
+/// armado a mano y `code: "0x"`. Con ese `code` vacío ningún node puede ejecutar
+/// el bloque génesis; con éste sí.
+///
+/// Acepta `dev` / `local` o la RUTA a un chain spec JSON. `mainnet` se rechaza a
+/// propósito: sus validadores son llaves placeholder `CA FE 00…04…` que nadie posee
+/// (gate L-3 de `docs/ORIGIN_CHAIN_LISTA_PARA_LANZAR_V1.md` del monorepo) — un node
+/// arrancado con ese génesis no produciría un bloque jamás, y lo haría en silencio.
+pub fn node_chain_spec(id: &str) -> Result<Box<dyn sc_service::ChainSpec>, String> {
+    let (name, chain_id, chain_type, preset) = match id {
+        "" | "dev" | "development" => (
+            "Origin Chain Development",
+            CHAIN_ID_DEVELOPMENT,
+            sc_service::ChainType::Development,
+            genesis_config_presets::PRESET_DEVELOPMENT,
+        ),
+        "local" | "local_testnet" => (
+            "Origin Chain Local Testnet",
+            CHAIN_ID_LOCAL_TESTNET,
+            sc_service::ChainType::Local,
+            genesis_config_presets::PRESET_LOCAL_TESTNET,
+        ),
+        "mainnet" | "mainnet_genesis" => {
+            return Err(
+                "el génesis de mainnet aún tiene validadores placeholder sin llave \
+                        (gate L-3): no se arranca un node con él. Genera el chain spec \
+                        con las llaves reales y pásalo como ruta a --chain."
+                    .into(),
+            )
+        }
+        path => {
+            return NodeChainSpec::from_json_file(path.into())
+                .map(|spec| Box::new(spec) as Box<dyn sc_service::ChainSpec>)
+        }
+    };
+    let wasm = origin_chain_runtime::WASM_BINARY.ok_or_else(|| {
+        "este binario se compiló sin el WASM del runtime: \
+         cargo build -p origin-chain-node --features wasm-build"
+            .to_string()
+    })?;
+    let properties = chain_properties().as_object().cloned().unwrap_or_default();
+    Ok(Box::new(
+        NodeChainSpec::builder(wasm, None)
+            .with_name(name)
+            .with_id(chain_id)
+            .with_chain_type(chain_type)
+            .with_protocol_id(PROTOCOL_ID)
+            .with_properties(properties)
+            .with_genesis_config_preset_name(preset)
+            .build(),
+    ))
+}
+
 /// Serialize chain spec canonical a JSON string canonical (pretty o raw canonical).
 pub fn serialize_chain_spec(spec: &Value, raw: bool) -> Result<String, String> {
     if raw {
         serde_json::to_string(spec).map_err(|e| format!("JSON serialization canonical: {e}"))
     } else {
-        serde_json::to_string_pretty(spec)
+        serde_json::to_string_pretty(spec).map_err(|e| format!("JSON serialization canonical: {e}"))
-            .map_err(|e| format!("JSON serialization canonical: {e}"))
     }
 }
 
@@ -195,6 +253,21 @@ pub fn serialize_chain_spec(spec: &Value, raw: bool) -> Result<String, String> {
 mod tests {
     use super::*;
 
+    /// `run --chain mainnet` se rechaza POR EL GÉNESIS, no por casualidad. Sin el
+    /// brazo `mainnet`, el id caería en la rama de ruta y también fallaría — como
+    /// «fichero no encontrado». Por eso el test exige la razón (gate L-3) y no sólo
+    /// el error: sin ella pasaría con y sin la salvaguarda.
+    #[test]
+    fn run_rechaza_el_genesis_de_mainnet_con_validadores_placeholder() {
+        for id in ["mainnet", "mainnet_genesis"] {
+            let err = node_chain_spec(id).err().expect("mainnet debe rechazarse");
+            assert!(
+                err.contains("gate L-3"),
+                "{id}: rechazado por otra razón: {err}"
+            );
+        }
+    }
+
     #[test]
     fn development_chain_spec_builds_canonical() {
         let spec = development_chain_spec().expect("development chain spec canonical");

crates/origin-chain-node/src/main.rs

@@ -35,31 +35,27 @@
 //! posibles canonical están a la vista canonical, BM V2 incluida canonical.
 
 mod chain_spec;
-// Slice 4 Paso 4c (v0.0.49): módulos sc-service `service.rs` + `rpc.rs` escritos
+mod rpc;
-// pero NO compilados aún — ver bloqueo arquitectural documentado abajo.
+mod service;
+// Slice 4 Paso 4c: `service.rs` + `rpc.rs` compilan y `run` arranca el node.
 //
-// BLOQUEO (hallazgo v0.0.49): las crates sc-*/sp- consensus PUBLICADAS en
+// El «bloqueo arquitectural» que los tuvo fuera del build desde v0.0.49 era un
-// crates.io (sc-consensus-aura 0.52.0 + sp-consensus-aura 0.45.0) tienen una API
+// diagnóstico FALSO (Charon, medido el 2026-09-23). Decía que las crates publicadas
-// DISTINTA al git tag polkadot-stable2509-3 bajo el MISMO número de versión.
+// `sc-consensus-aura 0.52.0` y `sp-consensus-aura 0.45.0` no tenían
-// El tag usa `sc_consensus_aura::standalone::slot_duration_at` +
+// `standalone::slot_duration_at` ni `from_timestamp_and_slot_duration` y que había que
-// `sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration`;
+// migrar todo a git. Las dos funciones están ahí, en crates.io. La causa real era que
-// las publicadas tienen `slot_duration_at` en root y NO tienen un slot
+// el workspace mezclaba dos releases de polkadot-sdk: las `sc-*` del cliente en
-// `InherentDataProvider` (Slot no implementa el trait). polkadot-sdk reusa
+// `sp-runtime 43` y las `frame-*` del runtime en `sp-runtime 44` — 36 crates del
-// números de versión con cambios git no publicados.
+// núcleo duplicadas, y errores de la forma «`Block` no satisface `Block»` (el mismo
+// tipo en dos copias). La cura fue alinear diez versiones del `Cargo.toml`; el runtime
+// no se tocó. Detalle en `docs/ORIGIN_CHAIN_LISTA_PARA_LANZAR_V1.md` del monorepo.
 //
-// Construir un node service real requiere migrar TODO el stack sc-*/sp- consensus
+// En macOS 27 el linker necesita `SDKROOT` apuntando al SDK 26.x de Xcode: el SDK de
-// a git sources del tag stable2509-3 — la misma cirugía de duplicate-crate que
+// las Command Line Tools declara la arquitectura `arm64e.x1`, que ld no reconoce.
-// golpeó pallet-revive (Ship 2 v0.0.39). Es una decisión arquitectural para David.
-// Ver docs/SLICE_4_SC_SERVICE_IMPLEMENTATION_PLAN_V1.md §10 (finding) para opciones.
-//
-// `service.rs`/`rpc.rs` se conservan como archivos (no `mod`-declarados) para la
-// siguiente fase. El core2 yanked unblock (Cargo.toml + vendor/) SÍ quedó resuelto
-// — era el blocker real de resolución que difirió sc-service 3 sesiones.
 
 use clap::{Parser, Subcommand};
-use origin_chain_runtime::{
+use origin_chain_runtime::{genesis_config_presets, Block, IMPL_NAME, RUNTIME_VERSION, SPEC_NAME};
-    genesis_config_presets, IMPL_NAME, RUNTIME_VERSION, SPEC_NAME,
+use sc_cli::SubstrateCli;
-};
 use sp_genesis_builder::PresetId;
 
 /// Canonical CLI structure para `origin-chain-node` binary canonical.
@@ -108,6 +104,44 @@ enum Command {
         #[arg(long)]
         raw: bool,
     },
+    /// Arranca el node: produce bloques (Aura), los finaliza (GRANDPA) y sirve RPC.
+    ///
+    /// `origin-chain-node run --dev` levanta una cadena de un solo validador (Alice)
+    /// con estado temporal. Requiere un binario compilado con `--features wasm-build`.
+    Run(Box<sc_cli::RunCmd>),
+}
+
+/// El node visto por `sc-cli`: nombre, versión y de dónde sale cada chain spec.
+struct NodeCli;
+
+impl SubstrateCli for NodeCli {
+    fn impl_name() -> String {
+        IMPL_NAME.into()
+    }
+
+    fn impl_version() -> String {
+        env!("CARGO_PKG_VERSION").into()
+    }
+
+    fn description() -> String {
+        "Origin Chain — Pilar 4 de Origin Metaverse".into()
+    }
+
+    fn author() -> String {
+        env!("CARGO_PKG_AUTHORS").into()
+    }
+
+    fn support_url() -> String {
+        "https://git.originmetaverse.com/davidherran/arkhe-origin-chain".into()
+    }
+
+    fn copyright_start_year() -> i32 {
+        2026
+    }
+
+    fn load_spec(&self, id: &str) -> Result<Box<dyn sc_service::ChainSpec>, String> {
+        chain_spec::node_chain_spec(id)
+    }
 }
 
 fn main() {
@@ -118,9 +152,33 @@ fn main() {
         Some(Command::PrintPreset { id }) => print_preset(&id),
         Some(Command::Info) => print_info(),
         Some(Command::BuildSpec { chain, raw }) => build_spec(&chain, raw),
+        Some(Command::Run(cmd)) => {
+            if let Err(e) = run_node(&cmd) {
+                eprintln!("❌ {e}");
+                std::process::exit(1);
+            }
+        }
     }
 }
 
+/// Arranca el node con el backend de red que pida la configuración (litep2p por
+/// defecto en esta release, libp2p con `--network-backend libp2p`).
+fn run_node(cmd: &sc_cli::RunCmd) -> sc_cli::Result<()> {
+    let runner = NodeCli.create_runner(cmd)?;
+    runner.run_node_until_exit(|config| async move {
+        match config.network.network_backend {
+            sc_network::config::NetworkBackendType::Libp2p => service::new_full::<
+                sc_network::NetworkWorker<Block, <Block as sp_runtime::traits::Block>::Hash>,
+            >(config)
+            .map_err(sc_cli::Error::Service),
+            sc_network::config::NetworkBackendType::Litep2p => {
+                service::new_full::<sc_network::Litep2pNetworkBackend>(config)
+                    .map_err(sc_cli::Error::Service)
+            }
+        }
+    })
+}
+
 fn print_version() {
     println!(
         "{} v{} — {} canonical",

crates/origin-chain-node/src/rpc.rs

@@ -6,34 +6,36 @@
 use std::sync::Arc;
 
 use jsonrpsee::RpcModule;
-use origin_chain_runtime::{AccountId, Balance, Block, Nonce};
 use sc_transaction_pool_api::TransactionPool;
-use sp_api::ProvideRuntimeApi;
+
-use sp_block_builder::BlockBuilder;
+use crate::service::FullClient;
-use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata};
+
+// El client es CONCRETO (`FullClient`), no un `C` genérico como en el template.
+//
+// El template puede ser genérico porque su node trabaja sobre `opaque::Block`, que no
+// menciona la cuenta. El nuestro trabaja sobre el `Block` completo del runtime (sobre
+// él están los `impl_runtime_apis!`), y ese tipo lleva dentro `ChainAccountId`, que es
+// una PROYECCIÓN: `<<MultiSignature as Verify>::Signer as IdentifyAccount>::AccountId`.
+// Dentro de un where-clause genérico rustc no la normaliza a `AccountId32`: el bound
+// `C: ProvideRuntimeApi<Block>` queda escrito con una forma del tipo y `System` lo
+// pide con la otra, y el compilador informa de que un bound declarado en la propia
+// firma «no se satisface» (6 errores, medido el 2026-09-23). Con el tipo concreto no
+// hay nada que normalizar en el param-env y los bounds se comprueban sobre el client
+// real — que es además el único que este node construye.
 
 /// Dependencias completas para construir los RPC del node.
-pub struct FullDeps<C, P> {
+pub struct FullDeps<P> {
     /// El client del node.
-    pub client: Arc<C>,
+    pub client: Arc<FullClient>,
     /// El transaction pool del node.
     pub pool: Arc<P>,
 }
 
 /// Instancia los RPC handlers completos (System + TransactionPayment).
-pub fn create_full<C, P>(
+pub fn create_full<P>(
-    deps: FullDeps<C, P>,
+    deps: FullDeps<P>,
 ) -> Result<RpcModule<()>, Box<dyn std::error::Error + Send + Sync>>
 where
-    C: ProvideRuntimeApi<Block>
-        + HeaderBackend<Block>
-        + HeaderMetadata<Block, Error = BlockChainError>
-        + Send
-        + Sync
-        + 'static,
-    C::Api: substrate_frame_rpc_system::AccountNonceApi<Block, AccountId, Nonce>
-        + pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi<Block, Balance>
-        + BlockBuilder<Block>,
     P: TransactionPool + 'static,
 {
     use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer};

crates/origin-chain-node/src/service.rs

@@ -66,7 +66,9 @@ pub fn new_partial(config: &Configuration) -> Result<Service, ServiceError> {
     let client = Arc::new(client);
 
     let telemetry = telemetry.map(|(worker, telemetry)| {
-        task_manager.spawn_handle().spawn("telemetry", None, worker.run());
+        task_manager
+            .spawn_handle()
+            .spawn("telemetry", None, worker.run());
         telemetry
     });
 
@@ -92,8 +94,8 @@ pub fn new_partial(config: &Configuration) -> Result<Service, ServiceError> {
     )?;
 
     let cidp_client = client.clone();
-    let import_queue =
+    let import_queue = sc_consensus_aura::import_queue::<AuraPair, _, _, _, _, _>(
-        sc_consensus_aura::import_queue::<AuraPair, _, _, _, _, _>(ImportQueueParams {
+        ImportQueueParams {
             block_import: grandpa_block_import.clone(),
             justification_import: Some(Box::new(grandpa_block_import.clone())),
             client: client.clone(),
@@ -120,7 +122,8 @@ pub fn new_partial(config: &Configuration) -> Result<Service, ServiceError> {
             check_for_equivocation: Default::default(),
             telemetry: telemetry.as_ref().map(|x| x.handle()),
             compatibility_mode: Default::default(),
-        })?;
+        },
+    )?;
 
     Ok(sc_service::PartialComponents {
         client,
@@ -160,7 +163,11 @@ pub fn new_full<
 
     let peer_store_handle = net_config.peer_store_handle();
     let grandpa_protocol_name = sc_consensus_grandpa::protocol_standard_name(
-        &client.block_hash(0).ok().flatten().expect("Genesis block exists; qed"),
+        &client
+            .block_hash(0)
+            .ok()
+            .flatten()
+            .expect("Genesis block exists; qed"),
         &config.chain_spec,
     );
     let (grandpa_protocol_config, grandpa_notification_service) =
@@ -208,7 +215,9 @@ pub fn new_full<
         task_manager.spawn_handle().spawn(
             "offchain-workers-runner",
             "offchain-worker",
-            offchain_workers.run(client.clone(), task_manager.spawn_handle()).boxed(),
+            offchain_workers
+                .run(client.clone(), task_manager.spawn_handle())
+                .boxed(),
         );
     }
 
@@ -224,7 +233,10 @@ pub fn new_full<
         let pool = transaction_pool.clone();
 
         Box::new(move |_| {
-            let deps = crate::rpc::FullDeps { client: client.clone(), pool: pool.clone() };
+            let deps = crate::rpc::FullDeps {
+                client: client.clone(),
+                pool: pool.clone(),
+            };
             crate::rpc::create_full(deps).map_err(Into::into)
         })
     };
@@ -293,7 +305,11 @@ pub fn new_full<
 
     if enable_grandpa {
         // Si el node no participa activamente en consensus, no necesita keystore.
-        let keystore = if role.is_authority() { Some(keystore_container.keystore()) } else { None };
+        let keystore = if role.is_authority() {
+            Some(keystore_container.keystore())
+        } else {
+            None
+        };
 
         let grandpa_config = sc_consensus_grandpa::Config {
             gossip_duration: Duration::from_millis(333),