Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

testmetaswap

package

Go to main page

Versions in this module

v1

v1.22.0

Nov 20, 2024

v1.21.1

Nov 18, 2024

v1.21.0

Nov 8, 2024

v1.20.2

Nov 7, 2024

v1.20.1

Nov 5, 2024

v1.20.0

Nov 5, 2024

v1.19.2

Nov 2, 2024

v1.19.1

Nov 1, 2024

v1.19.0

Oct 29, 2024

v1.18.0

Oct 25, 2024

v1.17.0

Oct 22, 2024

v1.16.0

Oct 21, 2024

v1.15.2

Oct 10, 2024

v1.15.1

Oct 10, 2024

v1.15.0

Oct 10, 2024

v1.14.0

Sep 26, 2024

v1.13.0

Sep 19, 2024

v1.12.1

Sep 16, 2024

v1.12.0

Sep 11, 2024

v1.11.0

Sep 10, 2024

v1.10.0

Sep 10, 2024

v1.9.0

Sep 9, 2024

v1.8.1

Sep 5, 2024

v1.8.0

Sep 3, 2024

v1.7.1

Aug 27, 2024

v1.7.0

Aug 27, 2024

v1.6.1

Aug 26, 2024

v1.6.0

Aug 23, 2024

v1.5.0

Aug 19, 2024

v1.4.0

Aug 16, 2024

v1.3.0

Aug 15, 2024

v1.2.1

Aug 13, 2024

v1.2.0

Aug 13, 2024

v1.1.0

Aug 9, 2024

v1.0.2

Aug 6, 2024

v1.0.1

Aug 6, 2024

v1.0.0

Aug 6, 2024

v0

v0.26.0

Jul 29, 2024

v0.25.0

Jul 28, 2024

v0.24.0

Jul 28, 2024

v0.23.1

Jul 28, 2024

v0.23.0

Jul 25, 2024

v0.22.0

Jul 19, 2024

v0.21.6

Jul 19, 2024

v0.21.5

Jul 19, 2024

v0.21.4

Jul 18, 2024

v0.21.3

Jul 18, 2024

v0.21.2

Jul 18, 2024

v0.21.1

Jul 18, 2024

v0.21.0

Jul 17, 2024

v0.20.0

Jul 11, 2024

v0.19.0

Jul 9, 2024

v0.18.13

Jul 8, 2024

v0.18.12

Jul 6, 2024

v0.18.11

Jul 6, 2024

v0.18.10

Jul 5, 2024

v0.18.9

Jul 2, 2024

v0.18.8

Jul 2, 2024

v0.18.7

Jul 2, 2024

v0.18.6

Jun 30, 2024

v0.18.5

Jun 29, 2024

v0.18.4

Jun 29, 2024

v0.18.3

Jun 29, 2024

v0.18.2

Jun 28, 2024

v0.18.1

Jun 28, 2024

v0.18.0

Jun 28, 2024

v0.17.0

Jun 27, 2024

v0.16.2

Jun 27, 2024

v0.16.1

Jun 26, 2024

v0.16.0

Jun 26, 2024

v0.15.12

Jun 25, 2024

v0.15.11

Jun 25, 2024

v0.15.10

Jun 25, 2024

v0.15.9

Jun 24, 2024

v0.15.8

Jun 22, 2024

v0.15.7

Jun 22, 2024

v0.15.6

Jun 22, 2024

v0.15.5

Jun 21, 2024

v0.15.4

Jun 21, 2024

v0.15.3

Jun 21, 2024

v0.15.2

Jun 21, 2024

v0.15.1

Jun 20, 2024

v0.15.0

Jun 20, 2024

v0.14.9

Jun 14, 2024

v0.14.8

Jun 14, 2024

v0.14.7

Jun 13, 2024

v0.14.6

Jun 10, 2024

v0.14.5

Jun 9, 2024

v0.14.4

Jun 9, 2024

v0.14.3

Jun 8, 2024

v0.14.2

Jun 8, 2024

v0.14.1

Jun 6, 2024

v0.14.0

Jun 6, 2024

v0.13.0

Jun 4, 2024

v0.12.8

Jun 1, 2024

v0.12.7

Jun 1, 2024

v0.12.6

May 31, 2024

v0.12.5

May 31, 2024

v0.12.4

May 31, 2024

v0.12.3

May 31, 2024

v0.12.2

May 31, 2024

v0.12.1

May 27, 2024

v0.12.0

May 21, 2024

v0.11.2

May 14, 2024

v0.11.1

May 14, 2024

v0.11.0

May 14, 2024

v0.10.0

May 9, 2024

v0.9.0

May 9, 2024

v0.8.0

May 5, 2024

v0.7.0

Apr 30, 2024

v0.6.1

Apr 23, 2024

v0.6.0

Apr 21, 2024

v0.5.0

Apr 18, 2024

v0.4.6

Apr 15, 2024

v0.4.5

Apr 12, 2024

v0.4.4

Apr 9, 2024

v0.4.3

Apr 9, 2024

v0.4.2

Apr 7, 2024

v0.4.1

Apr 6, 2024

v0.4.0

Apr 6, 2024

v0.3.3

Apr 3, 2024

v0.3.2

Apr 2, 2024

v0.3.1

Apr 2, 2024

v0.3.0

Apr 2, 2024

v0.2.1

Mar 27, 2024

v0.2.0

Mar 27, 2024

v0.1.36

Mar 4, 2024

v0.1.35

Mar 4, 2024

v0.1.34

Mar 4, 2024

v0.1.33

Mar 3, 2024

v0.1.32

Mar 1, 2024

v0.1.31

Mar 1, 2024

v0.1.30

Mar 1, 2024

v0.1.29

Feb 27, 2024

v0.1.28

Feb 26, 2024

v0.1.27

Feb 26, 2024

v0.1.26

Feb 25, 2024

v0.1.25

Feb 13, 2024

v0.1.24

Feb 13, 2024

v0.1.23

Feb 9, 2024

v0.1.22

Feb 6, 2024

v0.1.21

Jan 30, 2024

v0.1.20

Jan 30, 2024

v0.1.19

Jan 30, 2024

v0.1.18

Jan 29, 2024

v0.1.17

Jan 26, 2024

v0.1.16

Jan 25, 2024

v0.1.15

Jan 24, 2024

v0.1.14

Jan 14, 2024

v0.1.13

Jan 14, 2024

v0.1.12

Jan 14, 2024

v0.1.11

Jan 11, 2024

v0.1.10

Jan 8, 2024

v0.1.9

Jan 8, 2024

v0.1.8

Jan 7, 2024

v0.1.7

Jan 5, 2024

v0.1.6

Jan 5, 2024

v0.1.5

Dec 24, 2023

v0.1.4

Dec 23, 2023

v0.1.3

Dec 21, 2023

v0.1.2

Dec 21, 2023

v0.1.1

Dec 20, 2023

v0.1.0

Dec 13, 2023

v0.0.190

Dec 12, 2023

v0.0.189

Dec 12, 2023

v0.0.188

Dec 10, 2023

v0.0.187

Nov 10, 2023

v0.0.186

Nov 10, 2023

v0.0.185

Nov 9, 2023

v0.0.184

Nov 2, 2023

v0.0.183

Nov 2, 2023

v0.0.182

Oct 27, 2023

v0.0.181

Oct 26, 2023

v0.0.180

Oct 24, 2023

v0.0.179

Oct 20, 2023

v0.0.178

Oct 10, 2023

v0.0.177

Sep 19, 2023

v0.0.176

Sep 15, 2023

v0.0.175

Sep 14, 2023

v0.0.174

Sep 11, 2023

v0.0.173

Sep 7, 2023

v0.0.172

Sep 6, 2023

v0.0.171

Sep 3, 2023

v0.0.170

Sep 3, 2023

v0.0.169

Aug 31, 2023

v0.0.168

Aug 30, 2023

v0.0.167

Aug 24, 2023

v0.0.166

Aug 23, 2023

v0.0.165

Aug 23, 2023

v0.0.164

Aug 23, 2023

v0.0.163

Aug 23, 2023

v0.0.162

Aug 22, 2023

v0.0.161

Aug 18, 2023

v0.0.160

Aug 18, 2023

v0.0.159

Aug 15, 2023

v0.0.158

Aug 15, 2023

v0.0.157

Aug 9, 2023

v0.0.156

Aug 8, 2023

v0.0.155

Aug 8, 2023

v0.0.154

Aug 7, 2023

v0.0.153

Aug 7, 2023

v0.0.152

Jul 31, 2023

v0.0.151

Jul 30, 2023

v0.0.150

Jul 29, 2023

v0.0.149

Jul 29, 2023

v0.0.148

Jul 29, 2023

v0.0.147

Jul 29, 2023

v0.0.146

Jul 26, 2023

v0.0.145

Jul 26, 2023

v0.0.144

Jul 26, 2023

v0.0.143

Jul 25, 2023

v0.0.142

Jul 25, 2023

v0.0.141

Jul 25, 2023

v0.0.140

Jul 20, 2023

v0.0.139

Jul 11, 2023

v0.0.138

Jul 11, 2023

v0.0.137

Jul 7, 2023

v0.0.136

Jul 5, 2023

v0.0.135

Jul 3, 2023

v0.0.134

Jul 2, 2023

v0.0.133

Jul 2, 2023

v0.0.132

Jul 2, 2023

v0.0.131

Jun 28, 2023

v0.0.130

Jun 28, 2023

v0.0.129

Jun 28, 2023

v0.0.128

Jun 28, 2023

v0.0.127

Jun 27, 2023

v0.0.126

Jun 25, 2023

v0.0.125

Jun 18, 2023

v0.0.124

Jun 15, 2023

v0.0.123

Jun 14, 2023

v0.0.122

Jun 14, 2023

v0.0.121

Jun 14, 2023

v0.0.120

Jun 14, 2023

v0.0.119

Jun 13, 2023

v0.0.118

Jun 13, 2023

v0.0.117

Jun 13, 2023

v0.0.116

Jun 13, 2023

v0.0.115

Jun 5, 2023

v0.0.114

Jun 2, 2023

v0.0.113

Jun 2, 2023

v0.0.112

May 28, 2023

v0.0.111

May 28, 2023

v0.0.110

May 27, 2023

v0.0.109

May 19, 2023

v0.0.108

May 19, 2023

v0.0.107

May 19, 2023

v0.0.106

May 18, 2023

v0.0.105

May 9, 2023

v0.0.104

May 4, 2023

v0.0.103

May 3, 2023

v0.0.102

May 3, 2023

v0.0.101

May 3, 2023

v0.0.100

May 3, 2023

v0.0.99

May 2, 2023

v0.0.98

May 1, 2023

v0.0.97

May 1, 2023

v0.0.96

May 1, 2023

v0.0.95

Apr 26, 2023

v0.0.94

Apr 26, 2023

v0.0.93

Apr 26, 2023

v0.0.92

Apr 26, 2023

v0.0.91

Apr 26, 2023

v0.0.90

Apr 26, 2023

v0.0.89

Apr 14, 2023

v0.0.88

Apr 18, 2023

v0.0.87

Apr 10, 2023

v0.0.86

Apr 5, 2023

v0.0.85

Apr 5, 2023

v0.0.84

Apr 3, 2023

v0.0.83

Apr 2, 2023

v0.0.82

Mar 30, 2023

v0.0.81

Mar 28, 2023

Changes in this version

+ var AddressABI = AddressMetaData.ABI

+ var AddressBin = AddressMetaData.Bin

+ var AddressMetaData = &bind.MetaData

+ var AddressUpgradeableABI = AddressUpgradeableMetaData.ABI

+ var AddressUpgradeableBin = AddressUpgradeableMetaData.Bin

+ var AddressUpgradeableMetaData = &bind.MetaData

+ var AmplificationUtilsABI = AmplificationUtilsMetaData.ABI

+ var AmplificationUtilsBin = AmplificationUtilsMetaData.Bin

+ var AmplificationUtilsFuncSigs = AmplificationUtilsMetaData.Sigs

+ var AmplificationUtilsMetaData = &bind.MetaData

+ var ClonesABI = ClonesMetaData.ABI

+ var ClonesBin = ClonesMetaData.Bin

+ var ClonesMetaData = &bind.MetaData

+ var ContextABI = ContextMetaData.ABI

+ var ContextMetaData = &bind.MetaData

+ var ContextUpgradeableABI = ContextUpgradeableMetaData.ABI

+ var ContextUpgradeableMetaData = &bind.MetaData

+ var Contracts map[string]*compiler.Contract

+ var ERC20ABI = ERC20MetaData.ABI

+ var ERC20Bin = ERC20MetaData.Bin

+ var ERC20BurnableUpgradeableABI = ERC20BurnableUpgradeableMetaData.ABI

+ var ERC20BurnableUpgradeableFuncSigs = ERC20BurnableUpgradeableMetaData.Sigs

+ var ERC20BurnableUpgradeableMetaData = &bind.MetaData

+ var ERC20FuncSigs = ERC20MetaData.Sigs

+ var ERC20MetaData = &bind.MetaData

+ var ERC20UpgradeableABI = ERC20UpgradeableMetaData.ABI

+ var ERC20UpgradeableBin = ERC20UpgradeableMetaData.Bin

+ var ERC20UpgradeableFuncSigs = ERC20UpgradeableMetaData.Sigs

+ var ERC20UpgradeableMetaData = &bind.MetaData

+ var IERC20ABI = IERC20MetaData.ABI

+ var IERC20FuncSigs = IERC20MetaData.Sigs

+ var IERC20MetaData = &bind.MetaData

+ var IERC20UpgradeableABI = IERC20UpgradeableMetaData.ABI

+ var IERC20UpgradeableFuncSigs = IERC20UpgradeableMetaData.Sigs

+ var IERC20UpgradeableMetaData = &bind.MetaData

+ var ISwapABI = ISwapMetaData.ABI

+ var ISwapFuncSigs = ISwapMetaData.Sigs

+ var ISwapMetaData = &bind.MetaData

+ var InitializableABI = InitializableMetaData.ABI

+ var InitializableMetaData = &bind.MetaData

+ var LPTokenABI = LPTokenMetaData.ABI

+ var LPTokenBin = LPTokenMetaData.Bin

+ var LPTokenFuncSigs = LPTokenMetaData.Sigs

+ var LPTokenMetaData = &bind.MetaData

+ var MathUtilsABI = MathUtilsMetaData.ABI

+ var MathUtilsBin = MathUtilsMetaData.Bin

+ var MathUtilsMetaData = &bind.MetaData

+ var MetaSwapABI = MetaSwapMetaData.ABI

+ var MetaSwapBin = MetaSwapMetaData.Bin

+ var MetaSwapFuncSigs = MetaSwapMetaData.Sigs

+ var MetaSwapMetaData = &bind.MetaData

+ var MetaSwapUtilsABI = MetaSwapUtilsMetaData.ABI

+ var MetaSwapUtilsBin = MetaSwapUtilsMetaData.Bin

+ var MetaSwapUtilsFuncSigs = MetaSwapUtilsMetaData.Sigs

+ var MetaSwapUtilsMetaData = &bind.MetaData

+ var OwnableUpgradeableABI = OwnableUpgradeableMetaData.ABI

+ var OwnableUpgradeableFuncSigs = OwnableUpgradeableMetaData.Sigs

+ var OwnableUpgradeableMetaData = &bind.MetaData

+ var OwnerPausableUpgradeableABI = OwnerPausableUpgradeableMetaData.ABI

+ var OwnerPausableUpgradeableFuncSigs = OwnerPausableUpgradeableMetaData.Sigs

+ var OwnerPausableUpgradeableMetaData = &bind.MetaData

+ var PausableUpgradeableABI = PausableUpgradeableMetaData.ABI

+ var PausableUpgradeableFuncSigs = PausableUpgradeableMetaData.Sigs

+ var PausableUpgradeableMetaData = &bind.MetaData

+ var ReentrancyGuardUpgradeableABI = ReentrancyGuardUpgradeableMetaData.ABI

+ var ReentrancyGuardUpgradeableMetaData = &bind.MetaData

+ var SafeERC20ABI = SafeERC20MetaData.ABI

+ var SafeERC20Bin = SafeERC20MetaData.Bin

+ var SafeERC20MetaData = &bind.MetaData

+ var SafeMathABI = SafeMathMetaData.ABI

+ var SafeMathBin = SafeMathMetaData.Bin

+ var SafeMathMetaData = &bind.MetaData

+ var SafeMathUpgradeableABI = SafeMathUpgradeableMetaData.ABI

+ var SafeMathUpgradeableBin = SafeMathUpgradeableMetaData.Bin

+ var SafeMathUpgradeableMetaData = &bind.MetaData

+ var SwapABI = SwapMetaData.ABI

+ var SwapBin = SwapMetaData.Bin

+ var SwapFuncSigs = SwapMetaData.Sigs

+ var SwapMetaData = &bind.MetaData

+ var SwapUtilsABI = SwapUtilsMetaData.ABI

+ var SwapUtilsBin = SwapUtilsMetaData.Bin

+ var SwapUtilsFuncSigs = SwapUtilsMetaData.Sigs

+ var SwapUtilsMetaData = &bind.MetaData

+ var TestMetaSwapABI = TestMetaSwapMetaData.ABI

+ var TestMetaSwapBin = TestMetaSwapMetaData.Bin

+ var TestMetaSwapFuncSigs = TestMetaSwapMetaData.Sigs

+ var TestMetaSwapMetaData = &bind.MetaData

+ var TokenSwapUnderlyingTopic common.Hash

+ func EventTypeFromTopic(ogTopic common.Hash) *swap.EventType

+ func Topic(eventType swap.EventType) common.Hash

+ func TopicMap() map[swap.EventType]common.Hash

+ type Address struct

+ func DeployAddress(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Address, error)

+ func NewAddress(address common.Address, backend bind.ContractBackend) (*Address, error)

+ type AddressCaller struct

+ func NewAddressCaller(address common.Address, caller bind.ContractCaller) (*AddressCaller, error)

+ type AddressCallerRaw struct

+ Contract *AddressCaller

+ func (_Address *AddressCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type AddressCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *AddressCaller

+ type AddressFilterer struct

+ func NewAddressFilterer(address common.Address, filterer bind.ContractFilterer) (*AddressFilterer, error)

+ type AddressRaw struct

+ Contract *Address

+ func (_Address *AddressRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_Address *AddressRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Address *AddressRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AddressSession struct

+ CallOpts bind.CallOpts

+ Contract *Address

+ TransactOpts bind.TransactOpts

+ type AddressTransactor struct

+ func NewAddressTransactor(address common.Address, transactor bind.ContractTransactor) (*AddressTransactor, error)

+ type AddressTransactorRaw struct

+ Contract *AddressTransactor

+ func (_Address *AddressTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Address *AddressTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AddressTransactorSession struct

+ Contract *AddressTransactor

+ TransactOpts bind.TransactOpts

+ type AddressUpgradeable struct

+ func DeployAddressUpgradeable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *AddressUpgradeable, error)

+ func NewAddressUpgradeable(address common.Address, backend bind.ContractBackend) (*AddressUpgradeable, error)

+ type AddressUpgradeableCaller struct

+ func NewAddressUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*AddressUpgradeableCaller, error)

+ type AddressUpgradeableCallerRaw struct

+ Contract *AddressUpgradeableCaller

+ func (_AddressUpgradeable *AddressUpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type AddressUpgradeableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *AddressUpgradeableCaller

+ type AddressUpgradeableFilterer struct

+ func NewAddressUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*AddressUpgradeableFilterer, error)

+ type AddressUpgradeableRaw struct

+ Contract *AddressUpgradeable

+ func (_AddressUpgradeable *AddressUpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_AddressUpgradeable *AddressUpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_AddressUpgradeable *AddressUpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AddressUpgradeableSession struct

+ CallOpts bind.CallOpts

+ Contract *AddressUpgradeable

+ TransactOpts bind.TransactOpts

+ type AddressUpgradeableTransactor struct

+ func NewAddressUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*AddressUpgradeableTransactor, error)

+ type AddressUpgradeableTransactorRaw struct

+ Contract *AddressUpgradeableTransactor

+ func (_AddressUpgradeable *AddressUpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_AddressUpgradeable *AddressUpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AddressUpgradeableTransactorSession struct

+ Contract *AddressUpgradeableTransactor

+ TransactOpts bind.TransactOpts

+ type AmplificationUtils struct

+ func DeployAmplificationUtils(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *AmplificationUtils, error)

+ func NewAmplificationUtils(address common.Address, backend bind.ContractBackend) (*AmplificationUtils, error)

+ type AmplificationUtilsCaller struct

+ func NewAmplificationUtilsCaller(address common.Address, caller bind.ContractCaller) (*AmplificationUtilsCaller, error)

+ func (_AmplificationUtils *AmplificationUtilsCaller) APRECISION(opts *bind.CallOpts) (*big.Int, error)

+ func (_AmplificationUtils *AmplificationUtilsCaller) MAXA(opts *bind.CallOpts) (*big.Int, error)

+ type AmplificationUtilsCallerRaw struct

+ Contract *AmplificationUtilsCaller

+ func (_AmplificationUtils *AmplificationUtilsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type AmplificationUtilsCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *AmplificationUtilsCaller

+ func (_AmplificationUtils *AmplificationUtilsCallerSession) APRECISION() (*big.Int, error)

+ func (_AmplificationUtils *AmplificationUtilsCallerSession) MAXA() (*big.Int, error)

+ type AmplificationUtilsFilterer struct

+ func NewAmplificationUtilsFilterer(address common.Address, filterer bind.ContractFilterer) (*AmplificationUtilsFilterer, error)

+ func (_AmplificationUtils *AmplificationUtilsFilterer) FilterRampA(opts *bind.FilterOpts) (*AmplificationUtilsRampAIterator, error)

+ func (_AmplificationUtils *AmplificationUtilsFilterer) FilterStopRampA(opts *bind.FilterOpts) (*AmplificationUtilsStopRampAIterator, error)

+ func (_AmplificationUtils *AmplificationUtilsFilterer) ParseRampA(log types.Log) (*AmplificationUtilsRampA, error)

+ func (_AmplificationUtils *AmplificationUtilsFilterer) ParseStopRampA(log types.Log) (*AmplificationUtilsStopRampA, error)

+ func (_AmplificationUtils *AmplificationUtilsFilterer) WatchRampA(opts *bind.WatchOpts, sink chan<- *AmplificationUtilsRampA) (event.Subscription, error)

+ func (_AmplificationUtils *AmplificationUtilsFilterer) WatchStopRampA(opts *bind.WatchOpts, sink chan<- *AmplificationUtilsStopRampA) (event.Subscription, error)

+ type AmplificationUtilsRampA struct

+ FutureTime *big.Int

+ InitialTime *big.Int

+ NewA *big.Int

+ OldA *big.Int

+ Raw types.Log

+ type AmplificationUtilsRampAIterator struct

+ Event *AmplificationUtilsRampA

+ func (it *AmplificationUtilsRampAIterator) Close() error

+ func (it *AmplificationUtilsRampAIterator) Error() error

+ func (it *AmplificationUtilsRampAIterator) Next() bool

+ type AmplificationUtilsRaw struct

+ Contract *AmplificationUtils

+ func (_AmplificationUtils *AmplificationUtilsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_AmplificationUtils *AmplificationUtilsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_AmplificationUtils *AmplificationUtilsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AmplificationUtilsSession struct

+ CallOpts bind.CallOpts

+ Contract *AmplificationUtils

+ TransactOpts bind.TransactOpts

+ func (_AmplificationUtils *AmplificationUtilsSession) APRECISION() (*big.Int, error)

+ func (_AmplificationUtils *AmplificationUtilsSession) MAXA() (*big.Int, error)

+ type AmplificationUtilsStopRampA struct

+ CurrentA *big.Int

+ Raw types.Log

+ Time *big.Int

+ type AmplificationUtilsStopRampAIterator struct

+ Event *AmplificationUtilsStopRampA

+ func (it *AmplificationUtilsStopRampAIterator) Close() error

+ func (it *AmplificationUtilsStopRampAIterator) Error() error

+ func (it *AmplificationUtilsStopRampAIterator) Next() bool

+ type AmplificationUtilsTransactor struct

+ func NewAmplificationUtilsTransactor(address common.Address, transactor bind.ContractTransactor) (*AmplificationUtilsTransactor, error)

+ type AmplificationUtilsTransactorRaw struct

+ Contract *AmplificationUtilsTransactor

+ func (_AmplificationUtils *AmplificationUtilsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_AmplificationUtils *AmplificationUtilsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type AmplificationUtilsTransactorSession struct

+ Contract *AmplificationUtilsTransactor

+ TransactOpts bind.TransactOpts

+ type Clones struct

+ func DeployClones(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Clones, error)

+ func NewClones(address common.Address, backend bind.ContractBackend) (*Clones, error)

+ type ClonesCaller struct

+ func NewClonesCaller(address common.Address, caller bind.ContractCaller) (*ClonesCaller, error)

+ type ClonesCallerRaw struct

+ Contract *ClonesCaller

+ func (_Clones *ClonesCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ClonesCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ClonesCaller

+ type ClonesFilterer struct

+ func NewClonesFilterer(address common.Address, filterer bind.ContractFilterer) (*ClonesFilterer, error)

+ type ClonesRaw struct

+ Contract *Clones

+ func (_Clones *ClonesRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_Clones *ClonesRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Clones *ClonesRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ClonesSession struct

+ CallOpts bind.CallOpts

+ Contract *Clones

+ TransactOpts bind.TransactOpts

+ type ClonesTransactor struct

+ func NewClonesTransactor(address common.Address, transactor bind.ContractTransactor) (*ClonesTransactor, error)

+ type ClonesTransactorRaw struct

+ Contract *ClonesTransactor

+ func (_Clones *ClonesTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Clones *ClonesTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ClonesTransactorSession struct

+ Contract *ClonesTransactor

+ TransactOpts bind.TransactOpts

+ type Context struct

+ func NewContext(address common.Address, backend bind.ContractBackend) (*Context, error)

+ type ContextCaller struct

+ func NewContextCaller(address common.Address, caller bind.ContractCaller) (*ContextCaller, error)

+ type ContextCallerRaw struct

+ Contract *ContextCaller

+ func (_Context *ContextCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ContextCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ContextCaller

+ type ContextFilterer struct

+ func NewContextFilterer(address common.Address, filterer bind.ContractFilterer) (*ContextFilterer, error)

+ type ContextRaw struct

+ Contract *Context

+ func (_Context *ContextRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_Context *ContextRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Context *ContextRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ContextSession struct

+ CallOpts bind.CallOpts

+ Contract *Context

+ TransactOpts bind.TransactOpts

+ type ContextTransactor struct

+ func NewContextTransactor(address common.Address, transactor bind.ContractTransactor) (*ContextTransactor, error)

+ type ContextTransactorRaw struct

+ Contract *ContextTransactor

+ func (_Context *ContextTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Context *ContextTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ContextTransactorSession struct

+ Contract *ContextTransactor

+ TransactOpts bind.TransactOpts

+ type ContextUpgradeable struct

+ func NewContextUpgradeable(address common.Address, backend bind.ContractBackend) (*ContextUpgradeable, error)

+ type ContextUpgradeableCaller struct

+ func NewContextUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*ContextUpgradeableCaller, error)

+ type ContextUpgradeableCallerRaw struct

+ Contract *ContextUpgradeableCaller

+ func (_ContextUpgradeable *ContextUpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ContextUpgradeableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ContextUpgradeableCaller

+ type ContextUpgradeableFilterer struct

+ func NewContextUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*ContextUpgradeableFilterer, error)

+ type ContextUpgradeableRaw struct

+ Contract *ContextUpgradeable

+ func (_ContextUpgradeable *ContextUpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_ContextUpgradeable *ContextUpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ContextUpgradeable *ContextUpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ContextUpgradeableSession struct

+ CallOpts bind.CallOpts

+ Contract *ContextUpgradeable

+ TransactOpts bind.TransactOpts

+ type ContextUpgradeableTransactor struct

+ func NewContextUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*ContextUpgradeableTransactor, error)

+ type ContextUpgradeableTransactorRaw struct

+ Contract *ContextUpgradeableTransactor

+ func (_ContextUpgradeable *ContextUpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ContextUpgradeable *ContextUpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ContextUpgradeableTransactorSession struct

+ Contract *ContextUpgradeableTransactor

+ TransactOpts bind.TransactOpts

+ type ERC20 struct

+ func DeployERC20(auth *bind.TransactOpts, backend bind.ContractBackend, name_ string, ...) (common.Address, *types.Transaction, *ERC20, error)

+ func NewERC20(address common.Address, backend bind.ContractBackend) (*ERC20, error)

+ type ERC20Approval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type ERC20ApprovalIterator struct

+ Event *ERC20Approval

+ func (it *ERC20ApprovalIterator) Close() error

+ func (it *ERC20ApprovalIterator) Error() error

+ func (it *ERC20ApprovalIterator) Next() bool

+ type ERC20BurnableUpgradeable struct

+ func NewERC20BurnableUpgradeable(address common.Address, backend bind.ContractBackend) (*ERC20BurnableUpgradeable, error)

+ type ERC20BurnableUpgradeableApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type ERC20BurnableUpgradeableApprovalIterator struct

+ Event *ERC20BurnableUpgradeableApproval

+ func (it *ERC20BurnableUpgradeableApprovalIterator) Close() error

+ func (it *ERC20BurnableUpgradeableApprovalIterator) Error() error

+ func (it *ERC20BurnableUpgradeableApprovalIterator) Next() bool

+ type ERC20BurnableUpgradeableCaller struct

+ func NewERC20BurnableUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*ERC20BurnableUpgradeableCaller, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableCaller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type ERC20BurnableUpgradeableCallerRaw struct

+ Contract *ERC20BurnableUpgradeableCaller

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ERC20BurnableUpgradeableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20BurnableUpgradeableCaller

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableCallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableCallerSession) Decimals() (uint8, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableCallerSession) Name() (string, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableCallerSession) Symbol() (string, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableCallerSession) TotalSupply() (*big.Int, error)

+ type ERC20BurnableUpgradeableFilterer struct

+ func NewERC20BurnableUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20BurnableUpgradeableFilterer, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20BurnableUpgradeableApprovalIterator, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20BurnableUpgradeableTransferIterator, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableFilterer) ParseApproval(log types.Log) (*ERC20BurnableUpgradeableApproval, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableFilterer) ParseTransfer(log types.Log) (*ERC20BurnableUpgradeableTransfer, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20BurnableUpgradeableApproval, ...) (event.Subscription, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20BurnableUpgradeableTransfer, ...) (event.Subscription, error)

+ type ERC20BurnableUpgradeableRaw struct

+ Contract *ERC20BurnableUpgradeable

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20BurnableUpgradeableSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20BurnableUpgradeable

+ TransactOpts bind.TransactOpts

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableSession) Burn(amount *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableSession) Decimals() (uint8, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableSession) Name() (string, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableSession) Symbol() (string, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableSession) TotalSupply() (*big.Int, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ type ERC20BurnableUpgradeableTransactor struct

+ func NewERC20BurnableUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20BurnableUpgradeableTransactor, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableTransactor) BurnFrom(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, ...) (*types.Transaction, error)

+ type ERC20BurnableUpgradeableTransactorRaw struct

+ Contract *ERC20BurnableUpgradeableTransactor

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20BurnableUpgradeableTransactorSession struct

+ Contract *ERC20BurnableUpgradeableTransactor

+ TransactOpts bind.TransactOpts

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableTransactorSession) Burn(amount *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableTransactorSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20BurnableUpgradeable *ERC20BurnableUpgradeableTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ type ERC20BurnableUpgradeableTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type ERC20BurnableUpgradeableTransferIterator struct

+ Event *ERC20BurnableUpgradeableTransfer

+ func (it *ERC20BurnableUpgradeableTransferIterator) Close() error

+ func (it *ERC20BurnableUpgradeableTransferIterator) Error() error

+ func (it *ERC20BurnableUpgradeableTransferIterator) Next() bool

+ type ERC20Caller struct

+ func NewERC20Caller(address common.Address, caller bind.ContractCaller) (*ERC20Caller, error)

+ func (_ERC20 *ERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_ERC20 *ERC20Caller) Name(opts *bind.CallOpts) (string, error)

+ func (_ERC20 *ERC20Caller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_ERC20 *ERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type ERC20CallerRaw struct

+ Contract *ERC20Caller

+ func (_ERC20 *ERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ERC20CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20Caller

+ func (_ERC20 *ERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20CallerSession) Decimals() (uint8, error)

+ func (_ERC20 *ERC20CallerSession) Name() (string, error)

+ func (_ERC20 *ERC20CallerSession) Symbol() (string, error)

+ func (_ERC20 *ERC20CallerSession) TotalSupply() (*big.Int, error)

+ type ERC20Filterer struct

+ func NewERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC20Filterer, error)

+ func (_ERC20 *ERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20ApprovalIterator, error)

+ func (_ERC20 *ERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20TransferIterator, error)

+ func (_ERC20 *ERC20Filterer) ParseApproval(log types.Log) (*ERC20Approval, error)

+ func (_ERC20 *ERC20Filterer) ParseTransfer(log types.Log) (*ERC20Transfer, error)

+ func (_ERC20 *ERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20Approval, owner []common.Address, ...) (event.Subscription, error)

+ func (_ERC20 *ERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20Transfer, from []common.Address, ...) (event.Subscription, error)

+ type ERC20Raw struct

+ Contract *ERC20

+ func (_ERC20 *ERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_ERC20 *ERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC20 *ERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20Session struct

+ CallOpts bind.CallOpts

+ Contract *ERC20

+ TransactOpts bind.TransactOpts

+ func (_ERC20 *ERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Session) BalanceOf(account common.Address) (*big.Int, error)

+ func (_ERC20 *ERC20Session) Decimals() (uint8, error)

+ func (_ERC20 *ERC20Session) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Session) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Session) Name() (string, error)

+ func (_ERC20 *ERC20Session) Symbol() (string, error)

+ func (_ERC20 *ERC20Session) TotalSupply() (*big.Int, error)

+ func (_ERC20 *ERC20Session) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ type ERC20Transactor struct

+ func NewERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC20Transactor, error)

+ func (_ERC20 *ERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Transactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Transactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Transactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, ...) (*types.Transaction, error)

+ type ERC20TransactorRaw struct

+ Contract *ERC20Transactor

+ func (_ERC20 *ERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC20 *ERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20TransactorSession struct

+ Contract *ERC20Transactor

+ TransactOpts bind.TransactOpts

+ func (_ERC20 *ERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20TransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20TransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20TransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20 *ERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ type ERC20Transfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type ERC20TransferIterator struct

+ Event *ERC20Transfer

+ func (it *ERC20TransferIterator) Close() error

+ func (it *ERC20TransferIterator) Error() error

+ func (it *ERC20TransferIterator) Next() bool

+ type ERC20Upgradeable struct

+ func DeployERC20Upgradeable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20Upgradeable, error)

+ func NewERC20Upgradeable(address common.Address, backend bind.ContractBackend) (*ERC20Upgradeable, error)

+ type ERC20UpgradeableApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type ERC20UpgradeableApprovalIterator struct

+ Event *ERC20UpgradeableApproval

+ func (it *ERC20UpgradeableApprovalIterator) Close() error

+ func (it *ERC20UpgradeableApprovalIterator) Error() error

+ func (it *ERC20UpgradeableApprovalIterator) Next() bool

+ type ERC20UpgradeableCaller struct

+ func NewERC20UpgradeableCaller(address common.Address, caller bind.ContractCaller) (*ERC20UpgradeableCaller, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableCaller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type ERC20UpgradeableCallerRaw struct

+ Contract *ERC20UpgradeableCaller

+ func (_ERC20Upgradeable *ERC20UpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ERC20UpgradeableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20UpgradeableCaller

+ func (_ERC20Upgradeable *ERC20UpgradeableCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableCallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableCallerSession) Decimals() (uint8, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableCallerSession) Name() (string, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableCallerSession) Symbol() (string, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableCallerSession) TotalSupply() (*big.Int, error)

+ type ERC20UpgradeableFilterer struct

+ func NewERC20UpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20UpgradeableFilterer, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20UpgradeableApprovalIterator, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20UpgradeableTransferIterator, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableFilterer) ParseApproval(log types.Log) (*ERC20UpgradeableApproval, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableFilterer) ParseTransfer(log types.Log) (*ERC20UpgradeableTransfer, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20UpgradeableApproval, ...) (event.Subscription, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20UpgradeableTransfer, ...) (event.Subscription, error)

+ type ERC20UpgradeableRaw struct

+ Contract *ERC20Upgradeable

+ func (_ERC20Upgradeable *ERC20UpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_ERC20Upgradeable *ERC20UpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20UpgradeableSession struct

+ CallOpts bind.CallOpts

+ Contract *ERC20Upgradeable

+ TransactOpts bind.TransactOpts

+ func (_ERC20Upgradeable *ERC20UpgradeableSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableSession) Decimals() (uint8, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableSession) Name() (string, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableSession) Symbol() (string, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableSession) TotalSupply() (*big.Int, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ type ERC20UpgradeableTransactor struct

+ func NewERC20UpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20UpgradeableTransactor, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, ...) (*types.Transaction, error)

+ type ERC20UpgradeableTransactorRaw struct

+ Contract *ERC20UpgradeableTransactor

+ func (_ERC20Upgradeable *ERC20UpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ERC20UpgradeableTransactorSession struct

+ Contract *ERC20UpgradeableTransactor

+ TransactOpts bind.TransactOpts

+ func (_ERC20Upgradeable *ERC20UpgradeableTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_ERC20Upgradeable *ERC20UpgradeableTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ type ERC20UpgradeableTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type ERC20UpgradeableTransferIterator struct

+ Event *ERC20UpgradeableTransfer

+ func (it *ERC20UpgradeableTransferIterator) Close() error

+ func (it *ERC20UpgradeableTransferIterator) Error() error

+ func (it *ERC20UpgradeableTransferIterator) Next() bool

+ type IERC20 struct

+ func NewIERC20(address common.Address, backend bind.ContractBackend) (*IERC20, error)

+ type IERC20Approval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type IERC20ApprovalIterator struct

+ Event *IERC20Approval

+ func (it *IERC20ApprovalIterator) Close() error

+ func (it *IERC20ApprovalIterator) Error() error

+ func (it *IERC20ApprovalIterator) Next() bool

+ type IERC20Caller struct

+ func NewIERC20Caller(address common.Address, caller bind.ContractCaller) (*IERC20Caller, error)

+ func (_IERC20 *IERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type IERC20CallerRaw struct

+ Contract *IERC20Caller

+ func (_IERC20 *IERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type IERC20CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC20Caller

+ func (_IERC20 *IERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20CallerSession) TotalSupply() (*big.Int, error)

+ type IERC20Filterer struct

+ func NewIERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC20Filterer, error)

+ func (_IERC20 *IERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IERC20ApprovalIterator, error)

+ func (_IERC20 *IERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IERC20TransferIterator, error)

+ func (_IERC20 *IERC20Filterer) ParseApproval(log types.Log) (*IERC20Approval, error)

+ func (_IERC20 *IERC20Filterer) ParseTransfer(log types.Log) (*IERC20Transfer, error)

+ func (_IERC20 *IERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC20Approval, owner []common.Address, ...) (event.Subscription, error)

+ func (_IERC20 *IERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC20Transfer, from []common.Address, ...) (event.Subscription, error)

+ type IERC20Raw struct

+ Contract *IERC20

+ func (_IERC20 *IERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_IERC20 *IERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IERC20 *IERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC20Session struct

+ CallOpts bind.CallOpts

+ Contract *IERC20

+ TransactOpts bind.TransactOpts

+ func (_IERC20 *IERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20Session) BalanceOf(account common.Address) (*big.Int, error)

+ func (_IERC20 *IERC20Session) TotalSupply() (*big.Int, error)

+ func (_IERC20 *IERC20Session) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ type IERC20Transactor struct

+ func NewIERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC20Transactor, error)

+ func (_IERC20 *IERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20Transactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, ...) (*types.Transaction, error)

+ type IERC20TransactorRaw struct

+ Contract *IERC20Transactor

+ func (_IERC20 *IERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IERC20 *IERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC20TransactorSession struct

+ Contract *IERC20Transactor

+ TransactOpts bind.TransactOpts

+ func (_IERC20 *IERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20TransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20 *IERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ type IERC20Transfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type IERC20TransferIterator struct

+ Event *IERC20Transfer

+ func (it *IERC20TransferIterator) Close() error

+ func (it *IERC20TransferIterator) Error() error

+ func (it *IERC20TransferIterator) Next() bool

+ type IERC20Upgradeable struct

+ func NewIERC20Upgradeable(address common.Address, backend bind.ContractBackend) (*IERC20Upgradeable, error)

+ type IERC20UpgradeableApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type IERC20UpgradeableApprovalIterator struct

+ Event *IERC20UpgradeableApproval

+ func (it *IERC20UpgradeableApprovalIterator) Close() error

+ func (it *IERC20UpgradeableApprovalIterator) Error() error

+ func (it *IERC20UpgradeableApprovalIterator) Next() bool

+ type IERC20UpgradeableCaller struct

+ func NewIERC20UpgradeableCaller(address common.Address, caller bind.ContractCaller) (*IERC20UpgradeableCaller, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type IERC20UpgradeableCallerRaw struct

+ Contract *IERC20UpgradeableCaller

+ func (_IERC20Upgradeable *IERC20UpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type IERC20UpgradeableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC20UpgradeableCaller

+ func (_IERC20Upgradeable *IERC20UpgradeableCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableCallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableCallerSession) TotalSupply() (*big.Int, error)

+ type IERC20UpgradeableFilterer struct

+ func NewIERC20UpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*IERC20UpgradeableFilterer, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IERC20UpgradeableApprovalIterator, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IERC20UpgradeableTransferIterator, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableFilterer) ParseApproval(log types.Log) (*IERC20UpgradeableApproval, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableFilterer) ParseTransfer(log types.Log) (*IERC20UpgradeableTransfer, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC20UpgradeableApproval, ...) (event.Subscription, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC20UpgradeableTransfer, ...) (event.Subscription, error)

+ type IERC20UpgradeableRaw struct

+ Contract *IERC20Upgradeable

+ func (_IERC20Upgradeable *IERC20UpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_IERC20Upgradeable *IERC20UpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC20UpgradeableSession struct

+ CallOpts bind.CallOpts

+ Contract *IERC20Upgradeable

+ TransactOpts bind.TransactOpts

+ func (_IERC20Upgradeable *IERC20UpgradeableSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableSession) TotalSupply() (*big.Int, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ type IERC20UpgradeableTransactor struct

+ func NewIERC20UpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*IERC20UpgradeableTransactor, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, ...) (*types.Transaction, error)

+ type IERC20UpgradeableTransactorRaw struct

+ Contract *IERC20UpgradeableTransactor

+ func (_IERC20Upgradeable *IERC20UpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type IERC20UpgradeableTransactorSession struct

+ Contract *IERC20UpgradeableTransactor

+ TransactOpts bind.TransactOpts

+ func (_IERC20Upgradeable *IERC20UpgradeableTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_IERC20Upgradeable *IERC20UpgradeableTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ type IERC20UpgradeableTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type IERC20UpgradeableTransferIterator struct

+ Event *IERC20UpgradeableTransfer

+ func (it *IERC20UpgradeableTransferIterator) Close() error

+ func (it *IERC20UpgradeableTransferIterator) Error() error

+ func (it *IERC20UpgradeableTransferIterator) Next() bool

+ type ISwap struct

+ func NewISwap(address common.Address, backend bind.ContractBackend) (*ISwap, error)

+ type ISwapCaller struct

+ func NewISwapCaller(address common.Address, caller bind.ContractCaller) (*ISwapCaller, error)

+ func (_ISwap *ISwapCaller) CalculateRemoveLiquidity(opts *bind.CallOpts, amount *big.Int) ([]*big.Int, error)

+ func (_ISwap *ISwapCaller) CalculateRemoveLiquidityOneToken(opts *bind.CallOpts, tokenAmount *big.Int, tokenIndex uint8) (*big.Int, error)

+ func (_ISwap *ISwapCaller) CalculateSwap(opts *bind.CallOpts, tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_ISwap *ISwapCaller) CalculateTokenAmount(opts *bind.CallOpts, amounts []*big.Int, deposit bool) (*big.Int, error)

+ func (_ISwap *ISwapCaller) GetA(opts *bind.CallOpts) (*big.Int, error)

+ func (_ISwap *ISwapCaller) GetToken(opts *bind.CallOpts, index uint8) (common.Address, error)

+ func (_ISwap *ISwapCaller) GetTokenBalance(opts *bind.CallOpts, index uint8) (*big.Int, error)

+ func (_ISwap *ISwapCaller) GetTokenIndex(opts *bind.CallOpts, tokenAddress common.Address) (uint8, error)

+ func (_ISwap *ISwapCaller) GetVirtualPrice(opts *bind.CallOpts) (*big.Int, error)

+ type ISwapCallerRaw struct

+ Contract *ISwapCaller

+ func (_ISwap *ISwapCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ISwapCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ISwapCaller

+ func (_ISwap *ISwapCallerSession) CalculateRemoveLiquidity(amount *big.Int) ([]*big.Int, error)

+ func (_ISwap *ISwapCallerSession) CalculateRemoveLiquidityOneToken(tokenAmount *big.Int, tokenIndex uint8) (*big.Int, error)

+ func (_ISwap *ISwapCallerSession) CalculateSwap(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_ISwap *ISwapCallerSession) CalculateTokenAmount(amounts []*big.Int, deposit bool) (*big.Int, error)

+ func (_ISwap *ISwapCallerSession) GetA() (*big.Int, error)

+ func (_ISwap *ISwapCallerSession) GetToken(index uint8) (common.Address, error)

+ func (_ISwap *ISwapCallerSession) GetTokenBalance(index uint8) (*big.Int, error)

+ func (_ISwap *ISwapCallerSession) GetTokenIndex(tokenAddress common.Address) (uint8, error)

+ func (_ISwap *ISwapCallerSession) GetVirtualPrice() (*big.Int, error)

+ type ISwapFilterer struct

+ func NewISwapFilterer(address common.Address, filterer bind.ContractFilterer) (*ISwapFilterer, error)

+ type ISwapRaw struct

+ Contract *ISwap

+ func (_ISwap *ISwapRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_ISwap *ISwapRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ISwap *ISwapRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ISwapSession struct

+ CallOpts bind.CallOpts

+ Contract *ISwap

+ TransactOpts bind.TransactOpts

+ func (_ISwap *ISwapSession) AddLiquidity(amounts []*big.Int, minToMint *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_ISwap *ISwapSession) CalculateRemoveLiquidity(amount *big.Int) ([]*big.Int, error)

+ func (_ISwap *ISwapSession) CalculateRemoveLiquidityOneToken(tokenAmount *big.Int, tokenIndex uint8) (*big.Int, error)

+ func (_ISwap *ISwapSession) CalculateSwap(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_ISwap *ISwapSession) CalculateTokenAmount(amounts []*big.Int, deposit bool) (*big.Int, error)

+ func (_ISwap *ISwapSession) GetA() (*big.Int, error)

+ func (_ISwap *ISwapSession) GetToken(index uint8) (common.Address, error)

+ func (_ISwap *ISwapSession) GetTokenBalance(index uint8) (*big.Int, error)

+ func (_ISwap *ISwapSession) GetTokenIndex(tokenAddress common.Address) (uint8, error)

+ func (_ISwap *ISwapSession) GetVirtualPrice() (*big.Int, error)

+ func (_ISwap *ISwapSession) Initialize(pooledTokens []common.Address, decimals []uint8, lpTokenName string, ...) (*types.Transaction, error)

+ func (_ISwap *ISwapSession) RemoveLiquidity(amount *big.Int, minAmounts []*big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_ISwap *ISwapSession) RemoveLiquidityImbalance(amounts []*big.Int, maxBurnAmount *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_ISwap *ISwapSession) RemoveLiquidityOneToken(tokenAmount *big.Int, tokenIndex uint8, minAmount *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_ISwap *ISwapSession) Swap(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, minDy *big.Int, ...) (*types.Transaction, error)

+ type ISwapTransactor struct

+ func NewISwapTransactor(address common.Address, transactor bind.ContractTransactor) (*ISwapTransactor, error)

+ func (_ISwap *ISwapTransactor) AddLiquidity(opts *bind.TransactOpts, amounts []*big.Int, minToMint *big.Int, ...) (*types.Transaction, error)

+ func (_ISwap *ISwapTransactor) Initialize(opts *bind.TransactOpts, pooledTokens []common.Address, decimals []uint8, ...) (*types.Transaction, error)

+ func (_ISwap *ISwapTransactor) RemoveLiquidity(opts *bind.TransactOpts, amount *big.Int, minAmounts []*big.Int, ...) (*types.Transaction, error)

+ func (_ISwap *ISwapTransactor) RemoveLiquidityImbalance(opts *bind.TransactOpts, amounts []*big.Int, maxBurnAmount *big.Int, ...) (*types.Transaction, error)

+ func (_ISwap *ISwapTransactor) RemoveLiquidityOneToken(opts *bind.TransactOpts, tokenAmount *big.Int, tokenIndex uint8, ...) (*types.Transaction, error)

+ func (_ISwap *ISwapTransactor) Swap(opts *bind.TransactOpts, tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, ...) (*types.Transaction, error)

+ type ISwapTransactorRaw struct

+ Contract *ISwapTransactor

+ func (_ISwap *ISwapTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ISwap *ISwapTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ISwapTransactorSession struct

+ Contract *ISwapTransactor

+ TransactOpts bind.TransactOpts

+ func (_ISwap *ISwapTransactorSession) AddLiquidity(amounts []*big.Int, minToMint *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_ISwap *ISwapTransactorSession) Initialize(pooledTokens []common.Address, decimals []uint8, lpTokenName string, ...) (*types.Transaction, error)

+ func (_ISwap *ISwapTransactorSession) RemoveLiquidity(amount *big.Int, minAmounts []*big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_ISwap *ISwapTransactorSession) RemoveLiquidityImbalance(amounts []*big.Int, maxBurnAmount *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_ISwap *ISwapTransactorSession) RemoveLiquidityOneToken(tokenAmount *big.Int, tokenIndex uint8, minAmount *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_ISwap *ISwapTransactorSession) Swap(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, minDy *big.Int, ...) (*types.Transaction, error)

+ type Initializable struct

+ func NewInitializable(address common.Address, backend bind.ContractBackend) (*Initializable, error)

+ type InitializableCaller struct

+ func NewInitializableCaller(address common.Address, caller bind.ContractCaller) (*InitializableCaller, error)

+ type InitializableCallerRaw struct

+ Contract *InitializableCaller

+ func (_Initializable *InitializableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type InitializableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *InitializableCaller

+ type InitializableFilterer struct

+ func NewInitializableFilterer(address common.Address, filterer bind.ContractFilterer) (*InitializableFilterer, error)

+ type InitializableRaw struct

+ Contract *Initializable

+ func (_Initializable *InitializableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_Initializable *InitializableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Initializable *InitializableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InitializableSession struct

+ CallOpts bind.CallOpts

+ Contract *Initializable

+ TransactOpts bind.TransactOpts

+ type InitializableTransactor struct

+ func NewInitializableTransactor(address common.Address, transactor bind.ContractTransactor) (*InitializableTransactor, error)

+ type InitializableTransactorRaw struct

+ Contract *InitializableTransactor

+ func (_Initializable *InitializableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Initializable *InitializableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type InitializableTransactorSession struct

+ Contract *InitializableTransactor

+ TransactOpts bind.TransactOpts

+ type LPToken struct

+ func DeployLPToken(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *LPToken, error)

+ func NewLPToken(address common.Address, backend bind.ContractBackend) (*LPToken, error)

+ type LPTokenApproval struct

+ Owner common.Address

+ Raw types.Log

+ Spender common.Address

+ Value *big.Int

+ type LPTokenApprovalIterator struct

+ Event *LPTokenApproval

+ func (it *LPTokenApprovalIterator) Close() error

+ func (it *LPTokenApprovalIterator) Error() error

+ func (it *LPTokenApprovalIterator) Next() bool

+ type LPTokenCaller struct

+ func NewLPTokenCaller(address common.Address, caller bind.ContractCaller) (*LPTokenCaller, error)

+ func (_LPToken *LPTokenCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error)

+ func (_LPToken *LPTokenCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error)

+ func (_LPToken *LPTokenCaller) Decimals(opts *bind.CallOpts) (uint8, error)

+ func (_LPToken *LPTokenCaller) Name(opts *bind.CallOpts) (string, error)

+ func (_LPToken *LPTokenCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_LPToken *LPTokenCaller) Symbol(opts *bind.CallOpts) (string, error)

+ func (_LPToken *LPTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error)

+ type LPTokenCallerRaw struct

+ Contract *LPTokenCaller

+ func (_LPToken *LPTokenCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type LPTokenCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *LPTokenCaller

+ func (_LPToken *LPTokenCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_LPToken *LPTokenCallerSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_LPToken *LPTokenCallerSession) Decimals() (uint8, error)

+ func (_LPToken *LPTokenCallerSession) Name() (string, error)

+ func (_LPToken *LPTokenCallerSession) Owner() (common.Address, error)

+ func (_LPToken *LPTokenCallerSession) Symbol() (string, error)

+ func (_LPToken *LPTokenCallerSession) TotalSupply() (*big.Int, error)

+ type LPTokenFilterer struct

+ func NewLPTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*LPTokenFilterer, error)

+ func (_LPToken *LPTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*LPTokenApprovalIterator, error)

+ func (_LPToken *LPTokenFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*LPTokenOwnershipTransferredIterator, error)

+ func (_LPToken *LPTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*LPTokenTransferIterator, error)

+ func (_LPToken *LPTokenFilterer) ParseApproval(log types.Log) (*LPTokenApproval, error)

+ func (_LPToken *LPTokenFilterer) ParseOwnershipTransferred(log types.Log) (*LPTokenOwnershipTransferred, error)

+ func (_LPToken *LPTokenFilterer) ParseTransfer(log types.Log) (*LPTokenTransfer, error)

+ func (_LPToken *LPTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *LPTokenApproval, owner []common.Address, ...) (event.Subscription, error)

+ func (_LPToken *LPTokenFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *LPTokenOwnershipTransferred, ...) (event.Subscription, error)

+ func (_LPToken *LPTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *LPTokenTransfer, from []common.Address, ...) (event.Subscription, error)

+ type LPTokenOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type LPTokenOwnershipTransferredIterator struct

+ Event *LPTokenOwnershipTransferred

+ func (it *LPTokenOwnershipTransferredIterator) Close() error

+ func (it *LPTokenOwnershipTransferredIterator) Error() error

+ func (it *LPTokenOwnershipTransferredIterator) Next() bool

+ type LPTokenRaw struct

+ Contract *LPToken

+ func (_LPToken *LPTokenRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_LPToken *LPTokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_LPToken *LPTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type LPTokenSession struct

+ CallOpts bind.CallOpts

+ Contract *LPToken

+ TransactOpts bind.TransactOpts

+ func (_LPToken *LPTokenSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error)

+ func (_LPToken *LPTokenSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenSession) BalanceOf(account common.Address) (*big.Int, error)

+ func (_LPToken *LPTokenSession) Burn(amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenSession) Decimals() (uint8, error)

+ func (_LPToken *LPTokenSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenSession) Initialize(name string, symbol string) (*types.Transaction, error)

+ func (_LPToken *LPTokenSession) Mint(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenSession) Name() (string, error)

+ func (_LPToken *LPTokenSession) Owner() (common.Address, error)

+ func (_LPToken *LPTokenSession) RenounceOwnership() (*types.Transaction, error)

+ func (_LPToken *LPTokenSession) Symbol() (string, error)

+ func (_LPToken *LPTokenSession) TotalSupply() (*big.Int, error)

+ func (_LPToken *LPTokenSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type LPTokenTransactor struct

+ func NewLPTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*LPTokenTransactor, error)

+ func (_LPToken *LPTokenTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactor) BurnFrom(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactor) Initialize(opts *bind.TransactOpts, name string, symbol string) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactor) Mint(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, ...) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type LPTokenTransactorRaw struct

+ Contract *LPTokenTransactor

+ func (_LPToken *LPTokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type LPTokenTransactorSession struct

+ Contract *LPTokenTransactor

+ TransactOpts bind.TransactOpts

+ func (_LPToken *LPTokenTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactorSession) Burn(amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactorSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactorSession) Initialize(name string, symbol string) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactorSession) Mint(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error)

+ func (_LPToken *LPTokenTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type LPTokenTransfer struct

+ From common.Address

+ Raw types.Log

+ To common.Address

+ Value *big.Int

+ type LPTokenTransferIterator struct

+ Event *LPTokenTransfer

+ func (it *LPTokenTransferIterator) Close() error

+ func (it *LPTokenTransferIterator) Error() error

+ func (it *LPTokenTransferIterator) Next() bool

+ type MathUtils struct

+ func DeployMathUtils(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MathUtils, error)

+ func NewMathUtils(address common.Address, backend bind.ContractBackend) (*MathUtils, error)

+ type MathUtilsCaller struct

+ func NewMathUtilsCaller(address common.Address, caller bind.ContractCaller) (*MathUtilsCaller, error)

+ type MathUtilsCallerRaw struct

+ Contract *MathUtilsCaller

+ func (_MathUtils *MathUtilsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type MathUtilsCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MathUtilsCaller

+ type MathUtilsFilterer struct

+ func NewMathUtilsFilterer(address common.Address, filterer bind.ContractFilterer) (*MathUtilsFilterer, error)

+ type MathUtilsRaw struct

+ Contract *MathUtils

+ func (_MathUtils *MathUtilsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_MathUtils *MathUtilsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_MathUtils *MathUtilsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MathUtilsSession struct

+ CallOpts bind.CallOpts

+ Contract *MathUtils

+ TransactOpts bind.TransactOpts

+ type MathUtilsTransactor struct

+ func NewMathUtilsTransactor(address common.Address, transactor bind.ContractTransactor) (*MathUtilsTransactor, error)

+ type MathUtilsTransactorRaw struct

+ Contract *MathUtilsTransactor

+ func (_MathUtils *MathUtilsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_MathUtils *MathUtilsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MathUtilsTransactorSession struct

+ Contract *MathUtilsTransactor

+ TransactOpts bind.TransactOpts

+ type MetaSwap struct

+ func DeployMetaSwap(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MetaSwap, error)

+ func NewMetaSwap(address common.Address, backend bind.ContractBackend) (*MetaSwap, error)

+ type MetaSwapAddLiquidity struct

+ Fees []*big.Int

+ Invariant *big.Int

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokenAmounts []*big.Int

+ type MetaSwapAddLiquidityIterator struct

+ Event *MetaSwapAddLiquidity

+ func (it *MetaSwapAddLiquidityIterator) Close() error

+ func (it *MetaSwapAddLiquidityIterator) Error() error

+ func (it *MetaSwapAddLiquidityIterator) Next() bool

+ type MetaSwapCaller struct

+ func NewMetaSwapCaller(address common.Address, caller bind.ContractCaller) (*MetaSwapCaller, error)

+ func (_MetaSwap *MetaSwapCaller) CalculateRemoveLiquidity(opts *bind.CallOpts, amount *big.Int) ([]*big.Int, error)

+ func (_MetaSwap *MetaSwapCaller) CalculateRemoveLiquidityOneToken(opts *bind.CallOpts, tokenAmount *big.Int, tokenIndex uint8) (*big.Int, error)

+ func (_MetaSwap *MetaSwapCaller) CalculateSwap(opts *bind.CallOpts, tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_MetaSwap *MetaSwapCaller) CalculateSwapUnderlying(opts *bind.CallOpts, tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_MetaSwap *MetaSwapCaller) CalculateTokenAmount(opts *bind.CallOpts, amounts []*big.Int, deposit bool) (*big.Int, error)

+ func (_MetaSwap *MetaSwapCaller) GetA(opts *bind.CallOpts) (*big.Int, error)

+ func (_MetaSwap *MetaSwapCaller) GetAPrecise(opts *bind.CallOpts) (*big.Int, error)

+ func (_MetaSwap *MetaSwapCaller) GetAdminBalance(opts *bind.CallOpts, index *big.Int) (*big.Int, error)

+ func (_MetaSwap *MetaSwapCaller) GetToken(opts *bind.CallOpts, index uint8) (common.Address, error)

+ func (_MetaSwap *MetaSwapCaller) GetTokenBalance(opts *bind.CallOpts, index uint8) (*big.Int, error)

+ func (_MetaSwap *MetaSwapCaller) GetTokenIndex(opts *bind.CallOpts, tokenAddress common.Address) (uint8, error)

+ func (_MetaSwap *MetaSwapCaller) GetVirtualPrice(opts *bind.CallOpts) (*big.Int, error)

+ func (_MetaSwap *MetaSwapCaller) MetaSwapStorage(opts *bind.CallOpts) (struct{ ... }, error)

+ func (_MetaSwap *MetaSwapCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_MetaSwap *MetaSwapCaller) Paused(opts *bind.CallOpts) (bool, error)

+ func (_MetaSwap *MetaSwapCaller) SwapStorage(opts *bind.CallOpts) (struct{ ... }, error)

+ type MetaSwapCallerRaw struct

+ Contract *MetaSwapCaller

+ func (_MetaSwap *MetaSwapCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type MetaSwapCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MetaSwapCaller

+ func (_MetaSwap *MetaSwapCallerSession) CalculateRemoveLiquidity(amount *big.Int) ([]*big.Int, error)

+ func (_MetaSwap *MetaSwapCallerSession) CalculateRemoveLiquidityOneToken(tokenAmount *big.Int, tokenIndex uint8) (*big.Int, error)

+ func (_MetaSwap *MetaSwapCallerSession) CalculateSwap(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_MetaSwap *MetaSwapCallerSession) CalculateSwapUnderlying(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_MetaSwap *MetaSwapCallerSession) CalculateTokenAmount(amounts []*big.Int, deposit bool) (*big.Int, error)

+ func (_MetaSwap *MetaSwapCallerSession) GetA() (*big.Int, error)

+ func (_MetaSwap *MetaSwapCallerSession) GetAPrecise() (*big.Int, error)

+ func (_MetaSwap *MetaSwapCallerSession) GetAdminBalance(index *big.Int) (*big.Int, error)

+ func (_MetaSwap *MetaSwapCallerSession) GetToken(index uint8) (common.Address, error)

+ func (_MetaSwap *MetaSwapCallerSession) GetTokenBalance(index uint8) (*big.Int, error)

+ func (_MetaSwap *MetaSwapCallerSession) GetTokenIndex(tokenAddress common.Address) (uint8, error)

+ func (_MetaSwap *MetaSwapCallerSession) GetVirtualPrice() (*big.Int, error)

+ func (_MetaSwap *MetaSwapCallerSession) MetaSwapStorage() (struct{ ... }, error)

+ func (_MetaSwap *MetaSwapCallerSession) Owner() (common.Address, error)

+ func (_MetaSwap *MetaSwapCallerSession) Paused() (bool, error)

+ func (_MetaSwap *MetaSwapCallerSession) SwapStorage() (struct{ ... }, error)

+ type MetaSwapFilterer struct

+ func NewMetaSwapFilterer(address common.Address, filterer bind.ContractFilterer) (*MetaSwapFilterer, error)

+ func (_MetaSwap *MetaSwapFilterer) FilterAddLiquidity(opts *bind.FilterOpts, provider []common.Address) (*MetaSwapAddLiquidityIterator, error)

+ func (_MetaSwap *MetaSwapFilterer) FilterNewAdminFee(opts *bind.FilterOpts) (*MetaSwapNewAdminFeeIterator, error)

+ func (_MetaSwap *MetaSwapFilterer) FilterNewSwapFee(opts *bind.FilterOpts) (*MetaSwapNewSwapFeeIterator, error)

+ func (_MetaSwap *MetaSwapFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*MetaSwapOwnershipTransferredIterator, error)

+ func (_MetaSwap *MetaSwapFilterer) FilterPaused(opts *bind.FilterOpts) (*MetaSwapPausedIterator, error)

+ func (_MetaSwap *MetaSwapFilterer) FilterRampA(opts *bind.FilterOpts) (*MetaSwapRampAIterator, error)

+ func (_MetaSwap *MetaSwapFilterer) FilterRemoveLiquidity(opts *bind.FilterOpts, provider []common.Address) (*MetaSwapRemoveLiquidityIterator, error)

+ func (_MetaSwap *MetaSwapFilterer) FilterRemoveLiquidityImbalance(opts *bind.FilterOpts, provider []common.Address) (*MetaSwapRemoveLiquidityImbalanceIterator, error)

+ func (_MetaSwap *MetaSwapFilterer) FilterRemoveLiquidityOne(opts *bind.FilterOpts, provider []common.Address) (*MetaSwapRemoveLiquidityOneIterator, error)

+ func (_MetaSwap *MetaSwapFilterer) FilterStopRampA(opts *bind.FilterOpts) (*MetaSwapStopRampAIterator, error)

+ func (_MetaSwap *MetaSwapFilterer) FilterTokenSwap(opts *bind.FilterOpts, buyer []common.Address) (*MetaSwapTokenSwapIterator, error)

+ func (_MetaSwap *MetaSwapFilterer) FilterTokenSwapUnderlying(opts *bind.FilterOpts, buyer []common.Address) (*MetaSwapTokenSwapUnderlyingIterator, error)

+ func (_MetaSwap *MetaSwapFilterer) FilterUnpaused(opts *bind.FilterOpts) (*MetaSwapUnpausedIterator, error)

+ func (_MetaSwap *MetaSwapFilterer) ParseAddLiquidity(log types.Log) (*MetaSwapAddLiquidity, error)

+ func (_MetaSwap *MetaSwapFilterer) ParseNewAdminFee(log types.Log) (*MetaSwapNewAdminFee, error)

+ func (_MetaSwap *MetaSwapFilterer) ParseNewSwapFee(log types.Log) (*MetaSwapNewSwapFee, error)

+ func (_MetaSwap *MetaSwapFilterer) ParseOwnershipTransferred(log types.Log) (*MetaSwapOwnershipTransferred, error)

+ func (_MetaSwap *MetaSwapFilterer) ParsePaused(log types.Log) (*MetaSwapPaused, error)

+ func (_MetaSwap *MetaSwapFilterer) ParseRampA(log types.Log) (*MetaSwapRampA, error)

+ func (_MetaSwap *MetaSwapFilterer) ParseRemoveLiquidity(log types.Log) (*MetaSwapRemoveLiquidity, error)

+ func (_MetaSwap *MetaSwapFilterer) ParseRemoveLiquidityImbalance(log types.Log) (*MetaSwapRemoveLiquidityImbalance, error)

+ func (_MetaSwap *MetaSwapFilterer) ParseRemoveLiquidityOne(log types.Log) (*MetaSwapRemoveLiquidityOne, error)

+ func (_MetaSwap *MetaSwapFilterer) ParseStopRampA(log types.Log) (*MetaSwapStopRampA, error)

+ func (_MetaSwap *MetaSwapFilterer) ParseTokenSwap(log types.Log) (*MetaSwapTokenSwap, error)

+ func (_MetaSwap *MetaSwapFilterer) ParseTokenSwapUnderlying(log types.Log) (*MetaSwapTokenSwapUnderlying, error)

+ func (_MetaSwap *MetaSwapFilterer) ParseUnpaused(log types.Log) (*MetaSwapUnpaused, error)

+ func (_MetaSwap *MetaSwapFilterer) WatchAddLiquidity(opts *bind.WatchOpts, sink chan<- *MetaSwapAddLiquidity, ...) (event.Subscription, error)

+ func (_MetaSwap *MetaSwapFilterer) WatchNewAdminFee(opts *bind.WatchOpts, sink chan<- *MetaSwapNewAdminFee) (event.Subscription, error)

+ func (_MetaSwap *MetaSwapFilterer) WatchNewSwapFee(opts *bind.WatchOpts, sink chan<- *MetaSwapNewSwapFee) (event.Subscription, error)

+ func (_MetaSwap *MetaSwapFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *MetaSwapOwnershipTransferred, ...) (event.Subscription, error)

+ func (_MetaSwap *MetaSwapFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *MetaSwapPaused) (event.Subscription, error)

+ func (_MetaSwap *MetaSwapFilterer) WatchRampA(opts *bind.WatchOpts, sink chan<- *MetaSwapRampA) (event.Subscription, error)

+ func (_MetaSwap *MetaSwapFilterer) WatchRemoveLiquidity(opts *bind.WatchOpts, sink chan<- *MetaSwapRemoveLiquidity, ...) (event.Subscription, error)

+ func (_MetaSwap *MetaSwapFilterer) WatchRemoveLiquidityImbalance(opts *bind.WatchOpts, sink chan<- *MetaSwapRemoveLiquidityImbalance, ...) (event.Subscription, error)

+ func (_MetaSwap *MetaSwapFilterer) WatchRemoveLiquidityOne(opts *bind.WatchOpts, sink chan<- *MetaSwapRemoveLiquidityOne, ...) (event.Subscription, error)

+ func (_MetaSwap *MetaSwapFilterer) WatchStopRampA(opts *bind.WatchOpts, sink chan<- *MetaSwapStopRampA) (event.Subscription, error)

+ func (_MetaSwap *MetaSwapFilterer) WatchTokenSwap(opts *bind.WatchOpts, sink chan<- *MetaSwapTokenSwap, buyer []common.Address) (event.Subscription, error)

+ func (_MetaSwap *MetaSwapFilterer) WatchTokenSwapUnderlying(opts *bind.WatchOpts, sink chan<- *MetaSwapTokenSwapUnderlying, ...) (event.Subscription, error)

+ func (_MetaSwap *MetaSwapFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *MetaSwapUnpaused) (event.Subscription, error)

+ type MetaSwapNewAdminFee struct

+ NewAdminFee *big.Int

+ Raw types.Log

+ type MetaSwapNewAdminFeeIterator struct

+ Event *MetaSwapNewAdminFee

+ func (it *MetaSwapNewAdminFeeIterator) Close() error

+ func (it *MetaSwapNewAdminFeeIterator) Error() error

+ func (it *MetaSwapNewAdminFeeIterator) Next() bool

+ type MetaSwapNewSwapFee struct

+ NewSwapFee *big.Int

+ Raw types.Log

+ type MetaSwapNewSwapFeeIterator struct

+ Event *MetaSwapNewSwapFee

+ func (it *MetaSwapNewSwapFeeIterator) Close() error

+ func (it *MetaSwapNewSwapFeeIterator) Error() error

+ func (it *MetaSwapNewSwapFeeIterator) Next() bool

+ type MetaSwapOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type MetaSwapOwnershipTransferredIterator struct

+ Event *MetaSwapOwnershipTransferred

+ func (it *MetaSwapOwnershipTransferredIterator) Close() error

+ func (it *MetaSwapOwnershipTransferredIterator) Error() error

+ func (it *MetaSwapOwnershipTransferredIterator) Next() bool

+ type MetaSwapPaused struct

+ Account common.Address

+ Raw types.Log

+ type MetaSwapPausedIterator struct

+ Event *MetaSwapPaused

+ func (it *MetaSwapPausedIterator) Close() error

+ func (it *MetaSwapPausedIterator) Error() error

+ func (it *MetaSwapPausedIterator) Next() bool

+ type MetaSwapRampA struct

+ FutureTime *big.Int

+ InitialTime *big.Int

+ NewA *big.Int

+ OldA *big.Int

+ Raw types.Log

+ type MetaSwapRampAIterator struct

+ Event *MetaSwapRampA

+ func (it *MetaSwapRampAIterator) Close() error

+ func (it *MetaSwapRampAIterator) Error() error

+ func (it *MetaSwapRampAIterator) Next() bool

+ type MetaSwapRaw struct

+ Contract *MetaSwap

+ func (_MetaSwap *MetaSwapRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_MetaSwap *MetaSwapRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MetaSwapRemoveLiquidity struct

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokenAmounts []*big.Int

+ type MetaSwapRemoveLiquidityImbalance struct

+ Fees []*big.Int

+ Invariant *big.Int

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokenAmounts []*big.Int

+ type MetaSwapRemoveLiquidityImbalanceIterator struct

+ Event *MetaSwapRemoveLiquidityImbalance

+ func (it *MetaSwapRemoveLiquidityImbalanceIterator) Close() error

+ func (it *MetaSwapRemoveLiquidityImbalanceIterator) Error() error

+ func (it *MetaSwapRemoveLiquidityImbalanceIterator) Next() bool

+ type MetaSwapRemoveLiquidityIterator struct

+ Event *MetaSwapRemoveLiquidity

+ func (it *MetaSwapRemoveLiquidityIterator) Close() error

+ func (it *MetaSwapRemoveLiquidityIterator) Error() error

+ func (it *MetaSwapRemoveLiquidityIterator) Next() bool

+ type MetaSwapRemoveLiquidityOne struct

+ BoughtId *big.Int

+ LpTokenAmount *big.Int

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokensBought *big.Int

+ type MetaSwapRemoveLiquidityOneIterator struct

+ Event *MetaSwapRemoveLiquidityOne

+ func (it *MetaSwapRemoveLiquidityOneIterator) Close() error

+ func (it *MetaSwapRemoveLiquidityOneIterator) Error() error

+ func (it *MetaSwapRemoveLiquidityOneIterator) Next() bool

+ type MetaSwapSession struct

+ CallOpts bind.CallOpts

+ Contract *MetaSwap

+ TransactOpts bind.TransactOpts

+ func (_MetaSwap *MetaSwapSession) AddLiquidity(amounts []*big.Int, minToMint *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapSession) CalculateRemoveLiquidity(amount *big.Int) ([]*big.Int, error)

+ func (_MetaSwap *MetaSwapSession) CalculateRemoveLiquidityOneToken(tokenAmount *big.Int, tokenIndex uint8) (*big.Int, error)

+ func (_MetaSwap *MetaSwapSession) CalculateSwap(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_MetaSwap *MetaSwapSession) CalculateSwapUnderlying(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_MetaSwap *MetaSwapSession) CalculateTokenAmount(amounts []*big.Int, deposit bool) (*big.Int, error)

+ func (_MetaSwap *MetaSwapSession) GetA() (*big.Int, error)

+ func (_MetaSwap *MetaSwapSession) GetAPrecise() (*big.Int, error)

+ func (_MetaSwap *MetaSwapSession) GetAdminBalance(index *big.Int) (*big.Int, error)

+ func (_MetaSwap *MetaSwapSession) GetToken(index uint8) (common.Address, error)

+ func (_MetaSwap *MetaSwapSession) GetTokenBalance(index uint8) (*big.Int, error)

+ func (_MetaSwap *MetaSwapSession) GetTokenIndex(tokenAddress common.Address) (uint8, error)

+ func (_MetaSwap *MetaSwapSession) GetVirtualPrice() (*big.Int, error)

+ func (_MetaSwap *MetaSwapSession) Initialize(_pooledTokens []common.Address, decimals []uint8, lpTokenName string, ...) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapSession) InitializeMetaSwap(_pooledTokens []common.Address, decimals []uint8, lpTokenName string, ...) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapSession) MetaSwapStorage() (struct{ ... }, error)

+ func (_MetaSwap *MetaSwapSession) Owner() (common.Address, error)

+ func (_MetaSwap *MetaSwapSession) Pause() (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapSession) Paused() (bool, error)

+ func (_MetaSwap *MetaSwapSession) RampA(futureA *big.Int, futureTime *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapSession) RemoveLiquidity(amount *big.Int, minAmounts []*big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapSession) RemoveLiquidityImbalance(amounts []*big.Int, maxBurnAmount *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapSession) RemoveLiquidityOneToken(tokenAmount *big.Int, tokenIndex uint8, minAmount *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapSession) RenounceOwnership() (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapSession) SetAdminFee(newAdminFee *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapSession) SetSwapFee(newSwapFee *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapSession) StopRampA() (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapSession) Swap(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, minDy *big.Int, ...) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapSession) SwapStorage() (struct{ ... }, error)

+ func (_MetaSwap *MetaSwapSession) SwapUnderlying(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, minDy *big.Int, ...) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapSession) Unpause() (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapSession) WithdrawAdminFees() (*types.Transaction, error)

+ type MetaSwapStopRampA struct

+ CurrentA *big.Int

+ Raw types.Log

+ Time *big.Int

+ type MetaSwapStopRampAIterator struct

+ Event *MetaSwapStopRampA

+ func (it *MetaSwapStopRampAIterator) Close() error

+ func (it *MetaSwapStopRampAIterator) Error() error

+ func (it *MetaSwapStopRampAIterator) Next() bool

+ type MetaSwapTokenSwap struct

+ BoughtId *big.Int

+ Buyer common.Address

+ Raw types.Log

+ SoldId *big.Int

+ TokensBought *big.Int

+ TokensSold *big.Int

+ type MetaSwapTokenSwapIterator struct

+ Event *MetaSwapTokenSwap

+ func (it *MetaSwapTokenSwapIterator) Close() error

+ func (it *MetaSwapTokenSwapIterator) Error() error

+ func (it *MetaSwapTokenSwapIterator) Next() bool

+ type MetaSwapTokenSwapUnderlying struct

+ BoughtId *big.Int

+ Buyer common.Address

+ Raw types.Log

+ SoldId *big.Int

+ TokensBought *big.Int

+ TokensSold *big.Int

+ type MetaSwapTokenSwapUnderlyingIterator struct

+ Event *MetaSwapTokenSwapUnderlying

+ func (it *MetaSwapTokenSwapUnderlyingIterator) Close() error

+ func (it *MetaSwapTokenSwapUnderlyingIterator) Error() error

+ func (it *MetaSwapTokenSwapUnderlyingIterator) Next() bool

+ type MetaSwapTransactor struct

+ func NewMetaSwapTransactor(address common.Address, transactor bind.ContractTransactor) (*MetaSwapTransactor, error)

+ func (_MetaSwap *MetaSwapTransactor) AddLiquidity(opts *bind.TransactOpts, amounts []*big.Int, minToMint *big.Int, ...) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactor) Initialize(opts *bind.TransactOpts, _pooledTokens []common.Address, decimals []uint8, ...) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactor) InitializeMetaSwap(opts *bind.TransactOpts, _pooledTokens []common.Address, decimals []uint8, ...) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactor) RampA(opts *bind.TransactOpts, futureA *big.Int, futureTime *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactor) RemoveLiquidity(opts *bind.TransactOpts, amount *big.Int, minAmounts []*big.Int, ...) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactor) RemoveLiquidityImbalance(opts *bind.TransactOpts, amounts []*big.Int, maxBurnAmount *big.Int, ...) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactor) RemoveLiquidityOneToken(opts *bind.TransactOpts, tokenAmount *big.Int, tokenIndex uint8, ...) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactor) SetAdminFee(opts *bind.TransactOpts, newAdminFee *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactor) SetSwapFee(opts *bind.TransactOpts, newSwapFee *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactor) StopRampA(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactor) Swap(opts *bind.TransactOpts, tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, ...) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactor) SwapUnderlying(opts *bind.TransactOpts, tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, ...) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactor) WithdrawAdminFees(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MetaSwapTransactorRaw struct

+ Contract *MetaSwapTransactor

+ func (_MetaSwap *MetaSwapTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MetaSwapTransactorSession struct

+ Contract *MetaSwapTransactor

+ TransactOpts bind.TransactOpts

+ func (_MetaSwap *MetaSwapTransactorSession) AddLiquidity(amounts []*big.Int, minToMint *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorSession) Initialize(_pooledTokens []common.Address, decimals []uint8, lpTokenName string, ...) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorSession) InitializeMetaSwap(_pooledTokens []common.Address, decimals []uint8, lpTokenName string, ...) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorSession) Pause() (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorSession) RampA(futureA *big.Int, futureTime *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorSession) RemoveLiquidity(amount *big.Int, minAmounts []*big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorSession) RemoveLiquidityImbalance(amounts []*big.Int, maxBurnAmount *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorSession) RemoveLiquidityOneToken(tokenAmount *big.Int, tokenIndex uint8, minAmount *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorSession) SetAdminFee(newAdminFee *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorSession) SetSwapFee(newSwapFee *big.Int) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorSession) StopRampA() (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorSession) Swap(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, minDy *big.Int, ...) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorSession) SwapUnderlying(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, minDy *big.Int, ...) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorSession) Unpause() (*types.Transaction, error)

+ func (_MetaSwap *MetaSwapTransactorSession) WithdrawAdminFees() (*types.Transaction, error)

+ type MetaSwapUnpaused struct

+ Account common.Address

+ Raw types.Log

+ type MetaSwapUnpausedIterator struct

+ Event *MetaSwapUnpaused

+ func (it *MetaSwapUnpausedIterator) Close() error

+ func (it *MetaSwapUnpausedIterator) Error() error

+ func (it *MetaSwapUnpausedIterator) Next() bool

+ type MetaSwapUtils struct

+ func DeployMetaSwapUtils(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *MetaSwapUtils, error)

+ func NewMetaSwapUtils(address common.Address, backend bind.ContractBackend) (*MetaSwapUtils, error)

+ type MetaSwapUtilsAddLiquidity struct

+ Fees []*big.Int

+ Invariant *big.Int

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokenAmounts []*big.Int

+ type MetaSwapUtilsAddLiquidityIterator struct

+ Event *MetaSwapUtilsAddLiquidity

+ func (it *MetaSwapUtilsAddLiquidityIterator) Close() error

+ func (it *MetaSwapUtilsAddLiquidityIterator) Error() error

+ func (it *MetaSwapUtilsAddLiquidityIterator) Next() bool

+ type MetaSwapUtilsCaller struct

+ func NewMetaSwapUtilsCaller(address common.Address, caller bind.ContractCaller) (*MetaSwapUtilsCaller, error)

+ func (_MetaSwapUtils *MetaSwapUtilsCaller) BASECACHEEXPIRETIME(opts *bind.CallOpts) (*big.Int, error)

+ func (_MetaSwapUtils *MetaSwapUtilsCaller) BASEVIRTUALPRICEPRECISION(opts *bind.CallOpts) (*big.Int, error)

+ type MetaSwapUtilsCallerRaw struct

+ Contract *MetaSwapUtilsCaller

+ func (_MetaSwapUtils *MetaSwapUtilsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type MetaSwapUtilsCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *MetaSwapUtilsCaller

+ func (_MetaSwapUtils *MetaSwapUtilsCallerSession) BASECACHEEXPIRETIME() (*big.Int, error)

+ func (_MetaSwapUtils *MetaSwapUtilsCallerSession) BASEVIRTUALPRICEPRECISION() (*big.Int, error)

+ type MetaSwapUtilsFilterer struct

+ func NewMetaSwapUtilsFilterer(address common.Address, filterer bind.ContractFilterer) (*MetaSwapUtilsFilterer, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) FilterAddLiquidity(opts *bind.FilterOpts, provider []common.Address) (*MetaSwapUtilsAddLiquidityIterator, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) FilterNewAdminFee(opts *bind.FilterOpts) (*MetaSwapUtilsNewAdminFeeIterator, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) FilterNewSwapFee(opts *bind.FilterOpts) (*MetaSwapUtilsNewSwapFeeIterator, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) FilterRemoveLiquidityImbalance(opts *bind.FilterOpts, provider []common.Address) (*MetaSwapUtilsRemoveLiquidityImbalanceIterator, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) FilterRemoveLiquidityOne(opts *bind.FilterOpts, provider []common.Address) (*MetaSwapUtilsRemoveLiquidityOneIterator, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) FilterTokenSwap(opts *bind.FilterOpts, buyer []common.Address) (*MetaSwapUtilsTokenSwapIterator, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) FilterTokenSwapUnderlying(opts *bind.FilterOpts, buyer []common.Address) (*MetaSwapUtilsTokenSwapUnderlyingIterator, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) ParseAddLiquidity(log types.Log) (*MetaSwapUtilsAddLiquidity, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) ParseNewAdminFee(log types.Log) (*MetaSwapUtilsNewAdminFee, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) ParseNewSwapFee(log types.Log) (*MetaSwapUtilsNewSwapFee, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) ParseRemoveLiquidityImbalance(log types.Log) (*MetaSwapUtilsRemoveLiquidityImbalance, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) ParseRemoveLiquidityOne(log types.Log) (*MetaSwapUtilsRemoveLiquidityOne, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) ParseTokenSwap(log types.Log) (*MetaSwapUtilsTokenSwap, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) ParseTokenSwapUnderlying(log types.Log) (*MetaSwapUtilsTokenSwapUnderlying, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) WatchAddLiquidity(opts *bind.WatchOpts, sink chan<- *MetaSwapUtilsAddLiquidity, ...) (event.Subscription, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) WatchNewAdminFee(opts *bind.WatchOpts, sink chan<- *MetaSwapUtilsNewAdminFee) (event.Subscription, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) WatchNewSwapFee(opts *bind.WatchOpts, sink chan<- *MetaSwapUtilsNewSwapFee) (event.Subscription, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) WatchRemoveLiquidityImbalance(opts *bind.WatchOpts, sink chan<- *MetaSwapUtilsRemoveLiquidityImbalance, ...) (event.Subscription, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) WatchRemoveLiquidityOne(opts *bind.WatchOpts, sink chan<- *MetaSwapUtilsRemoveLiquidityOne, ...) (event.Subscription, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) WatchTokenSwap(opts *bind.WatchOpts, sink chan<- *MetaSwapUtilsTokenSwap, ...) (event.Subscription, error)

+ func (_MetaSwapUtils *MetaSwapUtilsFilterer) WatchTokenSwapUnderlying(opts *bind.WatchOpts, sink chan<- *MetaSwapUtilsTokenSwapUnderlying, ...) (event.Subscription, error)

+ type MetaSwapUtilsNewAdminFee struct

+ NewAdminFee *big.Int

+ Raw types.Log

+ type MetaSwapUtilsNewAdminFeeIterator struct

+ Event *MetaSwapUtilsNewAdminFee

+ func (it *MetaSwapUtilsNewAdminFeeIterator) Close() error

+ func (it *MetaSwapUtilsNewAdminFeeIterator) Error() error

+ func (it *MetaSwapUtilsNewAdminFeeIterator) Next() bool

+ type MetaSwapUtilsNewSwapFee struct

+ NewSwapFee *big.Int

+ Raw types.Log

+ type MetaSwapUtilsNewSwapFeeIterator struct

+ Event *MetaSwapUtilsNewSwapFee

+ func (it *MetaSwapUtilsNewSwapFeeIterator) Close() error

+ func (it *MetaSwapUtilsNewSwapFeeIterator) Error() error

+ func (it *MetaSwapUtilsNewSwapFeeIterator) Next() bool

+ type MetaSwapUtilsRaw struct

+ Contract *MetaSwapUtils

+ func (_MetaSwapUtils *MetaSwapUtilsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_MetaSwapUtils *MetaSwapUtilsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_MetaSwapUtils *MetaSwapUtilsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MetaSwapUtilsRemoveLiquidityImbalance struct

+ Fees []*big.Int

+ Invariant *big.Int

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokenAmounts []*big.Int

+ type MetaSwapUtilsRemoveLiquidityImbalanceIterator struct

+ Event *MetaSwapUtilsRemoveLiquidityImbalance

+ func (it *MetaSwapUtilsRemoveLiquidityImbalanceIterator) Close() error

+ func (it *MetaSwapUtilsRemoveLiquidityImbalanceIterator) Error() error

+ func (it *MetaSwapUtilsRemoveLiquidityImbalanceIterator) Next() bool

+ type MetaSwapUtilsRemoveLiquidityOne struct

+ BoughtId *big.Int

+ LpTokenAmount *big.Int

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokensBought *big.Int

+ type MetaSwapUtilsRemoveLiquidityOneIterator struct

+ Event *MetaSwapUtilsRemoveLiquidityOne

+ func (it *MetaSwapUtilsRemoveLiquidityOneIterator) Close() error

+ func (it *MetaSwapUtilsRemoveLiquidityOneIterator) Error() error

+ func (it *MetaSwapUtilsRemoveLiquidityOneIterator) Next() bool

+ type MetaSwapUtilsSession struct

+ CallOpts bind.CallOpts

+ Contract *MetaSwapUtils

+ TransactOpts bind.TransactOpts

+ func (_MetaSwapUtils *MetaSwapUtilsSession) BASECACHEEXPIRETIME() (*big.Int, error)

+ func (_MetaSwapUtils *MetaSwapUtilsSession) BASEVIRTUALPRICEPRECISION() (*big.Int, error)

+ type MetaSwapUtilsTokenSwap struct

+ BoughtId *big.Int

+ Buyer common.Address

+ Raw types.Log

+ SoldId *big.Int

+ TokensBought *big.Int

+ TokensSold *big.Int

+ type MetaSwapUtilsTokenSwapIterator struct

+ Event *MetaSwapUtilsTokenSwap

+ func (it *MetaSwapUtilsTokenSwapIterator) Close() error

+ func (it *MetaSwapUtilsTokenSwapIterator) Error() error

+ func (it *MetaSwapUtilsTokenSwapIterator) Next() bool

+ type MetaSwapUtilsTokenSwapUnderlying struct

+ BoughtId *big.Int

+ Buyer common.Address

+ Raw types.Log

+ SoldId *big.Int

+ TokensBought *big.Int

+ TokensSold *big.Int

+ type MetaSwapUtilsTokenSwapUnderlyingIterator struct

+ Event *MetaSwapUtilsTokenSwapUnderlying

+ func (it *MetaSwapUtilsTokenSwapUnderlyingIterator) Close() error

+ func (it *MetaSwapUtilsTokenSwapUnderlyingIterator) Error() error

+ func (it *MetaSwapUtilsTokenSwapUnderlyingIterator) Next() bool

+ type MetaSwapUtilsTransactor struct

+ func NewMetaSwapUtilsTransactor(address common.Address, transactor bind.ContractTransactor) (*MetaSwapUtilsTransactor, error)

+ type MetaSwapUtilsTransactorRaw struct

+ Contract *MetaSwapUtilsTransactor

+ func (_MetaSwapUtils *MetaSwapUtilsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_MetaSwapUtils *MetaSwapUtilsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type MetaSwapUtilsTransactorSession struct

+ Contract *MetaSwapUtilsTransactor

+ TransactOpts bind.TransactOpts

+ type OwnableUpgradeable struct

+ func NewOwnableUpgradeable(address common.Address, backend bind.ContractBackend) (*OwnableUpgradeable, error)

+ type OwnableUpgradeableCaller struct

+ func NewOwnableUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*OwnableUpgradeableCaller, error)

+ func (_OwnableUpgradeable *OwnableUpgradeableCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ type OwnableUpgradeableCallerRaw struct

+ Contract *OwnableUpgradeableCaller

+ func (_OwnableUpgradeable *OwnableUpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type OwnableUpgradeableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OwnableUpgradeableCaller

+ func (_OwnableUpgradeable *OwnableUpgradeableCallerSession) Owner() (common.Address, error)

+ type OwnableUpgradeableFilterer struct

+ func NewOwnableUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableUpgradeableFilterer, error)

+ func (_OwnableUpgradeable *OwnableUpgradeableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*OwnableUpgradeableOwnershipTransferredIterator, error)

+ func (_OwnableUpgradeable *OwnableUpgradeableFilterer) ParseOwnershipTransferred(log types.Log) (*OwnableUpgradeableOwnershipTransferred, error)

+ func (_OwnableUpgradeable *OwnableUpgradeableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableUpgradeableOwnershipTransferred, ...) (event.Subscription, error)

+ type OwnableUpgradeableOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type OwnableUpgradeableOwnershipTransferredIterator struct

+ Event *OwnableUpgradeableOwnershipTransferred

+ func (it *OwnableUpgradeableOwnershipTransferredIterator) Close() error

+ func (it *OwnableUpgradeableOwnershipTransferredIterator) Error() error

+ func (it *OwnableUpgradeableOwnershipTransferredIterator) Next() bool

+ type OwnableUpgradeableRaw struct

+ Contract *OwnableUpgradeable

+ func (_OwnableUpgradeable *OwnableUpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_OwnableUpgradeable *OwnableUpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_OwnableUpgradeable *OwnableUpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OwnableUpgradeableSession struct

+ CallOpts bind.CallOpts

+ Contract *OwnableUpgradeable

+ TransactOpts bind.TransactOpts

+ func (_OwnableUpgradeable *OwnableUpgradeableSession) Owner() (common.Address, error)

+ func (_OwnableUpgradeable *OwnableUpgradeableSession) RenounceOwnership() (*types.Transaction, error)

+ func (_OwnableUpgradeable *OwnableUpgradeableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type OwnableUpgradeableTransactor struct

+ func NewOwnableUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableUpgradeableTransactor, error)

+ func (_OwnableUpgradeable *OwnableUpgradeableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OwnableUpgradeable *OwnableUpgradeableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ type OwnableUpgradeableTransactorRaw struct

+ Contract *OwnableUpgradeableTransactor

+ func (_OwnableUpgradeable *OwnableUpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_OwnableUpgradeable *OwnableUpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OwnableUpgradeableTransactorSession struct

+ Contract *OwnableUpgradeableTransactor

+ TransactOpts bind.TransactOpts

+ func (_OwnableUpgradeable *OwnableUpgradeableTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_OwnableUpgradeable *OwnableUpgradeableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ type OwnerPausableUpgradeable struct

+ func NewOwnerPausableUpgradeable(address common.Address, backend bind.ContractBackend) (*OwnerPausableUpgradeable, error)

+ type OwnerPausableUpgradeableCaller struct

+ func NewOwnerPausableUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*OwnerPausableUpgradeableCaller, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableCaller) Paused(opts *bind.CallOpts) (bool, error)

+ type OwnerPausableUpgradeableCallerRaw struct

+ Contract *OwnerPausableUpgradeableCaller

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type OwnerPausableUpgradeableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *OwnerPausableUpgradeableCaller

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableCallerSession) Owner() (common.Address, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableCallerSession) Paused() (bool, error)

+ type OwnerPausableUpgradeableFilterer struct

+ func NewOwnerPausableUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnerPausableUpgradeableFilterer, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*OwnerPausableUpgradeableOwnershipTransferredIterator, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableFilterer) FilterPaused(opts *bind.FilterOpts) (*OwnerPausableUpgradeablePausedIterator, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableFilterer) FilterUnpaused(opts *bind.FilterOpts) (*OwnerPausableUpgradeableUnpausedIterator, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableFilterer) ParseOwnershipTransferred(log types.Log) (*OwnerPausableUpgradeableOwnershipTransferred, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableFilterer) ParsePaused(log types.Log) (*OwnerPausableUpgradeablePaused, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableFilterer) ParseUnpaused(log types.Log) (*OwnerPausableUpgradeableUnpaused, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, ...) (event.Subscription, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *OwnerPausableUpgradeablePaused) (event.Subscription, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *OwnerPausableUpgradeableUnpaused) (event.Subscription, error)

+ type OwnerPausableUpgradeableOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type OwnerPausableUpgradeableOwnershipTransferredIterator struct

+ Event *OwnerPausableUpgradeableOwnershipTransferred

+ func (it *OwnerPausableUpgradeableOwnershipTransferredIterator) Close() error

+ func (it *OwnerPausableUpgradeableOwnershipTransferredIterator) Error() error

+ func (it *OwnerPausableUpgradeableOwnershipTransferredIterator) Next() bool

+ type OwnerPausableUpgradeablePaused struct

+ Account common.Address

+ Raw types.Log

+ type OwnerPausableUpgradeablePausedIterator struct

+ Event *OwnerPausableUpgradeablePaused

+ func (it *OwnerPausableUpgradeablePausedIterator) Close() error

+ func (it *OwnerPausableUpgradeablePausedIterator) Error() error

+ func (it *OwnerPausableUpgradeablePausedIterator) Next() bool

+ type OwnerPausableUpgradeableRaw struct

+ Contract *OwnerPausableUpgradeable

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OwnerPausableUpgradeableSession struct

+ CallOpts bind.CallOpts

+ Contract *OwnerPausableUpgradeable

+ TransactOpts bind.TransactOpts

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableSession) Owner() (common.Address, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableSession) Pause() (*types.Transaction, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableSession) Paused() (bool, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableSession) RenounceOwnership() (*types.Transaction, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableSession) Unpause() (*types.Transaction, error)

+ type OwnerPausableUpgradeableTransactor struct

+ func NewOwnerPausableUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnerPausableUpgradeableTransactor, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OwnerPausableUpgradeableTransactorRaw struct

+ Contract *OwnerPausableUpgradeableTransactor

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type OwnerPausableUpgradeableTransactorSession struct

+ Contract *OwnerPausableUpgradeableTransactor

+ TransactOpts bind.TransactOpts

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableTransactorSession) Pause() (*types.Transaction, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_OwnerPausableUpgradeable *OwnerPausableUpgradeableTransactorSession) Unpause() (*types.Transaction, error)

+ type OwnerPausableUpgradeableUnpaused struct

+ Account common.Address

+ Raw types.Log

+ type OwnerPausableUpgradeableUnpausedIterator struct

+ Event *OwnerPausableUpgradeableUnpaused

+ func (it *OwnerPausableUpgradeableUnpausedIterator) Close() error

+ func (it *OwnerPausableUpgradeableUnpausedIterator) Error() error

+ func (it *OwnerPausableUpgradeableUnpausedIterator) Next() bool

+ type PausableUpgradeable struct

+ func NewPausableUpgradeable(address common.Address, backend bind.ContractBackend) (*PausableUpgradeable, error)

+ type PausableUpgradeableCaller struct

+ func NewPausableUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*PausableUpgradeableCaller, error)

+ func (_PausableUpgradeable *PausableUpgradeableCaller) Paused(opts *bind.CallOpts) (bool, error)

+ type PausableUpgradeableCallerRaw struct

+ Contract *PausableUpgradeableCaller

+ func (_PausableUpgradeable *PausableUpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type PausableUpgradeableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *PausableUpgradeableCaller

+ func (_PausableUpgradeable *PausableUpgradeableCallerSession) Paused() (bool, error)

+ type PausableUpgradeableFilterer struct

+ func NewPausableUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*PausableUpgradeableFilterer, error)

+ func (_PausableUpgradeable *PausableUpgradeableFilterer) FilterPaused(opts *bind.FilterOpts) (*PausableUpgradeablePausedIterator, error)

+ func (_PausableUpgradeable *PausableUpgradeableFilterer) FilterUnpaused(opts *bind.FilterOpts) (*PausableUpgradeableUnpausedIterator, error)

+ func (_PausableUpgradeable *PausableUpgradeableFilterer) ParsePaused(log types.Log) (*PausableUpgradeablePaused, error)

+ func (_PausableUpgradeable *PausableUpgradeableFilterer) ParseUnpaused(log types.Log) (*PausableUpgradeableUnpaused, error)

+ func (_PausableUpgradeable *PausableUpgradeableFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *PausableUpgradeablePaused) (event.Subscription, error)

+ func (_PausableUpgradeable *PausableUpgradeableFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *PausableUpgradeableUnpaused) (event.Subscription, error)

+ type PausableUpgradeablePaused struct

+ Account common.Address

+ Raw types.Log

+ type PausableUpgradeablePausedIterator struct

+ Event *PausableUpgradeablePaused

+ func (it *PausableUpgradeablePausedIterator) Close() error

+ func (it *PausableUpgradeablePausedIterator) Error() error

+ func (it *PausableUpgradeablePausedIterator) Next() bool

+ type PausableUpgradeableRaw struct

+ Contract *PausableUpgradeable

+ func (_PausableUpgradeable *PausableUpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_PausableUpgradeable *PausableUpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_PausableUpgradeable *PausableUpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PausableUpgradeableSession struct

+ CallOpts bind.CallOpts

+ Contract *PausableUpgradeable

+ TransactOpts bind.TransactOpts

+ func (_PausableUpgradeable *PausableUpgradeableSession) Paused() (bool, error)

+ type PausableUpgradeableTransactor struct

+ func NewPausableUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*PausableUpgradeableTransactor, error)

+ type PausableUpgradeableTransactorRaw struct

+ Contract *PausableUpgradeableTransactor

+ func (_PausableUpgradeable *PausableUpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_PausableUpgradeable *PausableUpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type PausableUpgradeableTransactorSession struct

+ Contract *PausableUpgradeableTransactor

+ TransactOpts bind.TransactOpts

+ type PausableUpgradeableUnpaused struct

+ Account common.Address

+ Raw types.Log

+ type PausableUpgradeableUnpausedIterator struct

+ Event *PausableUpgradeableUnpaused

+ func (it *PausableUpgradeableUnpausedIterator) Close() error

+ func (it *PausableUpgradeableUnpausedIterator) Error() error

+ func (it *PausableUpgradeableUnpausedIterator) Next() bool

+ type ReentrancyGuardUpgradeable struct

+ func NewReentrancyGuardUpgradeable(address common.Address, backend bind.ContractBackend) (*ReentrancyGuardUpgradeable, error)

+ type ReentrancyGuardUpgradeableCaller struct

+ func NewReentrancyGuardUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*ReentrancyGuardUpgradeableCaller, error)

+ type ReentrancyGuardUpgradeableCallerRaw struct

+ Contract *ReentrancyGuardUpgradeableCaller

+ func (_ReentrancyGuardUpgradeable *ReentrancyGuardUpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type ReentrancyGuardUpgradeableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *ReentrancyGuardUpgradeableCaller

+ type ReentrancyGuardUpgradeableFilterer struct

+ func NewReentrancyGuardUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*ReentrancyGuardUpgradeableFilterer, error)

+ type ReentrancyGuardUpgradeableRaw struct

+ Contract *ReentrancyGuardUpgradeable

+ func (_ReentrancyGuardUpgradeable *ReentrancyGuardUpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_ReentrancyGuardUpgradeable *ReentrancyGuardUpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ReentrancyGuardUpgradeable *ReentrancyGuardUpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ReentrancyGuardUpgradeableSession struct

+ CallOpts bind.CallOpts

+ Contract *ReentrancyGuardUpgradeable

+ TransactOpts bind.TransactOpts

+ type ReentrancyGuardUpgradeableTransactor struct

+ func NewReentrancyGuardUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*ReentrancyGuardUpgradeableTransactor, error)

+ type ReentrancyGuardUpgradeableTransactorRaw struct

+ Contract *ReentrancyGuardUpgradeableTransactor

+ func (_ReentrancyGuardUpgradeable *ReentrancyGuardUpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_ReentrancyGuardUpgradeable *ReentrancyGuardUpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type ReentrancyGuardUpgradeableTransactorSession struct

+ Contract *ReentrancyGuardUpgradeableTransactor

+ TransactOpts bind.TransactOpts

+ type SafeERC20 struct

+ func DeploySafeERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeERC20, error)

+ func NewSafeERC20(address common.Address, backend bind.ContractBackend) (*SafeERC20, error)

+ type SafeERC20Caller struct

+ func NewSafeERC20Caller(address common.Address, caller bind.ContractCaller) (*SafeERC20Caller, error)

+ type SafeERC20CallerRaw struct

+ Contract *SafeERC20Caller

+ func (_SafeERC20 *SafeERC20CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SafeERC20CallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeERC20Caller

+ type SafeERC20Filterer struct

+ func NewSafeERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*SafeERC20Filterer, error)

+ type SafeERC20Raw struct

+ Contract *SafeERC20

+ func (_SafeERC20 *SafeERC20Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_SafeERC20 *SafeERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_SafeERC20 *SafeERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeERC20Session struct

+ CallOpts bind.CallOpts

+ Contract *SafeERC20

+ TransactOpts bind.TransactOpts

+ type SafeERC20Transactor struct

+ func NewSafeERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*SafeERC20Transactor, error)

+ type SafeERC20TransactorRaw struct

+ Contract *SafeERC20Transactor

+ func (_SafeERC20 *SafeERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_SafeERC20 *SafeERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeERC20TransactorSession struct

+ Contract *SafeERC20Transactor

+ TransactOpts bind.TransactOpts

+ type SafeMath struct

+ func DeploySafeMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeMath, error)

+ func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error)

+ type SafeMathCaller struct

+ func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error)

+ type SafeMathCallerRaw struct

+ Contract *SafeMathCaller

+ func (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SafeMathCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeMathCaller

+ type SafeMathFilterer struct

+ func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error)

+ type SafeMathRaw struct

+ Contract *SafeMath

+ func (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_SafeMath *SafeMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeMathSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeMath

+ TransactOpts bind.TransactOpts

+ type SafeMathTransactor struct

+ func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error)

+ type SafeMathTransactorRaw struct

+ Contract *SafeMathTransactor

+ func (_SafeMath *SafeMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeMathTransactorSession struct

+ Contract *SafeMathTransactor

+ TransactOpts bind.TransactOpts

+ type SafeMathUpgradeable struct

+ func DeploySafeMathUpgradeable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeMathUpgradeable, error)

+ func NewSafeMathUpgradeable(address common.Address, backend bind.ContractBackend) (*SafeMathUpgradeable, error)

+ type SafeMathUpgradeableCaller struct

+ func NewSafeMathUpgradeableCaller(address common.Address, caller bind.ContractCaller) (*SafeMathUpgradeableCaller, error)

+ type SafeMathUpgradeableCallerRaw struct

+ Contract *SafeMathUpgradeableCaller

+ func (_SafeMathUpgradeable *SafeMathUpgradeableCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SafeMathUpgradeableCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeMathUpgradeableCaller

+ type SafeMathUpgradeableFilterer struct

+ func NewSafeMathUpgradeableFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathUpgradeableFilterer, error)

+ type SafeMathUpgradeableRaw struct

+ Contract *SafeMathUpgradeable

+ func (_SafeMathUpgradeable *SafeMathUpgradeableRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_SafeMathUpgradeable *SafeMathUpgradeableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_SafeMathUpgradeable *SafeMathUpgradeableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeMathUpgradeableSession struct

+ CallOpts bind.CallOpts

+ Contract *SafeMathUpgradeable

+ TransactOpts bind.TransactOpts

+ type SafeMathUpgradeableTransactor struct

+ func NewSafeMathUpgradeableTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathUpgradeableTransactor, error)

+ type SafeMathUpgradeableTransactorRaw struct

+ Contract *SafeMathUpgradeableTransactor

+ func (_SafeMathUpgradeable *SafeMathUpgradeableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_SafeMathUpgradeable *SafeMathUpgradeableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SafeMathUpgradeableTransactorSession struct

+ Contract *SafeMathUpgradeableTransactor

+ TransactOpts bind.TransactOpts

+ type Swap struct

+ func DeploySwap(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Swap, error)

+ func NewSwap(address common.Address, backend bind.ContractBackend) (*Swap, error)

+ type SwapAddLiquidity struct

+ Fees []*big.Int

+ Invariant *big.Int

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokenAmounts []*big.Int

+ type SwapAddLiquidityIterator struct

+ Event *SwapAddLiquidity

+ func (it *SwapAddLiquidityIterator) Close() error

+ func (it *SwapAddLiquidityIterator) Error() error

+ func (it *SwapAddLiquidityIterator) Next() bool

+ type SwapCaller struct

+ func NewSwapCaller(address common.Address, caller bind.ContractCaller) (*SwapCaller, error)

+ func (_Swap *SwapCaller) CalculateRemoveLiquidity(opts *bind.CallOpts, amount *big.Int) ([]*big.Int, error)

+ func (_Swap *SwapCaller) CalculateRemoveLiquidityOneToken(opts *bind.CallOpts, tokenAmount *big.Int, tokenIndex uint8) (*big.Int, error)

+ func (_Swap *SwapCaller) CalculateSwap(opts *bind.CallOpts, tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_Swap *SwapCaller) CalculateTokenAmount(opts *bind.CallOpts, amounts []*big.Int, deposit bool) (*big.Int, error)

+ func (_Swap *SwapCaller) GetA(opts *bind.CallOpts) (*big.Int, error)

+ func (_Swap *SwapCaller) GetAPrecise(opts *bind.CallOpts) (*big.Int, error)

+ func (_Swap *SwapCaller) GetAdminBalance(opts *bind.CallOpts, index *big.Int) (*big.Int, error)

+ func (_Swap *SwapCaller) GetToken(opts *bind.CallOpts, index uint8) (common.Address, error)

+ func (_Swap *SwapCaller) GetTokenBalance(opts *bind.CallOpts, index uint8) (*big.Int, error)

+ func (_Swap *SwapCaller) GetTokenIndex(opts *bind.CallOpts, tokenAddress common.Address) (uint8, error)

+ func (_Swap *SwapCaller) GetVirtualPrice(opts *bind.CallOpts) (*big.Int, error)

+ func (_Swap *SwapCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_Swap *SwapCaller) Paused(opts *bind.CallOpts) (bool, error)

+ func (_Swap *SwapCaller) SwapStorage(opts *bind.CallOpts) (struct{ ... }, error)

+ type SwapCallerRaw struct

+ Contract *SwapCaller

+ func (_Swap *SwapCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SwapCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SwapCaller

+ func (_Swap *SwapCallerSession) CalculateRemoveLiquidity(amount *big.Int) ([]*big.Int, error)

+ func (_Swap *SwapCallerSession) CalculateRemoveLiquidityOneToken(tokenAmount *big.Int, tokenIndex uint8) (*big.Int, error)

+ func (_Swap *SwapCallerSession) CalculateSwap(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_Swap *SwapCallerSession) CalculateTokenAmount(amounts []*big.Int, deposit bool) (*big.Int, error)

+ func (_Swap *SwapCallerSession) GetA() (*big.Int, error)

+ func (_Swap *SwapCallerSession) GetAPrecise() (*big.Int, error)

+ func (_Swap *SwapCallerSession) GetAdminBalance(index *big.Int) (*big.Int, error)

+ func (_Swap *SwapCallerSession) GetToken(index uint8) (common.Address, error)

+ func (_Swap *SwapCallerSession) GetTokenBalance(index uint8) (*big.Int, error)

+ func (_Swap *SwapCallerSession) GetTokenIndex(tokenAddress common.Address) (uint8, error)

+ func (_Swap *SwapCallerSession) GetVirtualPrice() (*big.Int, error)

+ func (_Swap *SwapCallerSession) Owner() (common.Address, error)

+ func (_Swap *SwapCallerSession) Paused() (bool, error)

+ func (_Swap *SwapCallerSession) SwapStorage() (struct{ ... }, error)

+ type SwapFilterer struct

+ func NewSwapFilterer(address common.Address, filterer bind.ContractFilterer) (*SwapFilterer, error)

+ func (_Swap *SwapFilterer) FilterAddLiquidity(opts *bind.FilterOpts, provider []common.Address) (*SwapAddLiquidityIterator, error)

+ func (_Swap *SwapFilterer) FilterNewAdminFee(opts *bind.FilterOpts) (*SwapNewAdminFeeIterator, error)

+ func (_Swap *SwapFilterer) FilterNewSwapFee(opts *bind.FilterOpts) (*SwapNewSwapFeeIterator, error)

+ func (_Swap *SwapFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*SwapOwnershipTransferredIterator, error)

+ func (_Swap *SwapFilterer) FilterPaused(opts *bind.FilterOpts) (*SwapPausedIterator, error)

+ func (_Swap *SwapFilterer) FilterRampA(opts *bind.FilterOpts) (*SwapRampAIterator, error)

+ func (_Swap *SwapFilterer) FilterRemoveLiquidity(opts *bind.FilterOpts, provider []common.Address) (*SwapRemoveLiquidityIterator, error)

+ func (_Swap *SwapFilterer) FilterRemoveLiquidityImbalance(opts *bind.FilterOpts, provider []common.Address) (*SwapRemoveLiquidityImbalanceIterator, error)

+ func (_Swap *SwapFilterer) FilterRemoveLiquidityOne(opts *bind.FilterOpts, provider []common.Address) (*SwapRemoveLiquidityOneIterator, error)

+ func (_Swap *SwapFilterer) FilterStopRampA(opts *bind.FilterOpts) (*SwapStopRampAIterator, error)

+ func (_Swap *SwapFilterer) FilterTokenSwap(opts *bind.FilterOpts, buyer []common.Address) (*SwapTokenSwapIterator, error)

+ func (_Swap *SwapFilterer) FilterUnpaused(opts *bind.FilterOpts) (*SwapUnpausedIterator, error)

+ func (_Swap *SwapFilterer) ParseAddLiquidity(log types.Log) (*SwapAddLiquidity, error)

+ func (_Swap *SwapFilterer) ParseNewAdminFee(log types.Log) (*SwapNewAdminFee, error)

+ func (_Swap *SwapFilterer) ParseNewSwapFee(log types.Log) (*SwapNewSwapFee, error)

+ func (_Swap *SwapFilterer) ParseOwnershipTransferred(log types.Log) (*SwapOwnershipTransferred, error)

+ func (_Swap *SwapFilterer) ParsePaused(log types.Log) (*SwapPaused, error)

+ func (_Swap *SwapFilterer) ParseRampA(log types.Log) (*SwapRampA, error)

+ func (_Swap *SwapFilterer) ParseRemoveLiquidity(log types.Log) (*SwapRemoveLiquidity, error)

+ func (_Swap *SwapFilterer) ParseRemoveLiquidityImbalance(log types.Log) (*SwapRemoveLiquidityImbalance, error)

+ func (_Swap *SwapFilterer) ParseRemoveLiquidityOne(log types.Log) (*SwapRemoveLiquidityOne, error)

+ func (_Swap *SwapFilterer) ParseStopRampA(log types.Log) (*SwapStopRampA, error)

+ func (_Swap *SwapFilterer) ParseTokenSwap(log types.Log) (*SwapTokenSwap, error)

+ func (_Swap *SwapFilterer) ParseUnpaused(log types.Log) (*SwapUnpaused, error)

+ func (_Swap *SwapFilterer) WatchAddLiquidity(opts *bind.WatchOpts, sink chan<- *SwapAddLiquidity, provider []common.Address) (event.Subscription, error)

+ func (_Swap *SwapFilterer) WatchNewAdminFee(opts *bind.WatchOpts, sink chan<- *SwapNewAdminFee) (event.Subscription, error)

+ func (_Swap *SwapFilterer) WatchNewSwapFee(opts *bind.WatchOpts, sink chan<- *SwapNewSwapFee) (event.Subscription, error)

+ func (_Swap *SwapFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *SwapOwnershipTransferred, ...) (event.Subscription, error)

+ func (_Swap *SwapFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *SwapPaused) (event.Subscription, error)

+ func (_Swap *SwapFilterer) WatchRampA(opts *bind.WatchOpts, sink chan<- *SwapRampA) (event.Subscription, error)

+ func (_Swap *SwapFilterer) WatchRemoveLiquidity(opts *bind.WatchOpts, sink chan<- *SwapRemoveLiquidity, ...) (event.Subscription, error)

+ func (_Swap *SwapFilterer) WatchRemoveLiquidityImbalance(opts *bind.WatchOpts, sink chan<- *SwapRemoveLiquidityImbalance, ...) (event.Subscription, error)

+ func (_Swap *SwapFilterer) WatchRemoveLiquidityOne(opts *bind.WatchOpts, sink chan<- *SwapRemoveLiquidityOne, ...) (event.Subscription, error)

+ func (_Swap *SwapFilterer) WatchStopRampA(opts *bind.WatchOpts, sink chan<- *SwapStopRampA) (event.Subscription, error)

+ func (_Swap *SwapFilterer) WatchTokenSwap(opts *bind.WatchOpts, sink chan<- *SwapTokenSwap, buyer []common.Address) (event.Subscription, error)

+ func (_Swap *SwapFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *SwapUnpaused) (event.Subscription, error)

+ type SwapNewAdminFee struct

+ NewAdminFee *big.Int

+ Raw types.Log

+ type SwapNewAdminFeeIterator struct

+ Event *SwapNewAdminFee

+ func (it *SwapNewAdminFeeIterator) Close() error

+ func (it *SwapNewAdminFeeIterator) Error() error

+ func (it *SwapNewAdminFeeIterator) Next() bool

+ type SwapNewSwapFee struct

+ NewSwapFee *big.Int

+ Raw types.Log

+ type SwapNewSwapFeeIterator struct

+ Event *SwapNewSwapFee

+ func (it *SwapNewSwapFeeIterator) Close() error

+ func (it *SwapNewSwapFeeIterator) Error() error

+ func (it *SwapNewSwapFeeIterator) Next() bool

+ type SwapOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type SwapOwnershipTransferredIterator struct

+ Event *SwapOwnershipTransferred

+ func (it *SwapOwnershipTransferredIterator) Close() error

+ func (it *SwapOwnershipTransferredIterator) Error() error

+ func (it *SwapOwnershipTransferredIterator) Next() bool

+ type SwapPaused struct

+ Account common.Address

+ Raw types.Log

+ type SwapPausedIterator struct

+ Event *SwapPaused

+ func (it *SwapPausedIterator) Close() error

+ func (it *SwapPausedIterator) Error() error

+ func (it *SwapPausedIterator) Next() bool

+ type SwapRampA struct

+ FutureTime *big.Int

+ InitialTime *big.Int

+ NewA *big.Int

+ OldA *big.Int

+ Raw types.Log

+ type SwapRampAIterator struct

+ Event *SwapRampA

+ func (it *SwapRampAIterator) Close() error

+ func (it *SwapRampAIterator) Error() error

+ func (it *SwapRampAIterator) Next() bool

+ type SwapRaw struct

+ Contract *Swap

+ func (_Swap *SwapRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_Swap *SwapRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Swap *SwapRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SwapRemoveLiquidity struct

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokenAmounts []*big.Int

+ type SwapRemoveLiquidityImbalance struct

+ Fees []*big.Int

+ Invariant *big.Int

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokenAmounts []*big.Int

+ type SwapRemoveLiquidityImbalanceIterator struct

+ Event *SwapRemoveLiquidityImbalance

+ func (it *SwapRemoveLiquidityImbalanceIterator) Close() error

+ func (it *SwapRemoveLiquidityImbalanceIterator) Error() error

+ func (it *SwapRemoveLiquidityImbalanceIterator) Next() bool

+ type SwapRemoveLiquidityIterator struct

+ Event *SwapRemoveLiquidity

+ func (it *SwapRemoveLiquidityIterator) Close() error

+ func (it *SwapRemoveLiquidityIterator) Error() error

+ func (it *SwapRemoveLiquidityIterator) Next() bool

+ type SwapRemoveLiquidityOne struct

+ BoughtId *big.Int

+ LpTokenAmount *big.Int

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokensBought *big.Int

+ type SwapRemoveLiquidityOneIterator struct

+ Event *SwapRemoveLiquidityOne

+ func (it *SwapRemoveLiquidityOneIterator) Close() error

+ func (it *SwapRemoveLiquidityOneIterator) Error() error

+ func (it *SwapRemoveLiquidityOneIterator) Next() bool

+ type SwapSession struct

+ CallOpts bind.CallOpts

+ Contract *Swap

+ TransactOpts bind.TransactOpts

+ func (_Swap *SwapSession) AddLiquidity(amounts []*big.Int, minToMint *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapSession) CalculateRemoveLiquidity(amount *big.Int) ([]*big.Int, error)

+ func (_Swap *SwapSession) CalculateRemoveLiquidityOneToken(tokenAmount *big.Int, tokenIndex uint8) (*big.Int, error)

+ func (_Swap *SwapSession) CalculateSwap(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_Swap *SwapSession) CalculateTokenAmount(amounts []*big.Int, deposit bool) (*big.Int, error)

+ func (_Swap *SwapSession) GetA() (*big.Int, error)

+ func (_Swap *SwapSession) GetAPrecise() (*big.Int, error)

+ func (_Swap *SwapSession) GetAdminBalance(index *big.Int) (*big.Int, error)

+ func (_Swap *SwapSession) GetToken(index uint8) (common.Address, error)

+ func (_Swap *SwapSession) GetTokenBalance(index uint8) (*big.Int, error)

+ func (_Swap *SwapSession) GetTokenIndex(tokenAddress common.Address) (uint8, error)

+ func (_Swap *SwapSession) GetVirtualPrice() (*big.Int, error)

+ func (_Swap *SwapSession) Initialize(_pooledTokens []common.Address, decimals []uint8, lpTokenName string, ...) (*types.Transaction, error)

+ func (_Swap *SwapSession) Owner() (common.Address, error)

+ func (_Swap *SwapSession) Pause() (*types.Transaction, error)

+ func (_Swap *SwapSession) Paused() (bool, error)

+ func (_Swap *SwapSession) RampA(futureA *big.Int, futureTime *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapSession) RemoveLiquidity(amount *big.Int, minAmounts []*big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapSession) RemoveLiquidityImbalance(amounts []*big.Int, maxBurnAmount *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapSession) RemoveLiquidityOneToken(tokenAmount *big.Int, tokenIndex uint8, minAmount *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Swap *SwapSession) SetAdminFee(newAdminFee *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapSession) SetSwapFee(newSwapFee *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapSession) StopRampA() (*types.Transaction, error)

+ func (_Swap *SwapSession) Swap(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, minDy *big.Int, ...) (*types.Transaction, error)

+ func (_Swap *SwapSession) SwapStorage() (struct{ ... }, error)

+ func (_Swap *SwapSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_Swap *SwapSession) Unpause() (*types.Transaction, error)

+ func (_Swap *SwapSession) WithdrawAdminFees() (*types.Transaction, error)

+ type SwapStopRampA struct

+ CurrentA *big.Int

+ Raw types.Log

+ Time *big.Int

+ type SwapStopRampAIterator struct

+ Event *SwapStopRampA

+ func (it *SwapStopRampAIterator) Close() error

+ func (it *SwapStopRampAIterator) Error() error

+ func (it *SwapStopRampAIterator) Next() bool

+ type SwapTokenSwap struct

+ BoughtId *big.Int

+ Buyer common.Address

+ Raw types.Log

+ SoldId *big.Int

+ TokensBought *big.Int

+ TokensSold *big.Int

+ type SwapTokenSwapIterator struct

+ Event *SwapTokenSwap

+ func (it *SwapTokenSwapIterator) Close() error

+ func (it *SwapTokenSwapIterator) Error() error

+ func (it *SwapTokenSwapIterator) Next() bool

+ type SwapTransactor struct

+ func NewSwapTransactor(address common.Address, transactor bind.ContractTransactor) (*SwapTransactor, error)

+ func (_Swap *SwapTransactor) AddLiquidity(opts *bind.TransactOpts, amounts []*big.Int, minToMint *big.Int, ...) (*types.Transaction, error)

+ func (_Swap *SwapTransactor) Initialize(opts *bind.TransactOpts, _pooledTokens []common.Address, decimals []uint8, ...) (*types.Transaction, error)

+ func (_Swap *SwapTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Swap *SwapTransactor) RampA(opts *bind.TransactOpts, futureA *big.Int, futureTime *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapTransactor) RemoveLiquidity(opts *bind.TransactOpts, amount *big.Int, minAmounts []*big.Int, ...) (*types.Transaction, error)

+ func (_Swap *SwapTransactor) RemoveLiquidityImbalance(opts *bind.TransactOpts, amounts []*big.Int, maxBurnAmount *big.Int, ...) (*types.Transaction, error)

+ func (_Swap *SwapTransactor) RemoveLiquidityOneToken(opts *bind.TransactOpts, tokenAmount *big.Int, tokenIndex uint8, ...) (*types.Transaction, error)

+ func (_Swap *SwapTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Swap *SwapTransactor) SetAdminFee(opts *bind.TransactOpts, newAdminFee *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapTransactor) SetSwapFee(opts *bind.TransactOpts, newSwapFee *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapTransactor) StopRampA(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Swap *SwapTransactor) Swap(opts *bind.TransactOpts, tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, ...) (*types.Transaction, error)

+ func (_Swap *SwapTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ func (_Swap *SwapTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_Swap *SwapTransactor) WithdrawAdminFees(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SwapTransactorRaw struct

+ Contract *SwapTransactor

+ func (_Swap *SwapTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_Swap *SwapTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SwapTransactorSession struct

+ Contract *SwapTransactor

+ TransactOpts bind.TransactOpts

+ func (_Swap *SwapTransactorSession) AddLiquidity(amounts []*big.Int, minToMint *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapTransactorSession) Initialize(_pooledTokens []common.Address, decimals []uint8, lpTokenName string, ...) (*types.Transaction, error)

+ func (_Swap *SwapTransactorSession) Pause() (*types.Transaction, error)

+ func (_Swap *SwapTransactorSession) RampA(futureA *big.Int, futureTime *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapTransactorSession) RemoveLiquidity(amount *big.Int, minAmounts []*big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapTransactorSession) RemoveLiquidityImbalance(amounts []*big.Int, maxBurnAmount *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapTransactorSession) RemoveLiquidityOneToken(tokenAmount *big.Int, tokenIndex uint8, minAmount *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_Swap *SwapTransactorSession) SetAdminFee(newAdminFee *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapTransactorSession) SetSwapFee(newSwapFee *big.Int) (*types.Transaction, error)

+ func (_Swap *SwapTransactorSession) StopRampA() (*types.Transaction, error)

+ func (_Swap *SwapTransactorSession) Swap(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, minDy *big.Int, ...) (*types.Transaction, error)

+ func (_Swap *SwapTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_Swap *SwapTransactorSession) Unpause() (*types.Transaction, error)

+ func (_Swap *SwapTransactorSession) WithdrawAdminFees() (*types.Transaction, error)

+ type SwapUnpaused struct

+ Account common.Address

+ Raw types.Log

+ type SwapUnpausedIterator struct

+ Event *SwapUnpaused

+ func (it *SwapUnpausedIterator) Close() error

+ func (it *SwapUnpausedIterator) Error() error

+ func (it *SwapUnpausedIterator) Next() bool

+ type SwapUtils struct

+ func DeploySwapUtils(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SwapUtils, error)

+ func NewSwapUtils(address common.Address, backend bind.ContractBackend) (*SwapUtils, error)

+ type SwapUtilsAddLiquidity struct

+ Fees []*big.Int

+ Invariant *big.Int

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokenAmounts []*big.Int

+ type SwapUtilsAddLiquidityIterator struct

+ Event *SwapUtilsAddLiquidity

+ func (it *SwapUtilsAddLiquidityIterator) Close() error

+ func (it *SwapUtilsAddLiquidityIterator) Error() error

+ func (it *SwapUtilsAddLiquidityIterator) Next() bool

+ type SwapUtilsCaller struct

+ func NewSwapUtilsCaller(address common.Address, caller bind.ContractCaller) (*SwapUtilsCaller, error)

+ func (_SwapUtils *SwapUtilsCaller) MAXADMINFEE(opts *bind.CallOpts) (*big.Int, error)

+ func (_SwapUtils *SwapUtilsCaller) MAXSWAPFEE(opts *bind.CallOpts) (*big.Int, error)

+ func (_SwapUtils *SwapUtilsCaller) POOLPRECISIONDECIMALS(opts *bind.CallOpts) (uint8, error)

+ type SwapUtilsCallerRaw struct

+ Contract *SwapUtilsCaller

+ func (_SwapUtils *SwapUtilsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type SwapUtilsCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *SwapUtilsCaller

+ func (_SwapUtils *SwapUtilsCallerSession) MAXADMINFEE() (*big.Int, error)

+ func (_SwapUtils *SwapUtilsCallerSession) MAXSWAPFEE() (*big.Int, error)

+ func (_SwapUtils *SwapUtilsCallerSession) POOLPRECISIONDECIMALS() (uint8, error)

+ type SwapUtilsFilterer struct

+ func NewSwapUtilsFilterer(address common.Address, filterer bind.ContractFilterer) (*SwapUtilsFilterer, error)

+ func (_SwapUtils *SwapUtilsFilterer) FilterAddLiquidity(opts *bind.FilterOpts, provider []common.Address) (*SwapUtilsAddLiquidityIterator, error)

+ func (_SwapUtils *SwapUtilsFilterer) FilterNewAdminFee(opts *bind.FilterOpts) (*SwapUtilsNewAdminFeeIterator, error)

+ func (_SwapUtils *SwapUtilsFilterer) FilterNewSwapFee(opts *bind.FilterOpts) (*SwapUtilsNewSwapFeeIterator, error)

+ func (_SwapUtils *SwapUtilsFilterer) FilterRemoveLiquidity(opts *bind.FilterOpts, provider []common.Address) (*SwapUtilsRemoveLiquidityIterator, error)

+ func (_SwapUtils *SwapUtilsFilterer) FilterRemoveLiquidityImbalance(opts *bind.FilterOpts, provider []common.Address) (*SwapUtilsRemoveLiquidityImbalanceIterator, error)

+ func (_SwapUtils *SwapUtilsFilterer) FilterRemoveLiquidityOne(opts *bind.FilterOpts, provider []common.Address) (*SwapUtilsRemoveLiquidityOneIterator, error)

+ func (_SwapUtils *SwapUtilsFilterer) FilterTokenSwap(opts *bind.FilterOpts, buyer []common.Address) (*SwapUtilsTokenSwapIterator, error)

+ func (_SwapUtils *SwapUtilsFilterer) ParseAddLiquidity(log types.Log) (*SwapUtilsAddLiquidity, error)

+ func (_SwapUtils *SwapUtilsFilterer) ParseNewAdminFee(log types.Log) (*SwapUtilsNewAdminFee, error)

+ func (_SwapUtils *SwapUtilsFilterer) ParseNewSwapFee(log types.Log) (*SwapUtilsNewSwapFee, error)

+ func (_SwapUtils *SwapUtilsFilterer) ParseRemoveLiquidity(log types.Log) (*SwapUtilsRemoveLiquidity, error)

+ func (_SwapUtils *SwapUtilsFilterer) ParseRemoveLiquidityImbalance(log types.Log) (*SwapUtilsRemoveLiquidityImbalance, error)

+ func (_SwapUtils *SwapUtilsFilterer) ParseRemoveLiquidityOne(log types.Log) (*SwapUtilsRemoveLiquidityOne, error)

+ func (_SwapUtils *SwapUtilsFilterer) ParseTokenSwap(log types.Log) (*SwapUtilsTokenSwap, error)

+ func (_SwapUtils *SwapUtilsFilterer) WatchAddLiquidity(opts *bind.WatchOpts, sink chan<- *SwapUtilsAddLiquidity, ...) (event.Subscription, error)

+ func (_SwapUtils *SwapUtilsFilterer) WatchNewAdminFee(opts *bind.WatchOpts, sink chan<- *SwapUtilsNewAdminFee) (event.Subscription, error)

+ func (_SwapUtils *SwapUtilsFilterer) WatchNewSwapFee(opts *bind.WatchOpts, sink chan<- *SwapUtilsNewSwapFee) (event.Subscription, error)

+ func (_SwapUtils *SwapUtilsFilterer) WatchRemoveLiquidity(opts *bind.WatchOpts, sink chan<- *SwapUtilsRemoveLiquidity, ...) (event.Subscription, error)

+ func (_SwapUtils *SwapUtilsFilterer) WatchRemoveLiquidityImbalance(opts *bind.WatchOpts, sink chan<- *SwapUtilsRemoveLiquidityImbalance, ...) (event.Subscription, error)

+ func (_SwapUtils *SwapUtilsFilterer) WatchRemoveLiquidityOne(opts *bind.WatchOpts, sink chan<- *SwapUtilsRemoveLiquidityOne, ...) (event.Subscription, error)

+ func (_SwapUtils *SwapUtilsFilterer) WatchTokenSwap(opts *bind.WatchOpts, sink chan<- *SwapUtilsTokenSwap, buyer []common.Address) (event.Subscription, error)

+ type SwapUtilsNewAdminFee struct

+ NewAdminFee *big.Int

+ Raw types.Log

+ type SwapUtilsNewAdminFeeIterator struct

+ Event *SwapUtilsNewAdminFee

+ func (it *SwapUtilsNewAdminFeeIterator) Close() error

+ func (it *SwapUtilsNewAdminFeeIterator) Error() error

+ func (it *SwapUtilsNewAdminFeeIterator) Next() bool

+ type SwapUtilsNewSwapFee struct

+ NewSwapFee *big.Int

+ Raw types.Log

+ type SwapUtilsNewSwapFeeIterator struct

+ Event *SwapUtilsNewSwapFee

+ func (it *SwapUtilsNewSwapFeeIterator) Close() error

+ func (it *SwapUtilsNewSwapFeeIterator) Error() error

+ func (it *SwapUtilsNewSwapFeeIterator) Next() bool

+ type SwapUtilsRaw struct

+ Contract *SwapUtils

+ func (_SwapUtils *SwapUtilsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_SwapUtils *SwapUtilsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_SwapUtils *SwapUtilsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SwapUtilsRemoveLiquidity struct

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokenAmounts []*big.Int

+ type SwapUtilsRemoveLiquidityImbalance struct

+ Fees []*big.Int

+ Invariant *big.Int

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokenAmounts []*big.Int

+ type SwapUtilsRemoveLiquidityImbalanceIterator struct

+ Event *SwapUtilsRemoveLiquidityImbalance

+ func (it *SwapUtilsRemoveLiquidityImbalanceIterator) Close() error

+ func (it *SwapUtilsRemoveLiquidityImbalanceIterator) Error() error

+ func (it *SwapUtilsRemoveLiquidityImbalanceIterator) Next() bool

+ type SwapUtilsRemoveLiquidityIterator struct

+ Event *SwapUtilsRemoveLiquidity

+ func (it *SwapUtilsRemoveLiquidityIterator) Close() error

+ func (it *SwapUtilsRemoveLiquidityIterator) Error() error

+ func (it *SwapUtilsRemoveLiquidityIterator) Next() bool

+ type SwapUtilsRemoveLiquidityOne struct

+ BoughtId *big.Int

+ LpTokenAmount *big.Int

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokensBought *big.Int

+ type SwapUtilsRemoveLiquidityOneIterator struct

+ Event *SwapUtilsRemoveLiquidityOne

+ func (it *SwapUtilsRemoveLiquidityOneIterator) Close() error

+ func (it *SwapUtilsRemoveLiquidityOneIterator) Error() error

+ func (it *SwapUtilsRemoveLiquidityOneIterator) Next() bool

+ type SwapUtilsSession struct

+ CallOpts bind.CallOpts

+ Contract *SwapUtils

+ TransactOpts bind.TransactOpts

+ func (_SwapUtils *SwapUtilsSession) MAXADMINFEE() (*big.Int, error)

+ func (_SwapUtils *SwapUtilsSession) MAXSWAPFEE() (*big.Int, error)

+ func (_SwapUtils *SwapUtilsSession) POOLPRECISIONDECIMALS() (uint8, error)

+ type SwapUtilsTokenSwap struct

+ BoughtId *big.Int

+ Buyer common.Address

+ Raw types.Log

+ SoldId *big.Int

+ TokensBought *big.Int

+ TokensSold *big.Int

+ type SwapUtilsTokenSwapIterator struct

+ Event *SwapUtilsTokenSwap

+ func (it *SwapUtilsTokenSwapIterator) Close() error

+ func (it *SwapUtilsTokenSwapIterator) Error() error

+ func (it *SwapUtilsTokenSwapIterator) Next() bool

+ type SwapUtilsTransactor struct

+ func NewSwapUtilsTransactor(address common.Address, transactor bind.ContractTransactor) (*SwapUtilsTransactor, error)

+ type SwapUtilsTransactorRaw struct

+ Contract *SwapUtilsTransactor

+ func (_SwapUtils *SwapUtilsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_SwapUtils *SwapUtilsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type SwapUtilsTransactorSession struct

+ Contract *SwapUtilsTransactor

+ TransactOpts bind.TransactOpts

+ type TestMetaSwap struct

+ func DeployTestMetaSwap(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *TestMetaSwap, error)

+ func NewTestMetaSwap(address common.Address, backend bind.ContractBackend) (*TestMetaSwap, error)

+ type TestMetaSwapAddLiquidity struct

+ Fees []*big.Int

+ Invariant *big.Int

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokenAmounts []*big.Int

+ type TestMetaSwapAddLiquidityIterator struct

+ Event *TestMetaSwapAddLiquidity

+ func (it *TestMetaSwapAddLiquidityIterator) Close() error

+ func (it *TestMetaSwapAddLiquidityIterator) Error() error

+ func (it *TestMetaSwapAddLiquidityIterator) Next() bool

+ type TestMetaSwapCaller struct

+ func NewTestMetaSwapCaller(address common.Address, caller bind.ContractCaller) (*TestMetaSwapCaller, error)

+ func (_TestMetaSwap *TestMetaSwapCaller) CalculateRemoveLiquidity(opts *bind.CallOpts, amount *big.Int) ([]*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCaller) CalculateRemoveLiquidityOneToken(opts *bind.CallOpts, tokenAmount *big.Int, tokenIndex uint8) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCaller) CalculateSwap(opts *bind.CallOpts, tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCaller) CalculateSwapUnderlying(opts *bind.CallOpts, tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCaller) CalculateTokenAmount(opts *bind.CallOpts, amounts []*big.Int, deposit bool) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCaller) GetA(opts *bind.CallOpts) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCaller) GetAPrecise(opts *bind.CallOpts) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCaller) GetAdminBalance(opts *bind.CallOpts, index *big.Int) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCaller) GetToken(opts *bind.CallOpts, index uint8) (common.Address, error)

+ func (_TestMetaSwap *TestMetaSwapCaller) GetTokenBalance(opts *bind.CallOpts, index uint8) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCaller) GetTokenIndex(opts *bind.CallOpts, tokenAddress common.Address) (uint8, error)

+ func (_TestMetaSwap *TestMetaSwapCaller) GetVirtualPrice(opts *bind.CallOpts) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCaller) MetaSwapStorage(opts *bind.CallOpts) (struct{ ... }, error)

+ func (_TestMetaSwap *TestMetaSwapCaller) Owner(opts *bind.CallOpts) (common.Address, error)

+ func (_TestMetaSwap *TestMetaSwapCaller) Paused(opts *bind.CallOpts) (bool, error)

+ func (_TestMetaSwap *TestMetaSwapCaller) SwapStorage(opts *bind.CallOpts) (struct{ ... }, error)

+ type TestMetaSwapCallerRaw struct

+ Contract *TestMetaSwapCaller

+ func (_TestMetaSwap *TestMetaSwapCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ type TestMetaSwapCallerSession struct

+ CallOpts bind.CallOpts

+ Contract *TestMetaSwapCaller

+ func (_TestMetaSwap *TestMetaSwapCallerSession) CalculateRemoveLiquidity(amount *big.Int) ([]*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCallerSession) CalculateRemoveLiquidityOneToken(tokenAmount *big.Int, tokenIndex uint8) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCallerSession) CalculateSwap(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCallerSession) CalculateSwapUnderlying(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCallerSession) CalculateTokenAmount(amounts []*big.Int, deposit bool) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCallerSession) GetA() (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCallerSession) GetAPrecise() (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCallerSession) GetAdminBalance(index *big.Int) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCallerSession) GetToken(index uint8) (common.Address, error)

+ func (_TestMetaSwap *TestMetaSwapCallerSession) GetTokenBalance(index uint8) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCallerSession) GetTokenIndex(tokenAddress common.Address) (uint8, error)

+ func (_TestMetaSwap *TestMetaSwapCallerSession) GetVirtualPrice() (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapCallerSession) MetaSwapStorage() (struct{ ... }, error)

+ func (_TestMetaSwap *TestMetaSwapCallerSession) Owner() (common.Address, error)

+ func (_TestMetaSwap *TestMetaSwapCallerSession) Paused() (bool, error)

+ func (_TestMetaSwap *TestMetaSwapCallerSession) SwapStorage() (struct{ ... }, error)

+ type TestMetaSwapFilterer struct

+ func NewTestMetaSwapFilterer(address common.Address, filterer bind.ContractFilterer) (*TestMetaSwapFilterer, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) FilterAddLiquidity(opts *bind.FilterOpts, provider []common.Address) (*TestMetaSwapAddLiquidityIterator, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) FilterNewAdminFee(opts *bind.FilterOpts) (*TestMetaSwapNewAdminFeeIterator, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) FilterNewSwapFee(opts *bind.FilterOpts) (*TestMetaSwapNewSwapFeeIterator, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, ...) (*TestMetaSwapOwnershipTransferredIterator, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) FilterPaused(opts *bind.FilterOpts) (*TestMetaSwapPausedIterator, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) FilterRampA(opts *bind.FilterOpts) (*TestMetaSwapRampAIterator, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) FilterRemoveLiquidity(opts *bind.FilterOpts, provider []common.Address) (*TestMetaSwapRemoveLiquidityIterator, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) FilterRemoveLiquidityImbalance(opts *bind.FilterOpts, provider []common.Address) (*TestMetaSwapRemoveLiquidityImbalanceIterator, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) FilterRemoveLiquidityOne(opts *bind.FilterOpts, provider []common.Address) (*TestMetaSwapRemoveLiquidityOneIterator, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) FilterStopRampA(opts *bind.FilterOpts) (*TestMetaSwapStopRampAIterator, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) FilterTokenSwap(opts *bind.FilterOpts, buyer []common.Address) (*TestMetaSwapTokenSwapIterator, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) FilterTokenSwapUnderlying(opts *bind.FilterOpts, buyer []common.Address) (*TestMetaSwapTokenSwapUnderlyingIterator, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) FilterUnpaused(opts *bind.FilterOpts) (*TestMetaSwapUnpausedIterator, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) ParseAddLiquidity(log types.Log) (*TestMetaSwapAddLiquidity, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) ParseNewAdminFee(log types.Log) (*TestMetaSwapNewAdminFee, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) ParseNewSwapFee(log types.Log) (*TestMetaSwapNewSwapFee, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) ParseOwnershipTransferred(log types.Log) (*TestMetaSwapOwnershipTransferred, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) ParsePaused(log types.Log) (*TestMetaSwapPaused, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) ParseRampA(log types.Log) (*TestMetaSwapRampA, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) ParseRemoveLiquidity(log types.Log) (*TestMetaSwapRemoveLiquidity, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) ParseRemoveLiquidityImbalance(log types.Log) (*TestMetaSwapRemoveLiquidityImbalance, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) ParseRemoveLiquidityOne(log types.Log) (*TestMetaSwapRemoveLiquidityOne, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) ParseStopRampA(log types.Log) (*TestMetaSwapStopRampA, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) ParseTokenSwap(log types.Log) (*TestMetaSwapTokenSwap, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) ParseTokenSwapUnderlying(log types.Log) (*TestMetaSwapTokenSwapUnderlying, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) ParseUnpaused(log types.Log) (*TestMetaSwapUnpaused, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) WatchAddLiquidity(opts *bind.WatchOpts, sink chan<- *TestMetaSwapAddLiquidity, ...) (event.Subscription, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) WatchNewAdminFee(opts *bind.WatchOpts, sink chan<- *TestMetaSwapNewAdminFee) (event.Subscription, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) WatchNewSwapFee(opts *bind.WatchOpts, sink chan<- *TestMetaSwapNewSwapFee) (event.Subscription, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *TestMetaSwapOwnershipTransferred, ...) (event.Subscription, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) WatchPaused(opts *bind.WatchOpts, sink chan<- *TestMetaSwapPaused) (event.Subscription, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) WatchRampA(opts *bind.WatchOpts, sink chan<- *TestMetaSwapRampA) (event.Subscription, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) WatchRemoveLiquidity(opts *bind.WatchOpts, sink chan<- *TestMetaSwapRemoveLiquidity, ...) (event.Subscription, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) WatchRemoveLiquidityImbalance(opts *bind.WatchOpts, sink chan<- *TestMetaSwapRemoveLiquidityImbalance, ...) (event.Subscription, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) WatchRemoveLiquidityOne(opts *bind.WatchOpts, sink chan<- *TestMetaSwapRemoveLiquidityOne, ...) (event.Subscription, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) WatchStopRampA(opts *bind.WatchOpts, sink chan<- *TestMetaSwapStopRampA) (event.Subscription, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) WatchTokenSwap(opts *bind.WatchOpts, sink chan<- *TestMetaSwapTokenSwap, ...) (event.Subscription, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) WatchTokenSwapUnderlying(opts *bind.WatchOpts, sink chan<- *TestMetaSwapTokenSwapUnderlying, ...) (event.Subscription, error)

+ func (_TestMetaSwap *TestMetaSwapFilterer) WatchUnpaused(opts *bind.WatchOpts, sink chan<- *TestMetaSwapUnpaused) (event.Subscription, error)

+ type TestMetaSwapNewAdminFee struct

+ NewAdminFee *big.Int

+ Raw types.Log

+ type TestMetaSwapNewAdminFeeIterator struct

+ Event *TestMetaSwapNewAdminFee

+ func (it *TestMetaSwapNewAdminFeeIterator) Close() error

+ func (it *TestMetaSwapNewAdminFeeIterator) Error() error

+ func (it *TestMetaSwapNewAdminFeeIterator) Next() bool

+ type TestMetaSwapNewSwapFee struct

+ NewSwapFee *big.Int

+ Raw types.Log

+ type TestMetaSwapNewSwapFeeIterator struct

+ Event *TestMetaSwapNewSwapFee

+ func (it *TestMetaSwapNewSwapFeeIterator) Close() error

+ func (it *TestMetaSwapNewSwapFeeIterator) Error() error

+ func (it *TestMetaSwapNewSwapFeeIterator) Next() bool

+ type TestMetaSwapOwnershipTransferred struct

+ NewOwner common.Address

+ PreviousOwner common.Address

+ Raw types.Log

+ type TestMetaSwapOwnershipTransferredIterator struct

+ Event *TestMetaSwapOwnershipTransferred

+ func (it *TestMetaSwapOwnershipTransferredIterator) Close() error

+ func (it *TestMetaSwapOwnershipTransferredIterator) Error() error

+ func (it *TestMetaSwapOwnershipTransferredIterator) Next() bool

+ type TestMetaSwapPaused struct

+ Account common.Address

+ Raw types.Log

+ type TestMetaSwapPausedIterator struct

+ Event *TestMetaSwapPaused

+ func (it *TestMetaSwapPausedIterator) Close() error

+ func (it *TestMetaSwapPausedIterator) Error() error

+ func (it *TestMetaSwapPausedIterator) Next() bool

+ type TestMetaSwapRampA struct

+ FutureTime *big.Int

+ InitialTime *big.Int

+ NewA *big.Int

+ OldA *big.Int

+ Raw types.Log

+ type TestMetaSwapRampAIterator struct

+ Event *TestMetaSwapRampA

+ func (it *TestMetaSwapRampAIterator) Close() error

+ func (it *TestMetaSwapRampAIterator) Error() error

+ func (it *TestMetaSwapRampAIterator) Next() bool

+ type TestMetaSwapRaw struct

+ Contract *TestMetaSwap

+ func (_TestMetaSwap *TestMetaSwapRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, ...) error

+ func (_TestMetaSwap *TestMetaSwapRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TestMetaSwapRef struct

+ func NewTestMetaSwapRef(address common.Address, backend bind.ContractBackend) (*TestMetaSwapRef, error)

+ func (s TestMetaSwapRef) Address() common.Address

+ type TestMetaSwapRemoveLiquidity struct

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokenAmounts []*big.Int

+ type TestMetaSwapRemoveLiquidityImbalance struct

+ Fees []*big.Int

+ Invariant *big.Int

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokenAmounts []*big.Int

+ type TestMetaSwapRemoveLiquidityImbalanceIterator struct

+ Event *TestMetaSwapRemoveLiquidityImbalance

+ func (it *TestMetaSwapRemoveLiquidityImbalanceIterator) Close() error

+ func (it *TestMetaSwapRemoveLiquidityImbalanceIterator) Error() error

+ func (it *TestMetaSwapRemoveLiquidityImbalanceIterator) Next() bool

+ type TestMetaSwapRemoveLiquidityIterator struct

+ Event *TestMetaSwapRemoveLiquidity

+ func (it *TestMetaSwapRemoveLiquidityIterator) Close() error

+ func (it *TestMetaSwapRemoveLiquidityIterator) Error() error

+ func (it *TestMetaSwapRemoveLiquidityIterator) Next() bool

+ type TestMetaSwapRemoveLiquidityOne struct

+ BoughtId *big.Int

+ LpTokenAmount *big.Int

+ LpTokenSupply *big.Int

+ Provider common.Address

+ Raw types.Log

+ TokensBought *big.Int

+ type TestMetaSwapRemoveLiquidityOneIterator struct

+ Event *TestMetaSwapRemoveLiquidityOne

+ func (it *TestMetaSwapRemoveLiquidityOneIterator) Close() error

+ func (it *TestMetaSwapRemoveLiquidityOneIterator) Error() error

+ func (it *TestMetaSwapRemoveLiquidityOneIterator) Next() bool

+ type TestMetaSwapSession struct

+ CallOpts bind.CallOpts

+ Contract *TestMetaSwap

+ TransactOpts bind.TransactOpts

+ func (_TestMetaSwap *TestMetaSwapSession) AddLiquidity(amounts []*big.Int, minToMint *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) CalculateRemoveLiquidity(amount *big.Int) ([]*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapSession) CalculateRemoveLiquidityOneToken(tokenAmount *big.Int, tokenIndex uint8) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapSession) CalculateSwap(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapSession) CalculateSwapUnderlying(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapSession) CalculateTokenAmount(amounts []*big.Int, deposit bool) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapSession) GetA() (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapSession) GetAPrecise() (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapSession) GetAdminBalance(index *big.Int) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapSession) GetToken(index uint8) (common.Address, error)

+ func (_TestMetaSwap *TestMetaSwapSession) GetTokenBalance(index uint8) (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapSession) GetTokenIndex(tokenAddress common.Address) (uint8, error)

+ func (_TestMetaSwap *TestMetaSwapSession) GetVirtualPrice() (*big.Int, error)

+ func (_TestMetaSwap *TestMetaSwapSession) Initialize(_pooledTokens []common.Address, decimals []uint8, lpTokenName string, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) InitializeMetaSwap(_pooledTokens []common.Address, decimals []uint8, lpTokenName string, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) MetaSwapStorage() (struct{ ... }, error)

+ func (_TestMetaSwap *TestMetaSwapSession) Owner() (common.Address, error)

+ func (_TestMetaSwap *TestMetaSwapSession) Pause() (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) Paused() (bool, error)

+ func (_TestMetaSwap *TestMetaSwapSession) RampA(futureA *big.Int, futureTime *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) RemoveLiquidity(amount *big.Int, minAmounts []*big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) RemoveLiquidityImbalance(amounts []*big.Int, maxBurnAmount *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) RemoveLiquidityOneToken(tokenAmount *big.Int, tokenIndex uint8, minAmount *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) RenounceOwnership() (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) SetAdminFee(newAdminFee *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) SetSwapFee(newSwapFee *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) StopRampA() (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) Swap(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, minDy *big.Int, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) SwapStorage() (struct{ ... }, error)

+ func (_TestMetaSwap *TestMetaSwapSession) SwapUnderlying(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, minDy *big.Int, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) TestSwap(buyer common.Address, tokensSold *big.Int, tokensBought *big.Int, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) TestSwapUnderlying(buyer common.Address, tokensSold *big.Int, tokensBought *big.Int, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) Unpause() (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapSession) WithdrawAdminFees() (*types.Transaction, error)

+ type TestMetaSwapStopRampA struct

+ CurrentA *big.Int

+ Raw types.Log

+ Time *big.Int

+ type TestMetaSwapStopRampAIterator struct

+ Event *TestMetaSwapStopRampA

+ func (it *TestMetaSwapStopRampAIterator) Close() error

+ func (it *TestMetaSwapStopRampAIterator) Error() error

+ func (it *TestMetaSwapStopRampAIterator) Next() bool

+ type TestMetaSwapTokenSwap struct

+ BoughtId *big.Int

+ Buyer common.Address

+ Raw types.Log

+ SoldId *big.Int

+ TokensBought *big.Int

+ TokensSold *big.Int

+ type TestMetaSwapTokenSwapIterator struct

+ Event *TestMetaSwapTokenSwap

+ func (it *TestMetaSwapTokenSwapIterator) Close() error

+ func (it *TestMetaSwapTokenSwapIterator) Error() error

+ func (it *TestMetaSwapTokenSwapIterator) Next() bool

+ type TestMetaSwapTokenSwapUnderlying struct

+ BoughtId *big.Int

+ Buyer common.Address

+ Raw types.Log

+ SoldId *big.Int

+ TokensBought *big.Int

+ TokensSold *big.Int

+ type TestMetaSwapTokenSwapUnderlyingIterator struct

+ Event *TestMetaSwapTokenSwapUnderlying

+ func (it *TestMetaSwapTokenSwapUnderlyingIterator) Close() error

+ func (it *TestMetaSwapTokenSwapUnderlyingIterator) Error() error

+ func (it *TestMetaSwapTokenSwapUnderlyingIterator) Next() bool

+ type TestMetaSwapTransactor struct

+ func NewTestMetaSwapTransactor(address common.Address, transactor bind.ContractTransactor) (*TestMetaSwapTransactor, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) AddLiquidity(opts *bind.TransactOpts, amounts []*big.Int, minToMint *big.Int, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) Initialize(opts *bind.TransactOpts, _pooledTokens []common.Address, decimals []uint8, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) InitializeMetaSwap(opts *bind.TransactOpts, _pooledTokens []common.Address, decimals []uint8, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) RampA(opts *bind.TransactOpts, futureA *big.Int, futureTime *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) RemoveLiquidity(opts *bind.TransactOpts, amount *big.Int, minAmounts []*big.Int, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) RemoveLiquidityImbalance(opts *bind.TransactOpts, amounts []*big.Int, maxBurnAmount *big.Int, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) RemoveLiquidityOneToken(opts *bind.TransactOpts, tokenAmount *big.Int, tokenIndex uint8, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) SetAdminFee(opts *bind.TransactOpts, newAdminFee *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) SetSwapFee(opts *bind.TransactOpts, newSwapFee *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) StopRampA(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) Swap(opts *bind.TransactOpts, tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) SwapUnderlying(opts *bind.TransactOpts, tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) TestSwap(opts *bind.TransactOpts, buyer common.Address, tokensSold *big.Int, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) TestSwapUnderlying(opts *bind.TransactOpts, buyer common.Address, tokensSold *big.Int, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactor) WithdrawAdminFees(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TestMetaSwapTransactorRaw struct

+ Contract *TestMetaSwapTransactor

+ func (_TestMetaSwap *TestMetaSwapTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error)

+ type TestMetaSwapTransactorSession struct

+ Contract *TestMetaSwapTransactor

+ TransactOpts bind.TransactOpts

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) AddLiquidity(amounts []*big.Int, minToMint *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) Initialize(_pooledTokens []common.Address, decimals []uint8, lpTokenName string, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) InitializeMetaSwap(_pooledTokens []common.Address, decimals []uint8, lpTokenName string, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) Pause() (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) RampA(futureA *big.Int, futureTime *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) RemoveLiquidity(amount *big.Int, minAmounts []*big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) RemoveLiquidityImbalance(amounts []*big.Int, maxBurnAmount *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) RemoveLiquidityOneToken(tokenAmount *big.Int, tokenIndex uint8, minAmount *big.Int, deadline *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) RenounceOwnership() (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) SetAdminFee(newAdminFee *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) SetSwapFee(newSwapFee *big.Int) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) StopRampA() (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) Swap(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, minDy *big.Int, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) SwapUnderlying(tokenIndexFrom uint8, tokenIndexTo uint8, dx *big.Int, minDy *big.Int, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) TestSwap(buyer common.Address, tokensSold *big.Int, tokensBought *big.Int, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) TestSwapUnderlying(buyer common.Address, tokensSold *big.Int, tokensBought *big.Int, ...) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) Unpause() (*types.Transaction, error)

+ func (_TestMetaSwap *TestMetaSwapTransactorSession) WithdrawAdminFees() (*types.Transaction, error)

+ type TestMetaSwapUnpaused struct

+ Account common.Address

+ Raw types.Log

+ type TestMetaSwapUnpausedIterator struct

+ Event *TestMetaSwapUnpaused

+ func (it *TestMetaSwapUnpausedIterator) Close() error

+ func (it *TestMetaSwapUnpausedIterator) Error() error

+ func (it *TestMetaSwapUnpausedIterator) Next() bool