Data Types

data class DynamicSDKConfig(
    val environmentId: String      // Your Dynamic environment ID (required)
)

val config = DynamicSDKConfig(
    environmentId = "YOUR_ENV_ID"
)

DynamicSDK.initialize(context = applicationContext, config = config)

data class UserProfile(
    val userId: String?,
    val email: String?,
    val phoneNumber: String?,
    // Additional fields available
)

val user = sdk.auth.authenticatedUser
if (user != null) {
    println("User ID: ${user.userId}")
    println("Email: ${user.email}")
    println("Phone: ${user.phoneNumber}")
}

data class PhoneData(
    val dialCode: String,   // e.g., "+1"
    val iso2: String,       // e.g., "US"
    val phone: String       // Phone number without country code
)

val phoneData = PhoneData(
    dialCode = "+1",
    iso2 = "US",
    phone = "5551234567"
)

sdk.auth.sms.sendOTP(phoneData)

data class SignInWithExternalJwtParams(
    val jwt: String     // The external JWT token
)

sdk.auth.externalAuth.signInWithExternalJwt(
    SignInWithExternalJwtParams(jwt = "your-jwt-token")
)

data class BaseWallet(
    val address: String,        // Wallet address
    val chain: String,          // "EVM" or "SOL"
    val walletName: String?,    // Wallet name (optional)
    val id: String?             // Wallet ID for API operations (optional)
)

val wallets = sdk.wallets.userWallets
wallets.forEach { wallet ->
    println("Address: ${wallet.address}")
    println("Chain: ${wallet.chain}")
    println("Name: ${wallet.walletName}")
    println("ID: ${wallet.id}")
}

data class GenericNetwork(
    val name: String,
    val chainId: Int?,      // For EVM networks
    val networkId: String?  // For Solana networks
)

val evmNetworks = sdk.networks.evm
val ethereum = evmNetworks.first { it.chainId == 1 }
println("Network: ${ethereum.name}, Chain ID: ${ethereum.chainId}")

val solanaNetworks = sdk.networks.solana
val mainnet = solanaNetworks.first { it.networkId == "mainnet-beta" }
println("Network: ${mainnet.name}, Network ID: ${mainnet.networkId}")

data class EthereumTransaction(
    val to: String,                     // Recipient address
    val value: String,                  // Amount in Wei (as String)
    val gasLimit: Int,                  // Gas limit
    val maxFeePerGas: Int? = null,      // Max fee per gas (optional)
    val maxPriorityFeePerGas: Int? = null, // Priority fee (optional)
    val data: String? = null            // Contract data (optional)
)

val transaction = EthereumTransaction(
    to = "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
    value = "1000000000000000", // 0.001 ETH in Wei
    gasLimit = 21000,
    maxFeePerGas = 30000000000,
    maxPriorityFeePerGas = 2000000000
)

data class WriteContractInput(
    val address: String,                // Contract address
    val functionName: String,           // Function to call
    val args: List<Any>,                // Function arguments
    val abi: List<Map<String, Any>>     // Contract ABI
)

val input = WriteContractInput(
    address = "0x...",
    functionName = "transfer",
    args = listOf("0x...", "1000000000000000000"), // recipient, amount
    abi = parseAbiJson(Erc20.abi)
)

data class GasPrice(
    val maxFeePerGas: Int,
    val maxPriorityFeePerGas: Int
)

val client = sdk.evm.createPublicClient(chainId = 1)
val gasPrice = client.getGasPrice()
println("Max fee: ${gasPrice.maxFeePerGas}")
println("Priority fee: ${gasPrice.maxPriorityFeePerGas}")

object Erc20 {
    val abi: String  // Standard ERC20 ABI as JSON string
}

// Parse ERC20 ABI for contract interactions
val abiList = parseAbiJson(Erc20.abi)

data class BlockhashResult(
    val blockhash: String,
    val lastValidBlockHeight: Long
)

val connection = sdk.solana.createConnection()
val result = connection.getLatestBlockhash()
println("Blockhash: ${result.blockhash}")
println("Valid until block: ${result.lastValidBlockHeight}")

data class MfaDevice(
    val id: String?,
    val type: MfaDeviceType?
)

enum class MfaDeviceType {
    totp
}

val devices = sdk.mfa.getUserDevices()
devices.forEach { device ->
    println("Device ID: ${device.id}")
    println("Type: ${device.type?.name}")
}

data class MfaAddDevice(
    val secret: String,     // Secret for QR code generation
    val id: String?
)

val device = sdk.mfa.addDevice("totp")
println("Secret for QR code: ${device.secret}")
// Display QR code with this secret for user to scan

data class MfaAuthenticateDevice(
    val code: String,
    val deviceId: String,
    val createMfaToken: MfaCreateToken
)

val token = sdk.mfa.authenticateDevice(
    MfaAuthenticateDevice(
        code = "123456",
        deviceId = "device-id",
        createMfaToken = MfaCreateToken(singleUse = true)
    )
)

data class MfaCreateToken(
    val singleUse: Boolean
)

val createToken = MfaCreateToken(singleUse = true)

data class UserPasskey(
    val id: String,
    val createdAt: String,      // ISO format
    val lastUsedAt: String?,    // ISO format (optional)
    val isDefault: Boolean?
)

val passkeys = sdk.passkeys.getPasskeys()
passkeys.forEach { passkey ->
    println("ID: ${passkey.id}")
    println("Created: ${passkey.createdAt}")
    println("Last used: ${passkey.lastUsedAt}")
    println("Is default: ${passkey.isDefault}")
}

data class DeletePasskeyRequest(
    val passkeyId: String
)

sdk.passkeys.deletePasskey(
    DeletePasskeyRequest(passkeyId = "passkey-id")
)

data class PasskeyAuthenticationResponse(
    val jwt: String?    // MFA token
)

val response = sdk.passkeys.authenticatePasskeyMFA(
    createMfaToken = MfaCreateToken(singleUse = true),
    relatedOriginRpId = null
)
println("MFA Token: ${response.jwt}")

try {
    sdk.auth.email.verifyOTP(code)
} catch (e: Exception) {
    Log.e("SDK", "Error: ${e.message}")
}

viewModelScope.launch {
    try {
        val wallets = sdk.wallets.userWallets
    } catch (e: Exception) {
        errorMessage.value = "Failed: ${e.message}"
    }
}