Using Web3Auth tKey MPC Swift SDK

import CustomAuth

let sub = SubVerifierDetails(
  loginType: .web, // default .web
  loginProvider: "TYPE_OF_LOGIN", // .google, .facebook, .discord and other supported login providers
  clientId: "CLIENT_ID",
  verifierName: "VERIFIER_NAME",
  redirectURL: "tdsdk://tdsdk/oauthCallback",
  browserRedirectURL: "https://scripts.toruswallet.io/redirect.html")

let tdsdk = CustomAuth(
  aggregateVerifierType: "TYPE_OF_VERIFIER", // singleLogin, singleIdVerifier supported
  aggregateVerifierName: "VERIFIER_NAME", // Web3Auth Custom verifier name
  subVerifierDetails: [sub],
  network: .SAPPHIRE_DEVNET,
  enableOneKey: true)

tdsdk.triggerLogin().done{ data in
    print("user data", data)
    self.userData = data
}.catch{ err in
    print(err)
}

let rss_comm = try RssComm()
let thresholdKey = try? ThresholdKey(
  storage_layer: storage_layer,
  service_provider: service_provider,
  enable_logging: true,
  manual_sync: false,
  rss_comm: rss_comm)

let finalKeyData = userData["finalKeyData"] as? [String: Any]

let postboxkey = finalKeyData["privKey"] as? String

let verifier =  userData["verifier"] as? String
let verifierId = userData["verifierId"] as? String

let storage_layer = try? StorageLayer(
  enable_logging: true,
  host_url: "https://metadata.tor.us",
  server_time_offset: 2)

let fnd = NodeDetailManager(network: .sapphire(.SAPPHIRE_DEVNET))
let nodeDetails = try await fnd.getNodeDetails(verifier: verifier, verifierID: verifierId)

let service_provider = try? ServiceProvider(
  enable_logging: true,
  postbox_key: postboxkey,
  useTss: true,
  verifier: verifier,
  verifierId: verifierId,
  nodeDetails: nodeDetails )

let rss_comm = try RssComm()

let thresholdKey = try? ThresholdKey(
  storage_layer: storage_layer,
  service_provider: service_provider,
  enable_logging: true,
  manual_sync: false,
  rss_comm: rss_comm)

@State private var signatures: [[String: Any]]!
@State private var tssEndpoint: [String]!

let fetchKey = finalKeyData["evmAddress"] as? String

let sessionData = userData["sessionData"] as? [String: Any]

let sessionTokenData = sessionData["sessionTokenData"] as? [SessionToken]

signatures = sessionTokenData.map { token in
    return [  "data": Data(hex: token.token)!.base64EncodedString(),
              "sig": token.signature ]
}

let torusUtils = TorusUtils(
  enableOneKey: true,
  network: .sapphire(.SAPPHIRE_DEVNET) )

tssEndpoint = nodeDetails!.torusNodeTSSEndpoints

import CustomAuth

let sub = SubVerifierDetails(
  loginType: .web, // default .web
  loginProvider: "TYPE_OF_LOGIN", // .google, .facebook, .discord and other supported login providers
  clientId: "CLIENT_ID",
  verifierName: "VERIFIER_NAME",
  redirectURL: "tdsdk://tdsdk/oauthCallback",
  browserRedirectURL: "https://scripts.toruswallet.io/redirect.html")

let tdsdk = CustomAuth(
  aggregateVerifierType: "TYPE_OF_VERIFIER", // singleLogin, singleIdVerifier supported
  aggregateVerifierName: "VERIFIER_NAME", // Web3Auth Custom verifier name
  subVerifierDetails: [sub],
  network: .SAPPHIRE_DEVNET,
  enableOneKey: true)

tdsdk.triggerLogin().done{ data in
    print("user data", data)

    let finalKeyData = data["finalKeyData"] as? [String: Any]
    let verifier =  data["verifier"] as? String
    let verifierId = data["verifierId"] as? String
    let postboxkey = finalKeyData["privKey"] as? String


    let fnd = NodeDetailManager(network: .sapphire(.SAPPHIRE_DEVNET))
    let nodeDetails = try await fnd.getNodeDetails(verifier: verifier, verifierID: verifierId)

    let service_provider = try? ServiceProvider(
      enable_logging: true,
      postbox_key: postboxkey,
      useTss: true,
      verifier: verifier,
      verifierId: verifierId,
      nodeDetails: nodeDetails )

    }.catch{ err in
        print(err)
    }

let torusUtils = TorusUtils(
  enableOneKey: true,
  network: .sapphire(.SAPPHIRE_DEVNET) )

let storage_layer = try? StorageLayer(
  enable_logging: true,
  host_url: "https://metadata.tor.us",
  server_time_offset: 2)

let rss_comm = try RssComm()

let thresholdKey = try? ThresholdKey(
  storage_layer: storage_layer,
  service_provider: service_provider,
  enable_logging: true,
  manual_sync: false,
  rss_comm: rss_comm)

threshold_key = thresholdKey

guard let key_details = try? await threshold_key.initialize(never_initialize_new_key: false, include_local_metadata_transitions: false) else {
  alertContent = "Failed to get key details"
  return
}
totalShares = Int(key_details.total_shares)
threshold = Int(key_details.threshold)

let tags = try? await threshold_key.get_all_tss_tags()

public static func get_tss_tag(threshold_key: ThresholdKey) throws -> String {
  var errorCode: Int32 = -1
  let result = withUnsafeMutablePointer(to: &errorCode, { error in
      threshold_key_get_tss_tag(threshold_key.pointer, error) })
  guard errorCode == 0 else {
      throw RuntimeError("Error in get_tss_tag")
  }
  let string = String(cString: result!)
  string_free(result)
  return string
}

let selected_tag = try TssModule.get_tss_tag(threshold_key: threshold_key)

public static func get_tss_share(threshold_key: ThresholdKey, tss_tag: String, factorKey: String, threshold: Int32 = 0) async throws -> (String, String) {
  if factorKey.count > 66 { throw RuntimeError("Invalid factor Key") }
  try await TssModule.set_tss_tag(threshold_key: threshold_key, tss_tag: tss_tag)

  var errorCode: Int32 = -1

  let curvePointer = UnsafeMutablePointer<Int8>(mutating: (threshold_key.curveN as NSString).utf8String)
  let factorKeyPointer = UnsafeMutablePointer<Int8>(mutating: (factorKey as NSString).utf8String)

  let result = withUnsafeMutablePointer(to: &errorCode, { error in
      threshold_key_get_tss_share(threshold_key.pointer, factorKeyPointer, threshold, curvePointer, error)
  })
  guard errorCode == 0 else {
      throw RuntimeError("Error in ThresholdKey get_tss_share")
  }
  let string = String(cString: result!)
  string_free(result)
  let splitString = string.split(separator: ",", maxSplits: 2)
  return (String(splitString[0]), String(splitString[1]))
}

let (tssIndex, tssShare) = try await TssModule.get_tss_share(threshold_key: threshold_key, tss_tag: selected_tag, factorKey: factorKey)

public static func get_tss_nonce(threshold_key: ThresholdKey, tss_tag: String, prefetch: Bool = false) throws -> Int32 {
    var errorCode: Int32 = -1
    let tss_tag_pointer: UnsafeMutablePointer<Int8>? = UnsafeMutablePointer<Int8>(mutating: NSString(string: tss_tag).utf8String)
    var nonce = withUnsafeMutablePointer(to: &errorCode, { error in
        threshold_key_get_tss_nonce(threshold_key.pointer, tss_tag_pointer, error) })
    guard errorCode == 0 else {
        throw RuntimeError("Error in ThresholdKey get_tss_nonce")
    }

    if prefetch {
        nonce += 1
    }

    return nonce
}

let tssNonce = try TssModule.get_tss_nonce(threshold_key: threshold_key, tss_tag: selected_tag)

public static func getTssPubAddress(threshold_key: ThresholdKey, tssTag: String, nonce: String, nodeDetails: AllNodeDetailsModel, torusUtils: TorusUtils) async throws -> GetTSSPubKeyResult {
    let extendedVerifierId = try threshold_key.get_extended_verifier_id()
    let split = extendedVerifierId.components(separatedBy: "\u{001c}")

    let result = try await torusUtils.getPublicAddress(endpoints: nodeDetails.torusNodeEndpoints, torusNodePubs: nodeDetails.torusNodePub, verifier: split[0], verifierId: split[1], extendedVerifierId: "\(split[1])\u{0015}\(tssTag)\u{0016}\(nonce)")

    print("result in service provider", result)
    guard let x = result.finalKeyData?.X, let y = result.finalKeyData?.Y, let nodeIndexes = result.nodesData?.nodeIndexes else {
        throw RuntimeError("conversion error")
    }
    let pubKey = GetTSSPubKeyResult.Point(x: x, y: y)
    return GetTSSPubKeyResult(publicKey: pubKey, nodeIndexes: nodeIndexes)
}

let tssPublicAddressInfo = try await TssModule.getTssPubAddress(threshold_key: threshold_key, tssTag: selected_tag, nonce: String(tssNonce), nodeDetails: nodeDetails, torusUtils: torusUtils)

public static func get_tss_pub_key(threshold_key: ThresholdKey, tss_tag: String) async throws -> String {
    try await TssModule.set_tss_tag(threshold_key: threshold_key, tss_tag: tss_tag)

    var errorCode: Int32 = -1

    let result = withUnsafeMutablePointer(to: &errorCode, { error in
        threshold_key_get_tss_public_key(threshold_key.pointer, error) })
    guard errorCode == 0 else {
        throw RuntimeError("Error in get_tss_tag")
    }
    let string = String(cString: result!)
    string_free(result)
    return string
}

tss_pub_key = try await TssModule.get_tss_pub_key(threshold_key: threshold_key, tss_tag: "default")

public static func create_tagged_tss_share(threshold_key: ThresholdKey, tss_tag: String, deviceTssShare: String?, factorPub: String, deviceTssIndex: Int32, nodeDetails: AllNodeDetailsModel, torusUtils: TorusUtils) async throws {
    try await TssModule.set_tss_tag(threshold_key: threshold_key, tss_tag: tss_tag)
    try await TssModule.update_tss_pub_key(threshold_key: threshold_key, tss_tag: tss_tag, nodeDetails: nodeDetails, torusUtils: torusUtils)
    return try await withCheckedThrowingContinuation {
        continuation in
        create_tagged_tss_share(threshold_key: threshold_key, deviceTssShare: deviceTssShare, factorPub: factorPub, deviceTssIndex: deviceTssIndex) {
            result in
            switch result {
            case let .success(result):
                continuation.resume(returning: result)
            case let .failure(error):
                continuation.resume(throwing: error)
            }
        }
    }
}

// generate factor key
let factorKey = try PrivateKey.generate()
// derive factor pub
let factorPub = try factorKey.toPublic()

try await TssModule.create_tagged_tss_share(
  threshold_key: self.threshold_key,
  tss_tag: "default",
  deviceTssShare: nil,
  factorPub: factorPub,
  deviceTssIndex: 2,
  nodeDetails: self.nodeDetails!,
  torusUtils: self.torusUtils!)

public static func get_all_factor_pub(threshold_key: ThresholdKey, tss_tag: String) async throws -> [String] {
    try await TssModule.set_tss_tag(threshold_key: threshold_key, tss_tag: tss_tag)

    var errorCode: Int32 = -1

    let result = withUnsafeMutablePointer(to: &errorCode, { error in
        threshold_key_get_tss_tag_factor_pub(threshold_key.pointer, error) })
    guard errorCode == 0 else {
        throw RuntimeError("Error in get_all_factor_pub")
    }
    let string = String(cString: result!)
    string_free(result)
    guard let data = string.data(using: .utf8) else {
        throw RuntimeError("Error in get_all_factor_pub : Invalid output ")
    }
    guard let result_vec = try JSONSerialization.jsonObject(with: data) as? [String] else {
        throw RuntimeError("Error in get_all_factor_pub : Invalid output ")
    }

    return result_vec
}

factor_pub = try await TssModule.get_all_factor_pub(threshold_key: threshold_key, tss_tag: "default")

public static func add_factor_pub(threshold_key: ThresholdKey, tss_tag: String, factor_key: String, auth_signatures: [String], new_factor_pub: String, new_tss_index: Int32, selected_servers: [Int32]? = nil, nodeDetails: AllNodeDetailsModel, torusUtils: TorusUtils) async throws {
    if factor_key.count > 66 { throw RuntimeError("Invalid factor Key") }
    try await TssModule.set_tss_tag(threshold_key: threshold_key, tss_tag: tss_tag)

    let (tss_index, tss_share) = try await get_tss_share(threshold_key: threshold_key, tss_tag: tss_tag, factorKey: factor_key)
    try await TssModule.generate_tss_share(threshold_key: threshold_key, tss_tag: tss_tag, input_tss_share: tss_share, tss_input_index: Int32(tss_index)!, auth_signatures: auth_signatures, new_factor_pub: new_factor_pub, new_tss_index: new_tss_index, nodeDetails: nodeDetails, torusUtils: torusUtils, selected_servers: selected_servers)
}

try await TssModule.add_factor_pub(threshold_key: threshold_key, tss_tag: selected_tag, factor_key: factorKey, auth_signatures: sigs, new_factor_pub: newFactorPub, new_tss_index: tssShareIndex, nodeDetails: nodeDetails!, torusUtils: torusUtils!)

public static func copy_factor_pub(threshold_key: ThresholdKey, tss_tag: String, factorKey: String, newFactorPub: String, tss_index: Int32, threshold: Int32 = 0) async throws {
    if factorKey.count > 66 { throw RuntimeError("Invalid factor Key") }
    try await TssModule.set_tss_tag(threshold_key: threshold_key, tss_tag: tss_tag)

    return try await withCheckedThrowingContinuation {
        continuation in
        copy_factor_pub(threshold_key: threshold_key, factorKey: factorKey, newFactorPub: newFactorPub, tss_index: tss_index) {
            result in
            switch result {
            case let .success(result):
                continuation.resume(returning: result)
            case let .failure(error):
                continuation.resume(throwing: error)
            }
        }
    }
}

try await TssModule.copy_factor_pub(threshold_key: threshold_key, tss_tag: selected_tag, factorKey: factorKey, newFactorPub: newFactorPub, tss_index: tssShareIndex)

public static func delete_factor_pub(threshold_key: ThresholdKey, tss_tag: String, factor_key: String, auth_signatures: [String], delete_factor_pub: String, nodeDetails: AllNodeDetailsModel, torusUtils: TorusUtils, selected_servers: [Int32]? = nil) async throws {
    if factor_key.count > 66 { throw RuntimeError("Invalid factor Key") }
    try await TssModule.set_tss_tag(threshold_key: threshold_key, tss_tag: tss_tag)

    let (tss_index, tss_share) = try await get_tss_share(threshold_key: threshold_key, tss_tag: tss_tag, factorKey: factor_key)
    try await TssModule.delete_tss_share(threshold_key: threshold_key, tss_tag: tss_tag, input_tss_share: tss_share, tss_input_index: Int32(tss_index)!, auth_signatures: auth_signatures, delete_factor_pub: delete_factor_pub, nodeDetails: nodeDetails, torusUtils: torusUtils, selected_servers: selected_servers)
}

try await TssModule.delete_factor_pub(threshold_key: threshold_key, tss_tag: selected_tag, factor_key: factorKey, auth_signatures: sigs, delete_factor_pub: deleteFactorPK.toPublic(), nodeDetails: nodeDetails!, torusUtils: torusUtils!)