entrypoint

package
v0.0.0-...-1dac6a7 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Feb 24, 2025 License: MIT Imports: 12 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	Method = "handleOps"
)

Variables

View Source 
var AlchemyBindingABI = AlchemyBindingMetaData.ABI

AlchemyBindingABI is the input ABI used to generate the binding from. Deprecated: Use AlchemyBindingMetaData.ABI instead.

View Source 
var AlchemyBindingMetaData = &bind.MetaData{
	ABI: "[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"initCode\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"accountGasLimits\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"preVerificationGas\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"gasFees\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"paymasterAndData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structAlchemyUserOperation[]\",\"name\":\"ops\",\"type\":\"tuple[]\"},{\"internalType\":\"addresspayable\",\"name\":\"beneficiary\",\"type\":\"address\"}],\"name\":\"handleOps\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
}

AlchemyBindingMetaData contains all meta data concerning the AlchemyBinding contract.

View Source 
var BiconomyBindingABI = BiconomyBindingMetaData.ABI

BiconomyBindingABI is the input ABI used to generate the binding from. Deprecated: Use BiconomyBindingMetaData.ABI instead.

View Source 
var BiconomyBindingMetaData = &bind.MetaData{
	ABI: "[{\"inputs\":[{\"components\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"nonce\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"initCode\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"callGasLimit\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"verificationGasLimit\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"preVerificationGas\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxFeePerGas\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"maxPriorityFeePerGas\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"paymasterAndData\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"}],\"internalType\":\"structBiconomyUserOperation[]\",\"name\":\"ops\",\"type\":\"tuple[]\"},{\"internalType\":\"addresspayable\",\"name\":\"beneficiary\",\"type\":\"address\"}],\"name\":\"handleOps\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
}

BiconomyBindingMetaData contains all meta data concerning the BiconomyBinding contract.

Functions

This section is empty.

Types

type AlchemyBinding 

type AlchemyBinding struct {
	AlchemyBindingCaller     // Read-only binding to the contract
	AlchemyBindingTransactor // Write-only binding to the contract
	AlchemyBindingFilterer   // Log filterer for contract events
}

AlchemyBinding is an auto generated Go binding around an Ethereum contract.

func NewAlchemyBinding 

func NewAlchemyBinding(address common.Address, backend bind.ContractBackend) (*AlchemyBinding, error)

NewAlchemyBinding creates a new instance of AlchemyBinding, bound to a specific deployed contract.

type AlchemyBindingCaller 

type AlchemyBindingCaller struct {
	// contains filtered or unexported fields
}

AlchemyBindingCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewAlchemyBindingCaller 

func NewAlchemyBindingCaller(address common.Address, caller bind.ContractCaller) (*AlchemyBindingCaller, error)

NewAlchemyBindingCaller creates a new read-only instance of AlchemyBinding, bound to a specific deployed contract.

type AlchemyBindingCallerRaw 

type AlchemyBindingCallerRaw struct {
	Contract *AlchemyBindingCaller // Generic read-only contract binding to access the raw methods on
}

AlchemyBindingCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*AlchemyBindingCallerRaw) Call 

func (_AlchemyBinding *AlchemyBindingCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type AlchemyBindingCallerSession 

type AlchemyBindingCallerSession struct {
	Contract *AlchemyBindingCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts         // Call options to use throughout this session
}

AlchemyBindingCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type AlchemyBindingFilterer 

type AlchemyBindingFilterer struct {
	// contains filtered or unexported fields
}

AlchemyBindingFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewAlchemyBindingFilterer 

func NewAlchemyBindingFilterer(address common.Address, filterer bind.ContractFilterer) (*AlchemyBindingFilterer, error)

NewAlchemyBindingFilterer creates a new log filterer instance of AlchemyBinding, bound to a specific deployed contract.

type AlchemyBindingRaw 

type AlchemyBindingRaw struct {
	Contract *AlchemyBinding // Generic contract binding to access the raw methods on
}

AlchemyBindingRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*AlchemyBindingRaw) Call 

func (_AlchemyBinding *AlchemyBindingRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*AlchemyBindingRaw) Transact 

func (_AlchemyBinding *AlchemyBindingRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*AlchemyBindingRaw) Transfer 

func (_AlchemyBinding *AlchemyBindingRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type AlchemyBindingSession 

type AlchemyBindingSession struct {
	Contract     *AlchemyBinding   // 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
}

AlchemyBindingSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*AlchemyBindingSession) HandleOps 

func (_AlchemyBinding *AlchemyBindingSession) HandleOps(ops []AlchemyUserOperation, beneficiary common.Address) (*types.Transaction, error)

HandleOps is a paid mutator transaction binding the contract method 0x765e827f.

Solidity: function handleOps((address,uint256,bytes,bytes,bytes32,uint256,bytes32,bytes,bytes)[] ops, address beneficiary) returns()

type AlchemyBindingTransactor 

type AlchemyBindingTransactor struct {
	// contains filtered or unexported fields
}

AlchemyBindingTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewAlchemyBindingTransactor 

func NewAlchemyBindingTransactor(address common.Address, transactor bind.ContractTransactor) (*AlchemyBindingTransactor, error)

NewAlchemyBindingTransactor creates a new write-only instance of AlchemyBinding, bound to a specific deployed contract.

func (*AlchemyBindingTransactor) HandleOps 

func (_AlchemyBinding *AlchemyBindingTransactor) HandleOps(opts *bind.TransactOpts, ops []AlchemyUserOperation, beneficiary common.Address) (*types.Transaction, error)

HandleOps is a paid mutator transaction binding the contract method 0x765e827f.

Solidity: function handleOps((address,uint256,bytes,bytes,bytes32,uint256,bytes32,bytes,bytes)[] ops, address beneficiary) returns()

type AlchemyBindingTransactorRaw 

type AlchemyBindingTransactorRaw struct {
	Contract *AlchemyBindingTransactor // Generic write-only contract binding to access the raw methods on
}

AlchemyBindingTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*AlchemyBindingTransactorRaw) Transact 

func (_AlchemyBinding *AlchemyBindingTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*AlchemyBindingTransactorRaw) Transfer 

func (_AlchemyBinding *AlchemyBindingTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type AlchemyBindingTransactorSession 

type AlchemyBindingTransactorSession struct {
	Contract     *AlchemyBindingTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
}

AlchemyBindingTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*AlchemyBindingTransactorSession) HandleOps 

func (_AlchemyBinding *AlchemyBindingTransactorSession) HandleOps(ops []AlchemyUserOperation, beneficiary common.Address) (*types.Transaction, error)

HandleOps is a paid mutator transaction binding the contract method 0x765e827f.

Solidity: function handleOps((address,uint256,bytes,bytes,bytes32,uint256,bytes32,bytes,bytes)[] ops, address beneficiary) returns()

type AlchemyUserOperation 

type AlchemyUserOperation struct {
	Sender             common.Address
	Nonce              *big.Int
	InitCode           []byte
	CallData           []byte
	AccountGasLimits   [32]byte
	PreVerificationGas *big.Int
	GasFees            [32]byte
	PaymasterAndData   []byte
	Signature          []byte
}

AlchemyUserOperation is an auto generated low-level Go binding around an user-defined struct.

type BiconomyBinding 

type BiconomyBinding struct {
	BiconomyBindingCaller     // Read-only binding to the contract
	BiconomyBindingTransactor // Write-only binding to the contract
	BiconomyBindingFilterer   // Log filterer for contract events
}

BiconomyBinding is an auto generated Go binding around an Ethereum contract.

func NewBiconomyBinding 

func NewBiconomyBinding(address common.Address, backend bind.ContractBackend) (*BiconomyBinding, error)

NewBiconomyBinding creates a new instance of BiconomyBinding, bound to a specific deployed contract.

type BiconomyBindingCaller 

type BiconomyBindingCaller struct {
	// contains filtered or unexported fields
}

BiconomyBindingCaller is an auto generated read-only Go binding around an Ethereum contract.

func NewBiconomyBindingCaller 

func NewBiconomyBindingCaller(address common.Address, caller bind.ContractCaller) (*BiconomyBindingCaller, error)

NewBiconomyBindingCaller creates a new read-only instance of BiconomyBinding, bound to a specific deployed contract.

type BiconomyBindingCallerRaw 

type BiconomyBindingCallerRaw struct {
	Contract *BiconomyBindingCaller // Generic read-only contract binding to access the raw methods on
}

BiconomyBindingCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.

func (*BiconomyBindingCallerRaw) Call 

func (_BiconomyBinding *BiconomyBindingCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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.

type BiconomyBindingCallerSession 

type BiconomyBindingCallerSession struct {
	Contract *BiconomyBindingCaller // Generic contract caller binding to set the session for
	CallOpts bind.CallOpts          // Call options to use throughout this session
}

BiconomyBindingCallerSession is an auto generated read-only Go binding around an Ethereum contract, with pre-set call options.

type BiconomyBindingFilterer 

type BiconomyBindingFilterer struct {
	// contains filtered or unexported fields
}

BiconomyBindingFilterer is an auto generated log filtering Go binding around an Ethereum contract events.

func NewBiconomyBindingFilterer 

func NewBiconomyBindingFilterer(address common.Address, filterer bind.ContractFilterer) (*BiconomyBindingFilterer, error)

NewBiconomyBindingFilterer creates a new log filterer instance of BiconomyBinding, bound to a specific deployed contract.

type BiconomyBindingRaw 

type BiconomyBindingRaw struct {
	Contract *BiconomyBinding // Generic contract binding to access the raw methods on
}

BiconomyBindingRaw is an auto generated low-level Go binding around an Ethereum contract.

func (*BiconomyBindingRaw) Call 

func (_BiconomyBinding *BiconomyBindingRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error

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 (*BiconomyBindingRaw) Transact 

func (_BiconomyBinding *BiconomyBindingRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*BiconomyBindingRaw) Transfer 

func (_BiconomyBinding *BiconomyBindingRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type BiconomyBindingSession 

type BiconomyBindingSession struct {
	Contract     *BiconomyBinding  // 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
}

BiconomyBindingSession is an auto generated Go binding around an Ethereum contract, with pre-set call and transact options.

func (*BiconomyBindingSession) HandleOps 

func (_BiconomyBinding *BiconomyBindingSession) HandleOps(ops []BiconomyUserOperation, beneficiary common.Address) (*types.Transaction, error)

HandleOps is a paid mutator transaction binding the contract method 0x1fad948c.

Solidity: function handleOps((address,uint256,bytes,bytes,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[] ops, address beneficiary) returns()

type BiconomyBindingTransactor 

type BiconomyBindingTransactor struct {
	// contains filtered or unexported fields
}

BiconomyBindingTransactor is an auto generated write-only Go binding around an Ethereum contract.

func NewBiconomyBindingTransactor 

func NewBiconomyBindingTransactor(address common.Address, transactor bind.ContractTransactor) (*BiconomyBindingTransactor, error)

NewBiconomyBindingTransactor creates a new write-only instance of BiconomyBinding, bound to a specific deployed contract.

func (*BiconomyBindingTransactor) HandleOps 

func (_BiconomyBinding *BiconomyBindingTransactor) HandleOps(opts *bind.TransactOpts, ops []BiconomyUserOperation, beneficiary common.Address) (*types.Transaction, error)

HandleOps is a paid mutator transaction binding the contract method 0x1fad948c.

Solidity: function handleOps((address,uint256,bytes,bytes,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[] ops, address beneficiary) returns()

type BiconomyBindingTransactorRaw 

type BiconomyBindingTransactorRaw struct {
	Contract *BiconomyBindingTransactor // Generic write-only contract binding to access the raw methods on
}

BiconomyBindingTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.

func (*BiconomyBindingTransactorRaw) Transact 

func (_BiconomyBinding *BiconomyBindingTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

Transact invokes the (paid) contract method with params as input values.

func (*BiconomyBindingTransactorRaw) Transfer 

func (_BiconomyBinding *BiconomyBindingTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

Transfer initiates a plain transaction to move funds to the contract, calling its default method if one is available.

type BiconomyBindingTransactorSession 

type BiconomyBindingTransactorSession struct {
	Contract     *BiconomyBindingTransactor // Generic contract transactor binding to set the session for
	TransactOpts bind.TransactOpts          // Transaction auth options to use throughout this session
}

BiconomyBindingTransactorSession is an auto generated write-only Go binding around an Ethereum contract, with pre-set transact options.

func (*BiconomyBindingTransactorSession) HandleOps 

func (_BiconomyBinding *BiconomyBindingTransactorSession) HandleOps(ops []BiconomyUserOperation, beneficiary common.Address) (*types.Transaction, error)

HandleOps is a paid mutator transaction binding the contract method 0x1fad948c.

Solidity: function handleOps((address,uint256,bytes,bytes,uint256,uint256,uint256,uint256,uint256,bytes,bytes)[] ops, address beneficiary) returns()

type BiconomyUserOperation 

type BiconomyUserOperation struct {
	Sender               common.Address
	Nonce                *big.Int
	InitCode             []byte
	CallData             []byte
	CallGasLimit         *big.Int
	VerificationGasLimit *big.Int
	PreVerificationGas   *big.Int
	MaxFeePerGas         *big.Int
	MaxPriorityFeePerGas *big.Int
	PaymasterAndData     []byte
	Signature            []byte
}

BiconomyUserOperation is an auto generated low-level Go binding around an user-defined struct.

type UserOperation 

type UserOperation struct {
	Sender   common.Address
	CallData []byte
}

func Decode 

func Decode(byt []byte) ([]UserOperation, common.Address, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.