mirror of
https://gitlab.com/pulsechaincom/erigon-pulse.git
synced 2024-12-25 21:17:16 +00:00
0be3044b7e
* rename * rename "make grpc" * rename "abi bindings templates" * rename "abi bindings templates"
325 lines
16 KiB
Go
325 lines
16 KiB
Go
// Code generated - DO NOT EDIT.
|
|
// This file is a generated binding and any manual changes will be lost.
|
|
|
|
package contracts
|
|
|
|
import (
|
|
"math/big"
|
|
"strings"
|
|
|
|
ethereum "github.com/ledgerwatch/erigon"
|
|
"github.com/ledgerwatch/erigon/accounts/abi"
|
|
"github.com/ledgerwatch/erigon/accounts/abi/bind"
|
|
"github.com/ledgerwatch/erigon/common"
|
|
"github.com/ledgerwatch/erigon/core/types"
|
|
"github.com/ledgerwatch/erigon/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
|
|
)
|
|
|
|
// TokenABI is the input ABI used to generate the binding from.
|
|
const TokenABI = "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_minter\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"minter\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]"
|
|
|
|
// TokenBin is the compiled bytecode used for deploying new contracts.
|
|
var TokenBin = "0x608060405234801561001057600080fd5b506040516102cd3803806102cd8339818101604052602081101561003357600080fd5b5051600280546001600160a01b0319166001600160a01b0390921691909117905561026a806100636000396000f3fe608060405234801561001057600080fd5b50600436106100575760003560e01c8063075461721461005c57806318160ddd1461008057806340c10f191461009a57806370a08231146100da578063a9059cbb14610100575b600080fd5b61006461012c565b604080516001600160a01b039092168252519081900360200190f35b61008861013b565b60408051918252519081900360200190f35b6100c6600480360360408110156100b057600080fd5b506001600160a01b038135169060200135610141565b604080519115158252519081900360200190f35b610088600480360360208110156100f057600080fd5b50356001600160a01b03166101b1565b6100c66004803603604081101561011657600080fd5b506001600160a01b0381351690602001356101c3565b6002546001600160a01b031681565b60005481565b6002546000906001600160a01b0316331461015b57600080fd5b6001600160a01b03831660009081526001602052604090205482810181111561018357600080fd5b6001600160a01b03841660009081526001602081905260408220928501909255805484019055905092915050565b60016020526000908152604090205481565b33600090815260016020526040808220546001600160a01b038516835290822054838210156101f157600080fd5b80848201101561020057600080fd5b336000908152600160208190526040808320948790039094556001600160a01b03969096168152919091209201909155509056fea2646970667358221220db4c7b3ba8d073604af68ade92006926639bb4003f2a18929524d580777155fb64736f6c63430007020033"
|
|
|
|
// DeployToken deploys a new Ethereum contract, binding an instance of Token to it.
|
|
func DeployToken(auth *bind.TransactOpts, backend bind.ContractBackend, _minter common.Address) (common.Address, types.Transaction, *Token, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(TokenABI))
|
|
if err != nil {
|
|
return common.Address{}, nil, nil, err
|
|
}
|
|
|
|
address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(TokenBin), backend, _minter)
|
|
if err != nil {
|
|
return common.Address{}, nil, nil, err
|
|
}
|
|
return address, tx, &Token{TokenCaller: TokenCaller{contract: contract}, TokenTransactor: TokenTransactor{contract: contract}, TokenFilterer: TokenFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// Token is an auto generated Go binding around an Ethereum contract.
|
|
type Token struct {
|
|
TokenCaller // Read-only binding to the contract
|
|
TokenTransactor // Write-only binding to the contract
|
|
TokenFilterer // Log filterer for contract events
|
|
}
|
|
|
|
// TokenCaller is an auto generated read-only Go binding around an Ethereum contract.
|
|
type TokenCaller struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// TokenTransactor is an auto generated write-only Go binding around an Ethereum contract.
|
|
type TokenTransactor struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// TokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
|
|
type TokenFilterer struct {
|
|
contract *bind.BoundContract // Generic contract wrapper for the low level calls
|
|
}
|
|
|
|
// TokenSession is an auto generated Go binding around an Ethereum contract,
|
|
// with pre-set call and transact options.
|
|
type TokenSession struct {
|
|
Contract *Token // 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
|
|
}
|
|
|
|
// TokenCallerSession is an auto generated read-only Go binding around an Ethereum contract,
|
|
// with pre-set call options.
|
|
type TokenCallerSession struct {
|
|
Contract *TokenCaller // Generic contract caller binding to set the session for
|
|
CallOpts bind.CallOpts // Call options to use throughout this session
|
|
}
|
|
|
|
// TokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
|
|
// with pre-set transact options.
|
|
type TokenTransactorSession struct {
|
|
Contract *TokenTransactor // Generic contract transactor binding to set the session for
|
|
TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
|
|
}
|
|
|
|
// TokenRaw is an auto generated low-level Go binding around an Ethereum contract.
|
|
type TokenRaw struct {
|
|
Contract *Token // Generic contract binding to access the raw methods on
|
|
}
|
|
|
|
// TokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
|
|
type TokenCallerRaw struct {
|
|
Contract *TokenCaller // Generic read-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// TokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
|
|
type TokenTransactorRaw struct {
|
|
Contract *TokenTransactor // Generic write-only contract binding to access the raw methods on
|
|
}
|
|
|
|
// NewToken creates a new instance of Token, bound to a specific deployed contract.
|
|
func NewToken(address common.Address, backend bind.ContractBackend) (*Token, error) {
|
|
contract, err := bindToken(address, backend, backend, backend)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Token{TokenCaller: TokenCaller{contract: contract}, TokenTransactor: TokenTransactor{contract: contract}, TokenFilterer: TokenFilterer{contract: contract}}, nil
|
|
}
|
|
|
|
// NewTokenCaller creates a new read-only instance of Token, bound to a specific deployed contract.
|
|
func NewTokenCaller(address common.Address, caller bind.ContractCaller) (*TokenCaller, error) {
|
|
contract, err := bindToken(address, caller, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TokenCaller{contract: contract}, nil
|
|
}
|
|
|
|
// NewTokenTransactor creates a new write-only instance of Token, bound to a specific deployed contract.
|
|
func NewTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*TokenTransactor, error) {
|
|
contract, err := bindToken(address, nil, transactor, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TokenTransactor{contract: contract}, nil
|
|
}
|
|
|
|
// NewTokenFilterer creates a new log filterer instance of Token, bound to a specific deployed contract.
|
|
func NewTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*TokenFilterer, error) {
|
|
contract, err := bindToken(address, nil, nil, filterer)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &TokenFilterer{contract: contract}, nil
|
|
}
|
|
|
|
// bindToken binds a generic wrapper to an already deployed contract.
|
|
func bindToken(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
|
|
parsed, err := abi.JSON(strings.NewReader(TokenABI))
|
|
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 (_Token *TokenRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _Token.Contract.TokenCaller.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 (_Token *TokenRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error) {
|
|
return _Token.Contract.TokenTransactor.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_Token *TokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (types.Transaction, error) {
|
|
return _Token.Contract.TokenTransactor.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 (_Token *TokenCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
|
|
return _Token.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 (_Token *TokenTransactorRaw) Transfer(opts *bind.TransactOpts) (types.Transaction, error) {
|
|
return _Token.Contract.contract.Transfer(opts)
|
|
}
|
|
|
|
// Transact invokes the (paid) contract method with params as input values.
|
|
func (_Token *TokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (types.Transaction, error) {
|
|
return _Token.Contract.contract.Transact(opts, method, params...)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address ) view returns(uint256)
|
|
func (_Token *TokenCaller) BalanceOf(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _Token.contract.Call(opts, &out, "balanceOf", arg0)
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address ) view returns(uint256)
|
|
func (_Token *TokenSession) BalanceOf(arg0 common.Address) (*big.Int, error) {
|
|
return _Token.Contract.BalanceOf(&_Token.CallOpts, arg0)
|
|
}
|
|
|
|
// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
|
|
//
|
|
// Solidity: function balanceOf(address ) view returns(uint256)
|
|
func (_Token *TokenCallerSession) BalanceOf(arg0 common.Address) (*big.Int, error) {
|
|
return _Token.Contract.BalanceOf(&_Token.CallOpts, arg0)
|
|
}
|
|
|
|
// Minter is a free data retrieval call binding the contract method 0x07546172.
|
|
//
|
|
// Solidity: function minter() view returns(address)
|
|
func (_Token *TokenCaller) Minter(opts *bind.CallOpts) (common.Address, error) {
|
|
var out []interface{}
|
|
err := _Token.contract.Call(opts, &out, "minter")
|
|
|
|
if err != nil {
|
|
return *new(common.Address), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// Minter is a free data retrieval call binding the contract method 0x07546172.
|
|
//
|
|
// Solidity: function minter() view returns(address)
|
|
func (_Token *TokenSession) Minter() (common.Address, error) {
|
|
return _Token.Contract.Minter(&_Token.CallOpts)
|
|
}
|
|
|
|
// Minter is a free data retrieval call binding the contract method 0x07546172.
|
|
//
|
|
// Solidity: function minter() view returns(address)
|
|
func (_Token *TokenCallerSession) Minter() (common.Address, error) {
|
|
return _Token.Contract.Minter(&_Token.CallOpts)
|
|
}
|
|
|
|
// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
|
|
//
|
|
// Solidity: function totalSupply() view returns(uint256)
|
|
func (_Token *TokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
|
|
var out []interface{}
|
|
err := _Token.contract.Call(opts, &out, "totalSupply")
|
|
|
|
if err != nil {
|
|
return *new(*big.Int), err
|
|
}
|
|
|
|
out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
|
|
|
|
return out0, err
|
|
|
|
}
|
|
|
|
// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
|
|
//
|
|
// Solidity: function totalSupply() view returns(uint256)
|
|
func (_Token *TokenSession) TotalSupply() (*big.Int, error) {
|
|
return _Token.Contract.TotalSupply(&_Token.CallOpts)
|
|
}
|
|
|
|
// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
|
|
//
|
|
// Solidity: function totalSupply() view returns(uint256)
|
|
func (_Token *TokenCallerSession) TotalSupply() (*big.Int, error) {
|
|
return _Token.Contract.TotalSupply(&_Token.CallOpts)
|
|
}
|
|
|
|
// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
|
|
//
|
|
// Solidity: function mint(address _to, uint256 _value) returns(bool)
|
|
func (_Token *TokenTransactor) Mint(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (types.Transaction, error) {
|
|
return _Token.contract.Transact(opts, "mint", _to, _value)
|
|
}
|
|
|
|
// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
|
|
//
|
|
// Solidity: function mint(address _to, uint256 _value) returns(bool)
|
|
func (_Token *TokenSession) Mint(_to common.Address, _value *big.Int) (types.Transaction, error) {
|
|
return _Token.Contract.Mint(&_Token.TransactOpts, _to, _value)
|
|
}
|
|
|
|
// Mint is a paid mutator transaction binding the contract method 0x40c10f19.
|
|
//
|
|
// Solidity: function mint(address _to, uint256 _value) returns(bool)
|
|
func (_Token *TokenTransactorSession) Mint(_to common.Address, _value *big.Int) (types.Transaction, error) {
|
|
return _Token.Contract.Mint(&_Token.TransactOpts, _to, _value)
|
|
}
|
|
|
|
// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
|
|
//
|
|
// Solidity: function transfer(address _to, uint256 _value) returns(bool)
|
|
func (_Token *TokenTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (types.Transaction, error) {
|
|
return _Token.contract.Transact(opts, "transfer", _to, _value)
|
|
}
|
|
|
|
// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
|
|
//
|
|
// Solidity: function transfer(address _to, uint256 _value) returns(bool)
|
|
func (_Token *TokenSession) Transfer(_to common.Address, _value *big.Int) (types.Transaction, error) {
|
|
return _Token.Contract.Transfer(&_Token.TransactOpts, _to, _value)
|
|
}
|
|
|
|
// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb.
|
|
//
|
|
// Solidity: function transfer(address _to, uint256 _value) returns(bool)
|
|
func (_Token *TokenTransactorSession) Transfer(_to common.Address, _value *big.Int) (types.Transaction, error) {
|
|
return _Token.Contract.Transfer(&_Token.TransactOpts, _to, _value)
|
|
}
|