Ouryn

enum WalletNetwork: String, Codable, CaseIterable, Identifiable {
 case tron = "트론", solana = "솔라나", ethereum = "이더리움", mantle = "맨틀",
      avalanche = "Avalanche C-Chain", bitcoin = "비트코인", cardano = "카르다노"
 var chainID: Int? {
  if Testnet.on { switch self { case .ethereum: return 11155111; case .mantle: return 5003; case .avalanche: return 43113; default: return nil } }
  switch self { case .ethereum: return 1; case .mantle: return 5000; case .avalanche: return 43114; default: return nil }
 }
 func contract(_ asset: String) -> String? {
  if Testnet.on { switch (self,asset) {
   case (.ethereum,"usdc"): return "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238" // Sepolia (Circle)
   /* … */ default: return nil } }
  switch (self,asset) {
  case (.mantle,"usdt0"): return "0x779Ded0c9e1022225f8E0630b35a9b54bE713736" // usdt0.to/ecosystem/mantle
  case (.ethereum,"usdt"): return "0xdAC17F958D2ee523a2206206994597C13D831ec7"
  /* … */ default: return nil }
 }
}

struct TransferQuote {
 let network: WalletNetwork
 let asset: String
 let owner: String
 let recipient: String
 let raw: String
 let fee: Decimal
 let expires: Date
 let draft: [String:Any]
 let maxFee: Int64
}

enum TransferDispatcher {
 static func broadcast(_ signed:SignedTransfer,network:WalletNetwork) async throws {
  switch network {
  case .tron: try await TronTransfer.broadcast(signed)
  case .solana: try await SolanaTransferEngine.broadcast(signed)
  case .bitcoin: try await BitcoinTransfer.broadcast(signed)
  case .cardano: try await CardanoTransfer.broadcast(signed)
  default: try await EVMTransfer.broadcast(signed,network:network)
  }
 }
}

static func parse(_ text: String, decimals: Int) throws -> String {
 guard (0...18).contains(decimals), !text.isEmpty else { throw AmountError.invalid }
 let parts = text.split(separator: ".", omittingEmptySubsequences: false)
 guard parts.count <= 2, !parts[0].isEmpty,
       parts.allSatisfy({ $0.allSatisfy { $0 >= "0" && $0 <= "9" } }) else { throw AmountError.invalid }
 let fraction = parts.count == 2 ? String(parts[1]) : ""
 guard fraction.count <= decimals else { throw AmountError.invalid }
 let raw = String(parts[0]) + fraction + String(repeating: "0", count: decimals - fraction.count)
 let stripped = String(raw.drop(while: { $0 == "0" }))
 guard stripped.count <= 38 else { throw AmountError.invalid }
 return stripped.isEmpty ? "0" : stripped
}

func parsePay(_ raw: String) -> PayRequest? {
    let s = raw.trimmingCharacters(in: .whitespacesAndNewlines)
    // 주소 모양으로 네트워크가 갈리는 것: 비트코인 tb1/bc1 · 카르다노 addr_test1/addr1
    if Testnet.looksTest(s) || Testnet.looksMain(s) {
        let test = Testnet.looksTest(s)
        guard let n = WalletNetwork.allCases.first(where: { WalletKeys.valid(s, network: $0, test: test) }) else { return nil }
        return PayRequest(to: s, network: n.rawValue, test: test, mainnet: !test)
    }
    if s.lowercased().hasPrefix("ethereum:") { return parseEIP681(String(s.dropFirst("ethereum:".count))) }
    if isAddr(s) {
        let net: String? = s.hasPrefix("0x") ? nil : WalletNetwork.allCases.first(where:{ WalletKeys.valid(s,network:$0) })?.rawValue
        return PayRequest(to:s,network:net)
    }
    if s.lowercased().hasPrefix("ouryn:") { return parseOuryn(String(s.dropFirst("ouryn:".count))) }
    guard s.lowercased().hasPrefix("solana:") else { return nil }
    /* … Solana Pay 해석 (모르는 spl-token은 받지 않음) */
}

private func prepare() {
 guard let owner = store.st.address(net: network.rawValue) else { error = "지갑 주소 검증을 확인해주세요"; return }
 // 같은 네트워크에 확정 안 된 송금이 있으면 새로 보내지 않음 (나중에 둘 다 처리돼 두 번 나가는 일 방지)
 if let prior = store.st.tx.first(where: { $0.type == .send && $0.inFlight && $0.network == network.rawValue }) {
  error = prior.status == .delayed
   ? "이 네트워크의 이전 송금이 오래 확인되지 않고 있어요. 그 송금이 처리되거나 실패로 확인된 뒤에 보낼 수 있어요"
   : "이 네트워크에서 이전 송금을 확인 중이에요"
  return
 }
 /* … 체인별 quote() 호출 */
}

static func signEVM(_ quote:TransferQuote) throws -> SignedTransfer {
 guard [.ethereum,.mantle,.avalanche].contains(quote.network), quote.expires > Date(),
       let wallet = signingWallet(), WalletKeys.signingAddress(wallet,.ethereum).lowercased() == quote.owner.lowercased(),
       quote.draft["chainID"] as? Int == quote.network.chainID,
       /* … nonce · gasPrice · gasLimit · amount를 바이트로 변환 */
 else { throw TransferError.invalid("확인이 만료됐거나 지갑을 열 수 없어요") }
 let input = EthereumSigningInput.with {
  $0.chainID = chainData; $0.nonce = nonceData; $0.gasPrice = priceData; $0.gasLimit = gasData
  $0.toAddress = quote.network.contract(quote.asset) ?? quote.recipient
  $0.privateKey = WalletKeys.signingKey(wallet,.ethereum).data
  /* … ERC-20이면 erc20Transfer, 아니면 transfer */
 }
 let output:EthereumSigningOutput = AnySigner.sign(input:input,coin:.ethereum)
 guard output.error == .ok, !output.encoded.isEmpty else { throw TransferError.invalid("서명 검증에 실패했어요") }
 let id = "0x" + Hash.keccak256(data:output.encoded).hexString
 return SignedTransfer(id:id,payload:["encoded":"0x" + output.encoded.hexString])
}

/// - 얼굴 등록 그대로: Face ID 만
/// - 얼굴 등록이 바뀜 또는 생체인증 없는 항목: 앱 비밀번호 먼저 (그다음 Face ID)
/// - 그 상태에서 비밀번호를 10번 넘게 틀림: 12단어만
static func sendGate(wallet: String) -> SendGate {
    let bio = isBiometric(wallet)
    let changed = bio && Biometry.changed()
    if PinVault.hardLocked && (changed || !bio) { return .words }
    if changed || !bio { return .pin }
    return .faceID
}

private static func bioAccess() -> SecAccessControl? {
    SecAccessControlCreateWithFlags(nil, kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly, .biometryAny, nil)
}

static func withSigner<T>(_ w: HDWallet, _ body: () throws -> T) rethrows -> T {
    signer = w
    defer { signer = nil }
    return try body()
}

private static let testWords = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
private static let expected = ChainAddrs(
    solana: "HAgk14JpMQLgt6rVgv7cBQFJWFto5Dqxi472uT3DKpqk",
    ethereum: "0x9858EfFD232B4033E47d90003D41EC34EcaEda94",
    bitcoin: "bc1qcr8te4kr609gcawutmrza0j4xv80jy8z306fyu",
    cardano: "addr1qy8ac7qq…afdhv")

static let selfTest: [String: Bool] = {
    guard let w = HDWallet(mnemonic: testWords, passphrase: "") else { /* 전부 실패 */ }
    let a = addrs(w)
    return [
        "솔라나": a.solana == expected.solana,
        "이더리움": a.ethereum == expected.ethereum,
        "비트코인": a.bitcoin == expected.bitcoin,
        "트론": a.tron == "TUEZSdKsoDHQMeZwihtdoBiN46zxhGWYdH",
        /* … 카르다노, 맨틀, Avalanche, 테스트넷 */
    ]
}()