@nomicfoundation/edr 0.12.0-next.10 → 0.12.0-next.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomicfoundation/edr",
-  "version": "0.12.0-next.10",
+  "version": "0.12.0-next.14",
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",
     "@nomicfoundation/ethereumjs-util": "^9.0.4",
@@ -36,8 +36,7 @@
   "files": [
     "index.js",
     "index.d.ts",
-    "src/",
-    "dist/src/"
+    "src/"
   ],
   "license": "MIT",
   "main": "index.js",
@@ -59,13 +58,13 @@
   "repository": "NomicFoundation/edr.git",
   "types": "index.d.ts",
   "dependencies": {
-    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.10",
-    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.10",
-    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.10",
-    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.10",
-    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.10",
-    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.10",
-    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.10"
+    "@nomicfoundation/edr-darwin-arm64": "0.12.0-next.14",
+    "@nomicfoundation/edr-darwin-x64": "0.12.0-next.14",
+    "@nomicfoundation/edr-linux-arm64-gnu": "0.12.0-next.14",
+    "@nomicfoundation/edr-linux-arm64-musl": "0.12.0-next.14",
+    "@nomicfoundation/edr-linux-x64-gnu": "0.12.0-next.14",
+    "@nomicfoundation/edr-linux-x64-musl": "0.12.0-next.14",
+    "@nomicfoundation/edr-win32-x64-msvc": "0.12.0-next.14"
   },
   "scripts": {
     "artifacts": "napi artifacts",

package/src/chains/l1.rs

@@ -1,10 +1,10 @@
 use std::{str::FromStr, sync::Arc};
 
-use edr_chain_l1::L1ChainSpec;
-use edr_evm::eips::{
+use edr_blockchain_fork::eips::{
     eip2935::{HISTORY_STORAGE_ADDRESS, HISTORY_STORAGE_UNSUPPORTED_BYTECODE},
     eip4788::{BEACON_ROOTS_ADDRESS, BEACON_ROOTS_BYTECODE},
 };
+use edr_chain_l1::L1ChainSpec;
 use edr_napi_core::{
     logger::Logger,
     provider::{SyncProvider, SyncProviderFactory},
@@ -142,25 +142,25 @@ impl FromStr for SpecId {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            edr_chain_l1::hardfork::name::FRONTIER => Ok(SpecId::Frontier),
-            edr_chain_l1::hardfork::name::FRONTIER_THAWING => Ok(SpecId::FrontierThawing),
-            edr_chain_l1::hardfork::name::HOMESTEAD => Ok(SpecId::Homestead),
-            edr_chain_l1::hardfork::name::DAO_FORK => Ok(SpecId::DaoFork),
-            edr_chain_l1::hardfork::name::TANGERINE => Ok(SpecId::Tangerine),
-            edr_chain_l1::hardfork::name::SPURIOUS_DRAGON => Ok(SpecId::SpuriousDragon),
-            edr_chain_l1::hardfork::name::BYZANTIUM => Ok(SpecId::Byzantium),
-            edr_chain_l1::hardfork::name::CONSTANTINOPLE => Ok(SpecId::Constantinople),
-            edr_chain_l1::hardfork::name::PETERSBURG => Ok(SpecId::Petersburg),
-            edr_chain_l1::hardfork::name::ISTANBUL => Ok(SpecId::Istanbul),
-            edr_chain_l1::hardfork::name::MUIR_GLACIER => Ok(SpecId::MuirGlacier),
-            edr_chain_l1::hardfork::name::BERLIN => Ok(SpecId::Berlin),
-            edr_chain_l1::hardfork::name::LONDON => Ok(SpecId::London),
-            edr_chain_l1::hardfork::name::ARROW_GLACIER => Ok(SpecId::ArrowGlacier),
-            edr_chain_l1::hardfork::name::GRAY_GLACIER => Ok(SpecId::GrayGlacier),
-            edr_chain_l1::hardfork::name::MERGE => Ok(SpecId::Merge),
-            edr_chain_l1::hardfork::name::SHANGHAI => Ok(SpecId::Shanghai),
-            edr_chain_l1::hardfork::name::CANCUN => Ok(SpecId::Cancun),
-            edr_chain_l1::hardfork::name::PRAGUE => Ok(SpecId::Prague),
+            edr_chain_l1::chains::name::FRONTIER => Ok(SpecId::Frontier),
+            edr_chain_l1::chains::name::FRONTIER_THAWING => Ok(SpecId::FrontierThawing),
+            edr_chain_l1::chains::name::HOMESTEAD => Ok(SpecId::Homestead),
+            edr_chain_l1::chains::name::DAO_FORK => Ok(SpecId::DaoFork),
+            edr_chain_l1::chains::name::TANGERINE => Ok(SpecId::Tangerine),
+            edr_chain_l1::chains::name::SPURIOUS_DRAGON => Ok(SpecId::SpuriousDragon),
+            edr_chain_l1::chains::name::BYZANTIUM => Ok(SpecId::Byzantium),
+            edr_chain_l1::chains::name::CONSTANTINOPLE => Ok(SpecId::Constantinople),
+            edr_chain_l1::chains::name::PETERSBURG => Ok(SpecId::Petersburg),
+            edr_chain_l1::chains::name::ISTANBUL => Ok(SpecId::Istanbul),
+            edr_chain_l1::chains::name::MUIR_GLACIER => Ok(SpecId::MuirGlacier),
+            edr_chain_l1::chains::name::BERLIN => Ok(SpecId::Berlin),
+            edr_chain_l1::chains::name::LONDON => Ok(SpecId::London),
+            edr_chain_l1::chains::name::ARROW_GLACIER => Ok(SpecId::ArrowGlacier),
+            edr_chain_l1::chains::name::GRAY_GLACIER => Ok(SpecId::GrayGlacier),
+            edr_chain_l1::chains::name::MERGE => Ok(SpecId::Merge),
+            edr_chain_l1::chains::name::SHANGHAI => Ok(SpecId::Shanghai),
+            edr_chain_l1::chains::name::CANCUN => Ok(SpecId::Cancun),
+            edr_chain_l1::chains::name::PRAGUE => Ok(SpecId::Prague),
             _ => Err(napi::Error::new(
                 napi::Status::InvalidArg,
                 format!("The provided hardfork `{s}` is not supported."),
@@ -206,25 +206,25 @@ pub fn l1_hardfork_from_string(hardfork: String) -> napi::Result<SpecId> {
 #[napi(catch_unwind)]
 pub fn l1_hardfork_to_string(harfork: SpecId) -> &'static str {
     match harfork {
-        SpecId::Frontier => edr_chain_l1::hardfork::name::FRONTIER,
-        SpecId::FrontierThawing => edr_chain_l1::hardfork::name::FRONTIER_THAWING,
-        SpecId::Homestead => edr_chain_l1::hardfork::name::HOMESTEAD,
-        SpecId::DaoFork => edr_chain_l1::hardfork::name::DAO_FORK,
-        SpecId::Tangerine => edr_chain_l1::hardfork::name::TANGERINE,
-        SpecId::SpuriousDragon => edr_chain_l1::hardfork::name::SPURIOUS_DRAGON,
-        SpecId::Byzantium => edr_chain_l1::hardfork::name::BYZANTIUM,
-        SpecId::Constantinople => edr_chain_l1::hardfork::name::CONSTANTINOPLE,
-        SpecId::Petersburg => edr_chain_l1::hardfork::name::PETERSBURG,
-        SpecId::Istanbul => edr_chain_l1::hardfork::name::ISTANBUL,
-        SpecId::MuirGlacier => edr_chain_l1::hardfork::name::MUIR_GLACIER,
-        SpecId::Berlin => edr_chain_l1::hardfork::name::BERLIN,
-        SpecId::London => edr_chain_l1::hardfork::name::LONDON,
-        SpecId::ArrowGlacier => edr_chain_l1::hardfork::name::ARROW_GLACIER,
-        SpecId::GrayGlacier => edr_chain_l1::hardfork::name::GRAY_GLACIER,
-        SpecId::Merge => edr_chain_l1::hardfork::name::MERGE,
-        SpecId::Shanghai => edr_chain_l1::hardfork::name::SHANGHAI,
-        SpecId::Cancun => edr_chain_l1::hardfork::name::CANCUN,
-        SpecId::Prague => edr_chain_l1::hardfork::name::PRAGUE,
+        SpecId::Frontier => edr_chain_l1::chains::name::FRONTIER,
+        SpecId::FrontierThawing => edr_chain_l1::chains::name::FRONTIER_THAWING,
+        SpecId::Homestead => edr_chain_l1::chains::name::HOMESTEAD,
+        SpecId::DaoFork => edr_chain_l1::chains::name::DAO_FORK,
+        SpecId::Tangerine => edr_chain_l1::chains::name::TANGERINE,
+        SpecId::SpuriousDragon => edr_chain_l1::chains::name::SPURIOUS_DRAGON,
+        SpecId::Byzantium => edr_chain_l1::chains::name::BYZANTIUM,
+        SpecId::Constantinople => edr_chain_l1::chains::name::CONSTANTINOPLE,
+        SpecId::Petersburg => edr_chain_l1::chains::name::PETERSBURG,
+        SpecId::Istanbul => edr_chain_l1::chains::name::ISTANBUL,
+        SpecId::MuirGlacier => edr_chain_l1::chains::name::MUIR_GLACIER,
+        SpecId::Berlin => edr_chain_l1::chains::name::BERLIN,
+        SpecId::London => edr_chain_l1::chains::name::LONDON,
+        SpecId::ArrowGlacier => edr_chain_l1::chains::name::ARROW_GLACIER,
+        SpecId::GrayGlacier => edr_chain_l1::chains::name::GRAY_GLACIER,
+        SpecId::Merge => edr_chain_l1::chains::name::MERGE,
+        SpecId::Shanghai => edr_chain_l1::chains::name::SHANGHAI,
+        SpecId::Cancun => edr_chain_l1::chains::name::CANCUN,
+        SpecId::Prague => edr_chain_l1::chains::name::PRAGUE,
     }
 }
 
@@ -240,7 +240,7 @@ macro_rules! export_spec_id {
     ($($variant:ident),*) => {
         $(
             #[napi]
-            pub const $variant: &str = edr_chain_l1::hardfork::name::$variant;
+            pub const $variant: &str = edr_chain_l1::chains::name::$variant;
         )*
     };
 }

package/src/config.rs

@@ -280,28 +280,28 @@ impl TryFrom<ForkConfig> for edr_provider::ForkConfig<String> {
                                         let condition = match condition {
                                             Either::A(HardforkActivationByBlockNumber {
                                                 block_number,
-                                            }) => edr_evm::hardfork::ForkCondition::Block(
+                                            }) => edr_chain_config::ForkCondition::Block(
                                                 block_number.try_cast()?,
                                             ),
                                             Either::B(HardforkActivationByTimestamp {
                                                 timestamp,
-                                            }) => edr_evm::hardfork::ForkCondition::Timestamp(
+                                            }) => edr_chain_config::ForkCondition::Timestamp(
                                                 timestamp.try_cast()?,
                                             ),
                                         };
 
-                                        Ok(edr_evm::hardfork::Activation {
+                                        Ok(edr_chain_config::HardforkActivation {
                                             condition,
                                             hardfork,
                                         })
                                     },
                                 )
                                 .collect::<napi::Result<Vec<_>>>()
-                                .map(edr_evm::hardfork::Activations::new)
+                                .map(edr_chain_config::HardforkActivations::new)
                                     })
                                     .transpose()?;
 
-                            let chain_config = edr_evm::hardfork::ChainOverride {
+                            let chain_config = edr_chain_config::ChainOverride {
                                 name,
                                 hardfork_activation_overrides,
                             };
@@ -339,7 +339,7 @@ impl From<MemPoolConfig> for edr_provider::MemPoolConfig {
     }
 }
 
-impl From<MineOrdering> for edr_evm::MineOrdering {
+impl From<MineOrdering> for edr_runtime::MineOrdering {
     fn from(value: MineOrdering) -> Self {
         match value {
             MineOrdering::Fifo => Self::Fifo,

package/src/mock/time.rs

@@ -1,11 +1,11 @@
 use std::sync::Arc;
 
-use edr_evm::spec::RuntimeSpec;
-use edr_evm_spec::ChainSpec;
+use edr_chain_spec::ChainSpec;
+use edr_chain_spec_block::BlockChainSpec;
 use edr_generic::GenericChainSpec;
 use edr_napi_core::logger::Logger;
 use edr_primitives::B256;
-use edr_rpc_spec::RpcSpec;
+use edr_rpc_spec::RpcBlockChainSpec;
 use napi::{bindgen_prelude::BigInt, tokio::runtime, Env, JsObject};
 use napi_derive::napi;
 
@@ -104,8 +104,8 @@ pub fn create_provider_with_mock_timer(
                     Box::new(logger),
                     Box::new(move |event| {
                         let event = edr_napi_core::subscription::SubscriptionEvent::new::<
-                            <GenericChainSpec as RuntimeSpec>::Block,
-                            <GenericChainSpec as RpcSpec>::RpcBlock<B256>,
+                            <GenericChainSpec as BlockChainSpec>::Block,
+                            <GenericChainSpec as RpcBlockChainSpec>::RpcBlock<B256>,
                             <GenericChainSpec as ChainSpec>::SignedTransaction,
                         >(event);
 

package/src/mock.rs

@@ -2,7 +2,7 @@ pub mod time;
 
 use std::sync::Arc;
 
-use edr_evm_spec::EvmHaltReason;
+use edr_chain_spec::EvmHaltReason;
 use edr_napi_core::provider::SyncProvider;
 use edr_rpc_client::jsonrpc;
 use edr_solidity::contract_decoder::ContractDecoder;

package/src/precompile.rs

@@ -1,4 +1,4 @@
-use edr_evm::precompile::{self, PrecompileFn, PrecompileWithAddress};
+use edr_precompile::{PrecompileFn, PrecompileWithAddress};
 use edr_primitives::Address;
 use napi::bindgen_prelude::Uint8Array;
 use napi_derive::napi;
@@ -46,5 +46,5 @@ impl Precompile {
 /// secp256r1 precompile.
 #[napi(catch_unwind)]
 pub fn precompile_p256_verify() -> Precompile {
-    Precompile::from(precompile::secp256r1::P256VERIFY)
+    Precompile::from(edr_precompile::secp256r1::P256VERIFY)
 }

package/src/provider/response.rs

@@ -1,4 +1,4 @@
-use edr_evm_spec::EvmHaltReason;
+use edr_chain_spec::EvmHaltReason;
 use edr_napi_core::spec::SolidityTraceData;
 use edr_solidity::contract_decoder::NestedTraceDecoder as _;
 use napi::Either;

package/src/result.rs

@@ -1,5 +1,5 @@
-use edr_evm::trace::AfterMessage;
-use edr_evm_spec::EvmHaltReason;
+use edr_chain_spec::EvmHaltReason;
+use edr_runtime::trace::AfterMessage;
 use napi::{
     bindgen_prelude::{BigInt, Either3, Uint8Array},
     Either,
@@ -19,17 +19,17 @@ pub enum SuccessReason {
     SelfDestruct,
 }
 
-impl From<edr_evm::result::SuccessReason> for SuccessReason {
-    fn from(eval: edr_evm::result::SuccessReason) -> Self {
+impl From<edr_evm_spec::result::SuccessReason> for SuccessReason {
+    fn from(eval: edr_evm_spec::result::SuccessReason) -> Self {
         match eval {
-            edr_evm::result::SuccessReason::Stop => Self::Stop,
-            edr_evm::result::SuccessReason::Return => Self::Return,
-            edr_evm::result::SuccessReason::SelfDestruct => Self::SelfDestruct,
+            edr_evm_spec::result::SuccessReason::Stop => Self::Stop,
+            edr_evm_spec::result::SuccessReason::Return => Self::Return,
+            edr_evm_spec::result::SuccessReason::SelfDestruct => Self::SelfDestruct,
         }
     }
 }
 
-impl From<SuccessReason> for edr_evm::result::SuccessReason {
+impl From<SuccessReason> for edr_evm_spec::result::SuccessReason {
     fn from(value: SuccessReason) -> Self {
         match value {
             SuccessReason::Stop => Self::Stop,
@@ -157,7 +157,7 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
         } = value;
 
         let result = match execution_result {
-            edr_evm::result::ExecutionResult::Success {
+            edr_evm_spec::result::ExecutionResult::Success {
                 reason,
                 gas_used,
                 gas_refunded,
@@ -172,12 +172,12 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
                     gas_refunded: BigInt::from(*gas_refunded),
                     logs,
                     output: match output {
-                        edr_evm::result::Output::Call(return_value) => {
+                        edr_evm_spec::result::Output::Call(return_value) => {
                             let return_value = Uint8Array::with_data_copied(return_value);
 
                             Either::A(CallOutput { return_value })
                         }
-                        edr_evm::result::Output::Create(return_value, address) => {
+                        edr_evm_spec::result::Output::Create(return_value, address) => {
                             let return_value = Uint8Array::with_data_copied(return_value);
 
                             Either::B(CreateOutput {
@@ -188,7 +188,7 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
                     },
                 })
             }
-            edr_evm::result::ExecutionResult::Revert { gas_used, output } => {
+            edr_evm_spec::result::ExecutionResult::Revert { gas_used, output } => {
                 let output = Uint8Array::with_data_copied(output);
 
                 Either3::B(RevertResult {
@@ -196,10 +196,12 @@ impl From<&AfterMessage<EvmHaltReason>> for ExecutionResult {
                     output,
                 })
             }
-            edr_evm::result::ExecutionResult::Halt { reason, gas_used } => Either3::C(HaltResult {
-                reason: ExceptionalHalt::from(*reason),
-                gas_used: BigInt::from(*gas_used),
-            }),
+            edr_evm_spec::result::ExecutionResult::Halt { reason, gas_used } => {
+                Either3::C(HaltResult {
+                    reason: ExceptionalHalt::from(*reason),
+                    gas_used: BigInt::from(*gas_used),
+                })
+            }
         };
 
         let contract_address = contract_address.as_ref().map(Uint8Array::with_data_copied);

package/src/solidity_tests/l1.rs

@@ -7,8 +7,12 @@ use edr_napi_core::solidity::{
 use edr_primitives::Bytes;
 use edr_solidity::artifacts::ArtifactId;
 use edr_solidity_tests::{
-    contracts::ContractsByArtifact, decode::RevertDecoder, evm_context::L1EvmBuilder,
-    multi_runner::TestContract, MultiContractRunner,
+    contracts::ContractsByArtifact,
+    decode::RevertDecoder,
+    evm_context::L1EvmBuilder,
+    multi_runner::TestContract,
+    revm::context::{BlockEnv, TxEnv},
+    MultiContractRunner,
 };
 use napi::tokio;
 use napi_derive::napi;
@@ -33,14 +37,14 @@ impl SyncTestRunnerFactory for L1TestRunnerFactory {
         let runner = tokio::task::block_in_place(|| {
             runtime
                 .block_on(MultiContractRunner::<
-                    edr_chain_l1::BlockEnv,
+                    BlockEnv,
                     (),
                     L1EvmBuilder,
                     edr_chain_l1::HaltReason,
                     edr_chain_l1::Hardfork,
                     _,
                     edr_chain_l1::InvalidTransaction,
-                    edr_chain_l1::TxEnv,
+                    TxEnv,
                 >::new(
                     config.try_into()?,
                     contracts,

package/src/solidity_tests/op.rs

@@ -4,11 +4,14 @@ use edr_napi_core::solidity::{
     config::{TestRunnerConfig, TracingConfigWithBuffers},
     SyncTestRunner, SyncTestRunnerFactory,
 };
-use edr_op::solidity_tests::OpEvmBuilder;
+use edr_op::{solidity_tests::OpEvmBuilder, transaction::OpTxEnv};
 use edr_primitives::Bytes;
 use edr_solidity::artifacts::ArtifactId;
 use edr_solidity_tests::{
-    contracts::ContractsByArtifact, decode::RevertDecoder, multi_runner::TestContract,
+    contracts::ContractsByArtifact,
+    decode::RevertDecoder,
+    multi_runner::TestContract,
+    revm::context::{BlockEnv, TxEnv},
     MultiContractRunner,
 };
 use napi::tokio;
@@ -34,14 +37,14 @@ impl SyncTestRunnerFactory for OpTestRunnerFactory {
         let runner = tokio::task::block_in_place(|| {
             runtime
                 .block_on(MultiContractRunner::<
-                    edr_op::BlockEnv,
+                    BlockEnv,
                     _,
                     OpEvmBuilder,
                     edr_op::HaltReason,
                     edr_op::Hardfork,
                     _,
-                    edr_op::transaction::InvalidTransaction,
-                    edr_op::transaction::OpTxEnv<edr_chain_l1::TxEnv>,
+                    edr_op::InvalidTransaction,
+                    OpTxEnv<TxEnv>,
                 >::new(
                     config.try_into()?,
                     contracts,

package/src/solidity_tests/runner.rs

@@ -1,6 +1,6 @@
 use std::sync::{Mutex, OnceLock};
 
-use edr_evm_spec::HaltReasonTrait;
+use edr_chain_spec::HaltReasonTrait;
 use edr_napi_core::solidity::config::TracingConfigWithBuffers;
 use edr_solidity::{
     artifacts::BuildInfoConfigWithBuffers,

package/src/trace/exit.rs

@@ -3,7 +3,7 @@
 
 use std::fmt;
 
-use edr_evm_spec::EvmHaltReason;
+use edr_chain_spec::EvmHaltReason;
 use napi_derive::napi;
 
 #[napi]

package/src/trace.rs

@@ -7,9 +7,9 @@
 
 use std::sync::Arc;
 
-use edr_evm::trace::BeforeMessage;
-use edr_evm_spec::EvmHaltReason;
+use edr_chain_spec::EvmHaltReason;
 use edr_primitives::bytecode::opcode::OpCode;
+use edr_runtime::trace::BeforeMessage;
 use napi::bindgen_prelude::{BigInt, Either3, Uint8Array};
 use napi_derive::napi;
 
@@ -123,7 +123,7 @@ pub struct TracingStep {
 }
 
 impl TracingStep {
-    pub fn new(step: &edr_evm::trace::Step) -> Self {
+    pub fn new(step: &edr_runtime::trace::Step) -> Self {
         let stack = step.stack.full().map_or_else(
             || {
                 step.stack
@@ -162,11 +162,11 @@ pub struct TracingMessageResult {
 #[napi]
 #[derive(Clone)]
 pub struct RawTrace {
-    inner: Arc<edr_evm::trace::Trace<EvmHaltReason>>,
+    inner: Arc<edr_runtime::trace::Trace<EvmHaltReason>>,
 }
 
-impl From<Arc<edr_evm::trace::Trace<EvmHaltReason>>> for RawTrace {
-    fn from(value: Arc<edr_evm::trace::Trace<EvmHaltReason>>) -> Self {
+impl From<Arc<edr_runtime::trace::Trace<EvmHaltReason>>> for RawTrace {
+    fn from(value: Arc<edr_runtime::trace::Trace<EvmHaltReason>>) -> Self {
         Self { inner: value }
     }
 }
@@ -179,13 +179,15 @@ impl RawTrace {
             .messages
             .iter()
             .map(|message| match message {
-                edr_evm::trace::TraceMessage::Before(message) => {
+                edr_runtime::trace::TraceMessage::Before(message) => {
                     Either3::A(TracingMessage::from(message))
                 }
-                edr_evm::trace::TraceMessage::Step(step) => Either3::B(TracingStep::new(step)),
-                edr_evm::trace::TraceMessage::After(message) => Either3::C(TracingMessageResult {
-                    execution_result: ExecutionResult::from(message),
-                }),
+                edr_runtime::trace::TraceMessage::Step(step) => Either3::B(TracingStep::new(step)),
+                edr_runtime::trace::TraceMessage::After(message) => {
+                    Either3::C(TracingMessageResult {
+                        execution_result: ExecutionResult::from(message),
+                    })
+                }
             })
             .collect()
     }