Actualmente desarrollo dapps que usan contratos inteligentes como almacenamiento para datos específicos. Utilizo abigen para generar una vinculación específica de mi contrato. Si alguien intenta cambiar el estado del contrato, uso el evento para registrar esta acción. Pero estoy atascado, porque realmente no entiendo cómo puedo ver el historial de registro de un evento específico usando go ethereum.
¿Cómo puedo usar json rpc call of eth_getlogsmethod y obtener todos los registros que están almacenados en esta dirección de contrato con go?
Seré apreciado por un fragmento de código.
¡Gracias por adelantado!
Por lo general, primero crearía un nuevo filtro ( eth_newFilter+ eth_getFilterLogs) y reutilizaría ese filtro para realizar la misma consulta muchas veces y escuchar los cambios. Sin embargo, también puede instalar un filtro ad-hoc con eth_getLogsreferencia a los temas que desea buscar.
Un tema es un dato que está buscando. Por ejemplo, si tiene el siguiente evento:
Transfer(address to, address from)
El siguiente filtro buscaría todos los registros que vayan a 0xb3904758c0d3bfc25746c47caa45b01da8930e19:
[0x000000000000000000000000b3904758c0d3bfc25746c47caa45b01da8930e19, null]
Este filtro buscaría todos los registros provenientes de 0xb3904758c0d3bfc25746c47caa45b01da8930e19:
[null, 0x000000000000000000000000b3904758c0d3bfc25746c47caa45b01da8930e19]
Y este filtro buscaría todos los registros que van 0xb3904758c0d3bfc25746c47caa45b01da8930e19desde 0x8cc19c7b50857abbfbeeed31c302319a075d4a9b:
[0x000000000000000000000000b3904758c0d3bfc25746c47caa45b01da8930e19, 0x0000000000000000000000008cc19c7b50857abbfbeeed31c302319a075d4a9b
Un contenedor de golang completo para solicitudes RPC se vería así:
// This needs to be instantiated
type EthereumClient struct {
URL string
}
// Basic RPC repsonse format
type JSONRPCRequest struct {
JSONRPC string `json:"jsonrpc"`
Method string `json:"method"`
ID int64 `json:"id"`
Params []interface{} `json:"params"`
}
// Base struct
type ResponseBase struct {
JSONRPC string `json:"jsonrpc"`
ID int64 `json:"id"`
}
// Response struct based on below RPC methods
type Response struct {
ResponseBase
Result string `json:"result"`
}
// ToJSON marshals a JSONRPCRequest into JSON
func (req *JSONRPCRequest) ToJSON() ([]byte, error) {
s, err := json.Marshal(req)
if err != nil {
return nil, err
}
return s, nil
}
// Get logs given an array of topics
func (client *EthereumClient) Eth_getLogs(topics string[]) (string, error) {
reqBody := JSONRPCRequest{
JSONRPC: "2.0",
ID: 1,
Method: "eth_sendRawTransaction",
Params: []interface{}{topics},
}
res, err := client.issueRequest(&reqBody)
if err != nil {
return "", err
}
var clientResp Response
err = json.Unmarshal(res, &clientResp)
if err != nil {
return "", err
}
return clientResp.Result, nil
}
El EthereumClientpuede ser instanciado en un paquete diferente por algo como esto:
// Global client connection
var client = EthereumClient{}
// provider = e.g. 'localhost:8545'
func ConnectToRPC(provider string) {
client = EthereumClient{provider}
}
Esto clientahora se puede usar para iniciar un nuevo filtro y obtener los registros de ese filtro.
No tengo un ejemplo específico para este caso de uso, pero consulte esto para ver algunos ejemplos de cómo realizar solicitudes RPC en Go.
Puede agregar la dirección del contrato como parámetro a la llamada eth_getLogs:
curl -X POST --data '{"jsonrpc":"2.0","method":"eth_getLogs","params":[{"address":["YOUR_CONTRACT_ADDRESS"]}],"id":74}'
Si está interesado en sondear constantemente las actualizaciones de eventos, primero puede crear un filtro con eth_newFilter y luego solicitar actualizaciones con eth_getFilterChanges .