Wrap Channel object

Sources/ElixxirDAppsSDK/Channel/Channel.swift

+import Bindings
+
+public struct Channel {
+  public var broadcast: ChannelBroadcast
+  public var broadcastAsymmetric: ChannelBroadcastAsymmetric
+  public var get: ChannelGet
+  public var listen: ChannelListen
+  public var maxAsymmetricPayloadSize: ChannelMaxAsymmetricPayloadSize
+  public var maxPayloadSize: ChannelMaxPayloadSize
+  public var stop: ChannelStop
+}
+
+extension Channel {
+  public static func live(_ bindingsChannel: BindingsChannel) -> Channel {
+    Channel(
+      broadcast: .live(bindingsChannel),
+      broadcastAsymmetric: .live(bindingsChannel),
+      get: .live(bindingsChannel),
+      listen: .live(bindingsChannel),
+      maxAsymmetricPayloadSize: .live(bindingsChannel),
+      maxPayloadSize: .live(bindingsChannel),
+      stop: .live(bindingsChannel)
+    )
+  }
+}
+
+extension Channel {
+  public static let unimplemented = Channel(
+    broadcast: .unimplemented,
+    broadcastAsymmetric: .unimplemented,
+    get: .unimplemented,
+    listen: .unimplemented,
+    maxAsymmetricPayloadSize: .unimplemented,
+    maxPayloadSize: .unimplemented,
+    stop: .unimplemented
+  )
+}

Sources/ElixxirDAppsSDK/Channel/Functors/ChannelBroadcast.swift

+import Bindings
+import XCTestDynamicOverlay
+
+public struct ChannelBroadcast {
+  public var run: (Data) throws -> Data
+
+  public func callAsFunction(_ payload: Data) throws -> Data {
+    try run(payload)
+  }
+}
+
+extension ChannelBroadcast {
+  public static func live(_ bindingsChannel: BindingsChannel) -> ChannelBroadcast {
+    ChannelBroadcast(run: bindingsChannel.broadcast)
+  }
+}
+
+extension ChannelBroadcast {
+  public static let unimplemented = ChannelBroadcast(
+    run: XCTUnimplemented("\(Self.self)")
+  )
+}

Sources/ElixxirDAppsSDK/Channel/Functors/ChannelBroadcastAsymmetric.swift

+import Bindings
+import XCTestDynamicOverlay
+
+public struct ChannelBroadcastAsymmetric {
+  public var run: (Data, Data) throws -> Data
+
+  public func callAsFunction(
+    payload: Data,
+    privateKey: Data
+  ) throws -> Data {
+    try run(payload, privateKey)
+  }
+}
+
+extension ChannelBroadcastAsymmetric {
+  public static func live(_ bindingsChannel: BindingsChannel) -> ChannelBroadcastAsymmetric {
+    ChannelBroadcastAsymmetric(run: bindingsChannel.broadcastAsymmetric(_:pk:))
+  }
+}
+
+extension ChannelBroadcastAsymmetric {
+  public static let unimplemented = ChannelBroadcastAsymmetric(
+    run: XCTUnimplemented("\(Self.self)")
+  )
+}

Sources/ElixxirDAppsSDK/Channel/Functors/ChannelGet.swift

+import Bindings
+import XCTestDynamicOverlay
+
+public struct ChannelGet {
+  public var run: () throws -> ChannelDef
+
+  public func callAsFunction() throws -> ChannelDef {
+    try run()
+  }
+}
+
+extension ChannelGet {
+  public static func live(_ bindingsChannel: BindingsChannel) -> ChannelGet {
+    ChannelGet {
+      try ChannelDef.decode(bindingsChannel.get())
+    }
+  }
+}
+
+extension ChannelGet {
+  public static let unimplemented = ChannelGet(
+    run: XCTUnimplemented("\(Self.self)")
+  )
+}

Sources/ElixxirDAppsSDK/Channel/Functors/ChannelListen.swift

+import Bindings
+import XCTestDynamicOverlay
+
+public struct ChannelListen {
+  public var run: (Int, BroadcastListener) throws -> Void
+
+  public func callAsFunction(
+    method: Int,
+    callback: BroadcastListener
+  ) throws {
+    try run(method, callback)
+  }
+}
+
+extension ChannelListen {
+  public static func live(_ bindingsChannel: BindingsChannel) -> ChannelListen {
+    ChannelListen { method, callback in
+      try bindingsChannel.listen(
+        callback.makeBindingsBroadcastListener(),
+        method: method
+      )
+    }
+  }
+}
+
+extension ChannelListen {
+  public static let unimplemented = ChannelListen(
+    run: XCTUnimplemented("\(Self.self)")
+  )
+}

Sources/ElixxirDAppsSDK/Channel/Functors/ChannelMaxAsymmetricPayloadSize.swift

+import Bindings
+import XCTestDynamicOverlay
+
+public struct ChannelMaxAsymmetricPayloadSize {
+  public var run: () -> Int
+
+  public func callAsFunction() -> Int {
+    run()
+  }
+}
+
+extension ChannelMaxAsymmetricPayloadSize {
+  public static func live(_ bindingsChannel: BindingsChannel) -> ChannelMaxAsymmetricPayloadSize {
+    ChannelMaxAsymmetricPayloadSize(run: bindingsChannel.maxAsymmetricPayloadSize)
+  }
+}
+
+extension ChannelMaxAsymmetricPayloadSize {
+  public static let unimplemented = ChannelMaxAsymmetricPayloadSize(
+    run: XCTUnimplemented("\(Self.self)")
+  )
+}

Sources/ElixxirDAppsSDK/Channel/Functors/ChannelMaxPayloadSize.swift

+import Bindings
+import XCTestDynamicOverlay
+
+public struct ChannelMaxPayloadSize {
+  public var run: () -> Int
+
+  public func callAsFunction() -> Int {
+    run()
+  }
+}
+
+extension ChannelMaxPayloadSize {
+  public static func live(_ bindingsChannel: BindingsChannel) -> ChannelMaxPayloadSize {
+    ChannelMaxPayloadSize(run: bindingsChannel.maxPayloadSize)
+  }
+}
+
+extension ChannelMaxPayloadSize {
+  public static let unimplemented = ChannelMaxPayloadSize(
+    run: XCTUnimplemented("\(Self.self)")
+  )
+}

Sources/ElixxirDAppsSDK/Channel/Functors/ChannelStop.swift

+import Bindings
+import XCTestDynamicOverlay
+
+public struct ChannelStop {
+  public var run: () -> Void
+
+  public func callAsFunction() {
+    run()
+  }
+}
+
+extension ChannelStop {
+  public static func live(_ bindingsChannel: BindingsChannel) -> ChannelStop {
+    ChannelStop(run: bindingsChannel.stop)
+  }
+}
+
+extension ChannelStop {
+  public static let unimplemented = ChannelStop(
+    run: XCTUnimplemented("\(Self.self)")
+  )
+}