private async Task Handle(TransactionExecutionStartedEvent evt, ICommandSender sender)
        {
            var aggregate = await _repository.GetOrAddAsync(
                evt.TransactionId,
                () => TransactionExecutionAggregate.Start(
                    evt.OperationId,
                    evt.TransactionId,
                    evt.TransactionNumber,
                    evt.FromAddress,
                    evt.Outputs
                    .Select(e => e.ToDomain())
                    .ToArray(),
                    evt.BlockchainType,
                    evt.BlockchainAssetId,
                    evt.AssetId,
                    evt.IncludeFee));

            _chaosKitty.Meow(evt.TransactionId);

            if (aggregate.State == TransactionExecutionState.Started)
            {
                sender.SendCommand
                (
                    new LockSourceAddressCommand
                {
                    OperationId    = aggregate.OperationId,
                    TransactionId  = aggregate.TransactionId,
                    BlockchainType = aggregate.BlockchainType,
                    FromAddress    = aggregate.FromAddress
                },
                    Self
                );
            }
        }
        private async Task Handle(TransactionStartedtEvent evt, ICommandSender sender)
        {
            var aggregate = await _repository.GetOrAddAsync(evt.TransactionId,
                                                            () => TransactionExecutionAggregate.StartNew(evt.TransactionId, evt.Address, evt.NeoAssetId, evt.GasAssetId));

            _chaosKitty.Meow(aggregate.TransactionId);

            sender.SendCommand(new AcquireLockCommand
            {
                TransactionId = aggregate.TransactionId
            }, Self);
        }