 					}
 					semaphore.signal()
 				}
-				receipt.transferDisposable += { progress?.cancel() }
+				receipt.disposable += { progress?.cancel() }
 				receipt.eventObserver.observe(.transferStarted(resourceRequest, peer, progress))
 				semaphore.wait()
 			}
-			receipt.transferDisposable += { item.cancel() }
+			receipt.disposable += { item.cancel() }
 			transferQueue.async(execute: item)
 		}
 

extension ResourceRequestReceipt: ResourceEventProducerProtocol {
	public func addEventObserver(on queue: DispatchQueue, action: @escaping (ResourceEvent<Request>) -> Void) -> Disposable {
		let observer = DispatchObserver(queue: queue, action: action)
		return eventObserver.add(observer)
	}
}

extension ResourceRequestReceipt: Disposable {
	public var isDisposed: Bool {
		return transferDisposable.isDisposed
	}

	public func dispose() {
		transferDisposable.dispose()
	}
}


	public let request: Request
	public let peers: [Peer]

	fileprivate let disposable = CompositeDisposable()
	fileprivate let eventObserver = CompositeObserver<Event>()

	fileprivate init(request: Request, peers: [Peer]) {
