Example Solidity contract, ABI and Go bindings
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
[ | |
{ | |
"inputs": [], | |
"name": "retrieve", | |
"outputs": [ | |
{ | |
"internalType": "uint256", | |
"name": "", | |
"type": "uint256" | |
} | |
], | |
"stateMutability": "view", | |
"type": "function" | |
}, | |
{ | |
"inputs": [ | |
{ | |
"internalType": "uint256", | |
"name": "num", | |
"type": "uint256" | |
} | |
], | |
"name": "store", | |
"outputs": [], | |
"stateMutability": "nonpayable", | |
"type": "function" | |
} | |
] |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// Code generated - DO NOT EDIT. | |
// This file is a generated binding and any manual changes will be lost. | |
package store | |
import ( | |
"math/big" | |
"strings" | |
ethereum "github.com/ethereum/go-ethereum" | |
"github.com/ethereum/go-ethereum/accounts/abi" | |
"github.com/ethereum/go-ethereum/accounts/abi/bind" | |
"github.com/ethereum/go-ethereum/common" | |
"github.com/ethereum/go-ethereum/core/types" | |
"github.com/ethereum/go-ethereum/event" | |
) | |
// Reference imports to suppress errors if they are not otherwise used. | |
var ( | |
_ = big.NewInt | |
_ = strings.NewReader | |
_ = ethereum.NotFound | |
_ = bind.Bind | |
_ = common.Big1 | |
_ = types.BloomLookup | |
_ = event.NewSubscription | |
) | |
// StoreABI is the input ABI used to generate the binding from. | |
const StoreABI = "[{\"inputs\":[],\"name\":\"retrieve\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"num\",\"type\":\"uint256\"}],\"name\":\"store\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" | |
// Store is an auto generated Go binding around an Ethereum contract. | |
type Store struct { | |
StoreCaller // Read-only binding to the contract | |
StoreTransactor // Write-only binding to the contract | |
StoreFilterer // Log filterer for contract events | |
} | |
// StoreCaller is an auto generated read-only Go binding around an Ethereum contract. | |
type StoreCaller struct { | |
contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
} | |
// StoreTransactor is an auto generated write-only Go binding around an Ethereum contract. | |
type StoreTransactor struct { | |
contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
} | |
// StoreFilterer is an auto generated log filtering Go binding around an Ethereum contract events. | |
type StoreFilterer struct { | |
contract *bind.BoundContract // Generic contract wrapper for the low level calls | |
} | |
// StoreSession is an auto generated Go binding around an Ethereum contract, | |
// with pre-set call and transact options. | |
type StoreSession struct { | |
Contract *Store // Generic contract binding to set the session for | |
CallOpts bind.CallOpts // Call options to use throughout this session | |
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session | |
} | |
// StoreCallerSession is an auto generated read-only Go binding around an Ethereum contract, | |
// with pre-set call options. | |
type StoreCallerSession struct { | |
Contract *StoreCaller // Generic contract caller binding to set the session for | |
CallOpts bind.CallOpts // Call options to use throughout this session | |
} | |
// StoreTransactorSession is an auto generated write-only Go binding around an Ethereum contract, | |
// with pre-set transact options. | |
type StoreTransactorSession struct { | |
Contract *StoreTransactor // Generic contract transactor binding to set the session for | |
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session | |
} | |
// StoreRaw is an auto generated low-level Go binding around an Ethereum contract. | |
type StoreRaw struct { | |
Contract *Store // Generic contract binding to access the raw methods on | |
} | |
// StoreCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. | |
type StoreCallerRaw struct { | |
Contract *StoreCaller // Generic read-only contract binding to access the raw methods on | |
} | |
// StoreTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. | |
type StoreTransactorRaw struct { | |
Contract *StoreTransactor // Generic write-only contract binding to access the raw methods on | |
} | |
// NewStore creates a new instance of Store, bound to a specific deployed contract. | |
func NewStore(address common.Address, backend bind.ContractBackend) (*Store, error) { | |
contract, err := bindStore(address, backend, backend, backend) | |
if err != nil { | |
return nil, err | |
} | |
return &Store{StoreCaller: StoreCaller{contract: contract}, StoreTransactor: StoreTransactor{contract: contract}, StoreFilterer: StoreFilterer{contract: contract}}, nil | |
} | |
// NewStoreCaller creates a new read-only instance of Store, bound to a specific deployed contract. | |
func NewStoreCaller(address common.Address, caller bind.ContractCaller) (*StoreCaller, error) { | |
contract, err := bindStore(address, caller, nil, nil) | |
if err != nil { | |
return nil, err | |
} | |
return &StoreCaller{contract: contract}, nil | |
} | |
// NewStoreTransactor creates a new write-only instance of Store, bound to a specific deployed contract. | |
func NewStoreTransactor(address common.Address, transactor bind.ContractTransactor) (*StoreTransactor, error) { | |
contract, err := bindStore(address, nil, transactor, nil) | |
if err != nil { | |
return nil, err | |
} | |
return &StoreTransactor{contract: contract}, nil | |
} | |
// NewStoreFilterer creates a new log filterer instance of Store, bound to a specific deployed contract. | |
func NewStoreFilterer(address common.Address, filterer bind.ContractFilterer) (*StoreFilterer, error) { | |
contract, err := bindStore(address, nil, nil, filterer) | |
if err != nil { | |
return nil, err | |
} | |
return &StoreFilterer{contract: contract}, nil | |
} | |
// bindStore binds a generic wrapper to an already deployed contract. | |
func bindStore(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { | |
parsed, err := abi.JSON(strings.NewReader(StoreABI)) | |
if err != nil { | |
return nil, err | |
} | |
return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil | |
} | |
// Call invokes the (constant) contract method with params as input values and | |
// sets the output to result. The result type might be a single field for simple | |
// returns, a slice of interfaces for anonymous returns and a struct for named | |
// returns. | |
func (_Store *StoreRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
return _Store.Contract.StoreCaller.contract.Call(opts, result, method, params...) | |
} | |
// Transfer initiates a plain transaction to move funds to the contract, calling | |
// its default method if one is available. | |
func (_Store *StoreRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
return _Store.Contract.StoreTransactor.contract.Transfer(opts) | |
} | |
// Transact invokes the (paid) contract method with params as input values. | |
func (_Store *StoreRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
return _Store.Contract.StoreTransactor.contract.Transact(opts, method, params...) | |
} | |
// Call invokes the (constant) contract method with params as input values and | |
// sets the output to result. The result type might be a single field for simple | |
// returns, a slice of interfaces for anonymous returns and a struct for named | |
// returns. | |
func (_Store *StoreCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { | |
return _Store.Contract.contract.Call(opts, result, method, params...) | |
} | |
// Transfer initiates a plain transaction to move funds to the contract, calling | |
// its default method if one is available. | |
func (_Store *StoreTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { | |
return _Store.Contract.contract.Transfer(opts) | |
} | |
// Transact invokes the (paid) contract method with params as input values. | |
func (_Store *StoreTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { | |
return _Store.Contract.contract.Transact(opts, method, params...) | |
} | |
// Retrieve is a free data retrieval call binding the contract method 0x2e64cec1. | |
// | |
// Solidity: function retrieve() view returns(uint256) | |
func (_Store *StoreCaller) Retrieve(opts *bind.CallOpts) (*big.Int, error) { | |
var out []interface{} | |
err := _Store.contract.Call(opts, &out, "retrieve") | |
if err != nil { | |
return *new(*big.Int), err | |
} | |
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) | |
return out0, err | |
} | |
// Retrieve is a free data retrieval call binding the contract method 0x2e64cec1. | |
// | |
// Solidity: function retrieve() view returns(uint256) | |
func (_Store *StoreSession) Retrieve() (*big.Int, error) { | |
return _Store.Contract.Retrieve(&_Store.CallOpts) | |
} | |
// Retrieve is a free data retrieval call binding the contract method 0x2e64cec1. | |
// | |
// Solidity: function retrieve() view returns(uint256) | |
func (_Store *StoreCallerSession) Retrieve() (*big.Int, error) { | |
return _Store.Contract.Retrieve(&_Store.CallOpts) | |
} | |
// Store is a paid mutator transaction binding the contract method 0x6057361d. | |
// | |
// Solidity: function store(uint256 num) returns() | |
func (_Store *StoreTransactor) Store(opts *bind.TransactOpts, num *big.Int) (*types.Transaction, error) { | |
return _Store.contract.Transact(opts, "store", num) | |
} | |
// Store is a paid mutator transaction binding the contract method 0x6057361d. | |
// | |
// Solidity: function store(uint256 num) returns() | |
func (_Store *StoreSession) Store(num *big.Int) (*types.Transaction, error) { | |
return _Store.Contract.Store(&_Store.TransactOpts, num) | |
} | |
// Store is a paid mutator transaction binding the contract method 0x6057361d. | |
// | |
// Solidity: function store(uint256 num) returns() | |
func (_Store *StoreTransactorSession) Store(num *big.Int) (*types.Transaction, error) { | |
return _Store.Contract.Store(&_Store.TransactOpts, num) | |
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
// SPDX-License-Identifier: GPL-3.0 | |
pragma solidity >=0.7.0 <0.9.0; | |
/** | |
* @title Storage | |
* @dev Store & retrieve value in a variable | |
*/ | |
contract Storage { | |
uint256 number; | |
/** | |
* @dev Store value in variable | |
* @param num value to store | |
*/ | |
function store(uint256 num) public { | |
number = num; | |
} | |
/** | |
* @dev Return value | |
* @return value of 'number' | |
*/ | |
function retrieve() public view returns (uint256){ | |
return number; | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment