> For the complete documentation index, see [llms.txt](https://docs.decentraland.org/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/rede/network-connections.md).

# Conexões de Rede

Como comunicar sua scene com servidores externos e APIs.

A sua scene pode tirar partido de serviços externos que disponibilizam APIs. Pode usá-los para obter dados atualizados sobre preços, meteorologia ou qualquer outro tipo de informação disponibilizada por uma API.

Também pode configurar o seu próprio servidor externo para apoiar a sua scene e sincronizar dados entre os seus jogadores. Pode fazê-lo com um servidor que disponibilize uma REST API ou com um servidor que use WebSockets.

## Fazer uma chamada a uma REST API

O código da sua scene pode fazer chamadas a uma REST API para obter dados.

Como o servidor pode demorar a enviar a resposta, tem de executar este comando como uma [função assíncrona](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/padroes-de-programacao/async-functions.md), usando `executeTask()`.

```ts
executeTask(async () => {
	try {
		let response = await fetch(callUrl)
		let json = await response.json()
		console.log(json)
	} catch {
		console.log('failed to reach URL')
	}
})
```

O comando fetch também pode incluir um segundo argumento opcional que reúne os cabeçalhos, o método HTTP e o corpo HTTP num único objeto.

* **url**: Endereço para o qual enviar o pedido
* **init**: Um `RequestInit` objecto que pode conter:
  * **method** : Método HTTP a utilizar (GET, POST, DELETE, etc.)
  * **body**: Conteúdo do corpo do pedido. Tem de ser enviado como um objeto JSON convertido numa string.
  * **headers**: Cabeçalhos adicionais a incluir no pedido.
  * **redirect**: Estratégia de redirecionamento ('follow' | 'error' | 'manual')
  * **timeout**: Tempo de espera por uma resposta antes de o pedido falhar. Por predefinição, 30000 milissegundos (30 segundos).

```ts
executeTask(async () => {
	try {
		let response = await fetch(callUrl, {
			headers: { 'Content-Type': 'application/json' },
			method: 'POST',
			body: JSON.stringify(myBody),
		})
		let json = await response.json()
		console.log(json)
	} catch {
		console.log('failed to reach URL')
	}
})
```

O comando fetch devolve um objeto `response` com os seguintes dados:

* `headers`: Um objeto `ReadOnlyHeaders` . Chame o método `get()` para obter um cabeçalho específico ou o método `has()` para verificar se um cabeçalho está presente.
* `ok`: Booleano
* `redirected`: Booleano
* `status`: Número do código de estado
* `statusText`: Texto do código de estado
* `type`: Terá um dos seguintes valores: *basic*, *cors*, *default*, *error*, *opaque*, *opaqueredirect*
* `url`: URL enviada
* `json()`: Obter o corpo no formato JSON.
* `text()`: Obter o corpo como texto.

{% hint style="warning" %}
**📔 Nota**: `json()` e `text()` são mutuamente exclusivos. Se obtiver o corpo da resposta num dos dois formatos, já não poderá obtê-lo no outro formato a partir do objeto `response` .
{% endhint %}

{% hint style="warning" %}
**📔 Nota**: Cada cena de Decentraland só pode executar um comando `fetch` de cada vez. Isto não afeta a forma como o código da cena tem de ser estruturado, uma vez que os pedidos são colocados em fila internamente. Se a sua cena precisar de enviar vários pedidos para diferentes endpoints, tenha em conta que cada pedido só é enviado depois de receber uma resposta ao pedido anterior.
{% endhint %}

## Pedidos assinados

Pode utilizar uma medida de segurança adicional para certificar que um pedido tem origem numa sessão de jogador dentro de Decentraland. Pode enviar os seus pedidos com uma assinatura adicional, assinada com uma chave efémera que a sessão de Decentraland gera para cada jogador com base no endereço do jogador. O servidor que recebe o pedido pode então verificar se a mensagem assinada corresponde efetivamente a um endereço que está ativo no mundo.

Este tipo de medidas de segurança é especialmente valioso quando um jogador pode ter incentivos para abusar do sistema, para obter tokens ou pontos num jogo.

Para enviar um pedido assinado, basta utilizar a função `signedFetch()` exatamente da mesma forma que utilizaria a função `fetch()` .

```ts
import { signedFetch } from '~system/SignedFetch'

executeTask(async () => {
	try {
		let response = await signedFetch({
			url: callUrl,
			init: {
				headers: { 'Content-Type': 'application/json' },
				method: 'POST',
				body: JSON.stringify(myBody),
			},
		})

		if (!response.ok) {
			throw new Error('Invalid response')
		}

		let json = JSON.parse(response.body)

		console.log('Response received: ', json)
	} catch {
		console.log('failed to reach URL')
	}
})
```

O pedido inclui uma série adicional de cabeçalhos, que contém uma mensagem assinada e um conjunto de metadados para a interpretar. A mensagem assinada consiste em todo o conteúdo do pedido encriptado com a chave efémera do jogador.

A função `signedFetch()` difere da função `fetch()` na medida em que a resposta é uma promise de uma mensagem HTTP completa, expressa como uma `FlatFetchResponse` objeto. Isto inclui as seguintes propriedades:

* `body`
* `headers`
* `ok`
* `status`
* `statusText`

O **body** é sempre uma string, que pode analisar como no exemplo acima.

### Validar um pedido assinado

Para utilizar pedidos assinados, o servidor que os recebe deve validar se as assinaturas correspondem ao restante do pedido e se o carimbo de data/hora codificado na mensagem assinada é atual.

Pode encontrar um exemplo simples de um servidor a realizar esta tarefa na seguinte cena de exemplo:

[Validar a autenticidade do jogador](https://github.com/decentraland-scenes/validate-player-authenticity)

## Tempo limite do pedido

Se um pedido HTTP demorar demasiado tempo a receber uma resposta, falha para que possam ser enviados outros pedidos. Para `fetch()`, o tempo limite predefinido é de 30 segundos, mas pode atribuir um valor diferente a cada pedido configurando a propriedade `timeout` . O valor de `timeout` é expresso em milissegundos.

```ts
fetch('https://some-url.com', { timeout: 1000 })
```

## Utilizar WebSockets

Também pode enviar e obter dados de um servidor WebSocket, desde que este utilize uma ligação segura com *wss*.

```ts
var socket = new WebSocket('url')

socket.onmessage = function (event) {
	console.log('WebSocket message received:', event)
}
```

A sintaxe para utilizar WebSockets não difere da implementada nativamente pelo JavaScript. Consulte a documentação da [Mozilla Web API](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) para obter detalhes sobre como receber e enviar mensagens através de WebSockets.

{% hint style="info" %}
**💡 Sugestão**: Uma biblioteca que simplifica a utilização de ligações websocket e que comprovadamente funciona muito bem com Decentraland é a [Colyseus](https://colyseus.io/). Várias outras bibliotecas websocket não são compatíveis com o SDK da Decentraland.

Esta biblioteca cria uma camada de abstração sobre as ligações websocket, o que facilita bastante a reação a alterações e o armazenamento remoto de um estado de jogo consistente no servidor. Pode vê-la em ação nestes exemplos:

* [Cube Jumper](https://github.com/decentraland-scenes/cube-jumper-colyesus-sdk7)
* [Space Traitor](https://github.com/decentraland-scenes/Space-Traitor)
* [AI NPC](https://github.com/decentraland-scenes/inworld-ai-sdk7)
  {% endhint %}

## Depurar pedidos de rede

Pode depurar pedidos de rede abrindo o Debug Panel.

Para abrir o Debug Panel, clique no ![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-9af92d7a9edeb4111484adc136865c46bf27e9e1%2Fdebug-icon.webp?alt=media) ícone no canto superior direito. Em seguida, selecione o separador **Web Requests** e clique em **Open Chrome Devtools**.

Isto abrirá uma nova janela do Chrome com o separador Network aberto.

Consulte [Depurar na pré-visualização](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/depuracao/debug-in-preview.md#web-requests) para obter mais detalhes.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/rede/network-connections.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
