O Amazon Managed Blockchain (AMB) Access Polygon está em versão prévia e está sujeito a alterações. As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Introdução ao Amazon Managed Blockchain (AMB) Access Polygon Comece a usar o Amazon Managed Blockchain (AMB) Access Polygon usando as informações e os procedimentos desta seção. **Topics** + [Crie uma política do IAM para acessar a rede blockchain Polygon](#getting-started-next-steps) + [Faça solicitações de chamada de procedimento remoto (RPC) do Polygon no editor RPC do AMB Access usando o Console de gerenciamento da AWS](#gs-console-polygon) + [Faça solicitações JSON-RPC do AMB Access Polygon usando o `awscurl` AWS CLI](#awscurl-polygon-rpc-requests) + [Faça solicitações Polygon JSON-RPC em Node.js](#nodejs-polygon-rpc-requests) ## Crie uma política do IAM para acessar a rede blockchain Polygon Para acessar o endpoint público da Polygon Mainnet para fazer chamadas JSON-RPC, você deve ter credenciais de usuário (`AWS_ACCESS_KEY_ID`e`AWS_SECRET_ACCESS_KEY`) que tenham as permissões apropriadas do IAM para o Amazon Managed Blockchain (AMB) Access Polygon. Em um terminal com o AWS CLI instalado, execute o comando a seguir para criar uma política do IAM para acessar os dois endpoints do Polygon: ``` cat < ~/amb-polygon-access-policy.json { "Version": "2012-10-17", "Statement": [ { "Sid" : "{{AMBPolygonAccessPolicy}}", "Effect": "Allow", "Action": [ "managedblockchain:{{InvokeRpcPolygon*}}" ], "Resource": "*" } ] } EOT aws iam create-policy --policy-name AmazonManagedBlockchainPolygonAccess --policy-document file://$HOME/amb-polygon-access-policy.json ``` **nota** O exemplo anterior fornece acesso a todas as redes Polygon disponíveis. Para obter acesso a um endpoint específico, use o seguinte `Action` comando: `"managedblockchain:InvokeRpcPolygonMainnet"` Depois de criar a política, anexe essa política à função de usuário do IAM para que ela entre em vigor. No Console de gerenciamento da AWS, navegue até o serviço do IAM e anexe a política `AmazonManagedBlockchainPolygonAccess` à função atribuída ao seu usuário do IAM. ## Faça solicitações de chamada de procedimento remoto (RPC) do Polygon no editor RPC do AMB Access usando o Console de gerenciamento da AWS Você pode editar, configurar e enviar chamadas de procedimento remoto (RPCs) Console de gerenciamento da AWS usando o AMB Access Polygon. Com eles RPCs, você pode ler dados e gravar transações na rede Polygon, incluindo a recuperação de dados e o envio de transações para a rede Polygon. **Example** O exemplo a seguir mostra como obter informações sobre o bloco *mais recente* usando o `eth_getBlockByNumber` RPC. Altere as variáveis destacadas para suas próprias entradas ou escolha um dos **métodos RPC** listados e insira as entradas relevantes necessárias. 1. Abra o console do Managed Blockchain em [https://console.aws.amazon.com/managedblockchain/](https://console.aws.amazon.com/managedblockchain/). 1. Escolha o **editor RPC**. 1. Na seção **Solicitação**, escolha `{{POLYGON_MAINNET}}` como **{{Blockchain Network}}**o. 1. Escolha `{{eth_getBlockByNumber}}` como **método RPC**. 1. Insira **latest** como **{{Block number}}**e escolha `{{False}}` como **sinalizador de transação completa**. 1. Em seguida, escolha **Enviar RPC**. 1. Você obtém os resultados do `latest` bloqueio na seção **Resposta**. Em seguida, você pode copiar todas as transações brutas para análise posterior ou para usar na lógica de negócios de seus aplicativos. Para obter mais informações, consulte o [RPCs suporte do AMB Access](https://docs.aws.amazon.com/managed-blockchain/latest/ambp-dg/polygon-api.html) Polygon ## Faça solicitações JSON-RPC do AMB Access Polygon usando o `awscurl` AWS CLI **Example** Assine solicitações com suas credenciais de usuário do IAM usando o [Signature Version 4 (SigV4)](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) para fazer solicitações Polygon JSON-RPC aos endpoints AMB Access Polygon. A ferramenta de linha de [https://github.com/okigan/awscurl](https://github.com/okigan/awscurl)comando pode ajudá-lo a assinar solicitações para AWS serviços usando o SigV4. Para obter mais informações, consulte o [awscurl](https://github.com/okigan/awscurl#readme) README.md. Instale `awscurl` usando o método apropriado ao seu sistema operacional. No macOS, HomeBrew é o aplicativo recomendado: ``` brew install awscurl ``` Se você já instalou e configurou o AWS CLI, suas credenciais de usuário do IAM e o padrão Região da AWS estão definidos em seu ambiente e você tem acesso a. `awscurl` Usando`awscurl`, envie uma solicitação para a Polygon *Mainnet* invocando a RPC. `eth_getBlockByNumber` Essa chamada aceita um parâmetro de string correspondente ao número do bloco para o qual você deseja recuperar as informações. O comando a seguir recupera os dados do bloco da Polygon Mainnet usando o número do bloco na `params` matriz para selecionar o bloco específico para o qual recuperar os cabeçalhos. ``` awscurl -X POST -d '{ "jsonrpc": "2.0", "id": "{{eth_getBlockByNumber-curltest"}}, "method":"{{eth_getBlockByNumber}}", "params":["{{latest}}", {{false}}] }' --service managedblockchain https://{{mainnet}}.polygon.managedblockchain.{{us-east-1}}.amazonaws.com -k ``` Você também pode fazer essa mesma solicitação usando o recurso `curl` de acesso baseado em token AMB Access usando `Accessor` tokens. Para obter mais informações, consulte [Criação e gerenciamento de tokens de acesso para acesso baseado em tokens para fazer solicitações do AMB Access Polygon](polygon-tokens.md). ``` curl -X POST -d '{"jsonrpc":"2.0", "id": "{{eth_getBlockByNumber-curltest"}}, "method":"{{eth_getBlockByNumber}}", "params":["{{latest}}", {{false}}] }' 'https://{{mainnet}}.polygon.managedblockchain.{{us-east-1}}.amazonaws.com?billingtoken={{your-billing-token}}' ``` A resposta de qualquer um dos comandos retorna informações sobre o bloco *mais recente*. Veja o exemplo a seguir para fins ilustrativos: ``` {"error":null,"id":"eth_getBlockByNumber-curltest","jsonrpc":"1.0", "result":{"baseFeePerGas":"0x873bf591e","difficulty":"0x18", "extraData":"0xd78301000683626f7288676f312e32312e32856c696e757800000000000000009a\ 423a58511085d90eaf15201a612af21ccbf1e9f8350455adaba0d27eff0ecc4133e8cd255888304cc\ 67176a33b451277c2c3c1a6a6482d2ec25ee1573e8ba000", "gasLimit":"0x1c9c380","gasUsed":"0x14ca04d", "hash":"0x1ee390533a3abc3c8e1306cc1690a1d28d913d27b437c74c761e1a49********;", "nonce":"0x0000000000000000","number":"0x2f0ec4d", "parentHash":"0x27d47bc2c47a6d329eb8aa62c1353f60e138fb0c596e3e8e9425de163afd6dec", "receiptsRoot":"0x394da96025e51cc69bbe3644bc4e1302942c2a6ca6bf0cf241a5724c74c063fd", "sha3Uncles":"0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347", "size":"0xbd6b", "stateRoot":"0x7ca9363cfe9baf4d1c0dca3159461b2cca8604394e69b30af05d7d5c1beea6c3", "timestamp":"0x653ff542", "totalDifficulty":"0x33eb01dd","transactions":[...], "transactionsRoot":"0xda1602c66ffd746dd470e90a47488114a9d00f600ab598466ecc0f3340b24e0c", "uncles":[]}} ``` ## Faça solicitações Polygon JSON-RPC em Node.js [Você pode invocar o Polygon JSON- enviando solicitações RPCs assinadas usando HTTPS para acessar a rede Polygon *Mainnet* usando o [módulo https nativo em Node.js](https://nodejs.org/api/https.html) ou pode usar uma biblioteca de terceiros, como a AXIOS.](https://axios-http.com) [https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) O primeiro exemplo envia uma transação de um endereço para outro e o exemplo a seguir solicita detalhes da transação e informações de saldo do blockchain. **Example** Para executar esse exemplo de script Node.js, aplique os seguintes pré-requisitos: 1. Você deve ter o node version manager (nvm) e o Node.js instalados em sua máquina. Você pode encontrar instruções de instalação para seu sistema operacional [aqui](https://github.com/nvm-sh/nvm). 1. Use o `node --version` comando e confirme se você está usando a *versão 18 ou superior do Node*. Se necessário, você pode usar o `nvm install v18.12.0` comando, seguido pelo `nvm use v18.12.0` comando, para instalar a *versão 18*, a versão *LTS* do Node. 1. As variáveis `AWS_ACCESS_KEY_ID` de ambiente `AWS_SECRET_ACCESS_KEY` devem conter as credenciais associadas à sua conta. Exporte essas variáveis como cadeias de caracteres em seu cliente usando os comandos a seguir. Substitua os valores em *vermelho* nas sequências de caracteres a seguir pelos valores apropriados da sua conta de usuário do IAM. ``` export AWS_ACCESS_KEY_ID="{{AKIAIOSFODNN7EXAMPLE}}" export AWS_SECRET_ACCESS_KEY="{{wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY}}" ``` Depois de concluir todos os pré-requisitos, copie os seguintes arquivos em um diretório em seu ambiente local usando seu editor de código preferido: *pacote.json* ``` { "name": "polygon-rpc", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "test": "echo \"Error: no test specified\" && exit 1" }, "author": "", "license": "ISC", "dependencies": { "ethers": "^6.8.1", "@aws-crypto/sha256-js": "^5.2.0", "@aws-sdk/credential-provider-node": "^3.360.0", "@aws-sdk/protocol-http": "^3.357.0", "@aws-sdk/signature-v4": "^3.357.0", "axios": "^1.6.2" } } ``` *dispatch-evm-rpc.js* ``` const axios = require("axios"); const SHA256 = require("@aws-crypto/sha256-js").Sha256; const defaultProvider = require("@aws-sdk/credential-provider-node").defaultProvider; const HttpRequest = require("@aws-sdk/protocol-http").HttpRequest; const SignatureV4 = require("@aws-sdk/signature-v4").SignatureV4; // define a signer object with AWS service name, credentials, and region const signer = new SignatureV4({ credentials: defaultProvider(), service: "managedblockchain", region: "{{us-east-1}}", sha256: SHA256, }); const rpcRequest = async (rpcEndpoint, rpc) => { // parse the URL into its component parts (e.g. host, path) let url = new URL(rpcEndpoint); // create an HTTP Request object const req = new HttpRequest({ hostname: url.hostname.toString(), path: url.pathname.toString(), body: JSON.stringify(rpc), method: "POST", headers: { "Content-Type": "application/json", "Accept-Encoding": "gzip", host: url.hostname, }, }); // use AWS SignatureV4 utility to sign the request, extract headers and body const signedRequest = await signer.sign(req, { signingDate: new Date() }); try { //make the request using axios const response = await axios({ ...signedRequest, url: url, data: req.body, }); return response.data; } catch (error) { console.error("Something went wrong: ", error); } }; module.exports = { rpcRequest: rpcRequest }; ``` *sendTx.js* O código a seguir usa uma chave privada codificada para gerar uma carteira que o Signatário usa apenas `Ethers.js` para fins de demonstração. Não use esse código em ambientes de produção, pois ele tem fundos reais e representa um risco de segurança. Se necessário, entre em contato com a equipe da sua conta para obter conselhos sobre as melhores práticas de carteira e signatários. ``` const ethers = require("ethers"); //set AMB Access Polygon endpoint using token based access (TBA) let token = "{{your-billing-token}}" let url = `https://{{mainnet}}.polygon.managedblockchain.{{us-east-1}}.amazonaws.com?billingtoken=${token}`; //prevent batch RPCs let options = { batchMaxCount: 1, }; //create JSON RPC provider with AMB Access endpoint and options let provider = new ethers.JsonRpcProvider(url, null, options); let sendTx = async (to) => { //create an instance of the Wallet class with a private key //DO NOT USE A WALLET YOU USE ON MAINNET, NEVER USE A RAW PRIVATE KEY IN PROD let pk = "{{wallet-private-key}}"; let signer = new ethers.Wallet(pk, provider); //use this wallet to send a transaction of POL from one address to another const tx = await signer.sendTransaction({ to: to, value: ethers.parseUnits("{{0.0001}}", "{{ether}}"), }); console.log(tx); }; sendTx("{{recipent-address}}"); ``` *readTx.js* ``` let rpcRequest = require("./dispatch-evm-rpc").rpcRequest; let ethers = require("ethers"); let getTxDetails = async (txHash) => { //set url to a Signature Version 4 endpoint for AMB Access let url = "https://{{mainnet}}.polygon.managedblockchain.{{us-east-1}}.amazonaws.com"; //set RPC request body to get transaction details let getTransactionByHash = { id: "{{1}}", jsonrpc: "2.0", method: "{{eth_getTransactionByHash}}", params: [{{txHash]}}, }; //make RPC request for transaction details let txDetails = await rpcRequest(url, getTransactionByHash); //set RPC request body to get recipient user balance let getBalance = { id: "2", jsonrpc: "2.0", method: "{{eth_getBalance}}", params: {{[txDetails.result.to, "latest"]}}, }; //make RPC request for recipient user balance let recipientBalance = await rpcRequest(url, {{getBalance}}); console.log("TX DETAILS: ", txDetails.result, "BALANCE: ", ethers.formatEther(recipientBalance.result)); }; getTxDetails("{{your-transaction-id}}"); ``` Depois que esses arquivos forem salvos em seu diretório, instale as dependências necessárias para executar o código usando o seguinte comando: ``` npm install ``` ### Enviar uma transação em Node.js O exemplo anterior envia o token nativo da Polygon Mainnet (POL) de um endereço para outro assinando uma transação e transmitindo-a para a Polygon Mainnet usando o AMB Access Polygon. Para fazer isso, use o `sendTx.js` script, que usa `Ethers.js` uma biblioteca popular para interagir com o Ethereum e blockchains compatíveis com o Ethereum, como o Polygon. *Você precisa substituir três variáveis no código *destacadas em vermelho*, incluindo a do seu token de acesso `billingToken` para [acesso baseado em token](https://docs.aws.amazon.com/managed-blockchain/latest/ambp-dg/polygon-tokens.html), a *chave privada* com a qual você assina a transação e o *endereço do destinatário* que recebe o POL.* **dica** Recomendamos que você crie uma nova chave privada (carteira) para essa finalidade, em vez de reutilizar uma carteira existente para eliminar o risco de perda de fundos. Você pode usar o método createRandom () da classe Wallet da biblioteca Ethers para gerar uma carteira para testar. Além disso, se você precisar solicitar POL da Polygon Mainnet, poderá usar a torneira pública POL para solicitar uma pequena quantidade para usar no teste. Depois de adicionar sua `billingToken` *chave privada* de uma carteira financiada e o endereço do destinatário ao código, você executa o código a seguir para assinar uma transação de *0,0001* POL a ser enviada do seu endereço para outro e transmiti-la para a Polygon Mainnet invocando o ` eth_sendRawTransaction` JSON-RPC usando o AMB Access Polygon. ``` node sendTx.js ``` A resposta recebida é semelhante à seguinte: ``` TransactionResponse { provider: JsonRpcProvider {}, blockNumber: null, blockHash: null, index: undefined, hash: '0x8d7538b4841261c5120c0a4dd66359e8ee189e7d1d34ac646a1d9923********', type: 2, to: '0xd2bb4f4f1BdC4CB54f715C249Fc5a991********', from: '0xcf2C679AC6cb7de09Bf6BB6042ecCF05********', nonce: 2, gasLimit: 21000n, gasPrice: undefined, maxPriorityFeePerGas: 16569518669n, maxFeePerGas: 16569518685n, data: '0x', value: 100000000000000n, chainId: 80001n, signature: Signature { r: "0x1b90ad9e9e4e005904562d50e904f9db10430a18b45931c059960ede337238ee", s: "0x7df3c930a964fd07fed4a59f60b4ee896ffc7df4ea41b0facfe82b470db448b7", yParity: 0, networkV: null }, accessList: [] } ``` A resposta constitui o recibo da transação. Salve o valor da propriedade`hash`. Esse é o identificador da transação que você acabou de enviar para o blockchain. Você usa essa propriedade no exemplo de transação de leitura para obter detalhes adicionais sobre essa transação na Polygon Mainnet. Observe que o `blockNumber` e `blockHash` está `null` na resposta. Isso porque a transação ainda não foi registrada em um bloco na rede Polygon. Observe que esses valores são definidos posteriormente e você pode vê-los ao solicitar os detalhes da transação na seção a seguir. ### Leia uma transação em Node.js Nesta seção, você solicita os detalhes da transação enviada anteriormente e recupera o saldo POL do endereço do destinatário usando solicitações de leitura para a Polygon Mainnet usando o AMB Access Polygon. No `readTx.js` arquivo, substitua a variável {{`your-transaction-id`}} rotulada pela `hash` que você salvou da resposta ao executar o código na seção anterior. [Esse código usa um utilitário,`dispatch-evm-rpc.js`, que assina solicitações HTTPS para o AMB Access Polygon com os módulos [Signature Version 4 (SigV4)](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) necessários do AWS SDK e envia solicitações usando o cliente HTTP amplamente usado, o AXIOS.](https://axios-http.com) A resposta recebida é semelhante à seguinte: ``` TX DETAILS: { blockHash: '0x59433e0096c783acab0659175460bb3c919545ac14e737d7465b3ddc********', blockNumber: '0x28b4059', from: '0xcf2c679ac6cb7de09bf6bb6042eccf05b7fa1394', gas: '0x5208', gasPrice: '0x3db9eca5d', maxPriorityFeePerGas: '0x3db9eca4d', maxFeePerGas: '0x3db9eca5d', hash: '0x8d7538b4841261c5120c0a4dd66359e8ee189e7d1d34ac646a1d9923********', input: '0x', nonce: '0x2', to: '0xd2bb4f4f1bdc4cb54f715c249fc5a991********', transactionIndex: '0x0', value: '0x5af3107a4000', type: '0x2', accessList: [], chainId: '0x13881', v: '0x0', r: '0x1b90ad9e9e4e005904562d50e904f9db10430a18b45931c059960ede337238ee', s: '0x7df3c930a964fd07fed4a59f60b4ee896ffc7df4ea41b0facfe82b470db448b7' } BALANCE: 0.0003 ``` A resposta representa os detalhes da transação. Observe que o `blockHash` e agora provavelmente `blockNumber` está definido. Isso indica que a transação foi registrada em um bloco. Se esses valores persistirem`null`, aguarde alguns minutos e execute o código novamente para verificar se sua transação foi incluída em um bloco. *Por fim, a representação hexadecimal do saldo do endereço do destinatário *(0x110d9316ec000)* é convertida em decimal usando o `formatEther()` método de Ethers, que converte o hexadecimal em decimal e desloca as casas decimais em 18 (10^18) para fornecer o verdadeiro equilíbrio em POL.* **dica** Embora os exemplos de código anteriores ilustrem como usar Node.js, Ethers e Axios para utilizar alguns dos JSON suportados no AMB Access RPCs Polygon, você pode modificar os exemplos e escrever outro código para criar seus aplicativos no Polygon usando esse serviço. Para obter uma lista completa de JSON- RPCs no AMB Access Polygon compatíveis, consulte. [API de blockchain gerenciada e JSON - RPCs compatíveis com o AMB Access Polygon](polygon-api.md)