diff --git a/configs/peer/executor.wasm b/configs/peer/executor.wasm
index bc3c581289e..98e55964961 100644
Binary files a/configs/peer/executor.wasm and b/configs/peer/executor.wasm differ
diff --git a/tools/kagami/src/genesis.rs b/tools/kagami/src/genesis.rs
index 41ff4c71237..0f12017a828 100644
--- a/tools/kagami/src/genesis.rs
+++ b/tools/kagami/src/genesis.rs
@@ -213,33 +213,38 @@ fn generate_synthetic(
     accounts_per_domain: u64,
     assets_per_domain: u64,
 ) -> color_eyre::Result<RawGenesisBlock> {
-    // Add default `Domain` and `Account` to still be able to query
-    let mut builder = RawGenesisBlockBuilder::default()
-        .domain("wonderland".parse()?)
-        .account("alice".parse()?, crate::DEFAULT_PUBLIC_KEY.parse()?)
-        .finish_domain();
+    let mut genesis = generate_default(executor)?;
+
+    let first_transaction = genesis
+        .first_transaction_mut()
+        .expect("transaction must exist");
 
     for domain in 0..domains {
-        let mut domain_builder = builder.domain(format!("domain_{domain}").parse()?);
+        let domain_id: DomainId = format!("domain_{domain}").parse()?;
+
+        let register = RegisterExpr::new(Domain::new(domain_id.clone())).into();
+
+        first_transaction.append_instruction(register);
 
         for account in 0..accounts_per_domain {
+            let account_id: AccountId = format!("account_{account}@{domain_id}").parse()?;
             let (public_key, _) = iroha_crypto::KeyPair::generate()?.into();
-            domain_builder =
-                domain_builder.account(format!("account_{account}").parse()?, public_key);
+
+            let register = RegisterExpr::new(Account::new(account_id, [public_key])).into();
+
+            first_transaction.append_instruction(register);
         }
 
         for asset in 0..assets_per_domain {
-            domain_builder =
-                domain_builder.asset(format!("asset_{asset}").parse()?, AssetValueType::Quantity);
-        }
+            let asset_id: AssetDefinitionId = format!("asset_{asset}#{domain_id}").parse()?;
+
+            let register =
+                RegisterExpr::new(AssetDefinition::new(asset_id, AssetValueType::Quantity)).into();
 
-        builder = domain_builder.finish_domain();
+            first_transaction.append_instruction(register);
+        }
     }
-    let mut genesis = builder.executor(executor).build();
 
-    let first_transaction = genesis
-        .first_transaction_mut()
-        .expect("At least one transaction is expected");
     for domain in 0..domains {
         for account in 0..accounts_per_domain {
             // FIXME: it actually generates (assets_per_domain * accounts_per_domain) assets per domain