SDK de Go para KYC, AML y transacciones

El módulo oficial de Didit para Go. Requiere Go 1.22 o posterior y usa solo la biblioteca estándar. Consulta la visión general de los SDK de servidor para ver lo que comparten todos los SDK.

Instalación

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

El módulo es github.com/didit-protocol/sdk-go en pkg.go.dev. Su código fuente y su registro de cambios están en didit-protocol/sdk-go en GitHub. El paquete se llama didit. Los webhooks están en github.com/didit-protocol/sdk-go/webhook, la autenticación está en .../authentication y las opciones del cliente en .../option. El ejemplo de cada página de la referencia de la API es el cuerpo de una función: usa context, fmt y log de la biblioteca estándar y este módulo.

Configurar el cliente

didit.NewClient() lee DIDIT_API_KEY del entorno. Pasa opciones para sobrescribirla o para establecer los ids de la organización y de la aplicación que requieren las llamadas específicas de la aplicación (casos, redes, informes regulatorios). Cualquier opción también funciona en una sola llamada.

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

Los campos opcionales de la solicitud son valores didit.Opt: establécelos con didit.String, didit.Int, didit.Bool, didit.Float o didit.Some, y omítelos para no enviar nada.

Crear una sesión

Crea una sesión de verificación para un workflow y envía a tu usuario a su 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)
}

Leer la decisión

Cuando el usuario haya terminado (o cuando llegue el webhook), lee la decisión. Cada resultado de función es un slice con una entrada por cada nodo del flujo.

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

Verificar un webhook

Pasa los bytes del cuerpo sin procesar y los encabezados de la solicitud. webhook.Verify devuelve un *didit.WebhookVerificationError para todo lo que no sea una entrega válida y reciente, y un evento tipado en caso contrario.

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

Mientras rotas el secreto, añade el anterior con webhook.WithSecrets. Consulta Webhooks para conocer los eventos y el esquema de firma.

Analizar una transacción

Envía un pago, una retirada o una transferencia de criptomonedas a monitorización de transacciones; la respuesta incluye su estado y su puntuación de riesgo.

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

Verificar tokens de Authentication

El paquete authentication comprueba los tokens de acceso que firma tu emisor de Authentication, en tu backend, sin consultar a Didit en cada solicitud. También intercambia códigos, renueva tokens, comprueba y revoca sesiones, y ejecuta verificaciones adicionales (step-ups).

La verificación de tokens realiza las comprobaciones de Verificar un token en tu servidor, con el emisor y las claves de firma de tu aplicación.

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

Errores

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

Listas y archivos

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 que aún no están en el SDK de Go

Go 1.0.1 se generó antes de que estos endpoints se añadieran a la API, así que no tiene ningún método para ellos y sus páginas no tienen ejemplo en Go:

Validar una dirección
Eliminar transacciones en lote
Redes de Travel Rule: obtener las redes, solicitar acceso a una red, y obtener, guardar o enviar el cuestionario de la red
Pruebas de wallet de Travel Rule: listar las pruebas de wallet por captura de pantalla y aprobar o rechazar una
Google Wallet, que todavía no está disponible en ninguna versión 1.0.1: iniciar una verificación de Google Wallet y enviar una respuesta de wallet

Tampoco puede enviar estos campos de solicitud más recientes:

biometric_consent, tags y user_state cuando crea una sesión
biometric_consent_mode cuando actualiza la configuración de webhooks
beneficiary_vasp cuando actualiza una transferencia de Travel Rule
confirm_delete, que se necesita para eliminar un informe finalizado
los 16 campos más recientes de Validación de base de datos que no tiene ninguna versión 1.0.1

Hasta que una versión posterior de Go los añada, invócalos mediante HTTP como muestra la solicitud cURL de cada página. Todas las demás páginas de endpoints de servidor de la referencia de la API tienen un ejemplo en Go para su operación.

Guías

Autenticación

Model Context Protocol (MCP)

SDKs web

SDKs nativos

SDK de servidor

Integraciones

SDK de Go para KYC, AML y transacciones

Instalación

Configurar el cliente

Crear una sesión

Leer la decisión

Verificar un webhook

Analizar una transacción

Verificar tokens de Authentication

Errores

Listas y archivos

Endpoints que aún no están en el SDK de Go

​Instalación

​Configurar el cliente

​Crear una sesión

​Leer la decisión

​Verificar un webhook

​Analizar una transacción

​Verificar tokens de Authentication

​Errores

​Listas y archivos

​Endpoints que aún no están en el SDK de Go

Instalación

Configurar el cliente

Crear una sesión

Leer la decisión

Verificar un webhook

Analizar una transacción

Verificar tokens de Authentication

Errores

Listas y archivos

Endpoints que aún no están en el SDK de Go