@lightninglabs/wavelength-react-native 0.1.0

package/ios/WavelengthModule.mm

@@ -0,0 +1,298 @@
+#import "WavelengthModule.h"
+
+#import <Wavewalletdk/Wavewalletdk.h>
+#import <WavelengthSpec/WavelengthSpec.h>
+#import "WavelengthReactNative-Swift.h"
+
+// The single device event name; the body is { kind, payload }.
+static NSString *const kWavelengthEvent = @"wavelengthActivity";
+static NSString *const kWavelengthErrorCode = @"wavelength_error";
+
+// The codegen spec conformance lives here (see the note in the header): the
+// generated protocol drags in C++ headers that must stay out of the public
+// Objective-C surface.
+@interface WavelengthModule () <NativeWavelengthSpec>
+@end
+
+@implementation WavelengthModule {
+  MobileSubscription *_subscription;
+  WavelengthPasskey *_passkey;
+}
+
+RCT_EXPORT_MODULE(Wavelength)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[ kWavelengthEvent ];
+}
+
+- (void)getDefaultDataDir:(RCTPromiseResolveBlock)resolve
+                   reject:(RCTPromiseRejectBlock)reject
+{
+  NSURL *appSupport = [[NSFileManager.defaultManager
+      URLsForDirectory:NSApplicationSupportDirectory
+             inDomains:NSUserDomainMask] firstObject];
+  resolve([appSupport URLByAppendingPathComponent:@"wavelength"].path);
+}
+
+- (void)passkeySupported:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject
+{
+  resolve(@([WavelengthPasskey prfSupported]));
+}
+
+- (void)passkeyCreate:(NSString *)requestJson
+              resolve:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject
+{
+  dispatch_async(dispatch_get_main_queue(), ^{
+    @synchronized (self) {
+      if (self->_passkey == nil) {
+        self->_passkey = [WavelengthPasskey new];
+      }
+    }
+    [self->_passkey create:requestJson
+                completion:^(NSString *json, NSString *errorMessage) {
+      if (json != nil) {
+        resolve(json);
+      } else {
+        reject(kWavelengthErrorCode,
+               errorMessage ?: @"passkey ceremony failed", nil);
+      }
+    }];
+  });
+}
+
+- (void)passkeyGet:(NSString *)requestJson
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject
+{
+  dispatch_async(dispatch_get_main_queue(), ^{
+    @synchronized (self) {
+      if (self->_passkey == nil) {
+        self->_passkey = [WavelengthPasskey new];
+      }
+    }
+    [self->_passkey get:requestJson
+             completion:^(NSString *json, NSString *errorMessage) {
+      if (json != nil) {
+        resolve(json);
+      } else {
+        reject(kWavelengthErrorCode,
+               errorMessage ?: @"passkey ceremony failed", nil);
+      }
+    }];
+  });
+}
+
+// call maps a verb name onto the gomobile Mobile* entry points. The facade
+// takes and returns JSON bytes; this switch stays dumb on purpose because all
+// typing lives in the TypeScript layer.
+- (void)call:(NSString *)method
+  paramsJson:(NSString *)paramsJson
+     resolve:(RCTPromiseResolveBlock)resolve
+      reject:(RCTPromiseRejectBlock)reject
+{
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    NSError *error = nil;
+    NSData *result = nil;
+    NSString *json = @"";
+    NSData *params = [paramsJson dataUsingEncoding:NSUTF8StringEncoding];
+
+    if ([method isEqualToString:@"start"]) {
+      MobileStart(paramsJson, &error);
+    } else if ([method isEqualToString:@"stop"]) {
+      MobileStop(&error);
+    } else if ([method isEqualToString:@"getInfo"]) {
+      result = MobileGetInfo(&error);
+    } else if ([method isEqualToString:@"status"]) {
+      result = MobileStatus(&error);
+    } else if ([method isEqualToString:@"balance"]) {
+      result = MobileBalance(&error);
+    } else if ([method isEqualToString:@"createWallet"]) {
+      result = MobileCreateWallet(params, &error);
+    } else if ([method isEqualToString:@"unlockWallet"]) {
+      result = MobileUnlockWallet(params, &error);
+    } else if ([method isEqualToString:@"openWalletFromPasskey"]) {
+      result = MobileOpenWalletFromPasskey(params, &error);
+    } else if ([method isEqualToString:@"deposit"]) {
+      result = MobileDeposit(params, &error);
+    } else if ([method isEqualToString:@"receive"]) {
+      result = MobileReceive(params, &error);
+    } else if ([method isEqualToString:@"prepareSend"]) {
+      result = MobilePrepareSend(params, &error);
+    } else if ([method isEqualToString:@"sendPrepared"]) {
+      result = MobileSendPrepared(params, &error);
+    } else if ([method isEqualToString:@"list"]) {
+      result = MobileList(params, &error);
+    } else if ([method isEqualToString:@"exit"]) {
+      result = MobileExit(params, &error);
+    } else if ([method isEqualToString:@"exitStatus"]) {
+      result = MobileExitStatus(params, &error);
+    } else if ([method isEqualToString:@"exitSummary"]) {
+      result = MobileExitSummary(params, &error);
+    } else if ([method isEqualToString:@"getExitPlan"]) {
+      result = MobileGetExitPlan(params, &error);
+    } else if ([method isEqualToString:@"sweepWallet"]) {
+      result = MobileSweepWallet(params, &error);
+    } else if ([method isEqualToString:@"confirmedBalanceSat"]) {
+      int64_t value = 0;
+      MobileConfirmedBalanceSat(&value, &error);
+      json = [NSString stringWithFormat:@"%lld",
+          (long long)value];
+    } else if ([method isEqualToString:@"pendingInboundSat"]) {
+      int64_t value = 0;
+      MobilePendingInboundSat(&value, &error);
+      json = [NSString stringWithFormat:@"%lld",
+          (long long)value];
+    } else if ([method isEqualToString:@"walletReady"]) {
+      BOOL value = NO;
+      MobileWalletReady(&value, &error);
+      json = value ? @"true" : @"false";
+    } else if ([method isEqualToString:@"isRunning"]) {
+      json = MobileIsRunning() ? @"true" : @"false";
+    } else {
+      reject(kWavelengthErrorCode,
+             [NSString stringWithFormat:@"unknown wavelength verb: %@", method],
+             nil);
+      return;
+    }
+
+    if (error != nil) {
+      reject(kWavelengthErrorCode, error.localizedDescription, error);
+      return;
+    }
+    if (result != nil) {
+      json = [[NSString alloc] initWithData:result encoding:NSUTF8StringEncoding];
+    }
+    resolve(json ?: @"");
+  });
+}
+
+// startActivity opens the facade's pull subscription and pumps entries to
+// device events on a background queue, because next() blocks.
+- (void)startActivity:(NSString *)reqJson
+              resolve:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject
+{
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    // The check, the subscribe, and the store happen in one critical section
+    // (mirroring the Kotlin module): separate sections would let two
+    // overlapping calls both subscribe, leaking a pump that double-emits
+    // every entry.
+    MobileSubscription *sub = nil;
+    NSError *error = nil;
+    @synchronized (self) {
+      if (self->_subscription != nil) {
+        resolve(nil);
+        return;
+      }
+      NSData *req = [reqJson dataUsingEncoding:NSUTF8StringEncoding];
+      sub = MobileSubscribe(req, &error);
+      if (error == nil && sub != nil) {
+        self->_subscription = sub;
+      }
+    }
+    if (error != nil || sub == nil) {
+      reject(kWavelengthErrorCode,
+             error.localizedDescription ?: @"wavelength subscribe failed",
+             error);
+      return;
+    }
+
+    [self pump:sub];
+    resolve(nil);
+  });
+}
+
+- (void)stopActivity:(RCTPromiseResolveBlock)resolve
+              reject:(RCTPromiseRejectBlock)reject
+{
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    MobileSubscription *sub = nil;
+    @synchronized (self) {
+      sub = self->_subscription;
+      // Detach before close returns so a queued start can't reuse a pump
+      // that's already stopping.
+      self->_subscription = nil;
+    }
+    NSError *error = nil;
+    if (sub != nil) {
+      [sub close:&error];
+    }
+    if (error != nil) {
+      reject(kWavelengthErrorCode, error.localizedDescription, error);
+      return;
+    }
+    resolve(nil);
+  });
+}
+
+// pump drains the subscription on a background queue until it ends, emitting
+// one device event per entry and a terminal end or error event.
+- (void)pump:(MobileSubscription *)sub
+{
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
+    while (YES) {
+      NSError *error = nil;
+      NSData *entry = [sub next:&error];
+      if (error != nil || entry == nil) {
+        // A nil entry with no error, or the exact terminal "EOF", is a clean
+        // close; a substring match would misclassify failures like
+        // "unexpected EOF" as clean ends.
+        BOOL eof = error == nil ||
+            [error.localizedDescription isEqualToString:@"EOF"];
+        BOOL stopped;
+        @synchronized (self) {
+          stopped = self->_subscription != sub;
+        }
+        // An intentional stop has no terminal event. A replacement may
+        // already be open by the time this old pump unblocks.
+        if (stopped) {
+          break;
+        }
+        if (eof) {
+          [self sendEventWithName:kWavelengthEvent
+                             body:@{ @"kind" : @"end", @"payload" : @"" }];
+        } else {
+          [self sendEventWithName:kWavelengthEvent
+                             body:@{
+                               @"kind" : @"error",
+                               @"payload" : error.localizedDescription
+                                   ?: @"wavelength activity stream failed"
+                             }];
+        }
+        break;
+      }
+      BOOL stopped;
+      @synchronized (self) {
+        stopped = self->_subscription != sub;
+      }
+      if (stopped) {
+        break;
+      }
+      NSString *json =
+          [[NSString alloc] initWithData:entry encoding:NSUTF8StringEncoding];
+      [self sendEventWithName:kWavelengthEvent
+                         body:@{ @"kind" : @"entry", @"payload" : json ?: @"" }];
+    }
+    @synchronized (self) {
+      if (self->_subscription == sub) {
+        self->_subscription = nil;
+      }
+    }
+  });
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeWavelengthSpecJSI>(params);
+}
+
+@end

package/ios/WavelengthPasskey.swift

@@ -0,0 +1,262 @@
+import AuthenticationServices
+import CryptoKit
+import Foundation
+import UIKit
+
+// The native half of the passkey ceremony: WebAuthn-shaped JSON in, a minimal
+// WebAuthn-shaped JSON response out. The TypeScript parser reads only id and
+// the PRF results; rawId and type ride along for WebAuthn shape fidelity. The JSON-to-
+// ASAuthorization mapping follows react-native-passkey (MIT,
+// https://github.com/f-23/react-native-passkey), which shipped the iOS 18 PRF
+// path this implementation mirrors.
+//
+// Experimental: compiles and is driven by unit-tested TS request shapes, but
+// has not been verified end to end; that needs an Associated Domains
+// entitlement backed by a paid Apple Developer Program team.
+@objc(WavelengthPasskey)
+public final class WavelengthPasskey: NSObject {
+
+  // Retains in-flight runners; ASAuthorizationController does not retain its
+  // delegate, so each ceremony holds itself here until it completes. Typed
+  // as AnyObject because stored properties cannot be availability-gated and
+  // PasskeyRunner itself requires iOS 18.
+  private var inFlight: [AnyObject] = []
+
+  // PRF requires the iOS 18 AuthenticationServices API.
+  @objc public static func prfSupported() -> Bool {
+    if #available(iOS 18.0, *) {
+      return true
+    }
+    return false
+  }
+
+  @objc public func create(
+    _ requestJson: String,
+    completion: @escaping (String?, String?) -> Void
+  ) {
+    guard #available(iOS 18.0, *) else {
+      completion(nil, "passkeys require iOS 18 or newer")
+      return
+    }
+    guard
+      let body = parseJson(requestJson),
+      let rp = body["rp"] as? [String: Any],
+      let rpId = rp["id"] as? String,
+      let user = body["user"] as? [String: Any],
+      let userName = user["name"] as? String,
+      let userIdB64 = user["id"] as? String,
+      let userId = Self.dataFromBase64Url(userIdB64),
+      let challengeB64 = body["challenge"] as? String,
+      let challenge = Self.dataFromBase64Url(challengeB64),
+      let salt = prfSalt(body)
+    else {
+      completion(nil, "malformed passkey registration request")
+      return
+    }
+
+    let provider = ASAuthorizationPlatformPublicKeyCredentialProvider(
+      relyingPartyIdentifier: rpId)
+    let request = provider.createCredentialRegistrationRequest(
+      challenge: challenge, name: userName, userID: userId)
+    request.userVerificationPreference = .required
+    request.prf = .inputValues(
+      ASAuthorizationPublicKeyCredentialPRFRegistrationInput.InputValues(
+        saltInput1: salt, saltInput2: nil))
+
+    run(
+      request: request,
+      cancelMessage: "passkey registration was cancelled",
+      completion: completion)
+  }
+
+  @objc public func get(
+    _ requestJson: String,
+    completion: @escaping (String?, String?) -> Void
+  ) {
+    guard #available(iOS 18.0, *) else {
+      completion(nil, "passkeys require iOS 18 or newer")
+      return
+    }
+    guard
+      let body = parseJson(requestJson),
+      let rpId = body["rpId"] as? String,
+      let challengeB64 = body["challenge"] as? String,
+      let challenge = Self.dataFromBase64Url(challengeB64),
+      let salt = prfSalt(body)
+    else {
+      completion(nil, "malformed passkey assertion request")
+      return
+    }
+
+    let provider = ASAuthorizationPlatformPublicKeyCredentialProvider(
+      relyingPartyIdentifier: rpId)
+    let request = provider.createCredentialAssertionRequest(challenge: challenge)
+    request.userVerificationPreference = .required
+    if let allowed = body["allowCredentials"] as? [[String: Any]] {
+      request.allowedCredentials = allowed.compactMap { entry in
+        guard
+          let idB64 = entry["id"] as? String,
+          let id = Self.dataFromBase64Url(idB64)
+        else {
+          return nil
+        }
+        return ASAuthorizationPlatformPublicKeyCredentialDescriptor(
+          credentialID: id)
+      }
+    }
+    request.prf = .inputValues(
+      ASAuthorizationPublicKeyCredentialPRFRegistrationInput.InputValues(
+        saltInput1: salt, saltInput2: nil))
+
+    run(
+      request: request,
+      cancelMessage: "passkey authentication was cancelled",
+      completion: completion)
+  }
+
+  @available(iOS 18.0, *)
+  private func run(
+    request: ASAuthorizationRequest,
+    cancelMessage: String,
+    completion: @escaping (String?, String?) -> Void
+  ) {
+    let runner = PasskeyRunner(
+      cancelMessage: cancelMessage, completion: completion)
+    runner.onDone = { [weak self, weak runner] in
+      self?.inFlight.removeAll { $0 === runner }
+    }
+    inFlight.append(runner)
+    runner.run(request: request)
+  }
+
+  // prfSalt reads extensions.prf.eval.first (base64url) from a request body.
+  private func prfSalt(_ body: [String: Any]) -> Data? {
+    guard
+      let extensions = body["extensions"] as? [String: Any],
+      let prf = extensions["prf"] as? [String: Any],
+      let eval = prf["eval"] as? [String: Any],
+      let firstB64 = eval["first"] as? String
+    else {
+      return nil
+    }
+    return Self.dataFromBase64Url(firstB64)
+  }
+
+  private func parseJson(_ json: String) -> [String: Any]? {
+    guard let data = json.data(using: .utf8) else {
+      return nil
+    }
+    return (try? JSONSerialization.jsonObject(with: data)) as? [String: Any]
+  }
+
+  static func base64Url(_ data: Data) -> String {
+    data.base64EncodedString()
+      .replacingOccurrences(of: "+", with: "-")
+      .replacingOccurrences(of: "/", with: "_")
+      .replacingOccurrences(of: "=", with: "")
+  }
+
+  static func dataFromBase64Url(_ value: String) -> Data? {
+    var s = value
+      .replacingOccurrences(of: "-", with: "+")
+      .replacingOccurrences(of: "_", with: "/")
+    while s.count % 4 != 0 {
+      s += "="
+    }
+    return Data(base64Encoded: s)
+  }
+}
+
+// PasskeyRunner owns one ceremony: it runs the controller, anchors its UI to
+// the key window, and serializes the credential (or error) back to JSON.
+@available(iOS 18.0, *)
+private final class PasskeyRunner: NSObject,
+  ASAuthorizationControllerDelegate,
+  ASAuthorizationControllerPresentationContextProviding {
+
+  private let cancelMessage: String
+  private let completion: (String?, String?) -> Void
+  var onDone: () -> Void = {}
+
+  init(cancelMessage: String, completion: @escaping (String?, String?) -> Void) {
+    self.cancelMessage = cancelMessage
+    self.completion = completion
+  }
+
+  func run(request: ASAuthorizationRequest) {
+    let controller = ASAuthorizationController(authorizationRequests: [request])
+    controller.delegate = self
+    controller.presentationContextProvider = self
+    controller.performRequests()
+  }
+
+  func presentationAnchor(
+    for controller: ASAuthorizationController
+  ) -> ASPresentationAnchor {
+    UIApplication.shared.connectedScenes
+      .compactMap { $0 as? UIWindowScene }
+      .flatMap { $0.windows }
+      .first { $0.isKeyWindow } ?? ASPresentationAnchor()
+  }
+
+  func authorizationController(
+    controller: ASAuthorizationController,
+    didCompleteWithAuthorization authorization: ASAuthorization
+  ) {
+    switch authorization.credential {
+    case let registration
+      as ASAuthorizationPlatformPublicKeyCredentialRegistration:
+      completion(
+        Self.responseJson(
+          credentialId: registration.credentialID,
+          prfFirst: Self.prfData(registration.prf?.first)),
+        nil)
+    case let assertion as ASAuthorizationPlatformPublicKeyCredentialAssertion:
+      completion(
+        Self.responseJson(
+          credentialId: assertion.credentialID,
+          prfFirst: Self.prfData(assertion.prf?.first)),
+        nil)
+    default:
+      completion(nil, "unexpected credential type from the authenticator")
+    }
+    onDone()
+  }
+
+  func authorizationController(
+    controller: ASAuthorizationController,
+    didCompleteWithError error: Error
+  ) {
+    let asError = error as? ASAuthorizationError
+    let message = asError?.code == .canceled
+      ? cancelMessage
+      : error.localizedDescription
+    completion(nil, message)
+    onDone()
+  }
+
+  // prfData converts a PRF output (a CryptoKit SymmetricKey) into raw bytes.
+  private static func prfData(_ key: SymmetricKey?) -> Data? {
+    key?.withUnsafeBytes { Data($0) }
+  }
+
+  // responseJson builds the minimal WebAuthn response the TS parser reads.
+  private static func responseJson(credentialId: Data, prfFirst: Data?) -> String? {
+    var extensionResults: [String: Any] = [:]
+    if let first = prfFirst {
+      extensionResults = [
+        "prf": ["results": ["first": WavelengthPasskey.base64Url(first)]],
+      ]
+    }
+    let body: [String: Any] = [
+      "id": WavelengthPasskey.base64Url(credentialId),
+      "rawId": WavelengthPasskey.base64Url(credentialId),
+      "type": "public-key",
+      "clientExtensionResults": extensionResults,
+    ]
+    guard let data = try? JSONSerialization.data(withJSONObject: body) else {
+      return nil
+    }
+    return String(data: data, encoding: .utf8)
+  }
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@lightninglabs/wavelength-react-native",
+  "version": "0.1.0",
+  "private": false,
+  "description": "React Native transport for the Wavelength self-custodial Lightning wallet SDK.",
+  "license": "MIT",
+  "homepage": "https://wavelength.lightning.engineering",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lightninglabs/wavelength-sdk.git",
+    "directory": "packages/react-native"
+  },
+  "bugs": "https://github.com/lightninglabs/wavelength-sdk/issues",
+  "keywords": [
+    "lightning",
+    "bitcoin",
+    "wallet",
+    "self-custodial",
+    "payments",
+    "react-native"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "sideEffects": false,
+  "codegenConfig": {
+    "name": "WavelengthSpec",
+    "type": "modules",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "engineering.lightning.wavelength.reactnative"
+    }
+  },
+  "dependencies": {
+    "@lightninglabs/wavelength-core": "0.1.0"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.76.0"
+  },
+  "devDependencies": {
+    "react-native": "0.86.0",
+    "@types/react": "^19.2.17",
+    "react": "19.2.3"
+  },
+  "files": [
+    "dist",
+    "src",
+    "android",
+    "ios",
+    "*.podspec",
+    "!android/libs",
+    "!ios/Wavewalletdk.xcframework"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --test",
+    "fetch-bindings": "bash scripts/fetch-bindings.sh"
+  }
+}

package/src/NativeWavelength.ts

@@ -0,0 +1,32 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+/**
+ * The Turbo Module contract for the wavelength native bridge. The surface is
+ * a deliberately thin JSON pipe: `call` dispatches every facade verb by name
+ * with a JSON string in and a JSON string out, and the activity stream
+ * arrives as 'wavelengthActivity' device events carrying
+ * `{ kind: 'entry' | 'end' | 'error', payload: string }`.
+ */
+export interface Spec extends TurboModule {
+  /** Invokes a facade verb by name with a JSON payload, returning JSON. */
+  call(method: string, paramsJson: string): Promise<string>;
+  /** Opens the activity subscription; entries arrive as device events. */
+  startActivity(reqJson: string): Promise<void>;
+  /** Closes the activity subscription; a no-op when none is open. */
+  stopActivity(): Promise<void>;
+  /** Resolves the platform default wallet data directory. */
+  getDefaultDataDir(): Promise<string>;
+  /** Reports whether the platform can run a passkey PRF ceremony. */
+  passkeySupported(): Promise<boolean>;
+  /** Runs a passkey registration ceremony; WebAuthn JSON in and out. */
+  passkeyCreate(requestJson: string): Promise<string>;
+  /** Runs a passkey assertion ceremony; WebAuthn JSON in and out. */
+  passkeyGet(requestJson: string): Promise<string>;
+  /** Required by NativeEventEmitter. */
+  addListener(eventName: string): void;
+  /** Required by NativeEventEmitter. */
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('Wavelength');