> ## Documentation Index
> Fetch the complete documentation index at: https://docs.didit.me/llms.txt
> Use this file to discover all available pages before exploring further.

# SDK Go per KYC, AML e transazioni

> Guida rapida all'SDK Go ufficiale di Didit: chiamate tipizzate alle API server con la sola libreria standard, verifica webhook e token.

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](https://docs.didit.me/it/integration/server-sdks/overview.md) per ciò che tutti gli SDK hanno in comune.

## Installazione

```bash theme={null}
go get github.com/didit-protocol/sdk-go
```

Il modulo è [`github.com/didit-protocol/sdk-go` su pkg.go.dev](https://pkg.go.dev/github.com/didit-protocol/sdk-go). Il codice sorgente e il changelog si trovano in [didit-protocol/sdk-go](https://github.com/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](https://docs.didit.me/it/api-reference/overview.md) è 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.

```go theme={null}
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](https://docs.didit.me/it/sessions-api/create-session.md) per un workflow e indirizza l'utente al relativo URL.

```go theme={null}
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](https://docs.didit.me/it/sessions-api/retrieve-session.md). Ogni risultato di una funzionalità è uno slice con una voce per ogni nodo del workflow.

```go theme={null}
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.

```go theme={null}
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](https://docs.didit.me/it/integration/webhooks.md) 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](https://docs.didit.me/it/transaction-monitoring/overview.md); la risposta contiene il relativo stato e il punteggio di rischio.

```go theme={null}
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](https://docs.didit.me/it/authentication/overview.md), 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.

> [!NOTE]
>
> La verifica dei token esegue i controlli descritti in [Verificare un token sul tuo server](https://docs.didit.me/it/authentication/tokens-and-jwks.md#verifica-un-token-sul-tuo-server), con l'emittente e le chiavi di firma della tua applicazione.

```go theme={null}
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

```go theme={null}
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

```go theme={null}
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](https://docs.didit.me/it/standalone-apis/address-validation.md)
* [Eliminare in batch le transazioni](https://docs.didit.me/it/management-api/transactions/delete.md)
* Reti Travel Rule: [ottenere le reti](https://docs.didit.me/it/management-api/travel-rule/get-networks.md), [richiedere l'accesso a una rete](https://docs.didit.me/it/management-api/travel-rule/request-network.md), e [ottenere](https://docs.didit.me/it/management-api/travel-rule/get-network-questionnaire.md), [salvare](https://docs.didit.me/it/management-api/travel-rule/update-network-questionnaire.md) o [inviare](https://docs.didit.me/it/management-api/travel-rule/submit-network-questionnaire.md) il questionario della rete
* Prove del wallet Travel Rule: [elencare le prove del wallet tramite screenshot](https://docs.didit.me/it/management-api/travel-rule/list-wallet-proofs.md) e [approvare o rifiutarne una](https://docs.didit.me/it/management-api/travel-rule/decide-wallet-proof.md)
* Google Wallet, che nessuna release 1.0.1 include ancora: [avviare una verifica con Google Wallet](https://docs.didit.me/it/api-reference/digital-id-wallets/google-wallet.md) e [inviare una risposta del wallet](https://docs.didit.me/it/standalone-apis/digital-id-wallet-response.md)

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

* `biometric_consent`, `tags` e `user_state` quando [crea una sessione](https://docs.didit.me/it/sessions-api/create-session.md)
* `biometric_consent_mode` quando [aggiorna la configurazione dei webhook](https://docs.didit.me/it/management-api/webhook/update-config.md)
* `beneficiary_vasp` quando [aggiorna un trasferimento Travel Rule](https://docs.didit.me/it/management-api/travel-rule/update-transfer.md)
* `confirm_delete`, necessario per [eliminare un report finalizzato](https://docs.didit.me/it/management-api/regulatory-reports/delete.md)
* 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](https://docs.didit.me/it/api-reference/overview.md) ha un esempio Go per la propria operazione.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.