> ## 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 de Go per a KYC, AML i transaccions

> SDK oficial de Go de Didit: crides tipades a les APIs de servidor amb la biblioteca estàndard, verificació de webhooks i comprovació de tokens.

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](https://docs.didit.me/ca/integration/server-sdks/overview.md) per veure què comparteixen tots els SDK.

## Instal·lació

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

El mòdul és [`github.com/didit-protocol/sdk-go` a pkg.go.dev](https://pkg.go.dev/github.com/didit-protocol/sdk-go). El codi font i el registre de canvis es troben a [didit-protocol/sdk-go](https://github.com/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](https://docs.didit.me/ca/api-reference/overview.md) é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.

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

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ó](https://docs.didit.me/ca/sessions-api/create-session.md) per a un flux de treball i envia l'usuari a la seva 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)
}
```

## Llegeix la decisió

Quan l'usuari acabi (o quan arribi el webhook), [llegeix la decisió](https://docs.didit.me/ca/sessions-api/retrieve-session.md). Cada resultat de funcionalitat és un slice amb una entrada per cada node del flux de treball.

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

## 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.

```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 rotes el secret compartit, afegeix l'antic amb `webhook.WithSecrets`. Consulta [Webhooks](https://docs.didit.me/ca/integration/webhooks.md) 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](https://docs.didit.me/ca/transaction-monitoring/overview.md); la resposta inclou el seu estat i la seva puntuació de risc.

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

## Verifica els tokens d'Authentication

El paquet `authentication` comprova els tokens d'accés que signa el teu emissor d'[Authentication](https://docs.didit.me/ca/authentication/overview.md), 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.

> [!NOTE]
>
> La verificació de tokens fa les comprovacions descrites a [Verifica un token al teu servidor](https://docs.didit.me/ca/authentication/tokens-and-jwks.md#verifica-un-token-al-teu-servidor), contra l'emissor i les claus de signatura de la teva aplicació.

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

## Errors

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

## Llistes i fitxers

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

## 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](https://docs.didit.me/ca/standalone-apis/address-validation.md)
* [Elimina transaccions per lots](https://docs.didit.me/ca/management-api/transactions/delete.md)
* Xarxes de Travel Rule: [obtén les xarxes](https://docs.didit.me/ca/management-api/travel-rule/get-networks.md), [sol·licita l'accés a una xarxa](https://docs.didit.me/ca/management-api/travel-rule/request-network.md), i [obtén](https://docs.didit.me/ca/management-api/travel-rule/get-network-questionnaire.md), [desa](https://docs.didit.me/ca/management-api/travel-rule/update-network-questionnaire.md) o [envia](https://docs.didit.me/ca/management-api/travel-rule/submit-network-questionnaire.md) el qüestionari de la xarxa
* Proves de cartera de Travel Rule: [llista les proves de cartera amb captura de pantalla](https://docs.didit.me/ca/management-api/travel-rule/list-wallet-proofs.md) i [aprova o rebutja una](https://docs.didit.me/ca/management-api/travel-rule/decide-wallet-proof.md)
* Google Wallet, que cap versió 1.0.1 encara no té: [inicia una verificació de Google Wallet](https://docs.didit.me/ca/api-reference/digital-id-wallets/google-wallet.md) i [envia una resposta de cartera](https://docs.didit.me/ca/standalone-apis/digital-id-wallet-response.md)

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

* `biometric_consent`, `tags` i `user_state` quan [crea una sessió](https://docs.didit.me/ca/sessions-api/create-session.md)
* `biometric_consent_mode` quan [actualitza la configuració del webhook](https://docs.didit.me/ca/management-api/webhook/update-config.md)
* `beneficiary_vasp` quan [actualitza una transferència de Travel Rule](https://docs.didit.me/ca/management-api/travel-rule/update-transfer.md)
* `confirm_delete`, que necessita [eliminar un informe finalitzat](https://docs.didit.me/ca/management-api/regulatory-reports/delete.md)
* 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](https://docs.didit.me/ca/api-reference/overview.md) tenen un exemple en Go per a la seva operació.


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