Data Types & Objects

public struct SdkUser {
    public let id: String
    public let email: String?
    public let phoneNumber: String?
    public let verifiedCredentials: [JwtVerifiedCredential]?
    public let token: String?
    public let projectSettings: ProjectSettings?
    // ... other properties
}

if let currentUser = dynamicClient.user {
    print("User ID: \(currentUser.id)")
    print("Email: \(currentUser.email ?? "Not provided")")
    print("Phone: \(currentUser.phoneNumber ?? "Not provided")")
    print("Token: \(currentUser.token ?? "No token")")

    if let credentials = currentUser.verifiedCredentials {
        print("Verified credentials: \(credentials.count)")
    }

    if let settings = currentUser.projectSettings {
        print("Project: \(settings.general.displayName ?? "Unknown")")
    }
}

public struct JwtVerifiedCredential {
    public let id: String
    public let format: CredentialFormat
    public let oauthProvider: OAuthProvider?
    public let walletProvider: WalletProvider?
    public let walletName: String?
    public let chain: String?
    public let publicIdentifier: String?
    public let walletProperties: WalletProperties?
    // ... other properties
}

if let verifiedCredentials = dynamicClient.user?.verifiedCredentials {
    for credential in verifiedCredentials {
        print("Credential ID: \(credential.id)")
        print("Format: \(credential.format.rawValue)")

        if let oauthProvider = credential.oauthProvider {
            print("OAuth Provider: \(oauthProvider.rawValue)")
        }

        if let walletProvider = credential.walletProvider {
            print("Wallet Provider: \(walletProvider.rawValue)")
        }

        if let walletName = credential.walletName {
            print("Wallet Name: \(walletName)")
        }

        if let chain = credential.chain {
            print("Chain: \(chain)")
        }

        if let publicIdentifier = credential.publicIdentifier {
            print("Public Identifier: \(publicIdentifier)")
        }
    }
}

public enum CredentialFormat: String {
    case blockchain = "blockchain"
    case oauth = "oauth"
    // ... other formats
}

public enum WalletProvider: String {
    case dynamic = "dynamic"
    case metamask = "metamask"
    case walletconnect = "walletconnect"
    // ... other providers
}

public struct OTPVerification {
    public let email: String?
    public let phoneNumber: String?
    public let phoneCountryCode: String?
    public let isoCountryCode: String?
    public let verificationUUID: String
}

// Email OTP verification
let emailOtp = OTPVerification(
    email: "[email protected]",
    phoneNumber: nil,
    phoneCountryCode: nil,
    isoCountryCode: nil,
    verificationUUID: "uuid-123"
)

// SMS OTP verification
let smsOtp = OTPVerification(
    email: nil,
    phoneNumber: "1234567890",
    phoneCountryCode: "+1",
    isoCountryCode: "US",
    verificationUUID: "uuid-456"
)

public enum ProviderType: String {
    case apple = "apple"
    case google = "google"
    case twitter = "twitter"
    case discord = "discord"
    case github = "github"
    case twitch = "twitch"
    case facebook = "facebook"
    case farcaster = "farcaster"
    // ... other providers
}

let provider: ProviderType = .google

switch provider {
case .apple:
    print("Apple ID")
case .google:
    print("Google account")
case .twitter:
    print("Twitter account")
case .discord:
    print("Discord account")
case .github:
    print("GitHub account")
case .twitch:
    print("Twitch account")
case .facebook:
    print("Facebook account")
case .farcaster:
    print("Farcaster account")
default:
    print("Other provider")
}

public struct BlockchainAddress {
    public func asString() -> String
}

public func asString() -> String

let blockchainAddress = ethereumWallet.accountAddress
let addressString = blockchainAddress.asString()
print("Blockchain Address: \(addressString)")

public struct KeyShares {
    public let id: Uuid
    // Key shares implementation details
}

func checkKeySharesAvailability(client: DynamicClient, walletAddress: String) -> Bool {
    let keyShares = loadKeyShares(client: client, accountAddress: walletAddress)
    return keyShares != nil
}

let hasKeyShares = checkKeySharesAvailability(
    client: dynamicClient,
    walletAddress: ethereumWallet.address.asString()
)

print("Key shares available: \(hasKeyShares)")

// Wei amounts (1 ETH = 10^18 Wei)
let oneEthInWei = BigUInt(1000000000000000000)
let halfEthInWei = BigUInt(500000000000000000)

// Gas limits
let standardGasLimit = BigUInt(21_000)
let erc20GasLimit = BigUInt(65_000)

// Chain IDs
let sepoliaChainId = BigUInt(11155111)
let mainnetChainId = BigUInt(1)

// Empty data for ETH transfers
let emptyData = Data()

// Custom data for contract interactions
let customData = Data([0x12, 0x34, 0x56, 0x78])

// String to data conversion
let messageData = "Hello".data(using: .utf8) ?? Data()

do {
    let result = try await someSDKFunction()
} catch {
    if let nsError = error as NSError? {
        switch nsError.code {
        case 1003:
            print("Could not determine wallet ID from address")
        case 1004:
            print("Invalid OTP code")
        case 1005:
            print("Network error")
        default:
            print("Unknown error: \(error)")
        }
    } else {
        print("Error: \(error)")
    }
}