SDK de Go per a KYC, AML i transaccions

El mòdul oficial de Didit per a Go. Requereix Go 1.22 o posterior i només fa servir la biblioteca estàndard. Consulta la visió general dels SDK de servidor per veure què comparteixen tots els SDK.

Instal·lació

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

El mòdul és github.com/didit-protocol/sdk-go a pkg.go.dev. El codi font i el registre de canvis es troben a didit-protocol/sdk-go a GitHub. El paquet s’anomena didit. Els webhooks es troben a github.com/didit-protocol/sdk-go/webhook, l’Authentication a .../authentication i les opcions del client a .../option. L’exemple de cada pàgina de referència de l’API és el cos d’una funció: fa servir context, fmt i log de la biblioteca estàndard i d’aquest mòdul.

Configura el client

didit.NewClient() llegeix DIDIT_API_KEY de l’entorn. Passa opcions per sobreescriure-la, o per definir els identificadors d’organització i d’aplicació que necessiten les crides amb àmbit d’aplicació (casos, xarxes, informes regulatoris). Qualsevol opció també funciona en una sola crida.

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

Els camps opcionals de la sol·licitud són valors didit.Opt: defineix-los amb didit.String, didit.Int, didit.Bool, didit.Float o didit.Some, o deixa’ls fora perquè no s’enviï res.

Crea una sessió

Crea una sessió de verificació per a un flux de treball i envia l’usuari a la seva 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)
}

Llegeix la decisió

Quan l’usuari acabi (o quan arribi el webhook), llegeix la decisió. Cada resultat de funcionalitat és un slice amb una entrada per cada node del flux de treball.

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

Verifica un webhook

Passa els bytes del cos sense processar i les capçaleres de la sol·licitud. webhook.Verify retorna un *didit.WebhookVerificationError per a qualsevol lliurament que no sigui vàlid o que no sigui recent, i un esdeveniment tipat en cas contrari.

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

Mentre rotes el secret compartit, afegeix l’antic amb webhook.WithSecrets. Consulta Webhooks per als esdeveniments i l’esquema de signatura.

Cribra una transacció

Envia un pagament, una retirada o una transferència de criptoactius al monitoratge de transaccions; la resposta inclou el seu estat i la seva puntuació de risc.

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

Verifica els tokens d’Authentication

El paquet authentication comprova els tokens d’accés que signa el teu emissor d’Authentication, al teu backend, sense cridar Didit per a cada sol·licitud. També intercanvia codis, renova tokens, comprova i revoca sessions, i executa processos de verificació addicional.

La verificació de tokens fa les comprovacions descrites a Verifica un token al teu servidor, contra l’emissor i les claus de signatura de la teva aplicació.

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

Errors

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

Llistes i fitxers

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 encara no són al SDK de Go

Go 1.0.1 es va generar abans que s’afegissin aquests endpoints a l’API, així que no té cap mètode per a ells i les seves pàgines no tenen cap exemple en Go:

Valida una adreça
Elimina transaccions per lots
Xarxes de Travel Rule: obtén les xarxes, sol·licita l’accés a una xarxa, i obtén, desa o envia el qüestionari de la xarxa
Proves de cartera de Travel Rule: llista les proves de cartera amb captura de pantalla i aprova o rebutja una
Google Wallet, que cap versió 1.0.1 encara no té: inicia una verificació de Google Wallet i envia una resposta de cartera

Tampoc no pot enviar aquests camps de sol·licitud més recents:

biometric_consent, tags i user_state quan crea una sessió
biometric_consent_mode quan actualitza la configuració del webhook
beneficiary_vasp quan actualitza una transferència de Travel Rule
confirm_delete, que necessita eliminar un informe finalitzat
els 16 camps nous de Validació en bases de dades que cap versió 1.0.1 no té

Fins que una versió posterior del SDK de Go els afegeixi, crida aquests endpoints per HTTP tal com mostra la sol·licitud cURL de cada pàgina. Totes les altres pàgines d’endpoints de servidor de la referència de l’API tenen un exemple en Go per a la seva operació.

Guies

Autenticació

Model Context Protocol (MCP)

SDK web

SDK natius

SDK de servidor

Integracions

SDK de Go per a KYC, AML i transaccions

Instal·lació

Configura el client

Crea una sessió

Llegeix la decisió

Verifica un webhook

Cribra una transacció

Verifica els tokens d’Authentication

Errors

Llistes i fitxers

Endpoints que encara no són al SDK de Go

​Instal·lació

​Configura el client

​Crea una sessió

​Llegeix la decisió

​Verifica un webhook

​Cribra una transacció

​Verifica els tokens d’Authentication

​Errors

​Llistes i fitxers

​Endpoints que encara no són al SDK de Go

Instal·lació

Configura el client

Crea una sessió

Llegeix la decisió

Verifica un webhook

Cribra una transacció

Verifica els tokens d’Authentication

Errors

Llistes i fitxers

Endpoints que encara no són al SDK de Go