do {
    let transactions = try await sdk.getTransactionHistory(
        txType: nil,
        tokenAddress: nil,
        limit: nil
    )

    for tx in transactions {
        print("\(tx.txType): \(tx.amount) - \(tx.txHash)")
    }
} catch {
    print("Failed to get history: \(error)")
}

struct Transaction {
    let txHash: String           // Transaction hash
    let txType: String           // "deposit", "withdraw", or "transfer"
    let tokenAddress: String     // Token contract address
    let amount: String           // Amount in wei
    let direction: String        // "incoming" or "outgoing"
    let senderPubKey: String     // Sender's public key
    let receiverPubKeys: [String] // Receiver public keys
    let createdAt: UInt64        // Unix timestamp
}

// Only deposits
let deposits = try await sdk.getTransactionHistory(
    txType: "deposit",
    tokenAddress: nil,
    limit: nil
)

// Only withdrawals
let withdrawals = try await sdk.getTransactionHistory(
    txType: "withdraw",
    tokenAddress: nil,
    limit: nil
)

// Only transfers
let transfers = try await sdk.getTransactionHistory(
    txType: "transfer",
    tokenAddress: nil,
    limit: nil
)

let usdcHistory = try await sdk.getTransactionHistory(
    txType: nil,
    tokenAddress: "0x...usdc-address",
    limit: nil
)

// Get last 10 transactions
let recent = try await sdk.getTransactionHistory(
    txType: nil,
    tokenAddress: nil,
    limit: 10
)

// Last 5 USDC deposits
let recentUsdcDeposits = try await sdk.getTransactionHistory(
    txType: "deposit",
    tokenAddress: "0x...usdc-address",
    limit: 5
)

// Incoming USDC only, 25 per page, gateway operations collapsed
let page = try await sdk.queryTransactionHistory(query: TransactionHistoryQuery(
    tokenId: 1,
    direction: .incoming,
    limit: 25,
    collapseGateway: true
))

for tx in page.data {
    print("\(tx.txType): \(tx.txHash)")
}

// page.next is the cursor for the following page; nil at the end

struct TransactionHistoryView: View {
    @State private var transactions: [Transaction] = []
    @State private var isLoading = true
    @State private var selectedFilter = "all"

    let filters = ["all", "deposit", "withdraw", "transfer"]

    var body: some View {
        VStack {
            // Filter picker
            Picker("Filter", selection: $selectedFilter) {
                ForEach(filters, id: \.self) { filter in
                    Text(filter.capitalized).tag(filter)
                }
            }
            .pickerStyle(.segmented)
            .padding(.horizontal)

            // Transaction list
            List {
                if isLoading {
                    ProgressView("Loading transactions...")
                } else if transactions.isEmpty {
                    Text("No transactions found")
                        .foregroundColor(.secondary)
                } else {
                    ForEach(transactions, id: \.txHash) { tx in
                        TransactionRow(transaction: tx)
                    }
                }
            }
        }
        .task { await loadTransactions() }
        .onChange(of: selectedFilter) { _ in
            Task { await loadTransactions() }
        }
        .refreshable {
            await loadTransactions()
        }
    }

    private func loadTransactions() async {
        isLoading = true
        do {
            let typeFilter = selectedFilter == "all" ? nil : selectedFilter
            transactions = try await sdk.getTransactionHistory(
                txType: typeFilter,
                tokenAddress: nil,
                limit: 50
            )
        } catch {
            print("Failed to load transactions: \(error)")
        }
        isLoading = false
    }
}

struct TransactionRow: View {
    let transaction: Transaction

    var icon: String {
        switch transaction.txType {
        case "deposit": return "arrow.down.circle.fill"
        case "withdraw": return "arrow.up.circle.fill"
        case "transfer": return "arrow.left.arrow.right.circle.fill"
        default: return "circle.fill"
        }
    }

    var formattedDate: String {
        let date = Date(timeIntervalSince1970: TimeInterval(transaction.createdAt))
        let formatter = DateFormatter()
        formatter.dateStyle = .medium
        formatter.timeStyle = .short
        return formatter.string(from: date)
    }

    var body: some View {
        HStack {
            Image(systemName: icon)
                .foregroundColor(transaction.txType == "deposit" ? .green : .blue)

            VStack(alignment: .leading) {
                Text(transaction.txType.capitalized)
                    .font(.headline)
                Text(formattedDate)
                    .font(.caption)
                    .foregroundColor(.secondary)
            }

            Spacer()

            Text(transaction.amount)
                .font(.subheadline)
                .monospacedDigit()
        }
    }
}

do {
    let transactions = try await sdk.getTransactionHistory(
        txType: nil,
        tokenAddress: nil,
        limit: nil
    )
} catch SDKError.notAuthenticated {
    print("Please log in first")
} catch SDKError.networkError(let message) {
    print("Network error: \(message)")
} catch {
    print("Failed to get history: \(error)")
}

func loadPage(offset: Int, pageSize: UInt32 = 20) async throws -> [Transaction] {
    return try await sdk.getTransactionHistory(
        txType: nil,
        tokenAddress: nil,
        limit: pageSize
    )
}

let shieldResult = try await sdk.shield(
    tokenAddress: tokenAddress,
    amount: amount
)

// Refresh transaction list
let updatedHistory = try await sdk.getTransactionHistory(
    txType: nil,
    tokenAddress: nil,
    limit: 20
)