@dynamic-labs/react-native-extension 4.67.3-device-registration.0 → 4.69.0

package/android/src/main/java/xyz/dynamic/keychain/KeyStoreKeyManager.kt

@@ -1,148 +0,0 @@
-package xyz.dynamic.keychain
-
-import android.content.Context
-import android.content.pm.PackageManager
-import android.os.Build
-import android.security.keystore.KeyGenParameterSpec
-import android.security.keystore.KeyProperties
-import android.security.keystore.StrongBoxUnavailableException
-import java.security.KeyPairGenerator
-import java.security.KeyStore
-import java.security.Signature
-import java.security.spec.ECGenParameterSpec
-
-/// Platform-agnostic Android KeyStore key manager.
-/// Provides P-256 key generation, signing, and management backed by hardware TEE/StrongBox.
-/// All public keys are returned in uncompressed SEC1 format (65 bytes: 04 || x || y).
-/// All binary data uses base64url encoding (RFC 4648 §5, no padding).
-class KeyStoreKeyManager {
-
-  fun isAvailable(context: Context?): Boolean {
-    return try {
-      val keyStore = KeyStore.getInstance(ANDROID_KEYSTORE)
-      keyStore.load(null)
-      val hasStrongBox = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && context != null) {
-        context.packageManager.hasSystemFeature(PackageManager.FEATURE_STRONGBOX_KEYSTORE)
-      } else {
-        false
-      }
-      // Even without StrongBox, Android KeyStore provides TEE-backed keys on most devices
-      hasStrongBox || Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
-    } catch (e: Exception) {
-      false
-    }
-  }
-
-  fun hasKey(alias: String): Boolean {
-    val keyStore = loadKeyStore()
-    return keyStore.containsAlias(alias)
-  }
-
-  fun generateKeyPair(alias: String): String {
-    val specBuilder = KeyGenParameterSpec.Builder(
-      alias,
-      KeyProperties.PURPOSE_SIGN or KeyProperties.PURPOSE_VERIFY
-    )
-      .setAlgorithmParameterSpec(ECGenParameterSpec("secp256r1"))
-      .setDigests(KeyProperties.DIGEST_SHA256)
-
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-      specBuilder.setIsStrongBoxBacked(true)
-    }
-
-    val keyPair = try {
-      val kpg = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, ANDROID_KEYSTORE)
-      kpg.initialize(specBuilder.build())
-      kpg.generateKeyPair()
-    } catch (e: Exception) {
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && e is StrongBoxUnavailableException) {
-        // Retry without StrongBox
-        specBuilder.setIsStrongBoxBacked(false)
-        val kpg = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, ANDROID_KEYSTORE)
-        kpg.initialize(specBuilder.build())
-        kpg.generateKeyPair()
-      } else {
-        throw e
-      }
-    }
-
-    val publicKeyBytes = extractUncompressedPublicKey(keyPair.public.encoded)
-    return base64urlEncode(publicKeyBytes)
-  }
-
-  fun getPublicKey(alias: String): String? {
-    val keyStore = loadKeyStore()
-    val entry = keyStore.getEntry(alias, null)
-
-    if (entry == null || entry !is KeyStore.PrivateKeyEntry) {
-      return null
-    }
-
-    val publicKeyBytes = extractUncompressedPublicKey(entry.certificate.publicKey.encoded)
-    return base64urlEncode(publicKeyBytes)
-  }
-
-  fun sign(alias: String, payload: ByteArray): String {
-    val keyStore = loadKeyStore()
-    val entry = keyStore.getEntry(alias, null)
-
-    if (entry == null || entry !is KeyStore.PrivateKeyEntry) {
-      throw IllegalArgumentException("Key not found: $alias")
-    }
-
-    val signature = Signature.getInstance("SHA256withECDSA")
-    signature.initSign(entry.privateKey)
-    signature.update(payload)
-    val signatureBytes = signature.sign()
-
-    return base64urlEncode(signatureBytes)
-  }
-
-  fun deleteKey(alias: String) {
-    val keyStore = loadKeyStore()
-    keyStore.deleteEntry(alias)
-  }
-
-  // region Private helpers
-
-  private fun loadKeyStore(): KeyStore {
-    val keyStore = KeyStore.getInstance(ANDROID_KEYSTORE)
-    keyStore.load(null)
-    return keyStore
-  }
-
-  /**
-   * Extract uncompressed SEC1 public key (65 bytes: 04 || x || y)
-   * from X.509 SubjectPublicKeyInfo DER encoding.
-   *
-   * For a P-256 key, the SubjectPublicKeyInfo contains the uncompressed
-   * point at the end of the DER structure. The point is always 65 bytes.
-   */
-  private fun extractUncompressedPublicKey(x509Encoded: ByteArray): ByteArray {
-    val uncompressedPointLength = 65
-    return x509Encoded.copyOfRange(
-      x509Encoded.size - uncompressedPointLength,
-      x509Encoded.size
-    )
-  }
-
-  private fun base64urlEncode(data: ByteArray): String {
-    return android.util.Base64.encodeToString(
-      data,
-      android.util.Base64.URL_SAFE or android.util.Base64.NO_WRAP or android.util.Base64.NO_PADDING
-    )
-  }
-
-  companion object {
-    private const val ANDROID_KEYSTORE = "AndroidKeyStore"
-
-    fun base64urlDecode(input: String): ByteArray {
-      return android.util.Base64.decode(
-        input,
-        android.util.Base64.URL_SAFE or android.util.Base64.NO_WRAP or android.util.Base64.NO_PADDING
-      )
-    }
-  }
-
-  // endregion
-}

package/android/src/main/java/xyz/dynamic/keychain/KeychainModule.kt

@@ -1,71 +0,0 @@
-package xyz.dynamic.keychain
-
-import expo.modules.kotlin.modules.Module
-import expo.modules.kotlin.modules.ModuleDefinition
-import expo.modules.kotlin.Promise
-
-class KeychainModule : Module() {
-  private val keyManager = KeyStoreKeyManager()
-
-  override fun definition() = ModuleDefinition {
-    Name("Keychain")
-
-    AsyncFunction("isAvailable") { promise: Promise ->
-      try {
-        val context = appContext.reactContext
-        promise.resolve(keyManager.isAvailable(context))
-      } catch (e: Exception) {
-        promise.resolve(false)
-      }
-    }
-
-    AsyncFunction("hasKey") { key: String, promise: Promise ->
-      try {
-        promise.resolve(keyManager.hasKey(key))
-      } catch (e: Exception) {
-        promise.reject("ERR_KEYCHAIN", "Failed to check key: ${e.message}", e)
-      }
-    }
-
-    AsyncFunction("generateKeyPair") { key: String, promise: Promise ->
-      try {
-        val publicKey = keyManager.generateKeyPair(key)
-        promise.resolve(mapOf("publicKey" to publicKey))
-      } catch (e: Exception) {
-        promise.reject("ERR_KEYCHAIN", "Failed to generate key pair: ${e.message}", e)
-      }
-    }
-
-    AsyncFunction("getPublicKey") { key: String, promise: Promise ->
-      try {
-        val publicKey = keyManager.getPublicKey(key)
-        if (publicKey == null) {
-          promise.resolve(null)
-        } else {
-          promise.resolve(mapOf("publicKey" to publicKey))
-        }
-      } catch (e: Exception) {
-        promise.reject("ERR_KEYCHAIN", "Failed to get public key: ${e.message}", e)
-      }
-    }
-
-    AsyncFunction("sign") { key: String, payload: String, promise: Promise ->
-      try {
-        val payloadData = KeyStoreKeyManager.base64urlDecode(payload)
-        val signature = keyManager.sign(key, payloadData)
-        promise.resolve(mapOf("signature" to signature))
-      } catch (e: Exception) {
-        promise.reject("ERR_KEYCHAIN", "Failed to sign: ${e.message}", e)
-      }
-    }
-
-    AsyncFunction("deleteKey") { key: String, promise: Promise ->
-      try {
-        keyManager.deleteKey(key)
-        promise.resolve(null)
-      } catch (e: Exception) {
-        promise.reject("ERR_KEYCHAIN", "Failed to delete key: ${e.message}", e)
-      }
-    }
-  }
-}

package/android/xyz/dynamic/keychain/KeyStoreKeyManager.kt

@@ -1,148 +0,0 @@
-package xyz.dynamic.keychain
-
-import android.content.Context
-import android.content.pm.PackageManager
-import android.os.Build
-import android.security.keystore.KeyGenParameterSpec
-import android.security.keystore.KeyProperties
-import android.security.keystore.StrongBoxUnavailableException
-import java.security.KeyPairGenerator
-import java.security.KeyStore
-import java.security.Signature
-import java.security.spec.ECGenParameterSpec
-
-/// Platform-agnostic Android KeyStore key manager.
-/// Provides P-256 key generation, signing, and management backed by hardware TEE/StrongBox.
-/// All public keys are returned in uncompressed SEC1 format (65 bytes: 04 || x || y).
-/// All binary data uses base64url encoding (RFC 4648 §5, no padding).
-class KeyStoreKeyManager {
-
-  fun isAvailable(context: Context?): Boolean {
-    return try {
-      val keyStore = KeyStore.getInstance(ANDROID_KEYSTORE)
-      keyStore.load(null)
-      val hasStrongBox = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && context != null) {
-        context.packageManager.hasSystemFeature(PackageManager.FEATURE_STRONGBOX_KEYSTORE)
-      } else {
-        false
-      }
-      // Even without StrongBox, Android KeyStore provides TEE-backed keys on most devices
-      hasStrongBox || Build.VERSION.SDK_INT >= Build.VERSION_CODES.M
-    } catch (e: Exception) {
-      false
-    }
-  }
-
-  fun hasKey(alias: String): Boolean {
-    val keyStore = loadKeyStore()
-    return keyStore.containsAlias(alias)
-  }
-
-  fun generateKeyPair(alias: String): String {
-    val specBuilder = KeyGenParameterSpec.Builder(
-      alias,
-      KeyProperties.PURPOSE_SIGN or KeyProperties.PURPOSE_VERIFY
-    )
-      .setAlgorithmParameterSpec(ECGenParameterSpec("secp256r1"))
-      .setDigests(KeyProperties.DIGEST_SHA256)
-
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
-      specBuilder.setIsStrongBoxBacked(true)
-    }
-
-    val keyPair = try {
-      val kpg = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, ANDROID_KEYSTORE)
-      kpg.initialize(specBuilder.build())
-      kpg.generateKeyPair()
-    } catch (e: Exception) {
-      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && e is StrongBoxUnavailableException) {
-        // Retry without StrongBox
-        specBuilder.setIsStrongBoxBacked(false)
-        val kpg = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, ANDROID_KEYSTORE)
-        kpg.initialize(specBuilder.build())
-        kpg.generateKeyPair()
-      } else {
-        throw e
-      }
-    }
-
-    val publicKeyBytes = extractUncompressedPublicKey(keyPair.public.encoded)
-    return base64urlEncode(publicKeyBytes)
-  }
-
-  fun getPublicKey(alias: String): String? {
-    val keyStore = loadKeyStore()
-    val entry = keyStore.getEntry(alias, null)
-
-    if (entry == null || entry !is KeyStore.PrivateKeyEntry) {
-      return null
-    }
-
-    val publicKeyBytes = extractUncompressedPublicKey(entry.certificate.publicKey.encoded)
-    return base64urlEncode(publicKeyBytes)
-  }
-
-  fun sign(alias: String, payload: ByteArray): String {
-    val keyStore = loadKeyStore()
-    val entry = keyStore.getEntry(alias, null)
-
-    if (entry == null || entry !is KeyStore.PrivateKeyEntry) {
-      throw IllegalArgumentException("Key not found: $alias")
-    }
-
-    val signature = Signature.getInstance("SHA256withECDSA")
-    signature.initSign(entry.privateKey)
-    signature.update(payload)
-    val signatureBytes = signature.sign()
-
-    return base64urlEncode(signatureBytes)
-  }
-
-  fun deleteKey(alias: String) {
-    val keyStore = loadKeyStore()
-    keyStore.deleteEntry(alias)
-  }
-
-  // region Private helpers
-
-  private fun loadKeyStore(): KeyStore {
-    val keyStore = KeyStore.getInstance(ANDROID_KEYSTORE)
-    keyStore.load(null)
-    return keyStore
-  }
-
-  /**
-   * Extract uncompressed SEC1 public key (65 bytes: 04 || x || y)
-   * from X.509 SubjectPublicKeyInfo DER encoding.
-   *
-   * For a P-256 key, the SubjectPublicKeyInfo contains the uncompressed
-   * point at the end of the DER structure. The point is always 65 bytes.
-   */
-  private fun extractUncompressedPublicKey(x509Encoded: ByteArray): ByteArray {
-    val uncompressedPointLength = 65
-    return x509Encoded.copyOfRange(
-      x509Encoded.size - uncompressedPointLength,
-      x509Encoded.size
-    )
-  }
-
-  private fun base64urlEncode(data: ByteArray): String {
-    return android.util.Base64.encodeToString(
-      data,
-      android.util.Base64.URL_SAFE or android.util.Base64.NO_WRAP or android.util.Base64.NO_PADDING
-    )
-  }
-
-  companion object {
-    private const val ANDROID_KEYSTORE = "AndroidKeyStore"
-
-    fun base64urlDecode(input: String): ByteArray {
-      return android.util.Base64.decode(
-        input,
-        android.util.Base64.URL_SAFE or android.util.Base64.NO_WRAP or android.util.Base64.NO_PADDING
-      )
-    }
-  }
-
-  // endregion
-}

package/android/xyz/dynamic/keychain/KeychainModule.kt

@@ -1,71 +0,0 @@
-package xyz.dynamic.keychain
-
-import expo.modules.kotlin.modules.Module
-import expo.modules.kotlin.modules.ModuleDefinition
-import expo.modules.kotlin.Promise
-
-class KeychainModule : Module() {
-  private val keyManager = KeyStoreKeyManager()
-
-  override fun definition() = ModuleDefinition {
-    Name("Keychain")
-
-    AsyncFunction("isAvailable") { promise: Promise ->
-      try {
-        val context = appContext.reactContext
-        promise.resolve(keyManager.isAvailable(context))
-      } catch (e: Exception) {
-        promise.resolve(false)
-      }
-    }
-
-    AsyncFunction("hasKey") { key: String, promise: Promise ->
-      try {
-        promise.resolve(keyManager.hasKey(key))
-      } catch (e: Exception) {
-        promise.reject("ERR_KEYCHAIN", "Failed to check key: ${e.message}", e)
-      }
-    }
-
-    AsyncFunction("generateKeyPair") { key: String, promise: Promise ->
-      try {
-        val publicKey = keyManager.generateKeyPair(key)
-        promise.resolve(mapOf("publicKey" to publicKey))
-      } catch (e: Exception) {
-        promise.reject("ERR_KEYCHAIN", "Failed to generate key pair: ${e.message}", e)
-      }
-    }
-
-    AsyncFunction("getPublicKey") { key: String, promise: Promise ->
-      try {
-        val publicKey = keyManager.getPublicKey(key)
-        if (publicKey == null) {
-          promise.resolve(null)
-        } else {
-          promise.resolve(mapOf("publicKey" to publicKey))
-        }
-      } catch (e: Exception) {
-        promise.reject("ERR_KEYCHAIN", "Failed to get public key: ${e.message}", e)
-      }
-    }
-
-    AsyncFunction("sign") { key: String, payload: String, promise: Promise ->
-      try {
-        val payloadData = KeyStoreKeyManager.base64urlDecode(payload)
-        val signature = keyManager.sign(key, payloadData)
-        promise.resolve(mapOf("signature" to signature))
-      } catch (e: Exception) {
-        promise.reject("ERR_KEYCHAIN", "Failed to sign: ${e.message}", e)
-      }
-    }
-
-    AsyncFunction("deleteKey") { key: String, promise: Promise ->
-      try {
-        keyManager.deleteKey(key)
-        promise.resolve(null)
-      } catch (e: Exception) {
-        promise.reject("ERR_KEYCHAIN", "Failed to delete key: ${e.message}", e)
-      }
-    }
-  }
-}

package/expo-module.config.json

@@ -1,9 +0,0 @@
-{
-  "platforms": ["ios", "android"],
-  "ios": {
-    "modules": ["KeychainModule"]
-  },
-  "android": {
-    "modules": ["xyz.dynamic.keychain.KeychainModule"]
-  }
-}

package/ios/Keychain.podspec

@@ -1,15 +0,0 @@
-Pod::Spec.new do |s|
-  s.name           = 'Keychain'
-  s.version        = '1.0.0'
-  s.summary        = 'TEE-backed key operations for Dynamic SDK'
-  s.description    = 'Provides Secure Enclave key generation, signing, and management via Expo Modules'
-  s.homepage       = 'https://www.dynamic.xyz'
-  s.license        = { type: 'MIT' }
-  s.author         = 'Dynamic Labs'
-  s.source         = { git: '' }
-  s.platform       = :ios, '15.1'
-  s.swift_version  = '5.4'
-  s.source_files   = '*.swift'
-
-  s.dependency 'ExpoModulesCore'
-end

package/ios/KeychainModule.swift

@@ -1,39 +0,0 @@
-import ExpoModulesCore
-
-public class KeychainModule: Module {
-  private let keyManager = SecureEnclaveKeyManager()
-
-  public func definition() -> ModuleDefinition {
-    Name("Keychain")
-
-    AsyncFunction("isAvailable") { () -> Bool in
-      self.keyManager.isAvailable()
-    }
-
-    AsyncFunction("hasKey") { (key: String) -> Bool in
-      self.keyManager.hasKey(tag: key)
-    }
-
-    AsyncFunction("generateKeyPair") { (key: String) -> [String: String] in
-      let publicKey = try self.keyManager.generateKeyPair(tag: key)
-      return ["publicKey": publicKey]
-    }
-
-    AsyncFunction("getPublicKey") { (key: String) -> [String: String]? in
-      guard let publicKey = try self.keyManager.getPublicKey(tag: key) else {
-        return nil
-      }
-      return ["publicKey": publicKey]
-    }
-
-    AsyncFunction("sign") { (key: String, payload: String) -> [String: String] in
-      let payloadData = base64urlDecode(payload)
-      let signature = try self.keyManager.sign(tag: key, payload: payloadData)
-      return ["signature": signature]
-    }
-
-    AsyncFunction("deleteKey") { (key: String) in
-      self.keyManager.deleteKey(tag: key)
-    }
-  }
-}

package/ios/SecureEnclaveKeyManager.swift

@@ -1,170 +0,0 @@
-import Foundation
-import Security
-import CryptoKit
-
-public enum SecureEnclaveKeyManagerError: Error, LocalizedError {
-  case generateFailed(String)
-  case exportFailed(String)
-  case keyNotFound(String)
-  case signFailed(String)
-
-  public var errorDescription: String? {
-    switch self {
-    case .generateFailed(let detail):
-      return "Failed to generate key pair: \(detail)"
-    case .exportFailed(let detail):
-      return "Failed to export public key: \(detail)"
-    case .keyNotFound(let tag):
-      return "Key not found for tag: \(tag)"
-    case .signFailed(let detail):
-      return "Failed to sign: \(detail)"
-    }
-  }
-}
-
-/// Platform-agnostic Secure Enclave key manager.
-/// Provides P-256 key generation, signing, and management backed by the iOS Secure Enclave.
-/// All public keys are returned in uncompressed SEC1 format (65 bytes: 04 || x || y).
-/// All binary data uses base64url encoding (RFC 4648 §5, no padding).
-public class SecureEnclaveKeyManager {
-
-  public init() {}
-
-  public func isAvailable() -> Bool {
-    if #available(iOS 13.0, *) {
-      return SecureEnclave.isAvailable
-    }
-    return false
-  }
-
-  public func hasKey(tag: String) -> Bool {
-    let query = baseQuery(for: tag, returning: true)
-    var item: CFTypeRef?
-    let status = SecItemCopyMatching(query as CFDictionary, &item)
-    return status == errSecSuccess
-  }
-
-  public func generateKeyPair(tag: String) throws -> String {
-    let tagData = tag.data(using: .utf8)!
-
-    let access = SecAccessControlCreateWithFlags(
-      kCFAllocatorDefault,
-      kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly,
-      .privateKeyUsage,
-      nil
-    )!
-
-    let attributes: [String: Any] = [
-      kSecAttrKeyType as String: kSecAttrKeyTypeECSECPrimeRandom,
-      kSecAttrKeySizeInBits as String: 256,
-      kSecAttrTokenID as String: kSecAttrTokenIDSecureEnclave,
-      kSecPrivateKeyAttrs as String: [
-        kSecAttrIsPermanent as String: true,
-        kSecAttrApplicationTag as String: tagData,
-        kSecAttrAccessControl as String: access,
-      ] as [String: Any],
-    ]
-
-    var error: Unmanaged<CFError>?
-    guard let privateKey = SecKeyCreateRandomKey(attributes as CFDictionary, &error) else {
-      throw SecureEnclaveKeyManagerError.generateFailed(
-        "\(error!.takeRetainedValue())"
-      )
-    }
-
-    let publicKey = SecKeyCopyPublicKey(privateKey)!
-    let publicKeyData = try exportPublicKey(publicKey)
-    return base64urlEncode(publicKeyData)
-  }
-
-  public func getPublicKey(tag: String) throws -> String? {
-    let query = baseQuery(for: tag, returning: true)
-
-    var item: CFTypeRef?
-    let status = SecItemCopyMatching(query as CFDictionary, &item)
-
-    guard status == errSecSuccess else {
-      return nil
-    }
-
-    let privateKey = item as! SecKey
-    let publicKey = SecKeyCopyPublicKey(privateKey)!
-    let publicKeyData = try exportPublicKey(publicKey)
-    return base64urlEncode(publicKeyData)
-  }
-
-  public func sign(tag: String, payload: Data) throws -> String {
-    let query = baseQuery(for: tag, returning: true)
-
-    var item: CFTypeRef?
-    let status = SecItemCopyMatching(query as CFDictionary, &item)
-
-    guard status == errSecSuccess else {
-      throw SecureEnclaveKeyManagerError.keyNotFound(tag)
-    }
-
-    let privateKey = item as! SecKey
-
-    var error: Unmanaged<CFError>?
-    guard let signature = SecKeyCreateSignature(
-      privateKey,
-      .ecdsaSignatureMessageX962SHA256,
-      payload as CFData,
-      &error
-    ) else {
-      throw SecureEnclaveKeyManagerError.signFailed(
-        "\(error!.takeRetainedValue())"
-      )
-    }
-
-    return base64urlEncode(signature as Data)
-  }
-
-  public func deleteKey(tag: String) {
-    let query = baseQuery(for: tag, returning: false)
-    SecItemDelete(query as CFDictionary)
-  }
-
-  // MARK: - Private helpers
-
-  private func baseQuery(for tag: String, returning returnRef: Bool) -> [String: Any] {
-    var query: [String: Any] = [
-      kSecClass as String: kSecClassKey,
-      kSecAttrApplicationTag as String: tag.data(using: .utf8)!,
-      kSecAttrKeyType as String: kSecAttrKeyTypeECSECPrimeRandom,
-    ]
-    if returnRef {
-      query[kSecReturnRef as String] = true
-    }
-    return query
-  }
-
-  private func exportPublicKey(_ publicKey: SecKey) throws -> Data {
-    var error: Unmanaged<CFError>?
-    guard let data = SecKeyCopyExternalRepresentation(publicKey, &error) else {
-      throw SecureEnclaveKeyManagerError.exportFailed(
-        "\(error!.takeRetainedValue())"
-      )
-    }
-    // SecKeyCopyExternalRepresentation returns uncompressed SEC1 format (04 || x || y)
-    return data as Data
-  }
-
-  private func base64urlEncode(_ data: Data) -> String {
-    data.base64EncodedString()
-      .replacingOccurrences(of: "+", with: "-")
-      .replacingOccurrences(of: "/", with: "_")
-      .replacingOccurrences(of: "=", with: "")
-  }
-}
-
-public func base64urlDecode(_ string: String) -> Data {
-  var base64 = string
-    .replacingOccurrences(of: "-", with: "+")
-    .replacingOccurrences(of: "_", with: "/")
-  let remainder = base64.count % 4
-  if remainder > 0 {
-    base64 += String(repeating: "=", count: 4 - remainder)
-  }
-  return Data(base64Encoded: base64)!
-}

package/src/ReactNativeExtension/setupKeychainHandler/index.d.ts

@@ -1 +0,0 @@
-export { setupKeychainHandler } from './setupKeychainHandler';

package/src/ReactNativeExtension/setupKeychainHandler/setupKeychainHandler.d.ts

@@ -1,2 +0,0 @@
-import { Core } from '@dynamic-labs/client';
-export declare const setupKeychainHandler: (core: Core) => void;

package/src/nativeModules/Keychain.d.ts

@@ -1,16 +0,0 @@
-type KeychainNativeModule = {
-    isAvailable: () => Promise<boolean>;
-    hasKey: (key: string) => Promise<boolean>;
-    generateKeyPair: (key: string) => Promise<{
-        publicKey: string;
-    }>;
-    getPublicKey: (key: string) => Promise<{
-        publicKey: string;
-    } | null>;
-    sign: (key: string, payload: string) => Promise<{
-        signature: string;
-    }>;
-    deleteKey: (key: string) => Promise<void>;
-};
-export declare const getKeychain: () => KeychainNativeModule;
-export {};