GoDiddy Integration

This guide covers the GoDiddy integration for TrustWeave. The GoDiddy plugin provides HTTP integration with GoDiddy services, including Universal Resolver, Registrar, Issuer, and Verifier, supporting 20+ DID methods.

Overview

The did/plugins/godiddy module provides HTTP integration with GoDiddy services for DID operations. This integration enables you to:

  • Resolve DIDs using GoDiddy Universal Resolver
  • Register DIDs via GoDiddy Registrar
  • Issue credentials using GoDiddy Issuer
  • Verify credentials using GoDiddy Verifier
  • Support 20+ DID methods through GoDiddy’s universal interfaces

Installation

Add the GoDiddy module to your dependencies:

1
2
3
4
5
6
7
8

dependencies {
    implementation("org.trustweave:did-plugins-godiddy:0.6.0")
    implementation("org.trustweave:did-did-core:0.6.0")
    implementation("org.trustweave:common:0.6.0")

    // HTTP client (OkHttp recommended)
    implementation("com.squareup.okhttp3:okhttp:4.12.0")
}

Configuration

Basic Configuration 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

import org.trustweave.godiddy.*
import org.trustweave.did.*

// Create configuration
val config = GodiddyConfig(
    baseUrl = "https://api.godiddy.com",  // Default public API
    timeout = 30000,
    apiKey = null  // Optional API key if required
)

// Create GoDiddy client
val client = GodiddyClient(config)

// Create DID method
val method = GodiddyDidMethod(client, config)

Custom Configuration 

1
2
3
4
5
6
7
8
9

// Use self-hosted GoDiddy instance
val config = GodiddyConfig(
    baseUrl = "https://godiddy.example.com",
    timeout = 60000,
    apiKey = "your-api-key"
)

val client = GodiddyClient(config)
val method = GodiddyDidMethod(client, config)

SPI Auto-Discovery

When the did/plugins/godiddy module is on the classpath, GoDiddy is automatically available:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

import org.trustweave.did.*
import java.util.ServiceLoader

// Discover GoDiddy provider
val providers = ServiceLoader.load(DidMethodProvider::class.java)
val godiddyProvider = providers.find { it.supportedMethods.contains("godiddy") }

// Create method with configuration
val options = didCreationOptions {
    property("baseUrl", "https://api.godiddy.com")
    property("timeout", 30000L)
}

val method = godiddyProvider?.create("godiddy", options)

Usage Examples

DID Resolution 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import org.trustweave.godiddy.*
import org.trustweave.did.resolver.DidResolutionResult

val client = GodiddyClient(GodiddyConfig.default())
val resolver = GodiddyResolver(client)

// Resolve any DID via Universal Resolver
val did = "did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK"
val resolutionResult = resolver.resolveDid(did)

when (resolutionResult) {
    is DidResolutionResult.Success -> {
        println("Resolved DID: ${resolutionResult.document.id}")
        println("Document: ${resolutionResult.document}")
    }
    is DidResolutionResult.Failure -> {
        println("Resolution failed: ${resolutionResult::class.simpleName}")
    }
}

DID Registration 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

import org.trustweave.godiddy.*

val client = GodiddyClient(GodiddyConfig.default())
val registrar = GodiddyRegistrar(client)

// Register DID via Registrar
val options = didCreationOptions {
    property("method", "key")
    property("algorithm", "Ed25519")
}

val registrationResult = registrar.registerDid(options)

registrationResult.fold(
    onSuccess = { didDoc ->
        println("Registered DID: ${didDoc.id}")
    },
    onFailure = { error ->
        println("Registration failed: ${error.message}")
    }
)

Credential Issuance 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import org.trustweave.godiddy.*

val client = GodiddyClient(GodiddyConfig.default())
val issuer = GodiddyIssuer(client)

// Issue credential via GoDiddy Issuer
val credentialRequest = mapOf(
    "issuerDid" to "did:key:z6Mk...",
    "credentialSubject" to mapOf(
        "id" to "did:key:z6Mk...",
        "type" to "VerifiableCredential",
        "credentialSubject" to mapOf(
            "id" to "did:example:subject",
            "name" to "Alice"
        )
    )
)

val issuanceResult = issuer.issueCredential(credentialRequest)

issuanceResult.fold(
    onSuccess = { credential ->
        println("Issued credential: ${credential.id}")
    },
    onFailure = { error ->
        println("Issuance failed: ${error.message}")
    }
)

Credential Verification 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import org.trustweave.godiddy.*
import kotlinx.coroutines.runBlocking
import kotlinx.serialization.json.JsonObject

val client = GodiddyClient(GodiddyConfig.default())
val verifier = GodiddyVerifier(client)

// verifyCredential is suspend and expects the credential as JsonObject
fun main() = runBlocking {
    val credentialJson: JsonObject = /* build or parse VC JSON */
    val verificationResult = verifier.verifyCredential(credentialJson)
    if (verificationResult.verified) {
        println("Credential is valid")
    } else {
        println("Credential is invalid: ${verificationResult.error}")
    }
}

Supported DID Methods

GoDiddy supports 20+ DID methods through Universal Resolver, including:

  • did:key
  • did:web
  • did:ethr
  • did:ion
  • did:cheqd
  • did:pkh
  • did:polygonid
  • did:iden3
  • And many more…

See the GoDiddy Documentation for a complete list of supported methods.

Error Handling

The GoDiddy integration follows TrustWeave’s error handling patterns:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

import org.trustweave.core.exception.TrustWeaveException

val result = resolver.resolveDid(did)
result.fold(
    onSuccess = { result -> /* handle success */ },
    onFailure = { error ->
        when (error) {
            is DidException.DidResolutionFailed -> {
                println("Resolution failed: ${error.reason}")
            }
            is TrustWeaveException.Unknown -> {
                println("Network error: ${error.message}")
            }
            else -> println("Error: ${error.message}")
        }
    }
)

Configuration Options

GodiddyConfig

Option Type Default Description
baseUrl String "https://api.godiddy.com" Base URL for GoDiddy services
timeout Long 30000 HTTP request timeout in milliseconds
apiKey String? null API key for authentication (if required)

Testing 

1
2
3
4
5

# Run all GoDiddy tests
./gradlew :did/plugins/godiddy:test

# Run specific test class
./gradlew :did/plugins/godiddy:test --tests "GodiddyDidMethodTest"

Next Steps

References

  • GoDiddy Documentation](https://godiddy.com/docs)
  • Universal Resolver](https://dev.uniresolver.io/)
  • TrustWeave DID Module](../modules/trustweave-did.md)
  • TrustWeave Core API](../api-reference/core-api.md)
This site uses Just the Docs, a documentation theme for Jekyll.