do {
    let result = try await sdk.unshield(
        tokenAddress: "0x...token-address",
        amount: "1000000000000000000", // 1 token
        recipient: "0x...recipient-address"
    )
    print("Transaction hash: \(result.txHash)")
} catch {
    print("Withdrawal failed: \(error)")
}

struct UnshieldResult {
    let txHash: String  // Main withdrawal transaction hash
    let fee: String     // Fee paid (in wei)
}

let myAddress = sdk.getWalletAddress()!

let result = try await sdk.unshield(
    tokenAddress: "0x...",
    amount: "1000000000000000000",
    recipient: myAddress
)

let recipientAddress = "0x..."

// Validate address first
guard sdk.isValidAddress(recipientAddress) else {
    print("Invalid recipient address")
    return
}

let result = try await sdk.unshield(
    tokenAddress: "0x...",
    amount: "1000000000000000000",
    recipient: recipientAddress
)

// Check available balance first
let balance = try await sdk.getBalance(tokenAddress: tokenAddress)

guard let shielded = UInt64(balance.shieldedBalance),
      let unshieldAmount = UInt64(amount),
      unshieldAmount <= shielded else {
    print("Insufficient shielded balance")
    return
}

let result = try await sdk.unshield(
    tokenAddress: tokenAddress,
    amount: amount,
    recipient: recipientAddress
)

do {
    let result = try await sdk.unshield(
        tokenAddress: tokenAddress,
        amount: amount,
        recipient: recipient
    )
} catch SDKError.insufficientBalance {
    print("Not enough shielded balance")
} catch SDKError.invalidAddress {
    print("Invalid recipient address")
} catch SDKError.invalidAmount {
    print("Invalid amount format")
} catch SDKError.walletError(let message) {
    print("Wallet error: \(message)")
} catch SDKError.networkError(let message) {
    print("Network error: \(message)")
} catch {
    print("Withdrawal error: \(error)")
}

func validateWithdrawal(tokenAddress: String, amount: String) async throws {
    let balance = try await sdk.getBalance(tokenAddress: tokenAddress)

    guard let shielded = UInt64(balance.shieldedBalance),
          let requested = UInt64(amount),
          requested <= shielded else {
        throw SDKError.insufficientBalance(message: "Insufficient shielded balance")
    }
}

func validateRecipient(_ address: String) throws {
    guard sdk.isValidAddress(address) else {
        throw SDKError.invalidAddress
    }
    guard address != "0x0000000000000000000000000000000000000000" else {
        throw SDKError.invalidAddress
    }
}

// Show estimated time in your UI
statusLabel.text = "Generating proof... This may take up to 30 seconds."

let result = try await sdk.unshield(
    tokenAddress: tokenAddress,
    amount: amount,
    recipient: recipient
)

statusLabel.text = "Withdrawal complete!"