private async Task Handle(SourceAddressLockedEvent evt, ICommandSender sender)
        {
            var aggregate = await _repository.GetAsync(evt.TransactionId);

            if (_stateSwitcher.Switch(aggregate, evt))
            {
                sender.SendCommand
                (
                    new BuildTransactionCommand
                {
                    OperationId       = aggregate.OperationId,
                    TransactionId     = aggregate.TransactionId,
                    TransactionNumber = aggregate.TransactionNumber,
                    BlockchainType    = aggregate.BlockchainType,
                    BlockchainAssetId = aggregate.BlockchainAssetId,
                    FromAddress       = aggregate.FromAddress,
                    Outputs           = aggregate.Outputs
                                        .Select(e => e.ToContract())
                                        .ToArray(),
                    IncludeFee = aggregate.IncludeFee
                },
                    Self
                );

                _chaosKitty.Meow(evt.TransactionId);

                await _repository.SaveAsync(aggregate);
            }
        }
        private async Task Handle(LockAcquiredEvent evt, ICommandSender sender)
        {
            var aggregate = await _repository.GetAsync(evt.TransactionId);

            aggregate.OnLockAcquired(DateTime.UtcNow);
            await _repository.SaveAsync(aggregate);

            _chaosKitty.Meow(aggregate.TransactionId);

            sender.SendCommand(new RetrieveAssetInfoCommand
            {
                NeoAssetId    = aggregate.NeoAssetId,
                GasAssetId    = aggregate.GasAssetId,
                TransactionId = aggregate.TransactionId
            }, Self);
        }