Memulai Kueri Amazon Managed Blockchain (AMB) - Kueri Blockchain yang Dikelola Amazon
Buat kebijakan IAMContoh menggunakan GoContoh menggunakan Node.jsContoh menggunakan PythonContoh menggunakan AWS Management Console

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Memulai Kueri Amazon Managed Blockchain (AMB)

Gunakan step-by-step tutorial di bagian ini untuk mempelajari cara melakukan tugas dengan menggunakan Kueri Amazon Managed Blockchain (AMB). Prosedur ini membutuhkan beberapa prasyarat. Jika Anda baru mengenal AMB Query, Anda dapat meninjau bagian Pengaturan dari panduan ini. Untuk informasi selengkapnya, lihat Menyiapkan Kueri Amazon Managed Blockchain (AMB).

catatan

Beberapa variabel dalam contoh-contoh ini sengaja dikaburkan. Ganti dengan yang valid dari Anda sendiri sebelum menjalankan contoh-contoh ini.

Membuat kebijakan IAM untuk mengakses operasi AMB Query API

Untuk membuat permintaan AMB Query API, Anda harus menggunakan kredensyal pengguna (AWS_ACCESS_KEY_ID dan AWS_SECRET_ACCESS_KEY) yang memiliki izin IAM yang sesuai untuk Kueri Amazon Managed Blockchain (AMB). Di terminal dengan AWS CLI instalasi, jalankan perintah berikut untuk membuat kebijakan IAM untuk mengakses operasi AMB Query API: 

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

Setelah Anda membuat kebijakan, lampirkan kebijakan tersebut ke Peran pengguna IAM agar kebijakan tersebut diterapkan. Di bagian AWS Management Console, navigasikan ke layanan IAM, dan lampirkan kebijakan AmazonManagedBlockchainQueryAccess ke Peran yang ditetapkan ke pengguna IAM yang akan menggunakan layanan. Untuk informasi selengkapnya, lihat Membuat Peran dan menetapkan ke pengguna IAM.

catatan

AWS merekomendasikan agar Anda memberikan akses ke operasi API tertentu daripada menggunakan wild-card*. Untuk informasi selengkapnya, lihat Mengakses tindakan kueri API Amazon Managed Blockchain (AMB) tertentu.

Buat permintaan API Kueri Amazon Managed Blockchain (AMB) dengan menggunakan Go

Dengan Amazon Managed Blockchain (AMB) Query, Anda dapat membangun aplikasi yang bergantung pada akses instan ke data blockchain setelah dikonfirmasi di blockchain, bahkan jika belum mencapai finalitas. AMB Query memungkinkan beberapa kasus penggunaan seperti mengisi riwayat transaksi dompet, memberikan informasi kontekstual tentang transaksi berdasarkan hash transaksinya, atau mendapatkan saldo token asli serta token ERC-721, ERC-1155, dan ERC-20.

Contoh berikut dibuat dalam bahasa Go dan menggunakan operasi AMB Query API. Untuk informasi selengkapnya tentang Go, lihat Dokumentasi Go. Untuk informasi selengkapnya tentang AMB Query API, lihat Dokumentasi Referensi API Kueri Amazon Managed Blockchain (AMB).

Contoh berikut menggunakan ListTransactions dan tindakan GetTransaction API untuk terlebih dahulu mendapatkan daftar semua transaksi untuk alamat yang dimiliki eksternal (EOA) tertentu di Ethereum Mainnet, dan kemudian contoh berikutnya mengambil detail transaksi untuk satu transaksi dari daftar.

contoh — Buat tindakan ListTransactions API menggunakan Go

Salin kode berikut ke file bernama listTransactions.go dalam ListTransactionsdirektori.

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

Setelah Anda menyimpan file, jalankan kode dengan menggunakan perintah berikut di dalam ListTransactionsdirektori:go run listTransactions.go.

Output yang berikut menyerupai berikut ini:

{
  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
    }
  ]
}
contoh — Buat tindakan GetTransaction API dengan menggunakan Go

Contoh ini menggunakan hash transaksi dari output sebelumnya. Salin kode berikut ke file bernama GetTransaction.go dalam GetTransactiondirektori.

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

Setelah Anda menyimpan file, jalankan kode dengan menggunakan perintah berikut di dalam GetTransactiondirektori:go run GetTransaction.go.

Output yang berikut menyerupai berikut ini:

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

GetTokenBalanceAPI menyediakan cara bagi Anda untuk mendapatkan saldo token asli (ETH dan BTC), yang dapat digunakan untuk mendapatkan saldo saat ini dari akun yang dimiliki secara eksternal (EOA) pada suatu titik waktu.

contoh — Gunakan tindakan GetTokenBalance API untuk mendapatkan saldo token asli di Go

Dalam contoh berikut, Anda menggunakan GetTokenBalance API untuk mendapatkan saldo alamat Ether (ETH) di Ethereum Mainnet. Salin kode berikut ke file bernama GetTokenBalanceEth.go dalam GetTokenBalancedirektori.

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

Setelah Anda menyimpan file, jalankan kode dengan menggunakan perintah berikut di dalam GetTokenBalancedirektori:go run GetTokenBalanceEth.go.

Output yang berikut menyerupai berikut ini:

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

Buat permintaan API Kueri Amazon Managed Blockchain (AMB) dengan menggunakan Node.js

Untuk menjalankan contoh Node ini, prasyarat berikut berlaku:

  1. Anda harus memiliki node version manager (nvm) dan Node.js diinstal pada mesin Anda. Anda dapat menemukan instruksi instalasi untuk OS Anda di sini.

  2. Gunakan node --version perintah dan konfirmasikan bahwa Anda menggunakan Node versi 14 atau lebih tinggi. Jika diperlukan, Anda dapat menggunakan nvm install 14 perintah, diikuti oleh nvm use 14 perintah untuk menginstal versi 14.

  3. Variabel lingkungan AWS_ACCESS_KEY_ID dan AWS_SECRET_ACCESS_KEY harus berisi kredensil yang terkait dengan akun.

    Ekspor variabel ini sebagai string pada klien Anda dengan menggunakan perintah berikut. Ganti nilai yang disorot berikut ini dengan nilai yang sesuai dari akun pengguna IAM.

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

  • Setelah menyelesaikan semua prasyarat, Anda dapat mengirimkan permintaan yang ditandatangani melalui HTTPS untuk mengakses operasi API Kueri Amazon Managed Blockchain (AMB) dan membuat permintaan dengan menggunakan modul https asli di Node.js, atau Anda dapat menggunakan pustaka pihak ketiga seperti AXIOS dan mengambil data dari AMB Query.

  • Contoh ini menggunakan klien HTTP pihak ketiga untuk Node.js, tetapi Anda juga dapat menggunakan AWS JavaScript SDK untuk membuat permintaan ke AMB Query.

  • Contoh berikut menunjukkan cara membuat permintaan AMB Query API dengan menggunakan Axios dan modul AWS SDK untuk SigV4.

Salin package.json file berikut ke direktori kerja lingkungan lokal Anda:

{
  "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"
  }
}
contoh — Ambil saldo token historis dari alamat yang dimiliki eksternal (EOA) tertentu dengan menggunakan AMB Query API GetTokenBalance

Anda dapat menggunakan GetTokenBalance API untuk mendapatkan saldo berbagai token (misalnya, ERC20, ERC721, dan ERC1155) dan koin asli (misalnya, ETH dan BTC), yang dapat Anda gunakan untuk mendapatkan saldo saat ini dari akun yang dimiliki secara eksternal (EOA) berdasarkan historis (stempel waktu Unix - detik). timestamp Dalam contoh ini, Anda menggunakan GetTokenBalanceAPI untuk mendapatkan saldo alamat token ERC20, USDC, di Ethereum Mainnet.

Untuk menguji GetTokenBalance API, salin kode berikut ke dalam file bernamatoken-balance.js, dan simpan file ke direktori kerja yang sama:

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

Untuk menjalankan kode, buka terminal di direktori yang sama dengan file Anda dan jalankan perintah berikut:

npm i
node token-balance.js

Perintah ini menjalankan skrip, meneruskan argumen yang ditentukan dalam kode untuk meminta saldo ERC20 USDC dari EOA yang terdaftar di Ethereum Mainnet. Responsnya terlihat seperti berikut:

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

Buat permintaan API Kueri Amazon Managed Blockchain (AMB) dengan menggunakan Python

Untuk menjalankan contoh Python ini, prasyarat berikut berlaku:

  1. Anda harus menginstal Python di mesin Anda. Anda dapat menemukan instruksi instalasi untuk OS Anda di sini.

  2. Instal AWS SDK untuk Python (Boto3).

  3. Instal AWS Command Line Interface dan jalankan perintah aws configure untuk mengatur variabel untuk AndaAccess Key ID,Secret Access Key, danRegion.

Setelah menyelesaikan semua prasyarat, Anda dapat menggunakan SDK AWS untuk Python melalui HTTPS untuk membuat permintaan API Kueri Amazon Managed Blockchain (AMB).

Contoh Python berikut menggunakan modul dari boto3 untuk mengirim permintaan yang ditempelkan dengan header SigV4 yang diperlukan ke operasi AMB Query API. ListTransactionEvents Contoh ini mengambil daftar peristiwa yang dipancarkan oleh transaksi tertentu di Ethereum Mainnet.

Salin list-transaction-events.py file berikut ke direktori kerja lingkungan lokal Anda:

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

Untuk menjalankan kode sampel keListTransactionEvents, simpan file di direktori kerja Anda dan kemudian jalankan perintahpython3 list-transaction-events.py. Perintah ini menjalankan skrip, meneruskan argumen yang ditentukan dalam kode untuk meminta peristiwa yang terkait dengan hash transaksi yang diberikan di Ethereum Mainnet. Responsnya terlihat seperti berikut:

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

Gunakan Kueri Amazon Managed Blockchain (AMB) AWS Management Console untuk menjalankan operasi GetTokenBalance

Contoh berikut menunjukkan cara mendapatkan saldo token di Ethereum Mainnet menggunakan Amazon Managed Blockchain (AMB) Query di AWS Management Console

  1. Buka konsol Amazon Managed Blockchain di https://console.aws.amazon.com/managedblockchain/.

  2. Pilih Editor kueri dari bagian Kueri.

  3. Pilih ETHEREUM_MAINNET sebagai jaringan Blockchain.

  4. Pilih GetTokenBalancesebagai tipe Query.

  5. Masukkan alamat Blockchain Anda untuk token.

  6. Masukkan alamat Kontrak untuk token.

  7. Masukkan ID Token opsional untuk token.

  8. Pilih Tanggal Pada untuk saldo token.

  9. Masukkan opsional Pada waktu untuk saldo token.

  10. Pilih Run query (Jalankan kueri).

AMB Query akan menjalankan query Anda dan Anda akan melihat hasilnya di jendela hasil Query.