SDK Go pour KYC, AML et transactions

Le module officiel Didit pour Go. Il nécessite Go 1.22 ou une version ultérieure et n’utilise que la bibliothèque standard. Consultez la vue d’ensemble des SDK serveur pour connaître les éléments communs à tous les SDK.

Installation

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

Le module est github.com/didit-protocol/sdk-go sur pkg.go.dev. Ses sources et son journal des modifications se trouvent dans didit-protocol/sdk-go sur GitHub. Le package s’appelle didit. Les webhooks se trouvent dans github.com/didit-protocol/sdk-go/webhook, l’Authentication dans .../authentication et les options du client dans .../option. L’exemple de chaque page de référence de l’API est le corps d’une fonction : il utilise context, fmt et log de la bibliothèque standard, ainsi que ce module.

Configurer le client

didit.NewClient() lit DIDIT_API_KEY depuis l’environnement. Passez des options pour le remplacer, ou pour définir les identifiants d’organisation et d’application dont les appels à portée application (dossiers, réseaux, rapports réglementaires) ont besoin. Toute option fonctionne aussi sur un seul appel.

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

Les champs de requête facultatifs sont des valeurs didit.Opt : définissez-les avec didit.String, didit.Int, didit.Bool, didit.Float ou didit.Some, et omettez-les pour ne rien envoyer.

Créer une session

Créez une session de vérification pour un workflow et redirigez votre utilisateur vers son URL.

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

Lire la décision

Lorsque l’utilisateur a terminé (ou lorsque le webhook arrive), lisez la décision. Chaque résultat de fonctionnalité est une tranche comportant une entrée par nœud du workflow.

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

Vérifier un webhook

Transmettez les octets bruts du corps et les en-têtes de la requête. webhook.Verify renvoie un *didit.WebhookVerificationError pour toute livraison qui n’est pas à la fois valide et récente, et un événement typé sinon.

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

Pendant la rotation du secret, ajoutez l’ancien avec webhook.WithSecrets. Consultez Webhooks pour les événements et le schéma de signature.

Filtrer une transaction

Soumettez un paiement, un retrait ou un transfert de crypto-actifs à la surveillance des transactions ; la réponse contient son statut et son score de risque.

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

Vérifier les tokens Authentication

Le package authentication vérifie, dans votre backend et sans appeler Didit pour chaque requête, les tokens d’accès que votre émetteur Authentication signe. Il permet aussi d’échanger des codes, de rafraîchir des tokens, de vérifier et révoquer des sessions, et d’exécuter des authentifications renforcées.

La vérification des tokens effectue les contrôles décrits dans Vérifier un token sur votre serveur, avec l’émetteur et les clés de signature de votre application.

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

Erreurs

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

Listes et fichiers

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 absents du SDK Go pour l’instant

Go 1.0.1 a été généré avant l’ajout de ces endpoints à l’API. Il n’a donc pas de méthode pour eux, et leurs pages ne contiennent pas d’exemple Go :

Valider une adresse
Supprimer des transactions en lot
Réseaux Travel Rule : obtenir les réseaux, demander l’accès à un réseau, et obtenir, enregistrer ou soumettre le questionnaire du réseau
Preuves de portefeuille Travel Rule : lister les preuves de portefeuille par capture d’écran et approuver ou rejeter une preuve
Google Wallet, qu’aucune version 1.0.1 ne contient encore : démarrer une vérification Google Wallet et soumettre une réponse de portefeuille

Il ne peut pas non plus envoyer ces champs de requête plus récents :

biometric_consent, tags et user_state lors de la création d’une session
biometric_consent_mode lors de la mise à jour de la configuration des webhooks
beneficiary_vasp lors de la mise à jour d’un transfert Travel Rule
confirm_delete, requis pour supprimer un rapport finalisé
les 16 champs plus récents de Validation en base de données qu’aucune version 1.0.1 ne contient

Jusqu’à ce qu’une version ultérieure du SDK Go les ajoute, appelez-les en HTTP comme le montre la requête cURL de chaque page. Toutes les autres pages d’endpoints serveur de la référence de l’API disposent d’un exemple Go pour leur opération.

Guides

Authentification

Model Context Protocol (MCP)

SDK web

SDK natifs

SDK serveur

Intégrations

SDK Go pour KYC, AML et transactions

Installation

Configurer le client

Créer une session

Lire la décision

Vérifier un webhook

Filtrer une transaction

Vérifier les tokens Authentication

Erreurs

Listes et fichiers

Endpoints absents du SDK Go pour l’instant

​Installation

​Configurer le client

​Créer une session

​Lire la décision

​Vérifier un webhook

​Filtrer une transaction

​Vérifier les tokens Authentication

​Erreurs

​Listes et fichiers

​Endpoints absents du SDK Go pour l’instant

Installation

Configurer le client

Créer une session

Lire la décision

Vérifier un webhook

Filtrer une transaction

Vérifier les tokens Authentication

Erreurs

Listes et fichiers

Endpoints absents du SDK Go pour l’instant