diff --git a/CoreStoreTests/BridgingTests.m b/CoreStoreTests/BridgingTests.m
index 886bc40..04c2efa 100644
--- a/CoreStoreTests/BridgingTests.m
+++ b/CoreStoreTests/BridgingTests.m
@@ -197,4 +197,41 @@
     XCTAssertNil(sqliteError);
 }
 
+- (void)test_ThatTransactions_BridgeCorrectly {
+    
+    [CSCoreStore
+     setDefaultStack:[[CSDataStack alloc]
+                      initWithModelName:@"Model"
+                      bundle:[NSBundle bundleForClass:[self class]]
+                      versionChain:nil]];
+    [CSCoreStore
+     addInMemoryStorageAndWait:[CSInMemoryStore new]
+     error:nil];
+    
+    {
+        CSUnsafeDataTransaction *transaction = [CSCoreStore beginUnsafe];
+        XCTAssertNotNil(transaction);
+        XCTAssert([transaction isKindOfClass:[CSUnsafeDataTransaction class]]);
+    }
+    {
+        XCTestExpectation *expectation = [self expectationWithDescription:@"sync"];
+        [CSCoreStore beginSynchronous:^(CSSynchronousDataTransaction * _Nonnull transaction) {
+            
+            XCTAssertNotNil(transaction);
+            XCTAssert([transaction isKindOfClass:[CSSynchronousDataTransaction class]]);
+            [expectation fulfill];
+        }];
+    }
+    {
+        XCTestExpectation *expectation = [self expectationWithDescription:@"async"];
+        [CSCoreStore beginAsynchronous:^(CSAsynchronousDataTransaction * _Nonnull transaction) {
+            
+            XCTAssertNotNil(transaction);
+            XCTAssert([transaction isKindOfClass:[CSAsynchronousDataTransaction class]]);
+            [expectation fulfill];
+        }];
+    }
+    [self waitForExpectationsWithTimeout:10 handler:nil];
+}
+
 @end
diff --git a/Sources/ObjectiveC/CSAsynchronousDataTransaction.swift b/Sources/ObjectiveC/CSAsynchronousDataTransaction.swift
index f31609d..bcd0e8f 100644
--- a/Sources/ObjectiveC/CSAsynchronousDataTransaction.swift
+++ b/Sources/ObjectiveC/CSAsynchronousDataTransaction.swift
@@ -144,7 +144,7 @@ public final class CSAsynchronousDataTransaction: CSBaseDataTransaction {
     
     // MARK: CoreStoreObjectiveCType
     
-    internal typealias SwiftType = AsynchronousDataTransaction
+    public typealias SwiftType = AsynchronousDataTransaction
     
     public override var bridgeToSwift: AsynchronousDataTransaction {
         
@@ -153,21 +153,21 @@ public final class CSAsynchronousDataTransaction: CSBaseDataTransaction {
     
     public required init(_ swiftValue: AsynchronousDataTransaction) {
         
-        super.init(swiftValue)
+        super.init(swiftValue as BaseDataTransaction)
     }
     
     public required init(_ swiftValue: BaseDataTransaction) {
         
-        fatalError("init(_:) requires an AsynchronousDataTransaction instance")
+        super.init(swiftValue as! AsynchronousDataTransaction)
     }
 }
 
 
 // MARK: - AsynchronousDataTransaction
 
-extension AsynchronousDataTransaction {
+extension AsynchronousDataTransaction: CoreStoreSwiftType {
     
     // MARK: CoreStoreSwiftType
     
-    internal typealias ObjectiveCType = CSAsynchronousDataTransaction
+    public typealias ObjectiveCType = CSAsynchronousDataTransaction
 }
diff --git a/Sources/ObjectiveC/CSBaseDataTransaction.swift b/Sources/ObjectiveC/CSBaseDataTransaction.swift
index 2362ab2..d86a583 100644
--- a/Sources/ObjectiveC/CSBaseDataTransaction.swift
+++ b/Sources/ObjectiveC/CSBaseDataTransaction.swift
@@ -292,8 +292,6 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
     
     // MARK: CoreStoreObjectiveCType
     
-    public typealias SwiftType = BaseDataTransaction
-    
     public required init(_ swiftValue: BaseDataTransaction) {
         
         self.swiftTransaction = swiftValue
@@ -312,11 +310,11 @@ public class CSBaseDataTransaction: NSObject, CoreStoreObjectiveCType {
 }
 
 
-// MARK: - BaseDataTransaction
-
-extension BaseDataTransaction: CoreStoreSwiftType {
-    
-    // MARK: CoreStoreSwiftType
-    
-    public typealias ObjectiveCType = CSBaseDataTransaction
-}
+//// MARK: - BaseDataTransaction
+//
+//extension BaseDataTransaction: CoreStoreSwiftType {
+//    
+//    // MARK: CoreStoreSwiftType
+//    
+//    public typealias ObjectiveCType = CSBaseDataTransaction
+//}
diff --git a/Sources/ObjectiveC/CSSynchronousDataTransaction.swift b/Sources/ObjectiveC/CSSynchronousDataTransaction.swift
index 166e75f..9403294 100644
--- a/Sources/ObjectiveC/CSSynchronousDataTransaction.swift
+++ b/Sources/ObjectiveC/CSSynchronousDataTransaction.swift
@@ -143,7 +143,7 @@ public final class CSSynchronousDataTransaction: CSBaseDataTransaction {
     
     // MARK: CoreStoreObjectiveCType
     
-    internal typealias SwiftType = SynchronousDataTransaction
+    public typealias SwiftType = SynchronousDataTransaction
     
     public override var bridgeToSwift: SynchronousDataTransaction {
         
@@ -152,21 +152,21 @@ public final class CSSynchronousDataTransaction: CSBaseDataTransaction {
     
     public required init(_ swiftValue: SynchronousDataTransaction) {
         
-        super.init(swiftValue)
+        super.init(swiftValue as BaseDataTransaction)
     }
     
     public required init(_ swiftValue: BaseDataTransaction) {
         
-        fatalError("init(_:) requires a BaseDataTransaction instance")
+        super.init(swiftValue as! SynchronousDataTransaction)
     }
 }
 
 
 // MARK: - SynchronousDataTransaction
 
-extension SynchronousDataTransaction {
+extension SynchronousDataTransaction: CoreStoreSwiftType {
     
     // MARK: CoreStoreSwiftType
     
-    internal typealias ObjectiveCType = CSSynchronousDataTransaction
+    public typealias ObjectiveCType = CSSynchronousDataTransaction
 }
diff --git a/Sources/ObjectiveC/CSUnsafeDataTransaction.swift b/Sources/ObjectiveC/CSUnsafeDataTransaction.swift
index 53d7ee8..57769c4 100644
--- a/Sources/ObjectiveC/CSUnsafeDataTransaction.swift
+++ b/Sources/ObjectiveC/CSUnsafeDataTransaction.swift
@@ -174,7 +174,7 @@ public final class CSUnsafeDataTransaction: CSBaseDataTransaction {
     
     // MARK: CoreStoreObjectiveCType
     
-    internal typealias SwiftType = UnsafeDataTransaction
+    public typealias SwiftType = UnsafeDataTransaction
     
     public override var bridgeToSwift: UnsafeDataTransaction {
         
@@ -183,21 +183,21 @@ public final class CSUnsafeDataTransaction: CSBaseDataTransaction {
     
     public required init(_ swiftValue: UnsafeDataTransaction) {
         
-        super.init(swiftValue)
+        super.init(swiftValue as BaseDataTransaction)
     }
     
     public required init(_ swiftValue: BaseDataTransaction) {
         
-        fatalError("init(_:) requires an UnsafeDataTransaction instance")
+        super.init(swiftValue as! UnsafeDataTransaction)
     }
 }
 
 
 // MARK: - UnsafeDataTransaction
 
-extension UnsafeDataTransaction {
+extension UnsafeDataTransaction: CoreStoreSwiftType {
     
     // MARK: CoreStoreSwiftType
     
-    internal typealias ObjectiveCType = CSUnsafeDataTransaction
+    public typealias ObjectiveCType = CSUnsafeDataTransaction
 }
diff --git a/Sources/ObjectiveC/CoreStoreBridge.swift b/Sources/ObjectiveC/CoreStoreBridge.swift
index bcc2aa6..fbb270c 100644
--- a/Sources/ObjectiveC/CoreStoreBridge.swift
+++ b/Sources/ObjectiveC/CoreStoreBridge.swift
@@ -118,12 +118,18 @@ internal func bridge<T: CoreStoreSwiftType>(error: NSErrorPointer, @noescape _ c
     do {
         
         let result = try closure()
-        error.memory = nil
+        if error != nil {
+            
+            error.memory = nil
+        }
         return result.bridgeToObjectiveC
     }
     catch let swiftError {
         
-        error.memory = swiftError.bridgeToObjectiveC
+        if error != nil {
+            
+            error.memory = swiftError.bridgeToObjectiveC
+        }
         return nil
     }
 }
@@ -133,12 +139,18 @@ internal func bridge(error: NSErrorPointer, @noescape _ closure: () throws -> Vo
     do {
         
         try closure()
-        error.memory = nil
+        if error != nil {
+            
+            error.memory = nil
+        }
         return true
     }
     catch let swiftError {
         
-        error.memory = swiftError.bridgeToObjectiveC
+        if error != nil {
+            
+            error.memory = swiftError.bridgeToObjectiveC
+        }
         return false
     }
 }
@@ -148,12 +160,18 @@ internal func bridge<T>(error: NSErrorPointer, @noescape _ closure: () throws ->
     do {
         
         let result = try closure()
-        error.memory = nil
+        if error != nil {
+            
+            error.memory = nil
+        }
         return result
     }
     catch let swiftError {
         
-        error.memory = swiftError.bridgeToObjectiveC
+        if error != nil {
+            
+            error.memory = swiftError.bridgeToObjectiveC
+        }
         return nil
     }
 }
@@ -163,12 +181,18 @@ internal func bridge<T: CoreStoreSwiftType>(error: NSErrorPointer, @noescape _ c
     do {
         
         let result = try closure()
-        error.memory = nil
+        if error != nil {
+            
+            error.memory = nil
+        }
         return result.map { $0.bridgeToObjectiveC }
     }
     catch let swiftError {
         
-        error.memory = swiftError.bridgeToObjectiveC
+        if error != nil {
+            
+            error.memory = swiftError.bridgeToObjectiveC
+        }
         return nil
     }
 }