SDK Go per KYC, AML e transazioni

Il modulo ufficiale di Didit per Go. Richiede Go 1.22 o versioni successive e usa solo la libreria standard. Consulta la panoramica degli SDK server per ciò che tutti gli SDK hanno in comune.

Installazione

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

Il modulo è github.com/didit-protocol/sdk-go su pkg.go.dev. Il codice sorgente e il changelog si trovano in didit-protocol/sdk-go su GitHub. Il package si chiama didit. I webhook si trovano in github.com/didit-protocol/sdk-go/webhook, Authentication in .../authentication e le opzioni del client in .../option. L’esempio presente in ogni pagina del riferimento API è il corpo di una funzione: usa context, fmt e log della libreria standard e questo modulo.

Configurare il client

didit.NewClient() legge DIDIT_API_KEY dalle variabili d’ambiente. Passa delle opzioni per sovrascriverla, oppure per impostare gli ID dell’organizzazione e dell’applicazione che le chiamate con ambito applicativo (casi, reti, report normativi) richiedono. Ogni opzione funziona anche su una singola chiamata.

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

I campi opzionali della richiesta sono valori didit.Opt: impostali con didit.String, didit.Int, didit.Bool, didit.Float o didit.Some, oppure omettili per non inviare nulla.

Creare una sessione

Crea una sessione di verifica per un workflow e indirizza l’utente al relativo 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)
}

Leggere la decisione

Quando l’utente completa la verifica (o quando arriva il webhook), leggi la decisione. Ogni risultato di una funzionalità è uno slice con una voce per ogni nodo del 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)
	}
}

Verificare un webhook

Passa i byte grezzi del corpo e le intestazioni della richiesta. webhook.Verify restituisce un *didit.WebhookVerificationError per qualsiasi consegna che non sia valida e recente, e un evento tipizzato altrimenti.

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 ruoti il segreto, aggiungi quello precedente con webhook.WithSecrets. Consulta Webhook per gli eventi e lo schema di firma.

Sottoporre a screening una transazione

Invia un pagamento, un prelievo o un trasferimento di criptovalute al monitoraggio delle transazioni; la risposta contiene il relativo stato e il punteggio di rischio.

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

Verificare i token di Authentication

Il package authentication controlla i token di accesso firmati dal tuo emittente di Authentication, nel tuo backend, senza chiamare Didit per ogni richiesta. Inoltre scambia i codici, rinnova i token, verifica e revoca le sessioni ed esegue gli step-up.

La verifica dei token esegue i controlli descritti in Verificare un token sul tuo server, con l’emittente e le chiavi di firma della tua applicazione.

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

Errori

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

Elenchi e file

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

Endpoint non ancora presenti nell’SDK Go

Go 1.0.1 è stato generato prima che questi endpoint fossero aggiunti all’API, quindi non ha un metodo per essi e le loro pagine non hanno un esempio in Go:

Validare un indirizzo
Eliminare in batch le transazioni
Reti Travel Rule: ottenere le reti, richiedere l’accesso a una rete, e ottenere, salvare o inviare il questionario della rete
Prove del wallet Travel Rule: elencare le prove del wallet tramite screenshot e approvare o rifiutarne una
Google Wallet, che nessuna release 1.0.1 include ancora: avviare una verifica con Google Wallet e inviare una risposta del wallet

Inoltre non può inviare questi campi più recenti della richiesta:

biometric_consent, tags e user_state quando crea una sessione
biometric_consent_mode quando aggiorna la configurazione dei webhook
beneficiary_vasp quando aggiorna un trasferimento Travel Rule
confirm_delete, necessario per eliminare un report finalizzato
i 16 campi più recenti di Validazione su database che nessuna release 1.0.1 include

Finché una versione successiva di Go non li aggiungerà, chiamali via HTTP come mostra la richiesta cURL di ciascuna pagina. Ogni altra pagina di endpoint server del riferimento API ha un esempio Go per la propria operazione.

Guide

Autenticazione

Model Context Protocol (MCP)

SDK web

SDK nativi

SDK server

Integrazioni

SDK Go per KYC, AML e transazioni

Installazione

Configurare il client

Creare una sessione

Leggere la decisione

Verificare un webhook

Sottoporre a screening una transazione

Verificare i token di Authentication

Errori

Elenchi e file

Endpoint non ancora presenti nell’SDK Go

​Installazione

​Configurare il client

​Creare una sessione

​Leggere la decisione

​Verificare un webhook

​Sottoporre a screening una transazione

​Verificare i token di Authentication

​Errori

​Elenchi e file

​Endpoint non ancora presenti nell’SDK Go

Installazione

Configurare il client

Creare una sessione

Leggere la decisione

Verificare un webhook

Sottoporre a screening una transazione

Verificare i token di Authentication

Errori

Elenchi e file

Endpoint non ancora presenti nell’SDK Go