go nennt neue Methode des Soliditätsvertrags

Ich habe letzte Woche im Gruppenchat geprahlt und mit dem Golang geprahlt, den ich geschrieben habe, um den Solana-Vertrag aufzurufen. Manche Leute sagen, dass sie lernen wollen, wie man Solidität nennt. Ich habe mir die Methoden zum Aufrufen von Verträgen ohne ABI angesehen, die ich auf dem Link gepostet habe. Sie wurden in Python, Ether und Solidity geschrieben, aber nicht in Golang. Sie können tatsächlich geschrieben werden.

Die Leute in dieser Gruppe sagten, dass die Verwendung von chatgpt Abigen verwenden wird, um Go-Pakete zu generieren, um Vertragsmethoden aufzurufen.
Deshalb werde ich über eine Methode sprechen, die nicht die Verwendung von Abigen zum Generieren eines Go-Pakets zum Aufrufen des Vertrags erfordert.

Ich verwende immer noch gerne meine Fork-Version von Xiaodao, https://github.com/daog1/ethgo
Fork von,umbracle/ethgo
Ich werde nicht über die Vorteile sprechen, lesen Sie einfach selbst den Code.

Zuerst erforderten Vertragsaufrufe die Generierung von ABI-Dateien. Später gab es eine einfachere Methode, die ich in Ethers nannte.

Ein für Menschen lesbares ABI

ethers wird so geschrieben:

// 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 ist ein bisschen wie das Forken von Ethern, daher unterstützt es auch Human-Readable ABI.

Der Code ist so geschrieben

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

Der Originalcode ist hier: https://github.com/daog1/ethgo/blob/main/examples/contract-call-basic.go

Wenn Sie Probleme mit meiner Fork-Version finden, können Sie es mir sagen.
Normalerweise verwende ich für den Anruf das vom Menschen lesbare ABI. Abigen ist zu mühsam und es kann leicht zu Fehlern kommen.

Das obige ist der detaillierte Inhalt vongo nennt neue Methode des Soliditätsvertrags. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!