Ethereum Blockchain Anchor Integration

This guide covers the Ethereum mainnet blockchain anchor client integration for TrustWeave. The Ethereum adapter provides production-ready anchoring for Ethereum mainnet and Sepolia testnet.

Overview

The chains/plugins/ethereum module provides a complete implementation of TrustWeave’s BlockchainAnchorClient interface using Ethereum mainnet. This integration enables you to:

Anchor credential digests on Ethereum mainnet
Support Sepolia testnet for development and testing
Use EVM-compatible transaction data storage
Leverage Ethereum’s security and decentralization

Installation

Add the Ethereum adapter module to your dependencies:

dependencies {
    implementation("org.trustweave:anchors-plugins-ethereum:0.6.0")
    implementation("org.trustweave:anchors-anchor-core:0.6.0")
    implementation("org.trustweave:common:0.6.0")
    implementation("org.trustweave:distribution-all:0.6.0")

    // Web3j for Ethereum blockchain
    implementation("org.web3j:core:5.0.1")
}

Configuration

Basic Configuration

import org.trustweave.anchor.*
import org.trustweave.anchor.ethereum.*

// Create Ethereum anchor client for mainnet
val options = mapOf(
    "rpcUrl" to "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY",
    "privateKey" to "0x..." // Optional: for signing transactions
)

val client = EthereumBlockchainAnchorClient(
    EthereumBlockchainAnchorClient.MAINNET,
    options
)

Pre-configured Networks

// Ethereum mainnet
val mainnetClient = EthereumBlockchainAnchorClient(
    EthereumBlockchainAnchorClient.MAINNET,
    mapOf(
        "rpcUrl" to "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY",
        "privateKey" to "0x..."
    )
)

// Sepolia testnet
val sepoliaClient = EthereumBlockchainAnchorClient(
    EthereumBlockchainAnchorClient.SEPOLIA,
    mapOf(
        "rpcUrl" to "https://eth-sepolia.g.alchemy.com/v2/YOUR_KEY",
        "privateKey" to "0x..."
    )
)

SPI Auto-Discovery

When the module is on the classpath, Ethereum adapter is automatically available:

import org.trustweave.anchor.*
import org.trustweave.anchor.spi.*
import java.util.ServiceLoader

// Discover Ethereum provider
val providers = ServiceLoader.load(BlockchainAnchorClientProvider::class.java)
val ethereumProvider = providers.find { it.name == "ethereum" }

// Create client
val client = ethereumProvider?.create(
    EthereumBlockchainAnchorClient.MAINNET,
    mapOf("rpcUrl" to "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY")
)

Integration Helper

import org.trustweave.anchor.ethereum.*

// Auto-discover and register (returns EthereumIntegrationResult with registry + registeredChains)
val result = EthereumIntegration.discoverAndRegister(
    options = mapOf(
        "rpcUrl" to "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY"
    )
)

// Or manually setup specific chains
val setup = EthereumIntegration.setup(
    chainIds = listOf(EthereumBlockchainAnchorClient.SEPOLIA),
    options = mapOf(
        "rpcUrl" to "https://eth-sepolia.g.alchemy.com/v2/YOUR_KEY"
    )
)

Usage Examples

Anchoring Data

import org.trustweave.anchor.*
import org.trustweave.anchor.ethereum.*
import kotlinx.serialization.json.*
import org.trustweave.core.json.jsonData

val client = EthereumBlockchainAnchorClient(
    EthereumBlockchainAnchorClient.SEPOLIA,
    mapOf(
        "rpcUrl" to "https://eth-sepolia.g.alchemy.com/v2/YOUR_KEY",
        "privateKey" to "0x..."
    )
)

// Anchor a JSON payload
val payload = jsonData {
    "digest" to "uABC123..."
    "timestamp" to System.currentTimeMillis()
}

val result = client.writePayload(payload, "application/json")
println("Anchored to: ${result.ref.txHash}")

Reading Anchored Data

// Read anchored data — readPayload takes the AnchorRef returned by writePayload
val readResult = client.readPayload(result.ref)
println("Retrieved: ${readResult.payload}")

Chain IDs

Network	Chain ID	RPC URL Example
Ethereum Mainnet	`eip155:1`	`https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY`
Sepolia Testnet	`eip155:11155111`	`https://eth-sepolia.g.alchemy.com/v2/YOUR_KEY`

Integration with TrustWeave

import org.trustweave.trust.TrustWeave
import org.trustweave.anchor.ethereum.*
import kotlinx.serialization.json.JsonElement
import org.trustweave.core.json.jsonData

val trustWeave = TrustWeave.build {
    did { method("key") { algorithm("Ed25519") } }
    anchor {
        chain(EthereumBlockchainAnchorClient.MAINNET) {
            provider("ethereum")
            options { "rpcUrl" to "https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY" }
        }
    }
}

val digest = "uABC123..."
val payload = jsonData { "digest" to digest }
val result = trustWeave.blockchains.anchor(
    data = payload,
    serializer = JsonElement.serializer(),
    chainId = EthereumBlockchainAnchorClient.MAINNET
)
println("Anchored: ${result.ref.txHash}")

Configuration Options

Option	Type	Required	Description
`rpcUrl`	String	Yes	Ethereum RPC endpoint URL
`privateKey`	String	No	Private key for signing transactions (hex format with 0x prefix)
`contractAddress`	String	No	Optional contract address for custom anchoring

Best Practices

Use Sepolia for testing: Always test on Sepolia before using mainnet
RPC endpoint reliability: Use reliable RPC providers (Alchemy, Infura, etc.)
Gas management: Monitor gas prices, especially on mainnet
Private key security: Never hardcode private keys, use environment variables or secure vaults
Error handling: Implement proper error handling for transaction failures