 
                 print ("SYS: Event: Transfer (\(wallet.name) @ \(transfer.hash?.description ?? "pending")): \(event.type)")
 
+                var transferEvent: TransferEvent? = nil
+
                 switch (event.type) {
                 case CRYPTO_TRANSFER_EVENT_CREATED:
-                    system.listener?.handleTransferEvent (system: manager.system,
-                                                            manager: manager,
-                                                            wallet: wallet,
-                                                            transfer: transfer,
-                                                            event: TransferEvent.created)
+                    transferEvent = TransferEvent.created
 
                 case CRYPTO_TRANSFER_EVENT_CHANGED:
-                    system.listener?.handleTransferEvent (system: manager.system,
-                                                            manager: manager,
-                                                            wallet: wallet,
-                                                            transfer: transfer,
-                                                            event: TransferEvent.changed (old: TransferState.init (core: event.u.state.old),
-                                                                                          new: TransferState.init (core: event.u.state.new)))
+                    transferEvent = TransferEvent.changed (old: TransferState.init (core: event.u.state.old),
+                                                           new: TransferState.init (core: event.u.state.new))
 
                 case CRYPTO_TRANSFER_EVENT_DELETED:
-                    system.listener?.handleTransferEvent (system: manager.system,
-                                                            manager: manager,
-                                                            wallet: wallet,
-                                                            transfer: transfer,
-                                                            event: TransferEvent.deleted)
+                    transferEvent = TransferEvent.deleted
+
                 default: precondition(false)
+                }
+
+                transferEvent.map { (event) in
+                    system.listenerQueue.async {
+                        system.listener?.handleTransferEvent (system: system,
+                                                              manager: manager,
+                                                              wallet: wallet,
+                                                              transfer: transfer,
+                                                              event: event)
+                    }
                 }
         })
     }

///
/// A SystemListener recieves asynchronous events announcing state changes to Networks, to Managers,
/// to Wallets and to Transfers.  This is an application's sole mechanism to learn of asynchronous
/// state changes.
///
/// Note: This must be 'class bound' as System holds a 'weak' reference (for GC reasons).
///

    public var wallets: [Wallet] {
        return managers.flatMap { $0.wallets }
    }

    ///
    /// Initialize System
    ///
    /// - Parameters:
    ///   - listener: The listener for handlng events.
    ///
    ///   - account: The account, derived from the `paperKey`, that will be used for all networks.
    ///
    ///   - onMainnet: boolean to indicate if this is for mainnet or for testnet.  As blockchains
    ///       are announced, we'll filter them to be for mainent or testnet.
    ///
    ///   - path: The path to use for persistent storage of data, such as for BTC and ETH blocks,
    ///       peers, transaction and logs.
    ///
    ///   - query: The query for BlockchiainDB interaction.
    ///
    ///   - listenerQueue: The queue to use when performing listen event handler callbacks.  If a
    ///       queue is not specficied (default to `nil`), then one will be provided.
    ///
    public init (listener: SystemListener,
                 account: Account,
                 onMainnet: Bool,
                 path: String,
                 query: BlockChainDB,
                 listenerQueue: DispatchQueue? = nil) {
        self.listener  = listener
        self.account   = account
        self.onMainnet = onMainnet
        self.path  = path
        self.query = query
        self.callbackCoordinator = SystemCallbackCoordinator()
        self.listenerQueue = listenerQueue ?? DispatchQueue (label: "Crypto System Listener")

        let _ = System.systemExtend(with: self)
        announceEvent(SystemEvent.created)
    }

    internal func announceEvent (_ event: SystemEvent) {
        self.listenerQueue.async {
            self.listener?.handleSystemEvent (system: self,
                                              event: event)
        }
    }

    ///
