ipld-eth-server/pkg/graphql/client.go

275 lines
6.6 KiB
Go
Raw Normal View History

2021-07-02 09:00:48 +00:00
package graphql
import (
"context"
"encoding/json"
"fmt"
"strings"
2021-07-02 09:00:48 +00:00
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
gqlclient "github.com/machinebox/graphql"
)
type StorageResponse struct {
2022-06-06 11:16:53 +00:00
CID string `json:"cid"`
2021-07-02 09:00:48 +00:00
Value common.Hash `json:"value"`
IpldBlock hexutil.Bytes `json:"ipldBlock"`
}
type GetStorageAt struct {
Response StorageResponse `json:"getStorageAt"`
}
type LogResponse struct {
2022-06-06 10:06:29 +00:00
Topics []common.Hash `json:"topics"`
Data hexutil.Bytes `json:"data"`
Transaction TransactionResponse `json:"transaction"`
ReceiptCID string `json:"receiptCID"`
Status int32 `json:"status"`
}
2022-06-06 10:06:29 +00:00
type TransactionResponse struct {
Hash common.Hash `json:"hash"`
2021-07-02 09:00:48 +00:00
}
type GetLogs struct {
Responses []LogResponse `json:"getLogs"`
}
2022-06-06 10:06:29 +00:00
type IPFSBlockResponse struct {
2022-06-01 09:15:48 +00:00
Key string `json:"key"`
Data string `json:"data"`
}
2022-06-06 11:16:53 +00:00
type EthTransactionCIDResponse struct {
CID string `json:"cid"`
TxHash string `json:"txHash"`
Index int32 `json:"index"`
Src string `json:"src"`
Dst string `json:"dst"`
BlockByCid IPFSBlockResponse `json:"blockByCid"`
2022-06-01 09:15:48 +00:00
}
2022-06-06 11:16:53 +00:00
type EthTransactionCIDByTxHash struct {
Response EthTransactionCIDResponse `json:"ethTransactionCidByTxHash"`
}
2022-06-06 11:16:53 +00:00
type EthTransactionCIDsByHeaderIdResponse struct {
Nodes []EthTransactionCIDResponse `json:"nodes"`
2022-06-01 09:15:48 +00:00
}
2022-06-06 11:16:53 +00:00
type EthHeaderCIDResponse struct {
CID string `json:"cid"`
2022-06-06 10:06:29 +00:00
BlockNumber BigInt `json:"blockNumber"`
BlockHash string `json:"blockHash"`
ParentHash string `json:"parentHash"`
Timestamp BigInt `json:"timestamp"`
StateRoot string `json:"stateRoot"`
Td BigInt `json:"td"`
TxRoot string `json:"txRoot"`
ReceiptRoot string `json:"receiptRoot"`
UncleRoot string `json:"uncleRoot"`
Bloom string `json:"bloom"`
2022-06-06 11:16:53 +00:00
EthTransactionCIDsByHeaderId EthTransactionCIDsByHeaderIdResponse `json:"ethTransactionCidsByHeaderId"`
BlockByCid IPFSBlockResponse `json:"blockByCid"`
2022-06-01 09:15:48 +00:00
}
2022-06-06 11:16:53 +00:00
type AllEthHeaderCIDsResponse struct {
Nodes []EthHeaderCIDResponse `json:"nodes"`
2022-06-01 09:15:48 +00:00
}
2022-06-06 11:16:53 +00:00
type AllEthHeaderCIDs struct {
Response AllEthHeaderCIDsResponse `json:"allEthHeaderCids"`
2022-06-01 09:15:48 +00:00
}
2021-07-02 09:00:48 +00:00
type Client struct {
client *gqlclient.Client
}
func NewClient(endpoint string) *Client {
client := gqlclient.NewClient(endpoint)
return &Client{client: client}
}
func (c *Client) GetLogs(ctx context.Context, hash common.Hash, addresses []common.Address) ([]LogResponse, error) {
params := fmt.Sprintf(`blockHash: "%s"`, hash.String())
if addresses != nil {
addressStrings := make([]string, len(addresses))
for i, address := range addresses {
addressStrings[i] = fmt.Sprintf(`"%s"`, address.String())
}
params += fmt.Sprintf(`, addresses: [%s]`, strings.Join(addressStrings, ","))
}
getLogsQuery := fmt.Sprintf(`query{
getLogs(%s) {
2021-07-02 09:00:48 +00:00
data
topics
transaction {
hash
}
2021-08-30 15:29:54 +00:00
status
2021-09-01 07:02:28 +00:00
receiptCID
2021-07-02 09:00:48 +00:00
}
}`, params)
2021-07-02 09:00:48 +00:00
req := gqlclient.NewRequest(getLogsQuery)
req.Header.Set("Cache-Control", "no-cache")
var respData map[string]interface{}
err := c.client.Run(ctx, req, &respData)
if err != nil {
return nil, err
}
jsonStr, err := json.Marshal(respData)
if err != nil {
return nil, err
}
var logs GetLogs
err = json.Unmarshal(jsonStr, &logs)
if err != nil {
return nil, err
}
return logs.Responses, nil
}
func (c *Client) GetStorageAt(ctx context.Context, hash common.Hash, address common.Address, slot string) (*StorageResponse, error) {
getLogsQuery := fmt.Sprintf(`
query{
getStorageAt(blockHash: "%s", contract: "%s",slot: "%s") {
cid
value
ipldBlock
}
}
`, hash.String(), address.String(), common.HexToHash(slot))
req := gqlclient.NewRequest(getLogsQuery)
req.Header.Set("Cache-Control", "no-cache")
var respData map[string]interface{}
err := c.client.Run(ctx, req, &respData)
if err != nil {
return nil, err
}
jsonStr, err := json.Marshal(respData)
if err != nil {
return nil, err
}
var storageAt GetStorageAt
err = json.Unmarshal(jsonStr, &storageAt)
if err != nil {
return nil, err
}
return &storageAt.Response, nil
}
2022-06-01 09:15:48 +00:00
2022-06-06 11:16:53 +00:00
func (c *Client) AllEthHeaderCIDs(ctx context.Context, condition EthHeaderCIDCondition) (*AllEthHeaderCIDsResponse, error) {
2022-06-01 09:15:48 +00:00
var params string
if condition.BlockHash != nil {
params = fmt.Sprintf(`blockHash: "%s"`, *condition.BlockHash)
}
if condition.BlockNumber != nil {
params += fmt.Sprintf(`blockNumber: "%s"`, condition.BlockNumber.String())
}
getHeadersQuery := fmt.Sprintf(`
2022-06-01 09:15:48 +00:00
query{
allEthHeaderCids(condition: { %s }) {
nodes {
cid
blockNumber
blockHash
parentHash
timestamp
stateRoot
td
txRoot
receiptRoot
uncleRoot
bloom
blockByCid {
2022-06-01 09:15:48 +00:00
key
data
}
ethTransactionCidsByHeaderId {
nodes {
cid
txHash
index
src
dst
}
}
}
}
}
`, params)
req := gqlclient.NewRequest(getHeadersQuery)
2022-06-01 09:15:48 +00:00
req.Header.Set("Cache-Control", "no-cache")
var respData map[string]interface{}
err := c.client.Run(ctx, req, &respData)
if err != nil {
return nil, err
}
jsonStr, err := json.Marshal(respData)
if err != nil {
return nil, err
}
2022-06-06 11:16:53 +00:00
var allEthHeaderCIDs AllEthHeaderCIDs
err = json.Unmarshal(jsonStr, &allEthHeaderCIDs)
2022-06-01 09:15:48 +00:00
if err != nil {
return nil, err
}
2022-06-06 11:16:53 +00:00
return &allEthHeaderCIDs.Response, nil
2022-06-01 09:15:48 +00:00
}
2022-06-06 11:16:53 +00:00
func (c *Client) EthTransactionCIDByTxHash(ctx context.Context, txHash string) (*EthTransactionCIDResponse, error) {
getTxQuery := fmt.Sprintf(`
query{
ethTransactionCidByTxHash(txHash: "%s") {
cid
txHash
index
src
dst
blockByCid {
data
}
}
}
`, txHash)
req := gqlclient.NewRequest(getTxQuery)
req.Header.Set("Cache-Control", "no-cache")
var respData map[string]interface{}
err := c.client.Run(ctx, req, &respData)
if err != nil {
return nil, err
}
jsonStr, err := json.Marshal(respData)
if err != nil {
return nil, err
}
2022-06-06 11:16:53 +00:00
var ethTxCID EthTransactionCIDByTxHash
err = json.Unmarshal(jsonStr, &ethTxCID)
if err != nil {
return nil, err
}
2022-06-06 11:16:53 +00:00
return &ethTxCID.Response, nil
}