react-native-zcash 0.6.13 → 0.7.0

package/ios/ZCashLightClientKit/Synchronizer.swift

@@ -35,10 +35,8 @@ public struct SynchronizerState: Equatable {
     /// given how application lifecycle varies between OS Versions, platforms, etc.
     /// SyncSessionIDs are provided to users
     public var syncSessionID: UUID
-    /// shielded balance known to this synchronizer given the data that has processed locally
-    public var shieldedBalance: WalletBalance
-    /// transparent balance known to this synchronizer given the data that has processed locally
-    public var transparentBalance: WalletBalance
+    /// account balance known to this synchronizer given the data that has processed locally
+    public var accountBalance: AccountBalance?
     /// status of the whole sync process
     var internalSyncStatus: InternalSyncStatus
     public var syncStatus: SyncStatus
@@ -49,8 +47,7 @@ public struct SynchronizerState: Equatable {
     public static var zero: SynchronizerState {
         SynchronizerState(
             syncSessionID: .nullID,
-            shieldedBalance: .zero,
-            transparentBalance: .zero,
+            accountBalance: .zero,
             internalSyncStatus: .unprepared,
             latestBlockHeight: .zero
         )
@@ -58,14 +55,12 @@ public struct SynchronizerState: Equatable {
     
     init(
         syncSessionID: UUID,
-        shieldedBalance: WalletBalance,
-        transparentBalance: WalletBalance,
+        accountBalance: AccountBalance?,
         internalSyncStatus: InternalSyncStatus,
         latestBlockHeight: BlockHeight
     ) {
         self.syncSessionID = syncSessionID
-        self.shieldedBalance = shieldedBalance
-        self.transparentBalance = transparentBalance
+        self.accountBalance = accountBalance
         self.internalSyncStatus = internalSyncStatus
         self.latestBlockHeight = latestBlockHeight
         self.syncStatus = internalSyncStatus.mapToSyncStatus()
@@ -106,9 +101,6 @@ public protocol Synchronizer: AnyObject {
     /// This stream is backed by `PassthroughSubject`. Check `SynchronizerEvent` to see which events may be emitted.
     var eventStream: AnyPublisher<SynchronizerEvent, Never> { get }
 
-    /// An object that when enabled collects mertrics from the synchronizer
-    var metrics: SDKMetrics { get }
-
     /// Initialize the wallet. The ZIP-32 seed bytes can optionally be passed to perform
     /// database migrations. most of the times the seed won't be needed. If they do and are
     /// not provided this will fail with `InitializationResult.seedRequired`. It could
@@ -162,15 +154,70 @@ public protocol Synchronizer: AnyObject {
     /// - Parameter accountIndex: the optional accountId whose address is of interest. By default, the first account is used.
     /// - Returns the address or nil if account index is incorrect
     func getTransparentAddress(accountIndex: Int) async throws -> TransparentAddress
-    
+
+    /// Creates a proposal for transferring funds to the given recipient.
+    ///
+    /// - Parameter accountIndex: the account from which to transfer funds.
+    /// - Parameter recipient: the recipient's address.
+    /// - Parameter amount: the amount to send in Zatoshi.
+    /// - Parameter memo: an optional memo to include as part of the proposal's transactions. Use `nil` when sending to transparent receivers otherwise the function will throw an error.
+    ///
+    /// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
+    /// `SynchronizerErrors.notPrepared`.
+    func proposeTransfer(
+        accountIndex: Int,
+        recipient: Recipient,
+        amount: Zatoshi,
+        memo: Memo?
+    ) async throws -> Proposal
+
+    /// Creates a proposal for shielding any transparent funds received by the given account.
+    ///
+    /// - Parameter accountIndex: the account for which to shield funds.
+    /// - Parameter shieldingThreshold: the minimum transparent balance required before a proposal will be created.
+    /// - Parameter memo: an optional memo to include as part of the proposal's transactions.
+    /// - Parameter transparentReceiver: a specific transparent receiver within the account
+    ///             that should be the source of transparent funds. Default is `nil` which
+    ///             will select whichever of the account's transparent receivers has funds
+    ///             to shield.
+    ///
+    /// Returns the proposal, or `nil` if the transparent balance that would be shielded
+    /// is zero or below `shieldingThreshold`.
+    ///
+    /// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
+    /// `SynchronizerErrors.notPrepared`.
+    func proposeShielding(
+        accountIndex: Int,
+        shieldingThreshold: Zatoshi,
+        memo: Memo,
+        transparentReceiver: TransparentAddress?
+    ) async throws -> Proposal?
+
+    /// Creates the transactions in the given proposal.
+    ///
+    /// - Parameter proposal: the proposal for which to create transactions.
+    /// - Parameter spendingKey: the `UnifiedSpendingKey` associated with the account for which the proposal was created.
+    ///
+    /// Returns a stream of objects for the transactions that were created as part of the
+    /// proposal, indicating whether they were submitted to the network or if an error
+    /// occurred.
+    ///
+    /// If `prepare()` hasn't already been called since creation of the synchronizer instance
+    /// or since the last wipe then this method throws `SynchronizerErrors.notPrepared`.
+    func createProposedTransactions(
+        proposal: Proposal,
+        spendingKey: UnifiedSpendingKey
+    ) async throws -> AsyncThrowingStream<TransactionSubmitResult, Error>
+
     /// Sends zatoshi.
     /// - Parameter spendingKey: the `UnifiedSpendingKey` that allows spends to occur.
     /// - Parameter zatoshi: the amount to send in Zatoshi.
     /// - Parameter toAddress: the recipient's address.
     /// - Parameter memo: an `Optional<Memo>`with the memo to include as part of the transaction. send `nil` when sending to transparent receivers otherwise the function will throw an error
     ///
-    /// If `prepare()` hasn't already been called since creating of synchronizer instance or since the last wipe then this method throws
+    /// - NOTE: If `prepare()` hasn't already been called since creating of synchronizer instance or since the last wipe then this method throws
     /// `SynchronizerErrors.notPrepared`.
+    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
     func sendToAddress(
         spendingKey: UnifiedSpendingKey,
         zatoshi: Zatoshi,
@@ -178,12 +225,25 @@ public protocol Synchronizer: AnyObject {
         memo: Memo?
     ) async throws -> ZcashTransaction.Overview
 
+    /// Attempts to propose fulfilling a [ZIP-321](https://zips.z.cash/zip-0321) payment URI using the given `accountIndex`
+    ///  - Parameter uri: a valid ZIP-321 payment URI
+    ///  - Parameter accountIndex: the account index that allows spends to occur.
+    ///
+    /// - NOTE: If `prepare()` hasn't already been called since creating of synchronizer instance or since the last wipe then this method throws
+    /// `SynchronizerErrors.notPrepared`.
+    func proposefulfillingPaymentURI(
+        _ uri: String,
+        accountIndex: Int
+    ) async throws -> Proposal
+
     /// Shields transparent funds from the given private key into the best shielded pool of the account associated to the given `UnifiedSpendingKey`.
     /// - Parameter spendingKey: the `UnifiedSpendingKey` that allows to spend transparent funds
     /// - Parameter memo: the optional memo to include as part of the transaction.
+    /// - Parameter shieldingThreshold: the minimum transparent balance required before a transaction will be created.
     ///
-    /// If `prepare()` hasn't already been called since creating of synchronizer instance or since the last wipe then this method throws
+    /// - Note: If `prepare()` hasn't already been called since creating of synchronizer instance or since the last wipe then this method throws
     /// `SynchronizerErrors.notPrepared`.
+    @available(*, deprecated, message: "Upcoming SDK 2.1 will create multiple transactions at once for some recipients.")
     func shieldFunds(
         spendingKey: UnifiedSpendingKey,
         memo: Memo,
@@ -235,22 +295,14 @@ public protocol Synchronizer: AnyObject {
 
     /// Returns the latests UTXOs for the given address from the specified height on
     ///
-    /// If `prepare()` hasn't already been called since creating of synchronizer instance or since the last wipe then this method throws
+    /// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
     /// `SynchronizerErrors.notPrepared`.
     func refreshUTXOs(address: TransparentAddress, from height: BlockHeight) async throws -> RefreshedUTXOs
 
-    /// Returns the last stored transparent balance
-    func getTransparentBalance(accountIndex: Int) async throws -> WalletBalance
-
-    /// get (unverified) balance from the given account index
+    /// Account balances from the given account index
     /// - Parameter accountIndex: the index of the account
-    /// - Returns: balance in `Zatoshi`
-    func getShieldedBalance(accountIndex: Int) async throws -> Zatoshi
-
-    /// get verified balance from the given account index
-    /// - Parameter accountIndex: the index of the account
-    /// - Returns: balance in `Zatoshi`
-    func getShieldedVerifiedBalance(accountIndex: Int) async throws -> Zatoshi
+    /// - Returns: `AccountBalance`, struct that holds sapling and unshielded balances or `nil` when no account is associated with `accountIndex`
+    func getAccountBalance(accountIndex: Int) async throws -> AccountBalance?
 
     /// Rescans the known blocks with the current keys.
     ///
@@ -267,7 +319,7 @@ public protocol Synchronizer: AnyObject {
     /// `rewind(policy:)` itself doesn't start the sync process when it's done and it doesn't trigger notifications as regorg would. After it is done
     /// you have start the sync process by calling `start()`
     ///
-    /// If `prepare()` hasn't already been called since creating of synchronizer instance or since the last wipe then returned publisher emits
+    /// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then returned publisher emits
     /// `SynchronizerErrors.notPrepared` error.
     ///
     /// - Parameter policy: the rewind policy
@@ -293,6 +345,17 @@ public protocol Synchronizer: AnyObject {
     /// this happens it means that some path passed to `Initializer` is invalid. The SDK can't recover from this and this instance won't do anything.
     /// 
     func wipe() -> AnyPublisher<Void, Error>
+    
+    /// This API stops the synchronization and re-initalizes everything according to the new endpoint provided.
+    /// It can be called anytime.
+    /// - Throws: ZcashError when failures occur and related to `synchronizer.start(retry: Bool)`, it's the only throwing operation
+    /// during the whole endpoint change.
+    func switchTo(endpoint: LightWalletEndpoint) async throws
+
+    /// Checks whether the given seed is relevant to any of the derived accounts in the wallet.
+    ///
+    /// - parameter seed: byte array of the seed
+    func isSeedRelevantToAnyDerivedAccount(seed: [UInt8]) async throws -> Bool
 }
 
 public enum SyncStatus: Equatable {
@@ -443,6 +506,19 @@ public enum RewindPolicy {
     case quick
 }
 
+/// The result of submitting a transaction to the network.
+///
+/// - success: the transaction was successfully submitted to the mempool.
+/// - grpcFailure: the transaction failed to reach the lightwalletd server.
+/// - submitFailure: the transaction reached the lightwalletd server but failed to enter the mempool.
+/// - notAttempted: the transaction was created and is in the local wallet, but was not submitted to the network.
+public enum TransactionSubmitResult: Equatable {
+    case success(txId: Data)
+    case grpcFailure(txId: Data, error: LightWalletServiceError)
+    case submitFailure(txId: Data, code: Int, description: String)
+    case notAttempted(txId: Data)
+}
+
 extension InternalSyncStatus {
     public static func == (lhs: InternalSyncStatus, rhs: InternalSyncStatus) -> Bool {
         switch (lhs, rhs) {

package/ios/ZCashLightClientKit/Transaction/TransactionEncoder.swift

@@ -2,7 +2,7 @@
 //  TransactionEncoder.swift
 //  ZcashLightClientKit
 //
-//  Created by Francisco Gindre on 11/20/19.
+//  Created by Francisco Gindre on 2019-11-20.
 //
 
 import Foundation
@@ -19,44 +19,73 @@ public enum TransactionEncoderError: Error {
 }
 
 protocol TransactionEncoder {
-    /// Creates a transaction, throwing an exception whenever things are missing. When the provided wallet implementation
-    /// doesn't throw an exception, we wrap the issue into a descriptive exception ourselves (rather than using
-    /// double-bangs for things).
+    /// Creates a proposal for transferring funds to the given recipient.
     ///
-    /// - Parameters:
-    /// - Parameter spendingKey: a `UnifiedSpendingKey` containing the spending key
-    /// - Parameter zatoshi: the amount to send in `Zatoshi`
-    /// - Parameter to: string containing the recipient address
-    /// - Parameter MemoBytes: string containing the memo (optional)
-    /// - Parameter accountIndex: index of the account that will be used to send the funds
+    /// - Parameter accountIndex: the account from which to transfer funds.
+    /// - Parameter recipient: string containing the recipient's address.
+    /// - Parameter amount: the amount to send in Zatoshi.
+    /// - Parameter memoBytes: an optional memo to include as part of the proposal's transactions. Use `nil` when sending to transparent receivers otherwise the function will throw an error.
+    ///
+    /// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
+    /// `SynchronizerErrors.notPrepared`.
+    func proposeTransfer(
+        accountIndex: Int,
+        recipient: String,
+        amount: Zatoshi,
+        memoBytes: MemoBytes?
+    ) async throws -> Proposal
+
+    /// Creates a proposal for shielding any transparent funds received by the given account.
+    ///
+    /// - Parameter accountIndex: the account for which to shield funds.
+    /// - Parameter shieldingThreshold: the minimum transparent balance required before a proposal will be created.
+    /// - Parameter memoBytes: an optional memo to include as part of the proposal's transactions.
+    /// - Parameter transparentReceiver: a specific transparent receiver within the account
+    ///             that should be the source of transparent funds. Default is `nil` which
+    ///             will select whichever of the account's transparent receivers has funds
+    ///             to shield.
+    ///
+    /// Returns the proposal, or `nil` if the transparent balance that would be shielded
+    /// is zero or below `shieldingThreshold`.
+    ///
+    /// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
+    /// `SynchronizerErrors.notPrepared`.
+    func proposeShielding(
+        accountIndex: Int,
+        shieldingThreshold: Zatoshi,
+        memoBytes: MemoBytes?,
+        transparentReceiver: String?
+    ) async throws -> Proposal?
+
+    /// Creates the transactions in the given proposal.
+    ///
+    /// - Parameter proposal: the proposal for which to create transactions.
+    /// - Parameter spendingKey: the `UnifiedSpendingKey` associated with the account for which the proposal was created.
     /// - Throws:
     ///     - `walletTransEncoderCreateTransactionMissingSaplingParams` if the sapling parameters aren't downloaded.
-    ///     - Some `ZcashError.rust*` if the creation of transaction fails.
-    func createTransaction(
-        spendingKey: UnifiedSpendingKey,
-        zatoshi: Zatoshi,
-        to address: String,
-        memoBytes: MemoBytes?,
-        from accountIndex: Int
-    ) async throws -> ZcashTransaction.Overview
-    
-    /// Creates a transaction that will attempt to shield transparent funds that are present on the blocks cache .throwing
-    /// an exception whenever things are missing. When the provided wallet implementation doesn't throw an exception,
-    /// we wrap the issue into a descriptive exception ourselves (rather than using double-bangs for things).
+    ///     - Some `ZcashError.rust*` if the creation of transaction(s) fails.
+    ///
+    /// If `prepare()` hasn't already been called since creation of the synchronizer instance or since the last wipe then this method throws
+    /// `SynchronizerErrors.notPrepared`.
+    func createProposedTransactions(
+        proposal: Proposal,
+        spendingKey: UnifiedSpendingKey
+    ) async throws -> [ZcashTransaction.Overview]
+
+    /// Creates a transaction proposal to fulfill a [ZIP-321](https://zips.z.cash/zip-0321), throwing an exception whenever things are missing. When the provided wallet implementation
+    /// doesn't throw an exception, we wrap the issue into a descriptive exception ourselves (rather than using
+    /// double-bangs for things).
     ///
     /// - Parameters:
-    /// - Parameter spendingKey: `UnifiedSpendingKey` to spend the UTXOs
-    /// - Parameter memoBytes: containing the memo (optional)
-    /// - Parameter accountIndex: index of the account that will be used to send the funds
+    /// - Parameter uri: a valid ZIP-321 payment URI.
+    /// - Parameter accountIndex: the index of the account the proposal should be made from.
     /// - Throws:
-    ///     - `walletTransEncoderShieldFundsMissingSaplingParams` if the sapling parameters aren't downloaded.
+    ///     - `walletTransEncoderCreateTransactionMissingSaplingParams` if the sapling parameters aren't downloaded.
     ///     - Some `ZcashError.rust*` if the creation of transaction fails.
-    func createShieldingTransaction(
-        spendingKey: UnifiedSpendingKey,
-        shieldingThreshold: Zatoshi,
-        memoBytes: MemoBytes?,
-        from accountIndex: Int
-    ) async throws -> ZcashTransaction.Overview
+    func proposeFulfillingPaymentFromURI(
+        _ uri: String,
+        accountIndex: Int
+    ) async throws -> Proposal
 
     /// submits a transaction to the Zcash peer-to-peer network.
     /// - Parameter transaction: a transaction overview

package/ios/ZCashLightClientKit/Transaction/WalletTransactionEncoder.swift

@@ -54,81 +54,72 @@ class WalletTransactionEncoder: TransactionEncoder {
             logger: initializer.logger
         )
     }
-    
-    func createTransaction(
-        spendingKey: UnifiedSpendingKey,
-        zatoshi: Zatoshi,
-        to address: String,
-        memoBytes: MemoBytes?,
-        from accountIndex: Int
-    ) async throws -> ZcashTransaction.Overview {
-        let txId = try await createSpend(
-            spendingKey: spendingKey,
-            zatoshi: zatoshi,
-            to: address,
-            memoBytes: memoBytes,
-            from: accountIndex
-        )
 
-        logger.debug("transaction id: \(txId)")
-        return try await repository.find(rawID: txId)
-    }
-    
-    func createSpend(
-        spendingKey: UnifiedSpendingKey,
-        zatoshi: Zatoshi,
-        to address: String,
-        memoBytes: MemoBytes?,
-        from accountIndex: Int
-    ) async throws -> Data {
-        guard ensureParams(spend: self.spendParamsURL, output: self.outputParamsURL) else {
-            throw ZcashError.walletTransEncoderCreateTransactionMissingSaplingParams
-        }
-
-        let txId = try await rustBackend.createToAddress(
-            usk: spendingKey,
-            to: address,
-            value: zatoshi.amount,
+    func proposeTransfer(
+        accountIndex: Int,
+        recipient: String,
+        amount: Zatoshi,
+        memoBytes: MemoBytes?
+    ) async throws -> Proposal {
+        let proposal = try await rustBackend.proposeTransfer(
+            account: Int32(accountIndex),
+            to: recipient,
+            value: amount.amount,
             memo: memoBytes
         )
 
-        return txId
+        return Proposal(inner: proposal)
     }
-    
-    func createShieldingTransaction(
-        spendingKey: UnifiedSpendingKey,
+
+    func proposeShielding(
+        accountIndex: Int,
         shieldingThreshold: Zatoshi,
         memoBytes: MemoBytes?,
-        from accountIndex: Int
-    ) async throws -> ZcashTransaction.Overview {
-        let txId = try await createShieldingSpend(
-            spendingKey: spendingKey,
-            shieldingThreshold: shieldingThreshold,
+        transparentReceiver: String? = nil
+    ) async throws -> Proposal? {
+        guard let proposal = try await rustBackend.proposeShielding(
+            account: Int32(accountIndex),
             memo: memoBytes,
-            accountIndex: accountIndex
-        )
-        
-        logger.debug("transaction id: \(txId)")
-        return try await repository.find(rawID: txId)
+            shieldingThreshold: shieldingThreshold,
+            transparentReceiver: transparentReceiver
+        ) else { return nil }
+
+        return Proposal(inner: proposal)
     }
 
-    func createShieldingSpend(
-        spendingKey: UnifiedSpendingKey,
-        shieldingThreshold: Zatoshi,
-        memo: MemoBytes?,
+    func proposeFulfillingPaymentFromURI(
+        _ uri: String,
         accountIndex: Int
-    ) async throws -> Data {
+    ) async throws -> Proposal {
+        let proposal = try await rustBackend.proposeTransferFromURI(
+            uri,
+            account: Int32(accountIndex)
+        )
+        return Proposal(inner: proposal)
+    }
+
+    func createProposedTransactions(
+        proposal: Proposal,
+        spendingKey: UnifiedSpendingKey
+    ) async throws -> [ZcashTransaction.Overview] {
         guard ensureParams(spend: self.spendParamsURL, output: self.outputParamsURL) else {
-            throw ZcashError.walletTransEncoderShieldFundsMissingSaplingParams
+            throw ZcashError.walletTransEncoderCreateTransactionMissingSaplingParams
         }
-        
-        let txId = try await rustBackend.shieldFunds(
-            usk: spendingKey,
-            memo: memo,
-            shieldingThreshold: shieldingThreshold
+
+        let txIds = try await rustBackend.createProposedTransactions(
+            proposal: proposal.inner,
+            usk: spendingKey
         )
-                
-        return txId
+
+        logger.debug("transaction ids: \(txIds)")
+
+        var txs: [ZcashTransaction.Overview] = []
+
+        for txId in txIds {
+            txs.append(try await repository.find(rawID: txId))
+        }
+
+        return txs
     }
 
     func submit(

package/ios/ZCashLightClientKit/Utils/DBActor.swift

@@ -0,0 +1,21 @@
+//
+//  DBActor.swift
+//
+//
+//  Created by Lukáš Korba on 04-08-2024.
+//
+
+import Foundation
+
+/// Global actor used to protect access to the Data DB.
+@globalActor
+enum DBActor {
+    typealias ActorType = Actor
+
+    actor Actor { }
+    static let shared = Actor()
+    
+    static var sharedUnownedExecutor: UnownedSerialExecutor {
+        shared.unownedExecutor
+    }
+}

package/ios/ZCashLightClientKit/Utils/LoggingProxy.swift

@@ -16,6 +16,7 @@ public protocol Logger {
     func event(_ message: String, file: StaticString, function: StaticString, line: Int)
     func warn(_ message: String, file: StaticString, function: StaticString, line: Int)
     func error(_ message: String, file: StaticString, function: StaticString, line: Int)
+    func sync(_ message: String, file: StaticString, function: StaticString, line: Int)
 }
 
 extension Logger {
@@ -34,6 +35,9 @@ extension Logger {
     func error(_ message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
         error(message, file: file, function: function, line: line)
     }
+    func sync(_ message: String, file: StaticString = #file, function: StaticString = #function, line: Int = #line) {
+        sync(message, file: file, function: function, line: line)
+    }
 }
 
 /**
@@ -45,4 +49,5 @@ struct NullLogger: Logger {
     func event(_ message: String, file: StaticString, function: StaticString, line: Int) {}
     func warn(_ message: String, file: StaticString, function: StaticString, line: Int) {}
     func error(_ message: String, file: StaticString, function: StaticString, line: Int) {}
+    func sync(_ message: String, file: StaticString, function: StaticString, line: Int) {}
 }

package/ios/ZCashLightClientKit/Utils/OSLogger.swift

@@ -23,7 +23,11 @@ public class OSLogger: Logger {
     
     var level: LogLevel
     
-    public init(logLevel: LogLevel, category: String = "logs", alias: ZcashSynchronizerAlias? = nil) {
+    public init(
+        logLevel: LogLevel,
+        category: String = "sdkLogs",
+        alias: ZcashSynchronizerAlias? = nil
+    ) {
         self.alias = alias
         self.level = logLevel
         if let bundleName = Bundle.main.bundleIdentifier {
@@ -42,19 +46,50 @@ public class OSLogger: Logger {
         line: Int = #line
     ) {
         guard level.rawValue == LogLevel.debug.rawValue else { return }
-        log(level: "DEBUG 🐞", message: message, file: file, function: function, line: line)
+        log(
+            level: "DEBUG 🐞",
+            logType: .debug,
+            message: message,
+            file: file,
+            function: function,
+            line: line
+        )
     }
     
-    public func error(
+    public func info(
         _ message: String,
         file: StaticString = #file,
         function: StaticString = #function,
         line: Int = #line
     ) {
-        guard level.rawValue <= LogLevel.error.rawValue else { return }
-        log(level: "ERROR 💥", message: message, file: file, function: function, line: line)
+        guard level.rawValue <= LogLevel.info.rawValue else { return }
+        log(
+            level: "INFO ℹ️",
+            logType: .info,
+            message: message,
+            file: file,
+            function: function,
+            line: line
+        )
     }
-    
+
+    public func event(
+        _ message: String,
+        file: StaticString = #file,
+        function: StaticString = #function,
+        line: Int = #line
+    ) {
+        guard level.rawValue <= LogLevel.event.rawValue else { return }
+        log(
+            level: "EVENT ⏱",
+            logType: .default,
+            message: message,
+            file: file,
+            function: function,
+            line: line
+        )
+    }
+
     public func warn(
         _ message: String,
         file: StaticString = #file,
@@ -62,31 +97,52 @@ public class OSLogger: Logger {
         line: Int = #line
     ) {
         guard level.rawValue <= LogLevel.warning.rawValue else { return }
-        log(level: "WARNING ⚠️", message: message, file: file, function: function, line: line)
+        log(
+            level: "WARNING ⚠️",
+            logType: .default,
+            message: message,
+            file: file,
+            function: function,
+            line: line
+        )
     }
 
-    public func event(
+    public func error(
         _ message: String,
         file: StaticString = #file,
         function: StaticString = #function,
         line: Int = #line
     ) {
-        guard level.rawValue <= LogLevel.event.rawValue else { return }
-        log(level: "EVENT ⏱", message: message, file: file, function: function, line: line)
+        guard level.rawValue <= LogLevel.error.rawValue else { return }
+        log(
+            level: "ERROR 💥",
+            logType: .error,
+            message: message,
+            file: file,
+            function: function,
+            line: line
+        )
     }
     
-    public func info(
+    public func sync(
         _ message: String,
         file: StaticString = #file,
         function: StaticString = #function,
         line: Int = #line
     ) {
-        guard level.rawValue <= LogLevel.info.rawValue else { return }
-        log(level: "INFO ℹ️", message: message, file: file, function: function, line: line)
+        log(
+            level: "SYNC_METRIC",
+            logType: .info,
+            message: message,
+            file: file,
+            function: function,
+            line: line
+        )
     }
-    
+
     private func log(
         level: String,
+        logType: OSLogType,
         message: String,
         file: StaticString = #file,
         function: StaticString = #function,
@@ -99,6 +155,7 @@ public class OSLogger: Logger {
         os_log(
             "[%{public}@] %{public}@ - %{public}@ - Line: %{public}d -> %{public}@",
             log: oslog,
+            type: logType,
             level,
             fileName,
             String(describing: function),