From c9212e4199432b0ea6e0defff390e804afe07a32 Mon Sep 17 00:00:00 2001 From: Daniel Liu <33597115+skyinglyh1@users.noreply.github.com> Date: Thu, 3 Sep 2020 10:18:27 +0800 Subject: [PATCH] update lockproxy with safeERC20 transfer and transferFrom (#8) * add update lockproxy with safeERC20 transfer and transferFrom * add usdt code on mainnet * delete unused code * update safeERC20 * update lockproxy, ongx, ontx abi * change _totalSupply variable into _totalSupply1, then generate go abi file * update lockproxy error msg --- Readme.md | 3 +- contracts/core/assets/usdt/USDT.sol | 451 ++ contracts/core/lock_proxy/LockProxy.sol | 26 +- contracts/libs/token/ERC20/SafeERC20.sol | 74 + go_abi/lock_proxy_abi/lock_proxy.go | 2190 ++++-- go_abi/ongx_abi/ongx_abi.go | 2 +- go_abi/ontx_abi/ontx_abi.go | 2 +- go_abi/usdt_abi/usdt_abi.go | 7766 ++++++++++++++++++++++ 8 files changed, 9985 insertions(+), 529 deletions(-) create mode 100644 contracts/core/assets/usdt/USDT.sol create mode 100644 contracts/libs/token/ERC20/SafeERC20.sol create mode 100644 go_abi/usdt_abi/usdt_abi.go diff --git a/Readme.md b/Readme.md index e36e51d..29e85c9 100644 --- a/Readme.md +++ b/Readme.md @@ -17,7 +17,7 @@ Download go-ethereum, choose the preferred version and build the executable abig ./abigen --sol ./contracts/core/assets/btc/BTCX.sol --pkg btcx_abi > ./go_abi/btcx_abi/btcx_abi.go -./abigen --sol ./contracts/core/assets/ont/ONTX.sol --pkg ontx_abi > ./go_abi/ontx_abi/ontx_abi.go +./abigen --sol ./contracts/core/assets/ont/xONT.sol --pkg ontx_abi > ./go_abi/ontx_abi/ontx_abi.go ./abigen --sol ./contracts/core/assets/ong/ONGX.sol --pkg ongx_abi > ./go_abi/ongx_abi/ongx_abi.go @@ -25,6 +25,7 @@ Download go-ethereum, choose the preferred version and build the executable abig ./abigen --sol ./contracts/core/assets/erc20_template/ERC20Template.sol --pkg erc20_abi > ./go_abi/erc20_abi/erc20_abi.go + ``` ## Truffle test instruction diff --git a/contracts/core/assets/usdt/USDT.sol b/contracts/core/assets/usdt/USDT.sol new file mode 100644 index 0000000..2f94df0 --- /dev/null +++ b/contracts/core/assets/usdt/USDT.sol @@ -0,0 +1,451 @@ +// /** +// *Submitted for verification at Etherscan.io on 2017-11-28 +// */ + +// pragma solidity ^0.4.17; + +// /** +// * @title SafeMath +// * @dev Math operations with safety checks that throw on error +// */ +// library SafeMath { +// function mul(uint256 a, uint256 b) internal pure returns (uint256) { +// if (a == 0) { +// return 0; +// } +// uint256 c = a * b; +// assert(c / a == b); +// return c; +// } + +// function div(uint256 a, uint256 b) internal pure returns (uint256) { +// // assert(b > 0); // Solidity automatically throws when dividing by 0 +// uint256 c = a / b; +// // assert(a == b * c + a % b); // There is no case in which this doesn't hold +// return c; +// } + +// function sub(uint256 a, uint256 b) internal pure returns (uint256) { +// assert(b <= a); +// return a - b; +// } + +// function add(uint256 a, uint256 b) internal pure returns (uint256) { +// uint256 c = a + b; +// assert(c >= a); +// return c; +// } +// } + +// /** +// * @title Ownable +// * @dev The Ownable contract has an owner address, and provides basic authorization control +// * functions, this simplifies the implementation of "user permissions". +// */ +// contract Ownable { +// address public owner; + +// /** +// * @dev The Ownable constructor sets the original `owner` of the contract to the sender +// * account. +// */ +// function Ownable() public { +// owner = msg.sender; +// } + +// /** +// * @dev Throws if called by any account other than the owner. +// */ +// modifier onlyOwner() { +// require(msg.sender == owner); +// _; +// } + +// /** +// * @dev Allows the current owner to transfer control of the contract to a newOwner. +// * @param newOwner The address to transfer ownership to. +// */ +// function transferOwnership(address newOwner) public onlyOwner { +// if (newOwner != address(0)) { +// owner = newOwner; +// } +// } + +// } + +// /** +// * @title ERC20Basic +// * @dev Simpler version of ERC20 interface +// * @dev see https://github.com/ethereum/EIPs/issues/20 +// */ +// contract ERC20Basic { +// uint public _totalSupply1; +// function totalSupply() public constant returns (uint); +// function balanceOf(address who) public constant returns (uint); +// function transfer(address to, uint value) public; +// event Transfer(address indexed from, address indexed to, uint value); +// } + +// /** +// * @title ERC20 interface +// * @dev see https://github.com/ethereum/EIPs/issues/20 +// */ +// contract ERC20 is ERC20Basic { +// function allowance(address owner, address spender) public constant returns (uint); +// function transferFrom(address from, address to, uint value) public; +// function approve(address spender, uint value) public; +// event Approval(address indexed owner, address indexed spender, uint value); +// } + +// /** +// * @title Basic token +// * @dev Basic version of StandardToken, with no allowances. +// */ +// contract BasicToken is Ownable, ERC20Basic { +// using SafeMath for uint; + +// mapping(address => uint) public balances; + +// // additional variables for use if transaction fees ever became necessary +// uint public basisPointsRate = 0; +// uint public maximumFee = 0; + +// /** +// * @dev Fix for the ERC20 short address attack. +// */ +// modifier onlyPayloadSize(uint size) { +// require(!(msg.data.length < size + 4)); +// _; +// } + +// /** +// * @dev transfer token for a specified address +// * @param _to The address to transfer to. +// * @param _value The amount to be transferred. +// */ +// function transfer(address _to, uint _value) public onlyPayloadSize(2 * 32) { +// uint fee = (_value.mul(basisPointsRate)).div(10000); +// if (fee > maximumFee) { +// fee = maximumFee; +// } +// uint sendAmount = _value.sub(fee); +// balances[msg.sender] = balances[msg.sender].sub(_value); +// balances[_to] = balances[_to].add(sendAmount); +// if (fee > 0) { +// balances[owner] = balances[owner].add(fee); +// Transfer(msg.sender, owner, fee); +// } +// Transfer(msg.sender, _to, sendAmount); +// } + +// /** +// * @dev Gets the balance of the specified address. +// * @param _owner The address to query the the balance of. +// * @return An uint representing the amount owned by the passed address. +// */ +// function balanceOf(address _owner) public constant returns (uint balance) { +// return balances[_owner]; +// } + +// } + +// /** +// * @title Standard ERC20 token +// * +// * @dev Implementation of the basic standard token. +// * @dev https://github.com/ethereum/EIPs/issues/20 +// * @dev Based oncode by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol +// */ +// contract StandardToken is BasicToken, ERC20 { + +// mapping (address => mapping (address => uint)) public allowed; + +// uint public constant MAX_UINT = 2**256 - 1; + +// /** +// * @dev Transfer tokens from one address to another +// * @param _from address The address which you want to send tokens from +// * @param _to address The address which you want to transfer to +// * @param _value uint the amount of tokens to be transferred +// */ +// function transferFrom(address _from, address _to, uint _value) public onlyPayloadSize(3 * 32) { +// var _allowance = allowed[_from][msg.sender]; + +// // Check is not needed because sub(_allowance, _value) will already throw if this condition is not met +// // if (_value > _allowance) throw; + +// uint fee = (_value.mul(basisPointsRate)).div(10000); +// if (fee > maximumFee) { +// fee = maximumFee; +// } +// if (_allowance < MAX_UINT) { +// allowed[_from][msg.sender] = _allowance.sub(_value); +// } +// uint sendAmount = _value.sub(fee); +// balances[_from] = balances[_from].sub(_value); +// balances[_to] = balances[_to].add(sendAmount); +// if (fee > 0) { +// balances[owner] = balances[owner].add(fee); +// Transfer(_from, owner, fee); +// } +// Transfer(_from, _to, sendAmount); +// } + +// /** +// * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender. +// * @param _spender The address which will spend the funds. +// * @param _value The amount of tokens to be spent. +// */ +// function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) { + +// // To change the approve amount you first have to reduce the addresses` +// // allowance to zero by calling `approve(_spender, 0)` if it is not +// // already 0 to mitigate the race condition described here: +// // https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 +// require(!((_value != 0) && (allowed[msg.sender][_spender] != 0))); + +// allowed[msg.sender][_spender] = _value; +// Approval(msg.sender, _spender, _value); +// } + +// /** +// * @dev Function to check the amount of tokens than an owner allowed to a spender. +// * @param _owner address The address which owns the funds. +// * @param _spender address The address which will spend the funds. +// * @return A uint specifying the amount of tokens still available for the spender. +// */ +// function allowance(address _owner, address _spender) public constant returns (uint remaining) { +// return allowed[_owner][_spender]; +// } + +// } + + +// /** +// * @title Pausable +// * @dev Base contract which allows children to implement an emergency stop mechanism. +// */ +// contract Pausable is Ownable { +// event Pause(); +// event Unpause(); + +// bool public paused = false; + + +// /** +// * @dev Modifier to make a function callable only when the contract is not paused. +// */ +// modifier whenNotPaused() { +// require(!paused); +// _; +// } + +// /** +// * @dev Modifier to make a function callable only when the contract is paused. +// */ +// modifier whenPaused() { +// require(paused); +// _; +// } + +// /** +// * @dev called by the owner to pause, triggers stopped state +// */ +// function pause() onlyOwner whenNotPaused public { +// paused = true; +// Pause(); +// } + +// /** +// * @dev called by the owner to unpause, returns to normal state +// */ +// function unpause() onlyOwner whenPaused public { +// paused = false; +// Unpause(); +// } +// } + +// contract BlackList is Ownable, BasicToken { + +// /////// Getters to allow the same blacklist to be used also by other contracts (including upgraded Tether) /////// +// function getBlackListStatus(address _maker) external constant returns (bool) { +// return isBlackListed[_maker]; +// } + +// function getOwner() external constant returns (address) { +// return owner; +// } + +// mapping (address => bool) public isBlackListed; + +// function addBlackList (address _evilUser) public onlyOwner { +// isBlackListed[_evilUser] = true; +// AddedBlackList(_evilUser); +// } + +// function removeBlackList (address _clearedUser) public onlyOwner { +// isBlackListed[_clearedUser] = false; +// RemovedBlackList(_clearedUser); +// } + +// function destroyBlackFunds (address _blackListedUser) public onlyOwner { +// require(isBlackListed[_blackListedUser]); +// uint dirtyFunds = balanceOf(_blackListedUser); +// balances[_blackListedUser] = 0; +// _totalSupply -= dirtyFunds; +// DestroyedBlackFunds(_blackListedUser, dirtyFunds); +// } + +// event DestroyedBlackFunds(address _blackListedUser, uint _balance); + +// event AddedBlackList(address _user); + +// event RemovedBlackList(address _user); + +// } + +// contract UpgradedStandardToken is StandardToken{ +// // those methods are called by the legacy contract +// // and they must ensure msg.sender to be the contract address +// function transferByLegacy(address from, address to, uint value) public; +// function transferFromByLegacy(address sender, address from, address spender, uint value) public; +// function approveByLegacy(address from, address spender, uint value) public; +// } + +// contract TetherToken is Pausable, StandardToken, BlackList { + +// string public name; +// string public symbol; +// uint public decimals; +// address public upgradedAddress; +// bool public deprecated; + +// // The contract can be initialized with a number of tokens +// // All the tokens are deposited to the owner address +// // +// // @param _balance Initial supply of the contract +// // @param _name Token Name +// // @param _symbol Token symbol +// // @param _decimals Token decimals +// function TetherToken(uint _initialSupply, string _name, string _symbol, uint _decimals) public { +// _totalSupply = _initialSupply; +// name = _name; +// symbol = _symbol; +// decimals = _decimals; +// balances[owner] = _initialSupply; +// deprecated = false; +// } + +// // Forward ERC20 methods to upgraded contract if this one is deprecated +// function transfer(address _to, uint _value) public whenNotPaused { +// require(!isBlackListed[msg.sender]); +// if (deprecated) { +// return UpgradedStandardToken(upgradedAddress).transferByLegacy(msg.sender, _to, _value); +// } else { +// return super.transfer(_to, _value); +// } +// } + +// // Forward ERC20 methods to upgraded contract if this one is deprecated +// function transferFrom(address _from, address _to, uint _value) public whenNotPaused { +// require(!isBlackListed[_from]); +// if (deprecated) { +// return UpgradedStandardToken(upgradedAddress).transferFromByLegacy(msg.sender, _from, _to, _value); +// } else { +// return super.transferFrom(_from, _to, _value); +// } +// } + +// // Forward ERC20 methods to upgraded contract if this one is deprecated +// function balanceOf(address who) public constant returns (uint) { +// if (deprecated) { +// return UpgradedStandardToken(upgradedAddress).balanceOf(who); +// } else { +// return super.balanceOf(who); +// } +// } + +// // Forward ERC20 methods to upgraded contract if this one is deprecated +// function approve(address _spender, uint _value) public onlyPayloadSize(2 * 32) { +// if (deprecated) { +// return UpgradedStandardToken(upgradedAddress).approveByLegacy(msg.sender, _spender, _value); +// } else { +// return super.approve(_spender, _value); +// } +// } + +// // Forward ERC20 methods to upgraded contract if this one is deprecated +// function allowance(address _owner, address _spender) public constant returns (uint remaining) { +// if (deprecated) { +// return StandardToken(upgradedAddress).allowance(_owner, _spender); +// } else { +// return super.allowance(_owner, _spender); +// } +// } + +// // deprecate current contract in favour of a new one +// function deprecate(address _upgradedAddress) public onlyOwner { +// deprecated = true; +// upgradedAddress = _upgradedAddress; +// Deprecate(_upgradedAddress); +// } + +// // deprecate current contract if favour of a new one +// function totalSupply() public constant returns (uint) { +// if (deprecated) { +// return StandardToken(upgradedAddress).totalSupply(); +// } else { +// return _totalSupply; +// } +// } + +// // Issue a new amount of tokens +// // these tokens are deposited into the owner address +// // +// // @param _amount Number of tokens to be issued +// function issue(uint amount) public onlyOwner { +// require(_totalSupply + amount > _totalSupply); +// require(balances[owner] + amount > balances[owner]); + +// balances[owner] += amount; +// _totalSupply += amount; +// Issue(amount); +// } + +// // Redeem tokens. +// // These tokens are withdrawn from the owner address +// // if the balance must be enough to cover the redeem +// // or the call will fail. +// // @param _amount Number of tokens to be issued +// function redeem(uint amount) public onlyOwner { +// require(_totalSupply >= amount); +// require(balances[owner] >= amount); + +// _totalSupply -= amount; +// balances[owner] -= amount; +// Redeem(amount); +// } + +// function setParams(uint newBasisPoints, uint newMaxFee) public onlyOwner { +// // Ensure transparency by hardcoding limit beyond which fees can never be added +// require(newBasisPoints < 20); +// require(newMaxFee < 50); + +// basisPointsRate = newBasisPoints; +// maximumFee = newMaxFee.mul(10**decimals); + +// Params(basisPointsRate, maximumFee); +// } + +// // Called when new token are issued +// event Issue(uint amount); + +// // Called when tokens are redeemed +// event Redeem(uint amount); + +// // Called when contract is deprecated +// event Deprecate(address newAddress); + +// // Called if contract ever adds fees +// event Params(uint feeBasisPoints, uint maxFee); +// } \ No newline at end of file diff --git a/contracts/core/lock_proxy/LockProxy.sol b/contracts/core/lock_proxy/LockProxy.sol index ce404f1..04da125 100644 --- a/contracts/core/lock_proxy/LockProxy.sol +++ b/contracts/core/lock_proxy/LockProxy.sol @@ -4,20 +4,15 @@ import "./../../libs/ownership/Ownable.sol"; import "./../../libs/common/ZeroCopySource.sol"; import "./../../libs/common/ZeroCopySink.sol"; import "./../../libs/utils/Utils.sol"; -import "./../../libs/math/SafeMath.sol"; +import "./../../libs/token/ERC20/SafeERC20.sol"; import "./../cross_chain_manager/interface/IEthCrossChainManager.sol"; import "./../cross_chain_manager/interface/IEthCrossChainManagerProxy.sol"; -interface ERC20Interface { - function transfer(address _to, uint256 _value) external returns (bool); - function transferFrom(address _from, address _to, uint _value) external returns (bool success); - function balanceOf(address account) external view returns (uint256); -} - contract LockProxy is Ownable { using SafeMath for uint; - + using SafeERC20 for IERC20; + struct TxArgs { bytes toAssetHash; bytes toAddress; @@ -26,6 +21,7 @@ contract LockProxy is Ownable { address public managerProxyContract; mapping(uint64 => bytes) public proxyHashMap; mapping(address => mapping(uint64 => bytes)) public assetHashMap; + mapping(address => bool) safeTransfer; event SetManagerProxyEvent(address manager); event BindProxyEvent(uint64 toChainId, bytes targetProxyHash); @@ -66,7 +62,7 @@ contract LockProxy is Ownable { * @param amount The amount of tokens to be crossed from ethereum to the chain with chainId */ function lock(address fromAssetHash, uint64 toChainId, bytes memory toAddress, uint256 amount) public payable returns (bool) { - require(amount != 0, "amount is less than zero!"); + require(amount != 0, "amount cannot be zero!"); require(_transferToContract(fromAssetHash, amount), "transfer asset from fromAddress to lock_proxy contract failed!"); @@ -128,7 +124,7 @@ contract LockProxy is Ownable { address selfAddr = address(this); return selfAddr.balance; } else { - ERC20Interface erc20Token = ERC20Interface(fromAssetHash); + IERC20 erc20Token = IERC20(fromAssetHash); return erc20Token.balanceOf(address(this)); } } @@ -160,13 +156,15 @@ contract LockProxy is Ownable { function _transferERC20ToContract(address fromAssetHash, address fromAddress, address toAddress, uint256 amount) internal returns (bool) { - ERC20Interface erc20Token = ERC20Interface(fromAssetHash); - require(erc20Token.transferFrom(fromAddress, toAddress, amount), "trasnfer ERC20 Token failed!"); + IERC20 erc20Token = IERC20(fromAssetHash); + // require(erc20Token.transferFrom(fromAddress, toAddress, amount), "trasnfer ERC20 Token failed!"); + erc20Token.safeTransferFrom(fromAddress, toAddress, amount); return true; } function _transferERC20FromContract(address toAssetHash, address toAddress, uint256 amount) internal returns (bool) { - ERC20Interface erc20Token = ERC20Interface(toAssetHash); - require(erc20Token.transfer(toAddress, amount), "trasnfer ERC20 Token failed!"); + IERC20 erc20Token = IERC20(toAssetHash); + // require(erc20Token.transfer(toAddress, amount), "trasnfer ERC20 Token failed!"); + erc20Token.safeTransfer(toAddress, amount); return true; } diff --git a/contracts/libs/token/ERC20/SafeERC20.sol b/contracts/libs/token/ERC20/SafeERC20.sol new file mode 100644 index 0000000..238e246 --- /dev/null +++ b/contracts/libs/token/ERC20/SafeERC20.sol @@ -0,0 +1,74 @@ +pragma solidity ^0.5.0; + +import "./IERC20.sol"; +import "../../math/SafeMath.sol"; +import "../../utils/Utils.sol"; + +/** + * @title SafeERC20 + * @dev Wrappers around ERC20 operations that throw on failure (when the token + * contract returns false). Tokens that return no value (and instead revert or + * throw on failure) are also supported, non-reverting calls are assumed to be + * successful. + * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract, + * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. + */ +library SafeERC20 { + using SafeMath for uint256; + + function safeTransfer(IERC20 token, address to, uint256 value) internal { + callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); + } + + function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { + callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); + } + + function safeApprove(IERC20 token, address spender, uint256 value) internal { + // safeApprove should only be called when setting an initial allowance, + // or when resetting it to zero. To increase and decrease it, use + // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' + // solhint-disable-next-line max-line-length + require((value == 0) || (token.allowance(address(this), spender) == 0), + "SafeERC20: approve from non-zero to non-zero allowance" + ); + callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); + } + + function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { + uint256 newAllowance = token.allowance(address(this), spender).add(value); + callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); + } + + function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { + uint256 newAllowance = token.allowance(address(this), spender).sub(value); + callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); + } + + /** + * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement + * on the return value: the return value is optional (but if data is returned, it must not be false). + * @param token The token targeted by the call. + * @param data The call data (encoded using abi.encode or one of its variants). + */ + function callOptionalReturn(IERC20 token, bytes memory data) private { + // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since + // we're implementing it ourselves. + + // A Solidity high level call has three parts: + // 1. The target address is checked to verify it contains contract code + // 2. The call itself is made, and success asserted + // 3. The return value is decoded, which in turn checks the size of the returned data. + // solhint-disable-next-line max-line-length + require(Utils.isContract(address(token)), "SafeERC20: call to non-contract"); + + // solhint-disable-next-line avoid-low-level-calls + (bool success, bytes memory returndata) = address(token).call(data); + require(success, "SafeERC20: low-level call failed"); + + if (returndata.length > 0) { // Return data is optional + // solhint-disable-next-line max-line-length + require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); + } + } +} \ No newline at end of file diff --git a/go_abi/lock_proxy_abi/lock_proxy.go b/go_abi/lock_proxy_abi/lock_proxy.go index b05d493..bf54fa9 100644 --- a/go_abi/lock_proxy_abi/lock_proxy.go +++ b/go_abi/lock_proxy_abi/lock_proxy.go @@ -171,114 +171,117 @@ func (_Context *ContextTransactorRaw) Transact(opts *bind.TransactOpts, method s return _Context.Contract.contract.Transact(opts, method, params...) } -// ERC20InterfaceABI is the input ABI used to generate the binding from. -const ERC20InterfaceABI = "[{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" +// IERC20ABI is the input ABI used to generate the binding from. +const IERC20ABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" -// ERC20InterfaceFuncSigs maps the 4-byte function signature to its string representation. -var ERC20InterfaceFuncSigs = map[string]string{ +// IERC20FuncSigs maps the 4-byte function signature to its string representation. +var IERC20FuncSigs = map[string]string{ + "dd62ed3e": "allowance(address,address)", + "095ea7b3": "approve(address,uint256)", "70a08231": "balanceOf(address)", + "18160ddd": "totalSupply()", "a9059cbb": "transfer(address,uint256)", "23b872dd": "transferFrom(address,address,uint256)", } -// ERC20Interface is an auto generated Go binding around an Ethereum contract. -type ERC20Interface struct { - ERC20InterfaceCaller // Read-only binding to the contract - ERC20InterfaceTransactor // Write-only binding to the contract - ERC20InterfaceFilterer // Log filterer for contract events +// IERC20 is an auto generated Go binding around an Ethereum contract. +type IERC20 struct { + IERC20Caller // Read-only binding to the contract + IERC20Transactor // Write-only binding to the contract + IERC20Filterer // Log filterer for contract events } -// ERC20InterfaceCaller is an auto generated read-only Go binding around an Ethereum contract. -type ERC20InterfaceCaller struct { +// IERC20Caller is an auto generated read-only Go binding around an Ethereum contract. +type IERC20Caller struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ERC20InterfaceTransactor is an auto generated write-only Go binding around an Ethereum contract. -type ERC20InterfaceTransactor struct { +// IERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. +type IERC20Transactor struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ERC20InterfaceFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type ERC20InterfaceFilterer struct { +// IERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IERC20Filterer struct { contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// ERC20InterfaceSession is an auto generated Go binding around an Ethereum contract, +// IERC20Session is an auto generated Go binding around an Ethereum contract, // with pre-set call and transact options. -type ERC20InterfaceSession struct { - Contract *ERC20Interface // Generic contract binding to set the session for +type IERC20Session struct { + Contract *IERC20 // Generic contract binding to set the session for CallOpts bind.CallOpts // Call options to use throughout this session TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } -// ERC20InterfaceCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// IERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, // with pre-set call options. -type ERC20InterfaceCallerSession struct { - Contract *ERC20InterfaceCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session +type IERC20CallerSession struct { + Contract *IERC20Caller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session } -// ERC20InterfaceTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// IERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, // with pre-set transact options. -type ERC20InterfaceTransactorSession struct { - Contract *ERC20InterfaceTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +type IERC20TransactorSession struct { + Contract *IERC20Transactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session } -// ERC20InterfaceRaw is an auto generated low-level Go binding around an Ethereum contract. -type ERC20InterfaceRaw struct { - Contract *ERC20Interface // Generic contract binding to access the raw methods on +// IERC20Raw is an auto generated low-level Go binding around an Ethereum contract. +type IERC20Raw struct { + Contract *IERC20 // Generic contract binding to access the raw methods on } -// ERC20InterfaceCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type ERC20InterfaceCallerRaw struct { - Contract *ERC20InterfaceCaller // Generic read-only contract binding to access the raw methods on +// IERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IERC20CallerRaw struct { + Contract *IERC20Caller // Generic read-only contract binding to access the raw methods on } -// ERC20InterfaceTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type ERC20InterfaceTransactorRaw struct { - Contract *ERC20InterfaceTransactor // Generic write-only contract binding to access the raw methods on +// IERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IERC20TransactorRaw struct { + Contract *IERC20Transactor // Generic write-only contract binding to access the raw methods on } -// NewERC20Interface creates a new instance of ERC20Interface, bound to a specific deployed contract. -func NewERC20Interface(address common.Address, backend bind.ContractBackend) (*ERC20Interface, error) { - contract, err := bindERC20Interface(address, backend, backend, backend) +// NewIERC20 creates a new instance of IERC20, bound to a specific deployed contract. +func NewIERC20(address common.Address, backend bind.ContractBackend) (*IERC20, error) { + contract, err := bindIERC20(address, backend, backend, backend) if err != nil { return nil, err } - return &ERC20Interface{ERC20InterfaceCaller: ERC20InterfaceCaller{contract: contract}, ERC20InterfaceTransactor: ERC20InterfaceTransactor{contract: contract}, ERC20InterfaceFilterer: ERC20InterfaceFilterer{contract: contract}}, nil + return &IERC20{IERC20Caller: IERC20Caller{contract: contract}, IERC20Transactor: IERC20Transactor{contract: contract}, IERC20Filterer: IERC20Filterer{contract: contract}}, nil } -// NewERC20InterfaceCaller creates a new read-only instance of ERC20Interface, bound to a specific deployed contract. -func NewERC20InterfaceCaller(address common.Address, caller bind.ContractCaller) (*ERC20InterfaceCaller, error) { - contract, err := bindERC20Interface(address, caller, nil, nil) +// NewIERC20Caller creates a new read-only instance of IERC20, bound to a specific deployed contract. +func NewIERC20Caller(address common.Address, caller bind.ContractCaller) (*IERC20Caller, error) { + contract, err := bindIERC20(address, caller, nil, nil) if err != nil { return nil, err } - return &ERC20InterfaceCaller{contract: contract}, nil + return &IERC20Caller{contract: contract}, nil } -// NewERC20InterfaceTransactor creates a new write-only instance of ERC20Interface, bound to a specific deployed contract. -func NewERC20InterfaceTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20InterfaceTransactor, error) { - contract, err := bindERC20Interface(address, nil, transactor, nil) +// NewIERC20Transactor creates a new write-only instance of IERC20, bound to a specific deployed contract. +func NewIERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC20Transactor, error) { + contract, err := bindIERC20(address, nil, transactor, nil) if err != nil { return nil, err } - return &ERC20InterfaceTransactor{contract: contract}, nil + return &IERC20Transactor{contract: contract}, nil } -// NewERC20InterfaceFilterer creates a new log filterer instance of ERC20Interface, bound to a specific deployed contract. -func NewERC20InterfaceFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20InterfaceFilterer, error) { - contract, err := bindERC20Interface(address, nil, nil, filterer) +// NewIERC20Filterer creates a new log filterer instance of IERC20, bound to a specific deployed contract. +func NewIERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC20Filterer, error) { + contract, err := bindIERC20(address, nil, nil, filterer) if err != nil { return nil, err } - return &ERC20InterfaceFilterer{contract: contract}, nil + return &IERC20Filterer{contract: contract}, nil } -// bindERC20Interface binds a generic wrapper to an already deployed contract. -func bindERC20Interface(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := abi.JSON(strings.NewReader(ERC20InterfaceABI)) +// bindIERC20 binds a generic wrapper to an already deployed contract. +func bindIERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(IERC20ABI)) if err != nil { return nil, err } @@ -289,261 +292,640 @@ func bindERC20Interface(address common.Address, caller bind.ContractCaller, tran // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. -func (_ERC20Interface *ERC20InterfaceRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { - return _ERC20Interface.Contract.ERC20InterfaceCaller.contract.Call(opts, result, method, params...) +func (_IERC20 *IERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _IERC20.Contract.IERC20Caller.contract.Call(opts, result, method, params...) } // Transfer initiates a plain transaction to move funds to the contract, calling // its default method if one is available. -func (_ERC20Interface *ERC20InterfaceRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ERC20Interface.Contract.ERC20InterfaceTransactor.contract.Transfer(opts) +func (_IERC20 *IERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IERC20.Contract.IERC20Transactor.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_ERC20Interface *ERC20InterfaceRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ERC20Interface.Contract.ERC20InterfaceTransactor.contract.Transact(opts, method, params...) +func (_IERC20 *IERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IERC20.Contract.IERC20Transactor.contract.Transact(opts, method, params...) } // Call invokes the (constant) contract method with params as input values and // sets the output to result. The result type might be a single field for simple // returns, a slice of interfaces for anonymous returns and a struct for named // returns. -func (_ERC20Interface *ERC20InterfaceCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { - return _ERC20Interface.Contract.contract.Call(opts, result, method, params...) +func (_IERC20 *IERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _IERC20.Contract.contract.Call(opts, result, method, params...) } // Transfer initiates a plain transaction to move funds to the contract, calling // its default method if one is available. -func (_ERC20Interface *ERC20InterfaceTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _ERC20Interface.Contract.contract.Transfer(opts) +func (_IERC20 *IERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IERC20.Contract.contract.Transfer(opts) } // Transact invokes the (paid) contract method with params as input values. -func (_ERC20Interface *ERC20InterfaceTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _ERC20Interface.Contract.contract.Transact(opts, method, params...) +func (_IERC20 *IERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IERC20.Contract.contract.Transact(opts, method, params...) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_IERC20 *IERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _IERC20.contract.Call(opts, out, "allowance", owner, spender) + return *ret0, err +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_IERC20 *IERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_IERC20 *IERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender) } // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. // // Solidity: function balanceOf(address account) view returns(uint256) -func (_ERC20Interface *ERC20InterfaceCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { +func (_IERC20 *IERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { var ( ret0 = new(*big.Int) ) out := ret0 - err := _ERC20Interface.contract.Call(opts, out, "balanceOf", account) + err := _IERC20.contract.Call(opts, out, "balanceOf", account) return *ret0, err } // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. // // Solidity: function balanceOf(address account) view returns(uint256) -func (_ERC20Interface *ERC20InterfaceSession) BalanceOf(account common.Address) (*big.Int, error) { - return _ERC20Interface.Contract.BalanceOf(&_ERC20Interface.CallOpts, account) +func (_IERC20 *IERC20Session) BalanceOf(account common.Address) (*big.Int, error) { + return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, account) } // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. // // Solidity: function balanceOf(address account) view returns(uint256) -func (_ERC20Interface *ERC20InterfaceCallerSession) BalanceOf(account common.Address) (*big.Int, error) { - return _ERC20Interface.Contract.BalanceOf(&_ERC20Interface.CallOpts, account) +func (_IERC20 *IERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) { + return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, account) } -// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. // -// Solidity: function transfer(address _to, uint256 _value) returns(bool) -func (_ERC20Interface *ERC20InterfaceTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error) { - return _ERC20Interface.contract.Transact(opts, "transfer", _to, _value) +// Solidity: function totalSupply() view returns(uint256) +func (_IERC20 *IERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _IERC20.contract.Call(opts, out, "totalSupply") + return *ret0, err } -// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. // -// Solidity: function transfer(address _to, uint256 _value) returns(bool) -func (_ERC20Interface *ERC20InterfaceSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { - return _ERC20Interface.Contract.Transfer(&_ERC20Interface.TransactOpts, _to, _value) +// Solidity: function totalSupply() view returns(uint256) +func (_IERC20 *IERC20Session) TotalSupply() (*big.Int, error) { + return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts) } -// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. // -// Solidity: function transfer(address _to, uint256 _value) returns(bool) -func (_ERC20Interface *ERC20InterfaceTransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { - return _ERC20Interface.Contract.Transfer(&_ERC20Interface.TransactOpts, _to, _value) +// Solidity: function totalSupply() view returns(uint256) +func (_IERC20 *IERC20CallerSession) TotalSupply() (*big.Int, error) { + return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts) } -// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. // -// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool success) -func (_ERC20Interface *ERC20InterfaceTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { - return _ERC20Interface.contract.Transact(opts, "transferFrom", _from, _to, _value) +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_IERC20 *IERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.contract.Transact(opts, "approve", spender, amount) } -// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. // -// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool success) -func (_ERC20Interface *ERC20InterfaceSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { - return _ERC20Interface.Contract.TransferFrom(&_ERC20Interface.TransactOpts, _from, _to, _value) +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_IERC20 *IERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, amount) } -// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. // -// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns(bool success) -func (_ERC20Interface *ERC20InterfaceTransactorSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { - return _ERC20Interface.Contract.TransferFrom(&_ERC20Interface.TransactOpts, _from, _to, _value) +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_IERC20 *IERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, amount) } -// IEthCrossChainManagerABI is the input ABI used to generate the binding from. -const IEthCrossChainManagerABI = "[{\"constant\":false,\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"_toChainId\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"_toContract\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"_method\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"_txData\",\"type\":\"bytes\"}],\"name\":\"crossChain\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" - -// IEthCrossChainManagerFuncSigs maps the 4-byte function signature to its string representation. -var IEthCrossChainManagerFuncSigs = map[string]string{ - "bd5cf625": "crossChain(uint64,bytes,bytes,bytes)", +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address recipient, uint256 amount) returns(bool) +func (_IERC20 *IERC20Transactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.contract.Transact(opts, "transfer", recipient, amount) } -// IEthCrossChainManager is an auto generated Go binding around an Ethereum contract. -type IEthCrossChainManager struct { - IEthCrossChainManagerCaller // Read-only binding to the contract - IEthCrossChainManagerTransactor // Write-only binding to the contract - IEthCrossChainManagerFilterer // Log filterer for contract events +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address recipient, uint256 amount) returns(bool) +func (_IERC20 *IERC20Session) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, recipient, amount) } -// IEthCrossChainManagerCaller is an auto generated read-only Go binding around an Ethereum contract. -type IEthCrossChainManagerCaller struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address recipient, uint256 amount) returns(bool) +func (_IERC20 *IERC20TransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, recipient, amount) } -// IEthCrossChainManagerTransactor is an auto generated write-only Go binding around an Ethereum contract. -type IEthCrossChainManagerTransactor struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) +func (_IERC20 *IERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.contract.Transact(opts, "transferFrom", sender, recipient, amount) } -// IEthCrossChainManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events. -type IEthCrossChainManagerFilterer struct { - contract *bind.BoundContract // Generic contract wrapper for the low level calls +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) +func (_IERC20 *IERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, sender, recipient, amount) } -// IEthCrossChainManagerSession is an auto generated Go binding around an Ethereum contract, -// with pre-set call and transact options. -type IEthCrossChainManagerSession struct { - Contract *IEthCrossChainManager // Generic contract binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) +func (_IERC20 *IERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { + return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, sender, recipient, amount) } -// IEthCrossChainManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract, -// with pre-set call options. -type IEthCrossChainManagerCallerSession struct { - Contract *IEthCrossChainManagerCaller // Generic contract caller binding to set the session for - CallOpts bind.CallOpts // Call options to use throughout this session -} +// IERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IERC20 contract. +type IERC20ApprovalIterator struct { + Event *IERC20Approval // Event containing the contract specifics and raw log -// IEthCrossChainManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, -// with pre-set transact options. -type IEthCrossChainManagerTransactorSession struct { - Contract *IEthCrossChainManagerTransactor // Generic contract transactor binding to set the session for - TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration } -// IEthCrossChainManagerRaw is an auto generated low-level Go binding around an Ethereum contract. -type IEthCrossChainManagerRaw struct { - Contract *IEthCrossChainManager // Generic contract binding to access the raw methods on +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IERC20ApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IERC20Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IERC20Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } } -// IEthCrossChainManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. -type IEthCrossChainManagerCallerRaw struct { - Contract *IEthCrossChainManagerCaller // Generic read-only contract binding to access the raw methods on +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IERC20ApprovalIterator) Error() error { + return it.fail } -// IEthCrossChainManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. -type IEthCrossChainManagerTransactorRaw struct { - Contract *IEthCrossChainManagerTransactor // Generic write-only contract binding to access the raw methods on +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IERC20ApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil } -// NewIEthCrossChainManager creates a new instance of IEthCrossChainManager, bound to a specific deployed contract. -func NewIEthCrossChainManager(address common.Address, backend bind.ContractBackend) (*IEthCrossChainManager, error) { - contract, err := bindIEthCrossChainManager(address, backend, backend, backend) - if err != nil { - return nil, err - } - return &IEthCrossChainManager{IEthCrossChainManagerCaller: IEthCrossChainManagerCaller{contract: contract}, IEthCrossChainManagerTransactor: IEthCrossChainManagerTransactor{contract: contract}, IEthCrossChainManagerFilterer: IEthCrossChainManagerFilterer{contract: contract}}, nil +// IERC20Approval represents a Approval event raised by the IERC20 contract. +type IERC20Approval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos } -// NewIEthCrossChainManagerCaller creates a new read-only instance of IEthCrossChainManager, bound to a specific deployed contract. -func NewIEthCrossChainManagerCaller(address common.Address, caller bind.ContractCaller) (*IEthCrossChainManagerCaller, error) { - contract, err := bindIEthCrossChainManager(address, caller, nil, nil) - if err != nil { - return nil, err +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_IERC20 *IERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IERC20ApprovalIterator, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) } - return &IEthCrossChainManagerCaller{contract: contract}, nil -} -// NewIEthCrossChainManagerTransactor creates a new write-only instance of IEthCrossChainManager, bound to a specific deployed contract. -func NewIEthCrossChainManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*IEthCrossChainManagerTransactor, error) { - contract, err := bindIEthCrossChainManager(address, nil, transactor, nil) + logs, sub, err := _IERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) if err != nil { return nil, err } - return &IEthCrossChainManagerTransactor{contract: contract}, nil + return &IERC20ApprovalIterator{contract: _IERC20.contract, event: "Approval", logs: logs, sub: sub}, nil } -// NewIEthCrossChainManagerFilterer creates a new log filterer instance of IEthCrossChainManager, bound to a specific deployed contract. -func NewIEthCrossChainManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*IEthCrossChainManagerFilterer, error) { - contract, err := bindIEthCrossChainManager(address, nil, nil, filterer) - if err != nil { - return nil, err +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_IERC20 *IERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) } - return &IEthCrossChainManagerFilterer{contract: contract}, nil -} -// bindIEthCrossChainManager binds a generic wrapper to an already deployed contract. -func bindIEthCrossChainManager(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { - parsed, err := abi.JSON(strings.NewReader(IEthCrossChainManagerABI)) + logs, sub, err := _IERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) if err != nil { return nil, err } - return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil -} + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IERC20Approval) + if err := _IERC20.contract.UnpackLog(event, "Approval", log); err != nil { + return err + } + event.Raw = log -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_IEthCrossChainManager *IEthCrossChainManagerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { - return _IEthCrossChainManager.Contract.IEthCrossChainManagerCaller.contract.Call(opts, result, method, params...) + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil } -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_IEthCrossChainManager *IEthCrossChainManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _IEthCrossChainManager.Contract.IEthCrossChainManagerTransactor.contract.Transfer(opts) +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_IERC20 *IERC20Filterer) ParseApproval(log types.Log) (*IERC20Approval, error) { + event := new(IERC20Approval) + if err := _IERC20.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + return event, nil } -// Transact invokes the (paid) contract method with params as input values. -func (_IEthCrossChainManager *IEthCrossChainManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _IEthCrossChainManager.Contract.IEthCrossChainManagerTransactor.contract.Transact(opts, method, params...) -} +// IERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IERC20 contract. +type IERC20TransferIterator struct { + Event *IERC20Transfer // Event containing the contract specifics and raw log -// Call invokes the (constant) contract method with params as input values and -// sets the output to result. The result type might be a single field for simple -// returns, a slice of interfaces for anonymous returns and a struct for named -// returns. -func (_IEthCrossChainManager *IEthCrossChainManagerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { - return _IEthCrossChainManager.Contract.contract.Call(opts, result, method, params...) -} + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data -// Transfer initiates a plain transaction to move funds to the contract, calling -// its default method if one is available. -func (_IEthCrossChainManager *IEthCrossChainManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { - return _IEthCrossChainManager.Contract.contract.Transfer(opts) + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration } -// Transact invokes the (paid) contract method with params as input values. -func (_IEthCrossChainManager *IEthCrossChainManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { - return _IEthCrossChainManager.Contract.contract.Transact(opts, method, params...) -} +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *IERC20TransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(IERC20Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true -// CrossChain is a paid mutator transaction binding the contract method 0xbd5cf625. -// -// Solidity: function crossChain(uint64 _toChainId, bytes _toContract, bytes _method, bytes _txData) returns(bool) + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(IERC20Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *IERC20TransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *IERC20TransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// IERC20Transfer represents a Transfer event raised by the IERC20 contract. +type IERC20Transfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_IERC20 *IERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IERC20TransferIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _IERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &IERC20TransferIterator{contract: _IERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_IERC20 *IERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _IERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(IERC20Transfer) + if err := _IERC20.contract.UnpackLog(event, "Transfer", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_IERC20 *IERC20Filterer) ParseTransfer(log types.Log) (*IERC20Transfer, error) { + event := new(IERC20Transfer) + if err := _IERC20.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + return event, nil +} + +// IEthCrossChainManagerABI is the input ABI used to generate the binding from. +const IEthCrossChainManagerABI = "[{\"constant\":false,\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"_toChainId\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"_toContract\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"_method\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"_txData\",\"type\":\"bytes\"}],\"name\":\"crossChain\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" + +// IEthCrossChainManagerFuncSigs maps the 4-byte function signature to its string representation. +var IEthCrossChainManagerFuncSigs = map[string]string{ + "bd5cf625": "crossChain(uint64,bytes,bytes,bytes)", +} + +// IEthCrossChainManager is an auto generated Go binding around an Ethereum contract. +type IEthCrossChainManager struct { + IEthCrossChainManagerCaller // Read-only binding to the contract + IEthCrossChainManagerTransactor // Write-only binding to the contract + IEthCrossChainManagerFilterer // Log filterer for contract events +} + +// IEthCrossChainManagerCaller is an auto generated read-only Go binding around an Ethereum contract. +type IEthCrossChainManagerCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IEthCrossChainManagerTransactor is an auto generated write-only Go binding around an Ethereum contract. +type IEthCrossChainManagerTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IEthCrossChainManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type IEthCrossChainManagerFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// IEthCrossChainManagerSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type IEthCrossChainManagerSession struct { + Contract *IEthCrossChainManager // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IEthCrossChainManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type IEthCrossChainManagerCallerSession struct { + Contract *IEthCrossChainManagerCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// IEthCrossChainManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type IEthCrossChainManagerTransactorSession struct { + Contract *IEthCrossChainManagerTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// IEthCrossChainManagerRaw is an auto generated low-level Go binding around an Ethereum contract. +type IEthCrossChainManagerRaw struct { + Contract *IEthCrossChainManager // Generic contract binding to access the raw methods on +} + +// IEthCrossChainManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type IEthCrossChainManagerCallerRaw struct { + Contract *IEthCrossChainManagerCaller // Generic read-only contract binding to access the raw methods on +} + +// IEthCrossChainManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type IEthCrossChainManagerTransactorRaw struct { + Contract *IEthCrossChainManagerTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewIEthCrossChainManager creates a new instance of IEthCrossChainManager, bound to a specific deployed contract. +func NewIEthCrossChainManager(address common.Address, backend bind.ContractBackend) (*IEthCrossChainManager, error) { + contract, err := bindIEthCrossChainManager(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &IEthCrossChainManager{IEthCrossChainManagerCaller: IEthCrossChainManagerCaller{contract: contract}, IEthCrossChainManagerTransactor: IEthCrossChainManagerTransactor{contract: contract}, IEthCrossChainManagerFilterer: IEthCrossChainManagerFilterer{contract: contract}}, nil +} + +// NewIEthCrossChainManagerCaller creates a new read-only instance of IEthCrossChainManager, bound to a specific deployed contract. +func NewIEthCrossChainManagerCaller(address common.Address, caller bind.ContractCaller) (*IEthCrossChainManagerCaller, error) { + contract, err := bindIEthCrossChainManager(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &IEthCrossChainManagerCaller{contract: contract}, nil +} + +// NewIEthCrossChainManagerTransactor creates a new write-only instance of IEthCrossChainManager, bound to a specific deployed contract. +func NewIEthCrossChainManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*IEthCrossChainManagerTransactor, error) { + contract, err := bindIEthCrossChainManager(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &IEthCrossChainManagerTransactor{contract: contract}, nil +} + +// NewIEthCrossChainManagerFilterer creates a new log filterer instance of IEthCrossChainManager, bound to a specific deployed contract. +func NewIEthCrossChainManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*IEthCrossChainManagerFilterer, error) { + contract, err := bindIEthCrossChainManager(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &IEthCrossChainManagerFilterer{contract: contract}, nil +} + +// bindIEthCrossChainManager binds a generic wrapper to an already deployed contract. +func bindIEthCrossChainManager(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(IEthCrossChainManagerABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IEthCrossChainManager *IEthCrossChainManagerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _IEthCrossChainManager.Contract.IEthCrossChainManagerCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IEthCrossChainManager *IEthCrossChainManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IEthCrossChainManager.Contract.IEthCrossChainManagerTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IEthCrossChainManager *IEthCrossChainManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IEthCrossChainManager.Contract.IEthCrossChainManagerTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_IEthCrossChainManager *IEthCrossChainManagerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _IEthCrossChainManager.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_IEthCrossChainManager *IEthCrossChainManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _IEthCrossChainManager.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_IEthCrossChainManager *IEthCrossChainManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _IEthCrossChainManager.Contract.contract.Transact(opts, method, params...) +} + +// CrossChain is a paid mutator transaction binding the contract method 0xbd5cf625. +// +// Solidity: function crossChain(uint64 _toChainId, bytes _toContract, bytes _method, bytes _txData) returns(bool) func (_IEthCrossChainManager *IEthCrossChainManagerTransactor) CrossChain(opts *bind.TransactOpts, _toChainId uint64, _toContract []byte, _method []byte, _txData []byte) (*types.Transaction, error) { return _IEthCrossChainManager.contract.Transact(opts, "crossChain", _toChainId, _toContract, _method, _txData) } @@ -739,7 +1121,7 @@ func (_IEthCrossChainManagerProxy *IEthCrossChainManagerProxyCallerSession) GetE } // LockProxyABI is the input ABI used to generate the binding from. -const LockProxyABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"fromAssetHash\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"toChainId\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"targetProxyHash\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"initialAmount\",\"type\":\"uint256\"}],\"name\":\"BindAssetEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"toChainId\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"targetProxyHash\",\"type\":\"bytes\"}],\"name\":\"BindProxyEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"fromAssetHash\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"fromAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"toChainId\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"toAssetHash\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"toAddress\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"LockEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"manager\",\"type\":\"address\"}],\"name\":\"SetManagerProxyEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"toAssetHash\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"toAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"UnlockEvent\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"name\":\"assetHashMap\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"fromAssetHash\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"toChainId\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"toAssetHash\",\"type\":\"bytes\"}],\"name\":\"bindAssetHash\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"toChainId\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"targetProxyHash\",\"type\":\"bytes\"}],\"name\":\"bindProxyHash\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"fromAssetHash\",\"type\":\"address\"}],\"name\":\"getBalanceFor\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"fromAssetHash\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"toChainId\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"toAddress\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"lock\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"managerProxyContract\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"operator\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"name\":\"proxyHashMap\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"ethCCMProxyAddr\",\"type\":\"address\"}],\"name\":\"setManagerProxy\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"argsBs\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"fromContractAddr\",\"type\":\"bytes\"},{\"internalType\":\"uint64\",\"name\":\"fromChainId\",\"type\":\"uint64\"}],\"name\":\"unlock\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" +const LockProxyABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"fromAssetHash\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"toChainId\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"targetProxyHash\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"initialAmount\",\"type\":\"uint256\"}],\"name\":\"BindAssetEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"toChainId\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"targetProxyHash\",\"type\":\"bytes\"}],\"name\":\"BindProxyEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"fromAssetHash\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"fromAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint64\",\"name\":\"toChainId\",\"type\":\"uint64\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"toAssetHash\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"toAddress\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"LockEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"manager\",\"type\":\"address\"}],\"name\":\"SetManagerProxyEvent\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"toAssetHash\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"toAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"UnlockEvent\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"name\":\"assetHashMap\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"fromAssetHash\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"toChainId\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"toAssetHash\",\"type\":\"bytes\"}],\"name\":\"bindAssetHash\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"toChainId\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"targetProxyHash\",\"type\":\"bytes\"}],\"name\":\"bindProxyHash\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"fromAssetHash\",\"type\":\"address\"}],\"name\":\"getBalanceFor\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"fromAssetHash\",\"type\":\"address\"},{\"internalType\":\"uint64\",\"name\":\"toChainId\",\"type\":\"uint64\"},{\"internalType\":\"bytes\",\"name\":\"toAddress\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"lock\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":true,\"stateMutability\":\"payable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"managerProxyContract\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"uint64\",\"name\":\"\",\"type\":\"uint64\"}],\"name\":\"proxyHashMap\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"ethCCMProxyAddr\",\"type\":\"address\"}],\"name\":\"setManagerProxy\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"argsBs\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"fromContractAddr\",\"type\":\"bytes\"},{\"internalType\":\"uint64\",\"name\":\"fromChainId\",\"type\":\"uint64\"}],\"name\":\"unlock\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" // LockProxyFuncSigs maps the 4-byte function signature to its string representation. var LockProxyFuncSigs = map[string]string{ @@ -747,16 +1129,19 @@ var LockProxyFuncSigs = map[string]string{ "3348f63b": "bindAssetHash(address,uint64,bytes)", "379b98f6": "bindProxyHash(uint64,bytes)", "59c589a1": "getBalanceFor(address)", + "8f32d59b": "isOwner()", "84a6d055": "lock(address,uint64,bytes,uint256)", "d798f881": "managerProxyContract()", - "570ca735": "operator()", + "8da5cb5b": "owner()", "9e5767aa": "proxyHashMap(uint64)", + "715018a6": "renounceOwnership()", "af9980f0": "setManagerProxy(address)", + "f2fde38b": "transferOwnership(address)", "06af4b9f": "unlock(bytes,bytes,uint64)", } // LockProxyBin is the compiled bytecode used for deploying new contracts. -var LockProxyBin = "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" +var LockProxyBin = "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" // DeployLockProxy deploys a new Ethereum contract, binding an instance of LockProxy to it. func DeployLockProxy(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *LockProxy, error) { @@ -966,6 +1351,32 @@ func (_LockProxy *LockProxyCallerSession) GetBalanceFor(fromAssetHash common.Add return _LockProxy.Contract.GetBalanceFor(&_LockProxy.CallOpts, fromAssetHash) } +// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. +// +// Solidity: function isOwner() view returns(bool) +func (_LockProxy *LockProxyCaller) IsOwner(opts *bind.CallOpts) (bool, error) { + var ( + ret0 = new(bool) + ) + out := ret0 + err := _LockProxy.contract.Call(opts, out, "isOwner") + return *ret0, err +} + +// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. +// +// Solidity: function isOwner() view returns(bool) +func (_LockProxy *LockProxySession) IsOwner() (bool, error) { + return _LockProxy.Contract.IsOwner(&_LockProxy.CallOpts) +} + +// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. +// +// Solidity: function isOwner() view returns(bool) +func (_LockProxy *LockProxyCallerSession) IsOwner() (bool, error) { + return _LockProxy.Contract.IsOwner(&_LockProxy.CallOpts) +} + // ManagerProxyContract is a free data retrieval call binding the contract method 0xd798f881. // // Solidity: function managerProxyContract() view returns(address) @@ -992,30 +1403,30 @@ func (_LockProxy *LockProxyCallerSession) ManagerProxyContract() (common.Address return _LockProxy.Contract.ManagerProxyContract(&_LockProxy.CallOpts) } -// Operator is a free data retrieval call binding the contract method 0x570ca735. +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. // -// Solidity: function operator() view returns(address) -func (_LockProxy *LockProxyCaller) Operator(opts *bind.CallOpts) (common.Address, error) { +// Solidity: function owner() view returns(address) +func (_LockProxy *LockProxyCaller) Owner(opts *bind.CallOpts) (common.Address, error) { var ( ret0 = new(common.Address) ) out := ret0 - err := _LockProxy.contract.Call(opts, out, "operator") + err := _LockProxy.contract.Call(opts, out, "owner") return *ret0, err } -// Operator is a free data retrieval call binding the contract method 0x570ca735. +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. // -// Solidity: function operator() view returns(address) -func (_LockProxy *LockProxySession) Operator() (common.Address, error) { - return _LockProxy.Contract.Operator(&_LockProxy.CallOpts) +// Solidity: function owner() view returns(address) +func (_LockProxy *LockProxySession) Owner() (common.Address, error) { + return _LockProxy.Contract.Owner(&_LockProxy.CallOpts) } -// Operator is a free data retrieval call binding the contract method 0x570ca735. +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. // -// Solidity: function operator() view returns(address) -func (_LockProxy *LockProxyCallerSession) Operator() (common.Address, error) { - return _LockProxy.Contract.Operator(&_LockProxy.CallOpts) +// Solidity: function owner() view returns(address) +func (_LockProxy *LockProxyCallerSession) Owner() (common.Address, error) { + return _LockProxy.Contract.Owner(&_LockProxy.CallOpts) } // ProxyHashMap is a free data retrieval call binding the contract method 0x9e5767aa. @@ -1107,17 +1518,38 @@ func (_LockProxy *LockProxyTransactorSession) Lock(fromAssetHash common.Address, return _LockProxy.Contract.Lock(&_LockProxy.TransactOpts, fromAssetHash, toChainId, toAddress, amount) } -// SetManagerProxy is a paid mutator transaction binding the contract method 0xaf9980f0. +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. // -// Solidity: function setManagerProxy(address ethCCMProxyAddr) returns() -func (_LockProxy *LockProxyTransactor) SetManagerProxy(opts *bind.TransactOpts, ethCCMProxyAddr common.Address) (*types.Transaction, error) { - return _LockProxy.contract.Transact(opts, "setManagerProxy", ethCCMProxyAddr) +// Solidity: function renounceOwnership() returns() +func (_LockProxy *LockProxyTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _LockProxy.contract.Transact(opts, "renounceOwnership") } -// SetManagerProxy is a paid mutator transaction binding the contract method 0xaf9980f0. +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. // -// Solidity: function setManagerProxy(address ethCCMProxyAddr) returns() -func (_LockProxy *LockProxySession) SetManagerProxy(ethCCMProxyAddr common.Address) (*types.Transaction, error) { +// Solidity: function renounceOwnership() returns() +func (_LockProxy *LockProxySession) RenounceOwnership() (*types.Transaction, error) { + return _LockProxy.Contract.RenounceOwnership(&_LockProxy.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_LockProxy *LockProxyTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _LockProxy.Contract.RenounceOwnership(&_LockProxy.TransactOpts) +} + +// SetManagerProxy is a paid mutator transaction binding the contract method 0xaf9980f0. +// +// Solidity: function setManagerProxy(address ethCCMProxyAddr) returns() +func (_LockProxy *LockProxyTransactor) SetManagerProxy(opts *bind.TransactOpts, ethCCMProxyAddr common.Address) (*types.Transaction, error) { + return _LockProxy.contract.Transact(opts, "setManagerProxy", ethCCMProxyAddr) +} + +// SetManagerProxy is a paid mutator transaction binding the contract method 0xaf9980f0. +// +// Solidity: function setManagerProxy(address ethCCMProxyAddr) returns() +func (_LockProxy *LockProxySession) SetManagerProxy(ethCCMProxyAddr common.Address) (*types.Transaction, error) { return _LockProxy.Contract.SetManagerProxy(&_LockProxy.TransactOpts, ethCCMProxyAddr) } @@ -1128,6 +1560,27 @@ func (_LockProxy *LockProxyTransactorSession) SetManagerProxy(ethCCMProxyAddr co return _LockProxy.Contract.SetManagerProxy(&_LockProxy.TransactOpts, ethCCMProxyAddr) } +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_LockProxy *LockProxyTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _LockProxy.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_LockProxy *LockProxySession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _LockProxy.Contract.TransferOwnership(&_LockProxy.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_LockProxy *LockProxyTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _LockProxy.Contract.TransferOwnership(&_LockProxy.TransactOpts, newOwner) +} + // Unlock is a paid mutator transaction binding the contract method 0x06af4b9f. // // Solidity: function unlock(bytes argsBs, bytes fromContractAddr, uint64 fromChainId) returns(bool) @@ -1225,24 +1678,581 @@ type LockProxyBindAssetEvent struct { Raw types.Log // Blockchain specific contextual infos } -// FilterBindAssetEvent is a free log retrieval operation binding the contract event 0x1628c8374c1bdfeb2275fd9f4c90562fd3fae974783dc522c8234e36abcfc58e. +// FilterBindAssetEvent is a free log retrieval operation binding the contract event 0x1628c8374c1bdfeb2275fd9f4c90562fd3fae974783dc522c8234e36abcfc58e. +// +// Solidity: event BindAssetEvent(address fromAssetHash, uint64 toChainId, bytes targetProxyHash, uint256 initialAmount) +func (_LockProxy *LockProxyFilterer) FilterBindAssetEvent(opts *bind.FilterOpts) (*LockProxyBindAssetEventIterator, error) { + + logs, sub, err := _LockProxy.contract.FilterLogs(opts, "BindAssetEvent") + if err != nil { + return nil, err + } + return &LockProxyBindAssetEventIterator{contract: _LockProxy.contract, event: "BindAssetEvent", logs: logs, sub: sub}, nil +} + +// WatchBindAssetEvent is a free log subscription operation binding the contract event 0x1628c8374c1bdfeb2275fd9f4c90562fd3fae974783dc522c8234e36abcfc58e. +// +// Solidity: event BindAssetEvent(address fromAssetHash, uint64 toChainId, bytes targetProxyHash, uint256 initialAmount) +func (_LockProxy *LockProxyFilterer) WatchBindAssetEvent(opts *bind.WatchOpts, sink chan<- *LockProxyBindAssetEvent) (event.Subscription, error) { + + logs, sub, err := _LockProxy.contract.WatchLogs(opts, "BindAssetEvent") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(LockProxyBindAssetEvent) + if err := _LockProxy.contract.UnpackLog(event, "BindAssetEvent", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseBindAssetEvent is a log parse operation binding the contract event 0x1628c8374c1bdfeb2275fd9f4c90562fd3fae974783dc522c8234e36abcfc58e. +// +// Solidity: event BindAssetEvent(address fromAssetHash, uint64 toChainId, bytes targetProxyHash, uint256 initialAmount) +func (_LockProxy *LockProxyFilterer) ParseBindAssetEvent(log types.Log) (*LockProxyBindAssetEvent, error) { + event := new(LockProxyBindAssetEvent) + if err := _LockProxy.contract.UnpackLog(event, "BindAssetEvent", log); err != nil { + return nil, err + } + return event, nil +} + +// LockProxyBindProxyEventIterator is returned from FilterBindProxyEvent and is used to iterate over the raw logs and unpacked data for BindProxyEvent events raised by the LockProxy contract. +type LockProxyBindProxyEventIterator struct { + Event *LockProxyBindProxyEvent // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *LockProxyBindProxyEventIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(LockProxyBindProxyEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(LockProxyBindProxyEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *LockProxyBindProxyEventIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *LockProxyBindProxyEventIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// LockProxyBindProxyEvent represents a BindProxyEvent event raised by the LockProxy contract. +type LockProxyBindProxyEvent struct { + ToChainId uint64 + TargetProxyHash []byte + Raw types.Log // Blockchain specific contextual infos +} + +// FilterBindProxyEvent is a free log retrieval operation binding the contract event 0xdacd7d303272a3b58aec6620d6d1fb588f4996a5b46858ed437f1c34348f2d0f. +// +// Solidity: event BindProxyEvent(uint64 toChainId, bytes targetProxyHash) +func (_LockProxy *LockProxyFilterer) FilterBindProxyEvent(opts *bind.FilterOpts) (*LockProxyBindProxyEventIterator, error) { + + logs, sub, err := _LockProxy.contract.FilterLogs(opts, "BindProxyEvent") + if err != nil { + return nil, err + } + return &LockProxyBindProxyEventIterator{contract: _LockProxy.contract, event: "BindProxyEvent", logs: logs, sub: sub}, nil +} + +// WatchBindProxyEvent is a free log subscription operation binding the contract event 0xdacd7d303272a3b58aec6620d6d1fb588f4996a5b46858ed437f1c34348f2d0f. +// +// Solidity: event BindProxyEvent(uint64 toChainId, bytes targetProxyHash) +func (_LockProxy *LockProxyFilterer) WatchBindProxyEvent(opts *bind.WatchOpts, sink chan<- *LockProxyBindProxyEvent) (event.Subscription, error) { + + logs, sub, err := _LockProxy.contract.WatchLogs(opts, "BindProxyEvent") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(LockProxyBindProxyEvent) + if err := _LockProxy.contract.UnpackLog(event, "BindProxyEvent", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseBindProxyEvent is a log parse operation binding the contract event 0xdacd7d303272a3b58aec6620d6d1fb588f4996a5b46858ed437f1c34348f2d0f. +// +// Solidity: event BindProxyEvent(uint64 toChainId, bytes targetProxyHash) +func (_LockProxy *LockProxyFilterer) ParseBindProxyEvent(log types.Log) (*LockProxyBindProxyEvent, error) { + event := new(LockProxyBindProxyEvent) + if err := _LockProxy.contract.UnpackLog(event, "BindProxyEvent", log); err != nil { + return nil, err + } + return event, nil +} + +// LockProxyLockEventIterator is returned from FilterLockEvent and is used to iterate over the raw logs and unpacked data for LockEvent events raised by the LockProxy contract. +type LockProxyLockEventIterator struct { + Event *LockProxyLockEvent // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *LockProxyLockEventIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(LockProxyLockEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(LockProxyLockEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *LockProxyLockEventIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *LockProxyLockEventIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// LockProxyLockEvent represents a LockEvent event raised by the LockProxy contract. +type LockProxyLockEvent struct { + FromAssetHash common.Address + FromAddress common.Address + ToChainId uint64 + ToAssetHash []byte + ToAddress []byte + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterLockEvent is a free log retrieval operation binding the contract event 0x8636abd6d0e464fe725a13346c7ac779b73561c705506044a2e6b2cdb1295ea5. +// +// Solidity: event LockEvent(address fromAssetHash, address fromAddress, uint64 toChainId, bytes toAssetHash, bytes toAddress, uint256 amount) +func (_LockProxy *LockProxyFilterer) FilterLockEvent(opts *bind.FilterOpts) (*LockProxyLockEventIterator, error) { + + logs, sub, err := _LockProxy.contract.FilterLogs(opts, "LockEvent") + if err != nil { + return nil, err + } + return &LockProxyLockEventIterator{contract: _LockProxy.contract, event: "LockEvent", logs: logs, sub: sub}, nil +} + +// WatchLockEvent is a free log subscription operation binding the contract event 0x8636abd6d0e464fe725a13346c7ac779b73561c705506044a2e6b2cdb1295ea5. +// +// Solidity: event LockEvent(address fromAssetHash, address fromAddress, uint64 toChainId, bytes toAssetHash, bytes toAddress, uint256 amount) +func (_LockProxy *LockProxyFilterer) WatchLockEvent(opts *bind.WatchOpts, sink chan<- *LockProxyLockEvent) (event.Subscription, error) { + + logs, sub, err := _LockProxy.contract.WatchLogs(opts, "LockEvent") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(LockProxyLockEvent) + if err := _LockProxy.contract.UnpackLog(event, "LockEvent", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseLockEvent is a log parse operation binding the contract event 0x8636abd6d0e464fe725a13346c7ac779b73561c705506044a2e6b2cdb1295ea5. +// +// Solidity: event LockEvent(address fromAssetHash, address fromAddress, uint64 toChainId, bytes toAssetHash, bytes toAddress, uint256 amount) +func (_LockProxy *LockProxyFilterer) ParseLockEvent(log types.Log) (*LockProxyLockEvent, error) { + event := new(LockProxyLockEvent) + if err := _LockProxy.contract.UnpackLog(event, "LockEvent", log); err != nil { + return nil, err + } + return event, nil +} + +// LockProxyOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the LockProxy contract. +type LockProxyOwnershipTransferredIterator struct { + Event *LockProxyOwnershipTransferred // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *LockProxyOwnershipTransferredIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(LockProxyOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(LockProxyOwnershipTransferred) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *LockProxyOwnershipTransferredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *LockProxyOwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// LockProxyOwnershipTransferred represents a OwnershipTransferred event raised by the LockProxy contract. +type LockProxyOwnershipTransferred struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_LockProxy *LockProxyFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*LockProxyOwnershipTransferredIterator, error) { + + var previousOwnerRule []interface{} + for _, previousOwnerItem := range previousOwner { + previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + } + var newOwnerRule []interface{} + for _, newOwnerItem := range newOwner { + newOwnerRule = append(newOwnerRule, newOwnerItem) + } + + logs, sub, err := _LockProxy.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &LockProxyOwnershipTransferredIterator{contract: _LockProxy.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil +} + +// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_LockProxy *LockProxyFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *LockProxyOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { + + var previousOwnerRule []interface{} + for _, previousOwnerItem := range previousOwner { + previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + } + var newOwnerRule []interface{} + for _, newOwnerItem := range newOwner { + newOwnerRule = append(newOwnerRule, newOwnerItem) + } + + logs, sub, err := _LockProxy.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(LockProxyOwnershipTransferred) + if err := _LockProxy.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_LockProxy *LockProxyFilterer) ParseOwnershipTransferred(log types.Log) (*LockProxyOwnershipTransferred, error) { + event := new(LockProxyOwnershipTransferred) + if err := _LockProxy.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + return event, nil +} + +// LockProxySetManagerProxyEventIterator is returned from FilterSetManagerProxyEvent and is used to iterate over the raw logs and unpacked data for SetManagerProxyEvent events raised by the LockProxy contract. +type LockProxySetManagerProxyEventIterator struct { + Event *LockProxySetManagerProxyEvent // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *LockProxySetManagerProxyEventIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(LockProxySetManagerProxyEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(LockProxySetManagerProxyEvent) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *LockProxySetManagerProxyEventIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *LockProxySetManagerProxyEventIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// LockProxySetManagerProxyEvent represents a SetManagerProxyEvent event raised by the LockProxy contract. +type LockProxySetManagerProxyEvent struct { + Manager common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterSetManagerProxyEvent is a free log retrieval operation binding the contract event 0x43b1a8ec337adb61e8311ed025d99c80db65c02fe5c5027c1b6a93b40970cec4. // -// Solidity: event BindAssetEvent(address fromAssetHash, uint64 toChainId, bytes targetProxyHash, uint256 initialAmount) -func (_LockProxy *LockProxyFilterer) FilterBindAssetEvent(opts *bind.FilterOpts) (*LockProxyBindAssetEventIterator, error) { +// Solidity: event SetManagerProxyEvent(address manager) +func (_LockProxy *LockProxyFilterer) FilterSetManagerProxyEvent(opts *bind.FilterOpts) (*LockProxySetManagerProxyEventIterator, error) { - logs, sub, err := _LockProxy.contract.FilterLogs(opts, "BindAssetEvent") + logs, sub, err := _LockProxy.contract.FilterLogs(opts, "SetManagerProxyEvent") if err != nil { return nil, err } - return &LockProxyBindAssetEventIterator{contract: _LockProxy.contract, event: "BindAssetEvent", logs: logs, sub: sub}, nil + return &LockProxySetManagerProxyEventIterator{contract: _LockProxy.contract, event: "SetManagerProxyEvent", logs: logs, sub: sub}, nil } -// WatchBindAssetEvent is a free log subscription operation binding the contract event 0x1628c8374c1bdfeb2275fd9f4c90562fd3fae974783dc522c8234e36abcfc58e. +// WatchSetManagerProxyEvent is a free log subscription operation binding the contract event 0x43b1a8ec337adb61e8311ed025d99c80db65c02fe5c5027c1b6a93b40970cec4. // -// Solidity: event BindAssetEvent(address fromAssetHash, uint64 toChainId, bytes targetProxyHash, uint256 initialAmount) -func (_LockProxy *LockProxyFilterer) WatchBindAssetEvent(opts *bind.WatchOpts, sink chan<- *LockProxyBindAssetEvent) (event.Subscription, error) { +// Solidity: event SetManagerProxyEvent(address manager) +func (_LockProxy *LockProxyFilterer) WatchSetManagerProxyEvent(opts *bind.WatchOpts, sink chan<- *LockProxySetManagerProxyEvent) (event.Subscription, error) { - logs, sub, err := _LockProxy.contract.WatchLogs(opts, "BindAssetEvent") + logs, sub, err := _LockProxy.contract.WatchLogs(opts, "SetManagerProxyEvent") if err != nil { return nil, err } @@ -1252,8 +2262,8 @@ func (_LockProxy *LockProxyFilterer) WatchBindAssetEvent(opts *bind.WatchOpts, s select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(LockProxyBindAssetEvent) - if err := _LockProxy.contract.UnpackLog(event, "BindAssetEvent", log); err != nil { + event := new(LockProxySetManagerProxyEvent) + if err := _LockProxy.contract.UnpackLog(event, "SetManagerProxyEvent", log); err != nil { return err } event.Raw = log @@ -1274,20 +2284,20 @@ func (_LockProxy *LockProxyFilterer) WatchBindAssetEvent(opts *bind.WatchOpts, s }), nil } -// ParseBindAssetEvent is a log parse operation binding the contract event 0x1628c8374c1bdfeb2275fd9f4c90562fd3fae974783dc522c8234e36abcfc58e. +// ParseSetManagerProxyEvent is a log parse operation binding the contract event 0x43b1a8ec337adb61e8311ed025d99c80db65c02fe5c5027c1b6a93b40970cec4. // -// Solidity: event BindAssetEvent(address fromAssetHash, uint64 toChainId, bytes targetProxyHash, uint256 initialAmount) -func (_LockProxy *LockProxyFilterer) ParseBindAssetEvent(log types.Log) (*LockProxyBindAssetEvent, error) { - event := new(LockProxyBindAssetEvent) - if err := _LockProxy.contract.UnpackLog(event, "BindAssetEvent", log); err != nil { +// Solidity: event SetManagerProxyEvent(address manager) +func (_LockProxy *LockProxyFilterer) ParseSetManagerProxyEvent(log types.Log) (*LockProxySetManagerProxyEvent, error) { + event := new(LockProxySetManagerProxyEvent) + if err := _LockProxy.contract.UnpackLog(event, "SetManagerProxyEvent", log); err != nil { return nil, err } return event, nil } -// LockProxyBindProxyEventIterator is returned from FilterBindProxyEvent and is used to iterate over the raw logs and unpacked data for BindProxyEvent events raised by the LockProxy contract. -type LockProxyBindProxyEventIterator struct { - Event *LockProxyBindProxyEvent // Event containing the contract specifics and raw log +// LockProxyUnlockEventIterator is returned from FilterUnlockEvent and is used to iterate over the raw logs and unpacked data for UnlockEvent events raised by the LockProxy contract. +type LockProxyUnlockEventIterator struct { + Event *LockProxyUnlockEvent // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -1301,7 +2311,7 @@ type LockProxyBindProxyEventIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *LockProxyBindProxyEventIterator) Next() bool { +func (it *LockProxyUnlockEventIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1310,7 +2320,7 @@ func (it *LockProxyBindProxyEventIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(LockProxyBindProxyEvent) + it.Event = new(LockProxyUnlockEvent) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1325,7 +2335,7 @@ func (it *LockProxyBindProxyEventIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(LockProxyBindProxyEvent) + it.Event = new(LockProxyUnlockEvent) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1341,42 +2351,43 @@ func (it *LockProxyBindProxyEventIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *LockProxyBindProxyEventIterator) Error() error { +func (it *LockProxyUnlockEventIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *LockProxyBindProxyEventIterator) Close() error { +func (it *LockProxyUnlockEventIterator) Close() error { it.sub.Unsubscribe() return nil } -// LockProxyBindProxyEvent represents a BindProxyEvent event raised by the LockProxy contract. -type LockProxyBindProxyEvent struct { - ToChainId uint64 - TargetProxyHash []byte - Raw types.Log // Blockchain specific contextual infos +// LockProxyUnlockEvent represents a UnlockEvent event raised by the LockProxy contract. +type LockProxyUnlockEvent struct { + ToAssetHash common.Address + ToAddress common.Address + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos } -// FilterBindProxyEvent is a free log retrieval operation binding the contract event 0xdacd7d303272a3b58aec6620d6d1fb588f4996a5b46858ed437f1c34348f2d0f. +// FilterUnlockEvent is a free log retrieval operation binding the contract event 0xd90288730b87c2b8e0c45bd82260fd22478aba30ae1c4d578b8daba9261604df. // -// Solidity: event BindProxyEvent(uint64 toChainId, bytes targetProxyHash) -func (_LockProxy *LockProxyFilterer) FilterBindProxyEvent(opts *bind.FilterOpts) (*LockProxyBindProxyEventIterator, error) { +// Solidity: event UnlockEvent(address toAssetHash, address toAddress, uint256 amount) +func (_LockProxy *LockProxyFilterer) FilterUnlockEvent(opts *bind.FilterOpts) (*LockProxyUnlockEventIterator, error) { - logs, sub, err := _LockProxy.contract.FilterLogs(opts, "BindProxyEvent") + logs, sub, err := _LockProxy.contract.FilterLogs(opts, "UnlockEvent") if err != nil { return nil, err } - return &LockProxyBindProxyEventIterator{contract: _LockProxy.contract, event: "BindProxyEvent", logs: logs, sub: sub}, nil + return &LockProxyUnlockEventIterator{contract: _LockProxy.contract, event: "UnlockEvent", logs: logs, sub: sub}, nil } -// WatchBindProxyEvent is a free log subscription operation binding the contract event 0xdacd7d303272a3b58aec6620d6d1fb588f4996a5b46858ed437f1c34348f2d0f. +// WatchUnlockEvent is a free log subscription operation binding the contract event 0xd90288730b87c2b8e0c45bd82260fd22478aba30ae1c4d578b8daba9261604df. // -// Solidity: event BindProxyEvent(uint64 toChainId, bytes targetProxyHash) -func (_LockProxy *LockProxyFilterer) WatchBindProxyEvent(opts *bind.WatchOpts, sink chan<- *LockProxyBindProxyEvent) (event.Subscription, error) { +// Solidity: event UnlockEvent(address toAssetHash, address toAddress, uint256 amount) +func (_LockProxy *LockProxyFilterer) WatchUnlockEvent(opts *bind.WatchOpts, sink chan<- *LockProxyUnlockEvent) (event.Subscription, error) { - logs, sub, err := _LockProxy.contract.WatchLogs(opts, "BindProxyEvent") + logs, sub, err := _LockProxy.contract.WatchLogs(opts, "UnlockEvent") if err != nil { return nil, err } @@ -1386,8 +2397,8 @@ func (_LockProxy *LockProxyFilterer) WatchBindProxyEvent(opts *bind.WatchOpts, s select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(LockProxyBindProxyEvent) - if err := _LockProxy.contract.UnpackLog(event, "BindProxyEvent", log); err != nil { + event := new(LockProxyUnlockEvent) + if err := _LockProxy.contract.UnpackLog(event, "UnlockEvent", log); err != nil { return err } event.Raw = log @@ -1408,158 +2419,267 @@ func (_LockProxy *LockProxyFilterer) WatchBindProxyEvent(opts *bind.WatchOpts, s }), nil } -// ParseBindProxyEvent is a log parse operation binding the contract event 0xdacd7d303272a3b58aec6620d6d1fb588f4996a5b46858ed437f1c34348f2d0f. +// ParseUnlockEvent is a log parse operation binding the contract event 0xd90288730b87c2b8e0c45bd82260fd22478aba30ae1c4d578b8daba9261604df. // -// Solidity: event BindProxyEvent(uint64 toChainId, bytes targetProxyHash) -func (_LockProxy *LockProxyFilterer) ParseBindProxyEvent(log types.Log) (*LockProxyBindProxyEvent, error) { - event := new(LockProxyBindProxyEvent) - if err := _LockProxy.contract.UnpackLog(event, "BindProxyEvent", log); err != nil { +// Solidity: event UnlockEvent(address toAssetHash, address toAddress, uint256 amount) +func (_LockProxy *LockProxyFilterer) ParseUnlockEvent(log types.Log) (*LockProxyUnlockEvent, error) { + event := new(LockProxyUnlockEvent) + if err := _LockProxy.contract.UnpackLog(event, "UnlockEvent", log); err != nil { return nil, err } return event, nil } -// LockProxyLockEventIterator is returned from FilterLockEvent and is used to iterate over the raw logs and unpacked data for LockEvent events raised by the LockProxy contract. -type LockProxyLockEventIterator struct { - Event *LockProxyLockEvent // Event containing the contract specifics and raw log +// OwnableABI is the input ABI used to generate the binding from. +const OwnableABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data +// OwnableFuncSigs maps the 4-byte function signature to its string representation. +var OwnableFuncSigs = map[string]string{ + "8f32d59b": "isOwner()", + "8da5cb5b": "owner()", + "715018a6": "renounceOwnership()", + "f2fde38b": "transferOwnership(address)", +} - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration +// Ownable is an auto generated Go binding around an Ethereum contract. +type Ownable struct { + OwnableCaller // Read-only binding to the contract + OwnableTransactor // Write-only binding to the contract + OwnableFilterer // Log filterer for contract events } -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *LockProxyLockEventIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false +// OwnableCaller is an auto generated read-only Go binding around an Ethereum contract. +type OwnableCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OwnableTransactor is an auto generated write-only Go binding around an Ethereum contract. +type OwnableTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OwnableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type OwnableFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OwnableSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type OwnableSession struct { + Contract *Ownable // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// OwnableCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type OwnableCallerSession struct { + Contract *OwnableCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// OwnableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type OwnableTransactorSession struct { + Contract *OwnableTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// OwnableRaw is an auto generated low-level Go binding around an Ethereum contract. +type OwnableRaw struct { + Contract *Ownable // Generic contract binding to access the raw methods on +} + +// OwnableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type OwnableCallerRaw struct { + Contract *OwnableCaller // Generic read-only contract binding to access the raw methods on +} + +// OwnableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type OwnableTransactorRaw struct { + Contract *OwnableTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewOwnable creates a new instance of Ownable, bound to a specific deployed contract. +func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error) { + contract, err := bindOwnable(address, backend, backend, backend) + if err != nil { + return nil, err } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(LockProxyLockEvent) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true + return &Ownable{OwnableCaller: OwnableCaller{contract: contract}, OwnableTransactor: OwnableTransactor{contract: contract}, OwnableFilterer: OwnableFilterer{contract: contract}}, nil +} - default: - return false - } +// NewOwnableCaller creates a new read-only instance of Ownable, bound to a specific deployed contract. +func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error) { + contract, err := bindOwnable(address, caller, nil, nil) + if err != nil { + return nil, err } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(LockProxyLockEvent) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true + return &OwnableCaller{contract: contract}, nil +} - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() +// NewOwnableTransactor creates a new write-only instance of Ownable, bound to a specific deployed contract. +func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error) { + contract, err := bindOwnable(address, nil, transactor, nil) + if err != nil { + return nil, err } + return &OwnableTransactor{contract: contract}, nil } -// Error returns any retrieval or parsing error occurred during filtering. -func (it *LockProxyLockEventIterator) Error() error { - return it.fail +// NewOwnableFilterer creates a new log filterer instance of Ownable, bound to a specific deployed contract. +func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error) { + contract, err := bindOwnable(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &OwnableFilterer{contract: contract}, nil } -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *LockProxyLockEventIterator) Close() error { - it.sub.Unsubscribe() - return nil +// bindOwnable binds a generic wrapper to an already deployed contract. +func bindOwnable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(OwnableABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil } -// LockProxyLockEvent represents a LockEvent event raised by the LockProxy contract. -type LockProxyLockEvent struct { - FromAssetHash common.Address - FromAddress common.Address - ToChainId uint64 - ToAssetHash []byte - ToAddress []byte - Amount *big.Int - Raw types.Log // Blockchain specific contextual infos +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Ownable *OwnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _Ownable.Contract.OwnableCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Ownable.Contract.OwnableTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Ownable *OwnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Ownable.Contract.OwnableTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Ownable *OwnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _Ownable.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Ownable.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Ownable *OwnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Ownable.Contract.contract.Transact(opts, method, params...) +} + +// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. +// +// Solidity: function isOwner() view returns(bool) +func (_Ownable *OwnableCaller) IsOwner(opts *bind.CallOpts) (bool, error) { + var ( + ret0 = new(bool) + ) + out := ret0 + err := _Ownable.contract.Call(opts, out, "isOwner") + return *ret0, err +} + +// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. +// +// Solidity: function isOwner() view returns(bool) +func (_Ownable *OwnableSession) IsOwner() (bool, error) { + return _Ownable.Contract.IsOwner(&_Ownable.CallOpts) +} + +// IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. +// +// Solidity: function isOwner() view returns(bool) +func (_Ownable *OwnableCallerSession) IsOwner() (bool, error) { + return _Ownable.Contract.IsOwner(&_Ownable.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var ( + ret0 = new(common.Address) + ) + out := ret0 + err := _Ownable.contract.Call(opts, out, "owner") + return *ret0, err +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Ownable *OwnableSession) Owner() (common.Address, error) { + return _Ownable.Contract.Owner(&_Ownable.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Ownable *OwnableCallerSession) Owner() (common.Address, error) { + return _Ownable.Contract.Owner(&_Ownable.CallOpts) } -// FilterLockEvent is a free log retrieval operation binding the contract event 0x8636abd6d0e464fe725a13346c7ac779b73561c705506044a2e6b2cdb1295ea5. +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. // -// Solidity: event LockEvent(address fromAssetHash, address fromAddress, uint64 toChainId, bytes toAssetHash, bytes toAddress, uint256 amount) -func (_LockProxy *LockProxyFilterer) FilterLockEvent(opts *bind.FilterOpts) (*LockProxyLockEventIterator, error) { +// Solidity: function renounceOwnership() returns() +func (_Ownable *OwnableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Ownable.contract.Transact(opts, "renounceOwnership") +} - logs, sub, err := _LockProxy.contract.FilterLogs(opts, "LockEvent") - if err != nil { - return nil, err - } - return &LockProxyLockEventIterator{contract: _LockProxy.contract, event: "LockEvent", logs: logs, sub: sub}, nil +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Ownable *OwnableSession) RenounceOwnership() (*types.Transaction, error) { + return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts) } -// WatchLockEvent is a free log subscription operation binding the contract event 0x8636abd6d0e464fe725a13346c7ac779b73561c705506044a2e6b2cdb1295ea5. +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. // -// Solidity: event LockEvent(address fromAssetHash, address fromAddress, uint64 toChainId, bytes toAssetHash, bytes toAddress, uint256 amount) -func (_LockProxy *LockProxyFilterer) WatchLockEvent(opts *bind.WatchOpts, sink chan<- *LockProxyLockEvent) (event.Subscription, error) { +// Solidity: function renounceOwnership() returns() +func (_Ownable *OwnableTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts) +} - logs, sub, err := _LockProxy.contract.WatchLogs(opts, "LockEvent") - if err != nil { - return nil, err - } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(LockProxyLockEvent) - if err := _LockProxy.contract.UnpackLog(event, "LockEvent", log); err != nil { - return err - } - event.Raw = log +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Ownable *OwnableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _Ownable.contract.Transact(opts, "transferOwnership", newOwner) +} - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner) } -// ParseLockEvent is a log parse operation binding the contract event 0x8636abd6d0e464fe725a13346c7ac779b73561c705506044a2e6b2cdb1295ea5. +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. // -// Solidity: event LockEvent(address fromAssetHash, address fromAddress, uint64 toChainId, bytes toAssetHash, bytes toAddress, uint256 amount) -func (_LockProxy *LockProxyFilterer) ParseLockEvent(log types.Log) (*LockProxyLockEvent, error) { - event := new(LockProxyLockEvent) - if err := _LockProxy.contract.UnpackLog(event, "LockEvent", log); err != nil { - return nil, err - } - return event, nil +// Solidity: function transferOwnership(address newOwner) returns() +func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner) } -// LockProxySetManagerProxyEventIterator is returned from FilterSetManagerProxyEvent and is used to iterate over the raw logs and unpacked data for SetManagerProxyEvent events raised by the LockProxy contract. -type LockProxySetManagerProxyEventIterator struct { - Event *LockProxySetManagerProxyEvent // Event containing the contract specifics and raw log +// OwnableOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Ownable contract. +type OwnableOwnershipTransferredIterator struct { + Event *OwnableOwnershipTransferred // Event containing the contract specifics and raw log contract *bind.BoundContract // Generic contract to use for unpacking event data event string // Event name to use for unpacking event data @@ -1573,7 +2693,7 @@ type LockProxySetManagerProxyEventIterator struct { // Next advances the iterator to the subsequent event, returning whether there // are any more events found. In case of a retrieval or parsing error, false is // returned and Error() can be queried for the exact failure. -func (it *LockProxySetManagerProxyEventIterator) Next() bool { +func (it *OwnableOwnershipTransferredIterator) Next() bool { // If the iterator failed, stop iterating if it.fail != nil { return false @@ -1582,7 +2702,7 @@ func (it *LockProxySetManagerProxyEventIterator) Next() bool { if it.done { select { case log := <-it.logs: - it.Event = new(LockProxySetManagerProxyEvent) + it.Event = new(OwnableOwnershipTransferred) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1597,7 +2717,7 @@ func (it *LockProxySetManagerProxyEventIterator) Next() bool { // Iterator still in progress, wait for either a data or an error event select { case log := <-it.logs: - it.Event = new(LockProxySetManagerProxyEvent) + it.Event = new(OwnableOwnershipTransferred) if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { it.fail = err return false @@ -1613,41 +2733,60 @@ func (it *LockProxySetManagerProxyEventIterator) Next() bool { } // Error returns any retrieval or parsing error occurred during filtering. -func (it *LockProxySetManagerProxyEventIterator) Error() error { +func (it *OwnableOwnershipTransferredIterator) Error() error { return it.fail } // Close terminates the iteration process, releasing any pending underlying // resources. -func (it *LockProxySetManagerProxyEventIterator) Close() error { +func (it *OwnableOwnershipTransferredIterator) Close() error { it.sub.Unsubscribe() return nil } -// LockProxySetManagerProxyEvent represents a SetManagerProxyEvent event raised by the LockProxy contract. -type LockProxySetManagerProxyEvent struct { - Manager common.Address - Raw types.Log // Blockchain specific contextual infos +// OwnableOwnershipTransferred represents a OwnershipTransferred event raised by the Ownable contract. +type OwnableOwnershipTransferred struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log // Blockchain specific contextual infos } -// FilterSetManagerProxyEvent is a free log retrieval operation binding the contract event 0x43b1a8ec337adb61e8311ed025d99c80db65c02fe5c5027c1b6a93b40970cec4. +// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. // -// Solidity: event SetManagerProxyEvent(address manager) -func (_LockProxy *LockProxyFilterer) FilterSetManagerProxyEvent(opts *bind.FilterOpts) (*LockProxySetManagerProxyEventIterator, error) { +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_Ownable *OwnableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*OwnableOwnershipTransferredIterator, error) { - logs, sub, err := _LockProxy.contract.FilterLogs(opts, "SetManagerProxyEvent") + var previousOwnerRule []interface{} + for _, previousOwnerItem := range previousOwner { + previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + } + var newOwnerRule []interface{} + for _, newOwnerItem := range newOwner { + newOwnerRule = append(newOwnerRule, newOwnerItem) + } + + logs, sub, err := _Ownable.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) if err != nil { return nil, err } - return &LockProxySetManagerProxyEventIterator{contract: _LockProxy.contract, event: "SetManagerProxyEvent", logs: logs, sub: sub}, nil + return &OwnableOwnershipTransferredIterator{contract: _Ownable.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil } -// WatchSetManagerProxyEvent is a free log subscription operation binding the contract event 0x43b1a8ec337adb61e8311ed025d99c80db65c02fe5c5027c1b6a93b40970cec4. +// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. // -// Solidity: event SetManagerProxyEvent(address manager) -func (_LockProxy *LockProxyFilterer) WatchSetManagerProxyEvent(opts *bind.WatchOpts, sink chan<- *LockProxySetManagerProxyEvent) (event.Subscription, error) { +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { - logs, sub, err := _LockProxy.contract.WatchLogs(opts, "SetManagerProxyEvent") + var previousOwnerRule []interface{} + for _, previousOwnerItem := range previousOwner { + previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + } + var newOwnerRule []interface{} + for _, newOwnerItem := range newOwner { + newOwnerRule = append(newOwnerRule, newOwnerItem) + } + + logs, sub, err := _Ownable.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) if err != nil { return nil, err } @@ -1657,8 +2796,8 @@ func (_LockProxy *LockProxyFilterer) WatchSetManagerProxyEvent(opts *bind.WatchO select { case log := <-logs: // New log arrived, parse the event and forward to the user - event := new(LockProxySetManagerProxyEvent) - if err := _LockProxy.contract.UnpackLog(event, "SetManagerProxyEvent", log); err != nil { + event := new(OwnableOwnershipTransferred) + if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { return err } event.Raw = log @@ -1679,150 +2818,177 @@ func (_LockProxy *LockProxyFilterer) WatchSetManagerProxyEvent(opts *bind.WatchO }), nil } -// ParseSetManagerProxyEvent is a log parse operation binding the contract event 0x43b1a8ec337adb61e8311ed025d99c80db65c02fe5c5027c1b6a93b40970cec4. +// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. // -// Solidity: event SetManagerProxyEvent(address manager) -func (_LockProxy *LockProxyFilterer) ParseSetManagerProxyEvent(log types.Log) (*LockProxySetManagerProxyEvent, error) { - event := new(LockProxySetManagerProxyEvent) - if err := _LockProxy.contract.UnpackLog(event, "SetManagerProxyEvent", log); err != nil { +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_Ownable *OwnableFilterer) ParseOwnershipTransferred(log types.Log) (*OwnableOwnershipTransferred, error) { + event := new(OwnableOwnershipTransferred) + if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { return nil, err } return event, nil } -// LockProxyUnlockEventIterator is returned from FilterUnlockEvent and is used to iterate over the raw logs and unpacked data for UnlockEvent events raised by the LockProxy contract. -type LockProxyUnlockEventIterator struct { - Event *LockProxyUnlockEvent // Event containing the contract specifics and raw log - - contract *bind.BoundContract // Generic contract to use for unpacking event data - event string // Event name to use for unpacking event data +// SafeERC20ABI is the input ABI used to generate the binding from. +const SafeERC20ABI = "[]" - logs chan types.Log // Log channel receiving the found contract events - sub ethereum.Subscription // Subscription for errors, completion and termination - done bool // Whether the subscription completed delivering logs - fail error // Occurred error to stop iteration -} +// SafeERC20Bin is the compiled bytecode used for deploying new contracts. +var SafeERC20Bin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a72315820fe6b50f82491efdceb2b214ff26d8bce47ff2f8b186c34497489fd8fb7be8a6a64736f6c634300050f0032" -// Next advances the iterator to the subsequent event, returning whether there -// are any more events found. In case of a retrieval or parsing error, false is -// returned and Error() can be queried for the exact failure. -func (it *LockProxyUnlockEventIterator) Next() bool { - // If the iterator failed, stop iterating - if it.fail != nil { - return false +// DeploySafeERC20 deploys a new Ethereum contract, binding an instance of SafeERC20 to it. +func DeploySafeERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeERC20, error) { + parsed, err := abi.JSON(strings.NewReader(SafeERC20ABI)) + if err != nil { + return common.Address{}, nil, nil, err } - // If the iterator completed, deliver directly whatever's available - if it.done { - select { - case log := <-it.logs: - it.Event = new(LockProxyUnlockEvent) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true - default: - return false - } + address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SafeERC20Bin), backend) + if err != nil { + return common.Address{}, nil, nil, err } - // Iterator still in progress, wait for either a data or an error event - select { - case log := <-it.logs: - it.Event = new(LockProxyUnlockEvent) - if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { - it.fail = err - return false - } - it.Event.Raw = log - return true + return address, tx, &SafeERC20{SafeERC20Caller: SafeERC20Caller{contract: contract}, SafeERC20Transactor: SafeERC20Transactor{contract: contract}, SafeERC20Filterer: SafeERC20Filterer{contract: contract}}, nil +} - case err := <-it.sub.Err(): - it.done = true - it.fail = err - return it.Next() - } +// SafeERC20 is an auto generated Go binding around an Ethereum contract. +type SafeERC20 struct { + SafeERC20Caller // Read-only binding to the contract + SafeERC20Transactor // Write-only binding to the contract + SafeERC20Filterer // Log filterer for contract events } -// Error returns any retrieval or parsing error occurred during filtering. -func (it *LockProxyUnlockEventIterator) Error() error { - return it.fail +// SafeERC20Caller is an auto generated read-only Go binding around an Ethereum contract. +type SafeERC20Caller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// Close terminates the iteration process, releasing any pending underlying -// resources. -func (it *LockProxyUnlockEventIterator) Close() error { - it.sub.Unsubscribe() - return nil +// SafeERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. +type SafeERC20Transactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// LockProxyUnlockEvent represents a UnlockEvent event raised by the LockProxy contract. -type LockProxyUnlockEvent struct { - ToAssetHash common.Address - ToAddress common.Address - Amount *big.Int - Raw types.Log // Blockchain specific contextual infos +// SafeERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. +type SafeERC20Filterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls } -// FilterUnlockEvent is a free log retrieval operation binding the contract event 0xd90288730b87c2b8e0c45bd82260fd22478aba30ae1c4d578b8daba9261604df. -// -// Solidity: event UnlockEvent(address toAssetHash, address toAddress, uint256 amount) -func (_LockProxy *LockProxyFilterer) FilterUnlockEvent(opts *bind.FilterOpts) (*LockProxyUnlockEventIterator, error) { +// SafeERC20Session is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type SafeERC20Session struct { + Contract *SafeERC20 // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} - logs, sub, err := _LockProxy.contract.FilterLogs(opts, "UnlockEvent") +// SafeERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type SafeERC20CallerSession struct { + Contract *SafeERC20Caller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// SafeERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type SafeERC20TransactorSession struct { + Contract *SafeERC20Transactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// SafeERC20Raw is an auto generated low-level Go binding around an Ethereum contract. +type SafeERC20Raw struct { + Contract *SafeERC20 // Generic contract binding to access the raw methods on +} + +// SafeERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type SafeERC20CallerRaw struct { + Contract *SafeERC20Caller // Generic read-only contract binding to access the raw methods on +} + +// SafeERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type SafeERC20TransactorRaw struct { + Contract *SafeERC20Transactor // Generic write-only contract binding to access the raw methods on +} + +// NewSafeERC20 creates a new instance of SafeERC20, bound to a specific deployed contract. +func NewSafeERC20(address common.Address, backend bind.ContractBackend) (*SafeERC20, error) { + contract, err := bindSafeERC20(address, backend, backend, backend) if err != nil { return nil, err } - return &LockProxyUnlockEventIterator{contract: _LockProxy.contract, event: "UnlockEvent", logs: logs, sub: sub}, nil + return &SafeERC20{SafeERC20Caller: SafeERC20Caller{contract: contract}, SafeERC20Transactor: SafeERC20Transactor{contract: contract}, SafeERC20Filterer: SafeERC20Filterer{contract: contract}}, nil } -// WatchUnlockEvent is a free log subscription operation binding the contract event 0xd90288730b87c2b8e0c45bd82260fd22478aba30ae1c4d578b8daba9261604df. -// -// Solidity: event UnlockEvent(address toAssetHash, address toAddress, uint256 amount) -func (_LockProxy *LockProxyFilterer) WatchUnlockEvent(opts *bind.WatchOpts, sink chan<- *LockProxyUnlockEvent) (event.Subscription, error) { +// NewSafeERC20Caller creates a new read-only instance of SafeERC20, bound to a specific deployed contract. +func NewSafeERC20Caller(address common.Address, caller bind.ContractCaller) (*SafeERC20Caller, error) { + contract, err := bindSafeERC20(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &SafeERC20Caller{contract: contract}, nil +} - logs, sub, err := _LockProxy.contract.WatchLogs(opts, "UnlockEvent") +// NewSafeERC20Transactor creates a new write-only instance of SafeERC20, bound to a specific deployed contract. +func NewSafeERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*SafeERC20Transactor, error) { + contract, err := bindSafeERC20(address, nil, transactor, nil) if err != nil { return nil, err } - return event.NewSubscription(func(quit <-chan struct{}) error { - defer sub.Unsubscribe() - for { - select { - case log := <-logs: - // New log arrived, parse the event and forward to the user - event := new(LockProxyUnlockEvent) - if err := _LockProxy.contract.UnpackLog(event, "UnlockEvent", log); err != nil { - return err - } - event.Raw = log + return &SafeERC20Transactor{contract: contract}, nil +} - select { - case sink <- event: - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - case err := <-sub.Err(): - return err - case <-quit: - return nil - } - } - }), nil +// NewSafeERC20Filterer creates a new log filterer instance of SafeERC20, bound to a specific deployed contract. +func NewSafeERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*SafeERC20Filterer, error) { + contract, err := bindSafeERC20(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &SafeERC20Filterer{contract: contract}, nil } -// ParseUnlockEvent is a log parse operation binding the contract event 0xd90288730b87c2b8e0c45bd82260fd22478aba30ae1c4d578b8daba9261604df. -// -// Solidity: event UnlockEvent(address toAssetHash, address toAddress, uint256 amount) -func (_LockProxy *LockProxyFilterer) ParseUnlockEvent(log types.Log) (*LockProxyUnlockEvent, error) { - event := new(LockProxyUnlockEvent) - if err := _LockProxy.contract.UnpackLog(event, "UnlockEvent", log); err != nil { +// bindSafeERC20 binds a generic wrapper to an already deployed contract. +func bindSafeERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(SafeERC20ABI)) + if err != nil { return nil, err } - return event, nil + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_SafeERC20 *SafeERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _SafeERC20.Contract.SafeERC20Caller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_SafeERC20 *SafeERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _SafeERC20.Contract.SafeERC20Transactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_SafeERC20 *SafeERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _SafeERC20.Contract.SafeERC20Transactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_SafeERC20 *SafeERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _SafeERC20.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_SafeERC20 *SafeERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _SafeERC20.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_SafeERC20 *SafeERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _SafeERC20.Contract.contract.Transact(opts, method, params...) } // SafeMathABI is the input ABI used to generate the binding from. diff --git a/go_abi/ongx_abi/ongx_abi.go b/go_abi/ongx_abi/ongx_abi.go index e63d6b0..28b623a 100644 --- a/go_abi/ongx_abi/ongx_abi.go +++ b/go_abi/ongx_abi/ongx_abi.go @@ -2138,7 +2138,7 @@ var ONGXFuncSigs = map[string]string{ } // ONGXBin is the compiled bytecode used for deploying new contracts. -var ONGXBin = "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" +var ONGXBin = "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" // DeployONGX deploys a new Ethereum contract, binding an instance of ONGX to it. func DeployONGX(auth *bind.TransactOpts, backend bind.ContractBackend, proxyContractAddress common.Address) (common.Address, *types.Transaction, *ONGX, error) { diff --git a/go_abi/ontx_abi/ontx_abi.go b/go_abi/ontx_abi/ontx_abi.go index a61b3c6..9239a0c 100644 --- a/go_abi/ontx_abi/ontx_abi.go +++ b/go_abi/ontx_abi/ontx_abi.go @@ -2138,7 +2138,7 @@ var ONTXFuncSigs = map[string]string{ } // ONTXBin is the compiled bytecode used for deploying new contracts. -var ONTXBin = "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" +var ONTXBin = "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" // DeployONTX deploys a new Ethereum contract, binding an instance of ONTX to it. func DeployONTX(auth *bind.TransactOpts, backend bind.ContractBackend, lockProxyContractAddress common.Address) (common.Address, *types.Transaction, *ONTX, error) { diff --git a/go_abi/usdt_abi/usdt_abi.go b/go_abi/usdt_abi/usdt_abi.go new file mode 100644 index 0000000..8c256f9 --- /dev/null +++ b/go_abi/usdt_abi/usdt_abi.go @@ -0,0 +1,7766 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package usdt_abi + +import ( + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription +) + +// BasicTokenABI is the input ABI used to generate the binding from. +const BasicTokenABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"balances\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"maximumFee\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"balance\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"_totalSupply1\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"basisPointsRate\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"}]" + +// BasicTokenFuncSigs maps the 4-byte function signature to its string representation. +var BasicTokenFuncSigs = map[string]string{ + "a2e70a2e": "_totalSupply1()", + "70a08231": "balanceOf(address)", + "27e235e3": "balances(address)", + "dd644f72": "basisPointsRate()", + "35390714": "maximumFee()", + "8da5cb5b": "owner()", + "18160ddd": "totalSupply()", + "a9059cbb": "transfer(address,uint256)", + "f2fde38b": "transferOwnership(address)", +} + +// BasicToken is an auto generated Go binding around an Ethereum contract. +type BasicToken struct { + BasicTokenCaller // Read-only binding to the contract + BasicTokenTransactor // Write-only binding to the contract + BasicTokenFilterer // Log filterer for contract events +} + +// BasicTokenCaller is an auto generated read-only Go binding around an Ethereum contract. +type BasicTokenCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// BasicTokenTransactor is an auto generated write-only Go binding around an Ethereum contract. +type BasicTokenTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// BasicTokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type BasicTokenFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// BasicTokenSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type BasicTokenSession struct { + Contract *BasicToken // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// BasicTokenCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type BasicTokenCallerSession struct { + Contract *BasicTokenCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// BasicTokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type BasicTokenTransactorSession struct { + Contract *BasicTokenTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// BasicTokenRaw is an auto generated low-level Go binding around an Ethereum contract. +type BasicTokenRaw struct { + Contract *BasicToken // Generic contract binding to access the raw methods on +} + +// BasicTokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type BasicTokenCallerRaw struct { + Contract *BasicTokenCaller // Generic read-only contract binding to access the raw methods on +} + +// BasicTokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type BasicTokenTransactorRaw struct { + Contract *BasicTokenTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewBasicToken creates a new instance of BasicToken, bound to a specific deployed contract. +func NewBasicToken(address common.Address, backend bind.ContractBackend) (*BasicToken, error) { + contract, err := bindBasicToken(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &BasicToken{BasicTokenCaller: BasicTokenCaller{contract: contract}, BasicTokenTransactor: BasicTokenTransactor{contract: contract}, BasicTokenFilterer: BasicTokenFilterer{contract: contract}}, nil +} + +// NewBasicTokenCaller creates a new read-only instance of BasicToken, bound to a specific deployed contract. +func NewBasicTokenCaller(address common.Address, caller bind.ContractCaller) (*BasicTokenCaller, error) { + contract, err := bindBasicToken(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &BasicTokenCaller{contract: contract}, nil +} + +// NewBasicTokenTransactor creates a new write-only instance of BasicToken, bound to a specific deployed contract. +func NewBasicTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*BasicTokenTransactor, error) { + contract, err := bindBasicToken(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &BasicTokenTransactor{contract: contract}, nil +} + +// NewBasicTokenFilterer creates a new log filterer instance of BasicToken, bound to a specific deployed contract. +func NewBasicTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*BasicTokenFilterer, error) { + contract, err := bindBasicToken(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &BasicTokenFilterer{contract: contract}, nil +} + +// bindBasicToken binds a generic wrapper to an already deployed contract. +func bindBasicToken(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(BasicTokenABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_BasicToken *BasicTokenRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _BasicToken.Contract.BasicTokenCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_BasicToken *BasicTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _BasicToken.Contract.BasicTokenTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_BasicToken *BasicTokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _BasicToken.Contract.BasicTokenTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_BasicToken *BasicTokenCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _BasicToken.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_BasicToken *BasicTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _BasicToken.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_BasicToken *BasicTokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _BasicToken.Contract.contract.Transact(opts, method, params...) +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_BasicToken *BasicTokenCaller) TotalSupply1(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _BasicToken.contract.Call(opts, out, "_totalSupply1") + return *ret0, err +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_BasicToken *BasicTokenSession) TotalSupply1() (*big.Int, error) { + return _BasicToken.Contract.TotalSupply1(&_BasicToken.CallOpts) +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_BasicToken *BasicTokenCallerSession) TotalSupply1() (*big.Int, error) { + return _BasicToken.Contract.TotalSupply1(&_BasicToken.CallOpts) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256 balance) +func (_BasicToken *BasicTokenCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _BasicToken.contract.Call(opts, out, "balanceOf", _owner) + return *ret0, err +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256 balance) +func (_BasicToken *BasicTokenSession) BalanceOf(_owner common.Address) (*big.Int, error) { + return _BasicToken.Contract.BalanceOf(&_BasicToken.CallOpts, _owner) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256 balance) +func (_BasicToken *BasicTokenCallerSession) BalanceOf(_owner common.Address) (*big.Int, error) { + return _BasicToken.Contract.BalanceOf(&_BasicToken.CallOpts, _owner) +} + +// Balances is a free data retrieval call binding the contract method 0x27e235e3. +// +// Solidity: function balances(address ) view returns(uint256) +func (_BasicToken *BasicTokenCaller) Balances(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _BasicToken.contract.Call(opts, out, "balances", arg0) + return *ret0, err +} + +// Balances is a free data retrieval call binding the contract method 0x27e235e3. +// +// Solidity: function balances(address ) view returns(uint256) +func (_BasicToken *BasicTokenSession) Balances(arg0 common.Address) (*big.Int, error) { + return _BasicToken.Contract.Balances(&_BasicToken.CallOpts, arg0) +} + +// Balances is a free data retrieval call binding the contract method 0x27e235e3. +// +// Solidity: function balances(address ) view returns(uint256) +func (_BasicToken *BasicTokenCallerSession) Balances(arg0 common.Address) (*big.Int, error) { + return _BasicToken.Contract.Balances(&_BasicToken.CallOpts, arg0) +} + +// BasisPointsRate is a free data retrieval call binding the contract method 0xdd644f72. +// +// Solidity: function basisPointsRate() view returns(uint256) +func (_BasicToken *BasicTokenCaller) BasisPointsRate(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _BasicToken.contract.Call(opts, out, "basisPointsRate") + return *ret0, err +} + +// BasisPointsRate is a free data retrieval call binding the contract method 0xdd644f72. +// +// Solidity: function basisPointsRate() view returns(uint256) +func (_BasicToken *BasicTokenSession) BasisPointsRate() (*big.Int, error) { + return _BasicToken.Contract.BasisPointsRate(&_BasicToken.CallOpts) +} + +// BasisPointsRate is a free data retrieval call binding the contract method 0xdd644f72. +// +// Solidity: function basisPointsRate() view returns(uint256) +func (_BasicToken *BasicTokenCallerSession) BasisPointsRate() (*big.Int, error) { + return _BasicToken.Contract.BasisPointsRate(&_BasicToken.CallOpts) +} + +// MaximumFee is a free data retrieval call binding the contract method 0x35390714. +// +// Solidity: function maximumFee() view returns(uint256) +func (_BasicToken *BasicTokenCaller) MaximumFee(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _BasicToken.contract.Call(opts, out, "maximumFee") + return *ret0, err +} + +// MaximumFee is a free data retrieval call binding the contract method 0x35390714. +// +// Solidity: function maximumFee() view returns(uint256) +func (_BasicToken *BasicTokenSession) MaximumFee() (*big.Int, error) { + return _BasicToken.Contract.MaximumFee(&_BasicToken.CallOpts) +} + +// MaximumFee is a free data retrieval call binding the contract method 0x35390714. +// +// Solidity: function maximumFee() view returns(uint256) +func (_BasicToken *BasicTokenCallerSession) MaximumFee() (*big.Int, error) { + return _BasicToken.Contract.MaximumFee(&_BasicToken.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_BasicToken *BasicTokenCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var ( + ret0 = new(common.Address) + ) + out := ret0 + err := _BasicToken.contract.Call(opts, out, "owner") + return *ret0, err +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_BasicToken *BasicTokenSession) Owner() (common.Address, error) { + return _BasicToken.Contract.Owner(&_BasicToken.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_BasicToken *BasicTokenCallerSession) Owner() (common.Address, error) { + return _BasicToken.Contract.Owner(&_BasicToken.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_BasicToken *BasicTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _BasicToken.contract.Call(opts, out, "totalSupply") + return *ret0, err +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_BasicToken *BasicTokenSession) TotalSupply() (*big.Int, error) { + return _BasicToken.Contract.TotalSupply(&_BasicToken.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_BasicToken *BasicTokenCallerSession) TotalSupply() (*big.Int, error) { + return _BasicToken.Contract.TotalSupply(&_BasicToken.CallOpts) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_BasicToken *BasicTokenTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error) { + return _BasicToken.contract.Transact(opts, "transfer", _to, _value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_BasicToken *BasicTokenSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { + return _BasicToken.Contract.Transfer(&_BasicToken.TransactOpts, _to, _value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_BasicToken *BasicTokenTransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { + return _BasicToken.Contract.Transfer(&_BasicToken.TransactOpts, _to, _value) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_BasicToken *BasicTokenTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _BasicToken.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_BasicToken *BasicTokenSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _BasicToken.Contract.TransferOwnership(&_BasicToken.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_BasicToken *BasicTokenTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _BasicToken.Contract.TransferOwnership(&_BasicToken.TransactOpts, newOwner) +} + +// BasicTokenTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the BasicToken contract. +type BasicTokenTransferIterator struct { + Event *BasicTokenTransfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *BasicTokenTransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(BasicTokenTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(BasicTokenTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *BasicTokenTransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *BasicTokenTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// BasicTokenTransfer represents a Transfer event raised by the BasicToken contract. +type BasicTokenTransfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_BasicToken *BasicTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*BasicTokenTransferIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _BasicToken.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &BasicTokenTransferIterator{contract: _BasicToken.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_BasicToken *BasicTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *BasicTokenTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _BasicToken.contract.WatchLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(BasicTokenTransfer) + if err := _BasicToken.contract.UnpackLog(event, "Transfer", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_BasicToken *BasicTokenFilterer) ParseTransfer(log types.Log) (*BasicTokenTransfer, error) { + event := new(BasicTokenTransfer) + if err := _BasicToken.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + return event, nil +} + +// BlackListABI is the input ABI used to generate the binding from. +const BlackListABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"_evilUser\",\"type\":\"address\"}],\"name\":\"addBlackList\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"balances\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"maximumFee\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_maker\",\"type\":\"address\"}],\"name\":\"getBlackListStatus\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"balance\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"getOwner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"_totalSupply1\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"basisPointsRate\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"isBlackListed\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_clearedUser\",\"type\":\"address\"}],\"name\":\"removeBlackList\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_blackListedUser\",\"type\":\"address\"}],\"name\":\"destroyBlackFunds\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"_blackListedUser\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"_balance\",\"type\":\"uint256\"}],\"name\":\"DestroyedBlackFunds\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"_user\",\"type\":\"address\"}],\"name\":\"AddedBlackList\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"_user\",\"type\":\"address\"}],\"name\":\"RemovedBlackList\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"}]" + +// BlackListFuncSigs maps the 4-byte function signature to its string representation. +var BlackListFuncSigs = map[string]string{ + "a2e70a2e": "_totalSupply1()", + "0ecb93c0": "addBlackList(address)", + "70a08231": "balanceOf(address)", + "27e235e3": "balances(address)", + "dd644f72": "basisPointsRate()", + "f3bdc228": "destroyBlackFunds(address)", + "59bf1abe": "getBlackListStatus(address)", + "893d20e8": "getOwner()", + "e47d6060": "isBlackListed(address)", + "35390714": "maximumFee()", + "8da5cb5b": "owner()", + "e4997dc5": "removeBlackList(address)", + "18160ddd": "totalSupply()", + "a9059cbb": "transfer(address,uint256)", + "f2fde38b": "transferOwnership(address)", +} + +// BlackList is an auto generated Go binding around an Ethereum contract. +type BlackList struct { + BlackListCaller // Read-only binding to the contract + BlackListTransactor // Write-only binding to the contract + BlackListFilterer // Log filterer for contract events +} + +// BlackListCaller is an auto generated read-only Go binding around an Ethereum contract. +type BlackListCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// BlackListTransactor is an auto generated write-only Go binding around an Ethereum contract. +type BlackListTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// BlackListFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type BlackListFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// BlackListSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type BlackListSession struct { + Contract *BlackList // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// BlackListCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type BlackListCallerSession struct { + Contract *BlackListCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// BlackListTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type BlackListTransactorSession struct { + Contract *BlackListTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// BlackListRaw is an auto generated low-level Go binding around an Ethereum contract. +type BlackListRaw struct { + Contract *BlackList // Generic contract binding to access the raw methods on +} + +// BlackListCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type BlackListCallerRaw struct { + Contract *BlackListCaller // Generic read-only contract binding to access the raw methods on +} + +// BlackListTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type BlackListTransactorRaw struct { + Contract *BlackListTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewBlackList creates a new instance of BlackList, bound to a specific deployed contract. +func NewBlackList(address common.Address, backend bind.ContractBackend) (*BlackList, error) { + contract, err := bindBlackList(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &BlackList{BlackListCaller: BlackListCaller{contract: contract}, BlackListTransactor: BlackListTransactor{contract: contract}, BlackListFilterer: BlackListFilterer{contract: contract}}, nil +} + +// NewBlackListCaller creates a new read-only instance of BlackList, bound to a specific deployed contract. +func NewBlackListCaller(address common.Address, caller bind.ContractCaller) (*BlackListCaller, error) { + contract, err := bindBlackList(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &BlackListCaller{contract: contract}, nil +} + +// NewBlackListTransactor creates a new write-only instance of BlackList, bound to a specific deployed contract. +func NewBlackListTransactor(address common.Address, transactor bind.ContractTransactor) (*BlackListTransactor, error) { + contract, err := bindBlackList(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &BlackListTransactor{contract: contract}, nil +} + +// NewBlackListFilterer creates a new log filterer instance of BlackList, bound to a specific deployed contract. +func NewBlackListFilterer(address common.Address, filterer bind.ContractFilterer) (*BlackListFilterer, error) { + contract, err := bindBlackList(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &BlackListFilterer{contract: contract}, nil +} + +// bindBlackList binds a generic wrapper to an already deployed contract. +func bindBlackList(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(BlackListABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_BlackList *BlackListRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _BlackList.Contract.BlackListCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_BlackList *BlackListRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _BlackList.Contract.BlackListTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_BlackList *BlackListRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _BlackList.Contract.BlackListTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_BlackList *BlackListCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _BlackList.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_BlackList *BlackListTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _BlackList.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_BlackList *BlackListTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _BlackList.Contract.contract.Transact(opts, method, params...) +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_BlackList *BlackListCaller) TotalSupply1(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _BlackList.contract.Call(opts, out, "_totalSupply1") + return *ret0, err +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_BlackList *BlackListSession) TotalSupply1() (*big.Int, error) { + return _BlackList.Contract.TotalSupply1(&_BlackList.CallOpts) +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_BlackList *BlackListCallerSession) TotalSupply1() (*big.Int, error) { + return _BlackList.Contract.TotalSupply1(&_BlackList.CallOpts) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256 balance) +func (_BlackList *BlackListCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _BlackList.contract.Call(opts, out, "balanceOf", _owner) + return *ret0, err +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256 balance) +func (_BlackList *BlackListSession) BalanceOf(_owner common.Address) (*big.Int, error) { + return _BlackList.Contract.BalanceOf(&_BlackList.CallOpts, _owner) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256 balance) +func (_BlackList *BlackListCallerSession) BalanceOf(_owner common.Address) (*big.Int, error) { + return _BlackList.Contract.BalanceOf(&_BlackList.CallOpts, _owner) +} + +// Balances is a free data retrieval call binding the contract method 0x27e235e3. +// +// Solidity: function balances(address ) view returns(uint256) +func (_BlackList *BlackListCaller) Balances(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _BlackList.contract.Call(opts, out, "balances", arg0) + return *ret0, err +} + +// Balances is a free data retrieval call binding the contract method 0x27e235e3. +// +// Solidity: function balances(address ) view returns(uint256) +func (_BlackList *BlackListSession) Balances(arg0 common.Address) (*big.Int, error) { + return _BlackList.Contract.Balances(&_BlackList.CallOpts, arg0) +} + +// Balances is a free data retrieval call binding the contract method 0x27e235e3. +// +// Solidity: function balances(address ) view returns(uint256) +func (_BlackList *BlackListCallerSession) Balances(arg0 common.Address) (*big.Int, error) { + return _BlackList.Contract.Balances(&_BlackList.CallOpts, arg0) +} + +// BasisPointsRate is a free data retrieval call binding the contract method 0xdd644f72. +// +// Solidity: function basisPointsRate() view returns(uint256) +func (_BlackList *BlackListCaller) BasisPointsRate(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _BlackList.contract.Call(opts, out, "basisPointsRate") + return *ret0, err +} + +// BasisPointsRate is a free data retrieval call binding the contract method 0xdd644f72. +// +// Solidity: function basisPointsRate() view returns(uint256) +func (_BlackList *BlackListSession) BasisPointsRate() (*big.Int, error) { + return _BlackList.Contract.BasisPointsRate(&_BlackList.CallOpts) +} + +// BasisPointsRate is a free data retrieval call binding the contract method 0xdd644f72. +// +// Solidity: function basisPointsRate() view returns(uint256) +func (_BlackList *BlackListCallerSession) BasisPointsRate() (*big.Int, error) { + return _BlackList.Contract.BasisPointsRate(&_BlackList.CallOpts) +} + +// GetBlackListStatus is a free data retrieval call binding the contract method 0x59bf1abe. +// +// Solidity: function getBlackListStatus(address _maker) view returns(bool) +func (_BlackList *BlackListCaller) GetBlackListStatus(opts *bind.CallOpts, _maker common.Address) (bool, error) { + var ( + ret0 = new(bool) + ) + out := ret0 + err := _BlackList.contract.Call(opts, out, "getBlackListStatus", _maker) + return *ret0, err +} + +// GetBlackListStatus is a free data retrieval call binding the contract method 0x59bf1abe. +// +// Solidity: function getBlackListStatus(address _maker) view returns(bool) +func (_BlackList *BlackListSession) GetBlackListStatus(_maker common.Address) (bool, error) { + return _BlackList.Contract.GetBlackListStatus(&_BlackList.CallOpts, _maker) +} + +// GetBlackListStatus is a free data retrieval call binding the contract method 0x59bf1abe. +// +// Solidity: function getBlackListStatus(address _maker) view returns(bool) +func (_BlackList *BlackListCallerSession) GetBlackListStatus(_maker common.Address) (bool, error) { + return _BlackList.Contract.GetBlackListStatus(&_BlackList.CallOpts, _maker) +} + +// GetOwner is a free data retrieval call binding the contract method 0x893d20e8. +// +// Solidity: function getOwner() view returns(address) +func (_BlackList *BlackListCaller) GetOwner(opts *bind.CallOpts) (common.Address, error) { + var ( + ret0 = new(common.Address) + ) + out := ret0 + err := _BlackList.contract.Call(opts, out, "getOwner") + return *ret0, err +} + +// GetOwner is a free data retrieval call binding the contract method 0x893d20e8. +// +// Solidity: function getOwner() view returns(address) +func (_BlackList *BlackListSession) GetOwner() (common.Address, error) { + return _BlackList.Contract.GetOwner(&_BlackList.CallOpts) +} + +// GetOwner is a free data retrieval call binding the contract method 0x893d20e8. +// +// Solidity: function getOwner() view returns(address) +func (_BlackList *BlackListCallerSession) GetOwner() (common.Address, error) { + return _BlackList.Contract.GetOwner(&_BlackList.CallOpts) +} + +// IsBlackListed is a free data retrieval call binding the contract method 0xe47d6060. +// +// Solidity: function isBlackListed(address ) view returns(bool) +func (_BlackList *BlackListCaller) IsBlackListed(opts *bind.CallOpts, arg0 common.Address) (bool, error) { + var ( + ret0 = new(bool) + ) + out := ret0 + err := _BlackList.contract.Call(opts, out, "isBlackListed", arg0) + return *ret0, err +} + +// IsBlackListed is a free data retrieval call binding the contract method 0xe47d6060. +// +// Solidity: function isBlackListed(address ) view returns(bool) +func (_BlackList *BlackListSession) IsBlackListed(arg0 common.Address) (bool, error) { + return _BlackList.Contract.IsBlackListed(&_BlackList.CallOpts, arg0) +} + +// IsBlackListed is a free data retrieval call binding the contract method 0xe47d6060. +// +// Solidity: function isBlackListed(address ) view returns(bool) +func (_BlackList *BlackListCallerSession) IsBlackListed(arg0 common.Address) (bool, error) { + return _BlackList.Contract.IsBlackListed(&_BlackList.CallOpts, arg0) +} + +// MaximumFee is a free data retrieval call binding the contract method 0x35390714. +// +// Solidity: function maximumFee() view returns(uint256) +func (_BlackList *BlackListCaller) MaximumFee(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _BlackList.contract.Call(opts, out, "maximumFee") + return *ret0, err +} + +// MaximumFee is a free data retrieval call binding the contract method 0x35390714. +// +// Solidity: function maximumFee() view returns(uint256) +func (_BlackList *BlackListSession) MaximumFee() (*big.Int, error) { + return _BlackList.Contract.MaximumFee(&_BlackList.CallOpts) +} + +// MaximumFee is a free data retrieval call binding the contract method 0x35390714. +// +// Solidity: function maximumFee() view returns(uint256) +func (_BlackList *BlackListCallerSession) MaximumFee() (*big.Int, error) { + return _BlackList.Contract.MaximumFee(&_BlackList.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_BlackList *BlackListCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var ( + ret0 = new(common.Address) + ) + out := ret0 + err := _BlackList.contract.Call(opts, out, "owner") + return *ret0, err +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_BlackList *BlackListSession) Owner() (common.Address, error) { + return _BlackList.Contract.Owner(&_BlackList.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_BlackList *BlackListCallerSession) Owner() (common.Address, error) { + return _BlackList.Contract.Owner(&_BlackList.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_BlackList *BlackListCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _BlackList.contract.Call(opts, out, "totalSupply") + return *ret0, err +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_BlackList *BlackListSession) TotalSupply() (*big.Int, error) { + return _BlackList.Contract.TotalSupply(&_BlackList.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_BlackList *BlackListCallerSession) TotalSupply() (*big.Int, error) { + return _BlackList.Contract.TotalSupply(&_BlackList.CallOpts) +} + +// AddBlackList is a paid mutator transaction binding the contract method 0x0ecb93c0. +// +// Solidity: function addBlackList(address _evilUser) returns() +func (_BlackList *BlackListTransactor) AddBlackList(opts *bind.TransactOpts, _evilUser common.Address) (*types.Transaction, error) { + return _BlackList.contract.Transact(opts, "addBlackList", _evilUser) +} + +// AddBlackList is a paid mutator transaction binding the contract method 0x0ecb93c0. +// +// Solidity: function addBlackList(address _evilUser) returns() +func (_BlackList *BlackListSession) AddBlackList(_evilUser common.Address) (*types.Transaction, error) { + return _BlackList.Contract.AddBlackList(&_BlackList.TransactOpts, _evilUser) +} + +// AddBlackList is a paid mutator transaction binding the contract method 0x0ecb93c0. +// +// Solidity: function addBlackList(address _evilUser) returns() +func (_BlackList *BlackListTransactorSession) AddBlackList(_evilUser common.Address) (*types.Transaction, error) { + return _BlackList.Contract.AddBlackList(&_BlackList.TransactOpts, _evilUser) +} + +// DestroyBlackFunds is a paid mutator transaction binding the contract method 0xf3bdc228. +// +// Solidity: function destroyBlackFunds(address _blackListedUser) returns() +func (_BlackList *BlackListTransactor) DestroyBlackFunds(opts *bind.TransactOpts, _blackListedUser common.Address) (*types.Transaction, error) { + return _BlackList.contract.Transact(opts, "destroyBlackFunds", _blackListedUser) +} + +// DestroyBlackFunds is a paid mutator transaction binding the contract method 0xf3bdc228. +// +// Solidity: function destroyBlackFunds(address _blackListedUser) returns() +func (_BlackList *BlackListSession) DestroyBlackFunds(_blackListedUser common.Address) (*types.Transaction, error) { + return _BlackList.Contract.DestroyBlackFunds(&_BlackList.TransactOpts, _blackListedUser) +} + +// DestroyBlackFunds is a paid mutator transaction binding the contract method 0xf3bdc228. +// +// Solidity: function destroyBlackFunds(address _blackListedUser) returns() +func (_BlackList *BlackListTransactorSession) DestroyBlackFunds(_blackListedUser common.Address) (*types.Transaction, error) { + return _BlackList.Contract.DestroyBlackFunds(&_BlackList.TransactOpts, _blackListedUser) +} + +// RemoveBlackList is a paid mutator transaction binding the contract method 0xe4997dc5. +// +// Solidity: function removeBlackList(address _clearedUser) returns() +func (_BlackList *BlackListTransactor) RemoveBlackList(opts *bind.TransactOpts, _clearedUser common.Address) (*types.Transaction, error) { + return _BlackList.contract.Transact(opts, "removeBlackList", _clearedUser) +} + +// RemoveBlackList is a paid mutator transaction binding the contract method 0xe4997dc5. +// +// Solidity: function removeBlackList(address _clearedUser) returns() +func (_BlackList *BlackListSession) RemoveBlackList(_clearedUser common.Address) (*types.Transaction, error) { + return _BlackList.Contract.RemoveBlackList(&_BlackList.TransactOpts, _clearedUser) +} + +// RemoveBlackList is a paid mutator transaction binding the contract method 0xe4997dc5. +// +// Solidity: function removeBlackList(address _clearedUser) returns() +func (_BlackList *BlackListTransactorSession) RemoveBlackList(_clearedUser common.Address) (*types.Transaction, error) { + return _BlackList.Contract.RemoveBlackList(&_BlackList.TransactOpts, _clearedUser) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_BlackList *BlackListTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error) { + return _BlackList.contract.Transact(opts, "transfer", _to, _value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_BlackList *BlackListSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { + return _BlackList.Contract.Transfer(&_BlackList.TransactOpts, _to, _value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_BlackList *BlackListTransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { + return _BlackList.Contract.Transfer(&_BlackList.TransactOpts, _to, _value) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_BlackList *BlackListTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _BlackList.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_BlackList *BlackListSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _BlackList.Contract.TransferOwnership(&_BlackList.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_BlackList *BlackListTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _BlackList.Contract.TransferOwnership(&_BlackList.TransactOpts, newOwner) +} + +// BlackListAddedBlackListIterator is returned from FilterAddedBlackList and is used to iterate over the raw logs and unpacked data for AddedBlackList events raised by the BlackList contract. +type BlackListAddedBlackListIterator struct { + Event *BlackListAddedBlackList // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *BlackListAddedBlackListIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(BlackListAddedBlackList) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(BlackListAddedBlackList) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *BlackListAddedBlackListIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *BlackListAddedBlackListIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// BlackListAddedBlackList represents a AddedBlackList event raised by the BlackList contract. +type BlackListAddedBlackList struct { + User common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAddedBlackList is a free log retrieval operation binding the contract event 0x42e160154868087d6bfdc0ca23d96a1c1cfa32f1b72ba9ba27b69b98a0d819dc. +// +// Solidity: event AddedBlackList(address _user) +func (_BlackList *BlackListFilterer) FilterAddedBlackList(opts *bind.FilterOpts) (*BlackListAddedBlackListIterator, error) { + + logs, sub, err := _BlackList.contract.FilterLogs(opts, "AddedBlackList") + if err != nil { + return nil, err + } + return &BlackListAddedBlackListIterator{contract: _BlackList.contract, event: "AddedBlackList", logs: logs, sub: sub}, nil +} + +// WatchAddedBlackList is a free log subscription operation binding the contract event 0x42e160154868087d6bfdc0ca23d96a1c1cfa32f1b72ba9ba27b69b98a0d819dc. +// +// Solidity: event AddedBlackList(address _user) +func (_BlackList *BlackListFilterer) WatchAddedBlackList(opts *bind.WatchOpts, sink chan<- *BlackListAddedBlackList) (event.Subscription, error) { + + logs, sub, err := _BlackList.contract.WatchLogs(opts, "AddedBlackList") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(BlackListAddedBlackList) + if err := _BlackList.contract.UnpackLog(event, "AddedBlackList", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseAddedBlackList is a log parse operation binding the contract event 0x42e160154868087d6bfdc0ca23d96a1c1cfa32f1b72ba9ba27b69b98a0d819dc. +// +// Solidity: event AddedBlackList(address _user) +func (_BlackList *BlackListFilterer) ParseAddedBlackList(log types.Log) (*BlackListAddedBlackList, error) { + event := new(BlackListAddedBlackList) + if err := _BlackList.contract.UnpackLog(event, "AddedBlackList", log); err != nil { + return nil, err + } + return event, nil +} + +// BlackListDestroyedBlackFundsIterator is returned from FilterDestroyedBlackFunds and is used to iterate over the raw logs and unpacked data for DestroyedBlackFunds events raised by the BlackList contract. +type BlackListDestroyedBlackFundsIterator struct { + Event *BlackListDestroyedBlackFunds // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *BlackListDestroyedBlackFundsIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(BlackListDestroyedBlackFunds) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(BlackListDestroyedBlackFunds) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *BlackListDestroyedBlackFundsIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *BlackListDestroyedBlackFundsIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// BlackListDestroyedBlackFunds represents a DestroyedBlackFunds event raised by the BlackList contract. +type BlackListDestroyedBlackFunds struct { + BlackListedUser common.Address + Balance *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDestroyedBlackFunds is a free log retrieval operation binding the contract event 0x61e6e66b0d6339b2980aecc6ccc0039736791f0ccde9ed512e789a7fbdd698c6. +// +// Solidity: event DestroyedBlackFunds(address _blackListedUser, uint256 _balance) +func (_BlackList *BlackListFilterer) FilterDestroyedBlackFunds(opts *bind.FilterOpts) (*BlackListDestroyedBlackFundsIterator, error) { + + logs, sub, err := _BlackList.contract.FilterLogs(opts, "DestroyedBlackFunds") + if err != nil { + return nil, err + } + return &BlackListDestroyedBlackFundsIterator{contract: _BlackList.contract, event: "DestroyedBlackFunds", logs: logs, sub: sub}, nil +} + +// WatchDestroyedBlackFunds is a free log subscription operation binding the contract event 0x61e6e66b0d6339b2980aecc6ccc0039736791f0ccde9ed512e789a7fbdd698c6. +// +// Solidity: event DestroyedBlackFunds(address _blackListedUser, uint256 _balance) +func (_BlackList *BlackListFilterer) WatchDestroyedBlackFunds(opts *bind.WatchOpts, sink chan<- *BlackListDestroyedBlackFunds) (event.Subscription, error) { + + logs, sub, err := _BlackList.contract.WatchLogs(opts, "DestroyedBlackFunds") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(BlackListDestroyedBlackFunds) + if err := _BlackList.contract.UnpackLog(event, "DestroyedBlackFunds", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseDestroyedBlackFunds is a log parse operation binding the contract event 0x61e6e66b0d6339b2980aecc6ccc0039736791f0ccde9ed512e789a7fbdd698c6. +// +// Solidity: event DestroyedBlackFunds(address _blackListedUser, uint256 _balance) +func (_BlackList *BlackListFilterer) ParseDestroyedBlackFunds(log types.Log) (*BlackListDestroyedBlackFunds, error) { + event := new(BlackListDestroyedBlackFunds) + if err := _BlackList.contract.UnpackLog(event, "DestroyedBlackFunds", log); err != nil { + return nil, err + } + return event, nil +} + +// BlackListRemovedBlackListIterator is returned from FilterRemovedBlackList and is used to iterate over the raw logs and unpacked data for RemovedBlackList events raised by the BlackList contract. +type BlackListRemovedBlackListIterator struct { + Event *BlackListRemovedBlackList // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *BlackListRemovedBlackListIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(BlackListRemovedBlackList) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(BlackListRemovedBlackList) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *BlackListRemovedBlackListIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *BlackListRemovedBlackListIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// BlackListRemovedBlackList represents a RemovedBlackList event raised by the BlackList contract. +type BlackListRemovedBlackList struct { + User common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRemovedBlackList is a free log retrieval operation binding the contract event 0xd7e9ec6e6ecd65492dce6bf513cd6867560d49544421d0783ddf06e76c24470c. +// +// Solidity: event RemovedBlackList(address _user) +func (_BlackList *BlackListFilterer) FilterRemovedBlackList(opts *bind.FilterOpts) (*BlackListRemovedBlackListIterator, error) { + + logs, sub, err := _BlackList.contract.FilterLogs(opts, "RemovedBlackList") + if err != nil { + return nil, err + } + return &BlackListRemovedBlackListIterator{contract: _BlackList.contract, event: "RemovedBlackList", logs: logs, sub: sub}, nil +} + +// WatchRemovedBlackList is a free log subscription operation binding the contract event 0xd7e9ec6e6ecd65492dce6bf513cd6867560d49544421d0783ddf06e76c24470c. +// +// Solidity: event RemovedBlackList(address _user) +func (_BlackList *BlackListFilterer) WatchRemovedBlackList(opts *bind.WatchOpts, sink chan<- *BlackListRemovedBlackList) (event.Subscription, error) { + + logs, sub, err := _BlackList.contract.WatchLogs(opts, "RemovedBlackList") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(BlackListRemovedBlackList) + if err := _BlackList.contract.UnpackLog(event, "RemovedBlackList", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRemovedBlackList is a log parse operation binding the contract event 0xd7e9ec6e6ecd65492dce6bf513cd6867560d49544421d0783ddf06e76c24470c. +// +// Solidity: event RemovedBlackList(address _user) +func (_BlackList *BlackListFilterer) ParseRemovedBlackList(log types.Log) (*BlackListRemovedBlackList, error) { + event := new(BlackListRemovedBlackList) + if err := _BlackList.contract.UnpackLog(event, "RemovedBlackList", log); err != nil { + return nil, err + } + return event, nil +} + +// BlackListTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the BlackList contract. +type BlackListTransferIterator struct { + Event *BlackListTransfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *BlackListTransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(BlackListTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(BlackListTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *BlackListTransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *BlackListTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// BlackListTransfer represents a Transfer event raised by the BlackList contract. +type BlackListTransfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_BlackList *BlackListFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*BlackListTransferIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _BlackList.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &BlackListTransferIterator{contract: _BlackList.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_BlackList *BlackListFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *BlackListTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _BlackList.contract.WatchLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(BlackListTransfer) + if err := _BlackList.contract.UnpackLog(event, "Transfer", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_BlackList *BlackListFilterer) ParseTransfer(log types.Log) (*BlackListTransfer, error) { + event := new(BlackListTransfer) + if err := _BlackList.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + return event, nil +} + +// ERC20ABI is the input ABI used to generate the binding from. +const ERC20ABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"spender\",\"type\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"who\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"_totalSupply1\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"owner\",\"type\":\"address\"},{\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"}]" + +// ERC20FuncSigs maps the 4-byte function signature to its string representation. +var ERC20FuncSigs = map[string]string{ + "a2e70a2e": "_totalSupply1()", + "dd62ed3e": "allowance(address,address)", + "095ea7b3": "approve(address,uint256)", + "70a08231": "balanceOf(address)", + "18160ddd": "totalSupply()", + "a9059cbb": "transfer(address,uint256)", + "23b872dd": "transferFrom(address,address,uint256)", +} + +// ERC20 is an auto generated Go binding around an Ethereum contract. +type ERC20 struct { + ERC20Caller // Read-only binding to the contract + ERC20Transactor // Write-only binding to the contract + ERC20Filterer // Log filterer for contract events +} + +// ERC20Caller is an auto generated read-only Go binding around an Ethereum contract. +type ERC20Caller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. +type ERC20Transactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ERC20Filterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ERC20Session is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ERC20Session struct { + Contract *ERC20 // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ERC20CallerSession struct { + Contract *ERC20Caller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ERC20TransactorSession struct { + Contract *ERC20Transactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ERC20Raw is an auto generated low-level Go binding around an Ethereum contract. +type ERC20Raw struct { + Contract *ERC20 // Generic contract binding to access the raw methods on +} + +// ERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ERC20CallerRaw struct { + Contract *ERC20Caller // Generic read-only contract binding to access the raw methods on +} + +// ERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ERC20TransactorRaw struct { + Contract *ERC20Transactor // Generic write-only contract binding to access the raw methods on +} + +// NewERC20 creates a new instance of ERC20, bound to a specific deployed contract. +func NewERC20(address common.Address, backend bind.ContractBackend) (*ERC20, error) { + contract, err := bindERC20(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ERC20{ERC20Caller: ERC20Caller{contract: contract}, ERC20Transactor: ERC20Transactor{contract: contract}, ERC20Filterer: ERC20Filterer{contract: contract}}, nil +} + +// NewERC20Caller creates a new read-only instance of ERC20, bound to a specific deployed contract. +func NewERC20Caller(address common.Address, caller bind.ContractCaller) (*ERC20Caller, error) { + contract, err := bindERC20(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ERC20Caller{contract: contract}, nil +} + +// NewERC20Transactor creates a new write-only instance of ERC20, bound to a specific deployed contract. +func NewERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC20Transactor, error) { + contract, err := bindERC20(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ERC20Transactor{contract: contract}, nil +} + +// NewERC20Filterer creates a new log filterer instance of ERC20, bound to a specific deployed contract. +func NewERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC20Filterer, error) { + contract, err := bindERC20(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ERC20Filterer{contract: contract}, nil +} + +// bindERC20 binds a generic wrapper to an already deployed contract. +func bindERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(ERC20ABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ERC20 *ERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _ERC20.Contract.ERC20Caller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ERC20 *ERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ERC20.Contract.ERC20Transactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ERC20 *ERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ERC20.Contract.ERC20Transactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ERC20 *ERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _ERC20.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ERC20 *ERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ERC20.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ERC20 *ERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ERC20.Contract.contract.Transact(opts, method, params...) +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_ERC20 *ERC20Caller) TotalSupply1(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _ERC20.contract.Call(opts, out, "_totalSupply1") + return *ret0, err +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_ERC20 *ERC20Session) TotalSupply1() (*big.Int, error) { + return _ERC20.Contract.TotalSupply1(&_ERC20.CallOpts) +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_ERC20 *ERC20CallerSession) TotalSupply1() (*big.Int, error) { + return _ERC20.Contract.TotalSupply1(&_ERC20.CallOpts) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_ERC20 *ERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _ERC20.contract.Call(opts, out, "allowance", owner, spender) + return *ret0, err +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_ERC20 *ERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _ERC20.Contract.Allowance(&_ERC20.CallOpts, owner, spender) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address owner, address spender) view returns(uint256) +func (_ERC20 *ERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _ERC20.Contract.Allowance(&_ERC20.CallOpts, owner, spender) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address who) view returns(uint256) +func (_ERC20 *ERC20Caller) BalanceOf(opts *bind.CallOpts, who common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _ERC20.contract.Call(opts, out, "balanceOf", who) + return *ret0, err +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address who) view returns(uint256) +func (_ERC20 *ERC20Session) BalanceOf(who common.Address) (*big.Int, error) { + return _ERC20.Contract.BalanceOf(&_ERC20.CallOpts, who) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address who) view returns(uint256) +func (_ERC20 *ERC20CallerSession) BalanceOf(who common.Address) (*big.Int, error) { + return _ERC20.Contract.BalanceOf(&_ERC20.CallOpts, who) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_ERC20 *ERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _ERC20.contract.Call(opts, out, "totalSupply") + return *ret0, err +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_ERC20 *ERC20Session) TotalSupply() (*big.Int, error) { + return _ERC20.Contract.TotalSupply(&_ERC20.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_ERC20 *ERC20CallerSession) TotalSupply() (*big.Int, error) { + return _ERC20.Contract.TotalSupply(&_ERC20.CallOpts) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 value) returns() +func (_ERC20 *ERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, value *big.Int) (*types.Transaction, error) { + return _ERC20.contract.Transact(opts, "approve", spender, value) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 value) returns() +func (_ERC20 *ERC20Session) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) { + return _ERC20.Contract.Approve(&_ERC20.TransactOpts, spender, value) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 value) returns() +func (_ERC20 *ERC20TransactorSession) Approve(spender common.Address, value *big.Int) (*types.Transaction, error) { + return _ERC20.Contract.Approve(&_ERC20.TransactOpts, spender, value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 value) returns() +func (_ERC20 *ERC20Transactor) Transfer(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error) { + return _ERC20.contract.Transact(opts, "transfer", to, value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 value) returns() +func (_ERC20 *ERC20Session) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) { + return _ERC20.Contract.Transfer(&_ERC20.TransactOpts, to, value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 value) returns() +func (_ERC20 *ERC20TransactorSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) { + return _ERC20.Contract.Transfer(&_ERC20.TransactOpts, to, value) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 value) returns() +func (_ERC20 *ERC20Transactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { + return _ERC20.contract.Transact(opts, "transferFrom", from, to, value) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 value) returns() +func (_ERC20 *ERC20Session) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { + return _ERC20.Contract.TransferFrom(&_ERC20.TransactOpts, from, to, value) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 value) returns() +func (_ERC20 *ERC20TransactorSession) TransferFrom(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { + return _ERC20.Contract.TransferFrom(&_ERC20.TransactOpts, from, to, value) +} + +// ERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC20 contract. +type ERC20ApprovalIterator struct { + Event *ERC20Approval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ERC20ApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ERC20Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ERC20Approval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ERC20ApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ERC20ApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ERC20Approval represents a Approval event raised by the ERC20 contract. +type ERC20Approval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_ERC20 *ERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20ApprovalIterator, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _ERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &ERC20ApprovalIterator{contract: _ERC20.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_ERC20 *ERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _ERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ERC20Approval) + if err := _ERC20.contract.UnpackLog(event, "Approval", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_ERC20 *ERC20Filterer) ParseApproval(log types.Log) (*ERC20Approval, error) { + event := new(ERC20Approval) + if err := _ERC20.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + return event, nil +} + +// ERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20 contract. +type ERC20TransferIterator struct { + Event *ERC20Transfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ERC20TransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ERC20Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ERC20Transfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ERC20TransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ERC20TransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ERC20Transfer represents a Transfer event raised by the ERC20 contract. +type ERC20Transfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ERC20 *ERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20TransferIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &ERC20TransferIterator{contract: _ERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ERC20 *ERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ERC20Transfer) + if err := _ERC20.contract.UnpackLog(event, "Transfer", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ERC20 *ERC20Filterer) ParseTransfer(log types.Log) (*ERC20Transfer, error) { + event := new(ERC20Transfer) + if err := _ERC20.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + return event, nil +} + +// ERC20BasicABI is the input ABI used to generate the binding from. +const ERC20BasicABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"who\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"_totalSupply1\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"}]" + +// ERC20BasicFuncSigs maps the 4-byte function signature to its string representation. +var ERC20BasicFuncSigs = map[string]string{ + "a2e70a2e": "_totalSupply1()", + "70a08231": "balanceOf(address)", + "18160ddd": "totalSupply()", + "a9059cbb": "transfer(address,uint256)", +} + +// ERC20Basic is an auto generated Go binding around an Ethereum contract. +type ERC20Basic struct { + ERC20BasicCaller // Read-only binding to the contract + ERC20BasicTransactor // Write-only binding to the contract + ERC20BasicFilterer // Log filterer for contract events +} + +// ERC20BasicCaller is an auto generated read-only Go binding around an Ethereum contract. +type ERC20BasicCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ERC20BasicTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ERC20BasicTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ERC20BasicFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ERC20BasicFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ERC20BasicSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ERC20BasicSession struct { + Contract *ERC20Basic // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ERC20BasicCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ERC20BasicCallerSession struct { + Contract *ERC20BasicCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ERC20BasicTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ERC20BasicTransactorSession struct { + Contract *ERC20BasicTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ERC20BasicRaw is an auto generated low-level Go binding around an Ethereum contract. +type ERC20BasicRaw struct { + Contract *ERC20Basic // Generic contract binding to access the raw methods on +} + +// ERC20BasicCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ERC20BasicCallerRaw struct { + Contract *ERC20BasicCaller // Generic read-only contract binding to access the raw methods on +} + +// ERC20BasicTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ERC20BasicTransactorRaw struct { + Contract *ERC20BasicTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewERC20Basic creates a new instance of ERC20Basic, bound to a specific deployed contract. +func NewERC20Basic(address common.Address, backend bind.ContractBackend) (*ERC20Basic, error) { + contract, err := bindERC20Basic(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ERC20Basic{ERC20BasicCaller: ERC20BasicCaller{contract: contract}, ERC20BasicTransactor: ERC20BasicTransactor{contract: contract}, ERC20BasicFilterer: ERC20BasicFilterer{contract: contract}}, nil +} + +// NewERC20BasicCaller creates a new read-only instance of ERC20Basic, bound to a specific deployed contract. +func NewERC20BasicCaller(address common.Address, caller bind.ContractCaller) (*ERC20BasicCaller, error) { + contract, err := bindERC20Basic(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ERC20BasicCaller{contract: contract}, nil +} + +// NewERC20BasicTransactor creates a new write-only instance of ERC20Basic, bound to a specific deployed contract. +func NewERC20BasicTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20BasicTransactor, error) { + contract, err := bindERC20Basic(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ERC20BasicTransactor{contract: contract}, nil +} + +// NewERC20BasicFilterer creates a new log filterer instance of ERC20Basic, bound to a specific deployed contract. +func NewERC20BasicFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20BasicFilterer, error) { + contract, err := bindERC20Basic(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ERC20BasicFilterer{contract: contract}, nil +} + +// bindERC20Basic binds a generic wrapper to an already deployed contract. +func bindERC20Basic(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(ERC20BasicABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ERC20Basic *ERC20BasicRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _ERC20Basic.Contract.ERC20BasicCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ERC20Basic *ERC20BasicRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ERC20Basic.Contract.ERC20BasicTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ERC20Basic *ERC20BasicRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ERC20Basic.Contract.ERC20BasicTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ERC20Basic *ERC20BasicCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _ERC20Basic.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ERC20Basic *ERC20BasicTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ERC20Basic.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ERC20Basic *ERC20BasicTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ERC20Basic.Contract.contract.Transact(opts, method, params...) +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_ERC20Basic *ERC20BasicCaller) TotalSupply1(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _ERC20Basic.contract.Call(opts, out, "_totalSupply1") + return *ret0, err +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_ERC20Basic *ERC20BasicSession) TotalSupply1() (*big.Int, error) { + return _ERC20Basic.Contract.TotalSupply1(&_ERC20Basic.CallOpts) +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_ERC20Basic *ERC20BasicCallerSession) TotalSupply1() (*big.Int, error) { + return _ERC20Basic.Contract.TotalSupply1(&_ERC20Basic.CallOpts) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address who) view returns(uint256) +func (_ERC20Basic *ERC20BasicCaller) BalanceOf(opts *bind.CallOpts, who common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _ERC20Basic.contract.Call(opts, out, "balanceOf", who) + return *ret0, err +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address who) view returns(uint256) +func (_ERC20Basic *ERC20BasicSession) BalanceOf(who common.Address) (*big.Int, error) { + return _ERC20Basic.Contract.BalanceOf(&_ERC20Basic.CallOpts, who) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address who) view returns(uint256) +func (_ERC20Basic *ERC20BasicCallerSession) BalanceOf(who common.Address) (*big.Int, error) { + return _ERC20Basic.Contract.BalanceOf(&_ERC20Basic.CallOpts, who) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_ERC20Basic *ERC20BasicCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _ERC20Basic.contract.Call(opts, out, "totalSupply") + return *ret0, err +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_ERC20Basic *ERC20BasicSession) TotalSupply() (*big.Int, error) { + return _ERC20Basic.Contract.TotalSupply(&_ERC20Basic.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_ERC20Basic *ERC20BasicCallerSession) TotalSupply() (*big.Int, error) { + return _ERC20Basic.Contract.TotalSupply(&_ERC20Basic.CallOpts) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 value) returns() +func (_ERC20Basic *ERC20BasicTransactor) Transfer(opts *bind.TransactOpts, to common.Address, value *big.Int) (*types.Transaction, error) { + return _ERC20Basic.contract.Transact(opts, "transfer", to, value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 value) returns() +func (_ERC20Basic *ERC20BasicSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) { + return _ERC20Basic.Contract.Transfer(&_ERC20Basic.TransactOpts, to, value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 value) returns() +func (_ERC20Basic *ERC20BasicTransactorSession) Transfer(to common.Address, value *big.Int) (*types.Transaction, error) { + return _ERC20Basic.Contract.Transfer(&_ERC20Basic.TransactOpts, to, value) +} + +// ERC20BasicTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20Basic contract. +type ERC20BasicTransferIterator struct { + Event *ERC20BasicTransfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ERC20BasicTransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ERC20BasicTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ERC20BasicTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ERC20BasicTransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ERC20BasicTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ERC20BasicTransfer represents a Transfer event raised by the ERC20Basic contract. +type ERC20BasicTransfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ERC20Basic *ERC20BasicFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20BasicTransferIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ERC20Basic.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &ERC20BasicTransferIterator{contract: _ERC20Basic.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ERC20Basic *ERC20BasicFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20BasicTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _ERC20Basic.contract.WatchLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ERC20BasicTransfer) + if err := _ERC20Basic.contract.UnpackLog(event, "Transfer", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_ERC20Basic *ERC20BasicFilterer) ParseTransfer(log types.Log) (*ERC20BasicTransfer, error) { + event := new(ERC20BasicTransfer) + if err := _ERC20Basic.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + return event, nil +} + +// OwnableABI is the input ABI used to generate the binding from. +const OwnableABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]" + +// OwnableFuncSigs maps the 4-byte function signature to its string representation. +var OwnableFuncSigs = map[string]string{ + "8da5cb5b": "owner()", + "f2fde38b": "transferOwnership(address)", +} + +// OwnableBin is the compiled bytecode used for deploying new contracts. +var OwnableBin = "0x6060604052341561000f57600080fd5b60008054600160a060020a033316600160a060020a031990911617905561011e8061003b6000396000f300606060405263ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416638da5cb5b81146045578063f2fde38b14607157600080fd5b3415604f57600080fd5b6055608f565b604051600160a060020a03909116815260200160405180910390f35b3415607b57600080fd5b608d600160a060020a0360043516609e565b005b600054600160a060020a031681565b60005433600160a060020a0390811691161460b857600080fd5b600160a060020a0381161560ef576000805473ffffffffffffffffffffffffffffffffffffffff1916600160a060020a0383161790555b505600a165627a7a723058202633f1f812970e5a09fadf4083772f22d9e255f786273885df2a9e5a0ce077670029" + +// DeployOwnable deploys a new Ethereum contract, binding an instance of Ownable to it. +func DeployOwnable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Ownable, error) { + parsed, err := abi.JSON(strings.NewReader(OwnableABI)) + if err != nil { + return common.Address{}, nil, nil, err + } + + address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(OwnableBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Ownable{OwnableCaller: OwnableCaller{contract: contract}, OwnableTransactor: OwnableTransactor{contract: contract}, OwnableFilterer: OwnableFilterer{contract: contract}}, nil +} + +// Ownable is an auto generated Go binding around an Ethereum contract. +type Ownable struct { + OwnableCaller // Read-only binding to the contract + OwnableTransactor // Write-only binding to the contract + OwnableFilterer // Log filterer for contract events +} + +// OwnableCaller is an auto generated read-only Go binding around an Ethereum contract. +type OwnableCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OwnableTransactor is an auto generated write-only Go binding around an Ethereum contract. +type OwnableTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OwnableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type OwnableFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// OwnableSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type OwnableSession struct { + Contract *Ownable // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// OwnableCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type OwnableCallerSession struct { + Contract *OwnableCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// OwnableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type OwnableTransactorSession struct { + Contract *OwnableTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// OwnableRaw is an auto generated low-level Go binding around an Ethereum contract. +type OwnableRaw struct { + Contract *Ownable // Generic contract binding to access the raw methods on +} + +// OwnableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type OwnableCallerRaw struct { + Contract *OwnableCaller // Generic read-only contract binding to access the raw methods on +} + +// OwnableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type OwnableTransactorRaw struct { + Contract *OwnableTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewOwnable creates a new instance of Ownable, bound to a specific deployed contract. +func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error) { + contract, err := bindOwnable(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Ownable{OwnableCaller: OwnableCaller{contract: contract}, OwnableTransactor: OwnableTransactor{contract: contract}, OwnableFilterer: OwnableFilterer{contract: contract}}, nil +} + +// NewOwnableCaller creates a new read-only instance of Ownable, bound to a specific deployed contract. +func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error) { + contract, err := bindOwnable(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &OwnableCaller{contract: contract}, nil +} + +// NewOwnableTransactor creates a new write-only instance of Ownable, bound to a specific deployed contract. +func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error) { + contract, err := bindOwnable(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &OwnableTransactor{contract: contract}, nil +} + +// NewOwnableFilterer creates a new log filterer instance of Ownable, bound to a specific deployed contract. +func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error) { + contract, err := bindOwnable(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &OwnableFilterer{contract: contract}, nil +} + +// bindOwnable binds a generic wrapper to an already deployed contract. +func bindOwnable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(OwnableABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Ownable *OwnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _Ownable.Contract.OwnableCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Ownable.Contract.OwnableTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Ownable *OwnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Ownable.Contract.OwnableTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Ownable *OwnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _Ownable.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Ownable.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Ownable *OwnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Ownable.Contract.contract.Transact(opts, method, params...) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var ( + ret0 = new(common.Address) + ) + out := ret0 + err := _Ownable.contract.Call(opts, out, "owner") + return *ret0, err +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Ownable *OwnableSession) Owner() (common.Address, error) { + return _Ownable.Contract.Owner(&_Ownable.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Ownable *OwnableCallerSession) Owner() (common.Address, error) { + return _Ownable.Contract.Owner(&_Ownable.CallOpts) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Ownable *OwnableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _Ownable.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner) +} + +// PausableABI is the input ABI used to generate the binding from. +const PausableABI = "[{\"constant\":false,\"inputs\":[],\"name\":\"unpause\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"pause\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"Pause\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"Unpause\",\"type\":\"event\"}]" + +// PausableFuncSigs maps the 4-byte function signature to its string representation. +var PausableFuncSigs = map[string]string{ + "8da5cb5b": "owner()", + "8456cb59": "pause()", + "5c975abb": "paused()", + "f2fde38b": "transferOwnership(address)", + "3f4ba83a": "unpause()", +} + +// PausableBin is the compiled bytecode used for deploying new contracts. +var PausableBin = "0x606060405260008054600160a060020a033316600160a860020a03199091161790556102a9806100306000396000f300606060405263ffffffff7c01000000000000000000000000000000000000000000000000000000006000350416633f4ba83a81146100685780635c975abb1461007d5780638456cb59146100a45780638da5cb5b146100b7578063f2fde38b146100e657600080fd5b341561007357600080fd5b61007b610105565b005b341561008857600080fd5b610090610184565b604051901515815260200160405180910390f35b34156100af57600080fd5b61007b610194565b34156100c257600080fd5b6100ca610218565b604051600160a060020a03909116815260200160405180910390f35b34156100f157600080fd5b61007b600160a060020a0360043516610227565b60005433600160a060020a0390811691161461012057600080fd5b60005460a060020a900460ff16151561013857600080fd5b6000805474ff0000000000000000000000000000000000000000191690557f7805862f689e2f13df9f062ff482ad3ad112aca9e0847911ed832e158c525b3360405160405180910390a1565b60005460a060020a900460ff1681565b60005433600160a060020a039081169116146101af57600080fd5b60005460a060020a900460ff16156101c657600080fd5b6000805474ff0000000000000000000000000000000000000000191660a060020a1790557f6985a02210a168e66602d3235cb6db0e70f92b3ba4d376a33c0f3d9434bff62560405160405180910390a1565b600054600160a060020a031681565b60005433600160a060020a0390811691161461024257600080fd5b600160a060020a0381161561027a576000805473ffffffffffffffffffffffffffffffffffffffff1916600160a060020a0383161790555b505600a165627a7a72305820eb136834149cee21edb995bea32970d15a50b87033e998831c276504ff1d7e280029" + +// DeployPausable deploys a new Ethereum contract, binding an instance of Pausable to it. +func DeployPausable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Pausable, error) { + parsed, err := abi.JSON(strings.NewReader(PausableABI)) + if err != nil { + return common.Address{}, nil, nil, err + } + + address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(PausableBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Pausable{PausableCaller: PausableCaller{contract: contract}, PausableTransactor: PausableTransactor{contract: contract}, PausableFilterer: PausableFilterer{contract: contract}}, nil +} + +// Pausable is an auto generated Go binding around an Ethereum contract. +type Pausable struct { + PausableCaller // Read-only binding to the contract + PausableTransactor // Write-only binding to the contract + PausableFilterer // Log filterer for contract events +} + +// PausableCaller is an auto generated read-only Go binding around an Ethereum contract. +type PausableCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PausableTransactor is an auto generated write-only Go binding around an Ethereum contract. +type PausableTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PausableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type PausableFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// PausableSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type PausableSession struct { + Contract *Pausable // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PausableCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type PausableCallerSession struct { + Contract *PausableCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// PausableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type PausableTransactorSession struct { + Contract *PausableTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// PausableRaw is an auto generated low-level Go binding around an Ethereum contract. +type PausableRaw struct { + Contract *Pausable // Generic contract binding to access the raw methods on +} + +// PausableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type PausableCallerRaw struct { + Contract *PausableCaller // Generic read-only contract binding to access the raw methods on +} + +// PausableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type PausableTransactorRaw struct { + Contract *PausableTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewPausable creates a new instance of Pausable, bound to a specific deployed contract. +func NewPausable(address common.Address, backend bind.ContractBackend) (*Pausable, error) { + contract, err := bindPausable(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Pausable{PausableCaller: PausableCaller{contract: contract}, PausableTransactor: PausableTransactor{contract: contract}, PausableFilterer: PausableFilterer{contract: contract}}, nil +} + +// NewPausableCaller creates a new read-only instance of Pausable, bound to a specific deployed contract. +func NewPausableCaller(address common.Address, caller bind.ContractCaller) (*PausableCaller, error) { + contract, err := bindPausable(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &PausableCaller{contract: contract}, nil +} + +// NewPausableTransactor creates a new write-only instance of Pausable, bound to a specific deployed contract. +func NewPausableTransactor(address common.Address, transactor bind.ContractTransactor) (*PausableTransactor, error) { + contract, err := bindPausable(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &PausableTransactor{contract: contract}, nil +} + +// NewPausableFilterer creates a new log filterer instance of Pausable, bound to a specific deployed contract. +func NewPausableFilterer(address common.Address, filterer bind.ContractFilterer) (*PausableFilterer, error) { + contract, err := bindPausable(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &PausableFilterer{contract: contract}, nil +} + +// bindPausable binds a generic wrapper to an already deployed contract. +func bindPausable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(PausableABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Pausable *PausableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _Pausable.Contract.PausableCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Pausable *PausableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pausable.Contract.PausableTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Pausable *PausableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Pausable.Contract.PausableTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_Pausable *PausableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _Pausable.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_Pausable *PausableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pausable.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Pausable *PausableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Pausable.Contract.contract.Transact(opts, method, params...) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Pausable *PausableCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var ( + ret0 = new(common.Address) + ) + out := ret0 + err := _Pausable.contract.Call(opts, out, "owner") + return *ret0, err +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Pausable *PausableSession) Owner() (common.Address, error) { + return _Pausable.Contract.Owner(&_Pausable.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Pausable *PausableCallerSession) Owner() (common.Address, error) { + return _Pausable.Contract.Owner(&_Pausable.CallOpts) +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_Pausable *PausableCaller) Paused(opts *bind.CallOpts) (bool, error) { + var ( + ret0 = new(bool) + ) + out := ret0 + err := _Pausable.contract.Call(opts, out, "paused") + return *ret0, err +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_Pausable *PausableSession) Paused() (bool, error) { + return _Pausable.Contract.Paused(&_Pausable.CallOpts) +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_Pausable *PausableCallerSession) Paused() (bool, error) { + return _Pausable.Contract.Paused(&_Pausable.CallOpts) +} + +// Pause is a paid mutator transaction binding the contract method 0x8456cb59. +// +// Solidity: function pause() returns() +func (_Pausable *PausableTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pausable.contract.Transact(opts, "pause") +} + +// Pause is a paid mutator transaction binding the contract method 0x8456cb59. +// +// Solidity: function pause() returns() +func (_Pausable *PausableSession) Pause() (*types.Transaction, error) { + return _Pausable.Contract.Pause(&_Pausable.TransactOpts) +} + +// Pause is a paid mutator transaction binding the contract method 0x8456cb59. +// +// Solidity: function pause() returns() +func (_Pausable *PausableTransactorSession) Pause() (*types.Transaction, error) { + return _Pausable.Contract.Pause(&_Pausable.TransactOpts) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Pausable *PausableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _Pausable.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Pausable *PausableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Pausable.Contract.TransferOwnership(&_Pausable.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Pausable *PausableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Pausable.Contract.TransferOwnership(&_Pausable.TransactOpts, newOwner) +} + +// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a. +// +// Solidity: function unpause() returns() +func (_Pausable *PausableTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Pausable.contract.Transact(opts, "unpause") +} + +// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a. +// +// Solidity: function unpause() returns() +func (_Pausable *PausableSession) Unpause() (*types.Transaction, error) { + return _Pausable.Contract.Unpause(&_Pausable.TransactOpts) +} + +// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a. +// +// Solidity: function unpause() returns() +func (_Pausable *PausableTransactorSession) Unpause() (*types.Transaction, error) { + return _Pausable.Contract.Unpause(&_Pausable.TransactOpts) +} + +// PausablePauseIterator is returned from FilterPause and is used to iterate over the raw logs and unpacked data for Pause events raised by the Pausable contract. +type PausablePauseIterator struct { + Event *PausablePause // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PausablePauseIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PausablePause) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PausablePause) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PausablePauseIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PausablePauseIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PausablePause represents a Pause event raised by the Pausable contract. +type PausablePause struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterPause is a free log retrieval operation binding the contract event 0x6985a02210a168e66602d3235cb6db0e70f92b3ba4d376a33c0f3d9434bff625. +// +// Solidity: event Pause() +func (_Pausable *PausableFilterer) FilterPause(opts *bind.FilterOpts) (*PausablePauseIterator, error) { + + logs, sub, err := _Pausable.contract.FilterLogs(opts, "Pause") + if err != nil { + return nil, err + } + return &PausablePauseIterator{contract: _Pausable.contract, event: "Pause", logs: logs, sub: sub}, nil +} + +// WatchPause is a free log subscription operation binding the contract event 0x6985a02210a168e66602d3235cb6db0e70f92b3ba4d376a33c0f3d9434bff625. +// +// Solidity: event Pause() +func (_Pausable *PausableFilterer) WatchPause(opts *bind.WatchOpts, sink chan<- *PausablePause) (event.Subscription, error) { + + logs, sub, err := _Pausable.contract.WatchLogs(opts, "Pause") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PausablePause) + if err := _Pausable.contract.UnpackLog(event, "Pause", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParsePause is a log parse operation binding the contract event 0x6985a02210a168e66602d3235cb6db0e70f92b3ba4d376a33c0f3d9434bff625. +// +// Solidity: event Pause() +func (_Pausable *PausableFilterer) ParsePause(log types.Log) (*PausablePause, error) { + event := new(PausablePause) + if err := _Pausable.contract.UnpackLog(event, "Pause", log); err != nil { + return nil, err + } + return event, nil +} + +// PausableUnpauseIterator is returned from FilterUnpause and is used to iterate over the raw logs and unpacked data for Unpause events raised by the Pausable contract. +type PausableUnpauseIterator struct { + Event *PausableUnpause // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *PausableUnpauseIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(PausableUnpause) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(PausableUnpause) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *PausableUnpauseIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *PausableUnpauseIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// PausableUnpause represents a Unpause event raised by the Pausable contract. +type PausableUnpause struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUnpause is a free log retrieval operation binding the contract event 0x7805862f689e2f13df9f062ff482ad3ad112aca9e0847911ed832e158c525b33. +// +// Solidity: event Unpause() +func (_Pausable *PausableFilterer) FilterUnpause(opts *bind.FilterOpts) (*PausableUnpauseIterator, error) { + + logs, sub, err := _Pausable.contract.FilterLogs(opts, "Unpause") + if err != nil { + return nil, err + } + return &PausableUnpauseIterator{contract: _Pausable.contract, event: "Unpause", logs: logs, sub: sub}, nil +} + +// WatchUnpause is a free log subscription operation binding the contract event 0x7805862f689e2f13df9f062ff482ad3ad112aca9e0847911ed832e158c525b33. +// +// Solidity: event Unpause() +func (_Pausable *PausableFilterer) WatchUnpause(opts *bind.WatchOpts, sink chan<- *PausableUnpause) (event.Subscription, error) { + + logs, sub, err := _Pausable.contract.WatchLogs(opts, "Unpause") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(PausableUnpause) + if err := _Pausable.contract.UnpackLog(event, "Unpause", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUnpause is a log parse operation binding the contract event 0x7805862f689e2f13df9f062ff482ad3ad112aca9e0847911ed832e158c525b33. +// +// Solidity: event Unpause() +func (_Pausable *PausableFilterer) ParseUnpause(log types.Log) (*PausableUnpause, error) { + event := new(PausableUnpause) + if err := _Pausable.contract.UnpackLog(event, "Unpause", log); err != nil { + return nil, err + } + return event, nil +} + +// SafeMathABI is the input ABI used to generate the binding from. +const SafeMathABI = "[]" + +// SafeMathBin is the compiled bytecode used for deploying new contracts. +var SafeMathBin = "0x60606040523415600e57600080fd5b603580601b6000396000f3006060604052600080fd00a165627a7a723058200d34b52bac249cb510967a8d60a3ade741eab4688c744694786260e1d3a44e880029" + +// DeploySafeMath deploys a new Ethereum contract, binding an instance of SafeMath to it. +func DeploySafeMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeMath, error) { + parsed, err := abi.JSON(strings.NewReader(SafeMathABI)) + if err != nil { + return common.Address{}, nil, nil, err + } + + address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SafeMathBin), backend) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil +} + +// SafeMath is an auto generated Go binding around an Ethereum contract. +type SafeMath struct { + SafeMathCaller // Read-only binding to the contract + SafeMathTransactor // Write-only binding to the contract + SafeMathFilterer // Log filterer for contract events +} + +// SafeMathCaller is an auto generated read-only Go binding around an Ethereum contract. +type SafeMathCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// SafeMathTransactor is an auto generated write-only Go binding around an Ethereum contract. +type SafeMathTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// SafeMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type SafeMathFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// SafeMathSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type SafeMathSession struct { + Contract *SafeMath // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// SafeMathCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type SafeMathCallerSession struct { + Contract *SafeMathCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// SafeMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type SafeMathTransactorSession struct { + Contract *SafeMathTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// SafeMathRaw is an auto generated low-level Go binding around an Ethereum contract. +type SafeMathRaw struct { + Contract *SafeMath // Generic contract binding to access the raw methods on +} + +// SafeMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type SafeMathCallerRaw struct { + Contract *SafeMathCaller // Generic read-only contract binding to access the raw methods on +} + +// SafeMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type SafeMathTransactorRaw struct { + Contract *SafeMathTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewSafeMath creates a new instance of SafeMath, bound to a specific deployed contract. +func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error) { + contract, err := bindSafeMath(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil +} + +// NewSafeMathCaller creates a new read-only instance of SafeMath, bound to a specific deployed contract. +func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error) { + contract, err := bindSafeMath(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &SafeMathCaller{contract: contract}, nil +} + +// NewSafeMathTransactor creates a new write-only instance of SafeMath, bound to a specific deployed contract. +func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error) { + contract, err := bindSafeMath(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &SafeMathTransactor{contract: contract}, nil +} + +// NewSafeMathFilterer creates a new log filterer instance of SafeMath, bound to a specific deployed contract. +func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error) { + contract, err := bindSafeMath(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &SafeMathFilterer{contract: contract}, nil +} + +// bindSafeMath binds a generic wrapper to an already deployed contract. +func bindSafeMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(SafeMathABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _SafeMath.Contract.SafeMathCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _SafeMath.Contract.SafeMathTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_SafeMath *SafeMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _SafeMath.Contract.SafeMathTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _SafeMath.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _SafeMath.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_SafeMath *SafeMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _SafeMath.Contract.contract.Transact(opts, method, params...) +} + +// StandardTokenABI is the input ABI used to generate the binding from. +const StandardTokenABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"_spender\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_from\",\"type\":\"address\"},{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"balances\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"maximumFee\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"},{\"name\":\"\",\"type\":\"address\"}],\"name\":\"allowed\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"balance\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"_totalSupply1\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"},{\"name\":\"_spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"name\":\"remaining\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"basisPointsRate\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"MAX_UINT\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"}]" + +// StandardTokenFuncSigs maps the 4-byte function signature to its string representation. +var StandardTokenFuncSigs = map[string]string{ + "e5b5019a": "MAX_UINT()", + "a2e70a2e": "_totalSupply1()", + "dd62ed3e": "allowance(address,address)", + "5c658165": "allowed(address,address)", + "095ea7b3": "approve(address,uint256)", + "70a08231": "balanceOf(address)", + "27e235e3": "balances(address)", + "dd644f72": "basisPointsRate()", + "35390714": "maximumFee()", + "8da5cb5b": "owner()", + "18160ddd": "totalSupply()", + "a9059cbb": "transfer(address,uint256)", + "23b872dd": "transferFrom(address,address,uint256)", + "f2fde38b": "transferOwnership(address)", +} + +// StandardToken is an auto generated Go binding around an Ethereum contract. +type StandardToken struct { + StandardTokenCaller // Read-only binding to the contract + StandardTokenTransactor // Write-only binding to the contract + StandardTokenFilterer // Log filterer for contract events +} + +// StandardTokenCaller is an auto generated read-only Go binding around an Ethereum contract. +type StandardTokenCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StandardTokenTransactor is an auto generated write-only Go binding around an Ethereum contract. +type StandardTokenTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StandardTokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type StandardTokenFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// StandardTokenSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type StandardTokenSession struct { + Contract *StandardToken // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StandardTokenCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type StandardTokenCallerSession struct { + Contract *StandardTokenCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// StandardTokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type StandardTokenTransactorSession struct { + Contract *StandardTokenTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// StandardTokenRaw is an auto generated low-level Go binding around an Ethereum contract. +type StandardTokenRaw struct { + Contract *StandardToken // Generic contract binding to access the raw methods on +} + +// StandardTokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type StandardTokenCallerRaw struct { + Contract *StandardTokenCaller // Generic read-only contract binding to access the raw methods on +} + +// StandardTokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type StandardTokenTransactorRaw struct { + Contract *StandardTokenTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewStandardToken creates a new instance of StandardToken, bound to a specific deployed contract. +func NewStandardToken(address common.Address, backend bind.ContractBackend) (*StandardToken, error) { + contract, err := bindStandardToken(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &StandardToken{StandardTokenCaller: StandardTokenCaller{contract: contract}, StandardTokenTransactor: StandardTokenTransactor{contract: contract}, StandardTokenFilterer: StandardTokenFilterer{contract: contract}}, nil +} + +// NewStandardTokenCaller creates a new read-only instance of StandardToken, bound to a specific deployed contract. +func NewStandardTokenCaller(address common.Address, caller bind.ContractCaller) (*StandardTokenCaller, error) { + contract, err := bindStandardToken(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &StandardTokenCaller{contract: contract}, nil +} + +// NewStandardTokenTransactor creates a new write-only instance of StandardToken, bound to a specific deployed contract. +func NewStandardTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*StandardTokenTransactor, error) { + contract, err := bindStandardToken(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &StandardTokenTransactor{contract: contract}, nil +} + +// NewStandardTokenFilterer creates a new log filterer instance of StandardToken, bound to a specific deployed contract. +func NewStandardTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*StandardTokenFilterer, error) { + contract, err := bindStandardToken(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &StandardTokenFilterer{contract: contract}, nil +} + +// bindStandardToken binds a generic wrapper to an already deployed contract. +func bindStandardToken(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(StandardTokenABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StandardToken *StandardTokenRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _StandardToken.Contract.StandardTokenCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StandardToken *StandardTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StandardToken.Contract.StandardTokenTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StandardToken *StandardTokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StandardToken.Contract.StandardTokenTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_StandardToken *StandardTokenCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _StandardToken.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_StandardToken *StandardTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _StandardToken.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_StandardToken *StandardTokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _StandardToken.Contract.contract.Transact(opts, method, params...) +} + +// MAXUINT is a free data retrieval call binding the contract method 0xe5b5019a. +// +// Solidity: function MAX_UINT() view returns(uint256) +func (_StandardToken *StandardTokenCaller) MAXUINT(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _StandardToken.contract.Call(opts, out, "MAX_UINT") + return *ret0, err +} + +// MAXUINT is a free data retrieval call binding the contract method 0xe5b5019a. +// +// Solidity: function MAX_UINT() view returns(uint256) +func (_StandardToken *StandardTokenSession) MAXUINT() (*big.Int, error) { + return _StandardToken.Contract.MAXUINT(&_StandardToken.CallOpts) +} + +// MAXUINT is a free data retrieval call binding the contract method 0xe5b5019a. +// +// Solidity: function MAX_UINT() view returns(uint256) +func (_StandardToken *StandardTokenCallerSession) MAXUINT() (*big.Int, error) { + return _StandardToken.Contract.MAXUINT(&_StandardToken.CallOpts) +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_StandardToken *StandardTokenCaller) TotalSupply1(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _StandardToken.contract.Call(opts, out, "_totalSupply1") + return *ret0, err +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_StandardToken *StandardTokenSession) TotalSupply1() (*big.Int, error) { + return _StandardToken.Contract.TotalSupply1(&_StandardToken.CallOpts) +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_StandardToken *StandardTokenCallerSession) TotalSupply1() (*big.Int, error) { + return _StandardToken.Contract.TotalSupply1(&_StandardToken.CallOpts) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining) +func (_StandardToken *StandardTokenCaller) Allowance(opts *bind.CallOpts, _owner common.Address, _spender common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _StandardToken.contract.Call(opts, out, "allowance", _owner, _spender) + return *ret0, err +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining) +func (_StandardToken *StandardTokenSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) { + return _StandardToken.Contract.Allowance(&_StandardToken.CallOpts, _owner, _spender) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining) +func (_StandardToken *StandardTokenCallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) { + return _StandardToken.Contract.Allowance(&_StandardToken.CallOpts, _owner, _spender) +} + +// Allowed is a free data retrieval call binding the contract method 0x5c658165. +// +// Solidity: function allowed(address , address ) view returns(uint256) +func (_StandardToken *StandardTokenCaller) Allowed(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _StandardToken.contract.Call(opts, out, "allowed", arg0, arg1) + return *ret0, err +} + +// Allowed is a free data retrieval call binding the contract method 0x5c658165. +// +// Solidity: function allowed(address , address ) view returns(uint256) +func (_StandardToken *StandardTokenSession) Allowed(arg0 common.Address, arg1 common.Address) (*big.Int, error) { + return _StandardToken.Contract.Allowed(&_StandardToken.CallOpts, arg0, arg1) +} + +// Allowed is a free data retrieval call binding the contract method 0x5c658165. +// +// Solidity: function allowed(address , address ) view returns(uint256) +func (_StandardToken *StandardTokenCallerSession) Allowed(arg0 common.Address, arg1 common.Address) (*big.Int, error) { + return _StandardToken.Contract.Allowed(&_StandardToken.CallOpts, arg0, arg1) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256 balance) +func (_StandardToken *StandardTokenCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _StandardToken.contract.Call(opts, out, "balanceOf", _owner) + return *ret0, err +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256 balance) +func (_StandardToken *StandardTokenSession) BalanceOf(_owner common.Address) (*big.Int, error) { + return _StandardToken.Contract.BalanceOf(&_StandardToken.CallOpts, _owner) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256 balance) +func (_StandardToken *StandardTokenCallerSession) BalanceOf(_owner common.Address) (*big.Int, error) { + return _StandardToken.Contract.BalanceOf(&_StandardToken.CallOpts, _owner) +} + +// Balances is a free data retrieval call binding the contract method 0x27e235e3. +// +// Solidity: function balances(address ) view returns(uint256) +func (_StandardToken *StandardTokenCaller) Balances(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _StandardToken.contract.Call(opts, out, "balances", arg0) + return *ret0, err +} + +// Balances is a free data retrieval call binding the contract method 0x27e235e3. +// +// Solidity: function balances(address ) view returns(uint256) +func (_StandardToken *StandardTokenSession) Balances(arg0 common.Address) (*big.Int, error) { + return _StandardToken.Contract.Balances(&_StandardToken.CallOpts, arg0) +} + +// Balances is a free data retrieval call binding the contract method 0x27e235e3. +// +// Solidity: function balances(address ) view returns(uint256) +func (_StandardToken *StandardTokenCallerSession) Balances(arg0 common.Address) (*big.Int, error) { + return _StandardToken.Contract.Balances(&_StandardToken.CallOpts, arg0) +} + +// BasisPointsRate is a free data retrieval call binding the contract method 0xdd644f72. +// +// Solidity: function basisPointsRate() view returns(uint256) +func (_StandardToken *StandardTokenCaller) BasisPointsRate(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _StandardToken.contract.Call(opts, out, "basisPointsRate") + return *ret0, err +} + +// BasisPointsRate is a free data retrieval call binding the contract method 0xdd644f72. +// +// Solidity: function basisPointsRate() view returns(uint256) +func (_StandardToken *StandardTokenSession) BasisPointsRate() (*big.Int, error) { + return _StandardToken.Contract.BasisPointsRate(&_StandardToken.CallOpts) +} + +// BasisPointsRate is a free data retrieval call binding the contract method 0xdd644f72. +// +// Solidity: function basisPointsRate() view returns(uint256) +func (_StandardToken *StandardTokenCallerSession) BasisPointsRate() (*big.Int, error) { + return _StandardToken.Contract.BasisPointsRate(&_StandardToken.CallOpts) +} + +// MaximumFee is a free data retrieval call binding the contract method 0x35390714. +// +// Solidity: function maximumFee() view returns(uint256) +func (_StandardToken *StandardTokenCaller) MaximumFee(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _StandardToken.contract.Call(opts, out, "maximumFee") + return *ret0, err +} + +// MaximumFee is a free data retrieval call binding the contract method 0x35390714. +// +// Solidity: function maximumFee() view returns(uint256) +func (_StandardToken *StandardTokenSession) MaximumFee() (*big.Int, error) { + return _StandardToken.Contract.MaximumFee(&_StandardToken.CallOpts) +} + +// MaximumFee is a free data retrieval call binding the contract method 0x35390714. +// +// Solidity: function maximumFee() view returns(uint256) +func (_StandardToken *StandardTokenCallerSession) MaximumFee() (*big.Int, error) { + return _StandardToken.Contract.MaximumFee(&_StandardToken.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_StandardToken *StandardTokenCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var ( + ret0 = new(common.Address) + ) + out := ret0 + err := _StandardToken.contract.Call(opts, out, "owner") + return *ret0, err +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_StandardToken *StandardTokenSession) Owner() (common.Address, error) { + return _StandardToken.Contract.Owner(&_StandardToken.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_StandardToken *StandardTokenCallerSession) Owner() (common.Address, error) { + return _StandardToken.Contract.Owner(&_StandardToken.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_StandardToken *StandardTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _StandardToken.contract.Call(opts, out, "totalSupply") + return *ret0, err +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_StandardToken *StandardTokenSession) TotalSupply() (*big.Int, error) { + return _StandardToken.Contract.TotalSupply(&_StandardToken.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_StandardToken *StandardTokenCallerSession) TotalSupply() (*big.Int, error) { + return _StandardToken.Contract.TotalSupply(&_StandardToken.CallOpts) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _spender, uint256 _value) returns() +func (_StandardToken *StandardTokenTransactor) Approve(opts *bind.TransactOpts, _spender common.Address, _value *big.Int) (*types.Transaction, error) { + return _StandardToken.contract.Transact(opts, "approve", _spender, _value) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _spender, uint256 _value) returns() +func (_StandardToken *StandardTokenSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error) { + return _StandardToken.Contract.Approve(&_StandardToken.TransactOpts, _spender, _value) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _spender, uint256 _value) returns() +func (_StandardToken *StandardTokenTransactorSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error) { + return _StandardToken.Contract.Approve(&_StandardToken.TransactOpts, _spender, _value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_StandardToken *StandardTokenTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error) { + return _StandardToken.contract.Transact(opts, "transfer", _to, _value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_StandardToken *StandardTokenSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { + return _StandardToken.Contract.Transfer(&_StandardToken.TransactOpts, _to, _value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_StandardToken *StandardTokenTransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { + return _StandardToken.Contract.Transfer(&_StandardToken.TransactOpts, _to, _value) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns() +func (_StandardToken *StandardTokenTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { + return _StandardToken.contract.Transact(opts, "transferFrom", _from, _to, _value) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns() +func (_StandardToken *StandardTokenSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { + return _StandardToken.Contract.TransferFrom(&_StandardToken.TransactOpts, _from, _to, _value) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns() +func (_StandardToken *StandardTokenTransactorSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { + return _StandardToken.Contract.TransferFrom(&_StandardToken.TransactOpts, _from, _to, _value) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_StandardToken *StandardTokenTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _StandardToken.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_StandardToken *StandardTokenSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _StandardToken.Contract.TransferOwnership(&_StandardToken.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_StandardToken *StandardTokenTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _StandardToken.Contract.TransferOwnership(&_StandardToken.TransactOpts, newOwner) +} + +// StandardTokenApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the StandardToken contract. +type StandardTokenApprovalIterator struct { + Event *StandardTokenApproval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StandardTokenApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StandardTokenApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StandardTokenApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StandardTokenApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StandardTokenApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StandardTokenApproval represents a Approval event raised by the StandardToken contract. +type StandardTokenApproval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_StandardToken *StandardTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*StandardTokenApprovalIterator, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _StandardToken.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &StandardTokenApprovalIterator{contract: _StandardToken.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_StandardToken *StandardTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *StandardTokenApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _StandardToken.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StandardTokenApproval) + if err := _StandardToken.contract.UnpackLog(event, "Approval", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_StandardToken *StandardTokenFilterer) ParseApproval(log types.Log) (*StandardTokenApproval, error) { + event := new(StandardTokenApproval) + if err := _StandardToken.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + return event, nil +} + +// StandardTokenTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the StandardToken contract. +type StandardTokenTransferIterator struct { + Event *StandardTokenTransfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *StandardTokenTransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(StandardTokenTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(StandardTokenTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *StandardTokenTransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *StandardTokenTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// StandardTokenTransfer represents a Transfer event raised by the StandardToken contract. +type StandardTokenTransfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_StandardToken *StandardTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*StandardTokenTransferIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _StandardToken.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &StandardTokenTransferIterator{contract: _StandardToken.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_StandardToken *StandardTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *StandardTokenTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _StandardToken.contract.WatchLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(StandardTokenTransfer) + if err := _StandardToken.contract.UnpackLog(event, "Transfer", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_StandardToken *StandardTokenFilterer) ParseTransfer(log types.Log) (*StandardTokenTransfer, error) { + event := new(StandardTokenTransfer) + if err := _StandardToken.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + return event, nil +} + +// TetherTokenABI is the input ABI used to generate the binding from. +const TetherTokenABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_upgradedAddress\",\"type\":\"address\"}],\"name\":\"deprecate\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_spender\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"deprecated\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_evilUser\",\"type\":\"address\"}],\"name\":\"addBlackList\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_from\",\"type\":\"address\"},{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"upgradedAddress\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"balances\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"maximumFee\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"unpause\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_maker\",\"type\":\"address\"}],\"name\":\"getBlackListStatus\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"},{\"name\":\"\",\"type\":\"address\"}],\"name\":\"allowed\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"who\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"pause\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"getOwner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"_totalSupply1\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"newBasisPoints\",\"type\":\"uint256\"},{\"name\":\"newMaxFee\",\"type\":\"uint256\"}],\"name\":\"setParams\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"issue\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"redeem\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"},{\"name\":\"_spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"name\":\"remaining\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"basisPointsRate\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"isBlackListed\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_clearedUser\",\"type\":\"address\"}],\"name\":\"removeBlackList\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"MAX_UINT\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_blackListedUser\",\"type\":\"address\"}],\"name\":\"destroyBlackFunds\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"name\":\"_initialSupply\",\"type\":\"uint256\"},{\"name\":\"_name\",\"type\":\"string\"},{\"name\":\"_symbol\",\"type\":\"string\"},{\"name\":\"_decimals\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Issue\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Redeem\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"newAddress\",\"type\":\"address\"}],\"name\":\"Deprecate\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"feeBasisPoints\",\"type\":\"uint256\"},{\"indexed\":false,\"name\":\"maxFee\",\"type\":\"uint256\"}],\"name\":\"Params\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"_blackListedUser\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"_balance\",\"type\":\"uint256\"}],\"name\":\"DestroyedBlackFunds\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"_user\",\"type\":\"address\"}],\"name\":\"AddedBlackList\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"name\":\"_user\",\"type\":\"address\"}],\"name\":\"RemovedBlackList\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"Pause\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[],\"name\":\"Unpause\",\"type\":\"event\"}]" + +// TetherTokenFuncSigs maps the 4-byte function signature to its string representation. +var TetherTokenFuncSigs = map[string]string{ + "e5b5019a": "MAX_UINT()", + "a2e70a2e": "_totalSupply1()", + "0ecb93c0": "addBlackList(address)", + "dd62ed3e": "allowance(address,address)", + "5c658165": "allowed(address,address)", + "095ea7b3": "approve(address,uint256)", + "70a08231": "balanceOf(address)", + "27e235e3": "balances(address)", + "dd644f72": "basisPointsRate()", + "313ce567": "decimals()", + "0753c30c": "deprecate(address)", + "0e136b19": "deprecated()", + "f3bdc228": "destroyBlackFunds(address)", + "59bf1abe": "getBlackListStatus(address)", + "893d20e8": "getOwner()", + "e47d6060": "isBlackListed(address)", + "cc872b66": "issue(uint256)", + "35390714": "maximumFee()", + "06fdde03": "name()", + "8da5cb5b": "owner()", + "8456cb59": "pause()", + "5c975abb": "paused()", + "db006a75": "redeem(uint256)", + "e4997dc5": "removeBlackList(address)", + "c0324c77": "setParams(uint256,uint256)", + "95d89b41": "symbol()", + "18160ddd": "totalSupply()", + "a9059cbb": "transfer(address,uint256)", + "23b872dd": "transferFrom(address,address,uint256)", + "f2fde38b": "transferOwnership(address)", + "3f4ba83a": "unpause()", + "26976e3f": "upgradedAddress()", +} + +// TetherTokenBin is the compiled bytecode used for deploying new contracts. +var TetherTokenBin = "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" + +// DeployTetherToken deploys a new Ethereum contract, binding an instance of TetherToken to it. +func DeployTetherToken(auth *bind.TransactOpts, backend bind.ContractBackend, _initialSupply *big.Int, _name string, _symbol string, _decimals *big.Int) (common.Address, *types.Transaction, *TetherToken, error) { + parsed, err := abi.JSON(strings.NewReader(TetherTokenABI)) + if err != nil { + return common.Address{}, nil, nil, err + } + + address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(TetherTokenBin), backend, _initialSupply, _name, _symbol, _decimals) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &TetherToken{TetherTokenCaller: TetherTokenCaller{contract: contract}, TetherTokenTransactor: TetherTokenTransactor{contract: contract}, TetherTokenFilterer: TetherTokenFilterer{contract: contract}}, nil +} + +// TetherToken is an auto generated Go binding around an Ethereum contract. +type TetherToken struct { + TetherTokenCaller // Read-only binding to the contract + TetherTokenTransactor // Write-only binding to the contract + TetherTokenFilterer // Log filterer for contract events +} + +// TetherTokenCaller is an auto generated read-only Go binding around an Ethereum contract. +type TetherTokenCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// TetherTokenTransactor is an auto generated write-only Go binding around an Ethereum contract. +type TetherTokenTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// TetherTokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type TetherTokenFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// TetherTokenSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type TetherTokenSession struct { + Contract *TetherToken // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// TetherTokenCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type TetherTokenCallerSession struct { + Contract *TetherTokenCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// TetherTokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type TetherTokenTransactorSession struct { + Contract *TetherTokenTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// TetherTokenRaw is an auto generated low-level Go binding around an Ethereum contract. +type TetherTokenRaw struct { + Contract *TetherToken // Generic contract binding to access the raw methods on +} + +// TetherTokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type TetherTokenCallerRaw struct { + Contract *TetherTokenCaller // Generic read-only contract binding to access the raw methods on +} + +// TetherTokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type TetherTokenTransactorRaw struct { + Contract *TetherTokenTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewTetherToken creates a new instance of TetherToken, bound to a specific deployed contract. +func NewTetherToken(address common.Address, backend bind.ContractBackend) (*TetherToken, error) { + contract, err := bindTetherToken(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &TetherToken{TetherTokenCaller: TetherTokenCaller{contract: contract}, TetherTokenTransactor: TetherTokenTransactor{contract: contract}, TetherTokenFilterer: TetherTokenFilterer{contract: contract}}, nil +} + +// NewTetherTokenCaller creates a new read-only instance of TetherToken, bound to a specific deployed contract. +func NewTetherTokenCaller(address common.Address, caller bind.ContractCaller) (*TetherTokenCaller, error) { + contract, err := bindTetherToken(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &TetherTokenCaller{contract: contract}, nil +} + +// NewTetherTokenTransactor creates a new write-only instance of TetherToken, bound to a specific deployed contract. +func NewTetherTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*TetherTokenTransactor, error) { + contract, err := bindTetherToken(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &TetherTokenTransactor{contract: contract}, nil +} + +// NewTetherTokenFilterer creates a new log filterer instance of TetherToken, bound to a specific deployed contract. +func NewTetherTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*TetherTokenFilterer, error) { + contract, err := bindTetherToken(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &TetherTokenFilterer{contract: contract}, nil +} + +// bindTetherToken binds a generic wrapper to an already deployed contract. +func bindTetherToken(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(TetherTokenABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_TetherToken *TetherTokenRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _TetherToken.Contract.TetherTokenCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_TetherToken *TetherTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _TetherToken.Contract.TetherTokenTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_TetherToken *TetherTokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _TetherToken.Contract.TetherTokenTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_TetherToken *TetherTokenCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _TetherToken.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_TetherToken *TetherTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _TetherToken.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_TetherToken *TetherTokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _TetherToken.Contract.contract.Transact(opts, method, params...) +} + +// MAXUINT is a free data retrieval call binding the contract method 0xe5b5019a. +// +// Solidity: function MAX_UINT() view returns(uint256) +func (_TetherToken *TetherTokenCaller) MAXUINT(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "MAX_UINT") + return *ret0, err +} + +// MAXUINT is a free data retrieval call binding the contract method 0xe5b5019a. +// +// Solidity: function MAX_UINT() view returns(uint256) +func (_TetherToken *TetherTokenSession) MAXUINT() (*big.Int, error) { + return _TetherToken.Contract.MAXUINT(&_TetherToken.CallOpts) +} + +// MAXUINT is a free data retrieval call binding the contract method 0xe5b5019a. +// +// Solidity: function MAX_UINT() view returns(uint256) +func (_TetherToken *TetherTokenCallerSession) MAXUINT() (*big.Int, error) { + return _TetherToken.Contract.MAXUINT(&_TetherToken.CallOpts) +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_TetherToken *TetherTokenCaller) TotalSupply1(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "_totalSupply1") + return *ret0, err +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_TetherToken *TetherTokenSession) TotalSupply1() (*big.Int, error) { + return _TetherToken.Contract.TotalSupply1(&_TetherToken.CallOpts) +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_TetherToken *TetherTokenCallerSession) TotalSupply1() (*big.Int, error) { + return _TetherToken.Contract.TotalSupply1(&_TetherToken.CallOpts) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining) +func (_TetherToken *TetherTokenCaller) Allowance(opts *bind.CallOpts, _owner common.Address, _spender common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "allowance", _owner, _spender) + return *ret0, err +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining) +func (_TetherToken *TetherTokenSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) { + return _TetherToken.Contract.Allowance(&_TetherToken.CallOpts, _owner, _spender) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining) +func (_TetherToken *TetherTokenCallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) { + return _TetherToken.Contract.Allowance(&_TetherToken.CallOpts, _owner, _spender) +} + +// Allowed is a free data retrieval call binding the contract method 0x5c658165. +// +// Solidity: function allowed(address , address ) view returns(uint256) +func (_TetherToken *TetherTokenCaller) Allowed(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "allowed", arg0, arg1) + return *ret0, err +} + +// Allowed is a free data retrieval call binding the contract method 0x5c658165. +// +// Solidity: function allowed(address , address ) view returns(uint256) +func (_TetherToken *TetherTokenSession) Allowed(arg0 common.Address, arg1 common.Address) (*big.Int, error) { + return _TetherToken.Contract.Allowed(&_TetherToken.CallOpts, arg0, arg1) +} + +// Allowed is a free data retrieval call binding the contract method 0x5c658165. +// +// Solidity: function allowed(address , address ) view returns(uint256) +func (_TetherToken *TetherTokenCallerSession) Allowed(arg0 common.Address, arg1 common.Address) (*big.Int, error) { + return _TetherToken.Contract.Allowed(&_TetherToken.CallOpts, arg0, arg1) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address who) view returns(uint256) +func (_TetherToken *TetherTokenCaller) BalanceOf(opts *bind.CallOpts, who common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "balanceOf", who) + return *ret0, err +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address who) view returns(uint256) +func (_TetherToken *TetherTokenSession) BalanceOf(who common.Address) (*big.Int, error) { + return _TetherToken.Contract.BalanceOf(&_TetherToken.CallOpts, who) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address who) view returns(uint256) +func (_TetherToken *TetherTokenCallerSession) BalanceOf(who common.Address) (*big.Int, error) { + return _TetherToken.Contract.BalanceOf(&_TetherToken.CallOpts, who) +} + +// Balances is a free data retrieval call binding the contract method 0x27e235e3. +// +// Solidity: function balances(address ) view returns(uint256) +func (_TetherToken *TetherTokenCaller) Balances(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "balances", arg0) + return *ret0, err +} + +// Balances is a free data retrieval call binding the contract method 0x27e235e3. +// +// Solidity: function balances(address ) view returns(uint256) +func (_TetherToken *TetherTokenSession) Balances(arg0 common.Address) (*big.Int, error) { + return _TetherToken.Contract.Balances(&_TetherToken.CallOpts, arg0) +} + +// Balances is a free data retrieval call binding the contract method 0x27e235e3. +// +// Solidity: function balances(address ) view returns(uint256) +func (_TetherToken *TetherTokenCallerSession) Balances(arg0 common.Address) (*big.Int, error) { + return _TetherToken.Contract.Balances(&_TetherToken.CallOpts, arg0) +} + +// BasisPointsRate is a free data retrieval call binding the contract method 0xdd644f72. +// +// Solidity: function basisPointsRate() view returns(uint256) +func (_TetherToken *TetherTokenCaller) BasisPointsRate(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "basisPointsRate") + return *ret0, err +} + +// BasisPointsRate is a free data retrieval call binding the contract method 0xdd644f72. +// +// Solidity: function basisPointsRate() view returns(uint256) +func (_TetherToken *TetherTokenSession) BasisPointsRate() (*big.Int, error) { + return _TetherToken.Contract.BasisPointsRate(&_TetherToken.CallOpts) +} + +// BasisPointsRate is a free data retrieval call binding the contract method 0xdd644f72. +// +// Solidity: function basisPointsRate() view returns(uint256) +func (_TetherToken *TetherTokenCallerSession) BasisPointsRate() (*big.Int, error) { + return _TetherToken.Contract.BasisPointsRate(&_TetherToken.CallOpts) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint256) +func (_TetherToken *TetherTokenCaller) Decimals(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "decimals") + return *ret0, err +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint256) +func (_TetherToken *TetherTokenSession) Decimals() (*big.Int, error) { + return _TetherToken.Contract.Decimals(&_TetherToken.CallOpts) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint256) +func (_TetherToken *TetherTokenCallerSession) Decimals() (*big.Int, error) { + return _TetherToken.Contract.Decimals(&_TetherToken.CallOpts) +} + +// Deprecated is a free data retrieval call binding the contract method 0x0e136b19. +// +// Solidity: function deprecated() view returns(bool) +func (_TetherToken *TetherTokenCaller) Deprecated(opts *bind.CallOpts) (bool, error) { + var ( + ret0 = new(bool) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "deprecated") + return *ret0, err +} + +// Deprecated is a free data retrieval call binding the contract method 0x0e136b19. +// +// Solidity: function deprecated() view returns(bool) +func (_TetherToken *TetherTokenSession) Deprecated() (bool, error) { + return _TetherToken.Contract.Deprecated(&_TetherToken.CallOpts) +} + +// Deprecated is a free data retrieval call binding the contract method 0x0e136b19. +// +// Solidity: function deprecated() view returns(bool) +func (_TetherToken *TetherTokenCallerSession) Deprecated() (bool, error) { + return _TetherToken.Contract.Deprecated(&_TetherToken.CallOpts) +} + +// GetBlackListStatus is a free data retrieval call binding the contract method 0x59bf1abe. +// +// Solidity: function getBlackListStatus(address _maker) view returns(bool) +func (_TetherToken *TetherTokenCaller) GetBlackListStatus(opts *bind.CallOpts, _maker common.Address) (bool, error) { + var ( + ret0 = new(bool) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "getBlackListStatus", _maker) + return *ret0, err +} + +// GetBlackListStatus is a free data retrieval call binding the contract method 0x59bf1abe. +// +// Solidity: function getBlackListStatus(address _maker) view returns(bool) +func (_TetherToken *TetherTokenSession) GetBlackListStatus(_maker common.Address) (bool, error) { + return _TetherToken.Contract.GetBlackListStatus(&_TetherToken.CallOpts, _maker) +} + +// GetBlackListStatus is a free data retrieval call binding the contract method 0x59bf1abe. +// +// Solidity: function getBlackListStatus(address _maker) view returns(bool) +func (_TetherToken *TetherTokenCallerSession) GetBlackListStatus(_maker common.Address) (bool, error) { + return _TetherToken.Contract.GetBlackListStatus(&_TetherToken.CallOpts, _maker) +} + +// GetOwner is a free data retrieval call binding the contract method 0x893d20e8. +// +// Solidity: function getOwner() view returns(address) +func (_TetherToken *TetherTokenCaller) GetOwner(opts *bind.CallOpts) (common.Address, error) { + var ( + ret0 = new(common.Address) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "getOwner") + return *ret0, err +} + +// GetOwner is a free data retrieval call binding the contract method 0x893d20e8. +// +// Solidity: function getOwner() view returns(address) +func (_TetherToken *TetherTokenSession) GetOwner() (common.Address, error) { + return _TetherToken.Contract.GetOwner(&_TetherToken.CallOpts) +} + +// GetOwner is a free data retrieval call binding the contract method 0x893d20e8. +// +// Solidity: function getOwner() view returns(address) +func (_TetherToken *TetherTokenCallerSession) GetOwner() (common.Address, error) { + return _TetherToken.Contract.GetOwner(&_TetherToken.CallOpts) +} + +// IsBlackListed is a free data retrieval call binding the contract method 0xe47d6060. +// +// Solidity: function isBlackListed(address ) view returns(bool) +func (_TetherToken *TetherTokenCaller) IsBlackListed(opts *bind.CallOpts, arg0 common.Address) (bool, error) { + var ( + ret0 = new(bool) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "isBlackListed", arg0) + return *ret0, err +} + +// IsBlackListed is a free data retrieval call binding the contract method 0xe47d6060. +// +// Solidity: function isBlackListed(address ) view returns(bool) +func (_TetherToken *TetherTokenSession) IsBlackListed(arg0 common.Address) (bool, error) { + return _TetherToken.Contract.IsBlackListed(&_TetherToken.CallOpts, arg0) +} + +// IsBlackListed is a free data retrieval call binding the contract method 0xe47d6060. +// +// Solidity: function isBlackListed(address ) view returns(bool) +func (_TetherToken *TetherTokenCallerSession) IsBlackListed(arg0 common.Address) (bool, error) { + return _TetherToken.Contract.IsBlackListed(&_TetherToken.CallOpts, arg0) +} + +// MaximumFee is a free data retrieval call binding the contract method 0x35390714. +// +// Solidity: function maximumFee() view returns(uint256) +func (_TetherToken *TetherTokenCaller) MaximumFee(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "maximumFee") + return *ret0, err +} + +// MaximumFee is a free data retrieval call binding the contract method 0x35390714. +// +// Solidity: function maximumFee() view returns(uint256) +func (_TetherToken *TetherTokenSession) MaximumFee() (*big.Int, error) { + return _TetherToken.Contract.MaximumFee(&_TetherToken.CallOpts) +} + +// MaximumFee is a free data retrieval call binding the contract method 0x35390714. +// +// Solidity: function maximumFee() view returns(uint256) +func (_TetherToken *TetherTokenCallerSession) MaximumFee() (*big.Int, error) { + return _TetherToken.Contract.MaximumFee(&_TetherToken.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_TetherToken *TetherTokenCaller) Name(opts *bind.CallOpts) (string, error) { + var ( + ret0 = new(string) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "name") + return *ret0, err +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_TetherToken *TetherTokenSession) Name() (string, error) { + return _TetherToken.Contract.Name(&_TetherToken.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_TetherToken *TetherTokenCallerSession) Name() (string, error) { + return _TetherToken.Contract.Name(&_TetherToken.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_TetherToken *TetherTokenCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var ( + ret0 = new(common.Address) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "owner") + return *ret0, err +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_TetherToken *TetherTokenSession) Owner() (common.Address, error) { + return _TetherToken.Contract.Owner(&_TetherToken.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_TetherToken *TetherTokenCallerSession) Owner() (common.Address, error) { + return _TetherToken.Contract.Owner(&_TetherToken.CallOpts) +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_TetherToken *TetherTokenCaller) Paused(opts *bind.CallOpts) (bool, error) { + var ( + ret0 = new(bool) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "paused") + return *ret0, err +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_TetherToken *TetherTokenSession) Paused() (bool, error) { + return _TetherToken.Contract.Paused(&_TetherToken.CallOpts) +} + +// Paused is a free data retrieval call binding the contract method 0x5c975abb. +// +// Solidity: function paused() view returns(bool) +func (_TetherToken *TetherTokenCallerSession) Paused() (bool, error) { + return _TetherToken.Contract.Paused(&_TetherToken.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_TetherToken *TetherTokenCaller) Symbol(opts *bind.CallOpts) (string, error) { + var ( + ret0 = new(string) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "symbol") + return *ret0, err +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_TetherToken *TetherTokenSession) Symbol() (string, error) { + return _TetherToken.Contract.Symbol(&_TetherToken.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_TetherToken *TetherTokenCallerSession) Symbol() (string, error) { + return _TetherToken.Contract.Symbol(&_TetherToken.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_TetherToken *TetherTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "totalSupply") + return *ret0, err +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_TetherToken *TetherTokenSession) TotalSupply() (*big.Int, error) { + return _TetherToken.Contract.TotalSupply(&_TetherToken.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_TetherToken *TetherTokenCallerSession) TotalSupply() (*big.Int, error) { + return _TetherToken.Contract.TotalSupply(&_TetherToken.CallOpts) +} + +// UpgradedAddress is a free data retrieval call binding the contract method 0x26976e3f. +// +// Solidity: function upgradedAddress() view returns(address) +func (_TetherToken *TetherTokenCaller) UpgradedAddress(opts *bind.CallOpts) (common.Address, error) { + var ( + ret0 = new(common.Address) + ) + out := ret0 + err := _TetherToken.contract.Call(opts, out, "upgradedAddress") + return *ret0, err +} + +// UpgradedAddress is a free data retrieval call binding the contract method 0x26976e3f. +// +// Solidity: function upgradedAddress() view returns(address) +func (_TetherToken *TetherTokenSession) UpgradedAddress() (common.Address, error) { + return _TetherToken.Contract.UpgradedAddress(&_TetherToken.CallOpts) +} + +// UpgradedAddress is a free data retrieval call binding the contract method 0x26976e3f. +// +// Solidity: function upgradedAddress() view returns(address) +func (_TetherToken *TetherTokenCallerSession) UpgradedAddress() (common.Address, error) { + return _TetherToken.Contract.UpgradedAddress(&_TetherToken.CallOpts) +} + +// AddBlackList is a paid mutator transaction binding the contract method 0x0ecb93c0. +// +// Solidity: function addBlackList(address _evilUser) returns() +func (_TetherToken *TetherTokenTransactor) AddBlackList(opts *bind.TransactOpts, _evilUser common.Address) (*types.Transaction, error) { + return _TetherToken.contract.Transact(opts, "addBlackList", _evilUser) +} + +// AddBlackList is a paid mutator transaction binding the contract method 0x0ecb93c0. +// +// Solidity: function addBlackList(address _evilUser) returns() +func (_TetherToken *TetherTokenSession) AddBlackList(_evilUser common.Address) (*types.Transaction, error) { + return _TetherToken.Contract.AddBlackList(&_TetherToken.TransactOpts, _evilUser) +} + +// AddBlackList is a paid mutator transaction binding the contract method 0x0ecb93c0. +// +// Solidity: function addBlackList(address _evilUser) returns() +func (_TetherToken *TetherTokenTransactorSession) AddBlackList(_evilUser common.Address) (*types.Transaction, error) { + return _TetherToken.Contract.AddBlackList(&_TetherToken.TransactOpts, _evilUser) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _spender, uint256 _value) returns() +func (_TetherToken *TetherTokenTransactor) Approve(opts *bind.TransactOpts, _spender common.Address, _value *big.Int) (*types.Transaction, error) { + return _TetherToken.contract.Transact(opts, "approve", _spender, _value) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _spender, uint256 _value) returns() +func (_TetherToken *TetherTokenSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error) { + return _TetherToken.Contract.Approve(&_TetherToken.TransactOpts, _spender, _value) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _spender, uint256 _value) returns() +func (_TetherToken *TetherTokenTransactorSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error) { + return _TetherToken.Contract.Approve(&_TetherToken.TransactOpts, _spender, _value) +} + +// Deprecate is a paid mutator transaction binding the contract method 0x0753c30c. +// +// Solidity: function deprecate(address _upgradedAddress) returns() +func (_TetherToken *TetherTokenTransactor) Deprecate(opts *bind.TransactOpts, _upgradedAddress common.Address) (*types.Transaction, error) { + return _TetherToken.contract.Transact(opts, "deprecate", _upgradedAddress) +} + +// Deprecate is a paid mutator transaction binding the contract method 0x0753c30c. +// +// Solidity: function deprecate(address _upgradedAddress) returns() +func (_TetherToken *TetherTokenSession) Deprecate(_upgradedAddress common.Address) (*types.Transaction, error) { + return _TetherToken.Contract.Deprecate(&_TetherToken.TransactOpts, _upgradedAddress) +} + +// Deprecate is a paid mutator transaction binding the contract method 0x0753c30c. +// +// Solidity: function deprecate(address _upgradedAddress) returns() +func (_TetherToken *TetherTokenTransactorSession) Deprecate(_upgradedAddress common.Address) (*types.Transaction, error) { + return _TetherToken.Contract.Deprecate(&_TetherToken.TransactOpts, _upgradedAddress) +} + +// DestroyBlackFunds is a paid mutator transaction binding the contract method 0xf3bdc228. +// +// Solidity: function destroyBlackFunds(address _blackListedUser) returns() +func (_TetherToken *TetherTokenTransactor) DestroyBlackFunds(opts *bind.TransactOpts, _blackListedUser common.Address) (*types.Transaction, error) { + return _TetherToken.contract.Transact(opts, "destroyBlackFunds", _blackListedUser) +} + +// DestroyBlackFunds is a paid mutator transaction binding the contract method 0xf3bdc228. +// +// Solidity: function destroyBlackFunds(address _blackListedUser) returns() +func (_TetherToken *TetherTokenSession) DestroyBlackFunds(_blackListedUser common.Address) (*types.Transaction, error) { + return _TetherToken.Contract.DestroyBlackFunds(&_TetherToken.TransactOpts, _blackListedUser) +} + +// DestroyBlackFunds is a paid mutator transaction binding the contract method 0xf3bdc228. +// +// Solidity: function destroyBlackFunds(address _blackListedUser) returns() +func (_TetherToken *TetherTokenTransactorSession) DestroyBlackFunds(_blackListedUser common.Address) (*types.Transaction, error) { + return _TetherToken.Contract.DestroyBlackFunds(&_TetherToken.TransactOpts, _blackListedUser) +} + +// Issue is a paid mutator transaction binding the contract method 0xcc872b66. +// +// Solidity: function issue(uint256 amount) returns() +func (_TetherToken *TetherTokenTransactor) Issue(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { + return _TetherToken.contract.Transact(opts, "issue", amount) +} + +// Issue is a paid mutator transaction binding the contract method 0xcc872b66. +// +// Solidity: function issue(uint256 amount) returns() +func (_TetherToken *TetherTokenSession) Issue(amount *big.Int) (*types.Transaction, error) { + return _TetherToken.Contract.Issue(&_TetherToken.TransactOpts, amount) +} + +// Issue is a paid mutator transaction binding the contract method 0xcc872b66. +// +// Solidity: function issue(uint256 amount) returns() +func (_TetherToken *TetherTokenTransactorSession) Issue(amount *big.Int) (*types.Transaction, error) { + return _TetherToken.Contract.Issue(&_TetherToken.TransactOpts, amount) +} + +// Pause is a paid mutator transaction binding the contract method 0x8456cb59. +// +// Solidity: function pause() returns() +func (_TetherToken *TetherTokenTransactor) Pause(opts *bind.TransactOpts) (*types.Transaction, error) { + return _TetherToken.contract.Transact(opts, "pause") +} + +// Pause is a paid mutator transaction binding the contract method 0x8456cb59. +// +// Solidity: function pause() returns() +func (_TetherToken *TetherTokenSession) Pause() (*types.Transaction, error) { + return _TetherToken.Contract.Pause(&_TetherToken.TransactOpts) +} + +// Pause is a paid mutator transaction binding the contract method 0x8456cb59. +// +// Solidity: function pause() returns() +func (_TetherToken *TetherTokenTransactorSession) Pause() (*types.Transaction, error) { + return _TetherToken.Contract.Pause(&_TetherToken.TransactOpts) +} + +// Redeem is a paid mutator transaction binding the contract method 0xdb006a75. +// +// Solidity: function redeem(uint256 amount) returns() +func (_TetherToken *TetherTokenTransactor) Redeem(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { + return _TetherToken.contract.Transact(opts, "redeem", amount) +} + +// Redeem is a paid mutator transaction binding the contract method 0xdb006a75. +// +// Solidity: function redeem(uint256 amount) returns() +func (_TetherToken *TetherTokenSession) Redeem(amount *big.Int) (*types.Transaction, error) { + return _TetherToken.Contract.Redeem(&_TetherToken.TransactOpts, amount) +} + +// Redeem is a paid mutator transaction binding the contract method 0xdb006a75. +// +// Solidity: function redeem(uint256 amount) returns() +func (_TetherToken *TetherTokenTransactorSession) Redeem(amount *big.Int) (*types.Transaction, error) { + return _TetherToken.Contract.Redeem(&_TetherToken.TransactOpts, amount) +} + +// RemoveBlackList is a paid mutator transaction binding the contract method 0xe4997dc5. +// +// Solidity: function removeBlackList(address _clearedUser) returns() +func (_TetherToken *TetherTokenTransactor) RemoveBlackList(opts *bind.TransactOpts, _clearedUser common.Address) (*types.Transaction, error) { + return _TetherToken.contract.Transact(opts, "removeBlackList", _clearedUser) +} + +// RemoveBlackList is a paid mutator transaction binding the contract method 0xe4997dc5. +// +// Solidity: function removeBlackList(address _clearedUser) returns() +func (_TetherToken *TetherTokenSession) RemoveBlackList(_clearedUser common.Address) (*types.Transaction, error) { + return _TetherToken.Contract.RemoveBlackList(&_TetherToken.TransactOpts, _clearedUser) +} + +// RemoveBlackList is a paid mutator transaction binding the contract method 0xe4997dc5. +// +// Solidity: function removeBlackList(address _clearedUser) returns() +func (_TetherToken *TetherTokenTransactorSession) RemoveBlackList(_clearedUser common.Address) (*types.Transaction, error) { + return _TetherToken.Contract.RemoveBlackList(&_TetherToken.TransactOpts, _clearedUser) +} + +// SetParams is a paid mutator transaction binding the contract method 0xc0324c77. +// +// Solidity: function setParams(uint256 newBasisPoints, uint256 newMaxFee) returns() +func (_TetherToken *TetherTokenTransactor) SetParams(opts *bind.TransactOpts, newBasisPoints *big.Int, newMaxFee *big.Int) (*types.Transaction, error) { + return _TetherToken.contract.Transact(opts, "setParams", newBasisPoints, newMaxFee) +} + +// SetParams is a paid mutator transaction binding the contract method 0xc0324c77. +// +// Solidity: function setParams(uint256 newBasisPoints, uint256 newMaxFee) returns() +func (_TetherToken *TetherTokenSession) SetParams(newBasisPoints *big.Int, newMaxFee *big.Int) (*types.Transaction, error) { + return _TetherToken.Contract.SetParams(&_TetherToken.TransactOpts, newBasisPoints, newMaxFee) +} + +// SetParams is a paid mutator transaction binding the contract method 0xc0324c77. +// +// Solidity: function setParams(uint256 newBasisPoints, uint256 newMaxFee) returns() +func (_TetherToken *TetherTokenTransactorSession) SetParams(newBasisPoints *big.Int, newMaxFee *big.Int) (*types.Transaction, error) { + return _TetherToken.Contract.SetParams(&_TetherToken.TransactOpts, newBasisPoints, newMaxFee) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_TetherToken *TetherTokenTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error) { + return _TetherToken.contract.Transact(opts, "transfer", _to, _value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_TetherToken *TetherTokenSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { + return _TetherToken.Contract.Transfer(&_TetherToken.TransactOpts, _to, _value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_TetherToken *TetherTokenTransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { + return _TetherToken.Contract.Transfer(&_TetherToken.TransactOpts, _to, _value) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns() +func (_TetherToken *TetherTokenTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { + return _TetherToken.contract.Transact(opts, "transferFrom", _from, _to, _value) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns() +func (_TetherToken *TetherTokenSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { + return _TetherToken.Contract.TransferFrom(&_TetherToken.TransactOpts, _from, _to, _value) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns() +func (_TetherToken *TetherTokenTransactorSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { + return _TetherToken.Contract.TransferFrom(&_TetherToken.TransactOpts, _from, _to, _value) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_TetherToken *TetherTokenTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _TetherToken.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_TetherToken *TetherTokenSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _TetherToken.Contract.TransferOwnership(&_TetherToken.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_TetherToken *TetherTokenTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _TetherToken.Contract.TransferOwnership(&_TetherToken.TransactOpts, newOwner) +} + +// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a. +// +// Solidity: function unpause() returns() +func (_TetherToken *TetherTokenTransactor) Unpause(opts *bind.TransactOpts) (*types.Transaction, error) { + return _TetherToken.contract.Transact(opts, "unpause") +} + +// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a. +// +// Solidity: function unpause() returns() +func (_TetherToken *TetherTokenSession) Unpause() (*types.Transaction, error) { + return _TetherToken.Contract.Unpause(&_TetherToken.TransactOpts) +} + +// Unpause is a paid mutator transaction binding the contract method 0x3f4ba83a. +// +// Solidity: function unpause() returns() +func (_TetherToken *TetherTokenTransactorSession) Unpause() (*types.Transaction, error) { + return _TetherToken.Contract.Unpause(&_TetherToken.TransactOpts) +} + +// TetherTokenAddedBlackListIterator is returned from FilterAddedBlackList and is used to iterate over the raw logs and unpacked data for AddedBlackList events raised by the TetherToken contract. +type TetherTokenAddedBlackListIterator struct { + Event *TetherTokenAddedBlackList // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TetherTokenAddedBlackListIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TetherTokenAddedBlackList) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TetherTokenAddedBlackList) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TetherTokenAddedBlackListIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TetherTokenAddedBlackListIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TetherTokenAddedBlackList represents a AddedBlackList event raised by the TetherToken contract. +type TetherTokenAddedBlackList struct { + User common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterAddedBlackList is a free log retrieval operation binding the contract event 0x42e160154868087d6bfdc0ca23d96a1c1cfa32f1b72ba9ba27b69b98a0d819dc. +// +// Solidity: event AddedBlackList(address _user) +func (_TetherToken *TetherTokenFilterer) FilterAddedBlackList(opts *bind.FilterOpts) (*TetherTokenAddedBlackListIterator, error) { + + logs, sub, err := _TetherToken.contract.FilterLogs(opts, "AddedBlackList") + if err != nil { + return nil, err + } + return &TetherTokenAddedBlackListIterator{contract: _TetherToken.contract, event: "AddedBlackList", logs: logs, sub: sub}, nil +} + +// WatchAddedBlackList is a free log subscription operation binding the contract event 0x42e160154868087d6bfdc0ca23d96a1c1cfa32f1b72ba9ba27b69b98a0d819dc. +// +// Solidity: event AddedBlackList(address _user) +func (_TetherToken *TetherTokenFilterer) WatchAddedBlackList(opts *bind.WatchOpts, sink chan<- *TetherTokenAddedBlackList) (event.Subscription, error) { + + logs, sub, err := _TetherToken.contract.WatchLogs(opts, "AddedBlackList") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TetherTokenAddedBlackList) + if err := _TetherToken.contract.UnpackLog(event, "AddedBlackList", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseAddedBlackList is a log parse operation binding the contract event 0x42e160154868087d6bfdc0ca23d96a1c1cfa32f1b72ba9ba27b69b98a0d819dc. +// +// Solidity: event AddedBlackList(address _user) +func (_TetherToken *TetherTokenFilterer) ParseAddedBlackList(log types.Log) (*TetherTokenAddedBlackList, error) { + event := new(TetherTokenAddedBlackList) + if err := _TetherToken.contract.UnpackLog(event, "AddedBlackList", log); err != nil { + return nil, err + } + return event, nil +} + +// TetherTokenApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the TetherToken contract. +type TetherTokenApprovalIterator struct { + Event *TetherTokenApproval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TetherTokenApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TetherTokenApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TetherTokenApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TetherTokenApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TetherTokenApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TetherTokenApproval represents a Approval event raised by the TetherToken contract. +type TetherTokenApproval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_TetherToken *TetherTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*TetherTokenApprovalIterator, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _TetherToken.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &TetherTokenApprovalIterator{contract: _TetherToken.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_TetherToken *TetherTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *TetherTokenApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _TetherToken.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TetherTokenApproval) + if err := _TetherToken.contract.UnpackLog(event, "Approval", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_TetherToken *TetherTokenFilterer) ParseApproval(log types.Log) (*TetherTokenApproval, error) { + event := new(TetherTokenApproval) + if err := _TetherToken.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + return event, nil +} + +// TetherTokenDeprecateIterator is returned from FilterDeprecate and is used to iterate over the raw logs and unpacked data for Deprecate events raised by the TetherToken contract. +type TetherTokenDeprecateIterator struct { + Event *TetherTokenDeprecate // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TetherTokenDeprecateIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TetherTokenDeprecate) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TetherTokenDeprecate) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TetherTokenDeprecateIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TetherTokenDeprecateIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TetherTokenDeprecate represents a Deprecate event raised by the TetherToken contract. +type TetherTokenDeprecate struct { + NewAddress common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDeprecate is a free log retrieval operation binding the contract event 0xcc358699805e9a8b7f77b522628c7cb9abd07d9efb86b6fb616af1609036a99e. +// +// Solidity: event Deprecate(address newAddress) +func (_TetherToken *TetherTokenFilterer) FilterDeprecate(opts *bind.FilterOpts) (*TetherTokenDeprecateIterator, error) { + + logs, sub, err := _TetherToken.contract.FilterLogs(opts, "Deprecate") + if err != nil { + return nil, err + } + return &TetherTokenDeprecateIterator{contract: _TetherToken.contract, event: "Deprecate", logs: logs, sub: sub}, nil +} + +// WatchDeprecate is a free log subscription operation binding the contract event 0xcc358699805e9a8b7f77b522628c7cb9abd07d9efb86b6fb616af1609036a99e. +// +// Solidity: event Deprecate(address newAddress) +func (_TetherToken *TetherTokenFilterer) WatchDeprecate(opts *bind.WatchOpts, sink chan<- *TetherTokenDeprecate) (event.Subscription, error) { + + logs, sub, err := _TetherToken.contract.WatchLogs(opts, "Deprecate") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TetherTokenDeprecate) + if err := _TetherToken.contract.UnpackLog(event, "Deprecate", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseDeprecate is a log parse operation binding the contract event 0xcc358699805e9a8b7f77b522628c7cb9abd07d9efb86b6fb616af1609036a99e. +// +// Solidity: event Deprecate(address newAddress) +func (_TetherToken *TetherTokenFilterer) ParseDeprecate(log types.Log) (*TetherTokenDeprecate, error) { + event := new(TetherTokenDeprecate) + if err := _TetherToken.contract.UnpackLog(event, "Deprecate", log); err != nil { + return nil, err + } + return event, nil +} + +// TetherTokenDestroyedBlackFundsIterator is returned from FilterDestroyedBlackFunds and is used to iterate over the raw logs and unpacked data for DestroyedBlackFunds events raised by the TetherToken contract. +type TetherTokenDestroyedBlackFundsIterator struct { + Event *TetherTokenDestroyedBlackFunds // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TetherTokenDestroyedBlackFundsIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TetherTokenDestroyedBlackFunds) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TetherTokenDestroyedBlackFunds) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TetherTokenDestroyedBlackFundsIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TetherTokenDestroyedBlackFundsIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TetherTokenDestroyedBlackFunds represents a DestroyedBlackFunds event raised by the TetherToken contract. +type TetherTokenDestroyedBlackFunds struct { + BlackListedUser common.Address + Balance *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterDestroyedBlackFunds is a free log retrieval operation binding the contract event 0x61e6e66b0d6339b2980aecc6ccc0039736791f0ccde9ed512e789a7fbdd698c6. +// +// Solidity: event DestroyedBlackFunds(address _blackListedUser, uint256 _balance) +func (_TetherToken *TetherTokenFilterer) FilterDestroyedBlackFunds(opts *bind.FilterOpts) (*TetherTokenDestroyedBlackFundsIterator, error) { + + logs, sub, err := _TetherToken.contract.FilterLogs(opts, "DestroyedBlackFunds") + if err != nil { + return nil, err + } + return &TetherTokenDestroyedBlackFundsIterator{contract: _TetherToken.contract, event: "DestroyedBlackFunds", logs: logs, sub: sub}, nil +} + +// WatchDestroyedBlackFunds is a free log subscription operation binding the contract event 0x61e6e66b0d6339b2980aecc6ccc0039736791f0ccde9ed512e789a7fbdd698c6. +// +// Solidity: event DestroyedBlackFunds(address _blackListedUser, uint256 _balance) +func (_TetherToken *TetherTokenFilterer) WatchDestroyedBlackFunds(opts *bind.WatchOpts, sink chan<- *TetherTokenDestroyedBlackFunds) (event.Subscription, error) { + + logs, sub, err := _TetherToken.contract.WatchLogs(opts, "DestroyedBlackFunds") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TetherTokenDestroyedBlackFunds) + if err := _TetherToken.contract.UnpackLog(event, "DestroyedBlackFunds", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseDestroyedBlackFunds is a log parse operation binding the contract event 0x61e6e66b0d6339b2980aecc6ccc0039736791f0ccde9ed512e789a7fbdd698c6. +// +// Solidity: event DestroyedBlackFunds(address _blackListedUser, uint256 _balance) +func (_TetherToken *TetherTokenFilterer) ParseDestroyedBlackFunds(log types.Log) (*TetherTokenDestroyedBlackFunds, error) { + event := new(TetherTokenDestroyedBlackFunds) + if err := _TetherToken.contract.UnpackLog(event, "DestroyedBlackFunds", log); err != nil { + return nil, err + } + return event, nil +} + +// TetherTokenIssueIterator is returned from FilterIssue and is used to iterate over the raw logs and unpacked data for Issue events raised by the TetherToken contract. +type TetherTokenIssueIterator struct { + Event *TetherTokenIssue // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TetherTokenIssueIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TetherTokenIssue) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TetherTokenIssue) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TetherTokenIssueIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TetherTokenIssueIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TetherTokenIssue represents a Issue event raised by the TetherToken contract. +type TetherTokenIssue struct { + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterIssue is a free log retrieval operation binding the contract event 0xcb8241adb0c3fdb35b70c24ce35c5eb0c17af7431c99f827d44a445ca624176a. +// +// Solidity: event Issue(uint256 amount) +func (_TetherToken *TetherTokenFilterer) FilterIssue(opts *bind.FilterOpts) (*TetherTokenIssueIterator, error) { + + logs, sub, err := _TetherToken.contract.FilterLogs(opts, "Issue") + if err != nil { + return nil, err + } + return &TetherTokenIssueIterator{contract: _TetherToken.contract, event: "Issue", logs: logs, sub: sub}, nil +} + +// WatchIssue is a free log subscription operation binding the contract event 0xcb8241adb0c3fdb35b70c24ce35c5eb0c17af7431c99f827d44a445ca624176a. +// +// Solidity: event Issue(uint256 amount) +func (_TetherToken *TetherTokenFilterer) WatchIssue(opts *bind.WatchOpts, sink chan<- *TetherTokenIssue) (event.Subscription, error) { + + logs, sub, err := _TetherToken.contract.WatchLogs(opts, "Issue") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TetherTokenIssue) + if err := _TetherToken.contract.UnpackLog(event, "Issue", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseIssue is a log parse operation binding the contract event 0xcb8241adb0c3fdb35b70c24ce35c5eb0c17af7431c99f827d44a445ca624176a. +// +// Solidity: event Issue(uint256 amount) +func (_TetherToken *TetherTokenFilterer) ParseIssue(log types.Log) (*TetherTokenIssue, error) { + event := new(TetherTokenIssue) + if err := _TetherToken.contract.UnpackLog(event, "Issue", log); err != nil { + return nil, err + } + return event, nil +} + +// TetherTokenParamsIterator is returned from FilterParams and is used to iterate over the raw logs and unpacked data for Params events raised by the TetherToken contract. +type TetherTokenParamsIterator struct { + Event *TetherTokenParams // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TetherTokenParamsIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TetherTokenParams) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TetherTokenParams) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TetherTokenParamsIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TetherTokenParamsIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TetherTokenParams represents a Params event raised by the TetherToken contract. +type TetherTokenParams struct { + FeeBasisPoints *big.Int + MaxFee *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterParams is a free log retrieval operation binding the contract event 0xb044a1e409eac5c48e5af22d4af52670dd1a99059537a78b31b48c6500a6354e. +// +// Solidity: event Params(uint256 feeBasisPoints, uint256 maxFee) +func (_TetherToken *TetherTokenFilterer) FilterParams(opts *bind.FilterOpts) (*TetherTokenParamsIterator, error) { + + logs, sub, err := _TetherToken.contract.FilterLogs(opts, "Params") + if err != nil { + return nil, err + } + return &TetherTokenParamsIterator{contract: _TetherToken.contract, event: "Params", logs: logs, sub: sub}, nil +} + +// WatchParams is a free log subscription operation binding the contract event 0xb044a1e409eac5c48e5af22d4af52670dd1a99059537a78b31b48c6500a6354e. +// +// Solidity: event Params(uint256 feeBasisPoints, uint256 maxFee) +func (_TetherToken *TetherTokenFilterer) WatchParams(opts *bind.WatchOpts, sink chan<- *TetherTokenParams) (event.Subscription, error) { + + logs, sub, err := _TetherToken.contract.WatchLogs(opts, "Params") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TetherTokenParams) + if err := _TetherToken.contract.UnpackLog(event, "Params", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseParams is a log parse operation binding the contract event 0xb044a1e409eac5c48e5af22d4af52670dd1a99059537a78b31b48c6500a6354e. +// +// Solidity: event Params(uint256 feeBasisPoints, uint256 maxFee) +func (_TetherToken *TetherTokenFilterer) ParseParams(log types.Log) (*TetherTokenParams, error) { + event := new(TetherTokenParams) + if err := _TetherToken.contract.UnpackLog(event, "Params", log); err != nil { + return nil, err + } + return event, nil +} + +// TetherTokenPauseIterator is returned from FilterPause and is used to iterate over the raw logs and unpacked data for Pause events raised by the TetherToken contract. +type TetherTokenPauseIterator struct { + Event *TetherTokenPause // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TetherTokenPauseIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TetherTokenPause) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TetherTokenPause) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TetherTokenPauseIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TetherTokenPauseIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TetherTokenPause represents a Pause event raised by the TetherToken contract. +type TetherTokenPause struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterPause is a free log retrieval operation binding the contract event 0x6985a02210a168e66602d3235cb6db0e70f92b3ba4d376a33c0f3d9434bff625. +// +// Solidity: event Pause() +func (_TetherToken *TetherTokenFilterer) FilterPause(opts *bind.FilterOpts) (*TetherTokenPauseIterator, error) { + + logs, sub, err := _TetherToken.contract.FilterLogs(opts, "Pause") + if err != nil { + return nil, err + } + return &TetherTokenPauseIterator{contract: _TetherToken.contract, event: "Pause", logs: logs, sub: sub}, nil +} + +// WatchPause is a free log subscription operation binding the contract event 0x6985a02210a168e66602d3235cb6db0e70f92b3ba4d376a33c0f3d9434bff625. +// +// Solidity: event Pause() +func (_TetherToken *TetherTokenFilterer) WatchPause(opts *bind.WatchOpts, sink chan<- *TetherTokenPause) (event.Subscription, error) { + + logs, sub, err := _TetherToken.contract.WatchLogs(opts, "Pause") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TetherTokenPause) + if err := _TetherToken.contract.UnpackLog(event, "Pause", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParsePause is a log parse operation binding the contract event 0x6985a02210a168e66602d3235cb6db0e70f92b3ba4d376a33c0f3d9434bff625. +// +// Solidity: event Pause() +func (_TetherToken *TetherTokenFilterer) ParsePause(log types.Log) (*TetherTokenPause, error) { + event := new(TetherTokenPause) + if err := _TetherToken.contract.UnpackLog(event, "Pause", log); err != nil { + return nil, err + } + return event, nil +} + +// TetherTokenRedeemIterator is returned from FilterRedeem and is used to iterate over the raw logs and unpacked data for Redeem events raised by the TetherToken contract. +type TetherTokenRedeemIterator struct { + Event *TetherTokenRedeem // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TetherTokenRedeemIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TetherTokenRedeem) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TetherTokenRedeem) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TetherTokenRedeemIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TetherTokenRedeemIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TetherTokenRedeem represents a Redeem event raised by the TetherToken contract. +type TetherTokenRedeem struct { + Amount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRedeem is a free log retrieval operation binding the contract event 0x702d5967f45f6513a38ffc42d6ba9bf230bd40e8f53b16363c7eb4fd2deb9a44. +// +// Solidity: event Redeem(uint256 amount) +func (_TetherToken *TetherTokenFilterer) FilterRedeem(opts *bind.FilterOpts) (*TetherTokenRedeemIterator, error) { + + logs, sub, err := _TetherToken.contract.FilterLogs(opts, "Redeem") + if err != nil { + return nil, err + } + return &TetherTokenRedeemIterator{contract: _TetherToken.contract, event: "Redeem", logs: logs, sub: sub}, nil +} + +// WatchRedeem is a free log subscription operation binding the contract event 0x702d5967f45f6513a38ffc42d6ba9bf230bd40e8f53b16363c7eb4fd2deb9a44. +// +// Solidity: event Redeem(uint256 amount) +func (_TetherToken *TetherTokenFilterer) WatchRedeem(opts *bind.WatchOpts, sink chan<- *TetherTokenRedeem) (event.Subscription, error) { + + logs, sub, err := _TetherToken.contract.WatchLogs(opts, "Redeem") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TetherTokenRedeem) + if err := _TetherToken.contract.UnpackLog(event, "Redeem", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRedeem is a log parse operation binding the contract event 0x702d5967f45f6513a38ffc42d6ba9bf230bd40e8f53b16363c7eb4fd2deb9a44. +// +// Solidity: event Redeem(uint256 amount) +func (_TetherToken *TetherTokenFilterer) ParseRedeem(log types.Log) (*TetherTokenRedeem, error) { + event := new(TetherTokenRedeem) + if err := _TetherToken.contract.UnpackLog(event, "Redeem", log); err != nil { + return nil, err + } + return event, nil +} + +// TetherTokenRemovedBlackListIterator is returned from FilterRemovedBlackList and is used to iterate over the raw logs and unpacked data for RemovedBlackList events raised by the TetherToken contract. +type TetherTokenRemovedBlackListIterator struct { + Event *TetherTokenRemovedBlackList // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TetherTokenRemovedBlackListIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TetherTokenRemovedBlackList) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TetherTokenRemovedBlackList) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TetherTokenRemovedBlackListIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TetherTokenRemovedBlackListIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TetherTokenRemovedBlackList represents a RemovedBlackList event raised by the TetherToken contract. +type TetherTokenRemovedBlackList struct { + User common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterRemovedBlackList is a free log retrieval operation binding the contract event 0xd7e9ec6e6ecd65492dce6bf513cd6867560d49544421d0783ddf06e76c24470c. +// +// Solidity: event RemovedBlackList(address _user) +func (_TetherToken *TetherTokenFilterer) FilterRemovedBlackList(opts *bind.FilterOpts) (*TetherTokenRemovedBlackListIterator, error) { + + logs, sub, err := _TetherToken.contract.FilterLogs(opts, "RemovedBlackList") + if err != nil { + return nil, err + } + return &TetherTokenRemovedBlackListIterator{contract: _TetherToken.contract, event: "RemovedBlackList", logs: logs, sub: sub}, nil +} + +// WatchRemovedBlackList is a free log subscription operation binding the contract event 0xd7e9ec6e6ecd65492dce6bf513cd6867560d49544421d0783ddf06e76c24470c. +// +// Solidity: event RemovedBlackList(address _user) +func (_TetherToken *TetherTokenFilterer) WatchRemovedBlackList(opts *bind.WatchOpts, sink chan<- *TetherTokenRemovedBlackList) (event.Subscription, error) { + + logs, sub, err := _TetherToken.contract.WatchLogs(opts, "RemovedBlackList") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TetherTokenRemovedBlackList) + if err := _TetherToken.contract.UnpackLog(event, "RemovedBlackList", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseRemovedBlackList is a log parse operation binding the contract event 0xd7e9ec6e6ecd65492dce6bf513cd6867560d49544421d0783ddf06e76c24470c. +// +// Solidity: event RemovedBlackList(address _user) +func (_TetherToken *TetherTokenFilterer) ParseRemovedBlackList(log types.Log) (*TetherTokenRemovedBlackList, error) { + event := new(TetherTokenRemovedBlackList) + if err := _TetherToken.contract.UnpackLog(event, "RemovedBlackList", log); err != nil { + return nil, err + } + return event, nil +} + +// TetherTokenTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the TetherToken contract. +type TetherTokenTransferIterator struct { + Event *TetherTokenTransfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TetherTokenTransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TetherTokenTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TetherTokenTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TetherTokenTransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TetherTokenTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TetherTokenTransfer represents a Transfer event raised by the TetherToken contract. +type TetherTokenTransfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_TetherToken *TetherTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*TetherTokenTransferIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _TetherToken.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &TetherTokenTransferIterator{contract: _TetherToken.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_TetherToken *TetherTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *TetherTokenTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _TetherToken.contract.WatchLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TetherTokenTransfer) + if err := _TetherToken.contract.UnpackLog(event, "Transfer", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_TetherToken *TetherTokenFilterer) ParseTransfer(log types.Log) (*TetherTokenTransfer, error) { + event := new(TetherTokenTransfer) + if err := _TetherToken.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + return event, nil +} + +// TetherTokenUnpauseIterator is returned from FilterUnpause and is used to iterate over the raw logs and unpacked data for Unpause events raised by the TetherToken contract. +type TetherTokenUnpauseIterator struct { + Event *TetherTokenUnpause // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *TetherTokenUnpauseIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(TetherTokenUnpause) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(TetherTokenUnpause) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *TetherTokenUnpauseIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *TetherTokenUnpauseIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// TetherTokenUnpause represents a Unpause event raised by the TetherToken contract. +type TetherTokenUnpause struct { + Raw types.Log // Blockchain specific contextual infos +} + +// FilterUnpause is a free log retrieval operation binding the contract event 0x7805862f689e2f13df9f062ff482ad3ad112aca9e0847911ed832e158c525b33. +// +// Solidity: event Unpause() +func (_TetherToken *TetherTokenFilterer) FilterUnpause(opts *bind.FilterOpts) (*TetherTokenUnpauseIterator, error) { + + logs, sub, err := _TetherToken.contract.FilterLogs(opts, "Unpause") + if err != nil { + return nil, err + } + return &TetherTokenUnpauseIterator{contract: _TetherToken.contract, event: "Unpause", logs: logs, sub: sub}, nil +} + +// WatchUnpause is a free log subscription operation binding the contract event 0x7805862f689e2f13df9f062ff482ad3ad112aca9e0847911ed832e158c525b33. +// +// Solidity: event Unpause() +func (_TetherToken *TetherTokenFilterer) WatchUnpause(opts *bind.WatchOpts, sink chan<- *TetherTokenUnpause) (event.Subscription, error) { + + logs, sub, err := _TetherToken.contract.WatchLogs(opts, "Unpause") + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(TetherTokenUnpause) + if err := _TetherToken.contract.UnpackLog(event, "Unpause", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseUnpause is a log parse operation binding the contract event 0x7805862f689e2f13df9f062ff482ad3ad112aca9e0847911ed832e158c525b33. +// +// Solidity: event Unpause() +func (_TetherToken *TetherTokenFilterer) ParseUnpause(log types.Log) (*TetherTokenUnpause, error) { + event := new(TetherTokenUnpause) + if err := _TetherToken.contract.UnpackLog(event, "Unpause", log); err != nil { + return nil, err + } + return event, nil +} + +// UpgradedStandardTokenABI is the input ABI used to generate the binding from. +const UpgradedStandardTokenABI = "[{\"constant\":false,\"inputs\":[{\"name\":\"_spender\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_from\",\"type\":\"address\"},{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"}],\"name\":\"balances\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"maximumFee\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"\",\"type\":\"address\"},{\"name\":\"\",\"type\":\"address\"}],\"name\":\"allowed\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"to\",\"type\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transferByLegacy\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"balance\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"sender\",\"type\":\"address\"},{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"spender\",\"type\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"transferFromByLegacy\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"_totalSupply1\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"_to\",\"type\":\"address\"},{\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"from\",\"type\":\"address\"},{\"name\":\"spender\",\"type\":\"address\"},{\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"approveByLegacy\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"_owner\",\"type\":\"address\"},{\"name\":\"_spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"name\":\"remaining\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"basisPointsRate\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"MAX_UINT\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"}]" + +// UpgradedStandardTokenFuncSigs maps the 4-byte function signature to its string representation. +var UpgradedStandardTokenFuncSigs = map[string]string{ + "e5b5019a": "MAX_UINT()", + "a2e70a2e": "_totalSupply1()", + "dd62ed3e": "allowance(address,address)", + "5c658165": "allowed(address,address)", + "095ea7b3": "approve(address,uint256)", + "aee92d33": "approveByLegacy(address,address,uint256)", + "70a08231": "balanceOf(address)", + "27e235e3": "balances(address)", + "dd644f72": "basisPointsRate()", + "35390714": "maximumFee()", + "8da5cb5b": "owner()", + "18160ddd": "totalSupply()", + "a9059cbb": "transfer(address,uint256)", + "6e18980a": "transferByLegacy(address,address,uint256)", + "23b872dd": "transferFrom(address,address,uint256)", + "8b477adb": "transferFromByLegacy(address,address,address,uint256)", + "f2fde38b": "transferOwnership(address)", +} + +// UpgradedStandardToken is an auto generated Go binding around an Ethereum contract. +type UpgradedStandardToken struct { + UpgradedStandardTokenCaller // Read-only binding to the contract + UpgradedStandardTokenTransactor // Write-only binding to the contract + UpgradedStandardTokenFilterer // Log filterer for contract events +} + +// UpgradedStandardTokenCaller is an auto generated read-only Go binding around an Ethereum contract. +type UpgradedStandardTokenCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// UpgradedStandardTokenTransactor is an auto generated write-only Go binding around an Ethereum contract. +type UpgradedStandardTokenTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// UpgradedStandardTokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type UpgradedStandardTokenFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// UpgradedStandardTokenSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type UpgradedStandardTokenSession struct { + Contract *UpgradedStandardToken // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// UpgradedStandardTokenCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type UpgradedStandardTokenCallerSession struct { + Contract *UpgradedStandardTokenCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// UpgradedStandardTokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type UpgradedStandardTokenTransactorSession struct { + Contract *UpgradedStandardTokenTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// UpgradedStandardTokenRaw is an auto generated low-level Go binding around an Ethereum contract. +type UpgradedStandardTokenRaw struct { + Contract *UpgradedStandardToken // Generic contract binding to access the raw methods on +} + +// UpgradedStandardTokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type UpgradedStandardTokenCallerRaw struct { + Contract *UpgradedStandardTokenCaller // Generic read-only contract binding to access the raw methods on +} + +// UpgradedStandardTokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type UpgradedStandardTokenTransactorRaw struct { + Contract *UpgradedStandardTokenTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewUpgradedStandardToken creates a new instance of UpgradedStandardToken, bound to a specific deployed contract. +func NewUpgradedStandardToken(address common.Address, backend bind.ContractBackend) (*UpgradedStandardToken, error) { + contract, err := bindUpgradedStandardToken(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &UpgradedStandardToken{UpgradedStandardTokenCaller: UpgradedStandardTokenCaller{contract: contract}, UpgradedStandardTokenTransactor: UpgradedStandardTokenTransactor{contract: contract}, UpgradedStandardTokenFilterer: UpgradedStandardTokenFilterer{contract: contract}}, nil +} + +// NewUpgradedStandardTokenCaller creates a new read-only instance of UpgradedStandardToken, bound to a specific deployed contract. +func NewUpgradedStandardTokenCaller(address common.Address, caller bind.ContractCaller) (*UpgradedStandardTokenCaller, error) { + contract, err := bindUpgradedStandardToken(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &UpgradedStandardTokenCaller{contract: contract}, nil +} + +// NewUpgradedStandardTokenTransactor creates a new write-only instance of UpgradedStandardToken, bound to a specific deployed contract. +func NewUpgradedStandardTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*UpgradedStandardTokenTransactor, error) { + contract, err := bindUpgradedStandardToken(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &UpgradedStandardTokenTransactor{contract: contract}, nil +} + +// NewUpgradedStandardTokenFilterer creates a new log filterer instance of UpgradedStandardToken, bound to a specific deployed contract. +func NewUpgradedStandardTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*UpgradedStandardTokenFilterer, error) { + contract, err := bindUpgradedStandardToken(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &UpgradedStandardTokenFilterer{contract: contract}, nil +} + +// bindUpgradedStandardToken binds a generic wrapper to an already deployed contract. +func bindUpgradedStandardToken(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(UpgradedStandardTokenABI)) + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_UpgradedStandardToken *UpgradedStandardTokenRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _UpgradedStandardToken.Contract.UpgradedStandardTokenCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_UpgradedStandardToken *UpgradedStandardTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.UpgradedStandardTokenTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_UpgradedStandardToken *UpgradedStandardTokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.UpgradedStandardTokenTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_UpgradedStandardToken *UpgradedStandardTokenCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { + return _UpgradedStandardToken.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_UpgradedStandardToken *UpgradedStandardTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_UpgradedStandardToken *UpgradedStandardTokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.contract.Transact(opts, method, params...) +} + +// MAXUINT is a free data retrieval call binding the contract method 0xe5b5019a. +// +// Solidity: function MAX_UINT() view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenCaller) MAXUINT(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _UpgradedStandardToken.contract.Call(opts, out, "MAX_UINT") + return *ret0, err +} + +// MAXUINT is a free data retrieval call binding the contract method 0xe5b5019a. +// +// Solidity: function MAX_UINT() view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenSession) MAXUINT() (*big.Int, error) { + return _UpgradedStandardToken.Contract.MAXUINT(&_UpgradedStandardToken.CallOpts) +} + +// MAXUINT is a free data retrieval call binding the contract method 0xe5b5019a. +// +// Solidity: function MAX_UINT() view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenCallerSession) MAXUINT() (*big.Int, error) { + return _UpgradedStandardToken.Contract.MAXUINT(&_UpgradedStandardToken.CallOpts) +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenCaller) TotalSupply1(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _UpgradedStandardToken.contract.Call(opts, out, "_totalSupply1") + return *ret0, err +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenSession) TotalSupply1() (*big.Int, error) { + return _UpgradedStandardToken.Contract.TotalSupply1(&_UpgradedStandardToken.CallOpts) +} + +// TotalSupply1 is a free data retrieval call binding the contract method 0xa2e70a2e. +// +// Solidity: function _totalSupply1() view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenCallerSession) TotalSupply1() (*big.Int, error) { + return _UpgradedStandardToken.Contract.TotalSupply1(&_UpgradedStandardToken.CallOpts) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining) +func (_UpgradedStandardToken *UpgradedStandardTokenCaller) Allowance(opts *bind.CallOpts, _owner common.Address, _spender common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _UpgradedStandardToken.contract.Call(opts, out, "allowance", _owner, _spender) + return *ret0, err +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining) +func (_UpgradedStandardToken *UpgradedStandardTokenSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) { + return _UpgradedStandardToken.Contract.Allowance(&_UpgradedStandardToken.CallOpts, _owner, _spender) +} + +// Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. +// +// Solidity: function allowance(address _owner, address _spender) view returns(uint256 remaining) +func (_UpgradedStandardToken *UpgradedStandardTokenCallerSession) Allowance(_owner common.Address, _spender common.Address) (*big.Int, error) { + return _UpgradedStandardToken.Contract.Allowance(&_UpgradedStandardToken.CallOpts, _owner, _spender) +} + +// Allowed is a free data retrieval call binding the contract method 0x5c658165. +// +// Solidity: function allowed(address , address ) view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenCaller) Allowed(opts *bind.CallOpts, arg0 common.Address, arg1 common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _UpgradedStandardToken.contract.Call(opts, out, "allowed", arg0, arg1) + return *ret0, err +} + +// Allowed is a free data retrieval call binding the contract method 0x5c658165. +// +// Solidity: function allowed(address , address ) view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenSession) Allowed(arg0 common.Address, arg1 common.Address) (*big.Int, error) { + return _UpgradedStandardToken.Contract.Allowed(&_UpgradedStandardToken.CallOpts, arg0, arg1) +} + +// Allowed is a free data retrieval call binding the contract method 0x5c658165. +// +// Solidity: function allowed(address , address ) view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenCallerSession) Allowed(arg0 common.Address, arg1 common.Address) (*big.Int, error) { + return _UpgradedStandardToken.Contract.Allowed(&_UpgradedStandardToken.CallOpts, arg0, arg1) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256 balance) +func (_UpgradedStandardToken *UpgradedStandardTokenCaller) BalanceOf(opts *bind.CallOpts, _owner common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _UpgradedStandardToken.contract.Call(opts, out, "balanceOf", _owner) + return *ret0, err +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256 balance) +func (_UpgradedStandardToken *UpgradedStandardTokenSession) BalanceOf(_owner common.Address) (*big.Int, error) { + return _UpgradedStandardToken.Contract.BalanceOf(&_UpgradedStandardToken.CallOpts, _owner) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address _owner) view returns(uint256 balance) +func (_UpgradedStandardToken *UpgradedStandardTokenCallerSession) BalanceOf(_owner common.Address) (*big.Int, error) { + return _UpgradedStandardToken.Contract.BalanceOf(&_UpgradedStandardToken.CallOpts, _owner) +} + +// Balances is a free data retrieval call binding the contract method 0x27e235e3. +// +// Solidity: function balances(address ) view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenCaller) Balances(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _UpgradedStandardToken.contract.Call(opts, out, "balances", arg0) + return *ret0, err +} + +// Balances is a free data retrieval call binding the contract method 0x27e235e3. +// +// Solidity: function balances(address ) view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenSession) Balances(arg0 common.Address) (*big.Int, error) { + return _UpgradedStandardToken.Contract.Balances(&_UpgradedStandardToken.CallOpts, arg0) +} + +// Balances is a free data retrieval call binding the contract method 0x27e235e3. +// +// Solidity: function balances(address ) view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenCallerSession) Balances(arg0 common.Address) (*big.Int, error) { + return _UpgradedStandardToken.Contract.Balances(&_UpgradedStandardToken.CallOpts, arg0) +} + +// BasisPointsRate is a free data retrieval call binding the contract method 0xdd644f72. +// +// Solidity: function basisPointsRate() view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenCaller) BasisPointsRate(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _UpgradedStandardToken.contract.Call(opts, out, "basisPointsRate") + return *ret0, err +} + +// BasisPointsRate is a free data retrieval call binding the contract method 0xdd644f72. +// +// Solidity: function basisPointsRate() view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenSession) BasisPointsRate() (*big.Int, error) { + return _UpgradedStandardToken.Contract.BasisPointsRate(&_UpgradedStandardToken.CallOpts) +} + +// BasisPointsRate is a free data retrieval call binding the contract method 0xdd644f72. +// +// Solidity: function basisPointsRate() view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenCallerSession) BasisPointsRate() (*big.Int, error) { + return _UpgradedStandardToken.Contract.BasisPointsRate(&_UpgradedStandardToken.CallOpts) +} + +// MaximumFee is a free data retrieval call binding the contract method 0x35390714. +// +// Solidity: function maximumFee() view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenCaller) MaximumFee(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _UpgradedStandardToken.contract.Call(opts, out, "maximumFee") + return *ret0, err +} + +// MaximumFee is a free data retrieval call binding the contract method 0x35390714. +// +// Solidity: function maximumFee() view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenSession) MaximumFee() (*big.Int, error) { + return _UpgradedStandardToken.Contract.MaximumFee(&_UpgradedStandardToken.CallOpts) +} + +// MaximumFee is a free data retrieval call binding the contract method 0x35390714. +// +// Solidity: function maximumFee() view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenCallerSession) MaximumFee() (*big.Int, error) { + return _UpgradedStandardToken.Contract.MaximumFee(&_UpgradedStandardToken.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_UpgradedStandardToken *UpgradedStandardTokenCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var ( + ret0 = new(common.Address) + ) + out := ret0 + err := _UpgradedStandardToken.contract.Call(opts, out, "owner") + return *ret0, err +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_UpgradedStandardToken *UpgradedStandardTokenSession) Owner() (common.Address, error) { + return _UpgradedStandardToken.Contract.Owner(&_UpgradedStandardToken.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_UpgradedStandardToken *UpgradedStandardTokenCallerSession) Owner() (common.Address, error) { + return _UpgradedStandardToken.Contract.Owner(&_UpgradedStandardToken.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var ( + ret0 = new(*big.Int) + ) + out := ret0 + err := _UpgradedStandardToken.contract.Call(opts, out, "totalSupply") + return *ret0, err +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenSession) TotalSupply() (*big.Int, error) { + return _UpgradedStandardToken.Contract.TotalSupply(&_UpgradedStandardToken.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_UpgradedStandardToken *UpgradedStandardTokenCallerSession) TotalSupply() (*big.Int, error) { + return _UpgradedStandardToken.Contract.TotalSupply(&_UpgradedStandardToken.CallOpts) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _spender, uint256 _value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenTransactor) Approve(opts *bind.TransactOpts, _spender common.Address, _value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.contract.Transact(opts, "approve", _spender, _value) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _spender, uint256 _value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.Approve(&_UpgradedStandardToken.TransactOpts, _spender, _value) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address _spender, uint256 _value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenTransactorSession) Approve(_spender common.Address, _value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.Approve(&_UpgradedStandardToken.TransactOpts, _spender, _value) +} + +// ApproveByLegacy is a paid mutator transaction binding the contract method 0xaee92d33. +// +// Solidity: function approveByLegacy(address from, address spender, uint256 value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenTransactor) ApproveByLegacy(opts *bind.TransactOpts, from common.Address, spender common.Address, value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.contract.Transact(opts, "approveByLegacy", from, spender, value) +} + +// ApproveByLegacy is a paid mutator transaction binding the contract method 0xaee92d33. +// +// Solidity: function approveByLegacy(address from, address spender, uint256 value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenSession) ApproveByLegacy(from common.Address, spender common.Address, value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.ApproveByLegacy(&_UpgradedStandardToken.TransactOpts, from, spender, value) +} + +// ApproveByLegacy is a paid mutator transaction binding the contract method 0xaee92d33. +// +// Solidity: function approveByLegacy(address from, address spender, uint256 value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenTransactorSession) ApproveByLegacy(from common.Address, spender common.Address, value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.ApproveByLegacy(&_UpgradedStandardToken.TransactOpts, from, spender, value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.contract.Transact(opts, "transfer", _to, _value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.Transfer(&_UpgradedStandardToken.TransactOpts, _to, _value) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address _to, uint256 _value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenTransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.Transfer(&_UpgradedStandardToken.TransactOpts, _to, _value) +} + +// TransferByLegacy is a paid mutator transaction binding the contract method 0x6e18980a. +// +// Solidity: function transferByLegacy(address from, address to, uint256 value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenTransactor) TransferByLegacy(opts *bind.TransactOpts, from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.contract.Transact(opts, "transferByLegacy", from, to, value) +} + +// TransferByLegacy is a paid mutator transaction binding the contract method 0x6e18980a. +// +// Solidity: function transferByLegacy(address from, address to, uint256 value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenSession) TransferByLegacy(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.TransferByLegacy(&_UpgradedStandardToken.TransactOpts, from, to, value) +} + +// TransferByLegacy is a paid mutator transaction binding the contract method 0x6e18980a. +// +// Solidity: function transferByLegacy(address from, address to, uint256 value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenTransactorSession) TransferByLegacy(from common.Address, to common.Address, value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.TransferByLegacy(&_UpgradedStandardToken.TransactOpts, from, to, value) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenTransactor) TransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.contract.Transact(opts, "transferFrom", _from, _to, _value) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.TransferFrom(&_UpgradedStandardToken.TransactOpts, _from, _to, _value) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address _from, address _to, uint256 _value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenTransactorSession) TransferFrom(_from common.Address, _to common.Address, _value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.TransferFrom(&_UpgradedStandardToken.TransactOpts, _from, _to, _value) +} + +// TransferFromByLegacy is a paid mutator transaction binding the contract method 0x8b477adb. +// +// Solidity: function transferFromByLegacy(address sender, address from, address spender, uint256 value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenTransactor) TransferFromByLegacy(opts *bind.TransactOpts, sender common.Address, from common.Address, spender common.Address, value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.contract.Transact(opts, "transferFromByLegacy", sender, from, spender, value) +} + +// TransferFromByLegacy is a paid mutator transaction binding the contract method 0x8b477adb. +// +// Solidity: function transferFromByLegacy(address sender, address from, address spender, uint256 value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenSession) TransferFromByLegacy(sender common.Address, from common.Address, spender common.Address, value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.TransferFromByLegacy(&_UpgradedStandardToken.TransactOpts, sender, from, spender, value) +} + +// TransferFromByLegacy is a paid mutator transaction binding the contract method 0x8b477adb. +// +// Solidity: function transferFromByLegacy(address sender, address from, address spender, uint256 value) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenTransactorSession) TransferFromByLegacy(sender common.Address, from common.Address, spender common.Address, value *big.Int) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.TransferFromByLegacy(&_UpgradedStandardToken.TransactOpts, sender, from, spender, value) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _UpgradedStandardToken.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.TransferOwnership(&_UpgradedStandardToken.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_UpgradedStandardToken *UpgradedStandardTokenTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _UpgradedStandardToken.Contract.TransferOwnership(&_UpgradedStandardToken.TransactOpts, newOwner) +} + +// UpgradedStandardTokenApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the UpgradedStandardToken contract. +type UpgradedStandardTokenApprovalIterator struct { + Event *UpgradedStandardTokenApproval // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *UpgradedStandardTokenApprovalIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(UpgradedStandardTokenApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(UpgradedStandardTokenApproval) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *UpgradedStandardTokenApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *UpgradedStandardTokenApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// UpgradedStandardTokenApproval represents a Approval event raised by the UpgradedStandardToken contract. +type UpgradedStandardTokenApproval struct { + Owner common.Address + Spender common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_UpgradedStandardToken *UpgradedStandardTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*UpgradedStandardTokenApprovalIterator, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _UpgradedStandardToken.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &UpgradedStandardTokenApprovalIterator{contract: _UpgradedStandardToken.contract, event: "Approval", logs: logs, sub: sub}, nil +} + +// WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_UpgradedStandardToken *UpgradedStandardTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *UpgradedStandardTokenApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { + + var ownerRule []interface{} + for _, ownerItem := range owner { + ownerRule = append(ownerRule, ownerItem) + } + var spenderRule []interface{} + for _, spenderItem := range spender { + spenderRule = append(spenderRule, spenderItem) + } + + logs, sub, err := _UpgradedStandardToken.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(UpgradedStandardTokenApproval) + if err := _UpgradedStandardToken.contract.UnpackLog(event, "Approval", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. +// +// Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) +func (_UpgradedStandardToken *UpgradedStandardTokenFilterer) ParseApproval(log types.Log) (*UpgradedStandardTokenApproval, error) { + event := new(UpgradedStandardTokenApproval) + if err := _UpgradedStandardToken.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + return event, nil +} + +// UpgradedStandardTokenTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the UpgradedStandardToken contract. +type UpgradedStandardTokenTransferIterator struct { + Event *UpgradedStandardTokenTransfer // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *UpgradedStandardTokenTransferIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(UpgradedStandardTokenTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(UpgradedStandardTokenTransfer) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *UpgradedStandardTokenTransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *UpgradedStandardTokenTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// UpgradedStandardTokenTransfer represents a Transfer event raised by the UpgradedStandardToken contract. +type UpgradedStandardTokenTransfer struct { + From common.Address + To common.Address + Value *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_UpgradedStandardToken *UpgradedStandardTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*UpgradedStandardTokenTransferIterator, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _UpgradedStandardToken.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &UpgradedStandardTokenTransferIterator{contract: _UpgradedStandardToken.contract, event: "Transfer", logs: logs, sub: sub}, nil +} + +// WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_UpgradedStandardToken *UpgradedStandardTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *UpgradedStandardTokenTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { + + var fromRule []interface{} + for _, fromItem := range from { + fromRule = append(fromRule, fromItem) + } + var toRule []interface{} + for _, toItem := range to { + toRule = append(toRule, toItem) + } + + logs, sub, err := _UpgradedStandardToken.contract.WatchLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(UpgradedStandardTokenTransfer) + if err := _UpgradedStandardToken.contract.UnpackLog(event, "Transfer", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. +// +// Solidity: event Transfer(address indexed from, address indexed to, uint256 value) +func (_UpgradedStandardToken *UpgradedStandardTokenFilterer) ParseTransfer(log types.Log) (*UpgradedStandardTokenTransfer, error) { + event := new(UpgradedStandardTokenTransfer) + if err := _UpgradedStandardToken.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + return event, nil +} +