partnerchain-reference-implementation/docs/dev_logs/initial_customizations.md at main · txpipe-shop/partnerchain-reference-implementation · GitHub

 members = [
     "demo/authorities",
     "griffin-core",
     "griffin-rpc",
     "node",
     "runtime",
     "wallet",
 [workspace.dependencies]
 griffin-core = { default-features = false, path = "griffin-core" }
 griffin-partner-chains-runtime = { path = "./runtime", default-features = false }
 griffin-rpc = { default-features = false, path = "griffin-rpc" }


           demo-authorities = { path = "demo/authorities", default-features = false }


           name = "griffin-partner-chains-runtime"
 [dependencies]
 demo-authorities = { workspace = true }
 griffin-core = { workspace = true }
 pub fn get_genesis_config(genesis_json: String) -> GenesisConfig {
     let mut json_data: &str = GENESIS_DEFAULT_JSON;
     if !genesis_json.is_empty() {
         json_data = &genesis_json;
     };

     match serde_json::from_str(json_data) {
         Err(e) => panic!("Error: {e}\nJSON data: {json_data}"),
         Ok(v) => v,
     }
 }
 use griffin_core::genesis::config_builder::GenesisConfig;
 use griffin_core::types::{Address, AssetName, Input, PolicyId};
 use griffin_core::utxo_set::TransparentUtxoSet;
 use griffin_core::MILLI_SECS_PER_SLOT;
 pub use opaque::SessionKeys;


           use demo_authorities as Authorities;
 pub mod opaque {
     use super::*;
     use sp_core::{ed25519, sr25519};

     // This part is necessary for generating session keys in the runtime
     impl_opaque_keys! {
         pub struct SessionKeys {
             pub aura: AuraAppPublic,
             pub grandpa: GrandpaAppPublic,
         }
     }
     impl From<(sr25519::Public, ed25519::Public)> for SessionKeys {
         fn from((aura, grandpa): (sr25519::Public, ed25519::Public)) -> Self {
             Self {
                 aura: aura.into(),
                 grandpa: grandpa.into(),
             }
         }
     }
     // Typically these are not implemented manually, but rather for the pallet associated with the
     // keys. Here we are not using the pallets, and these implementations are trivial, so we just
     // re-write them.
     pub struct AuraAppPublic;
     impl BoundToRuntimeAppPublic for AuraAppPublic {
         type Public = AuraId;
     }

     pub struct GrandpaAppPublic;
     impl BoundToRuntimeAppPublic for GrandpaAppPublic {
         type Public = sp_consensus_grandpa::AuthorityId;
     }
 }
 pub type Transaction = griffin_core::types::Transaction;
 pub type Block = griffin_core::types::Block;
 pub type Executive = griffin_core::Executive;
 pub type Output = griffin_core::types::Output;
 #[derive(Encode, Decode, PartialEq, Eq, Clone, TypeInfo)]
 pub struct Runtime;
 impl apis::Core<Block> for Runtime {
     fn version() -> RuntimeVersion {
         VERSION
     }

     fn execute_block(block: Block) {
         Executive::execute_block(block)
     }

     fn initialize_block(header: &<Block as BlockT>::Header) -> sp_runtime::ExtrinsicInclusionMode {
         Executive::open_block(header)
     }
 }
 impl apis::BlockBuilder<Block> for Runtime {
     fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {
         Executive::apply_extrinsic(extrinsic)
     }

     fn finalize_block() -> <Block as BlockT>::Header {
         Executive::close_block()
     }

     fn inherent_extrinsics(_data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
         Vec::new()
     }
 impl apis::TaggedTransactionQueue<Block> for Runtime {
     fn validate_transaction(
         source: TransactionSource,
         tx: <Block as BlockT>::Extrinsic,
         block_hash: <Block as BlockT>::Hash,
     ) -> TransactionValidity {
         Executive::validate_transaction(source, tx, block_hash)
     }
 }
 impl apis::SessionKeys<Block> for Runtime {
     fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {
         opaque::SessionKeys::generate(seed)
     }

     fn decode_session_keys(
         encoded: Vec<u8>,
     ) -> Option<Vec<(Vec<u8>, sp_core::crypto::KeyTypeId)>> {
         opaque::SessionKeys::decode_into_raw_public_keys(&encoded)
     }
 }
 impl apis::GenesisBuilder<Block> for Runtime {
     fn build_state(config: Vec<u8>) -> sp_genesis_builder::Result {
         let genesis_config = serde_json::from_slice::<GenesisConfig>(config.as_slice())
             .map_err(|_| "The input JSON is not a valid genesis configuration.")?;

         griffin_core::genesis::GriffinGenesisConfigBuilder::build(genesis_config)
     }

     fn get_preset(_id: &Option<sp_genesis_builder::PresetId>) -> Option<Vec<u8>> {
         let genesis_config : &GenesisConfig = &genesis::get_genesis_config("".to_string());
         Some(serde_json::to_vec(genesis_config)
              .expect("Genesis configuration is valid."))
     }

     fn preset_names() -> Vec<sp_genesis_builder::PresetId> {
         vec![]
     }
 }
 impl apis::AuraApi<Block, AuraId> for Runtime {
     fn slot_duration() -> sp_consensus_aura::SlotDuration {
         sp_consensus_aura::SlotDuration::from_millis(MILLI_SECS_PER_SLOT.into())
     }

     fn authorities() -> Vec<AuraId> {
         Authorities::aura_authorities()
     }
 }
 impl apis::GrandpaApi<Block> for Runtime {
     fn grandpa_authorities() -> sp_consensus_grandpa::AuthorityList {
         Authorities::grandpa_authorities()
     }

     fn current_set_id() -> sp_consensus_grandpa::SetId {
         0u64
     }

     fn submit_report_equivocation_unsigned_extrinsic(
         _equivocation_proof: sp_consensus_grandpa::EquivocationProof<
             <Block as BlockT>::Hash,
             sp_runtime::traits::NumberFor<Block>,
         >,
         _key_owner_proof: sp_consensus_grandpa::OpaqueKeyOwnershipProof,
     ) -> Option<()> {
         None
     }
 impl griffin_core::utxo_set::TransparentUtxoSetApi<Block> for Runtime {
     fn peek_utxo(input: &Input) -> Option<Output> {
         TransparentUtxoSet::peek_utxo(input)
     }

     fn peek_utxo_by_address(addr: &Address) -> Vec<Output> {
         TransparentUtxoSet::peek_utxos_from_address(addr)
     }

     fn peek_utxo_with_asset(asset_name: &AssetName, asset_policy: &PolicyId) -> Vec<Output> {
         TransparentUtxoSet::peek_utxos_with_asset(asset_name, asset_policy)
     }
 }
 griffin-core = { workspace = true }
 griffin-partner-chains-runtime = { workspace = true }
 griffin-rpc = { workspace = true }
 use griffin_partner_chains_runtime::genesis::get_genesis_config;
 use griffin_partner_chains_runtime::WASM_BINARY;
 pub fn development_config(genesis_json: String) -> Result<ChainSpec, String> {
     Ok(ChainSpec::builder(
         WASM_BINARY.ok_or_else(|| "Development wasm not available".to_string())?,
         None,
     )
     .with_name("Development")
     .with_id("dev")
     .with_chain_type(ChainType::Development)
     .with_genesis_config_patch(serde_json::json!(get_genesis_config(genesis_json)))
     .build())
 }
 pub fn local_testnet_config(genesis_json: String) -> Result<ChainSpec, String> {
     Ok(ChainSpec::builder(
         WASM_BINARY.ok_or_else(|| "Development wasm not available".to_string())?,
         None,
     )
     .with_name("Local Testnet")
     .with_id("local_testnet")
     .with_chain_type(ChainType::Local)
     .with_genesis_config_patch(serde_json::json!(get_genesis_config(genesis_json)))
     .build())
 }
     #[deprecated(
         note = "build-spec command will be removed after 1/04/2026. Use export-chain-spec command instead"
     )]
     BuildSpec(sc_cli::BuildSpecCmd),

     /// Export the chain specification.
     ExportChainSpec(sc_cli::ExportChainSpecCmd),
 fn impl_name() -> String {
     "Griffin solochain node based on Substrate / Polkadot SDK".into()
 }
 fn load_spec(&self, id: &str) -> Result<Box<dyn sc_service::ChainSpec>, String> {
     Ok(match id {
         "dev" => Box::new(chain_spec::development_config("".to_string())?),
         "" | "local" => Box::new(chain_spec::local_testnet_config("".to_string())?),
         path => {
             let file_content =
                 std::fs::read_to_string(path).expect("Unable to read the initialization file");
             Box::new(chain_spec::local_testnet_config(file_content)?)
         }
     })
 }
 Some(Subcommand::ExportChainSpec(cmd)) => {
     let chain_spec = cli.load_spec(&cmd.chain)?;
     cmd.run(chain_spec)
 }
 #[allow(deprecated)]
 Some(Subcommand::BuildSpec(cmd)) => {
     let runner = cli.create_runner(cmd)?;
     runner.sync_run(|config| cmd.run(config.chain_spec, config.network))
 }
 sc_network::config::NetworkBackendType::Libp2p => service::new_full::<
     sc_network::NetworkWorker<
         griffin_core::types::OpaqueBlock,
         <griffin_core::types::OpaqueBlock as sp_runtime::traits::Block>::Hash,
     >,
 >(
 use griffin_core::{genesis::GriffinGenesisBlockBuilder, types::OpaqueBlock as Block};
 use griffin_partner_chains_runtime::{self, RuntimeApi};


           let backend = sc_service::new_db_backend(config.db_config())?;
 let genesis_block_builder = GriffinGenesisBlockBuilder::new(
     config.chain_spec.as_storage_builder(),
     !config.no_genesis(),
     backend.clone(),
     executor.clone(),
 )?;
 let (client, backend, keystore_container, task_manager) =
     sc_service::new_full_parts_with_genesis_builder::<Block, RuntimeApi, _, _>(
         config,
         telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()),
         executor,
         backend,
         genesis_block_builder,
         false,
     )?;
 let chain_spec =
     &serde_json::from_str::<serde_json::Value>(&config.chain_spec.as_json(false).unwrap())
         .unwrap();
 let zero_time = chain_spec["genesis"]["runtimeGenesis"]["patch"]["zero_time"]
     .as_u64()
     .unwrap();
 let now = SystemTime::now()
     .duration_since(UNIX_EPOCH)
     .unwrap()
     .as_millis() as u64;

 // Wait until genesis time
 sleep(Duration::from_millis(
     zero_time.checked_sub(now).unwrap_or(0),
 ));
 use griffin_rpc::cardano_rpc::{CardanoRpc, CardanoRpcApiServer};
 use griffin_rpc::rpc::{TransparentUtxoSetRpc, TransparentUtxoSetRpcApiServer};
 C::Api: griffin_core::utxo_set::TransparentUtxoSetApi<
     <P as sc_transaction_pool_api::TransactionPool>::Block,
 >,
 let mut module = RpcModule::new(());
 let FullDeps { client, pool } = deps;

 module.merge(CardanoRpc::new(client.clone(), pool.clone()).into_rpc())?;
 module.merge(TransparentUtxoSetRpc::new(client.clone()).into_rpc())?;
	members = [
	"demo/authorities",
	"griffin-core",
	"griffin-rpc",
	"node",
	"runtime",
	"wallet",
	[workspace.dependencies]
	griffin-core = { default-features = false, path = "griffin-core" }
	griffin-partner-chains-runtime = { path = "./runtime", default-features = false }
	griffin-rpc = { default-features = false, path = "griffin-rpc" }
	[dependencies]
	demo-authorities = { workspace = true }
	griffin-core = { workspace = true }
	pub fn get_genesis_config(genesis_json: String) -> GenesisConfig {
	let mut json_data: &str = GENESIS_DEFAULT_JSON;
	if !genesis_json.is_empty() {
	json_data = &genesis_json;
	};

	match serde_json::from_str(json_data) {
	Err(e) => panic!("Error: {e}\nJSON data: {json_data}"),
	Ok(v) => v,
	}
	}
	use griffin_core::genesis::config_builder::GenesisConfig;
	use griffin_core::types::{Address, AssetName, Input, PolicyId};
	use griffin_core::utxo_set::TransparentUtxoSet;
	use griffin_core::MILLI_SECS_PER_SLOT;
	pub use opaque::SessionKeys;
	pub mod opaque {
	use super::*;
	use sp_core::{ed25519, sr25519};

	// This part is necessary for generating session keys in the runtime
	impl_opaque_keys! {
	pub struct SessionKeys {
	pub aura: AuraAppPublic,
	pub grandpa: GrandpaAppPublic,
	}
	}
	impl From<(sr25519::Public, ed25519::Public)> for SessionKeys {
	fn from((aura, grandpa): (sr25519::Public, ed25519::Public)) -> Self {
	Self {
	aura: aura.into(),
	grandpa: grandpa.into(),
	}
	}
	}
	// Typically these are not implemented manually, but rather for the pallet associated with the
	// keys. Here we are not using the pallets, and these implementations are trivial, so we just
	// re-write them.
	pub struct AuraAppPublic;
	impl BoundToRuntimeAppPublic for AuraAppPublic {
	type Public = AuraId;
	}

	pub struct GrandpaAppPublic;
	impl BoundToRuntimeAppPublic for GrandpaAppPublic {
	type Public = sp_consensus_grandpa::AuthorityId;
	}
	}
	pub type Transaction = griffin_core::types::Transaction;
	pub type Block = griffin_core::types::Block;
	pub type Executive = griffin_core::Executive;
	pub type Output = griffin_core::types::Output;
	#[derive(Encode, Decode, PartialEq, Eq, Clone, TypeInfo)]
	pub struct Runtime;
	impl apis::Core<Block> for Runtime {
	fn version() -> RuntimeVersion {
	VERSION
	}

	fn execute_block(block: Block) {
	Executive::execute_block(block)
	}

	fn initialize_block(header: &<Block as BlockT>::Header) -> sp_runtime::ExtrinsicInclusionMode {
	Executive::open_block(header)
	}
	}
	impl apis::BlockBuilder<Block> for Runtime {
	fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyExtrinsicResult {
	Executive::apply_extrinsic(extrinsic)
	}

	fn finalize_block() -> <Block as BlockT>::Header {
	Executive::close_block()
	}

	fn inherent_extrinsics(_data: sp_inherents::InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
	Vec::new()
	}