private static void ReceivedMessage()
        {
            var factory = new global::RabbitMQ.Client.ConnectionFactory()
            {
                HostName = "localhost"
            };

            using (var connection = factory.CreateConnection())
                using (var channel = connection.CreateModel())
                {
                    channel.QueueDeclare(queue: "JamesQueue",
                                         durable: true,
                                         exclusive: false,
                                         autoDelete: false,
                                         arguments: null);

                    var consumer = new global::RabbitMQ.Client.Events.EventingBasicConsumer(channel);
                    consumer.Received += (model, ea) =>
                    {
                        var body = ea.Body;

                        var message = global::System.Text.Encoding.UTF8.GetString(body);
                        global::System.Console.WriteLine(" [x] Received {0}", message);
                    };
                    channel.BasicConsume(queue: "JamesQueue", autoAck: true, consumer: consumer);

                    global::System.Console.WriteLine(" Press [enter] to exit.");
                    global::System.Console.ReadLine();
                }
        }
        protected override void Load(ContainerBuilder builder)
        {
            Lykke.Messaging.Serialization.MessagePackSerializerFactory.Defaults.FormatterResolver = MessagePack.Resolvers.ContractlessStandardResolver.Instance;
            var rabbitMqSagasSettings = new global::RabbitMQ.Client.ConnectionFactory {
                Uri = _settings.CurrentValue.EthereumCore.Cqrs.RabbitConnectionString
            };

            builder.Register(context => new AutofacDependencyResolver(context)).As <IDependencyResolver>();

            var messagingEngine = new MessagingEngine(_log,
                                                      new TransportResolver(new Dictionary <string, TransportInfo>
            {
                { "SagasRabbitMq", new TransportInfo(rabbitMqSagasSettings.Endpoint.ToString(), rabbitMqSagasSettings.UserName, rabbitMqSagasSettings.Password, "None", "RabbitMq") }
            }),
                                                      new RabbitMqTransportFactory());

            var sagasEndpointResolver = new RabbitMqConventionEndpointResolver(
                "SagasRabbitMq",
                "messagepack",
                environment: "lykke",
                exclusiveQueuePostfix: "k8s");

            builder.Register(ctx =>
            {
                const string defaultRoute = "self";

                return(new CqrsEngine(_log,
                                      ctx.Resolve <IDependencyResolver>(),
                                      messagingEngine,
                                      new DefaultEndpointProvider(),
                                      true,
                                      Register.DefaultEndpointResolver(sagasEndpointResolver),
                                      Register.BoundedContext("blockchain.ethereum.core.api")
                                      .PublishingCommands(typeof(AssignErc223DepositToUserCommand))
                                      .To(EthereumBoundedContext.Name)
                                      .With(defaultRoute)));
            })
            .As <ICqrsEngine>()
            .SingleInstance()
            .AutoActivate();
        }