Amazon Managed Blockchain (AMB) Access Polygon se encuentra en versión preliminar y está sujeto a cambios. Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Introducción a Amazon Managed Blockchain (AMB) Access Polygon Comience a utilizar Amazon Managed Blockchain (AMB) Access Polygon con la información y los procedimientos de esta sección. **Topics** + [Cree una política de IAM para acceder a la red de cadenas de bloques de Polygon](#getting-started-next-steps) + [Realice solicitudes de llamadas a procedimientos remotos (RPC) de Polygon en el editor RPC de AMB Access mediante el Consola de administración de AWS](#gs-console-polygon) + [Realice las solicitudes JSON-RPC de AMB Access Polygon mediante el `awscurl` AWS CLI](#awscurl-polygon-rpc-requests) + [Realice solicitudes JSON-RPC de Polygon en Node.js](#nodejs-polygon-rpc-requests) ## Cree una política de IAM para acceder a la red de cadenas de bloques de Polygon Para acceder al punto final público de la red principal de Polygon y realizar llamadas JSON-RPC, debe tener credenciales de usuario (`AWS_ACCESS_KEY_ID`y`AWS_SECRET_ACCESS_KEY`) los permisos de IAM adecuados para Amazon Managed Blockchain (AMB) Access Polygon. En una terminal con el terminal AWS CLI instalado, ejecute el siguiente comando para crear una política de IAM que permita acceder a los dos puntos de enlace de 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** El ejemplo anterior le da acceso a todas las redes de Polygon disponibles. Para acceder a un punto final específico, utilice el siguiente `Action` comando: `"managedblockchain:InvokeRpcPolygonMainnet"` Después de crear la política, asocie esa política a la función de su usuario de IAM para que surta efecto. En el Consola de administración de AWS, navegue hasta el servicio de IAM y asocie la política `AmazonManagedBlockchainPolygonAccess` a la función asignada a su usuario de IAM. ## Realice solicitudes de llamadas a procedimientos remotos (RPC) de Polygon en el editor RPC de AMB Access mediante el Consola de administración de AWS Puede editar, configurar y enviar llamadas a procedimientos remotos (RPCs) en el polígono de acceso AMB que Consola de administración de AWS utiliza. Con ellas RPCs, puede leer datos y escribir transacciones en la red Polygon, incluida la recuperación de datos y el envío de transacciones a la red Polygon. **Example** El siguiente ejemplo muestra cómo obtener información sobre el *último* bloque mediante RPC. `eth_getBlockByNumber` Cambie las variables resaltadas por sus propias entradas o elija uno de los **métodos de RPC** de la lista e introduzca las entradas pertinentes necesarias. 1. Abre la consola de Managed Blockchain en [https://console.aws.amazon.com/managedblockchain/](https://console.aws.amazon.com/managedblockchain/). 1. Elija el **editor RPC**. 1. En la sección **Solicitud**, elija `{{POLYGON_MAINNET}}` como. **{{Blockchain Network}}** 1. Elija `{{eth_getBlockByNumber}}` como **método RPC**. 1. **latest**Introdúzcalo como indicador de transacción completa **{{Block number}}**y `{{False}}` selecciónelo como **indicador de transacción completa**. 1. A continuación, selecciona **Enviar RPC.** 1. Los resultados del `latest` bloqueo se muestran en la sección de **respuestas**. A continuación, puede copiar todas las transacciones sin procesar para analizarlas más a fondo o utilizarlas en la lógica empresarial de sus aplicaciones. Para obtener más información, consulte la página [RPCs compatible con AMB Access Polygon](https://docs.aws.amazon.com/managed-blockchain/latest/ambp-dg/polygon-api.html) ## Realice las solicitudes JSON-RPC de AMB Access Polygon mediante el `awscurl` AWS CLI **Example** Firme las solicitudes con sus credenciales de usuario de IAM mediante la [versión 4 de Signature (SiGv4)](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) para realizar solicitudes JSON-RPC de Polygon a los puntos finales de AMB Access Polygon. La herramienta de línea de [https://github.com/okigan/awscurl](https://github.com/okigan/awscurl)comandos puede ayudarle a firmar las solicitudes de servicios mediante SiGv4. AWS Para obtener más información, consulta el archivo README.md de [awscurl](https://github.com/okigan/awscurl#readme). Realice la instalación `awscurl` mediante el método apropiado para su sistema operativo. En macOS, la aplicación recomendada HomeBrew es: ``` brew install awscurl ``` Si ya la ha instalado y configurado AWS CLI, sus credenciales de usuario de IAM y las predeterminadas Región de AWS están configuradas en su entorno y a `awscurl` las que tiene acceso. Para ello`awscurl`, envíe una solicitud a la *red principal* de Polygon invocando el RPC. `eth_getBlockByNumber` Esta llamada acepta un parámetro de cadena correspondiente al número de bloque del que se desea recuperar información. El siguiente comando recupera los datos del bloque de la red principal de Polygon utilizando el número de bloque de la `params` matriz para seleccionar el bloque específico del que se van a recuperar los encabezados. ``` 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 ``` También puede realizar esta misma solicitud utilizando `curl` la función de acceso basado en el token de AMB Access mediante el uso de tokens. `Accessor` Para obtener más información, consulte [Creación y administración de tokens de acceso para el acceso basado en tokens para realizar solicitudes de 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}}' ``` La respuesta de cualquiera de los comandos devuelve información sobre el *último* bloque. Consulte el siguiente ejemplo con fines 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":[]}} ``` ## Realice solicitudes JSON-RPC de Polygon en Node.js [Puede invocar Polygon JSON RPCs mediante el envío de solicitudes firmadas mediante HTTPS para acceder a la *red principal* de Polygon mediante el [módulo https nativo de Node.js](https://nodejs.org/api/https.html), o puede utilizar una biblioteca de terceros, como 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) En el primer ejemplo se envía una transacción de una dirección a otra y en el siguiente se solicitan los detalles de la transacción y la información de saldo de la cadena de bloques. **Example** Para ejecutar este script Node.js de ejemplo, aplique los siguientes requisitos previos: 1. Debe tener el administrador de versiones de nodos (nvm) y Node.js instalados en el equipo. Puede encontrar las instrucciones de instalación de su sistema operativo [aquí.](https://github.com/nvm-sh/nvm) 1. Utilice el `node --version` comando y confirme que está utilizando la *versión 18 o superior de Node*. Si es necesario, puede usar el `nvm install v18.12.0` comando, seguido del `nvm use v18.12.0` comando, para instalar la *versión 18*, la versión *LTS* de Node. 1. Las variables `AWS_ACCESS_KEY_ID` de entorno `AWS_SECRET_ACCESS_KEY` deben contener las credenciales asociadas a su cuenta. Exporte estas variables como cadenas en su cliente mediante los siguientes comandos. Sustituya los valores en *rojo* de las siguientes cadenas por los valores adecuados de su cuenta de usuario de IAM. ``` export AWS_ACCESS_KEY_ID="{{AKIAIOSFODNN7EXAMPLE}}" export AWS_SECRET_ACCESS_KEY="{{wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY}}" ``` Tras completar todos los requisitos previos, copie los siguientes archivos en un directorio de su entorno local mediante el editor de código que prefiera: *package.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* El siguiente código utiliza una clave privada codificada para generar una cartera que Signer utilice únicamente con `Ethers.js` fines de demostración. No utilice este código en entornos de producción, ya que tiene fondos reales y supone un riesgo para la seguridad. Si es necesario, ponte en contacto con tu equipo de cuentas para que te asesoren sobre las mejores prácticas de Wallet y Signer. ``` 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}}"); ``` Una vez guardados estos archivos en su directorio, instale las dependencias necesarias para ejecutar el código mediante el siguiente comando: ``` npm install ``` ### Envíe una transacción en Node.js El ejemplo anterior envía el token nativo de Polygon Mainnet (POL) de una dirección a otra mediante la firma de una transacción y su transmisión a la red principal de Polygon mediante AMB Access Polygon. Para ello, utilice el `sendTx.js` script, que utiliza una biblioteca popular para interactuar con Ethereum y cadenas de bloques compatibles con Ethereum`Ethers.js`, como Polygon. Debes reemplazar las tres variables del código *resaltadas en rojo*: la del token de acceso `billingToken` para el *acceso* [basado](https://docs.aws.amazon.com/managed-blockchain/latest/ambp-dg/polygon-tokens.html) en un token, la *clave privada* con la que firmas la transacción y la dirección *del destinatario que recibe la POL*. **sugerencia** Le recomendamos que cree una clave privada (cartera) nueva para este fin, en lugar de reutilizar una cartera existente para eliminar el riesgo de perder fondos. Puedes usar el método createRandom () de la clase Wallet de la biblioteca Ethers para generar una cartera con la que realizar pruebas. Además, si necesitas solicitar POL desde la red principal de Polygon, puedes usar el recurso POL público para solicitar una pequeña cantidad para utilizarla en las pruebas. Una vez que hayas añadido tu *clave privada `billingToken`*, la de una cartera financiada y la dirección del destinatario al código, ejecutas el siguiente código para firmar una transacción para que *.0001* POL se envíe de tu dirección a otra y la transmites a Polygon Mainnet invocando el ` eth_sendRawTransaction` JSON-RPC mediante el polígono de acceso AMB. ``` node sendTx.js ``` La respuesta recibida es similar a la siguiente: ``` 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: [] } ``` La respuesta constituye el recibo de la transacción. Guarde el valor de la propiedad`hash`. Este es el identificador de la transacción que acabas de enviar a la cadena de bloques. Utiliza esta propiedad en el ejemplo de transacción de lectura para obtener detalles adicionales sobre esta transacción desde la red principal de Polygon. Tenga en cuenta que las `blockNumber` y `blockHash` están `null` en la respuesta. Esto se debe a que la transacción aún no se ha registrado en un bloque de la red Polygon. Tenga en cuenta que estos valores se definen más adelante y es posible que los vea cuando solicite los detalles de la transacción en la siguiente sección. ### Lee una transacción en Node.js En esta sección, solicita los detalles de la transacción enviada anteriormente y recupera el saldo de POL de la dirección del destinatario mediante solicitudes de lectura a la red principal de Polygon mediante AMB Access Polygon. En el `readTx.js` archivo, sustituya la variable {{`your-transaction-id`}} etiquetada por la `hash` que guardó de la respuesta al ejecutar el código de la sección anterior. [Este código utiliza una utilidad que [firma las solicitudes HTTPS a AMB Access Polygon con los módulos Sigv4 (SigV4)](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) necesarios del AWS SDK y envía las solicitudes mediante el cliente HTTP AXIOS, muy utilizado. `dispatch-evm-rpc.js`](https://axios-http.com) La respuesta recibida es similar a la siguiente: ``` 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 ``` La respuesta representa los detalles de la transacción. Tenga en cuenta que es probable que `blockNumber` los `blockHash` y ahora estén definidos. Esto indica que la transacción se ha registrado en un bloque. Si estos valores se mantienen`null`, espere unos minutos y vuelva a ejecutar el código para comprobar si la transacción se ha incluido en un bloque. Por último, la representación hexadecimal del saldo de direcciones del destinatario *(0x110d9316ec000)* se convierte a decimal mediante el `formatEther()` método de Ethers, que convierte el hexadecimal en decimal y desplaza los decimales en *18 (10^18*) para obtener el saldo real en POL. **sugerencia** Si bien los ejemplos de código anteriores ilustran cómo usar Node.js, Ethers y Axios para utilizar algunos de los polígonos de acceso JSON RPCs en AMB compatibles, puede modificar los ejemplos y escribir otro código para crear sus aplicaciones en Polygon mediante este servicio. Para obtener una lista completa de los polígonos de acceso JSON RPCs en AMB compatibles, consulte. [La API de cadena de bloques gestionada y el JSON son RPCs compatibles con AMB Access Polygon](polygon-api.md)