Skip to main content

​
iOS Quickstart

Get started with Privacy Boost in iOS/Swift in 5 minutes.

​
Installation

​
Swift Package Manager

Add to your Package.swift: 
dependencies: [
    .package(url: "https://github.com/testinprod-io/privacy-boost.git", from: "0.1.0")
]
Or in Xcode:
  1. File → Add Package Dependencies
  2. Enter the repository URL
  3. Select version and add to your target

​
Quick Example

​
1. Create Wallet Delegate

import PrivacyBoost

class MyWalletDelegate: WalletDelegate {
    private let wallet: YourWalletImplementation

    func getAddress() async throws -> String {
        return wallet.address
    }

    func getChainId() async throws -> UInt64 {
        return wallet.chainId
    }

    func signMessage(message: String) async throws -> String {
        return try await wallet.sign(message: message)
    }

    func signTypedData(typedData: String) async throws -> String {
        return try await wallet.signTypedData(typedData)
    }

    func sendTransaction(tx: TransactionRequest) async throws -> String {
        return try await wallet.sendTransaction(tx)
    }
}

​
2. Initialize and Use SDK

import PrivacyBoost

// 1. Create configuration
let config = SdkConfig(
    indexerUrl: "https://test-api.privacy-boost.sunnyside.io/indexer",
    proverUrl: "https://test-api.privacy-boost.sunnyside.io/prover",
    chainId: 11155420,
    shieldContract: "0xB22fD661b322F10d4B7cd0cFcb9578C485423119",
    wethContract: "0x4200000000000000000000000000000000000006"
)

// 2. Initialize SDK
let sdk = try PrivacyBoostSdk(config: config)

// 3. Connect wallet
let walletDelegate = MyWalletDelegate()
let connectResult = try await sdk.connect(wallet: walletDelegate)
print("Connected: \(connectResult.address)")

// 4. Login
let loginResult = try await sdk.login()
print("Privacy address: \(loginResult.privacyAddress)")

// 5. Check balance
let balance = try await sdk.getBalance(tokenAddress: "0x...")
print("Shielded: \(balance.shielded)")

// 6. Deposit
let depositParams = DepositParams(
    tokenAddress: "0x...",
    amount: "1000000000000000000" // 1 token
)
let depositResult = try await sdk.deposit(params: depositParams)
print("Deposit tx: \(depositResult.txHash)")

// 7. Transfer
let transferParams = TransferParams(
    to: recipientPrivacyAddress,
    tokenAddress: "0x...",
    amount: "500000000000000000"
)
let transferResult = try await sdk.transfer(params: transferParams)
print("Transfer tx: \(transferResult.txHash)")

// 8. Withdraw
let withdrawParams = WithdrawParams(
    tokenAddress: "0x...",
    amount: "250000000000000000",
    recipientAddress: "0x..."
)
let withdrawResult = try await sdk.withdraw(params: withdrawParams)
print("Withdraw tx: \(withdrawResult.txHash)")

​
SwiftUI Example

import SwiftUI
import PrivacyBoost

struct ContentView: View {
    @StateObject private var viewModel = WalletViewModel()

    var body: some View {
        VStack {
            if viewModel.isAuthenticated {
                Text("Privacy Address:")
                Text(viewModel.privacyAddress ?? "")
                    .font(.caption)

                Button("Deposit 1 Token") {
                    Task { await viewModel.deposit() }
                }

                Button("Logout") {
                    viewModel.logout()
                }
            } else {
                Button("Connect Wallet") {
                    Task { await viewModel.connect() }
                }
            }
        }
    }
}

@MainActor
class WalletViewModel: ObservableObject {
    @Published var isAuthenticated = false
    @Published var privacyAddress: String?

    private var sdk: PrivacyBoostSdk?

    func connect() async {
        do {
            let config = SdkConfig(/* ... */)
            sdk = try PrivacyBoostSdk(config: config)

            let wallet = MyWalletDelegate()
            try await sdk?.connect(wallet: wallet)

            let result = try await sdk?.login()
            privacyAddress = result?.privacyAddress
            isAuthenticated = true
        } catch {
            print("Connection failed: \(error)")
        }
    }

    func deposit() async {
        let params = DepositParams(
            tokenAddress: "0x...",
            amount: "1000000000000000000"
        )
        try? await sdk?.deposit(params: params)
    }

    func logout() {
        sdk?.logout()
        isAuthenticated = false
        privacyAddress = nil
    }
}

​
Keychain Storage

Store sessions securely: 
import Security

func saveSession(_ session: ExportedSession) throws {
    let data = try JSONEncoder().encode(session)
    let query: [String: Any] = [
        kSecClass as String: kSecClassGenericPassword,
        kSecAttrAccount as String: "privacy_session",
        kSecValueData as String: data
    ]
    SecItemAdd(query as CFDictionary, nil)
}

func loadSession() throws -> ExportedSession? {
    let query: [String: Any] = [
        kSecClass as String: kSecClassGenericPassword,
        kSecAttrAccount as String: "privacy_session",
        kSecReturnData as String: true
    ]
    var result: AnyObject?
    SecItemCopyMatching(query as CFDictionary, &result)

    guard let data = result as? Data else { return nil }
    return try JSONDecoder().decode(ExportedSession.self, from: data)
}

​
Next Steps