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) Query
Utilice los step-by-step tutoriales de esta sección para aprender a realizar tareas con Amazon Managed Blockchain (AMB) Query. Estos procedimientos requieren algunos requisitos previos. Si es la primera vez que utiliza AMB Query, puede consultar la sección de *configuración* de esta guía. Para obtener más información, consulte [Configuración de una consulta de Amazon Managed Blockchain (AMB)](ambq-setting-up.md).
**nota**
Algunas variables de estos ejemplos se han ocultado deliberadamente. Sustitúyalas por otras válidas antes de ejecutar estos ejemplos.
**Topics**
+ [Cree una política de IAM para acceder a las operaciones de la API de consultas de AMB](#getting-started-iam-policy)
+ [Realice solicitudes de API de consultas de Amazon Managed Blockchain (AMB) mediante Go](#getting-started-go-example)
+ [Realice solicitudes de API de consultas de Amazon Managed Blockchain (AMB) mediante Node.js](#node-amb-query-requests)
+ [Realice solicitudes de API de consultas de Amazon Managed Blockchain (AMB) mediante Python](#python-amb-query-requests)
+ [Utilice Amazon Managed Blockchain (AMB) Query Consola de administración de AWS para ejecutar la operación GetTokenBalance](#query-console-gettokenbalance-example)
## Cree una política de IAM para acceder a las operaciones de la API de consultas de AMB
Para realizar solicitudes a la API AMB Query, debe utilizar las credenciales de usuario (AWS\$1ACCESS\$1KEY\$1ID y AWS\$1SECRET \$1ACCESS\$1KEY) que tengan los permisos de IAM adecuados para Amazon Managed Blockchain (AMB) Query. En una terminal con los AWS CLI instalados, ejecute el siguiente comando para crear una política de IAM que permita acceder a las operaciones de la API de consultas de AMB:
```
cat < ~/amb-query-access-policy.json
{
"Version": "2012-10-17",
"Statement": [
{
"Sid" : "AMBQueryAccessPolicy",
"Effect": "Allow",
"Action": [
"managedblockchain-query:*"
],
"Resource": "*"
}
]
}
EOT
aws iam create-policy --policy-name AmazonManagedBlockchainQueryAccess --policy-document file://$HOME/amb-query-access-policy.json
```
Después de crear la política, asocie esa política al rol de un 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 `AmazonManagedBlockchainQueryAccess` al rol asignado al usuario de IAM que utilizará el servicio. Para obtener más información, consulte [Crear un rol y asignarlo a un](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) usuario de IAM.
**nota**
AWS recomienda dar acceso a operaciones de API específicas en lugar de utilizar el comodín. `*` Para obtener más información, consulte [Acceso a acciones específicas de la API Query de Amazon Managed Blockchain (AMB)](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-access-ambquery-apis).
## Realice solicitudes de API de consultas de Amazon Managed Blockchain (AMB) mediante Go
Con Amazon Managed Blockchain (AMB) Query, puede crear aplicaciones que dependan del acceso instantáneo a los datos de la cadena de bloques una vez confirmados en la cadena de bloques, incluso si aún no han alcanzado la finalidad *definitiva*. AMB Query permite varios casos de uso, como rellenar el historial de transacciones de una cartera, proporcionar información contextual sobre una transacción en función de su hash de transacción u obtener el saldo de un token nativo, así como de los tokens ERC-721, ERC-1155 y ERC-20.
Los siguientes ejemplos se crearon en el lenguaje Go y utilizan las operaciones de la API AMB Query. Para obtener más información sobre Go, consulte la [documentación de Go](https://go.dev/doc/). Para obtener más información sobre la API de consultas de AMB, consulte la documentación de [referencia de la API de consultas de Amazon Managed Blockchain (AMB)](https://docs.aws.amazon.com/managed-blockchain/latest/AMBQ-APIReference/API_Operations.html).
Los ejemplos siguientes utilizan las acciones `ListTransactions` y las de la `GetTransaction` API para obtener primero una lista de todas las transacciones de una dirección de propiedad externa (EOA) determinada en la red principal de Ethereum y, a continuación, el siguiente ejemplo recupera los detalles de la transacción de una sola transacción de la lista.
**Example — Realiza la acción de la `ListTransactions` API con Go**
Copia el siguiente código en un archivo nombrado `listTransactions.go` en el *ListTransactions*directorio.
```
package main
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/managedblockchainquery"
"time"
)
func main() {
// Set up a session
ambQuerySession := session.Must(session.NewSessionWithOptions(session.Options{
Config: aws.Config{
Region: aws.String("us-east-1"),
},
}))
client := managedblockchainquery.New(ambQuerySession)
// Inputs for ListTransactions API
ownerAddress := "0x00000bf26964af9d7eed9e03e53415d********"
network := managedblockchainquery.QueryNetworkEthereumMainnet
sortOrder := managedblockchainquery.SortOrderAscending
fromTime := time.Date(1971, 1, 1, 1, 1, 1, 1, time.UTC)
toTime := time.Now()
nonFinal := "NONFINAL"
// Call ListTransactions API. Transactions that have reached finality are always returned
listTransactionRequest, listTransactionResponse := client.ListTransactionsRequest(&managedblockchainquery.ListTransactionsInput{
Address: &ownerAddress,
Network: &network,
Sort: &managedblockchainquery.ListTransactionsSort{
SortOrder: &sortOrder,
},
FromBlockchainInstant: &managedblockchainquery.BlockchainInstant{
Time: &fromTime,
},
ToBlockchainInstant: &managedblockchainquery.BlockchainInstant{
Time: &toTime,
},
ConfirmationStatusFilter: &managedblockchainquery.ConfirmationStatusFilter{
Include: []*string{&nonFinal},
},
})
errors := listTransactionRequest.Send()
if errors == nil {
// handle API response
fmt.Println(listTransactionResponse)
} else {
// handle API errors
fmt.Println(errors)
}
}
```
Después de guardar el archivo, ejecute el código mediante el siguiente comando dentro del *ListTransactions*directorio:`go run listTransactions.go`.
El resultado que se muestra a continuación es similar al siguiente:
```
{
Transactions: [
{
ConfirmationStatus: "FINAL",
Network: "ETHEREUM_MAINNET",
TransactionHash: "0x12345ea404b45323c0cf458ac755ecc45985fbf2b18e2996af3c8e8693354321",
TransactionTimestamp: 2020-06-01 01:59:11 +0000 UTC
},
{
ConfirmationStatus: "FINAL",
Network: "ETHEREUM_MAINNET",
TransactionHash: "0x1234547c65675d867ebd2935bb7ebe0996e9ec8e432a579a4516c7113bf54321",
TransactionTimestamp: 2021-09-01 20:06:59 +0000 UTC
},
{
ConfirmationStatus: "NONFINAL",
Network: "ETHEREUM_MAINNET",
TransactionHash: "0x123459df7c1cd42336cd1c444cae0eb660ccf13ef3a159f05061232a24954321",
TransactionTimestamp: 2024-01-23 17:10:11 +0000 UTC
}
]
}
```
**Example — Realice la acción `GetTransaction` de la API mediante Go**
En este ejemplo, se usa un hash de transacción del resultado anterior. Copie el siguiente código en un archivo con un nombre `GetTransaction.go` en el *GetTransaction*directorio.
```
package main
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/managedblockchainquery"
)
func main() {
// Set up a session
ambQuerySession := session.Must(session.NewSessionWithOptions(session.Options{
Config: aws.Config{
Region: aws.String("us-east-1"),
},
}))
client := managedblockchainquery.New(ambQuerySession)
// inputs for GetTransaction API
transactionHash := "0x123452695a82868950d9db8f64dfb2f6f0ad79284a6c461d115ede8930754321"
network := managedblockchainquery.QueryNetworkEthereumMainnet
// Call GetTransaction API. This operation will return transaction details for all
// transactions that are confirmed on the blockchain, even if they have not
// reached finality.
getTransactionRequest, getTransactionResponse := client.GetTransactionRequest(&managedblockchainquery.GetTransactionInput{
Network: &network,
TransactionHash: &transactionHash,
})
errors := getTransactionRequest.Send()
if errors == nil {
// handle API response
fmt.Println(getTransactionResponse)
} else {
// handle API errors
fmt.Println(errors)
}
}
```
Después de guardar el archivo, ejecute el código mediante el siguiente comando dentro del *GetTransaction*directorio:`go run GetTransaction.go`.
El resultado que se muestra a continuación es similar al siguiente:
```
{
Transaction: {
BlockHash: "0x000005c6a71d1afbc005a652b6ceca71cd516d97b0fc514c2a1d0f2ca3912345",
BlockNumber: "11111111",
CumulativeGasUsed: "5555555",
EffectiveGasPrice: "44444444444",
From: "0x9157f4de39ab4c657ad22b9f19997536********",
GasUsed: "22222",
Network: "ETHEREUM_MAINNET",
NumberOfTransactions: 111,
SignatureR: "0x99999894fd2df2d039b3555dab80df66753f84be475069dfaf6c6103********",
SignatureS: "0x77777a101e7f37dd2dd0bf878b39080d5ecf3bf082c9bd4f40de783e********",
SignatureV: 0,
ConfirmationStatus: "FINAL",
ExecutionStatus: "SUCCEEDED",
To: "0x5555564f282bf135d62168c1e513280d********",
TransactionHash: "0x123452695a82868950d9db8f64dfb2f6f0ad79284a6c461d115ede8930754321",
TransactionIndex: 11,
TransactionTimestamp: 2022-02-02 01:01:59 +0000 UTC
}
}
```
La `GetTokenBalance` API te permite obtener el saldo de los tokens nativos (ETH y BTC), que se puede utilizar para obtener el saldo actual de una cuenta de propiedad externa (EOA) en un momento dado.
**Example — Usa la acción de la `GetTokenBalance` API para obtener el saldo de un token nativo en Go**
En el siguiente ejemplo, utilizas la `GetTokenBalance` API para obtener el saldo de una dirección en Ether (ETH) en la red principal de Ethereum. Copia el siguiente código en un archivo con un nombre `GetTokenBalanceEth.go` en el *GetTokenBalance*directorio.
```
package main
import (
"fmt"
"github.com/aws/aws-sdk-go/aws"
"github.com/aws/aws-sdk-go/aws/session"
"github.com/aws/aws-sdk-go/service/managedblockchainquery"
)
func main() {
// Set up a session
ambQuerySession := session.Must(session.NewSessionWithOptions(session.Options{
Config: aws.Config{
Region: aws.String("us-east-1"),
},
}))
client := managedblockchainquery.New(ambQuerySession)
// inputs for GetTokenBalance API
ownerAddress := "0xBeE510AF9804F3B459C0419826b6f225********"
network := managedblockchainquery.QueryNetworkEthereumMainnet
nativeTokenId := "eth" //Ether on Ethereum mainnet
// call GetTokenBalance API
getTokenBalanceRequest, getTokenBalanceResponse := client.GetTokenBalanceRequest(&managedblockchainquery.GetTokenBalanceInput{
TokenIdentifier: &managedblockchainquery.TokenIdentifier{
Network: &network,
TokenId: &nativeTokenId,
},
OwnerIdentifier: &managedblockchainquery.OwnerIdentifier{
Address: &ownerAddress,
},
})
errors := getTokenBalanceRequest.Send()
if errors == nil {
// process API response
fmt.Println(getTokenBalanceResponse)
} else {
// process API errors
fmt.Println(errors)
}
}
```
Después de guardar el archivo, ejecute el código mediante el siguiente comando dentro del *GetTokenBalance*directorio:`go run GetTokenBalanceEth.go`.
El resultado que se muestra a continuación es similar al siguiente:
```
{
AtBlockchainInstant: {
Time: 2020-12-05 11:51:01 +0000 UTC
},
Balance: "4343260710",
LastTransactionHash: "0x00000ce94398e56641888f94a7d586d51664eb9271bf2b3c48297a50a0711111",
LastTransactionTime: 2023-03-14 18:33:59 +0000 UTC,
OwnerIdentifier: {
Address: "0x12345d31750D727E6A3a7B534255BADd********"
},
TokenIdentifier: {
Network: "ETHEREUM_MAINNET",
TokenId: "eth"
}
}
```
## Realice solicitudes de API de consultas de Amazon Managed Blockchain (AMB) mediante Node.js
Para ejecutar estos ejemplos de nodos, se deben cumplir los siguientes requisitos previos:
1. Debe tener el administrador de versiones de nodos (nvm) y Node.js instalados en su máquina. Puede encontrar las instrucciones de instalación para su sistema operativo [aquí.](https://github.com/nvm-sh/nvm)
1. Utilice el `node --version` comando y confirme que está utilizando la *versión 14 o superior de Node*. Si es necesario, puede usar el `nvm install 14` comando, seguido del `nvm use 14` comando para instalar la *versión 14*.
1. Las variables `AWS_ACCESS_KEY_ID` de entorno `AWS_SECRET_ACCESS_KEY` deben contener las credenciales asociadas a la cuenta.
Exporte estas variables como cadenas en su cliente mediante los siguientes comandos. Sustituya los valores resaltados a continuación por los valores correspondientes de la cuenta de usuario de IAM.
```
export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
```
**nota**
Una vez cumplidos todos los requisitos previos, puede enviar solicitudes firmadas a través de HTTPS para acceder a las operaciones de la API de consultas de Amazon Managed Blockchain (AMB) y realizar solicitudes 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://www.npmjs.com/package/axios), y recuperar datos de AMB Query.
En estos ejemplos se utiliza un cliente HTTP de terceros para Node.js, pero también se puede utilizar el AWS JavaScript SDK para realizar solicitudes a AMB Query.
En el siguiente ejemplo, se muestra cómo realizar solicitudes a la API de AMB Query mediante Axios y los módulos del AWS SDK para SiGv4.
Copie el siguiente `package.json` archivo en el directorio de trabajo de su entorno local:
```
{
"name": "amb-query-examples",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"author": "",
"license": "ISC",
"dependencies": {
"@aws-crypto/sha256-js": "^4.0.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.4.0"
}
}
```
**Example — Recupere el saldo histórico de fichas de una dirección de propiedad externa (EOA) específica mediante la API de consulta AMB `GetTokenBalance`**
Puedes usar la `GetTokenBalance` API para obtener el saldo de varios tokens (por ejemplo, ERC20 ERC721, y ERC1155) y monedas nativas (por ejemplo, ETH y BTC), que puedes usar para obtener el saldo actual de una cuenta de propiedad externa (EOA) en función de un historial `timestamp` (marca de tiempo de Unix: segundos). En este ejemplo, utilizas la [https://docs.aws.amazon.com/managed-blockchain/latest/AMBQ-APIReference/GetTokenBalance.html](https://docs.aws.amazon.com/managed-blockchain/latest/AMBQ-APIReference/GetTokenBalance.html)API para obtener el saldo de direcciones de un ERC20 token, el USDC, en la red principal de Ethereum.
Para probar la `GetTokenBalance` API, copia el siguiente código en un archivo denominado `token-balance.js` y guárdalo en el mismo directorio de trabajo:
```
const axios = require('axios').default;
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-query',
region: 'us-east-1',
sha256: SHA256,
});
const queryRequest = async (path, data) => {
//query endpoint
let queryEndpoint = `https://managedblockchain-query.us-east-1.amazonaws.com/${path}`;
// parse the URL into its component parts (e.g. host, path)
const url = new URL(queryEndpoint);
// create an HTTP Request object
const req = new HttpRequest({
hostname: url.hostname.toString(),
path: url.pathname.toString(),
body: JSON.stringify(data),
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: queryEndpoint, data: data})
console.log(response.data)
} catch (error) {
console.error('Something went wrong: ', error)
throw error
}
}
let methodArg = 'get-token-balance';
let dataArg = {
" atBlockchainInstant": {
"time": 1688071493
},
"ownerIdentifier": {
"address": "0xf3B0073E3a7F747C7A38B36B805247B2********" // externally owned address
},
"tokenIdentifier": {
"contractAddress":"0xA0b86991c6218b36c1d19D4a2e9Eb0cE********", //USDC contract address
"network":"ETHEREUM_MAINNET"
}
}
//Run the query request.
queryRequest(methodArg, dataArg);
```
Para ejecutar el código, abre una terminal en el mismo directorio que tus archivos y ejecuta el siguiente comando:
```
npm i
node token-balance.js
```
Este comando ejecuta el script y pasa los argumentos definidos en el código para solicitar el saldo en ERC20 USDC de la EOA que cotiza en la red principal de Ethereum. La respuesta será similar a la siguiente:
```
{
atBlockchainInstant: { time: 1688076218 },
balance: '140386693440144',
lastUpdatedTime: { time: 1688074727 },
ownerIdentifier: { address: '0xf3b0073e3a7f747c7a38b36b805247b2********' },
tokenIdentifier: {
contractAddress: '0xa0b86991c6218b36c1d19d4a2e9eb0ce********',
network: 'ETHEREUM_MAINNET'
}
```
## Realice solicitudes de API de consultas de Amazon Managed Blockchain (AMB) mediante Python
Para ejecutar estos ejemplos de Python, se deben cumplir los siguientes requisitos previos:
1. Debe tener Python instalado en su máquina. Puede encontrar las instrucciones de instalación para su sistema operativo [aquí](https://wiki.python.org/moin/BeginnersGuide/Download).
1. Instale el [AWS SDK para Python (Boto3)](https://aws.amazon.com/sdk-for-python/).
1. Instale la [interfaz de línea de AWS comandos](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) y ejecute el comando `aws configure` para establecer las variables para su `Access Key ID``Secret Access Key`, y. `Region`
Una vez cumplidos todos los requisitos previos, puede utilizar el AWS SDK para Python a través de HTTPS para realizar solicitudes a la API de consultas de Amazon Managed Blockchain (AMB).
El siguiente ejemplo de Python usa módulos de boto3 para enviar solicitudes adjuntas con los encabezados SigV4 necesarios a la operación AMB Query API. `ListTransactionEvents` Este ejemplo recupera una lista de eventos emitidos por una transacción determinada en la red principal de Ethereum.
Copie el siguiente `list-transaction-events.py` archivo en el directorio de trabajo de su entorno local:
```
import json
from botocore.auth import SigV4Auth
from botocore.awsrequest import AWSRequest
from botocore.session import Session
from botocore.httpsession import URLLib3Session
def signed_request(url, method, params, service, region):
session = Session()
sigv4 = SigV4Auth(session.get_credentials(), service, region)
data = json.dumps(params)
request = AWSRequest(method, url, data=data)
sigv4.add_auth(request)
http_session = URLLib3Session()
response = http_session.send(request.prepare())
return(response)
url = 'https://managedblockchain-query.us-east-1.amazonaws.com/list-transaction-events'
method = 'POST'
params = {
'network': 'ETHEREUM_MAINNET',
'transactionHash': '0x125714bb4db48757007fff2671b37637bbfd6d47b3a4757ebbd0c5222984f905'
}
service = 'managedblockchain-query'
region = 'us-east-1'
# Call the listTransactionEvents operation. This operation will return transaction details for
# all transactions that are confirmed on the blockchain, even if they have not reached
# finality.
listTransactionEvents = signed_request(url, method, params, service, region)
print(json.loads(listTransactionEvents.content.decode('utf-8')))
```
Para ejecutar el código de ejemplo`ListTransactionEvents`, guarde el archivo en su directorio de trabajo y, a continuación, ejecute el comando`python3 list-transaction-events.py`. Este comando ejecuta el script y pasa los argumentos definidos en el código para solicitar los eventos asociados al hash de transacción dado en la red principal de Ethereum. La respuesta será similar a la siguiente:
```
{
'events':
[
{
'contractAddress': '0x95ad61b0a150d79219dcf64e1e6cc01f********',
'eventType': 'ERC20_TRANSFER',
'from': '0xab5801a7d398351b8be11c439e05c5b3********',
'network': 'ETHEREUM_MAINNET',
'to': '0xdead0000000000000000420694206942********',
'transactionHash': '0x125714bb4db48757007fff2671b37637bbfd6d47b3a4757ebbd0c522********',
'value': '410241996771871894771826174755464'
}
]
}
```
## Utilice Amazon Managed Blockchain (AMB) Query Consola de administración de AWS para ejecutar la operación GetTokenBalance
El siguiente ejemplo muestra cómo obtener el saldo de un token en la *red principal de Ethereum* mediante una consulta Amazon Managed Blockchain (AMB) en el Consola de administración de AWS
**Example**
1. Abra la consola Amazon Managed Blockchain en [https://console.aws.amazon.com/managedblockchain/](https://console.aws.amazon.com/managedblockchain/).
1. Elija el **editor de consultas** en la sección de **consultas**.
1. **Elija **ETHEREUM\$1MAINNET como red** de cadena de bloques.**
1. **Elija **GetTokenBalance**como tipo de consulta.**
1. Introduce tu **dirección de cadena de bloques** para el token.
1. Introduce la **dirección del contrato** para el token.
1. Introduzca el **ID de token** opcional para el token.
1. Selecciona la **fecha A** para el saldo del token.
1. Introduce la **hora A** opcional para el saldo simbólico.
1. Elija **Ejecutar consulta**.
AMB Query ejecutará su consulta y verá los resultados en la ventana de resultados de la **consulta**.