> ## 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 da Didit para KYC, AML e transações

> Início rápido do SDK oficial da Didit para Go: chamadas tipadas às APIs de servidor com a biblioteca padrão, webhooks e tokens.

A versão oficial do Didit para Go. Requer Go 1.22 ou superior e usa apenas a biblioteca padrão. Consulte a [visão geral dos SDKs para servidor](https://docs.didit.me/pt/integration/server-sdks/overview.md) para ver o que todos os SDKs têm em comum.

## Instalação

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

O módulo é o [`github.com/didit-protocol/sdk-go` no pkg.go.dev](https://pkg.go.dev/github.com/didit-protocol/sdk-go). O código-fonte e o registo de alterações estão em [didit-protocol/sdk-go](https://github.com/didit-protocol/sdk-go) no GitHub.

O pacote chama-se `didit`. Os webhooks estão em `github.com/didit-protocol/sdk-go/webhook`, o pacote Authentication em `.../authentication` e as opções do cliente em `.../option`.

O exemplo de cada página da [referência da API](https://docs.didit.me/pt/api-reference/overview.md) é o corpo de uma função: usa `context`, `fmt` e `log` da biblioteca padrão e este módulo.

## Configurar o cliente

`didit.NewClient()` lê `DIDIT_API_KEY` a partir do ambiente. Passe opções para a substituir, ou para definir os identificadores da organização e da aplicação de que precisam as chamadas com âmbito de aplicação (casos, redes, relatórios regulamentares). Qualquer opção também funciona numa única chamada.

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

Os campos opcionais do pedido são valores `didit.Opt`: defina-os com `didit.String`, `didit.Int`, `didit.Bool`, `didit.Float` ou `didit.Some`, ou deixe-os de fora para não enviar nada.

## Criar uma sessão

Crie uma [sessão de verificação](https://docs.didit.me/pt/sessions-api/create-session.md) para um fluxo e envie o seu utilizador para o respetivo 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)
}
```

## Ler a decisão

Quando o utilizador terminar (ou quando o webhook chegar), [leia a decisão](https://docs.didit.me/pt/sessions-api/retrieve-session.md). Cada resultado de funcionalidade é um slice com uma entrada por nó do fluxo.

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

## Verificar um webhook

Passe os bytes do corpo bruto e os cabeçalhos do pedido. `webhook.Verify` devolve um `*didit.WebhookVerificationError` para qualquer entrega que não seja válida e recente, e um evento tipificado nos restantes casos.

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

Enquanto substitui o segredo, adicione o antigo com `webhook.WithSecrets`. Consulte [Webhooks](https://docs.didit.me/pt/integration/webhooks.md) para ver os eventos e o esquema de assinatura.

## Triar uma transação

Envie um pagamento, um levantamento ou uma transferência de criptoativos para a [monitorização de transações](https://docs.didit.me/pt/transaction-monitoring/overview.md); a resposta inclui o respetivo estado e a pontuação de risco.

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

## Verificar tokens de Authentication

O pacote `authentication` verifica, no seu backend, os tokens de acesso que o emissor da sua [Authentication](https://docs.didit.me/pt/authentication/overview.md) assina, sem chamar a Didit em cada pedido. Também troca códigos, atualiza tokens, verifica e revoga sessões e executa step-ups.

> [!NOTE]
>
> A verificação de tokens faz as validações descritas em [Verificar um token no seu servidor](https://docs.didit.me/pt/authentication/tokens-and-jwks.md#verifique-um-token-no-seu-servidor), com base no emissor e nas chaves de assinatura da sua aplicação.

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

## Erros

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

## Listas e ficheiros

```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 ainda não estão no SDK de Go

A versão 1.0.1 do SDK de Go foi gerada antes de estes endpoints serem adicionados à API, por isso não tem método para eles e as respetivas páginas não têm exemplo em Go:

* [Validar um endereço](https://docs.didit.me/pt/standalone-apis/address-validation.md)
* [Eliminar transações em lote](https://docs.didit.me/pt/management-api/transactions/delete.md)
* Redes Travel Rule: [obter as redes](https://docs.didit.me/pt/management-api/travel-rule/get-networks.md), [pedir acesso a uma rede](https://docs.didit.me/pt/management-api/travel-rule/request-network.md) e [obter](https://docs.didit.me/pt/management-api/travel-rule/get-network-questionnaire.md), [guardar](https://docs.didit.me/pt/management-api/travel-rule/update-network-questionnaire.md) ou [submeter](https://docs.didit.me/pt/management-api/travel-rule/submit-network-questionnaire.md) o questionário da rede
* Comprovativos de carteira Travel Rule: [listar os comprovativos de carteira por captura de ecrã](https://docs.didit.me/pt/management-api/travel-rule/list-wallet-proofs.md) e [aprovar ou rejeitar um](https://docs.didit.me/pt/management-api/travel-rule/decide-wallet-proof.md)
* Google Wallet, que ainda não existe em nenhuma versão 1.0.1: [iniciar uma verificação Google Wallet](https://docs.didit.me/pt/api-reference/digital-id-wallets/google-wallet.md) e [submeter uma resposta de carteira](https://docs.didit.me/pt/standalone-apis/digital-id-wallet-response.md)

Também não consegue enviar estes campos de pedido mais recentes:

* `biometric_consent`, `tags` e `user_state` ao [criar uma sessão](https://docs.didit.me/pt/sessions-api/create-session.md)
* `biometric_consent_mode` ao [atualizar a configuração do webhook](https://docs.didit.me/pt/management-api/webhook/update-config.md)
* `beneficiary_vasp` ao [atualizar uma transferência Travel Rule](https://docs.didit.me/pt/management-api/travel-rule/update-transfer.md)
* `confirm_delete`, necessário para [eliminar um relatório finalizado](https://docs.didit.me/pt/management-api/regulatory-reports/delete.md)
* os 16 campos mais recentes da Validação de base de dados, que nenhuma versão 1.0.1 inclui

Até que uma versão posterior do SDK de Go os adicione, chame estes endpoints por HTTP, tal como mostra o pedido cURL de cada página. Todas as outras páginas de endpoints do servidor na [referência da API](https://docs.didit.me/pt/api-reference/overview.md) têm um exemplo em Go para a respetiva operação.


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