Go-SDK für KYC, AML und Transaktionen

Das offizielle Didit-Modul für Go. Es setzt Go 1.22 oder höher voraus und nutzt ausschließlich die Standardbibliothek. In der Übersicht der Server-SDKs erfahren Sie, was alle SDKs gemeinsam haben.

Installation

go get github.com/didit-protocol/sdk-go

Das Modul ist github.com/didit-protocol/sdk-go auf pkg.go.dev. Der Quellcode und das Changelog befinden sich unter didit-protocol/sdk-go auf GitHub. Das Paket heißt didit. Webhooks befinden sich in github.com/didit-protocol/sdk-go/webhook, Authentifizierung in .../authentication und Client-Optionen in .../option. Das Codebeispiel auf jeder Seite der API-Referenz stellt den Rumpf einer Funktion dar: Es verwendet context, fmt und log aus der Standardbibliothek sowie dieses Modul.

Client konfigurieren

didit.NewClient() liest DIDIT_API_KEY aus den Umgebungsvariablen. Übergeben Sie Optionen, um diesen Wert zu überschreiben oder um die Organisations- und Anwendungs-IDs zu setzen, die für Aufrufe auf Anwendungsebene (Fälle, Netzwerke, regulatorische Berichte) erforderlich sind. Jede Option kann auch bei einem einzelnen Aufruf übergeben werden.

package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"time"

	"github.com/didit-protocol/sdk-go"
	"github.com/didit-protocol/sdk-go/option"
)

func main() {
	client := didit.NewClient(
		option.WithAPIKey(os.Getenv("DIDIT_API_KEY")),
		option.WithOrganizationID(os.Getenv("DIDIT_ORGANIZATION_ID")),
		option.WithApplicationID(os.Getenv("DIDIT_APPLICATION_ID")),
		option.WithTimeout(30*time.Second),
		option.WithMaxRetries(2),
	)

	// Options for a single call.
	decision, err := client.Sessions.RetrieveDecision(context.Background(), "11111111-2222-3333-4444-555555555555",
		didit.SessionsRetrieveDecisionParams{}, option.WithTimeout(5*time.Second))
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(decision.Status)
}

Optionale Anfragefelder sind didit.Opt-Werte: Setzen Sie diese mit didit.String, didit.Int, didit.Bool, didit.Float oder didit.Some, und lassen Sie sie weg, um nichts zu senden.

Sitzung erstellen

Erstellen Sie eine Verifizierungssitzung für einen Workflow und leiten Sie Ihren Benutzer auf deren URL weiter.

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/didit-protocol/sdk-go"
)

func main() {
	client := didit.NewClient()

	session, err := client.Sessions.Create(context.Background(), didit.SessionsCreateParams{
		WorkflowID: "11111111-2222-3333-4444-555555555555",
		VendorData: didit.String("user-123"),
		Callback:   didit.String("https://example.com/verification/done"),
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(session.URL)
}

Entscheidung abrufen

Sobald der Benutzer fertig ist (oder wenn der Webhook eingeht), rufen Sie die Entscheidung ab. Das Ergebnis jeder Funktion ist ein Slice mit einem Eintrag pro Workflow-Knoten.

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/didit-protocol/sdk-go"
)

func main() {
	client := didit.NewClient()

	decision, err := client.Sessions.RetrieveDecision(context.Background(), "11111111-2222-3333-4444-555555555555",
		didit.SessionsRetrieveDecisionParams{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(decision.Status)
	for _, verification := range decision.IDVerifications {
		fmt.Println(verification.Status)
	}
}

Webhook verifizieren

Übergeben Sie die unveränderten Body-Bytes und die Request-Header. webhook.Verify gibt für alles, was keine gültige, frische Zustellung ist, einen *didit.WebhookVerificationError zurück, andernfalls ein typisiertes Ereignis.

package main

import (
	"errors"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"

	"github.com/didit-protocol/sdk-go"
	"github.com/didit-protocol/sdk-go/webhook"
)

func main() {
	secret := os.Getenv("DIDIT_WEBHOOK_SECRET")
	http.HandleFunc("POST /webhooks/didit", func(w http.ResponseWriter, r *http.Request) {
		body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, 1<<20))
		if err != nil {
			http.Error(w, "bad body", http.StatusBadRequest)
			return
		}
		event, err := webhook.Verify(body, r.Header, secret)
		var invalid *didit.WebhookVerificationError
		if errors.As(err, &invalid) {
			http.Error(w, string(invalid.Reason), http.StatusBadRequest)
			return
		} else if err != nil {
			http.Error(w, "error", http.StatusInternalServerError)
			return
		}
		if e, ok := event.(*webhook.StatusUpdatedEvent); ok {
			fmt.Println(e.SessionID, e.Status)
		}
		w.WriteHeader(http.StatusOK)
	})
	log.Fatal(http.ListenAndServe(":8080", nil))
}

Wenn Sie das Secret rotieren, fügen Sie das alte mit webhook.WithSecrets hinzu. Unter Webhooks finden Sie die Ereignisse und das Signaturschema.

Transaktion prüfen

Übermitteln Sie eine Zahlung, eine Auszahlung oder einen Krypto-Transfer an die Transaktionsüberwachung; die Antwort enthält den Status und den Risiko-Score.

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/didit-protocol/sdk-go"
)

func main() {
	client := didit.NewClient()

	transaction, err := client.Transactions.Create(context.Background(), didit.TransactionsCreateParams{
		TransactionID:       "txn-1001",
		TransactionCategory: "finance",
		TransactionDetails: didit.TransactionsCreateParamsTransactionDetails{
			Direction: "outbound",
			Amount:    1500,
			Currency:  "EUR",
		},
		Subject: didit.TransactionsCreateParamsSubject{
			EntityType: didit.String("individual"),
			VendorData: "user-123",
			FullName:   "Maria Garcia",
		},
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(transaction.Status, transaction.Score)
}

Authentifizierungs-Token verifizieren

Das Paket authentication prüft die von Ihrem Authentication-Issuer signierten Access-Tokens direkt in Ihrem Backend, ohne für jede Anfrage Didit aufzurufen. Es tauscht zudem Codes um, aktualisiert Tokens, prüft und widerruft Sitzungen und führt Step-up-Authentifizierungen durch.

Die Token-Prüfung führt die unter Token auf Ihrem Server verifizieren beschriebenen Prüfungen anhand des Issuers und der Signaturschlüssel Ihrer Anwendung durch.

package main

import (
	"context"
	"errors"
	"fmt"
	"log"

	"github.com/didit-protocol/sdk-go"
	"github.com/didit-protocol/sdk-go/authentication"
)

func main() {
	// The publishable key (pk_live_... or pk_test_...) carries your issuer URL.
	auth, err := authentication.NewFromPublishableKey("pk_live_...", authentication.WithClientID("your-application-id"))
	if err != nil {
		log.Fatal(err)
	}

	claims, err := auth.VerifyAccessToken(context.Background(), "the bearer token")
	var invalid *didit.TokenVerificationError
	if errors.As(err, &invalid) {
		fmt.Println("rejected:", invalid.Reason)
		return
	} else if err != nil {
		log.Fatal(err)
	}
	fmt.Println(claims.Subject)
}

Fehler

package main

import (
	"context"
	"errors"
	"fmt"

	"github.com/didit-protocol/sdk-go"
)

func main() {
	client := didit.NewClient()

	_, err := client.Sessions.RetrieveDecision(context.Background(), "11111111-2222-3333-4444-555555555555",
		didit.SessionsRetrieveDecisionParams{})
	var notFound *didit.NotFoundError
	var status *didit.APIStatusError
	switch {
	case errors.As(err, &notFound):
		fmt.Println("no such session")
	case errors.As(err, &status):
		fmt.Println(status.StatusCode, status.RequestID, status.Body)
	case err != nil:
		fmt.Println("no response:", err)
	}
}

Listen und Dateien

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/didit-protocol/sdk-go"
)

func main() {
	ctx := context.Background()
	client := didit.NewClient()

	// Lists page through every result.
	iter := client.Sessions.ListAutoPaging(ctx, didit.SessionsListParams{Status: didit.String("Approved")})
	for iter.Next() {
		fmt.Println(iter.Current().SessionID)
	}
	if err := iter.Err(); err != nil {
		log.Fatal(err)
	}

	// Uploads take didit.FileFromPath, FileFromBytes or FileFromReader.
	result, err := client.IDVerification.Verify(ctx, didit.IDVerificationVerifyParams{
		FrontImage: didit.FileFromPath("id-front.jpg"),
		BackImage:  didit.Some(didit.FileFromPath("id-back.jpg")),
	})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(result.IDVerification.Status)
}

Endpoints, die noch nicht im Go-SDK enthalten sind

Go 1.0.1 wurde generiert, bevor diese Endpoints zur API hinzugefügt wurden. Daher enthält es keine Methode für sie und ihre Seiten verfügen über kein Go-Beispiel:

Adresse validieren
Transaktionen im Batch löschen
Travel Rule-Netzwerke: Netzwerke abrufen, Zugang zu einem Netzwerk anfordern sowie den Netzwerkfragebogen abrufen, speichern oder einreichen
Travel Rule-Wallet-Nachweise: Screenshot-Wallet-Nachweise auflisten und einen Nachweis genehmigen oder ablehnen
Google Wallet, das in keinem 1.0.1-Release enthalten ist: Google-Wallet-Verifizierung starten und Wallet-Antwort übermitteln

Zudem können diese neueren Anfragefelder nicht gesendet werden:

biometric_consent, tags und user_state beim Erstellen einer Sitzung
biometric_consent_mode beim Aktualisieren der Webhook-Konfiguration
beneficiary_vasp beim Aktualisieren eines Travel Rule-Transfers
confirm_delete, was beim Löschen eines finalisierten Berichts erforderlich ist
die 16 neueren Felder der Datenbankvalidierung, die in keinem 1.0.1-Release enthalten sind

Bis ein späteres Go-Release diese unterstützt, rufen Sie sie über HTTP auf, wie es im cURL-Beispiel der jeweiligen Seite gezeigt wird. Jede andere Seite eines Server-Endpoints in der API-Referenz enthält ein Go-Beispiel für die entsprechende Operation.

Leitfäden

Authentifizierung

Model Context Protocol (MCP)

Web-SDKs

Native SDKs

Server-SDKs

Integrationen

Go-SDK für KYC, AML und Transaktionen

Installation

Client konfigurieren

Sitzung erstellen

Entscheidung abrufen

Webhook verifizieren

Transaktion prüfen

Authentifizierungs-Token verifizieren

Fehler

Listen und Dateien

Endpoints, die noch nicht im Go-SDK enthalten sind

​Installation

​Client konfigurieren

​Sitzung erstellen

​Entscheidung abrufen

​Webhook verifizieren

​Transaktion prüfen

​Authentifizierungs-Token verifizieren

​Fehler

​Listen und Dateien

​Endpoints, die noch nicht im Go-SDK enthalten sind

Installation

Client konfigurieren

Sitzung erstellen

Entscheidung abrufen

Webhook verifizieren

Transaktion prüfen

Authentifizierungs-Token verifizieren

Fehler

Listen und Dateien

Endpoints, die noch nicht im Go-SDK enthalten sind