feat(emission): FIX-6 Stage 1 — emision que paga validadores (V2-CA2) + remover APR falso

Build + tests verde: emission pallet 5 + runtime 28 (incl. emission_pallet_index_13)
+ staking contract 4. Verificacion adversarial ultracode (2 skeptics): correctitud
+ seguridad CONFIRMADAS (split exacto, sin overflow, autor solo-desde-Aura sin
input de usuario, mint-None-seguro, sin dispatchable explotable, APR removal
honesto). 'partial' solo por cobertura de tests en ramas triviales (None /
reward==0), NO por vulnerabilidad.

Cierra V2-CA2 (la cadena no tenia emision -> los validadores ganaban 0 OGC):

NUEVO pallet origin-chain-emission (Index 13):
- on_initialize cada bloque: identifica al autor Aura (FindAuthor =
  pallet_session::FindAccountFromAuthorIndex<Runtime, Aura>), mintea un
  BlockReward (10 OGC, ~5.26% inflacion anual) y lo reparte:
  - 70% al autor (el validador que produjo el bloque).
  - 20% al treasury (og/gvtry — la MISMA cuenta-vault de governance FIX-6).
  - 10% al subsidy pool (og/subsy — proof-of-equity que financia el subsidio
    de hardware anti-clasista #16).
- El residual del split va al subsidy (no pierde unidades por redondeo de bps).
- TotalEmitted trackea la inflacion acumulada on-chain. mint_into (fungible::
  Mutate) = emision real (aumenta total issuance).
- El autor viene SOLO de FindAuthor/Aura (no de input de usuario) -> nadie puede
  mintear a una cuenta arbitraria. Si FindAuthor devuelve None, no mintea. Sin
  overflow (saturating_mul/div, 10^19 << u128::MAX).

sub_mult ORTOGONAL (David 2026-06-10): el subsidy pool financia el subsidio de
hardware SIN importar la suscripcion premium. Esta emision lo alimenta; el
OnChargeTransaction de Stage 2 lo consumira.

Remover APR falso (V1/V2 fake APR): staking contract default_chn3 reward rates
8/5/3% -> 0. Era enganoso (no habia motor que los pagara; los campos
reward_rate_bps se almacenaban pero NUNCA se leian, rewards_accumulated jamas se
acreditaba). Los validadores ahora cobran via la emision real; las tasas de
staking reales las define Stage 2 (NPoS por stake).

FIX-6 Stage 1 COMPLETO (con v0.0.56 treasury real): emision + treasury real +
APR removido. Stage 2: NPoS (pallet_staking + EraPayout) + fee unificado
(OnChargeTransaction con sub_mult ortogonal).

FOLLOW-UPS (low, documentados): anadir tests de cobertura para las ramas
FindAuthor==None (no mintea) y reward==0 (requieren un 2o mock runtime);
BlockReward fijo (decay schedule = Stage 2); el subsidy pool acumula pero no se
consume hasta el OnChargeTransaction de Stage 2; genesis mainnet del treasury
vault (pre-launch).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

crates/origin-chain-emission/Cargo.toml

@@ -0,0 +1,47 @@
+[package]
+name = "origin-chain-emission"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+authors.workspace = true
+repository.workspace = true
+homepage.workspace = true
+description = "Origin Chain emission pallet — FIX-6 Stage 1 (audit V2-CA2). Mintea un block reward por bloque y lo reparte autor (validador Aura) + treasury + subsidy pool (proof-of-equity, Inmutable #16 anti-clasista). Cierra 'los validadores ganan 0 OGC'."
+
+[dependencies]
+# FRAME canonical
+frame-support = { workspace = true }
+frame-system = { workspace = true }
+
+# Substrate primitives canonical (AccountIdConversion para PalletId)
+sp-runtime = { workspace = true }
+
+# SCALE codec canonical
+parity-scale-codec = { workspace = true }
+scale-info = { workspace = true }
+
+[dev-dependencies]
+# Mock runtime canonical — pallet_balances para testear el minteo real.
+pallet-balances = { workspace = true, default-features = true }
+sp-core = { workspace = true, default-features = true }
+sp-io = { workspace = true, default-features = true }
+sp-runtime = { workspace = true, default-features = true }
+
+[features]
+default = ["std"]
+std = [
+    "frame-support/std",
+    "frame-system/std",
+    "sp-runtime/std",
+    "parity-scale-codec/std",
+    "scale-info/std",
+]
+runtime-benchmarks = [
+    "frame-support/runtime-benchmarks",
+    "frame-system/runtime-benchmarks",
+]
+try-runtime = [
+    "frame-support/try-runtime",
+    "frame-system/try-runtime",
+]

crates/origin-chain-emission/src/lib.rs

@@ -0,0 +1,282 @@
+//! # pallet-origin-emission — FIX-6 Stage 1: emisión que paga a los validadores
+//!
+//! Cierra el crítico V2-CA2 del audit: la cadena NO tenía emisión (Aura PoA
+//! mintea 0), así que los validadores ganaban **0 OGC**. Ahora, en cada bloque,
+//! se mintea un `BlockReward` y se reparte:
+//!
+//! - **Autor** (el validador Aura que produjo el bloque) — el grueso.
+//! - **Treasury** (la cuenta-tesorería de governance, og/gvtry) — financia DAO.
+//! - **Subsidy pool** (proof-of-equity, og/subsy) — financia el subsidio de
+//!   hardware anti-clasista (Inmutable #16).
+//!
+//! La inflación resultante (~5% anual con el reward calibrado) materializa la
+//! emisión del BM V2 (40% Ecosystem distribuido en 10-15 años).
+//!
+//! ## sub_mult ORTOGONAL (ratificado David 2026-06-10)
+//!
+//! El subsidy pool financia el subsidio de hardware **sin importar la
+//! suscripción premium** (Pro/Ultra) — son dimensiones ortogonales (V2-CA3). Esta
+//! emisión alimenta el pool; el OnChargeTransaction de Stage 2 lo consumirá.
+//!
+//! ## NPoS diferido a Stage 2
+//!
+//! Esto es la emisión simple Phase 1 PoA (paga al autor Aura directo). Stage 2
+//! introduce pallet_staking + EraPayout (nominators + slashing + selección por
+//! stake). El reward por bloque aquí es el substrate sobre el que Stage 2 hereda.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![warn(missing_docs)]
+
+pub use pallet::*;
+
+extern crate alloc;
+
+#[frame_support::pallet]
+pub mod pallet {
+    use frame_support::pallet_prelude::*;
+    use frame_support::traits::fungible::Mutate;
+    use frame_support::traits::FindAuthor;
+    use frame_support::PalletId;
+    use frame_system::pallet_prelude::*;
+    use sp_runtime::traits::AccountIdConversion;
+
+    /// StorageVersion en código (FIX-2 lifecycle): arranca en 0 (genesis).
+    const STORAGE_VERSION: StorageVersion = StorageVersion::new(0);
+
+    /// Configuración del pallet de emisión.
+    #[pallet::config]
+    pub trait Config: frame_system::Config {
+        /// Runtime event type.
+        type RuntimeEvent: From<Event<Self>>
+            + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        /// Currency que se mintea (la emisión aumenta el total issuance).
+        type Currency: Mutate<Self::AccountId, Balance = u128>;
+
+        /// Cómo encontrar el autor del bloque. En el runtime se cablea con la
+        /// FindAuthor de Aura (pallet_session::FindAccountFromAuthorIndex).
+        type FindAuthor: FindAuthor<Self::AccountId>;
+
+        /// Recompensa por bloque en base units OGC (calibra la inflación ~5%/año).
+        #[pallet::constant]
+        type BlockReward: Get<u128>;
+
+        /// Share del autor en basis points (10_000 = 100%). E.g. 7_000 = 70%.
+        #[pallet::constant]
+        type AuthorShareBps: Get<u16>;
+
+        /// Share del treasury en basis points. E.g. 2_000 = 20%. El residual va al
+        /// subsidy pool.
+        #[pallet::constant]
+        type TreasuryShareBps: Get<u16>;
+
+        /// PalletId de la cuenta-tesorería (la MISMA de governance, og/gvtry).
+        #[pallet::constant]
+        type TreasuryPalletId: Get<PalletId>;
+
+        /// PalletId del subsidy pool (proof-of-equity, Inmutable #16 anti-clasista).
+        #[pallet::constant]
+        type SubsidyPalletId: Get<PalletId>;
+    }
+
+    /// Pallet definition.
+    #[pallet::pallet]
+    #[pallet::storage_version(STORAGE_VERSION)]
+    pub struct Pallet<T>(_);
+
+    /// Total OGC emitido acumulado (tracking de inflación on-chain).
+    #[pallet::storage]
+    #[pallet::getter(fn total_emitted)]
+    pub type TotalEmitted<T> = StorageValue<_, u128, ValueQuery>;
+
+    /// Eventos del pallet.
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        /// Block reward minteado y repartido autor/treasury/subsidy.
+        BlockRewardMinted {
+            /// El validador Aura autor del bloque.
+            author: T::AccountId,
+            /// Monto minteado al autor.
+            author_amount: u128,
+            /// Monto minteado al treasury.
+            treasury_amount: u128,
+            /// Monto minteado al subsidy pool.
+            subsidy_amount: u128,
+        },
+    }
+
+    #[pallet::hooks]
+    impl<T: Config> Hooks<BlockNumberFor<T>> for Pallet<T> {
+        /// Cada bloque: identifica al autor Aura (desde los pre-runtime digests),
+        /// mintea el BlockReward y lo reparte. Si no hay autor (e.g. bloque de
+        /// inherentes sin pre-digest), no mintea.
+        fn on_initialize(_n: BlockNumberFor<T>) -> Weight {
+            let digest = <frame_system::Pallet<T>>::digest();
+            let pre_runtime = digest.logs.iter().filter_map(|d| d.as_pre_runtime());
+            if let Some(author) = T::FindAuthor::find_author(pre_runtime) {
+                let reward = T::BlockReward::get();
+                if reward > 0 {
+                    let author_amount =
+                        reward.saturating_mul(T::AuthorShareBps::get() as u128) / 10_000;
+                    let treasury_amount =
+                        reward.saturating_mul(T::TreasuryShareBps::get() as u128) / 10_000;
+                    // El residual evita pérdida por redondeo de bps.
+                    let subsidy_amount = reward
+                        .saturating_sub(author_amount)
+                        .saturating_sub(treasury_amount);
+
+                    // mint_into aumenta el total issuance (emisión real).
+                    let _ = T::Currency::mint_into(&author, author_amount);
+                    let _ = T::Currency::mint_into(&Self::treasury_account(), treasury_amount);
+                    let _ = T::Currency::mint_into(&Self::subsidy_account(), subsidy_amount);
+
+                    TotalEmitted::<T>::mutate(|t| *t = t.saturating_add(reward));
+                    Self::deposit_event(Event::BlockRewardMinted {
+                        author,
+                        author_amount,
+                        treasury_amount,
+                        subsidy_amount,
+                    });
+                }
+            }
+            Weight::from_parts(30_000, 0)
+        }
+    }
+
+    impl<T: Config> Pallet<T> {
+        /// Cuenta-tesorería (vault) — la MISMA que governance (og/gvtry).
+        pub fn treasury_account() -> T::AccountId {
+            T::TreasuryPalletId::get().into_account_truncating()
+        }
+
+        /// Cuenta del subsidy pool (proof-of-equity, financia el subsidio #16).
+        pub fn subsidy_account() -> T::AccountId {
+            T::SubsidyPalletId::get().into_account_truncating()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate as origin_chain_emission;
+    use frame_support::traits::fungible::Inspect;
+    use frame_support::traits::{FindAuthor, Hooks};
+    use frame_support::{construct_runtime, derive_impl, parameter_types, PalletId};
+    use sp_runtime::{AccountId32, BuildStorage};
+
+    type Block = frame_system::mocking::MockBlock<Test>;
+
+    construct_runtime!(
+        pub enum Test {
+            System: frame_system,
+            Balances: pallet_balances,
+            Emission: origin_chain_emission,
+        }
+    );
+
+    #[derive_impl(frame_system::config_preludes::TestDefaultConfig)]
+    impl frame_system::Config for Test {
+        type Block = Block;
+        type AccountId = AccountId32;
+        type Lookup = sp_runtime::traits::IdentityLookup<Self::AccountId>;
+        type AccountData = pallet_balances::AccountData<u128>;
+    }
+
+    #[derive_impl(pallet_balances::config_preludes::TestDefaultConfig)]
+    impl pallet_balances::Config for Test {
+        type AccountStore = System;
+        type Balance = u128;
+    }
+
+    /// FindAuthor de prueba: devuelve siempre ALICE como autor del bloque.
+    pub struct MockFindAuthor;
+    impl FindAuthor<AccountId32> for MockFindAuthor {
+        fn find_author<'a, I>(_digests: I) -> Option<AccountId32>
+        where
+            I: 'a + IntoIterator<Item = (sp_runtime::ConsensusEngineId, &'a [u8])>,
+        {
+            Some(AccountId32::new([1u8; 32]))
+        }
+    }
+
+    parameter_types! {
+        pub const BlockRewardCfg: u128 = 1_000;
+        pub const AuthorShareBpsCfg: u16 = 7_000; // 70%
+        pub const TreasuryShareBpsCfg: u16 = 2_000; // 20% (subsidy = 10% residual)
+        pub const TreasuryPid: PalletId = PalletId(*b"og/gvtry");
+        pub const SubsidyPid: PalletId = PalletId(*b"og/subsy");
+    }
+
+    impl crate::Config for Test {
+        type RuntimeEvent = RuntimeEvent;
+        type Currency = Balances;
+        type FindAuthor = MockFindAuthor;
+        type BlockReward = BlockRewardCfg;
+        type AuthorShareBps = AuthorShareBpsCfg;
+        type TreasuryShareBps = TreasuryShareBpsCfg;
+        type TreasuryPalletId = TreasuryPid;
+        type SubsidyPalletId = SubsidyPid;
+    }
+
+    fn new_test_ext() -> sp_io::TestExternalities {
+        let storage = frame_system::GenesisConfig::<Test>::default()
+            .build_storage()
+            .expect("genesis builds");
+        let mut ext: sp_io::TestExternalities = storage.into();
+        ext.execute_with(|| System::set_block_number(1));
+        ext
+    }
+
+    fn author() -> AccountId32 {
+        AccountId32::new([1u8; 32])
+    }
+
+    #[test]
+    fn block_reward_minted_and_split_correctly() {
+        new_test_ext().execute_with(|| {
+            let treasury = Emission::treasury_account();
+            let subsidy = Emission::subsidy_account();
+
+            // Pre: autor/treasury/subsidy en 0 (no genesis-funded).
+            assert_eq!(<Balances as Inspect<_>>::balance(&author()), 0);
+            assert_eq!(Emission::total_emitted(), 0);
+
+            // Un bloque: mintea 1000 → autor 700, treasury 200, subsidy 100.
+            <Emission as Hooks<u64>>::on_initialize(1);
+
+            assert_eq!(<Balances as Inspect<_>>::balance(&author()), 700);
+            assert_eq!(<Balances as Inspect<_>>::balance(&treasury), 200);
+            assert_eq!(<Balances as Inspect<_>>::balance(&subsidy), 100);
+            assert_eq!(Emission::total_emitted(), 1000);
+        });
+    }
+
+    #[test]
+    fn emission_accumulates_over_blocks() {
+        new_test_ext().execute_with(|| {
+            <Emission as Hooks<u64>>::on_initialize(1);
+            <Emission as Hooks<u64>>::on_initialize(2);
+            <Emission as Hooks<u64>>::on_initialize(3);
+
+            // 3 bloques × 1000 = 3000 emitido; autor acumula 3 × 700 = 2100.
+            assert_eq!(Emission::total_emitted(), 3_000);
+            assert_eq!(<Balances as Inspect<_>>::balance(&author()), 2_100);
+        });
+    }
+
+    #[test]
+    fn split_no_pierde_por_redondeo() {
+        new_test_ext().execute_with(|| {
+            // author + treasury + subsidy == reward exacto (el residual al subsidy).
+            <Emission as Hooks<u64>>::on_initialize(1);
+            let treasury = Emission::treasury_account();
+            let subsidy = Emission::subsidy_account();
+            let total = <Balances as Inspect<_>>::balance(&author())
+                + <Balances as Inspect<_>>::balance(&treasury)
+                + <Balances as Inspect<_>>::balance(&subsidy);
+            assert_eq!(total, 1_000, "el reparto no pierde unidades");
+        });
+    }
+}