Blockchain Integration

EVM Operations (sdk.evm)

createPublicClient

Create a public client for interacting with an EVM chain.

fun createPublicClient(chainId: Int): EvmPublicClient

Parameters

• chainId (Int) - The chain ID (e.g., 1 for Ethereum mainnet, 137 for Polygon)

Returns

• EvmPublicClient - Public client for the chain

Example

val sdk = DynamicSDK.getInstance()
val client = sdk.evm.createPublicClient(chainId = 1) // Ethereum mainnet

getGasPrice

Get the current gas price for a chain.

suspend fun getGasPrice(): GasPrice

Returns

• GasPrice - Current gas price information

Example

val client = sdk.evm.createPublicClient(chainId = 1)

viewModelScope.launch {
    try {
        val gasPrice = client.getGasPrice()
        println("Gas price: $gasPrice")
    } catch (e: Exception) {
        println("Failed to get gas price: ${e.message}")
    }
}

sendTransaction

Send a transaction on an EVM chain.

suspend fun sendTransaction(wallet: BaseWallet, transaction: EthereumTransaction): String

Parameters

• wallet (BaseWallet) - The wallet to send from
• transaction (EthereumTransaction) - Transaction details

Returns

• String - Transaction hash

Example

val sdk = DynamicSDK.getInstance()

viewModelScope.launch {
    try {
        val transaction = EthereumTransaction(
            to = recipientAddress,
            value = "1000000000000000", // 0.001 ETH in Wei
            gasLimit = 21000
        )
        val txHash = sdk.evm.sendTransaction(wallet, transaction)
        println("Transaction sent: $txHash")
    } catch (e: Exception) {
        println("Transaction failed: ${e.message}")
    }
}

signTransaction

Sign a transaction without sending it.

suspend fun signTransaction(wallet: BaseWallet, transaction: EthereumTransaction): String

Parameters

• wallet (BaseWallet) - The wallet to sign with
• transaction (EthereumTransaction) - Transaction to sign

Returns

• String - Signed transaction

Example

viewModelScope.launch {
    try {
        val signedTx = sdk.evm.signTransaction(wallet, transaction)
        println("Signed transaction: $signedTx")
    } catch (e: Exception) {
        println("Failed to sign: ${e.message}")
    }
}

writeContract

Write to a smart contract (call a contract function).

suspend fun writeContract(wallet: BaseWallet, input: WriteContractInput): String

Parameters

• wallet (BaseWallet) - The wallet to call from
• input (WriteContractInput) - Contract call parameters

Returns

• String - Transaction hash

Example

val sdk = DynamicSDK.getInstance()

viewModelScope.launch {
    try {
        // Parse ERC20 ABI
        val abiList = parseAbiJson(Erc20.abi)

        // Calculate amount with decimals
        val decimals = 18
        val amount = BigDecimal("100")
        val multiplier = BigDecimal.TEN.pow(decimals)
        val rawAmount = amount.multiply(multiplier).toBigInteger()

        val input = WriteContractInput(
            address = tokenContractAddress,
            abi = abiList,
            functionName = "transfer",
            args = listOf(recipientAddress, rawAmount.toString())
        )

        val txHash = sdk.evm.writeContract(wallet, input)
        println("Contract write successful: $txHash")
    } catch (e: Exception) {
        println("Contract write failed: ${e.message}")
    }
}

Solana Operations (sdk.solana)

createConnection

Create a connection to a Solana network.

fun createConnection(): SolanaConnection

Returns

• SolanaConnection - Connection to the Solana network

Example

val sdk = DynamicSDK.getInstance()
val connection = sdk.solana.createConnection()

getLatestBlockhash

Get the latest blockhash for transaction creation.

suspend fun getLatestBlockhash(): BlockhashResult

Returns

• BlockhashResult - Contains the blockhash and last valid block height

Example

val connection = sdk.solana.createConnection()

viewModelScope.launch {
    try {
        val blockhashResult = connection.getLatestBlockhash()
        val blockhash = blockhashResult.blockhash
        println("Latest blockhash: $blockhash")
    } catch (e: Exception) {
        println("Failed to get blockhash: ${e.message}")
    }
}

createSigner

Create a signer for signing Solana transactions.

fun createSigner(wallet: BaseWallet): SolanaSigner

Parameters

• wallet (BaseWallet) - The Solana wallet

Returns

• SolanaSigner - Signer for the wallet

Example

val sdk = DynamicSDK.getInstance()
val signer = sdk.solana.createSigner(wallet)

signMessage

Sign a message with a Solana wallet.

suspend fun signMessage(message: String): String

Parameters

• message (String) - The message to sign

Returns

• String - The signature

Example

val signer = sdk.solana.createSigner(wallet)

viewModelScope.launch {
    try {
        val signature = signer.signMessage("Hello from Dynamic SDK!")
        println("Signature: $signature")
    } catch (e: Exception) {
        println("Failed to sign message: ${e.message}")
    }
}

signEncodedTransaction

Sign a Solana transaction (base64 encoded).

suspend fun signEncodedTransaction(base64Transaction: String): String

Parameters

• base64Transaction (String) - Base64 encoded transaction

Returns

• String - Signed transaction (base64 encoded)

Example

val signer = sdk.solana.createSigner(wallet)

viewModelScope.launch {
    try {
        val signedTx = signer.signEncodedTransaction(base64Transaction)
        println("Signed transaction: $signedTx")
    } catch (e: Exception) {
        println("Failed to sign transaction: ${e.message}")
    }
}

signAndSendEncodedTransaction

Sign and send a Solana transaction.

suspend fun signAndSendEncodedTransaction(base64Transaction: String): String

Parameters

• base64Transaction (String) - Base64 encoded transaction

Returns

• String - Transaction signature

Example

val signer = sdk.solana.createSigner(wallet)

viewModelScope.launch {
    try {
        val signature = signer.signAndSendEncodedTransaction(base64Transaction)
        println("Transaction sent: $signature")
    } catch (e: Exception) {
        println("Transaction failed: ${e.message}")
    }
}

Network Management (sdk.networks)

Available Networks

Get lists of available EVM and Solana networks.

val evmNetworks: List<GenericNetwork> = sdk.networks.evm
val solanaNetworks: List<GenericNetwork> = sdk.networks.solana

Example

val sdk = DynamicSDK.getInstance()

// Get all EVM networks
val evmNetworks = sdk.networks.evm
evmNetworks.forEach { network ->
    println("EVM Network: ${network.name}, Chain ID: ${network.chainId}")
}

// Get all Solana networks
val solanaNetworks = sdk.networks.solana
solanaNetworks.forEach { network ->
    println("Solana Network: ${network.name}, Network ID: ${network.networkId}")
}

// Find a specific network
val polygon = evmNetworks.first { it.chainId == 137 }
println("Found Polygon: ${polygon.name}")

Data Types

EthereumTransaction

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)
)

WriteContractInput

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
)

GasPrice

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

GenericNetwork

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

BlockhashResult

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