Implantando Seu Servidor de Transações

Forneça aos usuários transações sem custo

O transactions-server é um servidor proxy que retransmite transações para Gelato. Ele recebe uma transação assinada do cliente que por sua vez é enviada para a rede apropriada nos bastidores. Isso permite que o proprietário do servidor facilite para seus usuários transações sem custo

O transaction server é usado para ajudar na experiência de usar múltiplas redes e para evitar que eles mudem de provedores de rede dinamicamente. Os usuários podem permanecer conectados a Ethereum e interagir com Polygon apenas assinando transações

A Decentraland DAO configurou um servidor usado por nossas dapps, cobrindo o custo até um certo limite com algumas restrições. Este documento explica como você pode implantar este servidor para permitir que seus usuários retransmitam transações com as restrições que você precisar, se houver.

Restrições

Todas as restrições são por transação que o usuário tenta enviar. O que, na prática, se traduz em uma requisição POST para o servidor.

As restrições configuráveis que o servidor possui são:

• Verificações de cota de máximo de transações por dia. Veja a seção de collections para mais informações.

• Verificações de contratos na whitelist, então se uma transação tentar interagir com um contrato que não é reconhecido ela falhará. Para isso ela usa

  • Os contratos e collections implantados. Veja a seção de contratos e coleções para mais informações

• O preço das vendas, restringindo-o se estiver abaixo de um limite. Veja seção de valor mínimo de venda para mais informações

Configurando o Gelato

Gelato é um Protocolo Multichain Relayer. Usamos sua infraestrutura para permitir transações sem custo. Isso efetivamente significa que, quando você for enviar uma transação, você estará assinando uma mensagem e enviando-a para o Gelato. O serviço cuidará de enviar a transação para você e retornará uma resposta (hash da transação).

Ele precisa de um contrato para encaminhar as transações, mas felizmente podemos reutilizar o que está sendo usado pelo Decentraland (veja abaixo)

Gelato funciona como uma API para o servidor. Para configurar isso você primeiro precisará de uma API KEY que nós usaremos mais tarde. Para obter estes:

• Registrar no serviço

• Crie um novo dapp para a rede que pretende direcionar. Para imitar a configuração da Decentraland:

  • Selecione a Mainnets options

  • Defina um Nome do app para o seu dApp

  • escolher Polygon como a rede para o Smart Contract

  • Ativar o Qualquer Contract opção de alternância

• Copie a API KEY do API Key seção

Por fim, você precisará financiar seu dapp recém-criado. Você pode fazer isso conectando sua carteira no 1Balance seção na barra lateral esquerda. Uma vez conectado, isso permitirá que você deposite seu USDC para financiar as transações que seus usuários enviarão. Se você precisar obter MATIC, confira este post.

Testnet

Se você quiser testar seu app antes de ir ao vivo e estiver usando Polygon, você pode fazê-lo em Polygon Amoy, a testnet da Polygon.

Para fazer isso, simplesmente repita o processo mas escolhendo Matic Testnet (Amoy) no campo de rede.

Você precisará financiar sua dapp, mas pode fazer isso facilmente obtendo tokens Sepolia ETH do faucet.

Baixando o servidor de transações

Primeiro, você precisará de uma cópia do código do transactions-server da Decentraland. Você pode encontrá-lo no github. A partir daí, você tem duas opções:

1. Baixando o código: Para baixar o código, você deve primeiro clicar no botão verde Code e então ou

• Clique em Download ZIP

• Copie a URL sob o Clone título e então execute $ git clone THE_URL_HERE

1. Fazendo fork do código: Você pode clicar no fork botão no canto superior direito da página. Uma vez que o processo esteja completo, você poderá baixar seu código da mesma maneira que faria na primeira opção. Você precisará de uma conta no Github para isso; para mais informações sobre como fazer fork de repositórios, veja aqui

Configurando o servidor

O transactions server é escrito em NodeJS usando Typescript. Antes de executá-lo, você precisará configurar algumas variáveis de ambiente.

Para fazer isso:

• Copie o .env.example arquivo e cole-o renomeado para .env

• Abra o .env arquivo. Você verá que algumas variáveis têm um valor padrão, como HTTP_SERVER_PORT=5000 (em qual porta executar o servidor)

• Você pode deixar a maioria dos valores como estão, mas há alguns valores importantes a considerar:

  • Gelato

  • Transações

  • Contratos e coleções

  • Valor mínimo de venda

Gelato

Use a API KEY que obtivemos quando configurando gelato.

GELATO_API_KEY=p_qXAlcVwWyU__Fjbn_qwr0rTy14asDf_Z2XCVBnmZX_

Transações

Quando uma nova requisição de transação chega, ela verificará a quantidade um endereço enviou naquele dia. Se estiver acima do valor definido, a transação falhará.

MAX_TRANSACTIONS_PER_DAY=10

Para remover completamente essa verificação, você pode entrar no código e remover o

await checkQuota(components, transactionData)

método de async function checkData(transactionData: TransactionData): Promise<void> { em src/ports/transactions/component.ts

Contratos e coleções

O servidor buscará a URL de Contract addresses e as armazenará localmente e consultará o subgraph. Quando uma nova requisição de transação chegar, ele então verificará se o contrato com o qual a transação está interagindo pertence aos contratos implantados na URL ou às coleções implantadas no subgraph.

Se você quiser fornecer seus próprios contratos, altere a URL e mantenha a mesma estrutura que a atual https://contracts.decentraland.org/addresses.json possui. A rede usada é determinada por COLLECTIONS_CHAIN_ID, e o intervalo com o qual o cache é reobtido é COLLECTIONS_CHAIN_ID

Se você tiver suas próprias coleções, também pode alterar a URL do subgraph.

Para remover completamente essas verificações, você pode entrar no código e remover o

await checkContractAddress(components, transactionData)

método de async function checkData(transactionData: TransactionData): Promise<void> { em src/ports/transactions/component.ts

CONTRACT_ADDRESSES_URL=https://contracts.decentraland.org/addresses.json
COLLECTIONS_FETCH_INTERVAL_MS=3600000
COLLECTIONS_CHAIN_ID=80002

COLLECTIONS_SUBGRAPH_URL=https://subgraph.decentraland.org/decentraland/collections-matic-amoy

Valor mínimo de venda

Quando uma nova requisição de transação chegar, ela primeiro analisará os dados que está tentando retransmitir. Se detectar uma venda (compra no marketplace, oferta, etc.), verificará o valor em relação a MIN_SALE_VALUE_IN_WEI. Se for menor, a transação falhará.

MIN_SALE_VALUE_IN_WEI=1000000000000000000

Para verificar os métodos de venda relevantes, você pode ver src/ports/transaction/validation/checkSalePrice.ts e para remover completamente essa verificação, você pode entrar no código e remover o

await checkSalePrice(components, transactionData)

método de async function checkData(transactionData: TransactionData): Promise<void> { em src/ports/transactions/component.ts

Executando o servidor

Agora que toda a configuração está definida, o que resta é realmente executar o servidor. Você pode seguir seu README mas, em poucas palavras, você terá que:

• Ter NodeJS instalado

• Abra o terminal de sua preferência

• Execute os seguintes comandos:

npm install
npm run migrate # apenas na primeira execução
npm run start

Claro, provavelmente você vai querer implantar isso no serviço de sua preferência, como AWS por exemplo. Você pode usar o Dockerfile do Projeto para isso.

Usando o servidor

Agora que tudo está configurado e em execução, é hora de realmente usar o servidor.

Para realmente enviar uma transação, você precisa fazer um POST para /transactions. O esquema exigido para a requisição é definido por transactionSchema em src/ports/transaction/types.ts.

Se, em vez disso, você quiser usar nossas libs prontas para facilitar sua vida, você pode experimentar decentraland-transactions. É usado via decentraland-dapps em nossos dapps como o Marketplace, com as utils sendTransaction. Verifique este código para um exemplo.