# From rust-sdk directory
make docs-rust

# iOS-specific docs
cargo doc --no-deps -p privacy-boost-ios

init(config: PrivacyBoostConfig) throws

var isConnected: Bool { get }
var isAuthenticated: Bool { get }

func authenticate(wallet: WalletDelegate, keySource: KeySource? = nil, tokenProvider: TokenProvider? = nil) async throws -> AuthResult

func submitCredential(_ credential: String, tokenProvider: TokenProvider? = nil) async throws -> LoginResult

func logout()

func clearSession()

func getPrivacyAddress() -> String?
func getMpk() -> String?
func getWalletAddress() -> String?

func getBalance(tokenAddress: String) async throws -> TokenBalance

func getAllBalances() async throws -> [TokenBalance]

func deposit(tokenAddress: String, amount: String) async throws -> DepositResult

func withdraw(tokenAddress: String, amount: String, recipient: String) async throws -> UnshieldResult

func send(tokenAddress: String, amount: String, recipientPrivacyAddress: String) async throws -> TransferResult

func getTransactionHistory(
    txType: String?,
    tokenAddress: String?,
    limit: UInt32?
) async throws -> [Transaction]

func exportSession() -> ExportedSession?

func importSession(_ session: ExportedSession) throws -> Bool

func resolveIdentity(identifier: String) async throws -> IdentityResult

func isValidPrivacyAddress(_ address: String) -> Bool
func isValidAddress(_ address: String) -> Bool
func parseAmount(_ amount: String, decimals: UInt8) throws -> String
func formatAmount(_ wei: String, decimals: UInt8) throws -> String

func sdkVersion() -> String
func generateMnemonic() throws -> String

struct PrivacyBoostConfig {
    let serverUrl: String
    let wethContractAddress: String
    let appId: String
    let chainId: UInt64?
    let shieldContractAddress: String?
    let teePublicKey: String?
}

enum KeySource {
    case walletDerived
    case mnemonic(phrase: String)
    case rawSeed(hexSeed: String)
}

enum AuthResult {
    case authenticated(LoginResult)
    case credentialRequired(CredentialChallenge)
}

struct LoginResult {
    let privacyAddress: String
    let mpk: String
}

struct TokenBalance {
    let tokenAddress: String
    let shieldedBalance: String
    let walletBalance: String
    let symbol: String?
    let decimals: UInt8
}

struct DepositResult {
    let txHash: String
    let commitment: String
    let fee: String
}

struct UnshieldResult {
    let txHash: String
    let fee: String
}

struct TransferResult {
    let txHash: String
    let fee: String
}

struct Transaction {
    let txHash: String
    let txType: String
    let tokenAddress: String
    let amount: String
    let direction: String
    let senderPubKey: String
    let receiverPubKeys: [String]
    let createdAt: UInt64
}

struct IdentityResult {
    let mpk: String
    let ethereumAddress: String
    let viewingPublicKeyX: String
    let viewingPublicKeyY: String
    let privacyAddress: String
}

struct ExportedSession {
    let walletPublicKeyX: String
    let walletPublicKeyY: String
    let viewingKey: String
    let viewingPublicKeyX: String
    let viewingPublicKeyY: String
    let nullifyingKey: String
    let nullifyingPublicKeyX: String
    let nullifyingPublicKeyY: String
    let mpk: String
    let accountId: String
    let jwt: String
    let jwtExpiry: UInt64
    let walletAddress: String
}

protocol WalletDelegate: AnyObject {
    func getAddress() async throws -> String
    func getChainId() async throws -> UInt64
    func signMessage(message: String) async throws -> String
    func signTypedData(typedDataJson: String) async throws -> String
    func sendTransaction(toAddress: String, value: String, data: String) async throws -> String
}

protocol TokenProvider: AnyObject {
    func getToken(loginPayloadJson: String) async throws -> TokenResponse
}

struct TokenResponse {
    let token: String      // JWT access token
    let expiresIn: UInt64  // Token lifetime in seconds
}

class MyTokenProvider: TokenProvider {
    func getToken(loginPayloadJson: String) async throws -> TokenResponse {
        var request = URLRequest(url: URL(string: "https://your-server.com/api/privacy-auth")!)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        request.httpBody = loginPayloadJson.data(using: .utf8)

        let (data, _) = try await URLSession.shared.data(for: request)
        let json = try JSONSerialization.jsonObject(with: data) as! [String: Any]
        return TokenResponse(
            token: json["token"] as! String,
            expiresIn: json["expiresIn"] as! UInt64
        )
    }
}

let result = try await sdk.authenticate(
    wallet: walletDelegate,
    tokenProvider: MyTokenProvider()
)

enum SDKError: Error {
    case notConnected
    case notAuthenticated
    case invalidConfig
    case networkError(String)
    case walletError(String)
    case signatureRejected
    case insufficientBalance
    case invalidAddress
    case invalidAmount
    case serializationError(String)
    case authServerError(code: String, message: String)
    case shieldError(code: String, message: String)
    case transferError(code: String, message: String)
    case noteError(code: String, message: String)
    case merkleError(code: String, message: String)
    case apiError(code: String, message: String, retryable: Bool)
    case rateLimited(retryAfterMs: UInt64)
    case forbidden(String)
    case resourceNotFound(String)
    case internalError(String)
}