go appelle nouvelle méthode de contrat de solidité

Je me vantais dans le chat de groupe la semaine dernière, me vantant du golang que j'avais écrit pour appeler le contrat solana. Certaines personnes disent vouloir apprendre comment on appelle la solidité. J'ai regardé les méthodes d'appel de contrats sans ABI que j'ai publiées sur le lien. Elles étaient écrites en python, ethers et solidity, mais pas en golang.

Les membres de ce groupe ont déclaré que l'utilisation de chatgpt utiliserait abigen pour générer des packages go permettant d'appeler des méthodes de contrat.
Je vais donc parler d'une méthode qui ne nécessite pas d'utiliser abigen pour générer un package go pour appeler le contrat.

J'aime toujours utiliser ma version fork de Xiaodao, https://github.com/daog1/ethgo
Fourche de,umbracle/ethgo
Je ne parlerai pas des avantages, lisez simplement le code vous-même.

Au début, les appels de contrat nécessitaient la génération de fichiers abi. Plus tard, il y a eu une méthode plus simple. La première que j'ai vue s'appelait

dans les éthers.

Un ABI lisible par l'homme

les éthers s'écrivent ainsi :

// A Human-Readable ABI; for interacting with the contract, we
// must include any fragment we wish to use
const abi = [
    // Read-Only Functions
    "function balanceOf(address owner) view returns (uint256)",
    "function decimals() view returns (uint8)",
    "function symbol() view returns (string)",

    // Authenticated Functions
    "function transfer(address to, uint amount) returns (bool)",

    // Events
    "event Transfer(address indexed from, address indexed to, uint amount)"
];

// This can be an address or an ENS name
const address = "0x70ff5c5B1Ad0533eAA5489e0D5Ea01485d530674";

// Read-Only; By connecting to a Provider, allows:
// - Any constant function
// - Querying Filters
// - Populating Unsigned Transactions for non-constant methods
// - Estimating Gas for non-constant (as an anonymous sender)
// - Static Calling non-constant methods (as anonymous sender)
const erc20 = new ethers.Contract(address, abi, provider);

// Read-Write; By connecting to a Signer, allows:
// - Everything from Read-Only (except as Signer, not anonymous)
// - Sending transactions for non-constant functions
const erc20_rw = new ethers.Contract(address, abi, signer);

ethgo est un peu comme bifurquer des éthers, il prend donc également en charge l'ABI lisible par l'homme.
Le code est écrit comme ceci

package main

import (
    "fmt"
    "math/big"

    "github.com/umbracle/ethgo"
    "github.com/umbracle/ethgo/abi"
    "github.com/umbracle/ethgo/contract"
    "github.com/umbracle/ethgo/jsonrpc"
)

func handleErr(err error) {
    if err != nil {
        panic(err)
    }
}

func main() {
    var functions = []string{
        "function totalSupply() view returns (uint256)",  //Human-Readable ABI 
    }

    abiContract, err := abi.NewABIFromList(functions)
    handleErr(err)

    // Matic token
    addr := ethgo.HexToAddress("0x7d1afa7b718fb893db30a3abc0cfc608aacfebb0") 

    client, err := jsonrpc.NewClient("https://eth.llamarpc.com")
    handleErr(err)

    c := contract.NewContract(addr, abiContract, contract.WithJsonRPC(client.Eth()))
    res, err := c.Call("totalSupply", ethgo.Latest)  //call totalSupply
    handleErr(err)

    fmt.Printf("TotalSupply: %s", res["0"].(*big.Int))
}

Le code original est ici : https://github.com/daog1/ethgo/blob/main/examples/contract-call-basic.go
Si vous rencontrez des problèmes avec ma version fork, vous pouvez me le dire.
J'utilise généralement ABI lisible par l'homme pour appeler, abigen est trop gênant et facile à commettre des erreurs.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!