Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Erste Schritte mit Amazon Managed Blockchain (AMB) Query
In den step-by-step Tutorials in diesem Abschnitt erfahren Sie, wie Sie Aufgaben mithilfe von Amazon Managed Blockchain (AMB) Query ausführen. Für diese Verfahren sind einige Voraussetzungen erforderlich. Wenn Sie mit AMB Query noch nicht vertraut sind, können Sie den Abschnitt *Einrichtung* dieses Handbuchs lesen. Weitere Informationen finden Sie unter [Amazon Managed Blockchain (AMB) -Abfrage einrichten](ambq-setting-up.md).
**Anmerkung**
Einige Variablen in diesen Beispielen wurden bewusst verschleiert. Ersetzen Sie sie durch eigene gültige, bevor Sie diese Beispiele ausführen.
**Topics**
+ [Erstellen Sie eine IAM-Richtlinie für den Zugriff auf AMB Query API-Operationen](#getting-started-iam-policy)
+ [Stellen Sie mithilfe von Go API-Anfragen für Amazon Managed Blockchain (AMB) -Abfragen](#getting-started-go-example)
+ [Stellen Sie mithilfe von Node.js Anfragen an die Amazon Managed Blockchain (AMB) Query API](#node-amb-query-requests)
+ [Stellen Sie mithilfe von Python API-Anfragen für Amazon Managed Blockchain (AMB) -Abfragen](#python-amb-query-requests)
+ [Verwenden Sie Amazon Managed Blockchain (AMB) Query auf dem AWS-Managementkonsole , um den GetTokenBalance Vorgang auszuführen](#query-console-gettokenbalance-example)
## Erstellen Sie eine IAM-Richtlinie für den Zugriff auf AMB Query API-Operationen
Um AMB Query API-Anfragen zu stellen, müssen Sie die Benutzeranmeldedaten (AWS\_ACCESS\_KEY\_ID und AWS\_SECRET \_ACCESS\_KEY) verwenden, die über die entsprechenden IAM-Berechtigungen für Amazon Managed Blockchain (AMB) Query verfügen. Führen Sie in einem Terminal, auf dem das AWS CLI installiert ist, den folgenden Befehl aus, um eine IAM-Richtlinie für den Zugriff auf AMB Query API-Operationen zu erstellen:
```
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}}
```
Nachdem Sie die Richtlinie erstellt haben, fügen Sie diese Richtlinie der Rolle eines IAM-Benutzers hinzu, damit sie wirksam wird. Navigieren Sie in der AWS-Managementkonsole zum IAM-Dienst und fügen Sie die Richtlinie der Rolle `AmazonManagedBlockchainQueryAccess` hinzu, die dem IAM-Benutzer zugewiesen ist, der den Dienst verwenden wird. Weitere Informationen finden Sie unter [Rolle erstellen und sie einem IAM-Benutzer zuweisen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html).
**Anmerkung**
AWS empfiehlt, dass Sie Zugriff auf bestimmte API-Operationen gewähren, anstatt den Platzhalter zu verwenden. `*` Weitere Informationen finden Sie unter [Zugreifen auf bestimmte Amazon Managed Blockchain (AMB) Query API-Aktionen](security_iam_id-based-policy-examples.md#security_iam_id-based-policy-examples-access-ambquery-apis).
## Stellen Sie mithilfe von Go API-Anfragen für Amazon Managed Blockchain (AMB) -Abfragen
Mit Amazon Managed Blockchain (AMB) Query können Sie Anwendungen erstellen, die auf sofortigen Zugriff auf Blockchain-Daten angewiesen sind, sobald sie in der Blockchain bestätigt wurden, auch wenn sie noch nicht *endgültig* sind. AMB Query ermöglicht verschiedene Anwendungsfälle, z. B. das Auffüllen des Transaktionsverlaufs einer Wallet, die Bereitstellung von Kontextinformationen zu einer Transaktion auf der Grundlage ihres Transaktions-Hash oder das Abrufen des Saldos von systemeigenen Token sowie von ERC-721-, ERC-1155- und ERC-20-Token.
Die folgenden Beispiele wurden in der Sprache Go erstellt und verwenden die AMB Query API-Operationen. Weitere Informationen zu Go finden Sie in der [Go-Dokumentation](https://go.dev/doc/). Weitere Informationen zur AMB Query API finden Sie in der [Referenzdokumentation zur Amazon Managed Blockchain (AMB) Query API.](https://docs.aws.amazon.com/managed-blockchain/latest/AMBQ-APIReference/API_Operations.html)
In den folgenden Beispielen werden die API-Aktionen `ListTransactions` und die `GetTransaction` API-Aktionen verwendet, um zunächst eine Liste aller Transaktionen für eine bestimmte externe Adresse (EOA) im Ethereum-Mainnet abzurufen. Im nächsten Beispiel werden dann die Transaktionsdetails für eine einzelne Transaktion aus der Liste abgerufen.
**Example — Führen Sie die `ListTransactions` API-Aktion mit Go durch**
Kopieren Sie den folgenden Code in eine Datei mit dem Namen `listTransactions.go` im *ListTransactions*Verzeichnis.
```
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)
}
}
```
Nachdem Sie die Datei gespeichert haben, führen Sie den Code mit dem folgenden Befehl im *ListTransactions*Verzeichnis aus:`go run listTransactions.go`.
Die folgende Ausgabe ähnelt der folgenden:
```
{
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 — Führen Sie die `GetTransaction` API-Aktion mithilfe von Go durch**
In diesem Beispiel wird ein Transaktions-Hash aus der vorherigen Ausgabe verwendet. Kopieren Sie den folgenden Code in eine Datei mit dem Namen `GetTransaction.go` im *GetTransaction*Verzeichnis.
```
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)
}
}
```
Nachdem Sie die Datei gespeichert haben, führen Sie den Code mit dem folgenden Befehl im *GetTransaction*Verzeichnis aus:`go run GetTransaction.go`.
Die folgende Ausgabe ähnelt der folgenden:
```
{
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
}
}
```
Die `GetTokenBalance` API bietet Ihnen die Möglichkeit, den Saldo der systemeigenen Tokens (ETH und BTC) abzurufen. Dieser kann verwendet werden, um den aktuellen Saldo eines externen Kontos (EOA) zu einem bestimmten Zeitpunkt abzurufen.
**Example — Verwenden Sie die `GetTokenBalance` API-Aktion, um den Saldo eines nativen Tokens in Go abzurufen**
Im folgenden Beispiel verwenden Sie die `GetTokenBalance` API, um einen Adress-Ether-Saldo (ETH) im Ethereum-Mainnet abzurufen. Kopieren Sie den folgenden Code in eine Datei mit dem Namen `GetTokenBalanceEth.go` im *GetTokenBalance*Verzeichnis.
```
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)
}
}
```
Nachdem Sie die Datei gespeichert haben, führen Sie den Code mit dem folgenden Befehl im *GetTokenBalance*Verzeichnis aus:`go run GetTokenBalanceEth.go`.
Die folgende Ausgabe ähnelt der folgenden:
```
{
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"
}
}
```
## Stellen Sie mithilfe von Node.js Anfragen an die Amazon Managed Blockchain (AMB) Query API
Für die Ausführung dieser Node-Beispiele gelten die folgenden Voraussetzungen:
1. Sie müssen den Node Version Manager (nvm) und Node.js auf Ihrem Computer installiert haben. Eine Installationsanleitung für Ihr Betriebssystem finden Sie [hier.](https://github.com/nvm-sh/nvm)
1. Verwenden Sie den `node --version` Befehl und bestätigen Sie, dass Sie *Node Version 14* oder höher verwenden. Bei Bedarf können Sie den `nvm install 14` Befehl verwenden, gefolgt vom `nvm use 14` Befehl, um *Version 14* zu installieren.
1. Die Umgebungsvariablen `AWS_ACCESS_KEY_ID` und `AWS_SECRET_ACCESS_KEY` müssen die Anmeldeinformationen enthalten, die dem Konto zugeordnet sind.
Exportieren Sie diese Variablen mithilfe der folgenden Befehle als Zeichenfolgen auf Ihrem Client. Ersetzen Sie die im Folgenden hervorgehobenen Werte durch entsprechende Werte aus dem IAM-Benutzerkonto.
```
export AWS_ACCESS_KEY_ID="{{AKIAIOSFODNN7EXAMPLE}}"
export AWS_SECRET_ACCESS_KEY="{{wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY}}"
```
**Anmerkung**
Nachdem Sie alle Voraussetzungen erfüllt haben, können Sie signierte Anfragen über HTTPS einreichen, um auf Amazon Managed Blockchain (AMB) Query API-Operationen zuzugreifen und Anfragen mithilfe des [nativen https-Moduls in Node.js](https://nodejs.org/api/https.html) zu stellen, oder Sie können eine Drittanbieterbibliothek wie [AXIOS](https://www.npmjs.com/package/axios) verwenden und Daten aus AMB Query abrufen.
In diesen Beispielen wird ein HTTP-Client eines Drittanbieters für Node.js verwendet, Sie können jedoch auch das AWS JavaScript SDK verwenden, um Anfragen an AMB Query zu stellen.
Das folgende Beispiel zeigt Ihnen, wie Sie mithilfe von Axios und den AWS SDK-Modulen für SigV4 AMB Query-API-Anfragen stellen.
Kopieren Sie die folgende `package.json` Datei in das Arbeitsverzeichnis Ihrer lokalen Umgebung:
```
{
"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 — Rufen Sie mithilfe der AMB Query API den historischen Token-Saldo von einer bestimmten externen Adresse (EOA) ab `GetTokenBalance`**
Sie können die `GetTokenBalance` API verwenden, um den Saldo verschiedener Tokens (z. B., ERC20 ERC721, und ERC1155) und systemeigener Münzen (z. B. ETH und BTC) abzurufen, sodass Sie den aktuellen Saldo eines externen Kontos (EOA) auf der Grundlage eines historischen `timestamp` (Unix-Zeitstempel — Sekunden) ermitteln können. In diesem Beispiel verwenden Sie die [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, um den Adresssaldo eines ERC20 Tokens, USDC, im Ethereum-Mainnet abzurufen.
Um die `GetTokenBalance` API zu testen, kopieren Sie den folgenden Code in eine Datei mit dem Namen `token-balance.js` und speichern Sie die Datei im selben Arbeitsverzeichnis:
```
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);
```
Um den Code auszuführen, öffnen Sie ein Terminal im selben Verzeichnis wie Ihre Dateien und führen Sie den folgenden Befehl aus:
```
npm i
node token-balance.js
```
Dieser Befehl führt das Skript aus und übergibt die im Code definierten Argumente, um den ERC20 USDC-Kontostand der im Ethereum-Mainnet gelisteten EOA anzufordern. Die Antwort ähnelt dem folgenden Beispiel:
```
{
atBlockchainInstant: { time: 1688076218 },
balance: '140386693440144',
lastUpdatedTime: { time: 1688074727 },
ownerIdentifier: { address: '0xf3b0073e3a7f747c7a38b36b805247b2********' },
tokenIdentifier: {
contractAddress: '0xa0b86991c6218b36c1d19d4a2e9eb0ce********',
network: 'ETHEREUM_MAINNET'
}
```
## Stellen Sie mithilfe von Python API-Anfragen für Amazon Managed Blockchain (AMB) -Abfragen
Um diese Python-Beispiele auszuführen, gelten die folgenden Voraussetzungen:
1. Sie müssen Python auf Ihrem Computer installiert haben. Eine Installationsanleitung für Ihr Betriebssystem finden Sie [hier](https://wiki.python.org/moin/BeginnersGuide/Download).
1. Installieren Sie das [AWS-SDK SDK for Python (Boto3](https://aws.amazon.com/sdk-for-python/)).
1. Installieren Sie die [AWS Befehlszeilenschnittstelle](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) und führen Sie den Befehl aus`aws configure`, um die Variablen für Ihr `Access Key ID``Secret Access Key`, und festzulegen. `Region`
Nachdem Sie alle Voraussetzungen erfüllt haben, können Sie das AWS SDK für Python über HTTPS verwenden, um API-Anfragen für Amazon Managed Blockchain (AMB) Query zu stellen.
Das folgende Python-Beispiel verwendet Module von boto3, um Anfragen mit den erforderlichen SigV4-Headern an den AMB Query API-Vorgang zu senden. `ListTransactionEvents` In diesem Beispiel wird eine Liste von Ereignissen abgerufen, die von einer bestimmten Transaktion im Ethereum-Mainnet ausgelöst wurden.
Kopieren Sie die folgende `list-transaction-events.py` Datei in das Arbeitsverzeichnis Ihrer lokalen Umgebung:
```
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')))
```
Um den Beispielcode auszuführen`ListTransactionEvents`, speichern Sie die Datei in Ihrem Arbeitsverzeichnis und führen Sie dann den Befehl aus`python3 list-transaction-events.py`. Dieser Befehl führt das Skript aus und übergibt die im Code definierten Argumente, um die Ereignisse anzufordern, die mit dem angegebenen Transaktions-Hash im Ethereum-Mainnet verknüpft sind. Die Antwort ähnelt dem folgenden Beispiel:
```
{
'events':
[
{
'contractAddress': '0x95ad61b0a150d79219dcf64e1e6cc01f********',
'eventType': 'ERC20_TRANSFER',
'from': '0xab5801a7d398351b8be11c439e05c5b3********',
'network': 'ETHEREUM_MAINNET',
'to': '0xdead0000000000000000420694206942********',
'transactionHash': '0x125714bb4db48757007fff2671b37637bbfd6d47b3a4757ebbd0c522********',
'value': '410241996771871894771826174755464'
}
]
}
```
## Verwenden Sie Amazon Managed Blockchain (AMB) Query auf dem AWS-Managementkonsole , um den GetTokenBalance Vorgang auszuführen
Das folgende Beispiel zeigt, wie Sie den Saldo eines Tokens im *Ethereum-Mainnet* mithilfe von Amazon Managed Blockchain (AMB) Query auf dem AWS-Managementkonsole
**Example**
1. Öffnen Sie die Amazon Managed Blockchain Blockchain-Konsole unter [https://console.aws.amazon.com/managedblockchain/](https://console.aws.amazon.com/managedblockchain/).
1. Wählen Sie im **Abfragebereich den **Abfrage-Editor**** aus.
1. **Wählen Sie **ETHEREUM\_MAINNET** als Blockchain-Netzwerk.**
1. **Wählen Sie **GetTokenBalance**als Abfragetyp.**
1. Geben Sie Ihre **Blockchain-Adresse** für das Token ein.
1. Geben Sie die **Vertragsadresse** für das Token ein.
1. Geben Sie die optionale **Token-ID** für das Token ein.
1. Wählen Sie das Datum „**Datum**“ für das Tokenguthaben aus.
1. Geben Sie optional die **Uhrzeit** für das Token-Guthaben ein.
1. Wählen Sie **Abfrage ausführen**.
AMB Query führt Ihre Abfrage aus und Sie sehen die Ergebnisse im Fenster mit den **Abfrageergebnissen**.