Guida introduttiva ad Amazon Managed Blockchain (AMB) Query - Query su Blockchain gestita da Amazon
Crea una IAM politicaEsempi che utilizzano GoEsempi che utilizzano Node.jsEsempi che utilizzano PythonEsempio di utilizzo di AWS Management Console

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Guida introduttiva ad Amazon Managed Blockchain (AMB) Query

Utilizza step-by-step i tutorial in questa sezione per imparare a eseguire attività utilizzando Amazon Managed Blockchain (AMB) Query. Queste procedure richiedono alcuni prerequisiti. Se non conosci AMB Query, puoi consultare la sezione Configurazione di questa guida. Per ulteriori informazioni, consulta Configurazione di Amazon Managed Blockchain (AMB) Query.

Nota

Alcune variabili in questi esempi sono state deliberatamente offuscate. Sostituiscile con altre valide prima di eseguire questi esempi.

Crea una IAM policy per accedere alle API operazioni di AMB Query

Per effettuare API richieste di AMB Query, devi utilizzare le credenziali utente (AWS_ACCESS_ KEY _ID e _ AWS_SECRET ACCESS _KEY) che dispongono delle IAM autorizzazioni appropriate per Amazon Managed Blockchain (AMB) Query. In un terminale con AWS CLI installato, esegui il seguente comando per creare una IAM politica di accesso alle API operazioni di AMB Query: 

cat <<EOT > ~/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

Dopo aver creato la policy, associala al ruolo di un IAM utente per renderla effettiva. Nel AWS Management Console, accedi al IAM servizio e allega la policy AmazonManagedBlockchainQueryAccess al ruolo assegnato all'IAMutente che utilizzerà il servizio. Per ulteriori informazioni, consulta Creazione di un ruolo e assegnazione a un IAM utente.

Nota

AWS consiglia di consentire l'accesso a API operazioni specifiche anziché utilizzare la * wild-card. Per ulteriori informazioni, consulta Accesso a specifiche API azioni Amazon Managed Blockchain (AMB) Query.

Effettua API richieste Amazon Managed Blockchain (AMB) Query utilizzando Go

Con Amazon Managed Blockchain (AMB) Query, puoi creare applicazioni che dipendono dall'accesso istantaneo ai dati della blockchain una volta confermati sulla blockchain, anche se non sono ancora stati raggiunti. AMBQuery consente diversi casi d'uso, come la compilazione della cronologia delle transazioni di un portafoglio, la fornitura di informazioni contestuali su una transazione in base all'hash della transazione o l'ottenimento del saldo di un token nativo e di ERC -721, ERC -1155 e -20 token. ERC

I seguenti esempi sono creati nel linguaggio Go e utilizzano le operazioni Query. AMB API Per ulteriori informazioni su Go, consulta la documentazione di Go. Per ulteriori informazioni sulla AMB QueryAPI, consulta la documentazione di API riferimento per le query di Amazon Managed Blockchain (AMB).

Gli esempi seguenti utilizzano le GetTransaction API azioni ListTransactions e per ottenere prima un elenco di tutte le transazioni per un determinato indirizzo di proprietà esterna (EOA) sulla rete principale di Ethereum, quindi l'esempio successivo recupera i dettagli della transazione per una singola transazione dall'elenco.

Esempio — Effettua l'azione usando Go ListTransactions API

Copia il codice seguente in un file denominato listTransactions.go nella ListTransactionsdirectory.

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)
    }
}

Dopo aver salvato il file, esegui il codice utilizzando il seguente comando all'interno della ListTransactionsdirectory:go run listTransactions.go.

L'output che segue è simile al seguente:

{
  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
    }
  ]
}
Esempio — Effettua l'GetTransactionAPIazione usando Go

Questo esempio utilizza un hash di transazione dell'output precedente. Copia il codice seguente in un file denominato GetTransaction.go nella GetTransactiondirectory.

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)
    }
}

Dopo aver salvato il file, esegui il codice utilizzando il seguente comando all'interno della GetTransactiondirectory:go run GetTransaction.go.

L'output che segue è simile al seguente:

{
  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
  }
}

GetTokenBalanceAPIFornisce un modo per ottenere il saldo dei token nativi (ETHeBTC), che può essere utilizzato per ottenere il saldo corrente di un account di proprietà esterna (EOA) in un determinato momento.

Esempio — Usa l'GetTokenBalanceAPIazione per ottenere il saldo di un token nativo in Go

Nell'esempio seguente, usi il GetTokenBalance API per ottenere un saldo di indirizzo Ether (ETH) sulla rete principale di Ethereum. Copia il codice seguente in un file denominato GetTokenBalanceEth.go nella GetTokenBalancedirectory.

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)
    }
}

Dopo aver salvato il file, esegui il codice utilizzando il seguente comando all'interno della GetTokenBalancedirectory:go run GetTokenBalanceEth.go.

L'output che segue è simile al seguente:

{
  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"
  }
}

Effettua API richieste di Amazon Managed Blockchain (AMB) Query utilizzando Node.js

Per eseguire questi esempi di nodi, si applicano i seguenti prerequisiti:

  1. È necessario che il node version manager (nvm) e Node.js siano installati sul computer. Puoi trovare le istruzioni di installazione per il tuo sistema operativo qui.

  2. Usa il node --version comando e conferma che stai usando la versione 14 o successiva di Node. Se necessario, è possibile utilizzare il nvm install 14 comando, seguito dal nvm use 14 comando per installare la versione 14.

  3. Le variabili AWS_ACCESS_KEY_ID di ambiente AWS_SECRET_ACCESS_KEY devono contenere le credenziali associate all'account.

    Esporta queste variabili come stringhe sul tuo client utilizzando i seguenti comandi. Sostituisci i valori evidenziati di seguito con i valori appropriati IAM dell'account utente.

    export AWS_ACCESS_KEY_ID="AKIAIOSFODNN7EXAMPLE"
export AWS_SECRET_ACCESS_KEY="wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
Nota

  • Dopo aver completato tutti i prerequisiti, puoi inviare richieste firmate HTTPS per accedere alle API operazioni di Amazon Managed Blockchain (AMB) Query ed effettuare richieste utilizzando il modulo https nativo in Node.js, oppure puoi utilizzare una libreria di terze parti come AXIOSe recuperare dati da AMB Query.

  • Questi esempi utilizzano un HTTP client di terze parti per Node.js, ma puoi anche usare AWS JavaScript SDKper effettuare richieste a AMB Query.

  • L'esempio seguente mostra come effettuare API richieste di AMB Query utilizzando Axios e il AWS SDKmoduli per SigV4.

Copia il seguente package.json file nella directory di lavoro del tuo ambiente locale:

{
  "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"
  }
}
Esempio — Recupera il saldo storico dei token da uno specifico indirizzo di proprietà esterna (EOA) utilizzando Query AMB GetTokenBalance API

È possibile utilizzare il GetTokenBalance API per ottenere il saldo di vari token (ad esempio, ERC2 0ERC721, eERC1155) e monete native (ad esempio ETH eBTC), che è possibile utilizzare per ottenere il saldo corrente di un account di proprietà esterna () in base a uno storico timestamp (timestamp Unix: secondiEOA). In questo esempio, si utilizza il GetTokenBalanceAPIper ottenere il saldo degli indirizzi di un token ERC2 0, USDC sulla rete principale di Ethereum.

Per testare il GetTokenBalanceAPI, copia il codice seguente in un file denominato token-balance.js e salva il file nella stessa directory di lavoro:

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);

Per eseguire il codice, aprite un terminale nella stessa directory dei file ed eseguite il seguente comando:

npm i
node token-balance.js

Questo comando esegue lo script, passando gli argomenti definiti nel codice per richiedere il USDC saldo ERC2 0 dei EOA listati sulla rete principale di Ethereum. La risposta è simile a quella riportata di seguito.

 {
  atBlockchainInstant: { time: 1688076218 },
  balance: '140386693440144',
  lastUpdatedTime: { time: 1688074727 },
  ownerIdentifier: { address: '0xf3b0073e3a7f747c7a38b36b805247b2********' },
  tokenIdentifier: {
    contractAddress: '0xa0b86991c6218b36c1d19d4a2e9eb0ce********',
    network: 'ETHEREUM_MAINNET'
  }

Effettua API richieste di Amazon Managed Blockchain (AMB) Query utilizzando Python

Per eseguire questi esempi in Python, si applicano i seguenti prerequisiti:

  1. Devi avere Python installato sulla tua macchina. Puoi trovare le istruzioni di installazione per il tuo sistema operativo qui.

  2. Installa il AWSSDKfor Python (Boto3).

  3. Installazione di AWS Interfaccia a riga di comando ed esegui il comando aws configure per impostare le variabili perAccess Key ID, Secret Access Key e. Region

Dopo aver completato tutti i prerequisiti, è possibile utilizzare AWS SDKper Python over per HTTPS effettuare richieste Amazon Managed Blockchain (AMB) QueryAPI.

Il seguente esempio di Python utilizza i moduli di boto3 per inviare richieste apposte con le intestazioni SigV4 richieste all'operazione Query. AMB ListTransactionEvents API Questo esempio recupera un elenco di eventi emessi da una determinata transazione sulla rete principale di Ethereum.

Copia il seguente list-transaction-events.py file nella directory di lavoro del tuo ambiente locale:

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')))

Per eseguire il codice di esempio suListTransactionEvents, salvate il file nella directory di lavoro, quindi eseguite il comandopython3 list-transaction-events.py. Questo comando esegue lo script, passando gli argomenti definiti nel codice per richiedere gli eventi associati all'hash della transazione specificato sulla rete principale di Ethereum. La risposta è simile a quella riportata di seguito.

{
 'events': 
 [
  {
      'contractAddress': '0x95ad61b0a150d79219dcf64e1e6cc01f********',
      'eventType': 'ERC20_TRANSFER',
      'from': '0xab5801a7d398351b8be11c439e05c5b3********',
      'network': 'ETHEREUM_MAINNET',
      'to': '0xdead0000000000000000420694206942********',
      'transactionHash': '0x125714bb4db48757007fff2671b37637bbfd6d47b3a4757ebbd0c522********',
      'value': '410241996771871894771826174755464'
  }
 ]
}

Usa Amazon Managed Blockchain (AMB) Query su AWS Management Console per eseguire l' GetTokenBalance operazione

L'esempio seguente mostra come ottenere il saldo di un token sulla rete principale di Ethereum utilizzando Amazon Managed Blockchain (AMB) Query su AWS Management Console

  1. Apri la console Amazon Managed Blockchain all'indirizzo https://console.aws.amazon.com/managedblockchain/.

  2. Scegli Query editor dalla sezione Query.

  3. Scegli ETHEREUM_ MAINNET come rete Blockchain.

  4. Scegli GetTokenBalancecome tipo di query.

  5. Inserisci il tuo indirizzo Blockchain per il token.

  6. Inserisci l'indirizzo del contratto per il token.

  7. Inserisci l'ID token opzionale per il token.

  8. Scegli la data di scadenza per il saldo del token.

  9. Inserisci l'opzione At time per il saldo del token.

  10. Scegli Esegui query.

AMBQuery eseguirà la tua query e vedrai i risultati nella finestra dei risultati della query.