partnerchain-reference-implementation/docs/tutorial/partnerchain_integration.md at main · txpipe-shop/partnerchain-reference-implementation · GitHub

 if context.prompt_yes_no("Do you want to continue?", true) {
     let initial_permissioned_candidates_data: &Vec<
         sidechain_domain::PermissionedCandidateData,
     > = &config
         .initial_permissioned_candidates_parsed
         .iter()
         .map(From::from)
         .collect::<Vec<sidechain_domain::PermissionedCandidateData>>();
     let encoded_authorities =
         permissioned_candidates_to_plutus_data(initial_permissioned_candidates_data)
             .to_hex();
     let mut genesis: GenesisConfig = serde_json::from_str(GENESIS_DEFAULT_JSON)?;
     genesis.outputs[0].datum = Some(encoded_authorities);
     context.write_file(
         "new-genesis.json",
         serde_json::to_string_pretty(&genesis)?.as_str(),
     );
 pub const GENESIS_DEFAULT_JSON: &str = r#"
 {
     "zero_time": 1747081100000,
     "zero_slot": 0,
     "outputs": [
         {
             "address": "0000000000000000000000000000000000000000000000000000000000",
             "coin": 314150000,
             "value": [
                     {
                         "policy": "0298aa99f95e2fe0a0132a6bb794261fb7e7b0d988215da2f2de2005",
                         "assets": [ ["Authorities", 300000000]]
                     }
                     ],
             "datum": ""
         },
         {
             "address": "6101e6301758a6badfab05035cffc8e3438b3aff2a4edc6544b47329c4",
             "coin": 314000000,
             "value": [
                     {
                         "policy": "0298aa99f95e2fe0a0132a6bb794261fb7e7b0d988215da2f2de2005",
                         "assets": [ ["tokenA", 271000000], ["tokenB", 1123581321] ]
                     }
                     ],
             "datum": "820080"
         },
         {
             "address": "61547932e40a24e2b7deb41f31af21ed57acd125f4ed8a72b626b3d7f6",
             "coin": 314150000,
             "value": [
                     {
                         "policy": "0298aa99f95e2fe0a0132a6bb794261fb7e7b0d988215da2f2de2005",
                         "assets": [ ["tokenA", 300000000], ["tokenB", 2000000000] ]
                     }
                     ],
             "datum": "820080"
         }
     ]
 }
 "#;


           use sp_core::{crypto::KeyTypeId, OpaqueMetadata};
 pub mod cross_chain_app {
     use super::CROSS_CHAIN;
     use parity_scale_codec::MaxEncodedLen;
     use sidechain_domain::SidechainPublicKey;
     use sp_core::crypto::AccountId32;
     use sp_runtime::app_crypto::{app_crypto, ecdsa};
     use sp_runtime::traits::IdentifyAccount;
     use sp_runtime::MultiSigner;
     use sp_std::vec::Vec;

     app_crypto!(ecdsa, CROSS_CHAIN);
     impl MaxEncodedLen for Signature {
         fn max_encoded_len() -> usize {
             ecdsa::Signature::max_encoded_len()
         }
     }

     impl From<Signature> for Vec<u8> {
         fn from(value: Signature) -> Self {
             value.into_inner().0.to_vec()
         }
     }

     impl From<Public> for AccountId32 {
         fn from(value: Public) -> Self {
             MultiSigner::from(ecdsa::Public::from(value)).into_account()
         }
     }

     impl From<Public> for Vec<u8> {
         fn from(value: Public) -> Self {
             value.into_inner().0.to_vec()
         }
     }

     impl TryFrom<SidechainPublicKey> for Public {
         type Error = SidechainPublicKey;
         fn try_from(pubkey: SidechainPublicKey) -> Result<Self, Self::Error> {
             let cross_chain_public_key =
                 Public::try_from(pubkey.0.as_slice()).map_err(|_| pubkey)?;
             Ok(cross_chain_public_key)
         }
     }
 }
     impl_opaque_keys! {
         pub struct CrossChainKey {
             pub account: CrossChainPublic,
         }
     }
 }

 pub type CrossChainPublic = opaque::cross_chain_app::Public;
	if context.prompt_yes_no("Do you want to continue?", true) {
	let initial_permissioned_candidates_data: &Vec<
	sidechain_domain::PermissionedCandidateData,
	> = &config
	.initial_permissioned_candidates_parsed
	.iter()
	.map(From::from)
	.collect::<Vec<sidechain_domain::PermissionedCandidateData>>();
	let encoded_authorities =
	permissioned_candidates_to_plutus_data(initial_permissioned_candidates_data)
	.to_hex();
	let mut genesis: GenesisConfig = serde_json::from_str(GENESIS_DEFAULT_JSON)?;
	genesis.outputs[0].datum = Some(encoded_authorities);
	context.write_file(
	"new-genesis.json",
	serde_json::to_string_pretty(&genesis)?.as_str(),
	);
	pub const GENESIS_DEFAULT_JSON: &str = r#"
	{
	"zero_time": 1747081100000,
	"zero_slot": 0,
	"outputs": [
	{
	"address": "0000000000000000000000000000000000000000000000000000000000",
	"coin": 314150000,
	"value": [
	{
	"policy": "0298aa99f95e2fe0a0132a6bb794261fb7e7b0d988215da2f2de2005",
	"assets": [ ["Authorities", 300000000]]
	}
	],
	"datum": ""
	},
	{
	"address": "6101e6301758a6badfab05035cffc8e3438b3aff2a4edc6544b47329c4",
	"coin": 314000000,
	"value": [
	{
	"policy": "0298aa99f95e2fe0a0132a6bb794261fb7e7b0d988215da2f2de2005",
	"assets": [ ["tokenA", 271000000], ["tokenB", 1123581321] ]
	}
	],
	"datum": "820080"
	},
	{
	"address": "61547932e40a24e2b7deb41f31af21ed57acd125f4ed8a72b626b3d7f6",
	"coin": 314150000,
	"value": [
	{
	"policy": "0298aa99f95e2fe0a0132a6bb794261fb7e7b0d988215da2f2de2005",
	"assets": [ ["tokenA", 300000000], ["tokenB", 2000000000] ]
	}
	],
	"datum": "820080"
	}
	]
	}
	"#;
	pub mod cross_chain_app {
	use super::CROSS_CHAIN;
	use parity_scale_codec::MaxEncodedLen;
	use sidechain_domain::SidechainPublicKey;
	use sp_core::crypto::AccountId32;
	use sp_runtime::app_crypto::{app_crypto, ecdsa};
	use sp_runtime::traits::IdentifyAccount;
	use sp_runtime::MultiSigner;
	use sp_std::vec::Vec;

	app_crypto!(ecdsa, CROSS_CHAIN);
	impl MaxEncodedLen for Signature {
	fn max_encoded_len() -> usize {
	ecdsa::Signature::max_encoded_len()
	}
	}

	impl From<Signature> for Vec<u8> {
	fn from(value: Signature) -> Self {
	value.into_inner().0.to_vec()
	}
	}

	impl From<Public> for AccountId32 {
	fn from(value: Public) -> Self {
	MultiSigner::from(ecdsa::Public::from(value)).into_account()
	}
	}

	impl From<Public> for Vec<u8> {
	fn from(value: Public) -> Self {
	value.into_inner().0.to_vec()
	}
	}

	impl TryFrom<SidechainPublicKey> for Public {
	type Error = SidechainPublicKey;
	fn try_from(pubkey: SidechainPublicKey) -> Result<Self, Self::Error> {
	let cross_chain_public_key =
	Public::try_from(pubkey.0.as_slice()).map_err(\|_\| pubkey)?;
	Ok(cross_chain_public_key)
	}
	}
	}
	impl_opaque_keys! {
	pub struct CrossChainKey {
	pub account: CrossChainPublic,
	}
	}
	}

	pub type CrossChainPublic = opaque::cross_chain_app::Public;