go calls new method of solidity contract

I was bragging in the group chat last week, bragging about the golang I wrote to call the solana contract. Some people say that they want to learn how go calls solidity. I looked at the methods of calling contracts without ABI that I posted on the link. They were written in python, ethers, and solidity, but not in golang. They can indeed be written.

People in that group said that using chatgpt will use abigen to generate go packages to call contract methods.
So I will talk about a method that does not require using abigen to generate a go package to call the contract.

I still like to use my fork version of Xiaodao, https://github.com/daog1/ethgo
Fork from,umbracle/ethgo
I won’t talk about the benefits, just read the code yourself.

At first, contract calls required the generation of abi files. Later, there was a simpler method. The earliest I saw was called

in ethers.

A Human-Readable ABI

ethers is written like this:

// 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 is a bit like forking ethers, so it also supports Human-Readable ABI.
The code is written like this

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

The original code is here: https://github.com/daog1/ethgo/blob/main/examples/contract-call-basic.go
If you find any problems with my fork version, you can tell me.
I usually use Human-Readable ABI to call, abigen is too troublesome and easy to make mistakes.

The above is the detailed content of go calls new method of solidity contract. For more information, please follow other related articles on the PHP Chinese website!