 
             var bytes = blob.bytes
             let status = cryptoWalletMigratorHandleTransactionAsBTC (migrator,
-                                                                &bytes, bytes.count,
-                                                                blob.blockHeight,
-                                                                blob.timestamp)
+                                                                     &bytes, bytes.count,
+                                                                     blob.blockHeight,
+                                                                     blob.timestamp)
             if status.type != CRYPTO_WALLET_MIGRATOR_SUCCESS {
                 throw MigrateError.transaction
             }

            else { return nil }

        switch network.currency.code.lowercased() {
            case Currency.codeAsBTC,
                 Currency.codeAsBCH:
                var blockHeight: UInt32 = 0
                var timestamp:   UInt32 = 0
                var bytesCount:  size_t = 0
                var bytes: UnsafeMutablePointer<UInt8>? = nil
                defer { if nil != bytes { free(bytes) }}

                cryptoTransferExtractBlobAsBTC (transfer.core,
                                                &bytes, &bytesCount,
                                                &blockHeight,
                                                &timestamp)

                return TransactionBlob.btc (bytes: UnsafeMutableBufferPointer<UInt8> (start: bytes, count: bytesCount).map { $0 },
                                             blockHeight: blockHeight,
                                             timestamp: timestamp)
        default:
            return nil
        }

            try hashes.withUnsafeMutableBytes { (hashesBytes: UnsafeMutableRawBufferPointer) -> Void in
                let hashesAddr = hashesBytes.baseAddress?.assumingMemoryBound(to: UInt256.self)
                let status = cryptoWalletMigratorHandleBlockAsBTC (migrator,
                                                                   blob.height,
                                                                   blob.nonce,
                                                                   blob.target,
                                                                   blob.txCount,
                                                                   blob.version,
                                                                   blob.timestamp!,
                                                                   &flags, flags.count,
                                                                   hashesAddr, hashesCount,
                                                                   merkleRoot,
                                                                   prevBlock)
                if status.type != CRYPTO_WALLET_MIGRATOR_SUCCESS {
                    throw MigrateError.block
                }
            }
        }

        try peerBlobs.forEach { (blob: PeerBlob) in
            guard case let .btc (blob) = blob
                else { throw MigrateError.peer }

            // On a `nil` timestamp, by definition skip out, don't migrate this blob
            guard nil != blob.timestamp
                else { return }

            let status = cryptoWalletMigratorHandlePeerAsBTC (migrator,
                                                              blob.address,
                                                              blob.port,
                                                              blob.services,
                                                              blob.timestamp!)

            if status.type != CRYPTO_WALLET_MIGRATOR_SUCCESS {
                throw MigrateError.peer
            }
