feat: Waku v2 bridge

Issue #12610

vendor/github.com/status-im/status-go/contracts/balancechecker/BalanceChecker.go

@@ -0,0 +1,275 @@
+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package balancechecker
+
+import (
+	"errors"
+	"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 (
+	_ = errors.New
+	_ = big.NewInt
+	_ = strings.NewReader
+	_ = ethereum.NotFound
+	_ = bind.Bind
+	_ = common.Big1
+	_ = types.BloomLookup
+	_ = event.NewSubscription
+	_ = abi.ConvertType
+)
+
+// BalanceCheckerMetaData contains all meta data concerning the BalanceChecker contract.
+var BalanceCheckerMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"users\",\"type\":\"address[]\"},{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"}],\"name\":\"balancesHash\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"},{\"internalType\":\"bytes32[]\",\"name\":\"\",\"type\":\"bytes32[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"tokens\",\"type\":\"address[]\"}],\"name\":\"balancesPerAddress\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"tokenBalance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+}
+
+// BalanceCheckerABI is the input ABI used to generate the binding from.
+// Deprecated: Use BalanceCheckerMetaData.ABI instead.
+var BalanceCheckerABI = BalanceCheckerMetaData.ABI
+
+// BalanceChecker is an auto generated Go binding around an Ethereum contract.
+type BalanceChecker struct {
+	BalanceCheckerCaller     // Read-only binding to the contract
+	BalanceCheckerTransactor // Write-only binding to the contract
+	BalanceCheckerFilterer   // Log filterer for contract events
+}
+
+// BalanceCheckerCaller is an auto generated read-only Go binding around an Ethereum contract.
+type BalanceCheckerCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// BalanceCheckerTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type BalanceCheckerTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// BalanceCheckerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type BalanceCheckerFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// BalanceCheckerSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type BalanceCheckerSession struct {
+	Contract     *BalanceChecker   // 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
+}
+
+// BalanceCheckerCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type BalanceCheckerCallerSession struct {
+	Contract *BalanceCheckerCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts         // Call options to use throughout this session
+}
+
+// BalanceCheckerTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type BalanceCheckerTransactorSession struct {
+	Contract     *BalanceCheckerTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
+}
+
+// BalanceCheckerRaw is an auto generated low-level Go binding around an Ethereum contract.
+type BalanceCheckerRaw struct {
+	Contract *BalanceChecker // Generic contract binding to access the raw methods on
+}
+
+// BalanceCheckerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type BalanceCheckerCallerRaw struct {
+	Contract *BalanceCheckerCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// BalanceCheckerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type BalanceCheckerTransactorRaw struct {
+	Contract *BalanceCheckerTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewBalanceChecker creates a new instance of BalanceChecker, bound to a specific deployed contract.
+func NewBalanceChecker(address common.Address, backend bind.ContractBackend) (*BalanceChecker, error) {
+	contract, err := bindBalanceChecker(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &BalanceChecker{BalanceCheckerCaller: BalanceCheckerCaller{contract: contract}, BalanceCheckerTransactor: BalanceCheckerTransactor{contract: contract}, BalanceCheckerFilterer: BalanceCheckerFilterer{contract: contract}}, nil
+}
+
+// NewBalanceCheckerCaller creates a new read-only instance of BalanceChecker, bound to a specific deployed contract.
+func NewBalanceCheckerCaller(address common.Address, caller bind.ContractCaller) (*BalanceCheckerCaller, error) {
+	contract, err := bindBalanceChecker(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &BalanceCheckerCaller{contract: contract}, nil
+}
+
+// NewBalanceCheckerTransactor creates a new write-only instance of BalanceChecker, bound to a specific deployed contract.
+func NewBalanceCheckerTransactor(address common.Address, transactor bind.ContractTransactor) (*BalanceCheckerTransactor, error) {
+	contract, err := bindBalanceChecker(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &BalanceCheckerTransactor{contract: contract}, nil
+}
+
+// NewBalanceCheckerFilterer creates a new log filterer instance of BalanceChecker, bound to a specific deployed contract.
+func NewBalanceCheckerFilterer(address common.Address, filterer bind.ContractFilterer) (*BalanceCheckerFilterer, error) {
+	contract, err := bindBalanceChecker(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &BalanceCheckerFilterer{contract: contract}, nil
+}
+
+// bindBalanceChecker binds a generic wrapper to an already deployed contract.
+func bindBalanceChecker(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := BalanceCheckerMetaData.GetAbi()
+	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 (_BalanceChecker *BalanceCheckerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _BalanceChecker.Contract.BalanceCheckerCaller.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 (_BalanceChecker *BalanceCheckerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _BalanceChecker.Contract.BalanceCheckerTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_BalanceChecker *BalanceCheckerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _BalanceChecker.Contract.BalanceCheckerTransactor.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 (_BalanceChecker *BalanceCheckerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _BalanceChecker.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 (_BalanceChecker *BalanceCheckerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _BalanceChecker.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_BalanceChecker *BalanceCheckerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _BalanceChecker.Contract.contract.Transact(opts, method, params...)
+}
+
+// BalancesHash is a free data retrieval call binding the contract method 0x23c0503e.
+//
+// Solidity: function balancesHash(address[] users, address[] tokens) view returns(uint256, bytes32[])
+func (_BalanceChecker *BalanceCheckerCaller) BalancesHash(opts *bind.CallOpts, users []common.Address, tokens []common.Address) (*big.Int, [][32]byte, error) {
+	var out []interface{}
+	err := _BalanceChecker.contract.Call(opts, &out, "balancesHash", users, tokens)
+
+	if err != nil {
+		return *new(*big.Int), *new([][32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+	out1 := *abi.ConvertType(out[1], new([][32]byte)).(*[][32]byte)
+
+	return out0, out1, err
+
+}
+
+// BalancesHash is a free data retrieval call binding the contract method 0x23c0503e.
+//
+// Solidity: function balancesHash(address[] users, address[] tokens) view returns(uint256, bytes32[])
+func (_BalanceChecker *BalanceCheckerSession) BalancesHash(users []common.Address, tokens []common.Address) (*big.Int, [][32]byte, error) {
+	return _BalanceChecker.Contract.BalancesHash(&_BalanceChecker.CallOpts, users, tokens)
+}
+
+// BalancesHash is a free data retrieval call binding the contract method 0x23c0503e.
+//
+// Solidity: function balancesHash(address[] users, address[] tokens) view returns(uint256, bytes32[])
+func (_BalanceChecker *BalanceCheckerCallerSession) BalancesHash(users []common.Address, tokens []common.Address) (*big.Int, [][32]byte, error) {
+	return _BalanceChecker.Contract.BalancesHash(&_BalanceChecker.CallOpts, users, tokens)
+}
+
+// BalancesPerAddress is a free data retrieval call binding the contract method 0x1a55d770.
+//
+// Solidity: function balancesPerAddress(address user, address[] tokens) view returns(uint256[])
+func (_BalanceChecker *BalanceCheckerCaller) BalancesPerAddress(opts *bind.CallOpts, user common.Address, tokens []common.Address) ([]*big.Int, error) {
+	var out []interface{}
+	err := _BalanceChecker.contract.Call(opts, &out, "balancesPerAddress", user, tokens)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// BalancesPerAddress is a free data retrieval call binding the contract method 0x1a55d770.
+//
+// Solidity: function balancesPerAddress(address user, address[] tokens) view returns(uint256[])
+func (_BalanceChecker *BalanceCheckerSession) BalancesPerAddress(user common.Address, tokens []common.Address) ([]*big.Int, error) {
+	return _BalanceChecker.Contract.BalancesPerAddress(&_BalanceChecker.CallOpts, user, tokens)
+}
+
+// BalancesPerAddress is a free data retrieval call binding the contract method 0x1a55d770.
+//
+// Solidity: function balancesPerAddress(address user, address[] tokens) view returns(uint256[])
+func (_BalanceChecker *BalanceCheckerCallerSession) BalancesPerAddress(user common.Address, tokens []common.Address) ([]*big.Int, error) {
+	return _BalanceChecker.Contract.BalancesPerAddress(&_BalanceChecker.CallOpts, user, tokens)
+}
+
+// TokenBalance is a free data retrieval call binding the contract method 0x1049334f.
+//
+// Solidity: function tokenBalance(address user, address token) view returns(uint256)
+func (_BalanceChecker *BalanceCheckerCaller) TokenBalance(opts *bind.CallOpts, user common.Address, token common.Address) (*big.Int, error) {
+	var out []interface{}
+	err := _BalanceChecker.contract.Call(opts, &out, "tokenBalance", user, token)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// TokenBalance is a free data retrieval call binding the contract method 0x1049334f.
+//
+// Solidity: function tokenBalance(address user, address token) view returns(uint256)
+func (_BalanceChecker *BalanceCheckerSession) TokenBalance(user common.Address, token common.Address) (*big.Int, error) {
+	return _BalanceChecker.Contract.TokenBalance(&_BalanceChecker.CallOpts, user, token)
+}
+
+// TokenBalance is a free data retrieval call binding the contract method 0x1049334f.
+//
+// Solidity: function tokenBalance(address user, address token) view returns(uint256)
+func (_BalanceChecker *BalanceCheckerCallerSession) TokenBalance(user common.Address, token common.Address) (*big.Int, error) {
+	return _BalanceChecker.Contract.TokenBalance(&_BalanceChecker.CallOpts, user, token)
+}

vendor/github.com/status-im/status-go/contracts/balancechecker/BalanceChecker.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.4.22 <0.9.0;
+
+// ERC20 contract interface
+abstract contract Token {
+    function balanceOf(address) public view virtual returns (uint);
+}
+
+contract BalanceChecker {
+    function tokenBalance(
+        address user,
+        address token
+    ) public view returns (uint) {
+        return Token(token).balanceOf(user);
+    }
+
+    function balancesPerAddress(
+        address user,
+        address[] memory tokens
+    ) public view returns (uint[] memory) {
+        uint[] memory addrBalances = new uint[](
+            tokens.length + 1
+        );
+        for (uint i = 0; i < tokens.length; i++) {
+            addrBalances[i] = tokenBalance(user, tokens[i]);
+        }
+
+        addrBalances[tokens.length] = user.balance;
+        return addrBalances;
+    }
+
+    function balancesHash(
+        address[] calldata users,
+        address[] calldata tokens
+    ) external view returns (uint256, bytes32[] memory) {
+        bytes32[] memory addrBalances = new bytes32[](users.length);
+
+        for (uint i = 0; i < users.length; i++) {
+            addrBalances[i] = keccak256(
+                abi.encodePacked(balancesPerAddress(users[i], tokens))
+            );
+        }
+
+        return (block.number, addrBalances);
+    }
+}

vendor/github.com/status-im/status-go/contracts/balancechecker/address.go

@@ -0,0 +1,30 @@
+package balancechecker
+
+import (
+	"errors"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+var errorNotAvailableOnChainID = errors.New("BalanceChecker not available for chainID")
+
+var contractDataByChainID = map[uint64]common.Address{
+	1:        common.HexToAddress("0x040EA8bFE441597849A9456182fa46D38B75BC05"), // mainnet
+	10:       common.HexToAddress("0x55bD303eA3D50FC982A8a5b43972d7f38D129bbF"), // optimism
+	42161:    common.HexToAddress("0x54764eF12d29b249fDC7FC3caDc039955A396A8e"), // arbitrum
+	5:        common.HexToAddress("0xA5522A3194B78Dd231b64d0ccd6deA6156DCa7C8"), // goerli
+	421613:   common.HexToAddress("0x54764eF12d29b249fDC7FC3caDc039955A396A8e"), // goerli arbitrum
+	420:      common.HexToAddress("0x55bD303eA3D50FC982A8a5b43972d7f38D129bbF"), // goerli optimism
+	11155111: common.HexToAddress("0x55bD303eA3D50FC982A8a5b43972d7f38D129bbF"), // sepolia
+	421614:   common.HexToAddress("0x54764eF12d29b249fDC7FC3caDc039955A396A8e"), // sepolia arbitrum
+	11155420: common.HexToAddress("0x55bD303eA3D50FC982A8a5b43972d7f38D129bbF"), // sepolia optimism
+	777333:   common.HexToAddress("0x0000000000000000000000000000000010777333"), // unit tests
+}
+
+func ContractAddress(chainID uint64) (common.Address, error) {
+	contract, exists := contractDataByChainID[chainID]
+	if !exists {
+		return *new(common.Address), errorNotAvailableOnChainID
+	}
+	return contract, nil
+}

vendor/github.com/status-im/status-go/contracts/celer/doc.go

@@ -0,0 +1,3 @@
+package celer
+
+//go:generate abigen --abi bridge.abi --pkg celer --out bridge.go

vendor/github.com/status-im/status-go/contracts/community-tokens/deployer/address.go

@@ -0,0 +1,29 @@
+package communitytokendeployer
+
+import (
+	"errors"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+var errorNotAvailableOnChainID = errors.New("deployer contract not available for chainID")
+
+// addresses can be found on https://github.com/status-im/communities-contracts#deployments
+var contractAddressByChainID = map[uint64]common.Address{
+	1:        common.HexToAddress("0xB3Ef5B0825D5f665bE14394eea41E684CE96A4c5"), // Mainnet
+	5:        common.HexToAddress("0x81f4951ff8859d305F47A4574B206cF64C0d2645"), // Goerli
+	10:       common.HexToAddress("0x31463D22750324C8721FF7751584EF62F2ff93b3"), // Optimism
+	420:      common.HexToAddress("0xfFa8A255D905c909379859eA45B959D090DDC2d4"), // Optimism Goerli
+	42161:    common.HexToAddress("0x744Fd6e98dad09Fb8CCF530B5aBd32B56D64943b"), // Arbitrum
+	421613:   common.HexToAddress("0x7Ff554af5b6624db2135E4364F416d1D397f43e6"), // Arbitrum Goerli
+	11155111: common.HexToAddress("0xCDE984e57cdb88c70b53437cc694345B646371f9"), // Sepolia
+	421614:   common.HexToAddress("0x7Ff554af5b6624db2135E4364F416d1D397f43e6"), // Arbitrum Sepolia
+}
+
+func ContractAddress(chainID uint64) (common.Address, error) {
+	addr, exists := contractAddressByChainID[chainID]
+	if !exists {
+		return *new(common.Address), errorNotAvailableOnChainID
+	}
+	return addr, nil
+}

vendor/github.com/status-im/status-go/contracts/contracts.go

@@ -0,0 +1,254 @@
+package contracts
+
+import (
+	"errors"
+
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/status-im/status-go/contracts/balancechecker"
+	"github.com/status-im/status-go/contracts/directory"
+	"github.com/status-im/status-go/contracts/ethscan"
+	"github.com/status-im/status-go/contracts/hop"
+	hopBridge "github.com/status-im/status-go/contracts/hop/bridge"
+	hopSwap "github.com/status-im/status-go/contracts/hop/swap"
+	hopWrapper "github.com/status-im/status-go/contracts/hop/wrapper"
+	"github.com/status-im/status-go/contracts/ierc20"
+	"github.com/status-im/status-go/contracts/registrar"
+	"github.com/status-im/status-go/contracts/resolver"
+	"github.com/status-im/status-go/contracts/snt"
+	"github.com/status-im/status-go/contracts/stickers"
+	"github.com/status-im/status-go/rpc"
+)
+
+type ContractMaker struct {
+	RPCClient *rpc.Client
+}
+
+func NewContractMaker(client *rpc.Client) (*ContractMaker, error) {
+	if client == nil {
+		return nil, errors.New("could not initialize ContractMaker with an rpc client")
+	}
+	return &ContractMaker{RPCClient: client}, nil
+}
+
+func (c *ContractMaker) NewRegistryWithAddress(chainID uint64, address common.Address) (*resolver.ENSRegistryWithFallback, error) {
+	backend, err := c.RPCClient.EthClient(chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	return resolver.NewENSRegistryWithFallback(
+		address,
+		backend,
+	)
+}
+
+func (c *ContractMaker) NewRegistry(chainID uint64) (*resolver.ENSRegistryWithFallback, error) {
+	contractAddr, err := resolver.ContractAddress(chainID)
+	if err != nil {
+		return nil, err
+	}
+	return c.NewRegistryWithAddress(chainID, contractAddr)
+}
+
+func (c *ContractMaker) NewPublicResolver(chainID uint64, resolverAddress *common.Address) (*resolver.PublicResolver, error) {
+	backend, err := c.RPCClient.EthClient(chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	return resolver.NewPublicResolver(*resolverAddress, backend)
+}
+
+func (c *ContractMaker) NewUsernameRegistrar(chainID uint64, contractAddr common.Address) (*registrar.UsernameRegistrar, error) {
+	backend, err := c.RPCClient.EthClient(chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	return registrar.NewUsernameRegistrar(
+		contractAddr,
+		backend,
+	)
+}
+
+func (c *ContractMaker) NewERC20(chainID uint64, contractAddr common.Address) (*ierc20.IERC20, error) {
+	backend, err := c.RPCClient.EthClient(chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	return ierc20.NewIERC20(
+		contractAddr,
+		backend,
+	)
+}
+
+func (c *ContractMaker) NewSNT(chainID uint64) (*snt.SNT, error) {
+	contractAddr, err := snt.ContractAddress(chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	backend, err := c.RPCClient.EthClient(chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	return snt.NewSNT(contractAddr, backend)
+}
+
+func (c *ContractMaker) NewStickerType(chainID uint64) (*stickers.StickerType, error) {
+	contractAddr, err := stickers.StickerTypeContractAddress(chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	backend, err := c.RPCClient.EthClient(chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	return stickers.NewStickerType(
+		contractAddr,
+		backend,
+	)
+}
+
+func (c *ContractMaker) NewStickerMarket(chainID uint64) (*stickers.StickerMarket, error) {
+	contractAddr, err := stickers.StickerMarketContractAddress(chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	backend, err := c.RPCClient.EthClient(chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	return stickers.NewStickerMarket(
+		contractAddr,
+		backend,
+	)
+}
+
+func (c *ContractMaker) NewStickerPack(chainID uint64) (*stickers.StickerPack, error) {
+	contractAddr, err := stickers.StickerPackContractAddress(chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	backend, err := c.RPCClient.EthClient(chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	return stickers.NewStickerPack(
+		contractAddr,
+		backend,
+	)
+}
+
+func (c *ContractMaker) NewDirectory(chainID uint64) (*directory.Directory, error) {
+	contractAddr, err := directory.ContractAddress(chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	backend, err := c.RPCClient.EthClient(chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	return directory.NewDirectory(
+		contractAddr,
+		backend,
+	)
+}
+
+func (c *ContractMaker) NewEthScan(chainID uint64) (*ethscan.BalanceScanner, uint, error) {
+	contractAddr, err := ethscan.ContractAddress(chainID)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	contractCreatedAt, err := ethscan.ContractCreatedAt(chainID)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	backend, err := c.RPCClient.EthClient(chainID)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	scanner, err := ethscan.NewBalanceScanner(
+		contractAddr,
+		backend,
+	)
+
+	return scanner, contractCreatedAt, err
+}
+
+func (c *ContractMaker) NewBalanceChecker(chainID uint64) (*balancechecker.BalanceChecker, error) {
+	contractAddr, err := balancechecker.ContractAddress(chainID)
+	if err != nil {
+		return nil, err
+	}
+
+	backend, err := c.RPCClient.EthClient(chainID)
+	if err != nil {
+		return nil, err
+	}
+	return balancechecker.NewBalanceChecker(
+		contractAddr,
+		backend,
+	)
+}
+
+func (c *ContractMaker) NewHopL2SaddlSwap(chainID uint64, symbol string) (*hopSwap.HopSwap, error) {
+	contractAddr, err := hop.L2SaddleSwapContractAddress(chainID, symbol)
+	if err != nil {
+		return nil, err
+	}
+
+	backend, err := c.RPCClient.EthClient(chainID)
+	if err != nil {
+		return nil, err
+	}
+	return hopSwap.NewHopSwap(
+		contractAddr,
+		backend,
+	)
+}
+
+func (c *ContractMaker) NewHopL1Bridge(chainID uint64, symbol string) (*hopBridge.HopBridge, error) {
+	contractAddr, err := hop.L1BridgeContractAddress(chainID, symbol)
+	if err != nil {
+		return nil, err
+	}
+
+	backend, err := c.RPCClient.EthClient(chainID)
+	if err != nil {
+		return nil, err
+	}
+	return hopBridge.NewHopBridge(
+		contractAddr,
+		backend,
+	)
+}
+
+func (c *ContractMaker) NewHopL2AmmWrapper(chainID uint64, symbol string) (*hopWrapper.HopWrapper, error) {
+	contractAddr, err := hop.L2AmmWrapperContractAddress(chainID, symbol)
+	if err != nil {
+		return nil, err
+	}
+
+	backend, err := c.RPCClient.EthClient(chainID)
+	if err != nil {
+		return nil, err
+	}
+	return hopWrapper.NewHopWrapper(
+		contractAddr,
+		backend,
+	)
+}

vendor/github.com/status-im/status-go/contracts/directory/address.go

@@ -0,0 +1,22 @@
+package directory
+
+import (
+	"errors"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+var errorNotAvailableOnChainID = errors.New("not available for chainID")
+
+var contractAddressByChainID = map[uint64]common.Address{
+	10:  common.HexToAddress("0xA8d270048a086F5807A8dc0a9ae0e96280C41e3A"), // optimism mainnet
+	420: common.HexToAddress("0xB3Ef5B0825D5f665bE14394eea41E684CE96A4c5"), // optimism goerli testnet
+}
+
+func ContractAddress(chainID uint64) (common.Address, error) {
+	addr, exists := contractAddressByChainID[chainID]
+	if !exists {
+		return *new(common.Address), errorNotAvailableOnChainID
+	}
+	return addr, nil
+}

vendor/github.com/status-im/status-go/contracts/directory/directory.abi

@@ -0,0 +1,147 @@
+[
+    {
+        "inputs": [
+            {
+                "internalType": "address",
+                "name": "_votingContract",
+                "type": "address"
+            },
+            {
+                "internalType": "address",
+                "name": "_featuredVotingContract",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes",
+                "name": "community",
+                "type": "bytes"
+            }
+        ],
+        "name": "addCommunity",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "featuredVotingContract",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getCommunities",
+        "outputs": [
+            {
+                "internalType": "bytes[]",
+                "name": "",
+                "type": "bytes[]"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "getFeaturedCommunities",
+        "outputs": [
+            {
+                "internalType": "bytes[]",
+                "name": "",
+                "type": "bytes[]"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes",
+                "name": "community",
+                "type": "bytes"
+            }
+        ],
+        "name": "isCommunityFeatured",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes",
+                "name": "community",
+                "type": "bytes"
+            }
+        ],
+        "name": "isCommunityInDirectory",
+        "outputs": [
+            {
+                "internalType": "bool",
+                "name": "",
+                "type": "bool"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes",
+                "name": "community",
+                "type": "bytes"
+            }
+        ],
+        "name": "removeCommunity",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "internalType": "bytes[]",
+                "name": "_featuredCommunities",
+                "type": "bytes[]"
+            }
+        ],
+        "name": "setFeaturedCommunities",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "votingContract",
+        "outputs": [
+            {
+                "internalType": "address",
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    }
+]

vendor/github.com/status-im/status-go/contracts/directory/directory.go

@@ -0,0 +1,430 @@
+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package directory
+
+import (
+	"errors"
+	"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 (
+	_ = errors.New
+	_ = big.NewInt
+	_ = strings.NewReader
+	_ = ethereum.NotFound
+	_ = bind.Bind
+	_ = common.Big1
+	_ = types.BloomLookup
+	_ = event.NewSubscription
+	_ = abi.ConvertType
+)
+
+// DirectoryMetaData contains all meta data concerning the Directory contract.
+var DirectoryMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_votingContract\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_featuredVotingContract\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"community\",\"type\":\"bytes\"}],\"name\":\"addCommunity\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"featuredVotingContract\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getCommunities\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"\",\"type\":\"bytes[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getFeaturedCommunities\",\"outputs\":[{\"internalType\":\"bytes[]\",\"name\":\"\",\"type\":\"bytes[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"community\",\"type\":\"bytes\"}],\"name\":\"isCommunityFeatured\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"community\",\"type\":\"bytes\"}],\"name\":\"isCommunityInDirectory\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"community\",\"type\":\"bytes\"}],\"name\":\"removeCommunity\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"_featuredCommunities\",\"type\":\"bytes[]\"}],\"name\":\"setFeaturedCommunities\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"votingContract\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+}
+
+// DirectoryABI is the input ABI used to generate the binding from.
+// Deprecated: Use DirectoryMetaData.ABI instead.
+var DirectoryABI = DirectoryMetaData.ABI
+
+// Directory is an auto generated Go binding around an Ethereum contract.
+type Directory struct {
+	DirectoryCaller     // Read-only binding to the contract
+	DirectoryTransactor // Write-only binding to the contract
+	DirectoryFilterer   // Log filterer for contract events
+}
+
+// DirectoryCaller is an auto generated read-only Go binding around an Ethereum contract.
+type DirectoryCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DirectoryTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type DirectoryTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DirectoryFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type DirectoryFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DirectorySession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type DirectorySession struct {
+	Contract     *Directory        // 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
+}
+
+// DirectoryCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type DirectoryCallerSession struct {
+	Contract *DirectoryCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts    // Call options to use throughout this session
+}
+
+// DirectoryTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type DirectoryTransactorSession struct {
+	Contract     *DirectoryTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts    // Transaction auth options to use throughout this session
+}
+
+// DirectoryRaw is an auto generated low-level Go binding around an Ethereum contract.
+type DirectoryRaw struct {
+	Contract *Directory // Generic contract binding to access the raw methods on
+}
+
+// DirectoryCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type DirectoryCallerRaw struct {
+	Contract *DirectoryCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// DirectoryTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type DirectoryTransactorRaw struct {
+	Contract *DirectoryTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewDirectory creates a new instance of Directory, bound to a specific deployed contract.
+func NewDirectory(address common.Address, backend bind.ContractBackend) (*Directory, error) {
+	contract, err := bindDirectory(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &Directory{DirectoryCaller: DirectoryCaller{contract: contract}, DirectoryTransactor: DirectoryTransactor{contract: contract}, DirectoryFilterer: DirectoryFilterer{contract: contract}}, nil
+}
+
+// NewDirectoryCaller creates a new read-only instance of Directory, bound to a specific deployed contract.
+func NewDirectoryCaller(address common.Address, caller bind.ContractCaller) (*DirectoryCaller, error) {
+	contract, err := bindDirectory(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &DirectoryCaller{contract: contract}, nil
+}
+
+// NewDirectoryTransactor creates a new write-only instance of Directory, bound to a specific deployed contract.
+func NewDirectoryTransactor(address common.Address, transactor bind.ContractTransactor) (*DirectoryTransactor, error) {
+	contract, err := bindDirectory(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &DirectoryTransactor{contract: contract}, nil
+}
+
+// NewDirectoryFilterer creates a new log filterer instance of Directory, bound to a specific deployed contract.
+func NewDirectoryFilterer(address common.Address, filterer bind.ContractFilterer) (*DirectoryFilterer, error) {
+	contract, err := bindDirectory(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &DirectoryFilterer{contract: contract}, nil
+}
+
+// bindDirectory binds a generic wrapper to an already deployed contract.
+func bindDirectory(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := DirectoryMetaData.GetAbi()
+	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 (_Directory *DirectoryRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Directory.Contract.DirectoryCaller.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 (_Directory *DirectoryRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Directory.Contract.DirectoryTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Directory *DirectoryRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Directory.Contract.DirectoryTransactor.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 (_Directory *DirectoryCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Directory.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 (_Directory *DirectoryTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Directory.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Directory *DirectoryTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Directory.Contract.contract.Transact(opts, method, params...)
+}
+
+// FeaturedVotingContract is a free data retrieval call binding the contract method 0x7475fe93.
+//
+// Solidity: function featuredVotingContract() view returns(address)
+func (_Directory *DirectoryCaller) FeaturedVotingContract(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _Directory.contract.Call(opts, &out, "featuredVotingContract")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// FeaturedVotingContract is a free data retrieval call binding the contract method 0x7475fe93.
+//
+// Solidity: function featuredVotingContract() view returns(address)
+func (_Directory *DirectorySession) FeaturedVotingContract() (common.Address, error) {
+	return _Directory.Contract.FeaturedVotingContract(&_Directory.CallOpts)
+}
+
+// FeaturedVotingContract is a free data retrieval call binding the contract method 0x7475fe93.
+//
+// Solidity: function featuredVotingContract() view returns(address)
+func (_Directory *DirectoryCallerSession) FeaturedVotingContract() (common.Address, error) {
+	return _Directory.Contract.FeaturedVotingContract(&_Directory.CallOpts)
+}
+
+// GetCommunities is a free data retrieval call binding the contract method 0xc251b565.
+//
+// Solidity: function getCommunities() view returns(bytes[])
+func (_Directory *DirectoryCaller) GetCommunities(opts *bind.CallOpts) ([][]byte, error) {
+	var out []interface{}
+	err := _Directory.contract.Call(opts, &out, "getCommunities")
+
+	if err != nil {
+		return *new([][]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte)
+
+	return out0, err
+
+}
+
+// GetCommunities is a free data retrieval call binding the contract method 0xc251b565.
+//
+// Solidity: function getCommunities() view returns(bytes[])
+func (_Directory *DirectorySession) GetCommunities() ([][]byte, error) {
+	return _Directory.Contract.GetCommunities(&_Directory.CallOpts)
+}
+
+// GetCommunities is a free data retrieval call binding the contract method 0xc251b565.
+//
+// Solidity: function getCommunities() view returns(bytes[])
+func (_Directory *DirectoryCallerSession) GetCommunities() ([][]byte, error) {
+	return _Directory.Contract.GetCommunities(&_Directory.CallOpts)
+}
+
+// GetFeaturedCommunities is a free data retrieval call binding the contract method 0x967961c6.
+//
+// Solidity: function getFeaturedCommunities() view returns(bytes[])
+func (_Directory *DirectoryCaller) GetFeaturedCommunities(opts *bind.CallOpts) ([][]byte, error) {
+	var out []interface{}
+	err := _Directory.contract.Call(opts, &out, "getFeaturedCommunities")
+
+	if err != nil {
+		return *new([][]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([][]byte)).(*[][]byte)
+
+	return out0, err
+
+}
+
+// GetFeaturedCommunities is a free data retrieval call binding the contract method 0x967961c6.
+//
+// Solidity: function getFeaturedCommunities() view returns(bytes[])
+func (_Directory *DirectorySession) GetFeaturedCommunities() ([][]byte, error) {
+	return _Directory.Contract.GetFeaturedCommunities(&_Directory.CallOpts)
+}
+
+// GetFeaturedCommunities is a free data retrieval call binding the contract method 0x967961c6.
+//
+// Solidity: function getFeaturedCommunities() view returns(bytes[])
+func (_Directory *DirectoryCallerSession) GetFeaturedCommunities() ([][]byte, error) {
+	return _Directory.Contract.GetFeaturedCommunities(&_Directory.CallOpts)
+}
+
+// IsCommunityFeatured is a free data retrieval call binding the contract method 0xf6a18e62.
+//
+// Solidity: function isCommunityFeatured(bytes community) view returns(bool)
+func (_Directory *DirectoryCaller) IsCommunityFeatured(opts *bind.CallOpts, community []byte) (bool, error) {
+	var out []interface{}
+	err := _Directory.contract.Call(opts, &out, "isCommunityFeatured", community)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// IsCommunityFeatured is a free data retrieval call binding the contract method 0xf6a18e62.
+//
+// Solidity: function isCommunityFeatured(bytes community) view returns(bool)
+func (_Directory *DirectorySession) IsCommunityFeatured(community []byte) (bool, error) {
+	return _Directory.Contract.IsCommunityFeatured(&_Directory.CallOpts, community)
+}
+
+// IsCommunityFeatured is a free data retrieval call binding the contract method 0xf6a18e62.
+//
+// Solidity: function isCommunityFeatured(bytes community) view returns(bool)
+func (_Directory *DirectoryCallerSession) IsCommunityFeatured(community []byte) (bool, error) {
+	return _Directory.Contract.IsCommunityFeatured(&_Directory.CallOpts, community)
+}
+
+// IsCommunityInDirectory is a free data retrieval call binding the contract method 0xb3dbb52a.
+//
+// Solidity: function isCommunityInDirectory(bytes community) view returns(bool)
+func (_Directory *DirectoryCaller) IsCommunityInDirectory(opts *bind.CallOpts, community []byte) (bool, error) {
+	var out []interface{}
+	err := _Directory.contract.Call(opts, &out, "isCommunityInDirectory", community)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// IsCommunityInDirectory is a free data retrieval call binding the contract method 0xb3dbb52a.
+//
+// Solidity: function isCommunityInDirectory(bytes community) view returns(bool)
+func (_Directory *DirectorySession) IsCommunityInDirectory(community []byte) (bool, error) {
+	return _Directory.Contract.IsCommunityInDirectory(&_Directory.CallOpts, community)
+}
+
+// IsCommunityInDirectory is a free data retrieval call binding the contract method 0xb3dbb52a.
+//
+// Solidity: function isCommunityInDirectory(bytes community) view returns(bool)
+func (_Directory *DirectoryCallerSession) IsCommunityInDirectory(community []byte) (bool, error) {
+	return _Directory.Contract.IsCommunityInDirectory(&_Directory.CallOpts, community)
+}
+
+// VotingContract is a free data retrieval call binding the contract method 0xc1fc006a.
+//
+// Solidity: function votingContract() view returns(address)
+func (_Directory *DirectoryCaller) VotingContract(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _Directory.contract.Call(opts, &out, "votingContract")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// VotingContract is a free data retrieval call binding the contract method 0xc1fc006a.
+//
+// Solidity: function votingContract() view returns(address)
+func (_Directory *DirectorySession) VotingContract() (common.Address, error) {
+	return _Directory.Contract.VotingContract(&_Directory.CallOpts)
+}
+
+// VotingContract is a free data retrieval call binding the contract method 0xc1fc006a.
+//
+// Solidity: function votingContract() view returns(address)
+func (_Directory *DirectoryCallerSession) VotingContract() (common.Address, error) {
+	return _Directory.Contract.VotingContract(&_Directory.CallOpts)
+}
+
+// AddCommunity is a paid mutator transaction binding the contract method 0x74837935.
+//
+// Solidity: function addCommunity(bytes community) returns()
+func (_Directory *DirectoryTransactor) AddCommunity(opts *bind.TransactOpts, community []byte) (*types.Transaction, error) {
+	return _Directory.contract.Transact(opts, "addCommunity", community)
+}
+
+// AddCommunity is a paid mutator transaction binding the contract method 0x74837935.
+//
+// Solidity: function addCommunity(bytes community) returns()
+func (_Directory *DirectorySession) AddCommunity(community []byte) (*types.Transaction, error) {
+	return _Directory.Contract.AddCommunity(&_Directory.TransactOpts, community)
+}
+
+// AddCommunity is a paid mutator transaction binding the contract method 0x74837935.
+//
+// Solidity: function addCommunity(bytes community) returns()
+func (_Directory *DirectoryTransactorSession) AddCommunity(community []byte) (*types.Transaction, error) {
+	return _Directory.Contract.AddCommunity(&_Directory.TransactOpts, community)
+}
+
+// RemoveCommunity is a paid mutator transaction binding the contract method 0x3c01b93c.
+//
+// Solidity: function removeCommunity(bytes community) returns()
+func (_Directory *DirectoryTransactor) RemoveCommunity(opts *bind.TransactOpts, community []byte) (*types.Transaction, error) {
+	return _Directory.contract.Transact(opts, "removeCommunity", community)
+}
+
+// RemoveCommunity is a paid mutator transaction binding the contract method 0x3c01b93c.
+//
+// Solidity: function removeCommunity(bytes community) returns()
+func (_Directory *DirectorySession) RemoveCommunity(community []byte) (*types.Transaction, error) {
+	return _Directory.Contract.RemoveCommunity(&_Directory.TransactOpts, community)
+}
+
+// RemoveCommunity is a paid mutator transaction binding the contract method 0x3c01b93c.
+//
+// Solidity: function removeCommunity(bytes community) returns()
+func (_Directory *DirectoryTransactorSession) RemoveCommunity(community []byte) (*types.Transaction, error) {
+	return _Directory.Contract.RemoveCommunity(&_Directory.TransactOpts, community)
+}
+
+// SetFeaturedCommunities is a paid mutator transaction binding the contract method 0xd62879f1.
+//
+// Solidity: function setFeaturedCommunities(bytes[] _featuredCommunities) returns()
+func (_Directory *DirectoryTransactor) SetFeaturedCommunities(opts *bind.TransactOpts, _featuredCommunities [][]byte) (*types.Transaction, error) {
+	return _Directory.contract.Transact(opts, "setFeaturedCommunities", _featuredCommunities)
+}
+
+// SetFeaturedCommunities is a paid mutator transaction binding the contract method 0xd62879f1.
+//
+// Solidity: function setFeaturedCommunities(bytes[] _featuredCommunities) returns()
+func (_Directory *DirectorySession) SetFeaturedCommunities(_featuredCommunities [][]byte) (*types.Transaction, error) {
+	return _Directory.Contract.SetFeaturedCommunities(&_Directory.TransactOpts, _featuredCommunities)
+}
+
+// SetFeaturedCommunities is a paid mutator transaction binding the contract method 0xd62879f1.
+//
+// Solidity: function setFeaturedCommunities(bytes[] _featuredCommunities) returns()
+func (_Directory *DirectoryTransactorSession) SetFeaturedCommunities(_featuredCommunities [][]byte) (*types.Transaction, error) {
+	return _Directory.Contract.SetFeaturedCommunities(&_Directory.TransactOpts, _featuredCommunities)
+}

vendor/github.com/status-im/status-go/contracts/directory/doc.go

@@ -0,0 +1,3 @@
+package directory
+
+//go:generate abigen -abi directory.abi -pkg directory -out directory.go

vendor/github.com/status-im/status-go/contracts/ethscan/address.go

@@ -0,0 +1,43 @@
+package ethscan
+
+import (
+	"errors"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+var errorNotAvailableOnChainID = errors.New("not available for chainID")
+
+type ContractData struct {
+	Address        common.Address
+	CreatedAtBlock uint
+}
+
+var contractDataByChainID = map[uint64]ContractData{
+	1:        {common.HexToAddress("0x08A8fDBddc160A7d5b957256b903dCAb1aE512C5"), 12_194_222}, // mainnet
+	5:        {common.HexToAddress("0x08A8fDBddc160A7d5b957256b903dCAb1aE512C5"), 4_578_854},  // goerli
+	10:       {common.HexToAddress("0x9e5076df494fc949abc4461f4e57592b81517d81"), 34_421_097}, // optimism
+	420:      {common.HexToAddress("0xf532c75239fa61b66d31e73f44300c46da41aadd"), 2_236_534},  // goerli optimism
+	42161:    {common.HexToAddress("0xbb85398092b83a016935a17fc857507b7851a071"), 70_031_945}, // arbitrum
+	421613:   {common.HexToAddress("0xec21ebe1918e8975fc0cd0c7747d318c00c0acd5"), 818_155},    // goerli arbitrum
+	777333:   {common.HexToAddress("0x0000000000000000000000000000000000777333"), 50},         // unit tests
+	11155111: {common.HexToAddress("0xec21ebe1918e8975fc0cd0c7747d318c00c0acd5"), 4_366_506},  // sepolia
+	421614:   {common.HexToAddress("0xec21Ebe1918E8975FC0CD0c7747D318C00C0aCd5"), 553_947},    // sepolia arbitrum
+	11155420: {common.HexToAddress("0xec21ebe1918e8975fc0cd0c7747d318c00c0acd5"), 7_362_011},  // sepolia optimism
+}
+
+func ContractAddress(chainID uint64) (common.Address, error) {
+	contract, exists := contractDataByChainID[chainID]
+	if !exists {
+		return *new(common.Address), errorNotAvailableOnChainID
+	}
+	return contract.Address, nil
+}
+
+func ContractCreatedAt(chainID uint64) (uint, error) {
+	contract, exists := contractDataByChainID[chainID]
+	if !exists {
+		return 0, errorNotAvailableOnChainID
+	}
+	return contract.CreatedAtBlock, nil
+}

vendor/github.com/status-im/status-go/contracts/ethscan/doc.go

@@ -0,0 +1,3 @@
+package ethscan
+
+//go:generate abigen -sol ethscan.sol -pkg ethscan -out ethscan.go

vendor/github.com/status-im/status-go/contracts/ethscan/ethscan.go

@@ -0,0 +1,342 @@
+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package ethscan
+
+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
+)
+
+// BalanceScannerResult is an auto generated low-level Go binding around an user-defined struct.
+type BalanceScannerResult struct {
+	Success bool
+	Data    []byte
+}
+
+// BalanceScannerABI is the input ABI used to generate the binding from.
+const BalanceScannerABI = "[{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"contracts\",\"type\":\"address[]\"},{\"internalType\":\"bytes[]\",\"name\":\"data\",\"type\":\"bytes[]\"},{\"internalType\":\"uint256\",\"name\":\"gas\",\"type\":\"uint256\"}],\"name\":\"call\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"internalType\":\"structBalanceScanner.Result[]\",\"name\":\"results\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"contracts\",\"type\":\"address[]\"},{\"internalType\":\"bytes[]\",\"name\":\"data\",\"type\":\"bytes[]\"}],\"name\":\"call\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"internalType\":\"structBalanceScanner.Result[]\",\"name\":\"results\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"addresses\",\"type\":\"address[]\"}],\"name\":\"etherBalances\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"internalType\":\"structBalanceScanner.Result[]\",\"name\":\"results\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"addresses\",\"type\":\"address[]\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"tokenBalances\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"internalType\":\"structBalanceScanner.Result[]\",\"name\":\"results\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"contracts\",\"type\":\"address[]\"}],\"name\":\"tokensBalance\",\"outputs\":[{\"components\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"internalType\":\"structBalanceScanner.Result[]\",\"name\":\"results\",\"type\":\"tuple[]\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]"
+
+// BalanceScannerFuncSigs maps the 4-byte function signature to its string representation.
+var BalanceScannerFuncSigs = map[string]string{
+	"458b3a7c": "call(address[],bytes[])",
+	"36738374": "call(address[],bytes[],uint256)",
+	"dbdbb51b": "etherBalances(address[])",
+	"aad33091": "tokenBalances(address[],address)",
+	"e5da1b68": "tokensBalance(address,address[])",
+}
+
+// BalanceScanner is an auto generated Go binding around an Ethereum contract.
+type BalanceScanner struct {
+	BalanceScannerCaller     // Read-only binding to the contract
+	BalanceScannerTransactor // Write-only binding to the contract
+	BalanceScannerFilterer   // Log filterer for contract events
+}
+
+// BalanceScannerCaller is an auto generated read-only Go binding around an Ethereum contract.
+type BalanceScannerCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// BalanceScannerTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type BalanceScannerTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// BalanceScannerFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type BalanceScannerFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// BalanceScannerSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type BalanceScannerSession struct {
+	Contract     *BalanceScanner   // 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
+}
+
+// BalanceScannerCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type BalanceScannerCallerSession struct {
+	Contract *BalanceScannerCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts         // Call options to use throughout this session
+}
+
+// BalanceScannerTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type BalanceScannerTransactorSession struct {
+	Contract     *BalanceScannerTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts         // Transaction auth options to use throughout this session
+}
+
+// BalanceScannerRaw is an auto generated low-level Go binding around an Ethereum contract.
+type BalanceScannerRaw struct {
+	Contract *BalanceScanner // Generic contract binding to access the raw methods on
+}
+
+// BalanceScannerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type BalanceScannerCallerRaw struct {
+	Contract *BalanceScannerCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// BalanceScannerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type BalanceScannerTransactorRaw struct {
+	Contract *BalanceScannerTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewBalanceScanner creates a new instance of BalanceScanner, bound to a specific deployed contract.
+func NewBalanceScanner(address common.Address, backend bind.ContractBackend) (*BalanceScanner, error) {
+	contract, err := bindBalanceScanner(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &BalanceScanner{BalanceScannerCaller: BalanceScannerCaller{contract: contract}, BalanceScannerTransactor: BalanceScannerTransactor{contract: contract}, BalanceScannerFilterer: BalanceScannerFilterer{contract: contract}}, nil
+}
+
+// NewBalanceScannerCaller creates a new read-only instance of BalanceScanner, bound to a specific deployed contract.
+func NewBalanceScannerCaller(address common.Address, caller bind.ContractCaller) (*BalanceScannerCaller, error) {
+	contract, err := bindBalanceScanner(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &BalanceScannerCaller{contract: contract}, nil
+}
+
+// NewBalanceScannerTransactor creates a new write-only instance of BalanceScanner, bound to a specific deployed contract.
+func NewBalanceScannerTransactor(address common.Address, transactor bind.ContractTransactor) (*BalanceScannerTransactor, error) {
+	contract, err := bindBalanceScanner(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &BalanceScannerTransactor{contract: contract}, nil
+}
+
+// NewBalanceScannerFilterer creates a new log filterer instance of BalanceScanner, bound to a specific deployed contract.
+func NewBalanceScannerFilterer(address common.Address, filterer bind.ContractFilterer) (*BalanceScannerFilterer, error) {
+	contract, err := bindBalanceScanner(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &BalanceScannerFilterer{contract: contract}, nil
+}
+
+// bindBalanceScanner binds a generic wrapper to an already deployed contract.
+func bindBalanceScanner(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := abi.JSON(strings.NewReader(BalanceScannerABI))
+	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 (_BalanceScanner *BalanceScannerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _BalanceScanner.Contract.BalanceScannerCaller.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 (_BalanceScanner *BalanceScannerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _BalanceScanner.Contract.BalanceScannerTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_BalanceScanner *BalanceScannerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _BalanceScanner.Contract.BalanceScannerTransactor.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 (_BalanceScanner *BalanceScannerCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _BalanceScanner.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 (_BalanceScanner *BalanceScannerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _BalanceScanner.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_BalanceScanner *BalanceScannerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _BalanceScanner.Contract.contract.Transact(opts, method, params...)
+}
+
+// Call is a free data retrieval call binding the contract method 0x36738374.
+//
+// Solidity: function call(address[] contracts, bytes[] data, uint256 gas) view returns((bool,bytes)[] results)
+func (_BalanceScanner *BalanceScannerCaller) Call(opts *bind.CallOpts, contracts []common.Address, data [][]byte, gas *big.Int) ([]BalanceScannerResult, error) {
+	var out []interface{}
+	err := _BalanceScanner.contract.Call(opts, &out, "call", contracts, data, gas)
+
+	if err != nil {
+		return *new([]BalanceScannerResult), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]BalanceScannerResult)).(*[]BalanceScannerResult)
+
+	return out0, err
+
+}
+
+// Call is a free data retrieval call binding the contract method 0x36738374.
+//
+// Solidity: function call(address[] contracts, bytes[] data, uint256 gas) view returns((bool,bytes)[] results)
+func (_BalanceScanner *BalanceScannerSession) Call(contracts []common.Address, data [][]byte, gas *big.Int) ([]BalanceScannerResult, error) {
+	return _BalanceScanner.Contract.Call(&_BalanceScanner.CallOpts, contracts, data, gas)
+}
+
+// Call is a free data retrieval call binding the contract method 0x36738374.
+//
+// Solidity: function call(address[] contracts, bytes[] data, uint256 gas) view returns((bool,bytes)[] results)
+func (_BalanceScanner *BalanceScannerCallerSession) Call(contracts []common.Address, data [][]byte, gas *big.Int) ([]BalanceScannerResult, error) {
+	return _BalanceScanner.Contract.Call(&_BalanceScanner.CallOpts, contracts, data, gas)
+}
+
+// Call0 is a free data retrieval call binding the contract method 0x458b3a7c.
+//
+// Solidity: function call(address[] contracts, bytes[] data) view returns((bool,bytes)[] results)
+func (_BalanceScanner *BalanceScannerCaller) Call0(opts *bind.CallOpts, contracts []common.Address, data [][]byte) ([]BalanceScannerResult, error) {
+	var out []interface{}
+	err := _BalanceScanner.contract.Call(opts, &out, "call0", contracts, data)
+
+	if err != nil {
+		return *new([]BalanceScannerResult), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]BalanceScannerResult)).(*[]BalanceScannerResult)
+
+	return out0, err
+
+}
+
+// Call0 is a free data retrieval call binding the contract method 0x458b3a7c.
+//
+// Solidity: function call(address[] contracts, bytes[] data) view returns((bool,bytes)[] results)
+func (_BalanceScanner *BalanceScannerSession) Call0(contracts []common.Address, data [][]byte) ([]BalanceScannerResult, error) {
+	return _BalanceScanner.Contract.Call0(&_BalanceScanner.CallOpts, contracts, data)
+}
+
+// Call0 is a free data retrieval call binding the contract method 0x458b3a7c.
+//
+// Solidity: function call(address[] contracts, bytes[] data) view returns((bool,bytes)[] results)
+func (_BalanceScanner *BalanceScannerCallerSession) Call0(contracts []common.Address, data [][]byte) ([]BalanceScannerResult, error) {
+	return _BalanceScanner.Contract.Call0(&_BalanceScanner.CallOpts, contracts, data)
+}
+
+// EtherBalances is a free data retrieval call binding the contract method 0xdbdbb51b.
+//
+// Solidity: function etherBalances(address[] addresses) view returns((bool,bytes)[] results)
+func (_BalanceScanner *BalanceScannerCaller) EtherBalances(opts *bind.CallOpts, addresses []common.Address) ([]BalanceScannerResult, error) {
+	var out []interface{}
+	err := _BalanceScanner.contract.Call(opts, &out, "etherBalances", addresses)
+
+	if err != nil {
+		return *new([]BalanceScannerResult), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]BalanceScannerResult)).(*[]BalanceScannerResult)
+
+	return out0, err
+
+}
+
+// EtherBalances is a free data retrieval call binding the contract method 0xdbdbb51b.
+//
+// Solidity: function etherBalances(address[] addresses) view returns((bool,bytes)[] results)
+func (_BalanceScanner *BalanceScannerSession) EtherBalances(addresses []common.Address) ([]BalanceScannerResult, error) {
+	return _BalanceScanner.Contract.EtherBalances(&_BalanceScanner.CallOpts, addresses)
+}
+
+// EtherBalances is a free data retrieval call binding the contract method 0xdbdbb51b.
+//
+// Solidity: function etherBalances(address[] addresses) view returns((bool,bytes)[] results)
+func (_BalanceScanner *BalanceScannerCallerSession) EtherBalances(addresses []common.Address) ([]BalanceScannerResult, error) {
+	return _BalanceScanner.Contract.EtherBalances(&_BalanceScanner.CallOpts, addresses)
+}
+
+// TokenBalances is a free data retrieval call binding the contract method 0xaad33091.
+//
+// Solidity: function tokenBalances(address[] addresses, address token) view returns((bool,bytes)[] results)
+func (_BalanceScanner *BalanceScannerCaller) TokenBalances(opts *bind.CallOpts, addresses []common.Address, token common.Address) ([]BalanceScannerResult, error) {
+	var out []interface{}
+	err := _BalanceScanner.contract.Call(opts, &out, "tokenBalances", addresses, token)
+
+	if err != nil {
+		return *new([]BalanceScannerResult), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]BalanceScannerResult)).(*[]BalanceScannerResult)
+
+	return out0, err
+
+}
+
+// TokenBalances is a free data retrieval call binding the contract method 0xaad33091.
+//
+// Solidity: function tokenBalances(address[] addresses, address token) view returns((bool,bytes)[] results)
+func (_BalanceScanner *BalanceScannerSession) TokenBalances(addresses []common.Address, token common.Address) ([]BalanceScannerResult, error) {
+	return _BalanceScanner.Contract.TokenBalances(&_BalanceScanner.CallOpts, addresses, token)
+}
+
+// TokenBalances is a free data retrieval call binding the contract method 0xaad33091.
+//
+// Solidity: function tokenBalances(address[] addresses, address token) view returns((bool,bytes)[] results)
+func (_BalanceScanner *BalanceScannerCallerSession) TokenBalances(addresses []common.Address, token common.Address) ([]BalanceScannerResult, error) {
+	return _BalanceScanner.Contract.TokenBalances(&_BalanceScanner.CallOpts, addresses, token)
+}
+
+// TokensBalance is a free data retrieval call binding the contract method 0xe5da1b68.
+//
+// Solidity: function tokensBalance(address owner, address[] contracts) view returns((bool,bytes)[] results)
+func (_BalanceScanner *BalanceScannerCaller) TokensBalance(opts *bind.CallOpts, owner common.Address, contracts []common.Address) ([]BalanceScannerResult, error) {
+	var out []interface{}
+	err := _BalanceScanner.contract.Call(opts, &out, "tokensBalance", owner, contracts)
+
+	if err != nil {
+		return *new([]BalanceScannerResult), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]BalanceScannerResult)).(*[]BalanceScannerResult)
+
+	return out0, err
+
+}
+
+// TokensBalance is a free data retrieval call binding the contract method 0xe5da1b68.
+//
+// Solidity: function tokensBalance(address owner, address[] contracts) view returns((bool,bytes)[] results)
+func (_BalanceScanner *BalanceScannerSession) TokensBalance(owner common.Address, contracts []common.Address) ([]BalanceScannerResult, error) {
+	return _BalanceScanner.Contract.TokensBalance(&_BalanceScanner.CallOpts, owner, contracts)
+}
+
+// TokensBalance is a free data retrieval call binding the contract method 0xe5da1b68.
+//
+// Solidity: function tokensBalance(address owner, address[] contracts) view returns((bool,bytes)[] results)
+func (_BalanceScanner *BalanceScannerCallerSession) TokensBalance(owner common.Address, contracts []common.Address) ([]BalanceScannerResult, error) {
+	return _BalanceScanner.Contract.TokensBalance(&_BalanceScanner.CallOpts, owner, contracts)
+}

vendor/github.com/status-im/status-go/contracts/ethscan/ethscan.sol

@@ -0,0 +1,64 @@
+/**
+ *Submitted for verification at Etherscan.io on 2021-04-07
+*/
+
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.3;
+
+/**
+ * @title An Ether or token balance scanner
+ * @author Maarten Zuidhoorn
+ * @author Luit Hollander
+ */
+abstract contract BalanceScanner {
+  struct Result {
+    bool success;
+    bytes data;
+  }
+
+  /**
+   * @notice Get the Ether balance for all addresses specified
+   * @param addresses The addresses to get the Ether balance for
+   * @return results The Ether balance for all addresses in the same order as specified
+   */
+  function etherBalances(address[] calldata addresses) external virtual view returns (Result[] memory results);
+
+  /**
+   * @notice Get the ERC-20 token balance of `token` for all addresses specified
+   * @dev This does not check if the `token` address specified is actually an ERC-20 token
+   * @param addresses The addresses to get the token balance for
+   * @param token The address of the ERC-20 token contract
+   * @return results The token balance for all addresses in the same order as specified
+   */
+  function tokenBalances(address[] calldata addresses, address token) external virtual view returns (Result[] memory results);
+
+  /**
+   * @notice Get the ERC-20 token balance from multiple contracts for a single owner
+   * @param owner The address of the token owner
+   * @param contracts The addresses of the ERC-20 token contracts
+   * @return results The token balances in the same order as the addresses specified
+   */
+  function tokensBalance(address owner, address[] calldata contracts) external virtual view returns (Result[] memory results);
+
+  /**
+   * @notice Call multiple contracts with the provided arbitrary data
+   * @param contracts The contracts to call
+   * @param data The data to call the contracts with
+   * @return results The raw result of the contract calls
+   */
+  function call(address[] calldata contracts, bytes[] calldata data) external virtual view returns (Result[] memory results);
+
+  /**
+   * @notice Call multiple contracts with the provided arbitrary data
+   * @param contracts The contracts to call
+   * @param data The data to call the contracts with
+   * @param gas The amount of gas to call the contracts with
+   * @return results The raw result of the contract calls
+   */
+  function call(
+    address[] calldata contracts,
+    bytes[] calldata data,
+    uint256 gas
+  ) public view virtual returns (Result[] memory results);
+}

vendor/github.com/status-im/status-go/contracts/hop/address.go

@@ -0,0 +1,115 @@
+package hop
+
+import (
+	"errors"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+var errorNotAvailableOnChainID = errors.New("not available for chainID")
+
+var l2SaddleSwapContractAddresses = map[uint64]map[string]common.Address{
+	10: {
+		"USDC": common.HexToAddress("0x3c0FFAca566fCcfD9Cc95139FEF6CBA143795963"),
+		"USDT": common.HexToAddress("0xeC4B41Af04cF917b54AEb6Df58c0f8D78895b5Ef"),
+		"DAI":  common.HexToAddress("0xF181eD90D6CfaC84B8073FdEA6D34Aa744B41810"),
+		"ETH":  common.HexToAddress("0xaa30D6bba6285d0585722e2440Ff89E23EF68864"),
+		"WBTC": common.HexToAddress("0x46fc3Af3A47792cA3ED06fdF3D657145A675a8D8"),
+	},
+	42161: {
+		"USDC": common.HexToAddress("0x10541b07d8Ad2647Dc6cD67abd4c03575dade261"),
+		"USDT": common.HexToAddress("0x18f7402B673Ba6Fb5EA4B95768aABb8aaD7ef18a"),
+		"DAI":  common.HexToAddress("0xa5A33aB9063395A90CCbEa2D86a62EcCf27B5742"),
+		"ETH":  common.HexToAddress("0x652d27c0F72771Ce5C76fd400edD61B406Ac6D97"),
+		"WBTC": common.HexToAddress("0x7191061D5d4C60f598214cC6913502184BAddf18"),
+	},
+	420: {
+		"USDC": common.HexToAddress("0xE4757dD81AFbecF61E51824AB9238df6691c3D0e"),
+		"ETH":  common.HexToAddress("0xa50395bdEaca7062255109fedE012eFE63d6D402"),
+	},
+	421613: {
+		"USDC": common.HexToAddress("0x83f6244Bd87662118d96D9a6D44f09dffF14b30E"),
+		"ETH":  common.HexToAddress("0x69a71b7F6Ff088a0310b4f911b4f9eA11e2E9740"),
+	},
+}
+
+var l2AmmWrapperContractAddress = map[uint64]map[string]common.Address{
+	10: {
+		"USDC": common.HexToAddress("0x2ad09850b0CA4c7c1B33f5AcD6cBAbCaB5d6e796"),
+		"USDT": common.HexToAddress("0x7D269D3E0d61A05a0bA976b7DBF8805bF844AF3F"),
+		"DAI":  common.HexToAddress("0xb3C68a491608952Cb1257FC9909a537a0173b63B"),
+		"ETH":  common.HexToAddress("0x86cA30bEF97fB651b8d866D45503684b90cb3312"),
+		"WBTC": common.HexToAddress("0x2A11a98e2fCF4674F30934B5166645fE6CA35F56"),
+	},
+	42161: {
+		"USDC": common.HexToAddress("0xe22D2beDb3Eca35E6397e0C6D62857094aA26F52"),
+		"USDT": common.HexToAddress("0xCB0a4177E0A60247C0ad18Be87f8eDfF6DD30283"),
+		"DAI":  common.HexToAddress("0xe7F40BF16AB09f4a6906Ac2CAA4094aD2dA48Cc2"),
+		"ETH":  common.HexToAddress("0x33ceb27b39d2Bb7D2e61F7564d3Df29344020417"),
+		"WBTC": common.HexToAddress("0xC08055b634D43F2176d721E26A3428D3b7E7DdB5"),
+	},
+	420: {
+		"USDC": common.HexToAddress("0xfF21e82a4Bc305BCE591530A68628192b5b6B6FD"),
+		"ETH":  common.HexToAddress("0xC1985d7a3429cDC85E59E2E4Fcc805b857e6Ee2E"),
+	},
+	421613: {
+		"USDC": common.HexToAddress("0x32219766597DFbb10297127238D921E7CCF5D920"),
+		"ETH":  common.HexToAddress("0xa832293f2DCe2f092182F17dd873ae06AD5fDbaF"),
+	},
+}
+
+var l1BridgeContractAddress = map[uint64]map[string]common.Address{
+	1: {
+		"USDC": common.HexToAddress("0x3666f603Cc164936C1b87e207F36BEBa4AC5f18a"),
+		"USDT": common.HexToAddress("0x3666f603Cc164936C1b87e207F36BEBa4AC5f18a"),
+		"DAI":  common.HexToAddress("0x3d4Cc8A61c7528Fd86C55cfe061a78dCBA48EDd1"),
+		"ETH":  common.HexToAddress("0xb8901acB165ed027E32754E0FFe830802919727f"),
+		"WBTC": common.HexToAddress("0xb98454270065A31D71Bf635F6F7Ee6A518dFb849"),
+	},
+	5: {
+		"USDC": common.HexToAddress("0x7D269D3E0d61A05a0bA976b7DBF8805bF844AF3F"),
+		"ETH":  common.HexToAddress("0xC8A4FB931e8D77df8497790381CA7d228E68a41b"),
+	},
+}
+
+func L2SaddleSwapContractAddress(chainID uint64, symbol string) (common.Address, error) {
+	tokens, exists := l2SaddleSwapContractAddresses[chainID]
+	if !exists {
+		return *new(common.Address), errorNotAvailableOnChainID
+	}
+
+	addr, exists := tokens[symbol]
+	if !exists {
+		return *new(common.Address), errorNotAvailableOnChainID
+	}
+
+	return addr, nil
+}
+
+func L2AmmWrapperContractAddress(chainID uint64, symbol string) (common.Address, error) {
+	tokens, exists := l2AmmWrapperContractAddress[chainID]
+	if !exists {
+		return *new(common.Address), errorNotAvailableOnChainID
+	}
+
+	addr, exists := tokens[symbol]
+	if !exists {
+		return *new(common.Address), errorNotAvailableOnChainID
+	}
+
+	return addr, nil
+}
+
+func L1BridgeContractAddress(chainID uint64, symbol string) (common.Address, error) {
+	tokens, exists := l1BridgeContractAddress[chainID]
+	if !exists {
+		return *new(common.Address), errorNotAvailableOnChainID
+	}
+
+	addr, exists := tokens[symbol]
+	if !exists {
+		return *new(common.Address), errorNotAvailableOnChainID
+	}
+
+	return addr, nil
+}

vendor/github.com/status-im/status-go/contracts/hop/doc.go

@@ -0,0 +1,5 @@
+package hop
+
+//go:generate abigen --abi l2SaddleSwap.abi --pkg hopSwap --out swap/l2SaddleSwap.go
+//go:generate abigen --abi l1Bridge.abi --pkg hopBridge --out bridge/l1Bridge.go
+//go:generate abigen --abi l2AmmWrapper.abi --pkg hopWrapper --out wrapper/l2AmmWrapper.go

vendor/github.com/status-im/status-go/contracts/hop/l2AmmWrapper.abi

@@ -0,0 +1 @@
+[{"inputs":[{"internalType":"contract L2_Bridge","name":"_bridge","type":"address"},{"internalType":"contract IERC20","name":"_l2CanonicalToken","type":"address"},{"internalType":"bool","name":"_l2CanonicalTokenIsEth","type":"bool"},{"internalType":"contract IERC20","name":"_hToken","type":"address"},{"internalType":"contract Swap","name":"_exchangeAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"attemptSwap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"bridge","outputs":[{"internalType":"contract L2_Bridge","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"exchangeAddress","outputs":[{"internalType":"contract Swap","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l2CanonicalToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"l2CanonicalTokenIsEth","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"bonderFee","type":"uint256"},{"internalType":"uint256","name":"amountOutMin","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint256","name":"destinationAmountOutMin","type":"uint256"},{"internalType":"uint256","name":"destinationDeadline","type":"uint256"}],"name":"swapAndSend","outputs":[],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

vendor/github.com/status-im/status-go/contracts/hop/wrapper/l2AmmWrapper.go

@@ -0,0 +1,390 @@
+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package hopWrapper
+
+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
+)
+
+// HopWrapperABI is the input ABI used to generate the binding from.
+const HopWrapperABI = "[{\"inputs\":[{\"internalType\":\"contractL2_Bridge\",\"name\":\"_bridge\",\"type\":\"address\"},{\"internalType\":\"contractIERC20\",\"name\":\"_l2CanonicalToken\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"_l2CanonicalTokenIsEth\",\"type\":\"bool\"},{\"internalType\":\"contractIERC20\",\"name\":\"_hToken\",\"type\":\"address\"},{\"internalType\":\"contractSwap\",\"name\":\"_exchangeAddress\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMin\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"}],\"name\":\"attemptSwap\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"bridge\",\"outputs\":[{\"internalType\":\"contractL2_Bridge\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"exchangeAddress\",\"outputs\":[{\"internalType\":\"contractSwap\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"hToken\",\"outputs\":[{\"internalType\":\"contractIERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l2CanonicalToken\",\"outputs\":[{\"internalType\":\"contractIERC20\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l2CanonicalTokenIsEth\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"chainId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"bonderFee\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOutMin\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"deadline\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"destinationAmountOutMin\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"destinationDeadline\",\"type\":\"uint256\"}],\"name\":\"swapAndSend\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}]"
+
+// HopWrapper is an auto generated Go binding around an Ethereum contract.
+type HopWrapper struct {
+	HopWrapperCaller     // Read-only binding to the contract
+	HopWrapperTransactor // Write-only binding to the contract
+	HopWrapperFilterer   // Log filterer for contract events
+}
+
+// HopWrapperCaller is an auto generated read-only Go binding around an Ethereum contract.
+type HopWrapperCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// HopWrapperTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type HopWrapperTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// HopWrapperFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type HopWrapperFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// HopWrapperSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type HopWrapperSession struct {
+	Contract     *HopWrapper       // 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
+}
+
+// HopWrapperCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type HopWrapperCallerSession struct {
+	Contract *HopWrapperCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts     // Call options to use throughout this session
+}
+
+// HopWrapperTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type HopWrapperTransactorSession struct {
+	Contract     *HopWrapperTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts     // Transaction auth options to use throughout this session
+}
+
+// HopWrapperRaw is an auto generated low-level Go binding around an Ethereum contract.
+type HopWrapperRaw struct {
+	Contract *HopWrapper // Generic contract binding to access the raw methods on
+}
+
+// HopWrapperCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type HopWrapperCallerRaw struct {
+	Contract *HopWrapperCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// HopWrapperTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type HopWrapperTransactorRaw struct {
+	Contract *HopWrapperTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewHopWrapper creates a new instance of HopWrapper, bound to a specific deployed contract.
+func NewHopWrapper(address common.Address, backend bind.ContractBackend) (*HopWrapper, error) {
+	contract, err := bindHopWrapper(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &HopWrapper{HopWrapperCaller: HopWrapperCaller{contract: contract}, HopWrapperTransactor: HopWrapperTransactor{contract: contract}, HopWrapperFilterer: HopWrapperFilterer{contract: contract}}, nil
+}
+
+// NewHopWrapperCaller creates a new read-only instance of HopWrapper, bound to a specific deployed contract.
+func NewHopWrapperCaller(address common.Address, caller bind.ContractCaller) (*HopWrapperCaller, error) {
+	contract, err := bindHopWrapper(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &HopWrapperCaller{contract: contract}, nil
+}
+
+// NewHopWrapperTransactor creates a new write-only instance of HopWrapper, bound to a specific deployed contract.
+func NewHopWrapperTransactor(address common.Address, transactor bind.ContractTransactor) (*HopWrapperTransactor, error) {
+	contract, err := bindHopWrapper(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &HopWrapperTransactor{contract: contract}, nil
+}
+
+// NewHopWrapperFilterer creates a new log filterer instance of HopWrapper, bound to a specific deployed contract.
+func NewHopWrapperFilterer(address common.Address, filterer bind.ContractFilterer) (*HopWrapperFilterer, error) {
+	contract, err := bindHopWrapper(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &HopWrapperFilterer{contract: contract}, nil
+}
+
+// bindHopWrapper binds a generic wrapper to an already deployed contract.
+func bindHopWrapper(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := abi.JSON(strings.NewReader(HopWrapperABI))
+	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 (_HopWrapper *HopWrapperRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _HopWrapper.Contract.HopWrapperCaller.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 (_HopWrapper *HopWrapperRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _HopWrapper.Contract.HopWrapperTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_HopWrapper *HopWrapperRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _HopWrapper.Contract.HopWrapperTransactor.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 (_HopWrapper *HopWrapperCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _HopWrapper.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 (_HopWrapper *HopWrapperTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _HopWrapper.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_HopWrapper *HopWrapperTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _HopWrapper.Contract.contract.Transact(opts, method, params...)
+}
+
+// Bridge is a free data retrieval call binding the contract method 0xe78cea92.
+//
+// Solidity: function bridge() view returns(address)
+func (_HopWrapper *HopWrapperCaller) Bridge(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _HopWrapper.contract.Call(opts, &out, "bridge")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// Bridge is a free data retrieval call binding the contract method 0xe78cea92.
+//
+// Solidity: function bridge() view returns(address)
+func (_HopWrapper *HopWrapperSession) Bridge() (common.Address, error) {
+	return _HopWrapper.Contract.Bridge(&_HopWrapper.CallOpts)
+}
+
+// Bridge is a free data retrieval call binding the contract method 0xe78cea92.
+//
+// Solidity: function bridge() view returns(address)
+func (_HopWrapper *HopWrapperCallerSession) Bridge() (common.Address, error) {
+	return _HopWrapper.Contract.Bridge(&_HopWrapper.CallOpts)
+}
+
+// ExchangeAddress is a free data retrieval call binding the contract method 0x9cd01605.
+//
+// Solidity: function exchangeAddress() view returns(address)
+func (_HopWrapper *HopWrapperCaller) ExchangeAddress(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _HopWrapper.contract.Call(opts, &out, "exchangeAddress")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// ExchangeAddress is a free data retrieval call binding the contract method 0x9cd01605.
+//
+// Solidity: function exchangeAddress() view returns(address)
+func (_HopWrapper *HopWrapperSession) ExchangeAddress() (common.Address, error) {
+	return _HopWrapper.Contract.ExchangeAddress(&_HopWrapper.CallOpts)
+}
+
+// ExchangeAddress is a free data retrieval call binding the contract method 0x9cd01605.
+//
+// Solidity: function exchangeAddress() view returns(address)
+func (_HopWrapper *HopWrapperCallerSession) ExchangeAddress() (common.Address, error) {
+	return _HopWrapper.Contract.ExchangeAddress(&_HopWrapper.CallOpts)
+}
+
+// HToken is a free data retrieval call binding the contract method 0xfc6e3b3b.
+//
+// Solidity: function hToken() view returns(address)
+func (_HopWrapper *HopWrapperCaller) HToken(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _HopWrapper.contract.Call(opts, &out, "hToken")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// HToken is a free data retrieval call binding the contract method 0xfc6e3b3b.
+//
+// Solidity: function hToken() view returns(address)
+func (_HopWrapper *HopWrapperSession) HToken() (common.Address, error) {
+	return _HopWrapper.Contract.HToken(&_HopWrapper.CallOpts)
+}
+
+// HToken is a free data retrieval call binding the contract method 0xfc6e3b3b.
+//
+// Solidity: function hToken() view returns(address)
+func (_HopWrapper *HopWrapperCallerSession) HToken() (common.Address, error) {
+	return _HopWrapper.Contract.HToken(&_HopWrapper.CallOpts)
+}
+
+// L2CanonicalToken is a free data retrieval call binding the contract method 0x1ee1bf67.
+//
+// Solidity: function l2CanonicalToken() view returns(address)
+func (_HopWrapper *HopWrapperCaller) L2CanonicalToken(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _HopWrapper.contract.Call(opts, &out, "l2CanonicalToken")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// L2CanonicalToken is a free data retrieval call binding the contract method 0x1ee1bf67.
+//
+// Solidity: function l2CanonicalToken() view returns(address)
+func (_HopWrapper *HopWrapperSession) L2CanonicalToken() (common.Address, error) {
+	return _HopWrapper.Contract.L2CanonicalToken(&_HopWrapper.CallOpts)
+}
+
+// L2CanonicalToken is a free data retrieval call binding the contract method 0x1ee1bf67.
+//
+// Solidity: function l2CanonicalToken() view returns(address)
+func (_HopWrapper *HopWrapperCallerSession) L2CanonicalToken() (common.Address, error) {
+	return _HopWrapper.Contract.L2CanonicalToken(&_HopWrapper.CallOpts)
+}
+
+// L2CanonicalTokenIsEth is a free data retrieval call binding the contract method 0x28555125.
+//
+// Solidity: function l2CanonicalTokenIsEth() view returns(bool)
+func (_HopWrapper *HopWrapperCaller) L2CanonicalTokenIsEth(opts *bind.CallOpts) (bool, error) {
+	var out []interface{}
+	err := _HopWrapper.contract.Call(opts, &out, "l2CanonicalTokenIsEth")
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// L2CanonicalTokenIsEth is a free data retrieval call binding the contract method 0x28555125.
+//
+// Solidity: function l2CanonicalTokenIsEth() view returns(bool)
+func (_HopWrapper *HopWrapperSession) L2CanonicalTokenIsEth() (bool, error) {
+	return _HopWrapper.Contract.L2CanonicalTokenIsEth(&_HopWrapper.CallOpts)
+}
+
+// L2CanonicalTokenIsEth is a free data retrieval call binding the contract method 0x28555125.
+//
+// Solidity: function l2CanonicalTokenIsEth() view returns(bool)
+func (_HopWrapper *HopWrapperCallerSession) L2CanonicalTokenIsEth() (bool, error) {
+	return _HopWrapper.Contract.L2CanonicalTokenIsEth(&_HopWrapper.CallOpts)
+}
+
+// AttemptSwap is a paid mutator transaction binding the contract method 0x676c5ef6.
+//
+// Solidity: function attemptSwap(address recipient, uint256 amount, uint256 amountOutMin, uint256 deadline) returns()
+func (_HopWrapper *HopWrapperTransactor) AttemptSwap(opts *bind.TransactOpts, recipient common.Address, amount *big.Int, amountOutMin *big.Int, deadline *big.Int) (*types.Transaction, error) {
+	return _HopWrapper.contract.Transact(opts, "attemptSwap", recipient, amount, amountOutMin, deadline)
+}
+
+// AttemptSwap is a paid mutator transaction binding the contract method 0x676c5ef6.
+//
+// Solidity: function attemptSwap(address recipient, uint256 amount, uint256 amountOutMin, uint256 deadline) returns()
+func (_HopWrapper *HopWrapperSession) AttemptSwap(recipient common.Address, amount *big.Int, amountOutMin *big.Int, deadline *big.Int) (*types.Transaction, error) {
+	return _HopWrapper.Contract.AttemptSwap(&_HopWrapper.TransactOpts, recipient, amount, amountOutMin, deadline)
+}
+
+// AttemptSwap is a paid mutator transaction binding the contract method 0x676c5ef6.
+//
+// Solidity: function attemptSwap(address recipient, uint256 amount, uint256 amountOutMin, uint256 deadline) returns()
+func (_HopWrapper *HopWrapperTransactorSession) AttemptSwap(recipient common.Address, amount *big.Int, amountOutMin *big.Int, deadline *big.Int) (*types.Transaction, error) {
+	return _HopWrapper.Contract.AttemptSwap(&_HopWrapper.TransactOpts, recipient, amount, amountOutMin, deadline)
+}
+
+// SwapAndSend is a paid mutator transaction binding the contract method 0xeea0d7b2.
+//
+// Solidity: function swapAndSend(uint256 chainId, address recipient, uint256 amount, uint256 bonderFee, uint256 amountOutMin, uint256 deadline, uint256 destinationAmountOutMin, uint256 destinationDeadline) payable returns()
+func (_HopWrapper *HopWrapperTransactor) SwapAndSend(opts *bind.TransactOpts, chainId *big.Int, recipient common.Address, amount *big.Int, bonderFee *big.Int, amountOutMin *big.Int, deadline *big.Int, destinationAmountOutMin *big.Int, destinationDeadline *big.Int) (*types.Transaction, error) {
+	return _HopWrapper.contract.Transact(opts, "swapAndSend", chainId, recipient, amount, bonderFee, amountOutMin, deadline, destinationAmountOutMin, destinationDeadline)
+}
+
+// SwapAndSend is a paid mutator transaction binding the contract method 0xeea0d7b2.
+//
+// Solidity: function swapAndSend(uint256 chainId, address recipient, uint256 amount, uint256 bonderFee, uint256 amountOutMin, uint256 deadline, uint256 destinationAmountOutMin, uint256 destinationDeadline) payable returns()
+func (_HopWrapper *HopWrapperSession) SwapAndSend(chainId *big.Int, recipient common.Address, amount *big.Int, bonderFee *big.Int, amountOutMin *big.Int, deadline *big.Int, destinationAmountOutMin *big.Int, destinationDeadline *big.Int) (*types.Transaction, error) {
+	return _HopWrapper.Contract.SwapAndSend(&_HopWrapper.TransactOpts, chainId, recipient, amount, bonderFee, amountOutMin, deadline, destinationAmountOutMin, destinationDeadline)
+}
+
+// SwapAndSend is a paid mutator transaction binding the contract method 0xeea0d7b2.
+//
+// Solidity: function swapAndSend(uint256 chainId, address recipient, uint256 amount, uint256 bonderFee, uint256 amountOutMin, uint256 deadline, uint256 destinationAmountOutMin, uint256 destinationDeadline) payable returns()
+func (_HopWrapper *HopWrapperTransactorSession) SwapAndSend(chainId *big.Int, recipient common.Address, amount *big.Int, bonderFee *big.Int, amountOutMin *big.Int, deadline *big.Int, destinationAmountOutMin *big.Int, destinationDeadline *big.Int) (*types.Transaction, error) {
+	return _HopWrapper.Contract.SwapAndSend(&_HopWrapper.TransactOpts, chainId, recipient, amount, bonderFee, amountOutMin, deadline, destinationAmountOutMin, destinationDeadline)
+}
+
+// Receive is a paid mutator transaction binding the contract receive function.
+//
+// Solidity: receive() payable returns()
+func (_HopWrapper *HopWrapperTransactor) Receive(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _HopWrapper.contract.RawTransact(opts, nil) // calldata is disallowed for receive function
+}
+
+// Receive is a paid mutator transaction binding the contract receive function.
+//
+// Solidity: receive() payable returns()
+func (_HopWrapper *HopWrapperSession) Receive() (*types.Transaction, error) {
+	return _HopWrapper.Contract.Receive(&_HopWrapper.TransactOpts)
+}
+
+// Receive is a paid mutator transaction binding the contract receive function.
+//
+// Solidity: receive() payable returns()
+func (_HopWrapper *HopWrapperTransactorSession) Receive() (*types.Transaction, error) {
+	return _HopWrapper.Contract.Receive(&_HopWrapper.TransactOpts)
+}

vendor/github.com/status-im/status-go/contracts/ierc1155/ERC1155.abi

@@ -0,0 +1 @@
+[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_owner","type":"address"},{"indexed":true,"internalType":"address","name":"_operator","type":"address"},{"indexed":false,"internalType":"bool","name":"_approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_operator","type":"address"},{"indexed":true,"internalType":"address","name":"_from","type":"address"},{"indexed":true,"internalType":"address","name":"_to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"_ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"_values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_operator","type":"address"},{"indexed":true,"internalType":"address","name":"_from","type":"address"},{"indexed":true,"internalType":"address","name":"_to","type":"address"},{"indexed":false,"internalType":"uint256","name":"_id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"_value","type":"string"},{"indexed":true,"internalType":"uint256","name":"_id","type":"uint256"}],"name":"URI","type":"event"},{"constant":true,"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address[]","name":"_owners","type":"address[]"},{"internalType":"uint256[]","name":"_ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256[]","name":"_ids","type":"uint256[]"},{"internalType":"uint256[]","name":"_values","type":"uint256[]"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_id","type":"uint256"},{"internalType":"uint256","name":"_value","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"_operator","type":"address"},{"internalType":"bool","name":"_approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

vendor/github.com/status-im/status-go/contracts/ierc1155/doc.go

@@ -0,0 +1,3 @@
+package ierc1155
+
+//go:generate abigen -abi ./ERC1155.abi -pkg ierc1155 -out ierc1155.go

vendor/github.com/status-im/status-go/contracts/ierc1155/ierc1155.go

@@ -0,0 +1,964 @@
+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package ierc1155
+
+import (
+	"errors"
+	"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 (
+	_ = errors.New
+	_ = big.NewInt
+	_ = strings.NewReader
+	_ = ethereum.NotFound
+	_ = bind.Bind
+	_ = common.Big1
+	_ = types.BloomLookup
+	_ = event.NewSubscription
+	_ = abi.ConvertType
+)
+
+// Ierc1155MetaData contains all meta data concerning the Ierc1155 contract.
+var Ierc1155MetaData = &bind.MetaData{
+	ABI: "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"_approved\",\"type\":\"bool\"}],\"name\":\"ApprovalForAll\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"_ids\",\"type\":\"uint256[]\"},{\"indexed\":false,\"internalType\":\"uint256[]\",\"name\":\"_values\",\"type\":\"uint256[]\"}],\"name\":\"TransferBatch\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_id\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"TransferSingle\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"string\",\"name\":\"_value\",\"type\":\"string\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"_id\",\"type\":\"uint256\"}],\"name\":\"URI\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_id\",\"type\":\"uint256\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_owners\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"_ids\",\"type\":\"uint256[]\"}],\"name\":\"balanceOfBatch\",\"outputs\":[{\"internalType\":\"uint256[]\",\"name\":\"\",\"type\":\"uint256[]\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"}],\"name\":\"isApprovedForAll\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256[]\",\"name\":\"_ids\",\"type\":\"uint256[]\"},{\"internalType\":\"uint256[]\",\"name\":\"_values\",\"type\":\"uint256[]\"},{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"safeBatchTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_id\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"name\":\"safeTransferFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_operator\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"_approved\",\"type\":\"bool\"}],\"name\":\"setApprovalForAll\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
+}
+
+// Ierc1155ABI is the input ABI used to generate the binding from.
+// Deprecated: Use Ierc1155MetaData.ABI instead.
+var Ierc1155ABI = Ierc1155MetaData.ABI
+
+// Ierc1155 is an auto generated Go binding around an Ethereum contract.
+type Ierc1155 struct {
+	Ierc1155Caller     // Read-only binding to the contract
+	Ierc1155Transactor // Write-only binding to the contract
+	Ierc1155Filterer   // Log filterer for contract events
+}
+
+// Ierc1155Caller is an auto generated read-only Go binding around an Ethereum contract.
+type Ierc1155Caller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// Ierc1155Transactor is an auto generated write-only Go binding around an Ethereum contract.
+type Ierc1155Transactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// Ierc1155Filterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type Ierc1155Filterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// Ierc1155Session is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type Ierc1155Session struct {
+	Contract     *Ierc1155         // 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
+}
+
+// Ierc1155CallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type Ierc1155CallerSession struct {
+	Contract *Ierc1155Caller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts   // Call options to use throughout this session
+}
+
+// Ierc1155TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type Ierc1155TransactorSession struct {
+	Contract     *Ierc1155Transactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts   // Transaction auth options to use throughout this session
+}
+
+// Ierc1155Raw is an auto generated low-level Go binding around an Ethereum contract.
+type Ierc1155Raw struct {
+	Contract *Ierc1155 // Generic contract binding to access the raw methods on
+}
+
+// Ierc1155CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type Ierc1155CallerRaw struct {
+	Contract *Ierc1155Caller // Generic read-only contract binding to access the raw methods on
+}
+
+// Ierc1155TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type Ierc1155TransactorRaw struct {
+	Contract *Ierc1155Transactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewIerc1155 creates a new instance of Ierc1155, bound to a specific deployed contract.
+func NewIerc1155(address common.Address, backend bind.ContractBackend) (*Ierc1155, error) {
+	contract, err := bindIerc1155(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &Ierc1155{Ierc1155Caller: Ierc1155Caller{contract: contract}, Ierc1155Transactor: Ierc1155Transactor{contract: contract}, Ierc1155Filterer: Ierc1155Filterer{contract: contract}}, nil
+}
+
+// NewIerc1155Caller creates a new read-only instance of Ierc1155, bound to a specific deployed contract.
+func NewIerc1155Caller(address common.Address, caller bind.ContractCaller) (*Ierc1155Caller, error) {
+	contract, err := bindIerc1155(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &Ierc1155Caller{contract: contract}, nil
+}
+
+// NewIerc1155Transactor creates a new write-only instance of Ierc1155, bound to a specific deployed contract.
+func NewIerc1155Transactor(address common.Address, transactor bind.ContractTransactor) (*Ierc1155Transactor, error) {
+	contract, err := bindIerc1155(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &Ierc1155Transactor{contract: contract}, nil
+}
+
+// NewIerc1155Filterer creates a new log filterer instance of Ierc1155, bound to a specific deployed contract.
+func NewIerc1155Filterer(address common.Address, filterer bind.ContractFilterer) (*Ierc1155Filterer, error) {
+	contract, err := bindIerc1155(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &Ierc1155Filterer{contract: contract}, nil
+}
+
+// bindIerc1155 binds a generic wrapper to an already deployed contract.
+func bindIerc1155(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := Ierc1155MetaData.GetAbi()
+	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 (_Ierc1155 *Ierc1155Raw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Ierc1155.Contract.Ierc1155Caller.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 (_Ierc1155 *Ierc1155Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Ierc1155.Contract.Ierc1155Transactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Ierc1155 *Ierc1155Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Ierc1155.Contract.Ierc1155Transactor.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 (_Ierc1155 *Ierc1155CallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _Ierc1155.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 (_Ierc1155 *Ierc1155TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _Ierc1155.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_Ierc1155 *Ierc1155TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _Ierc1155.Contract.contract.Transact(opts, method, params...)
+}
+
+// BalanceOf is a free data retrieval call binding the contract method 0x00fdd58e.
+//
+// Solidity: function balanceOf(address _owner, uint256 _id) view returns(uint256)
+func (_Ierc1155 *Ierc1155Caller) BalanceOf(opts *bind.CallOpts, _owner common.Address, _id *big.Int) (*big.Int, error) {
+	var out []interface{}
+	err := _Ierc1155.contract.Call(opts, &out, "balanceOf", _owner, _id)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// BalanceOf is a free data retrieval call binding the contract method 0x00fdd58e.
+//
+// Solidity: function balanceOf(address _owner, uint256 _id) view returns(uint256)
+func (_Ierc1155 *Ierc1155Session) BalanceOf(_owner common.Address, _id *big.Int) (*big.Int, error) {
+	return _Ierc1155.Contract.BalanceOf(&_Ierc1155.CallOpts, _owner, _id)
+}
+
+// BalanceOf is a free data retrieval call binding the contract method 0x00fdd58e.
+//
+// Solidity: function balanceOf(address _owner, uint256 _id) view returns(uint256)
+func (_Ierc1155 *Ierc1155CallerSession) BalanceOf(_owner common.Address, _id *big.Int) (*big.Int, error) {
+	return _Ierc1155.Contract.BalanceOf(&_Ierc1155.CallOpts, _owner, _id)
+}
+
+// BalanceOfBatch is a free data retrieval call binding the contract method 0x4e1273f4.
+//
+// Solidity: function balanceOfBatch(address[] _owners, uint256[] _ids) view returns(uint256[])
+func (_Ierc1155 *Ierc1155Caller) BalanceOfBatch(opts *bind.CallOpts, _owners []common.Address, _ids []*big.Int) ([]*big.Int, error) {
+	var out []interface{}
+	err := _Ierc1155.contract.Call(opts, &out, "balanceOfBatch", _owners, _ids)
+
+	if err != nil {
+		return *new([]*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int)
+
+	return out0, err
+
+}
+
+// BalanceOfBatch is a free data retrieval call binding the contract method 0x4e1273f4.
+//
+// Solidity: function balanceOfBatch(address[] _owners, uint256[] _ids) view returns(uint256[])
+func (_Ierc1155 *Ierc1155Session) BalanceOfBatch(_owners []common.Address, _ids []*big.Int) ([]*big.Int, error) {
+	return _Ierc1155.Contract.BalanceOfBatch(&_Ierc1155.CallOpts, _owners, _ids)
+}
+
+// BalanceOfBatch is a free data retrieval call binding the contract method 0x4e1273f4.
+//
+// Solidity: function balanceOfBatch(address[] _owners, uint256[] _ids) view returns(uint256[])
+func (_Ierc1155 *Ierc1155CallerSession) BalanceOfBatch(_owners []common.Address, _ids []*big.Int) ([]*big.Int, error) {
+	return _Ierc1155.Contract.BalanceOfBatch(&_Ierc1155.CallOpts, _owners, _ids)
+}
+
+// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
+//
+// Solidity: function isApprovedForAll(address _owner, address _operator) view returns(bool)
+func (_Ierc1155 *Ierc1155Caller) IsApprovedForAll(opts *bind.CallOpts, _owner common.Address, _operator common.Address) (bool, error) {
+	var out []interface{}
+	err := _Ierc1155.contract.Call(opts, &out, "isApprovedForAll", _owner, _operator)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
+//
+// Solidity: function isApprovedForAll(address _owner, address _operator) view returns(bool)
+func (_Ierc1155 *Ierc1155Session) IsApprovedForAll(_owner common.Address, _operator common.Address) (bool, error) {
+	return _Ierc1155.Contract.IsApprovedForAll(&_Ierc1155.CallOpts, _owner, _operator)
+}
+
+// IsApprovedForAll is a free data retrieval call binding the contract method 0xe985e9c5.
+//
+// Solidity: function isApprovedForAll(address _owner, address _operator) view returns(bool)
+func (_Ierc1155 *Ierc1155CallerSession) IsApprovedForAll(_owner common.Address, _operator common.Address) (bool, error) {
+	return _Ierc1155.Contract.IsApprovedForAll(&_Ierc1155.CallOpts, _owner, _operator)
+}
+
+// SafeBatchTransferFrom is a paid mutator transaction binding the contract method 0x2eb2c2d6.
+//
+// Solidity: function safeBatchTransferFrom(address _from, address _to, uint256[] _ids, uint256[] _values, bytes _data) returns()
+func (_Ierc1155 *Ierc1155Transactor) SafeBatchTransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _ids []*big.Int, _values []*big.Int, _data []byte) (*types.Transaction, error) {
+	return _Ierc1155.contract.Transact(opts, "safeBatchTransferFrom", _from, _to, _ids, _values, _data)
+}
+
+// SafeBatchTransferFrom is a paid mutator transaction binding the contract method 0x2eb2c2d6.
+//
+// Solidity: function safeBatchTransferFrom(address _from, address _to, uint256[] _ids, uint256[] _values, bytes _data) returns()
+func (_Ierc1155 *Ierc1155Session) SafeBatchTransferFrom(_from common.Address, _to common.Address, _ids []*big.Int, _values []*big.Int, _data []byte) (*types.Transaction, error) {
+	return _Ierc1155.Contract.SafeBatchTransferFrom(&_Ierc1155.TransactOpts, _from, _to, _ids, _values, _data)
+}
+
+// SafeBatchTransferFrom is a paid mutator transaction binding the contract method 0x2eb2c2d6.
+//
+// Solidity: function safeBatchTransferFrom(address _from, address _to, uint256[] _ids, uint256[] _values, bytes _data) returns()
+func (_Ierc1155 *Ierc1155TransactorSession) SafeBatchTransferFrom(_from common.Address, _to common.Address, _ids []*big.Int, _values []*big.Int, _data []byte) (*types.Transaction, error) {
+	return _Ierc1155.Contract.SafeBatchTransferFrom(&_Ierc1155.TransactOpts, _from, _to, _ids, _values, _data)
+}
+
+// SafeTransferFrom is a paid mutator transaction binding the contract method 0xf242432a.
+//
+// Solidity: function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes _data) returns()
+func (_Ierc1155 *Ierc1155Transactor) SafeTransferFrom(opts *bind.TransactOpts, _from common.Address, _to common.Address, _id *big.Int, _value *big.Int, _data []byte) (*types.Transaction, error) {
+	return _Ierc1155.contract.Transact(opts, "safeTransferFrom", _from, _to, _id, _value, _data)
+}
+
+// SafeTransferFrom is a paid mutator transaction binding the contract method 0xf242432a.
+//
+// Solidity: function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes _data) returns()
+func (_Ierc1155 *Ierc1155Session) SafeTransferFrom(_from common.Address, _to common.Address, _id *big.Int, _value *big.Int, _data []byte) (*types.Transaction, error) {
+	return _Ierc1155.Contract.SafeTransferFrom(&_Ierc1155.TransactOpts, _from, _to, _id, _value, _data)
+}
+
+// SafeTransferFrom is a paid mutator transaction binding the contract method 0xf242432a.
+//
+// Solidity: function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes _data) returns()
+func (_Ierc1155 *Ierc1155TransactorSession) SafeTransferFrom(_from common.Address, _to common.Address, _id *big.Int, _value *big.Int, _data []byte) (*types.Transaction, error) {
+	return _Ierc1155.Contract.SafeTransferFrom(&_Ierc1155.TransactOpts, _from, _to, _id, _value, _data)
+}
+
+// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
+//
+// Solidity: function setApprovalForAll(address _operator, bool _approved) returns()
+func (_Ierc1155 *Ierc1155Transactor) SetApprovalForAll(opts *bind.TransactOpts, _operator common.Address, _approved bool) (*types.Transaction, error) {
+	return _Ierc1155.contract.Transact(opts, "setApprovalForAll", _operator, _approved)
+}
+
+// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
+//
+// Solidity: function setApprovalForAll(address _operator, bool _approved) returns()
+func (_Ierc1155 *Ierc1155Session) SetApprovalForAll(_operator common.Address, _approved bool) (*types.Transaction, error) {
+	return _Ierc1155.Contract.SetApprovalForAll(&_Ierc1155.TransactOpts, _operator, _approved)
+}
+
+// SetApprovalForAll is a paid mutator transaction binding the contract method 0xa22cb465.
+//
+// Solidity: function setApprovalForAll(address _operator, bool _approved) returns()
+func (_Ierc1155 *Ierc1155TransactorSession) SetApprovalForAll(_operator common.Address, _approved bool) (*types.Transaction, error) {
+	return _Ierc1155.Contract.SetApprovalForAll(&_Ierc1155.TransactOpts, _operator, _approved)
+}
+
+// Ierc1155ApprovalForAllIterator is returned from FilterApprovalForAll and is used to iterate over the raw logs and unpacked data for ApprovalForAll events raised by the Ierc1155 contract.
+type Ierc1155ApprovalForAllIterator struct {
+	Event *Ierc1155ApprovalForAll // 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 *Ierc1155ApprovalForAllIterator) 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(Ierc1155ApprovalForAll)
+			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(Ierc1155ApprovalForAll)
+		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 *Ierc1155ApprovalForAllIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *Ierc1155ApprovalForAllIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// Ierc1155ApprovalForAll represents a ApprovalForAll event raised by the Ierc1155 contract.
+type Ierc1155ApprovalForAll struct {
+	Owner    common.Address
+	Operator common.Address
+	Approved bool
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterApprovalForAll is a free log retrieval operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
+//
+// Solidity: event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved)
+func (_Ierc1155 *Ierc1155Filterer) FilterApprovalForAll(opts *bind.FilterOpts, _owner []common.Address, _operator []common.Address) (*Ierc1155ApprovalForAllIterator, error) {
+
+	var _ownerRule []interface{}
+	for _, _ownerItem := range _owner {
+		_ownerRule = append(_ownerRule, _ownerItem)
+	}
+	var _operatorRule []interface{}
+	for _, _operatorItem := range _operator {
+		_operatorRule = append(_operatorRule, _operatorItem)
+	}
+
+	logs, sub, err := _Ierc1155.contract.FilterLogs(opts, "ApprovalForAll", _ownerRule, _operatorRule)
+	if err != nil {
+		return nil, err
+	}
+	return &Ierc1155ApprovalForAllIterator{contract: _Ierc1155.contract, event: "ApprovalForAll", logs: logs, sub: sub}, nil
+}
+
+// WatchApprovalForAll is a free log subscription operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
+//
+// Solidity: event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved)
+func (_Ierc1155 *Ierc1155Filterer) WatchApprovalForAll(opts *bind.WatchOpts, sink chan<- *Ierc1155ApprovalForAll, _owner []common.Address, _operator []common.Address) (event.Subscription, error) {
+
+	var _ownerRule []interface{}
+	for _, _ownerItem := range _owner {
+		_ownerRule = append(_ownerRule, _ownerItem)
+	}
+	var _operatorRule []interface{}
+	for _, _operatorItem := range _operator {
+		_operatorRule = append(_operatorRule, _operatorItem)
+	}
+
+	logs, sub, err := _Ierc1155.contract.WatchLogs(opts, "ApprovalForAll", _ownerRule, _operatorRule)
+	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(Ierc1155ApprovalForAll)
+				if err := _Ierc1155.contract.UnpackLog(event, "ApprovalForAll", 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
+}
+
+// ParseApprovalForAll is a log parse operation binding the contract event 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31.
+//
+// Solidity: event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved)
+func (_Ierc1155 *Ierc1155Filterer) ParseApprovalForAll(log types.Log) (*Ierc1155ApprovalForAll, error) {
+	event := new(Ierc1155ApprovalForAll)
+	if err := _Ierc1155.contract.UnpackLog(event, "ApprovalForAll", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// Ierc1155TransferBatchIterator is returned from FilterTransferBatch and is used to iterate over the raw logs and unpacked data for TransferBatch events raised by the Ierc1155 contract.
+type Ierc1155TransferBatchIterator struct {
+	Event *Ierc1155TransferBatch // 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 *Ierc1155TransferBatchIterator) 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(Ierc1155TransferBatch)
+			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(Ierc1155TransferBatch)
+		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 *Ierc1155TransferBatchIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *Ierc1155TransferBatchIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// Ierc1155TransferBatch represents a TransferBatch event raised by the Ierc1155 contract.
+type Ierc1155TransferBatch struct {
+	Operator common.Address
+	From     common.Address
+	To       common.Address
+	Ids      []*big.Int
+	Values   []*big.Int
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterTransferBatch is a free log retrieval operation binding the contract event 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb.
+//
+// Solidity: event TransferBatch(address indexed _operator, address indexed _from, address indexed _to, uint256[] _ids, uint256[] _values)
+func (_Ierc1155 *Ierc1155Filterer) FilterTransferBatch(opts *bind.FilterOpts, _operator []common.Address, _from []common.Address, _to []common.Address) (*Ierc1155TransferBatchIterator, error) {
+
+	var _operatorRule []interface{}
+	for _, _operatorItem := range _operator {
+		_operatorRule = append(_operatorRule, _operatorItem)
+	}
+	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 := _Ierc1155.contract.FilterLogs(opts, "TransferBatch", _operatorRule, _fromRule, _toRule)
+	if err != nil {
+		return nil, err
+	}
+	return &Ierc1155TransferBatchIterator{contract: _Ierc1155.contract, event: "TransferBatch", logs: logs, sub: sub}, nil
+}
+
+// WatchTransferBatch is a free log subscription operation binding the contract event 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb.
+//
+// Solidity: event TransferBatch(address indexed _operator, address indexed _from, address indexed _to, uint256[] _ids, uint256[] _values)
+func (_Ierc1155 *Ierc1155Filterer) WatchTransferBatch(opts *bind.WatchOpts, sink chan<- *Ierc1155TransferBatch, _operator []common.Address, _from []common.Address, _to []common.Address) (event.Subscription, error) {
+
+	var _operatorRule []interface{}
+	for _, _operatorItem := range _operator {
+		_operatorRule = append(_operatorRule, _operatorItem)
+	}
+	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 := _Ierc1155.contract.WatchLogs(opts, "TransferBatch", _operatorRule, _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(Ierc1155TransferBatch)
+				if err := _Ierc1155.contract.UnpackLog(event, "TransferBatch", 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
+}
+
+// ParseTransferBatch is a log parse operation binding the contract event 0x4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb.
+//
+// Solidity: event TransferBatch(address indexed _operator, address indexed _from, address indexed _to, uint256[] _ids, uint256[] _values)
+func (_Ierc1155 *Ierc1155Filterer) ParseTransferBatch(log types.Log) (*Ierc1155TransferBatch, error) {
+	event := new(Ierc1155TransferBatch)
+	if err := _Ierc1155.contract.UnpackLog(event, "TransferBatch", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// Ierc1155TransferSingleIterator is returned from FilterTransferSingle and is used to iterate over the raw logs and unpacked data for TransferSingle events raised by the Ierc1155 contract.
+type Ierc1155TransferSingleIterator struct {
+	Event *Ierc1155TransferSingle // 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 *Ierc1155TransferSingleIterator) 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(Ierc1155TransferSingle)
+			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(Ierc1155TransferSingle)
+		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 *Ierc1155TransferSingleIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *Ierc1155TransferSingleIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// Ierc1155TransferSingle represents a TransferSingle event raised by the Ierc1155 contract.
+type Ierc1155TransferSingle struct {
+	Operator common.Address
+	From     common.Address
+	To       common.Address
+	Id       *big.Int
+	Value    *big.Int
+	Raw      types.Log // Blockchain specific contextual infos
+}
+
+// FilterTransferSingle is a free log retrieval operation binding the contract event 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62.
+//
+// Solidity: event TransferSingle(address indexed _operator, address indexed _from, address indexed _to, uint256 _id, uint256 _value)
+func (_Ierc1155 *Ierc1155Filterer) FilterTransferSingle(opts *bind.FilterOpts, _operator []common.Address, _from []common.Address, _to []common.Address) (*Ierc1155TransferSingleIterator, error) {
+
+	var _operatorRule []interface{}
+	for _, _operatorItem := range _operator {
+		_operatorRule = append(_operatorRule, _operatorItem)
+	}
+	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 := _Ierc1155.contract.FilterLogs(opts, "TransferSingle", _operatorRule, _fromRule, _toRule)
+	if err != nil {
+		return nil, err
+	}
+	return &Ierc1155TransferSingleIterator{contract: _Ierc1155.contract, event: "TransferSingle", logs: logs, sub: sub}, nil
+}
+
+// WatchTransferSingle is a free log subscription operation binding the contract event 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62.
+//
+// Solidity: event TransferSingle(address indexed _operator, address indexed _from, address indexed _to, uint256 _id, uint256 _value)
+func (_Ierc1155 *Ierc1155Filterer) WatchTransferSingle(opts *bind.WatchOpts, sink chan<- *Ierc1155TransferSingle, _operator []common.Address, _from []common.Address, _to []common.Address) (event.Subscription, error) {
+
+	var _operatorRule []interface{}
+	for _, _operatorItem := range _operator {
+		_operatorRule = append(_operatorRule, _operatorItem)
+	}
+	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 := _Ierc1155.contract.WatchLogs(opts, "TransferSingle", _operatorRule, _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(Ierc1155TransferSingle)
+				if err := _Ierc1155.contract.UnpackLog(event, "TransferSingle", 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
+}
+
+// ParseTransferSingle is a log parse operation binding the contract event 0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62.
+//
+// Solidity: event TransferSingle(address indexed _operator, address indexed _from, address indexed _to, uint256 _id, uint256 _value)
+func (_Ierc1155 *Ierc1155Filterer) ParseTransferSingle(log types.Log) (*Ierc1155TransferSingle, error) {
+	event := new(Ierc1155TransferSingle)
+	if err := _Ierc1155.contract.UnpackLog(event, "TransferSingle", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// Ierc1155URIIterator is returned from FilterURI and is used to iterate over the raw logs and unpacked data for URI events raised by the Ierc1155 contract.
+type Ierc1155URIIterator struct {
+	Event *Ierc1155URI // 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 *Ierc1155URIIterator) 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(Ierc1155URI)
+			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(Ierc1155URI)
+		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 *Ierc1155URIIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *Ierc1155URIIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// Ierc1155URI represents a URI event raised by the Ierc1155 contract.
+type Ierc1155URI struct {
+	Value string
+	Id    *big.Int
+	Raw   types.Log // Blockchain specific contextual infos
+}
+
+// FilterURI is a free log retrieval operation binding the contract event 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b.
+//
+// Solidity: event URI(string _value, uint256 indexed _id)
+func (_Ierc1155 *Ierc1155Filterer) FilterURI(opts *bind.FilterOpts, _id []*big.Int) (*Ierc1155URIIterator, error) {
+
+	var _idRule []interface{}
+	for _, _idItem := range _id {
+		_idRule = append(_idRule, _idItem)
+	}
+
+	logs, sub, err := _Ierc1155.contract.FilterLogs(opts, "URI", _idRule)
+	if err != nil {
+		return nil, err
+	}
+	return &Ierc1155URIIterator{contract: _Ierc1155.contract, event: "URI", logs: logs, sub: sub}, nil
+}
+
+// WatchURI is a free log subscription operation binding the contract event 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b.
+//
+// Solidity: event URI(string _value, uint256 indexed _id)
+func (_Ierc1155 *Ierc1155Filterer) WatchURI(opts *bind.WatchOpts, sink chan<- *Ierc1155URI, _id []*big.Int) (event.Subscription, error) {
+
+	var _idRule []interface{}
+	for _, _idItem := range _id {
+		_idRule = append(_idRule, _idItem)
+	}
+
+	logs, sub, err := _Ierc1155.contract.WatchLogs(opts, "URI", _idRule)
+	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(Ierc1155URI)
+				if err := _Ierc1155.contract.UnpackLog(event, "URI", 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
+}
+
+// ParseURI is a log parse operation binding the contract event 0x6bb7ff708619ba0610cba295a58592e0451dee2622938c8755667688daf3529b.
+//
+// Solidity: event URI(string _value, uint256 indexed _id)
+func (_Ierc1155 *Ierc1155Filterer) ParseURI(log types.Log) (*Ierc1155URI, error) {
+	event := new(Ierc1155URI)
+	if err := _Ierc1155.contract.UnpackLog(event, "URI", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}

vendor/github.com/status-im/status-go/contracts/ierc1155/ierc1155.sol

@@ -0,0 +1,147 @@
+pragma solidity ^0.5.16;
+
+/**
+    @title ERC-1155 Multi Token Standard
+    @dev See https://eips.ethereum.org/EIPS/eip-1155
+    Note: The ERC-165 identifier for this interface is 0xd9b67a26.
+ */
+/* is ERC165 */ interface ERC1155 {
+    /**
+        @dev Either `TransferSingle` or `TransferBatch` MUST emit when tokens are transferred, including zero value transfers as well as minting or burning (see "Safe Transfer Rules" section of the standard).
+        The `_operator` argument MUST be the address of an account/contract that is approved to make the transfer (SHOULD be msg.sender).
+        The `_from` argument MUST be the address of the holder whose balance is decreased.
+        The `_to` argument MUST be the address of the recipient whose balance is increased.
+        The `_id` argument MUST be the token type being transferred.
+        The `_value` argument MUST be the number of tokens the holder balance is decreased by and match what the recipient balance is increased by.
+        When minting/creating tokens, the `_from` argument MUST be set to `0x0` (i.e. zero address).
+        When burning/destroying tokens, the `_to` argument MUST be set to `0x0` (i.e. zero address).        
+    */
+    event TransferSingle(
+        address indexed _operator,
+        address indexed _from,
+        address indexed _to,
+        uint256 _id,
+        uint256 _value
+    );
+
+    /**
+        @dev Either `TransferSingle` or `TransferBatch` MUST emit when tokens are transferred, including zero value transfers as well as minting or burning (see "Safe Transfer Rules" section of the standard).      
+        The `_operator` argument MUST be the address of an account/contract that is approved to make the transfer (SHOULD be msg.sender).
+        The `_from` argument MUST be the address of the holder whose balance is decreased.
+        The `_to` argument MUST be the address of the recipient whose balance is increased.
+        The `_ids` argument MUST be the list of tokens being transferred.
+        The `_values` argument MUST be the list of number of tokens (matching the list and order of tokens specified in _ids) the holder balance is decreased by and match what the recipient balance is increased by.
+        When minting/creating tokens, the `_from` argument MUST be set to `0x0` (i.e. zero address).
+        When burning/destroying tokens, the `_to` argument MUST be set to `0x0` (i.e. zero address).                
+    */
+    event TransferBatch(
+        address indexed _operator,
+        address indexed _from,
+        address indexed _to,
+        uint256[] _ids,
+        uint256[] _values
+    );
+
+    /**
+        @dev MUST emit when approval for a second party/operator address to manage all tokens for an owner address is enabled or disabled (absence of an event assumes disabled).        
+    */
+    event ApprovalForAll(
+        address indexed _owner,
+        address indexed _operator,
+        bool _approved
+    );
+
+    /**
+        @dev MUST emit when the URI is updated for a token ID.
+        URIs are defined in RFC 3986.
+        The URI MUST point to a JSON file that conforms to the "ERC-1155 Metadata URI JSON Schema".
+    */
+    event URI(string _value, uint256 indexed _id);
+
+    /**
+        @notice Transfers `_value` amount of an `_id` from the `_from` address to the `_to` address specified (with safety call).
+        @dev Caller must be approved to manage the tokens being transferred out of the `_from` account (see "Approval" section of the standard).
+        MUST revert if `_to` is the zero address.
+        MUST revert if balance of holder for token `_id` is lower than the `_value` sent.
+        MUST revert on any other error.
+        MUST emit the `TransferSingle` event to reflect the balance change (see "Safe Transfer Rules" section of the standard).
+        After the above conditions are met, this function MUST check if `_to` is a smart contract (e.g. code size > 0). If so, it MUST call `onERC1155Received` on `_to` and act appropriately (see "Safe Transfer Rules" section of the standard).        
+        @param _from    Source address
+        @param _to      Target address
+        @param _id      ID of the token type
+        @param _value   Transfer amount
+        @param _data    Additional data with no specified format, MUST be sent unaltered in call to `onERC1155Received` on `_to`
+    */
+    function safeTransferFrom(
+        address _from,
+        address _to,
+        uint256 _id,
+        uint256 _value,
+        bytes calldata _data
+    ) external;
+
+    /**
+        @notice Transfers `_values` amount(s) of `_ids` from the `_from` address to the `_to` address specified (with safety call).
+        @dev Caller must be approved to manage the tokens being transferred out of the `_from` account (see "Approval" section of the standard).
+        MUST revert if `_to` is the zero address.
+        MUST revert if length of `_ids` is not the same as length of `_values`.
+        MUST revert if any of the balance(s) of the holder(s) for token(s) in `_ids` is lower than the respective amount(s) in `_values` sent to the recipient.
+        MUST revert on any other error.        
+        MUST emit `TransferSingle` or `TransferBatch` event(s) such that all the balance changes are reflected (see "Safe Transfer Rules" section of the standard).
+        Balance changes and events MUST follow the ordering of the arrays (_ids[0]/_values[0] before _ids[1]/_values[1], etc).
+        After the above conditions for the transfer(s) in the batch are met, this function MUST check if `_to` is a smart contract (e.g. code size > 0). If so, it MUST call the relevant `ERC1155TokenReceiver` hook(s) on `_to` and act appropriately (see "Safe Transfer Rules" section of the standard).                      
+        @param _from    Source address
+        @param _to      Target address
+        @param _ids     IDs of each token type (order and length must match _values array)
+        @param _values  Transfer amounts per token type (order and length must match _ids array)
+        @param _data    Additional data with no specified format, MUST be sent unaltered in call to the `ERC1155TokenReceiver` hook(s) on `_to`
+    */
+    function safeBatchTransferFrom(
+        address _from,
+        address _to,
+        uint256[] calldata _ids,
+        uint256[] calldata _values,
+        bytes calldata _data
+    ) external;
+
+    /**
+        @notice Get the balance of an account's tokens.
+        @param _owner  The address of the token holder
+        @param _id     ID of the token
+        @return        The _owner's balance of the token type requested
+     */
+    function balanceOf(
+        address _owner,
+        uint256 _id
+    ) external view returns (uint256);
+
+    /**
+        @notice Get the balance of multiple account/token pairs
+        @param _owners The addresses of the token holders
+        @param _ids    ID of the tokens
+        @return        The _owner's balance of the token types requested (i.e. balance for each (owner, id) pair)
+     */
+    function balanceOfBatch(
+        address[] calldata _owners,
+        uint256[] calldata _ids
+    ) external view returns (uint256[] memory);
+
+    /**
+        @notice Enable or disable approval for a third party ("operator") to manage all of the caller's tokens.
+        @dev MUST emit the ApprovalForAll event on success.
+        @param _operator  Address to add to the set of authorized operators
+        @param _approved  True if the operator is approved, false to revoke approval
+    */
+    function setApprovalForAll(address _operator, bool _approved) external;
+
+    /**
+        @notice Queries the approval status of an operator for a given owner.
+        @param _owner     The owner of the tokens
+        @param _operator  Address of authorized operator
+        @return           True if the operator is approved, false if not
+    */
+    function isApprovedForAll(
+        address _owner,
+        address _operator
+    ) external view returns (bool);
+}

vendor/github.com/status-im/status-go/contracts/ierc20/README.md

@@ -0,0 +1,5 @@
+ERC20 interface
+===============
+
+Can be used for interaction with any erc20 compatible token.
+Code was taken from [zeppelin libraries](https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/token/ERC20/IERC20.sol).

vendor/github.com/status-im/status-go/contracts/ierc20/doc.go

@@ -0,0 +1,3 @@
+package ierc20
+
+//go:generate abigen -sol ierc20.sol -pkg ierc20 -out ierc20.go

vendor/github.com/status-im/status-go/contracts/ierc20/ierc20.go

@@ -0,0 +1,742 @@
+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package ierc20
+
+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
+)
+
+// IERC20ABI is the input ABI used to generate the binding from.
+const IERC20ABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"spender\",\"type\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"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\":\"sender\",\"type\":\"address\"},{\"name\":\"recipient\",\"type\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"name\":\"recipient\",\"type\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"name\":\"\",\"type\":\"bool\"}],\"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\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"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\"}]"
+
+// 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)",
+	"313ce567": "decimals()",
+	"06fdde03": "name()",
+	"95d89b41": "symbol()",
+	"18160ddd": "totalSupply()",
+	"a9059cbb": "transfer(address,uint256)",
+	"23b872dd": "transferFrom(address,address,uint256)",
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// IERC20Session is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+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
+}
+
+// IERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type IERC20CallerSession struct {
+	Contract *IERC20Caller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts // Call options to use throughout this session
+}
+
+// IERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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 &IERC20{IERC20Caller: IERC20Caller{contract: contract}, IERC20Transactor: IERC20Transactor{contract: contract}, IERC20Filterer: IERC20Filterer{contract: contract}}, 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 &IERC20Caller{contract: contract}, 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 &IERC20Transactor{contract: contract}, nil
+}
+
+// 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 &IERC20Filterer{contract: contract}, nil
+}
+
+// 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
+	}
+	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 (_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 (_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 (_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 (_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 (_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 (_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 out []interface{}
+	err := _IERC20.contract.Call(opts, &out, "allowance", owner, spender)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, 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 (_IERC20 *IERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) {
+	var out []interface{}
+	err := _IERC20.contract.Call(opts, &out, "balanceOf", account)
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// BalanceOf is a free data retrieval call binding the contract method 0x70a08231.
+//
+// Solidity: function balanceOf(address account) view returns(uint256)
+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 (_IERC20 *IERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) {
+	return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, account)
+}
+
+// Decimals is a free data retrieval call binding the contract method 0x313ce567.
+//
+// Solidity: function decimals() view returns(uint8)
+func (_IERC20 *IERC20Caller) Decimals(opts *bind.CallOpts) (uint8, error) {
+	var out []interface{}
+	err := _IERC20.contract.Call(opts, &out, "decimals")
+
+	if err != nil {
+		return *new(uint8), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(uint8)).(*uint8)
+
+	return out0, err
+
+}
+
+// Decimals is a free data retrieval call binding the contract method 0x313ce567.
+//
+// Solidity: function decimals() view returns(uint8)
+func (_IERC20 *IERC20Session) Decimals() (uint8, error) {
+	return _IERC20.Contract.Decimals(&_IERC20.CallOpts)
+}
+
+// Decimals is a free data retrieval call binding the contract method 0x313ce567.
+//
+// Solidity: function decimals() view returns(uint8)
+func (_IERC20 *IERC20CallerSession) Decimals() (uint8, error) {
+	return _IERC20.Contract.Decimals(&_IERC20.CallOpts)
+}
+
+// Name is a free data retrieval call binding the contract method 0x06fdde03.
+//
+// Solidity: function name() view returns(string)
+func (_IERC20 *IERC20Caller) Name(opts *bind.CallOpts) (string, error) {
+	var out []interface{}
+	err := _IERC20.contract.Call(opts, &out, "name")
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// Name is a free data retrieval call binding the contract method 0x06fdde03.
+//
+// Solidity: function name() view returns(string)
+func (_IERC20 *IERC20Session) Name() (string, error) {
+	return _IERC20.Contract.Name(&_IERC20.CallOpts)
+}
+
+// Name is a free data retrieval call binding the contract method 0x06fdde03.
+//
+// Solidity: function name() view returns(string)
+func (_IERC20 *IERC20CallerSession) Name() (string, error) {
+	return _IERC20.Contract.Name(&_IERC20.CallOpts)
+}
+
+// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
+//
+// Solidity: function symbol() view returns(string)
+func (_IERC20 *IERC20Caller) Symbol(opts *bind.CallOpts) (string, error) {
+	var out []interface{}
+	err := _IERC20.contract.Call(opts, &out, "symbol")
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
+//
+// Solidity: function symbol() view returns(string)
+func (_IERC20 *IERC20Session) Symbol() (string, error) {
+	return _IERC20.Contract.Symbol(&_IERC20.CallOpts)
+}
+
+// Symbol is a free data retrieval call binding the contract method 0x95d89b41.
+//
+// Solidity: function symbol() view returns(string)
+func (_IERC20 *IERC20CallerSession) Symbol() (string, error) {
+	return _IERC20.Contract.Symbol(&_IERC20.CallOpts)
+}
+
+// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
+//
+// Solidity: function totalSupply() view returns(uint256)
+func (_IERC20 *IERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _IERC20.contract.Call(opts, &out, "totalSupply")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
+//
+// Solidity: function totalSupply() view returns(uint256)
+func (_IERC20 *IERC20Session) TotalSupply() (*big.Int, error) {
+	return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts)
+}
+
+// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd.
+//
+// Solidity: function totalSupply() view returns(uint256)
+func (_IERC20 *IERC20CallerSession) TotalSupply() (*big.Int, error) {
+	return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts)
+}
+
+// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
+//
+// 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)
+}
+
+// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
+//
+// 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)
+}
+
+// Approve is a paid mutator transaction binding the contract method 0x095ea7b3.
+//
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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)
+}
+
+// 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
+
+	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 *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()
+	}
+}
+
+// Error returns any retrieval or parsing error occurred during filtering.
+func (it *IERC20ApprovalIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *IERC20ApprovalIterator) Close() error {
+	it.sub.Unsubscribe()
+	return 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
+}
+
+// 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)
+	}
+
+	logs, sub, err := _IERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule)
+	if err != nil {
+		return nil, err
+	}
+	return &IERC20ApprovalIterator{contract: _IERC20.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 (_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)
+	}
+
+	logs, sub, err := _IERC20.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(IERC20Approval)
+				if err := _IERC20.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 (_IERC20 *IERC20Filterer) ParseApproval(log types.Log) (*IERC20Approval, error) {
+	event := new(IERC20Approval)
+	if err := _IERC20.contract.UnpackLog(event, "Approval", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// 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
+
+	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 *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
+
+		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
+	}
+	event.Raw = log
+	return event, nil
+}

vendor/github.com/status-im/status-go/contracts/ierc20/ierc20.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.4.24;
+
+/**
+ * @dev Interface of the ERC20 standard as defined in the EIP.
+ */
+interface IERC20 {
+    function name() external view returns (string memory);
+
+    function symbol() external view returns (string memory);
+
+    function decimals() external view returns (uint8);
+    
+    /**
+     * @dev Returns the amount of tokens in existence.
+     */
+    function totalSupply() external view returns (uint256);
+
+    /**
+     * @dev Returns the amount of tokens owned by `account`.
+     */
+    function balanceOf(address account) external view returns (uint256);
+
+    /**
+     * @dev Moves `amount` tokens from the caller's account to `recipient`.
+     *
+     * Returns a boolean value indicating whether the operation succeeded.
+     *
+     * Emits a {Transfer} event.
+     */
+    function transfer(address recipient, uint256 amount)
+        external
+        returns (bool);
+
+    /**
+     * @dev Returns the remaining number of tokens that `spender` will be
+     * allowed to spend on behalf of `owner` through {transferFrom}. This is
+     * zero by default.
+     *
+     * This value changes when {approve} or {transferFrom} are called.
+     */
+    function allowance(address owner, address spender)
+        external
+        view
+        returns (uint256);
+
+    /**
+     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
+     *
+     * Returns a boolean value indicating whether the operation succeeded.
+     *
+     * IMPORTANT: Beware that changing an allowance with this method brings the risk
+     * that someone may use both the old and the new allowance by unfortunate
+     * transaction ordering. One possible solution to mitigate this race
+     * condition is to first reduce the spender's allowance to 0 and set the
+     * desired value afterwards:
+     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
+     *
+     * Emits an {Approval} event.
+     */
+    function approve(address spender, uint256 amount) external returns (bool);
+
+    /**
+     * @dev Moves `amount` tokens from `sender` to `recipient` using the
+     * allowance mechanism. `amount` is then deducted from the caller's
+     * allowance.
+     *
+     * Returns a boolean value indicating whether the operation succeeded.
+     *
+     * Emits a {Transfer} event.
+     */
+    function transferFrom(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) external returns (bool);
+
+    /**
+     * @dev Emitted when `value` tokens are moved from one account (`from`) to
+     * another (`to`).
+     *
+     * Note that `value` may be zero.
+     */
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    /**
+     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
+     * a call to {approve}. `value` is the new allowance.
+     */
+    event Approval(
+        address indexed owner,
+        address indexed spender,
+        uint256 value
+    );
+}

vendor/github.com/status-im/status-go/contracts/registrar/Registrar.sol

@@ -0,0 +1,297 @@
+// This solidity file was added to the project to generate the ABI to consume
+// the smart contract deployed at 0xDB5ac1a559b02E12F29fC0eC0e37Be8E046DEF49
+
+pragma solidity ^0.4.24;
+
+contract Controlled {
+    address public controller;
+
+    /// @notice Changes the controller of the contract
+    /// @param _newController The new controller of the contract
+    function changeController(address _newController) public;
+}
+
+contract ApproveAndCallFallBack {
+    function receiveApproval(
+        address from,
+        uint256 _amount,
+        address _token,
+        bytes _data
+    ) public;
+}
+
+contract UsernameRegistrar is Controlled, ApproveAndCallFallBack {
+    address public token;
+    address public ensRegistry;
+    address public resolver;
+    address public parentRegistry;
+
+    uint256 public constant releaseDelay = 365 days;
+    mapping(bytes32 => Account) public accounts;
+    mapping(bytes32 => SlashReserve) reservedSlashers;
+
+    //Slashing conditions
+    uint256 public usernameMinLength;
+    bytes32 public reservedUsernamesMerkleRoot;
+
+    event RegistryState(RegistrarState state);
+    event RegistryPrice(uint256 price);
+    event RegistryMoved(address newRegistry);
+    event UsernameOwner(bytes32 indexed nameHash, address owner);
+
+    enum RegistrarState {
+        Inactive,
+        Active,
+        Moved
+    }
+    bytes32 public ensNode;
+    uint256 public price;
+    RegistrarState public state;
+    uint256 public reserveAmount;
+
+    struct Account {
+        uint256 balance;
+        uint256 creationTime;
+        address owner;
+    }
+
+    struct SlashReserve {
+        address reserver;
+        uint256 blockNumber;
+    }
+
+    /**
+     * @notice Registers `_label` username to `ensNode` setting msg.sender as owner.
+     * Terms of name registration:
+     * - SNT is deposited, not spent; the amount is locked up for 1 year.
+     * - After 1 year, the user can release the name and receive their deposit back (at any time).
+     * - User deposits are completely protected. The contract controller cannot access them.
+     * - User's address(es) will be publicly associated with the ENS name.
+     * - User must authorise the contract to transfer `price` `token.name()`  on their behalf.
+     * - Usernames registered with less then `usernameMinLength` characters can be slashed.
+     * - Usernames contained in the merkle tree of root `reservedUsernamesMerkleRoot` can be slashed.
+     * - Usernames starting with `0x` and bigger then 12 characters can be slashed.
+     * - If terms of the contract change—e.g. Status makes contract upgrades—the user has the right to release the username and get their deposit back.
+     * @param _label Choosen unowned username hash.
+     * @param _account Optional address to set at public resolver.
+     * @param _pubkeyA Optional pubkey part A to set at public resolver.
+     * @param _pubkeyB Optional pubkey part B to set at public resolver.
+     */
+    function register(
+        bytes32 _label,
+        address _account,
+        bytes32 _pubkeyA,
+        bytes32 _pubkeyB
+    ) external returns (bytes32 namehash);
+
+    /**
+     * @notice Release username and retrieve locked fee, needs to be called
+     * after `releasePeriod` from creation time by ENS registry owner of domain
+     * or anytime by account owner when domain migrated to a new registry.
+     * @param _label Username hash.
+     */
+    function release(bytes32 _label) external;
+
+    /**
+     * @notice update account owner, should be called by new ens node owner
+     * to update this contract registry, otherwise former owner can release
+     * if domain is moved to a new registry.
+     * @param _label Username hash.
+     **/
+    function updateAccountOwner(bytes32 _label) external;
+
+    /**
+     * @notice secretly reserve the slashing reward to `msg.sender`
+     * @param _secret keccak256(abi.encodePacked(namehash, creationTime, reserveSecret))
+     */
+    function reserveSlash(bytes32 _secret) external;
+
+    /**
+     * @notice Slash username smaller then `usernameMinLength`.
+     * @param _username Raw value of offending username.
+     */
+    function slashSmallUsername(string _username, uint256 _reserveSecret)
+        external;
+
+    /**
+     * @notice Slash username starting with "0x" and with length greater than 12.
+     * @param _username Raw value of offending username.
+     */
+    function slashAddressLikeUsername(string _username, uint256 _reserveSecret)
+        external;
+
+    /**
+     * @notice Slash username that is exactly a reserved name.
+     * @param _username Raw value of offending username.
+     * @param _proof Merkle proof that name is listed on merkle tree.
+     */
+    function slashReservedUsername(
+        string _username,
+        bytes32[] _proof,
+        uint256 _reserveSecret
+    ) external;
+
+    /**
+     * @notice Slash username that contains a non alphanumeric character.
+     * @param _username Raw value of offending username.
+     * @param _offendingPos Position of non alphanumeric character.
+     */
+    function slashInvalidUsername(
+        string _username,
+        uint256 _offendingPos,
+        uint256 _reserveSecret
+    ) external;
+
+    /**
+     * @notice Clear resolver and ownership of unowned subdomians.
+     * @param _labels Sequence to erase.
+     */
+    function eraseNode(bytes32[] _labels) external;
+
+    /**
+     * @notice Migrate account to new registry, opt-in to new contract.
+     * @param _label Username hash.
+     **/
+    function moveAccount(bytes32 _label, UsernameRegistrar _newRegistry)
+        external;
+
+    /**
+     * @notice Activate registration.
+     * @param _price The price of registration.
+     */
+    function activate(uint256 _price) external;
+
+    /**
+     * @notice Updates Public Resolver for resolving users.
+     * @param _resolver New PublicResolver.
+     */
+    function setResolver(address _resolver) external;
+
+    /**
+     * @notice Updates registration price.
+     * @param _price New registration price.
+     */
+    function updateRegistryPrice(uint256 _price) external;
+
+    /**
+     * @notice Transfer ownership of ensNode to `_newRegistry`.
+     * Usernames registered are not affected, but they would be able to instantly release.
+     * @param _newRegistry New UsernameRegistrar for hodling `ensNode` node.
+     */
+    function moveRegistry(UsernameRegistrar _newRegistry) external;
+
+    /**
+     * @notice Opt-out migration of username from `parentRegistry()`.
+     * Clear ENS resolver and subnode owner.
+     * @param _label Username hash.
+     */
+    function dropUsername(bytes32 _label) external;
+
+    /**
+     * @notice Withdraw not reserved tokens
+     * @param _token Address of ERC20 withdrawing excess, or address(0) if want ETH.
+     * @param _beneficiary Address to send the funds.
+     **/
+    function withdrawExcessBalance(address _token, address _beneficiary)
+        external;
+
+    /**
+     * @notice Withdraw ens nodes not belonging to this contract.
+     * @param _domainHash Ens node namehash.
+     * @param _beneficiary New owner of ens node.
+     **/
+    function withdrawWrongNode(bytes32 _domainHash, address _beneficiary)
+        external;
+
+    /**
+     * @notice Gets registration price.
+     * @return Registration price.
+     **/
+    function getPrice() external view returns (uint256 registryPrice);
+
+    /**
+     * @notice reads amount tokens locked in username
+     * @param _label Username hash.
+     * @return Locked username balance.
+     **/
+    function getAccountBalance(bytes32 _label)
+        external
+        view
+        returns (uint256 accountBalance);
+
+    /**
+     * @notice reads username account owner at this contract,
+     * which can release or migrate in case of upgrade.
+     * @param _label Username hash.
+     * @return Username account owner.
+     **/
+    function getAccountOwner(bytes32 _label)
+        external
+        view
+        returns (address owner);
+
+    /**
+     * @notice reads when the account was registered
+     * @param _label Username hash.
+     * @return Registration time.
+     **/
+    function getCreationTime(bytes32 _label)
+        external
+        view
+        returns (uint256 creationTime);
+
+    /**
+     * @notice calculate time where username can be released
+     * @param _label Username hash.
+     * @return Exact time when username can be released.
+     **/
+    function getExpirationTime(bytes32 _label)
+        external
+        view
+        returns (uint256 releaseTime);
+
+    /**
+     * @notice calculate reward part an account could payout on slash
+     * @param _label Username hash.
+     * @return Part of reward
+     **/
+    function getSlashRewardPart(bytes32 _label)
+        external
+        view
+        returns (uint256 partReward);
+
+    /**
+     * @notice Support for "approveAndCall". Callable only by `token()`.
+     * @param _from Who approved.
+     * @param _amount Amount being approved, need to be equal `getPrice()`.
+     * @param _token Token being approved, need to be equal `token()`.
+     * @param _data Abi encoded data with selector of `register(bytes32,address,bytes32,bytes32)`.
+     */
+    function receiveApproval(
+        address _from,
+        uint256 _amount,
+        address _token,
+        bytes _data
+    ) public;
+
+    /**
+     * @notice Continues migration of username to new registry.
+     * @param _label Username hash.
+     * @param _tokenBalance Amount being transfered from `parentRegistry()`.
+     * @param _creationTime Time user registrated in `parentRegistry()` is preserved.
+     * @param _accountOwner Account owner which migrated the account.
+     **/
+    function migrateUsername(
+        bytes32 _label,
+        uint256 _tokenBalance,
+        uint256 _creationTime,
+        address _accountOwner
+    ) external;
+
+    /**
+     * @dev callable only by parent registry to continue migration
+     * of registry and activate registration.
+     * @param _price The price of registration.
+     **/
+    function migrateRegistry(uint256 _price) external;
+}

vendor/github.com/status-im/status-go/contracts/registrar/doc.go

@@ -0,0 +1,3 @@
+package registrar
+
+//go:generate abigen -sol Registrar.sol -pkg registrar -out registrar.go

vendor/github.com/status-im/status-go/contracts/resolver/address.go

@@ -0,0 +1,23 @@
+package resolver
+
+import (
+	"errors"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+var errorNotAvailableOnChainID = errors.New("not available for chainID")
+
+var contractAddressByChainID = map[uint64]common.Address{
+	1:        common.HexToAddress("0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"), // mainnet
+	5:        common.HexToAddress("0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"), // goerli
+	11155111: common.HexToAddress("0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"), // sepolia testnet
+}
+
+func ContractAddress(chainID uint64) (common.Address, error) {
+	addr, exists := contractAddressByChainID[chainID]
+	if !exists {
+		return *new(common.Address), errorNotAvailableOnChainID
+	}
+	return addr, nil
+}

vendor/github.com/status-im/status-go/contracts/resolver/doc.go

@@ -0,0 +1,3 @@
+package resolver
+
+//go:generate abigen -sol resolver.sol -pkg resolver -out resolver.go

vendor/github.com/status-im/status-go/contracts/resolver/resolver.sol

@@ -0,0 +1,555 @@
+// This solidity file was added to the project to generate the ABI to consume
+// the smart contract deployed at 0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e
+
+pragma solidity >=0.4.24;
+
+interface ENS {
+    // Logged when the owner of a node assigns a new owner to a subnode.
+    event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);
+
+    // Logged when the owner of a node transfers ownership to a new account.
+    event Transfer(bytes32 indexed node, address owner);
+
+    // Logged when the resolver for a node changes.
+    event NewResolver(bytes32 indexed node, address resolver);
+
+    // Logged when the TTL of a node changes
+    event NewTTL(bytes32 indexed node, uint64 ttl);
+
+    // Logged when an operator is added or removed.
+    event ApprovalForAll(
+        address indexed owner,
+        address indexed operator,
+        bool approved
+    );
+
+    function setRecord(
+        bytes32 node,
+        address owner,
+        address resolver,
+        uint64 ttl
+    ) external;
+
+    function setSubnodeRecord(
+        bytes32 node,
+        bytes32 label,
+        address owner,
+        address resolver,
+        uint64 ttl
+    ) external;
+
+    function setSubnodeOwner(
+        bytes32 node,
+        bytes32 label,
+        address owner
+    ) external returns (bytes32);
+
+    function setResolver(bytes32 node, address resolver) external;
+
+    function setOwner(bytes32 node, address owner) external;
+
+    function setTTL(bytes32 node, uint64 ttl) external;
+
+    function setApprovalForAll(address operator, bool approved) external;
+
+    function owner(bytes32 node) external view returns (address);
+
+    function resolver(bytes32 node) external view returns (address);
+
+    function ttl(bytes32 node) external view returns (uint64);
+
+    function recordExists(bytes32 node) external view returns (bool);
+
+    function isApprovedForAll(address owner, address operator)
+        external
+        view
+        returns (bool);
+}
+
+/**
+ * The ENS registry contract.
+ */
+contract ENSRegistry is ENS {
+    struct Record {
+        address owner;
+        address resolver;
+        uint64 ttl;
+    }
+
+    /**
+     * @dev Sets the record for a node.
+     * @param node The node to update.
+     * @param owner The address of the new owner.
+     * @param resolver The address of the resolver.
+     * @param ttl The TTL in seconds.
+     */
+    function setRecord(
+        bytes32 node,
+        address owner,
+        address resolver,
+        uint64 ttl
+    ) external;
+
+    /**
+     * @dev Sets the record for a subnode.
+     * @param node The parent node.
+     * @param label The hash of the label specifying the subnode.
+     * @param owner The address of the new owner.
+     * @param resolver The address of the resolver.
+     * @param ttl The TTL in seconds.
+     */
+    function setSubnodeRecord(
+        bytes32 node,
+        bytes32 label,
+        address owner,
+        address resolver,
+        uint64 ttl
+    ) external;
+
+    /**
+     * @dev Transfers ownership of a node to a new address. May only be called by the current owner of the node.
+     * @param node The node to transfer ownership of.
+     * @param owner The address of the new owner.
+     */
+    function setOwner(bytes32 node, address owner) public;
+
+    /**
+     * @dev Transfers ownership of a subnode keccak256(node, label) to a new address. May only be called by the owner of the parent node.
+     * @param node The parent node.
+     * @param label The hash of the label specifying the subnode.
+     * @param owner The address of the new owner.
+     */
+    function setSubnodeOwner(
+        bytes32 node,
+        bytes32 label,
+        address owner
+    ) public returns (bytes32);
+
+    /**
+     * @dev Sets the resolver address for the specified node.
+     * @param node The node to update.
+     * @param resolver The address of the resolver.
+     */
+    function setResolver(bytes32 node, address resolver) public;
+
+    /**
+     * @dev Sets the TTL for the specified node.
+     * @param node The node to update.
+     * @param ttl The TTL in seconds.
+     */
+    function setTTL(bytes32 node, uint64 ttl) public;
+
+    /**
+     * @dev Enable or disable approval for a third party ("operator") to manage
+     *  all of `msg.sender`'s ENS records. Emits the ApprovalForAll event.
+     * @param operator Address to add to the set of authorized operators.
+     * @param approved True if the operator is approved, false to revoke approval.
+     */
+    function setApprovalForAll(address operator, bool approved) external;
+
+    /**
+     * @dev Returns the address that owns the specified node.
+     * @param node The specified node.
+     * @return address of the owner.
+     */
+    function owner(bytes32 node) public view returns (address);
+
+    /**
+     * @dev Returns the address of the resolver for the specified node.
+     * @param node The specified node.
+     * @return address of the resolver.
+     */
+    function resolver(bytes32 node) public view returns (address);
+
+    /**
+     * @dev Returns the TTL of a node, and any records associated with it.
+     * @param node The specified node.
+     * @return ttl of the node.
+     */
+    function ttl(bytes32 node) public view returns (uint64);
+
+    /**
+     * @dev Returns whether a record has been imported to the registry.
+     * @param node The specified node.
+     * @return Bool if record exists
+     */
+    function recordExists(bytes32 node) public view returns (bool);
+
+    /**
+     * @dev Query if an address is an authorized operator for another address.
+     * @param owner The address that owns the records.
+     * @param operator The address that acts on behalf of the owner.
+     * @return True if `operator` is an approved operator for `owner`, false otherwise.
+     */
+    function isApprovedForAll(address owner, address operator)
+        external
+        view
+        returns (bool);
+}
+
+/**
+ * The ENS registry contract.
+ */
+contract ENSRegistryWithFallback is ENSRegistry {
+    /**
+     * @dev Returns the address of the resolver for the specified node.
+     * @param node The specified node.
+     * @return address of the resolver.
+     */
+    function resolver(bytes32 node) public view returns (address);
+
+    /**
+     * @dev Returns the address that owns the specified node.
+     * @param node The specified node.
+     * @return address of the owner.
+     */
+    function owner(bytes32 node) public view returns (address);
+
+    /**
+     * @dev Returns the TTL of a node, and any records associated with it.
+     * @param node The specified node.
+     * @return ttl of the node.
+     */
+    function ttl(bytes32 node) public view returns (uint64);
+}
+
+contract ResolverBase {
+    function supportsInterface(bytes4 interfaceID) public pure returns (bool);
+}
+
+contract ABIResolver is ResolverBase {
+    event ABIChanged(bytes32 indexed node, uint256 indexed contentType);
+
+    /**
+     * Sets the ABI associated with an ENS node.
+     * Nodes may have one ABI of each content type. To remove an ABI, set it to
+     * the empty string.
+     * @param node The node to update.
+     * @param contentType The content type of the ABI
+     * @param data The ABI data.
+     */
+    function setABI(
+        bytes32 node,
+        uint256 contentType,
+        bytes calldata data
+    ) external;
+
+    /**
+     * Returns the ABI associated with an ENS node.
+     * Defined in EIP205.
+     * @param node The ENS node to query
+     * @param contentTypes A bitwise OR of the ABI formats accepted by the caller.
+     * @return contentType The content type of the return value
+     * @return data The ABI data
+     */
+    function ABI(bytes32 node, uint256 contentTypes)
+        external
+        view
+        returns (uint256, bytes memory);
+
+    function supportsInterface(bytes4 interfaceID) public pure returns (bool);
+}
+
+contract AddrResolver is ResolverBase {
+    event AddrChanged(bytes32 indexed node, address a);
+    event AddressChanged(
+        bytes32 indexed node,
+        uint256 coinType,
+        bytes newAddress
+    );
+
+    /**
+     * Sets the address associated with an ENS node.
+     * May only be called by the owner of that node in the ENS registry.
+     * @param node The node to update.
+     * @param a The address to set.
+     */
+    function setAddr(bytes32 node, address a) external;
+
+    /**
+     * Returns the address associated with an ENS node.
+     * @param node The ENS node to query.
+     * @return The associated address.
+     */
+    function addr(bytes32 node) public view returns (address payable);
+
+    function setAddr(
+        bytes32 node,
+        uint256 coinType,
+        bytes memory a
+    ) public;
+
+    function addr(bytes32 node, uint256 coinType)
+        public
+        view
+        returns (bytes memory);
+
+    function supportsInterface(bytes4 interfaceID) public pure returns (bool);
+}
+
+contract ContentHashResolver is ResolverBase {
+    event ContenthashChanged(bytes32 indexed node, bytes hash);
+
+    /**
+     * Sets the contenthash associated with an ENS node.
+     * May only be called by the owner of that node in the ENS registry.
+     * @param node The node to update.
+     * @param hash The contenthash to set
+     */
+    function setContenthash(bytes32 node, bytes calldata hash) external;
+
+    /**
+     * Returns the contenthash associated with an ENS node.
+     * @param node The ENS node to query.
+     * @return The associated contenthash.
+     */
+    function contenthash(bytes32 node) external view returns (bytes memory);
+
+    function supportsInterface(bytes4 interfaceID) public pure returns (bool);
+}
+
+contract DNSResolver is ResolverBase {
+    // DNSRecordChanged is emitted whenever a given node/name/resource's RRSET is updated.
+    event DNSRecordChanged(
+        bytes32 indexed node,
+        bytes name,
+        uint16 resource,
+        bytes record
+    );
+    // DNSRecordDeleted is emitted whenever a given node/name/resource's RRSET is deleted.
+    event DNSRecordDeleted(bytes32 indexed node, bytes name, uint16 resource);
+    // DNSZoneCleared is emitted whenever a given node's zone information is cleared.
+    event DNSZoneCleared(bytes32 indexed node);
+
+    /**
+     * Set one or more DNS records.  Records are supplied in wire-format.
+     * Records with the same node/name/resource must be supplied one after the
+     * other to ensure the data is updated correctly. For example, if the data
+     * was supplied:
+     *     a.example.com IN A 1.2.3.4
+     *     a.example.com IN A 5.6.7.8
+     *     www.example.com IN CNAME a.example.com.
+     * then this would store the two A records for a.example.com correctly as a
+     * single RRSET, however if the data was supplied:
+     *     a.example.com IN A 1.2.3.4
+     *     www.example.com IN CNAME a.example.com.
+     *     a.example.com IN A 5.6.7.8
+     * then this would store the first A record, the CNAME, then the second A
+     * record which would overwrite the first.
+     *
+     * @param node the namehash of the node for which to set the records
+     * @param data the DNS wire format records to set
+     */
+    function setDNSRecords(bytes32 node, bytes calldata data) external;
+
+    /**
+     * Obtain a DNS record.
+     * @param node the namehash of the node for which to fetch the record
+     * @param name the keccak-256 hash of the fully-qualified name for which to fetch the record
+     * @param resource the ID of the resource as per https://en.wikipedia.org/wiki/List_of_DNS_record_types
+     * @return the DNS record in wire format if present, otherwise empty
+     */
+    function dnsRecord(
+        bytes32 node,
+        bytes32 name,
+        uint16 resource
+    ) public view returns (bytes memory);
+
+    /**
+     * Check if a given node has records.
+     * @param node the namehash of the node for which to check the records
+     * @param name the namehash of the node for which to check the records
+     */
+    function hasDNSRecords(bytes32 node, bytes32 name)
+        public
+        view
+        returns (bool);
+
+    /**
+     * Clear all information for a DNS zone.
+     * @param node the namehash of the node for which to clear the zone
+     */
+    function clearDNSZone(bytes32 node) public;
+
+    function supportsInterface(bytes4 interfaceID) public pure returns (bool);
+}
+
+contract InterfaceResolver is ResolverBase, AddrResolver {
+    event InterfaceChanged(
+        bytes32 indexed node,
+        bytes4 indexed interfaceID,
+        address implementer
+    );
+
+    /**
+     * Sets an interface associated with a name.
+     * Setting the address to 0 restores the default behaviour of querying the contract at `addr()` for interface support.
+     * @param node The node to update.
+     * @param interfaceID The EIP 168 interface ID.
+     * @param implementer The address of a contract that implements this interface for this node.
+     */
+    function setInterface(
+        bytes32 node,
+        bytes4 interfaceID,
+        address implementer
+    ) external;
+
+    /**
+     * Returns the address of a contract that implements the specified interface for this name.
+     * If an implementer has not been set for this interfaceID and name, the resolver will query
+     * the contract at `addr()`. If `addr()` is set, a contract exists at that address, and that
+     * contract implements EIP168 and returns `true` for the specified interfaceID, its address
+     * will be returned.
+     * @param node The ENS node to query.
+     * @param interfaceID The EIP 168 interface ID to check for.
+     * @return The address that implements this interface, or 0 if the interface is unsupported.
+     */
+    function interfaceImplementer(bytes32 node, bytes4 interfaceID)
+        external
+        view
+        returns (address);
+
+    function supportsInterface(bytes4 interfaceID) public pure returns (bool);
+}
+
+contract NameResolver is ResolverBase {
+    event NameChanged(bytes32 indexed node, string name);
+
+    /**
+     * Sets the name associated with an ENS node, for reverse records.
+     * May only be called by the owner of that node in the ENS registry.
+     * @param node The node to update.
+     * @param name The name to set.
+     */
+    function setName(bytes32 node, string calldata name) external;
+
+    /**
+     * Returns the name associated with an ENS node, for reverse records.
+     * Defined in EIP181.
+     * @param node The ENS node to query.
+     * @return The associated name.
+     */
+    function name(bytes32 node) external view returns (string memory);
+
+    function supportsInterface(bytes4 interfaceID) public pure returns (bool);
+}
+
+contract PubkeyResolver is ResolverBase {
+    event PubkeyChanged(bytes32 indexed node, bytes32 x, bytes32 y);
+
+    struct PublicKey {
+        bytes32 x;
+        bytes32 y;
+    }
+
+    /**
+     * Sets the SECP256k1 public key associated with an ENS node.
+     * @param node The ENS node to query
+     * @param x the X coordinate of the curve point for the public key.
+     * @param y the Y coordinate of the curve point for the public key.
+     */
+    function setPubkey(
+        bytes32 node,
+        bytes32 x,
+        bytes32 y
+    ) external;
+
+    /**
+     * Returns the SECP256k1 public key associated with an ENS node.
+     * Defined in EIP 619.
+     * @param node The ENS node to query
+     * @return x, y the X and Y coordinates of the curve point for the public key.
+     */
+    function pubkey(bytes32 node) external view returns (bytes32 x, bytes32 y);
+
+    function supportsInterface(bytes4 interfaceID) public pure returns (bool);
+}
+
+contract TextResolver is ResolverBase {
+    event TextChanged(
+        bytes32 indexed node,
+        string indexed indexedKey,
+        string key
+    );
+
+    /**
+     * Sets the text data associated with an ENS node and key.
+     * May only be called by the owner of that node in the ENS registry.
+     * @param node The node to update.
+     * @param key The key to set.
+     * @param value The text data value to set.
+     */
+    function setText(
+        bytes32 node,
+        string calldata key,
+        string calldata value
+    ) external;
+
+    /**
+     * Returns the text data associated with an ENS node and key.
+     * @param node The ENS node to query.
+     * @param key The text data key to query.
+     * @return The associated text data.
+     */
+    function text(bytes32 node, string calldata key)
+        external
+        view
+        returns (string memory);
+
+    function supportsInterface(bytes4 interfaceID) public pure returns (bool);
+}
+
+pragma experimental ABIEncoderV2;
+
+/**
+ * A simple resolver anyone can use; only allows the owner of a node to set its
+ * address.
+ */
+contract PublicResolver is
+    ABIResolver,
+    AddrResolver,
+    ContentHashResolver,
+    DNSResolver,
+    InterfaceResolver,
+    NameResolver,
+    PubkeyResolver,
+    TextResolver
+{
+    /**
+     * A mapping of authorisations. An address that is authorised for a name
+     * may make any changes to the name that the owner could, but may not update
+     * the set of authorisations.
+     * (node, owner, caller) => isAuthorised
+     */
+    mapping(bytes32 => mapping(address => mapping(address => bool)))
+        public authorisations;
+
+    event AuthorisationChanged(
+        bytes32 indexed node,
+        address indexed owner,
+        address indexed target,
+        bool isAuthorised
+    );
+
+    /**
+     * @dev Sets or clears an authorisation.
+     * Authorisations are specific to the caller. Any account can set an authorisation
+     * for any name, but the authorisation that is checked will be that of the
+     * current owner of a name. Thus, transferring a name effectively clears any
+     * existing authorisations, and new authorisations can be set in advance of
+     * an ownership transfer if desired.
+     *
+     * @param node The name to change the authorisation on.
+     * @param target The address that is to be authorised or deauthorised.
+     * @param isAuthorised True if the address should be authorised, or false if it should be deauthorised.
+     */
+    function setAuthorisation(
+        bytes32 node,
+        address target,
+        bool isAuthorised
+    ) external;
+
+    function multicall(bytes[] calldata data)
+        external
+        returns (bytes[] memory results);
+}

vendor/github.com/status-im/status-go/contracts/snt/address.go

@@ -0,0 +1,22 @@
+package snt
+
+import (
+	"errors"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+var errorNotAvailableOnChainID = errors.New("not available for chainID")
+
+var contractAddressByChainID = map[uint64]common.Address{
+	1: common.HexToAddress("0x744d70fdbe2ba4cf95131626614a1763df805b9e"), // mainnet
+	5: common.HexToAddress("0x3d6afaa395c31fcd391fe3d562e75fe9e8ec7e6a"), // goerli
+}
+
+func ContractAddress(chainID uint64) (common.Address, error) {
+	addr, exists := contractAddressByChainID[chainID]
+	if !exists {
+		return *new(common.Address), errorNotAvailableOnChainID
+	}
+	return addr, nil
+}

vendor/github.com/status-im/status-go/contracts/snt/doc.go

@@ -0,0 +1,3 @@
+package snt
+
+//go:generate abigen -sol snt.sol -pkg snt -out snt.go

vendor/github.com/status-im/status-go/contracts/snt/snt.sol

@@ -0,0 +1,412 @@
+// This solidity file was added to the project to generate the ABI to consume
+// the smart contract deployed at 0x744d70fdbe2ba4cf95131626614a1763df805b9e
+
+pragma solidity ^0.4.11;
+
+// Abstract contract for the full ERC 20 Token standard
+// https://github.com/ethereum/EIPs/issues/20
+
+contract ERC20Token {
+    /* This is a slight change to the ERC20 base standard.
+    function totalSupply() constant returns (uint256 supply);
+    is replaced with:
+    uint256 public totalSupply;
+    This automatically creates a getter function for the totalSupply.
+    This is moved to the base contract since public getter functions are not
+    currently recognised as an implementation of the matching abstract
+    function by the compiler.
+    */
+    /// total amount of tokens
+    uint256 public totalSupply;
+
+    /// @param _owner The address from which the balance will be retrieved
+    /// @return The balance
+    function balanceOf(address _owner) constant returns (uint256 balance);
+
+    /// @notice send `_value` token to `_to` from `msg.sender`
+    /// @param _to The address of the recipient
+    /// @param _value The amount of token to be transferred
+    /// @return Whether the transfer was successful or not
+    function transfer(address _to, uint256 _value) returns (bool success);
+
+    /// @notice send `_value` token to `_to` from `_from` on the condition it is approved by `_from`
+    /// @param _from The address of the sender
+    /// @param _to The address of the recipient
+    /// @param _value The amount of token to be transferred
+    /// @return Whether the transfer was successful or not
+    function transferFrom(
+        address _from,
+        address _to,
+        uint256 _value
+    ) returns (bool success);
+
+    /// @notice `msg.sender` approves `_spender` to spend `_value` tokens
+    /// @param _spender The address of the account able to transfer the tokens
+    /// @param _value The amount of tokens to be approved for transfer
+    /// @return Whether the approval was successful or not
+    function approve(address _spender, uint256 _value) returns (bool success);
+
+    /// @param _owner The address of the account owning tokens
+    /// @param _spender The address of the account able to transfer the tokens
+    /// @return Amount of remaining tokens allowed to spent
+    function allowance(address _owner, address _spender)
+        constant
+        returns (uint256 remaining);
+
+    event Transfer(address indexed _from, address indexed _to, uint256 _value);
+    event Approval(
+        address indexed _owner,
+        address indexed _spender,
+        uint256 _value
+    );
+}
+
+/*
+    Copyright 2016, Jordi Baylina
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/// @title MiniMeToken Contract
+/// @author Jordi Baylina
+/// @dev This token contract's goal is to make it easy for anyone to clone this
+///  token using the token distribution at a given block, this will allow DAO's
+///  and DApps to upgrade their features in a decentralized manner without
+///  affecting the original token
+/// @dev It is ERC20 compliant, but still needs to under go further testing.
+
+/// @dev The token controller contract must implement these functions
+contract TokenController {
+    /// @notice Called when `_owner` sends ether to the MiniMe Token contract
+    /// @param _owner The address that sent the ether to create tokens
+    /// @return True if the ether is accepted, false if it throws
+    function proxyPayment(address _owner) payable returns (bool);
+
+    /// @notice Notifies the controller about a token transfer allowing the
+    ///  controller to react if desired
+    /// @param _from The origin of the transfer
+    /// @param _to The destination of the transfer
+    /// @param _amount The amount of the transfer
+    /// @return False if the controller does not authorize the transfer
+    function onTransfer(
+        address _from,
+        address _to,
+        uint256 _amount
+    ) returns (bool);
+
+    /// @notice Notifies the controller about an approval allowing the
+    ///  controller to react if desired
+    /// @param _owner The address that calls `approve()`
+    /// @param _spender The spender in the `approve()` call
+    /// @param _amount The amount in the `approve()` call
+    /// @return False if the controller does not authorize the approval
+    function onApprove(
+        address _owner,
+        address _spender,
+        uint256 _amount
+    ) returns (bool);
+}
+
+contract Controlled {
+    address public controller;
+
+    function Controlled() {}
+
+    /// @notice Changes the controller of the contract
+    /// @param _newController The new controller of the contract
+    function changeController(address _newController) {}
+}
+
+contract ApproveAndCallFallBack {
+    function receiveApproval(
+        address from,
+        uint256 _amount,
+        address _token,
+        bytes _data
+    );
+}
+
+/// @dev The actual token contract, the default controller is the msg.sender
+///  that deploys the contract, so usually this token will be deployed by a
+///  token controller contract, which Giveth will call a "Campaign"
+contract MiniMeToken is Controlled {
+    string public name; //The Token's name: e.g. DigixDAO Tokens
+    uint8 public decimals; //Number of decimals of the smallest unit
+    string public symbol; //An identifier: e.g. REP
+    string public version = "MMT_0.1"; //An arbitrary versioning scheme
+
+    /// @dev `Checkpoint` is the structure that attaches a block number to a
+    ///  given value, the block number attached is the one that last changed the
+    ///  value
+    struct Checkpoint {
+        // `fromBlock` is the block number that the value was generated from
+        uint128 fromBlock;
+        // `value` is the amount of tokens at a specific block number
+        uint128 value;
+    }
+
+    // `parentToken` is the Token address that was cloned to produce this token;
+    //  it will be 0x0 for a token that was not cloned
+    MiniMeToken public parentToken;
+
+    // `parentSnapShotBlock` is the block number from the Parent Token that was
+    //  used to determine the initial distribution of the Clone Token
+    uint256 public parentSnapShotBlock;
+
+    // `creationBlock` is the block number that the Clone Token was created
+    uint256 public creationBlock;
+
+    // `balances` is the map that tracks the balance of each address, in this
+    //  contract when the balance changes the block number that the change
+    //  occurred is also included in the map
+    mapping(address => Checkpoint[]) balances;
+
+    // `allowed` tracks any extra transfer rights as in all ERC20 tokens
+    mapping(address => mapping(address => uint256)) allowed;
+
+    // Tracks the history of the `totalSupply` of the token
+    Checkpoint[] totalSupplyHistory;
+
+    // Flag that determines if the token is transferable or not.
+    bool public transfersEnabled;
+
+    // The factory used to create new clone tokens
+    MiniMeTokenFactory public tokenFactory;
+
+    ////////////////
+    // Constructor
+    ////////////////
+
+    /// @notice Constructor to create a MiniMeToken
+    /// @param _tokenFactory The address of the MiniMeTokenFactory contract that
+    ///  will create the Clone token contracts, the token factory needs to be
+    ///  deployed first
+    /// @param _parentToken Address of the parent token, set to 0x0 if it is a
+    ///  new token
+    /// @param _parentSnapShotBlock Block of the parent token that will
+    ///  determine the initial distribution of the clone token, set to 0 if it
+    ///  is a new token
+    /// @param _tokenName Name of the new token
+    /// @param _decimalUnits Number of decimals of the new token
+    /// @param _tokenSymbol Token Symbol for the new token
+    /// @param _transfersEnabled If true, tokens will be able to be transferred
+    function MiniMeToken(
+        address _tokenFactory,
+        address _parentToken,
+        uint256 _parentSnapShotBlock,
+        string _tokenName,
+        uint8 _decimalUnits,
+        string _tokenSymbol,
+        bool _transfersEnabled
+    ) {}
+
+    ///////////////////
+    // ERC20 Methods
+    ///////////////////
+
+    /// @notice Send `_amount` tokens to `_to` from `msg.sender`
+    /// @param _to The address of the recipient
+    /// @param _amount The amount of tokens to be transferred
+    /// @return Whether the transfer was successful or not
+    function transfer(address _to, uint256 _amount) returns (bool success) {}
+
+    /// @notice Send `_amount` tokens to `_to` from `_from` on the condition it
+    ///  is approved by `_from`
+    /// @param _from The address holding the tokens being transferred
+    /// @param _to The address of the recipient
+    /// @param _amount The amount of tokens to be transferred
+    /// @return True if the transfer was successful
+    function transferFrom(
+        address _from,
+        address _to,
+        uint256 _amount
+    ) returns (bool success) {}
+
+    /// @param _owner The address that's balance is being requested
+    /// @return The balance of `_owner` at the current block
+    function balanceOf(address _owner) constant returns (uint256 balance) {}
+
+    /// @notice `msg.sender` approves `_spender` to spend `_amount` tokens on
+    ///  its behalf. This is a modified version of the ERC20 approve function
+    ///  to be a little bit safer
+    /// @param _spender The address of the account able to transfer the tokens
+    /// @param _amount The amount of tokens to be approved for transfer
+    /// @return True if the approval was successful
+    function approve(address _spender, uint256 _amount)
+        returns (bool success)
+    {}
+
+    /// @dev This function makes it easy to read the `allowed[]` map
+    /// @param _owner The address of the account that owns the token
+    /// @param _spender The address of the account able to transfer the tokens
+    /// @return Amount of remaining tokens of _owner that _spender is allowed
+    ///  to spend
+    function allowance(address _owner, address _spender)
+        constant
+        returns (uint256 remaining)
+    {}
+
+    /// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
+    ///  its behalf, and then a function is triggered in the contract that is
+    ///  being approved, `_spender`. This allows users to use their tokens to
+    ///  interact with contracts in one function call instead of two
+    /// @param _spender The address of the contract able to transfer the tokens
+    /// @param _amount The amount of tokens to be approved for transfer
+    /// @return True if the function call was successful
+    function approveAndCall(
+        address _spender,
+        uint256 _amount,
+        bytes _extraData
+    ) returns (bool success) {}
+
+    /// @dev This function makes it easy to get the total number of tokens
+    /// @return The total number of tokens
+    function totalSupply() constant returns (uint256) {}
+
+    ////////////////
+    // Query balance and totalSupply in History
+    ////////////////
+
+    /// @dev Queries the balance of `_owner` at a specific `_blockNumber`
+    /// @param _owner The address from which the balance will be retrieved
+    /// @param _blockNumber The block number when the balance is queried
+    /// @return The balance at `_blockNumber`
+    function balanceOfAt(address _owner, uint256 _blockNumber)
+        constant
+        returns (uint256)
+    {}
+
+    /// @notice Total amount of tokens at a specific `_blockNumber`.
+    /// @param _blockNumber The block number when the totalSupply is queried
+    /// @return The total amount of tokens at `_blockNumber`
+    function totalSupplyAt(uint256 _blockNumber) constant returns (uint256) {}
+
+    ////////////////
+    // Clone Token Method
+    ////////////////
+
+    /// @notice Creates a new clone token with the initial distribution being
+    ///  this token at `_snapshotBlock`
+    /// @param _cloneTokenName Name of the clone token
+    /// @param _cloneDecimalUnits Number of decimals of the smallest unit
+    /// @param _cloneTokenSymbol Symbol of the clone token
+    /// @param _snapshotBlock Block when the distribution of the parent token is
+    ///  copied to set the initial distribution of the new clone token;
+    ///  if the block is zero than the actual block, the current block is used
+    /// @param _transfersEnabled True if transfers are allowed in the clone
+    /// @return The address of the new MiniMeToken Contract
+    function createCloneToken(
+        string _cloneTokenName,
+        uint8 _cloneDecimalUnits,
+        string _cloneTokenSymbol,
+        uint256 _snapshotBlock,
+        bool _transfersEnabled
+    ) returns (address) {}
+
+    ////////////////
+    // Generate and destroy tokens
+    ////////////////
+
+    /// @notice Generates `_amount` tokens that are assigned to `_owner`
+    /// @param _owner The address that will be assigned the new tokens
+    /// @param _amount The quantity of tokens generated
+    /// @return True if the tokens are generated correctly
+    function generateTokens(address _owner, uint256 _amount) returns (bool) {}
+
+    /// @notice Burns `_amount` tokens from `_owner`
+    /// @param _owner The address that will lose the tokens
+    /// @param _amount The quantity of tokens to burn
+    /// @return True if the tokens are burned correctly
+    function destroyTokens(address _owner, uint256 _amount) returns (bool) {}
+
+    ////////////////
+    // Enable tokens transfers
+    ////////////////
+
+    /// @notice Enables token holders to transfer their tokens freely if true
+    /// @param _transfersEnabled True if transfers are allowed in the clone
+    function enableTransfers(bool _transfersEnabled) {}
+
+    /// @dev Helper function to return a min betwen the two uints
+    function min(uint256 a, uint256 b) internal returns (uint256) {
+        return a < b ? a : b;
+    }
+
+    /// @notice The fallback function: If the contract's controller has not been
+    ///  set to 0, then the `proxyPayment` method is called which relays the
+    ///  ether and creates tokens as described in the token controller contract
+    function() payable {}
+
+    //////////
+    // Safety Methods
+    //////////
+
+    /// @notice This method can be used by the controller to extract mistakenly
+    ///  sent tokens to this contract.
+    /// @param _token The address of the token contract that you want to recover
+    ///  set to 0 in case you want to extract ether.
+    function claimTokens(address _token) {}
+
+    ////////////////
+    // Events
+    ////////////////
+
+    event ClaimedTokens(
+        address indexed _token,
+        address indexed _controller,
+        uint256 _amount
+    );
+    event Transfer(address indexed _from, address indexed _to, uint256 _amount);
+    event NewCloneToken(address indexed _cloneToken, uint256 _snapshotBlock);
+    event Approval(
+        address indexed _owner,
+        address indexed _spender,
+        uint256 _amount
+    );
+}
+
+////////////////
+// MiniMeTokenFactory
+////////////////
+
+/// @dev This contract is used to generate clone contracts from a contract.
+///  In solidity this is the way to create a contract from a contract of the
+///  same class
+contract MiniMeTokenFactory {
+    /// @notice Update the DApp by creating a new token with new functionalities
+    ///  the msg.sender becomes the controller of this clone token
+    /// @param _parentToken Address of the token being cloned
+    /// @param _snapshotBlock Block of the parent token that will
+    ///  determine the initial distribution of the clone token
+    /// @param _tokenName Name of the new token
+    /// @param _decimalUnits Number of decimals of the new token
+    /// @param _tokenSymbol Token Symbol for the new token
+    /// @param _transfersEnabled If true, tokens will be able to be transferred
+    /// @return The address of the new token contract
+    function createCloneToken(
+        address _parentToken,
+        uint256 _snapshotBlock,
+        string _tokenName,
+        uint8 _decimalUnits,
+        string _tokenSymbol,
+        bool _transfersEnabled
+    ) returns (MiniMeToken);
+}
+
+/*
+    Copyright 2017, Jarrad Hope (Status Research & Development GmbH)
+*/
+contract SNT is MiniMeToken {
+
+}

vendor/github.com/status-im/status-go/contracts/stickers/address.go

@@ -0,0 +1,51 @@
+package stickers
+
+import (
+	"errors"
+
+	"github.com/ethereum/go-ethereum/common"
+)
+
+var errorNotAvailableOnChainID = errors.New("not available for chainID")
+
+var stickerTypeByChainID = map[uint64]common.Address{
+	1:        common.HexToAddress("0x0577215622f43a39f4bc9640806dfea9b10d2a36"), // mainnet
+	5:        common.HexToAddress("0x07f7CB0C0a4ab3e0999AfE8b3997Da34880f05d0"), // goerli testnet
+	11155111: common.HexToAddress("0x5acbae26c23427aeee0a7f26949f093577a61aab"), // sepolia testnet
+}
+
+var stickerMarketByChainID = map[uint64]common.Address{
+	1:        common.HexToAddress("0x12824271339304d3a9f7e096e62a2a7e73b4a7e7"), // mainnet
+	5:        common.HexToAddress("0xf1E149A7DF70D5Ff1E265daAa738d785D3274717"), // goerli testnet
+	11155111: common.HexToAddress("0xf852198d0385c4b871e0b91804ecd47c6ba97351"), // sepolia testnet
+}
+
+var stickerPackByChainID = map[uint64]common.Address{
+	1:        common.HexToAddress("0x110101156e8F0743948B2A61aFcf3994A8Fb172e"), // mainnet
+	5:        common.HexToAddress("0x8D3fD2EA24bD53a8Bd2b1026727db8bbe9A8C8Af"), // goerli testnet
+	11155111: common.HexToAddress("0x8cc272396be7583c65bee82cd7b743c69a87287d"), // sepolia testnet
+}
+
+func StickerTypeContractAddress(chainID uint64) (common.Address, error) {
+	addr, exists := stickerTypeByChainID[chainID]
+	if !exists {
+		return *new(common.Address), errorNotAvailableOnChainID
+	}
+	return addr, nil
+}
+
+func StickerMarketContractAddress(chainID uint64) (common.Address, error) {
+	addr, exists := stickerMarketByChainID[chainID]
+	if !exists {
+		return *new(common.Address), errorNotAvailableOnChainID
+	}
+	return addr, nil
+}
+
+func StickerPackContractAddress(chainID uint64) (common.Address, error) {
+	addr, exists := stickerPackByChainID[chainID]
+	if !exists {
+		return *new(common.Address), errorNotAvailableOnChainID
+	}
+	return addr, nil
+}

vendor/github.com/status-im/status-go/contracts/stickers/contracts.sol

@@ -0,0 +1,771 @@
+// This solidity file was added to the project to generate the ABI to consume
+// these smart contracts:
+// 0x0577215622f43a39f4bc9640806dfea9b10d2a36: StickerType
+// 0x12824271339304d3a9f7e096e62a2a7e73b4a7e7: StickerMarket
+// 0x110101156e8F0743948B2A61aFcf3994A8Fb172e: StickerPack
+
+pragma solidity ^0.5.0;
+
+contract Controlled {
+    event NewController(address controller);
+
+    address payable public controller;
+
+    /// @notice Changes the controller of the contract
+    /// @param _newController The new controller of the contract
+    function changeController(address payable _newController) public;
+}
+
+/**
+ * @dev Interface of the ERC165 standard, as defined in the
+ * [EIP](https://eips.ethereum.org/EIPS/eip-165).
+ *
+ * Implementers can declare support of contract interfaces, which can then be
+ * queried by others (`ERC165Checker`).
+ *
+ * For an implementation, see `ERC165`.
+ */
+interface IERC165 {
+    /**
+     * @dev Returns true if this contract implements the interface defined by
+     * `interfaceId`. See the corresponding
+     * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
+     * to learn more about how these ids are created.
+     *
+     * This function call must use less than 30 000 gas.
+     */
+    function supportsInterface(bytes4 interfaceId) external view returns (bool);
+}
+
+/**
+ * @title ERC721 token receiver interface
+ * @dev Interface for any contract that wants to support safeTransfers
+ * from ERC721 asset contracts.
+ */
+contract IERC721Receiver {
+    /**
+     * @notice Handle the receipt of an NFT
+     * @dev The ERC721 smart contract calls this function on the recipient
+     * after a `safeTransfer`. This function MUST return the function selector,
+     * otherwise the caller will revert the transaction. The selector to be
+     * returned can be obtained as `this.onERC721Received.selector`. This
+     * function MAY throw to revert and reject the transfer.
+     * Note: the ERC721 contract address is always the message sender.
+     * @param operator The address which called `safeTransferFrom` function
+     * @param from The address which previously owned the token
+     * @param tokenId The NFT identifier which is being transferred
+     * @param data Additional data with no specified format
+     * @return bytes4 `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
+     */
+    function onERC721Received(
+        address operator,
+        address from,
+        uint256 tokenId,
+        bytes memory data
+    ) public returns (bytes4);
+}
+
+/**
+ * @dev Implementation of the `IERC165` interface.
+ *
+ * Contracts may inherit from this and call `_registerInterface` to declare
+ * their support of an interface.
+ */
+contract ERC165 is IERC165 {
+    /**
+     * @dev See `IERC165.supportsInterface`.
+     *
+     * Time complexity O(1), guaranteed to always use less than 30 000 gas.
+     */
+    function supportsInterface(bytes4 interfaceId) external view returns (bool);
+}
+
+
+/**
+ * @dev Required interface of an ERC721 compliant contract.
+ */
+contract IERC721 is IERC165 {
+    event Transfer(
+        address indexed from,
+        address indexed to,
+        uint256 indexed tokenId
+    );
+    event Approval(
+        address indexed owner,
+        address indexed approved,
+        uint256 indexed tokenId
+    );
+    event ApprovalForAll(
+        address indexed owner,
+        address indexed operator,
+        bool approved
+    );
+
+    /**
+     * @dev Returns the number of NFTs in `owner`'s account.
+     */
+    function balanceOf(address owner) public view returns (uint256 balance);
+
+    /**
+     * @dev Returns the owner of the NFT specified by `tokenId`.
+     */
+    function ownerOf(uint256 tokenId) public view returns (address owner);
+
+    /**
+     * @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
+     * another (`to`).
+     *
+     *
+     *
+     * Requirements:
+     * - `from`, `to` cannot be zero.
+     * - `tokenId` must be owned by `from`.
+     * - If the caller is not `from`, it must be have been allowed to move this
+     * NFT by either `approve` or `setApproveForAll`.
+     */
+    function safeTransferFrom(
+        address from,
+        address to,
+        uint256 tokenId
+    ) public;
+
+    /**
+     * @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
+     * another (`to`).
+     *
+     * Requirements:
+     * - If the caller is not `from`, it must be approved to move this NFT by
+     * either `approve` or `setApproveForAll`.
+     */
+    function transferFrom(
+        address from,
+        address to,
+        uint256 tokenId
+    ) public;
+
+    function approve(address to, uint256 tokenId) public;
+
+    function getApproved(uint256 tokenId)
+        public
+        view
+        returns (address operator);
+
+    function setApprovalForAll(address operator, bool _approved) public;
+
+    function isApprovedForAll(address owner, address operator)
+        public
+        view
+        returns (bool);
+
+    function safeTransferFrom(
+        address from,
+        address to,
+        uint256 tokenId,
+        bytes memory data
+    ) public;
+}
+
+/**
+ * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
+ * @dev See https://eips.ethereum.org/EIPS/eip-721
+ */
+contract IERC721Enumerable is IERC721 {
+    function totalSupply() public view returns (uint256);
+
+    function tokenOfOwnerByIndex(address owner, uint256 index)
+        public
+        view
+        returns (uint256 tokenId);
+
+    function tokenByIndex(uint256 index) public view returns (uint256);
+}
+
+/**
+ * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
+ * @dev See https://eips.ethereum.org/EIPS/eip-721
+ */
+contract IERC721Metadata is IERC721 {
+    function name() external view returns (string memory);
+
+    function symbol() external view returns (string memory);
+
+    function tokenURI(uint256 tokenId) external view returns (string memory);
+}
+
+contract TokenClaimer {
+    event ClaimedTokens(
+        address indexed _token,
+        address indexed _controller,
+        uint256 _amount
+    );
+
+    function claimTokens(address _token) external;
+}
+
+/**
+ * @title ERC721 Non-Fungible Token Standard basic implementation
+ * @dev see https://eips.ethereum.org/EIPS/eip-721
+ */
+contract ERC721 is ERC165, IERC721 {
+    /**
+     * @dev Gets the balance of the specified address.
+     * @param owner address to query the balance of
+     * @return uint256 representing the amount owned by the passed address
+     */
+    function balanceOf(address owner) public view returns (uint256);
+
+    /**
+     * @dev Gets the owner of the specified token ID.
+     * @param tokenId uint256 ID of the token to query the owner of
+     * @return address currently marked as the owner of the given token ID
+     */
+    function ownerOf(uint256 tokenId) public view returns (address);
+
+    /**
+     * @dev Approves another address to transfer the given token ID
+     * The zero address indicates there is no approved address.
+     * There can only be one approved address per token at a given time.
+     * Can only be called by the token owner or an approved operator.
+     * @param to address to be approved for the given token ID
+     * @param tokenId uint256 ID of the token to be approved
+     */
+    function approve(address to, uint256 tokenId) public;
+
+    /**
+     * @dev Gets the approved address for a token ID, or zero if no address set
+     * Reverts if the token ID does not exist.
+     * @param tokenId uint256 ID of the token to query the approval of
+     * @return address currently approved for the given token ID
+     */
+    function getApproved(uint256 tokenId) public view returns (address);
+
+    /**
+     * @dev Sets or unsets the approval of a given operator
+     * An operator is allowed to transfer all tokens of the sender on their behalf.
+     * @param to operator address to set the approval
+     * @param approved representing the status of the approval to be set
+     */
+    function setApprovalForAll(address to, bool approved) public;
+
+    /**
+     * @dev Tells whether an operator is approved by a given owner.
+     * @param owner owner address which you want to query the approval of
+     * @param operator operator address which you want to query the approval of
+     * @return bool whether the given operator is approved by the given owner
+     */
+    function isApprovedForAll(address owner, address operator)
+        public
+        view
+        returns (bool);
+
+    /**
+     * @dev Transfers the ownership of a given token ID to another address.
+     * Usage of this method is discouraged, use `safeTransferFrom` whenever possible.
+     * Requires the msg.sender to be the owner, approved, or operator.
+     * @param from current owner of the token
+     * @param to address to receive the ownership of the given token ID
+     * @param tokenId uint256 ID of the token to be transferred
+     */
+    function transferFrom(
+        address from,
+        address to,
+        uint256 tokenId
+    ) public;
+
+    /**
+     * @dev Safely transfers the ownership of a given token ID to another address
+     * If the target address is a contract, it must implement `onERC721Received`,
+     * which is called upon a safe transfer, and return the magic value
+     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
+     * the transfer is reverted.
+     * Requires the msg.sender to be the owner, approved, or operator
+     * @param from current owner of the token
+     * @param to address to receive the ownership of the given token ID
+     * @param tokenId uint256 ID of the token to be transferred
+     */
+    function safeTransferFrom(
+        address from,
+        address to,
+        uint256 tokenId
+    ) public;
+
+    /**
+     * @dev Safely transfers the ownership of a given token ID to another address
+     * If the target address is a contract, it must implement `onERC721Received`,
+     * which is called upon a safe transfer, and return the magic value
+     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
+     * the transfer is reverted.
+     * Requires the msg.sender to be the owner, approved, or operator
+     * @param from current owner of the token
+     * @param to address to receive the ownership of the given token ID
+     * @param tokenId uint256 ID of the token to be transferred
+     * @param _data bytes data to send along with a safe transfer check
+     */
+    function safeTransferFrom(
+        address from,
+        address to,
+        uint256 tokenId,
+        bytes memory _data
+    ) public;
+}
+
+/**
+ * @title ERC-721 Non-Fungible Token Standard, full implementation interface
+ * @dev See https://eips.ethereum.org/EIPS/eip-721
+ */
+contract IERC721Full is IERC721, IERC721Enumerable, IERC721Metadata {
+    // solhint-disable-previous-line no-empty-blocks
+}
+
+/**
+ * @title ERC-721 Non-Fungible Token with optional enumeration extension logic
+ * @dev See https://eips.ethereum.org/EIPS/eip-721
+ */
+contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
+    /**
+     * @dev Gets the token ID at a given index of the tokens list of the requested owner.
+     * @param owner address owning the tokens list to be accessed
+     * @param index uint256 representing the index to be accessed of the requested tokens list
+     * @return uint256 token ID at the given index of the tokens list owned by the requested address
+     */
+    function tokenOfOwnerByIndex(address owner, uint256 index)
+        public
+        view
+        returns (uint256);
+
+    /**
+     * @dev Gets the total amount of tokens stored by the contract.
+     * @return uint256 representing the total amount of tokens
+     */
+    function totalSupply() public view returns (uint256);
+
+    /**
+     * @dev Gets the token ID at a given index of all the tokens in this contract
+     * Reverts if the index is greater or equal to the total number of tokens.
+     * @param index uint256 representing the index to be accessed of the tokens list
+     * @return uint256 token ID at the given index of the tokens list
+     */
+    function tokenByIndex(uint256 index) public view returns (uint256);
+}
+
+contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
+    /**
+     * @dev Gets the token name.
+     * @return string representing the token name
+     */
+    function name() external view returns (string memory);
+
+    /**
+     * @dev Gets the token symbol.
+     * @return string representing the token symbol
+     */
+    function symbol() external view returns (string memory);
+
+    /**
+     * @dev Returns an URI for a given token ID.
+     * Throws if the token ID does not exist. May return an empty string.
+     * @param tokenId uint256 ID of the token to query
+     */
+    function tokenURI(uint256 tokenId) external view returns (string memory);
+}
+
+/**
+ * @title Full ERC721 Token
+ * This implementation includes all the required and some optional functionality of the ERC721 standard
+ * Moreover, it includes approve all functionality using operator terminology
+ * @dev see https://eips.ethereum.org/EIPS/eip-721
+ */
+contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
+
+}
+
+/**
+ * @author Ricardo Guilherme Schmidt (Status Research & Development GmbH)
+ */
+contract StickerPack is Controlled, TokenClaimer, ERC721Full {
+    mapping(uint256 => uint256) public tokenPackId; //packId
+    uint256 public tokenCount; //tokens buys
+
+    /**
+     * @notice controller can generate tokens at will
+     * @param _owner account being included new token
+     * @param _packId pack being minted
+     * @return tokenId created
+     */
+    function generateToken(address _owner, uint256 _packId)
+        external
+        returns (uint256 tokenId);
+
+    /**
+     * @notice This method can be used by the controller to extract mistakenly
+     *  sent tokens to this contract.
+     * @param _token The address of the token contract that you want to recover
+     *  set to 0 in case you want to extract ether.
+     */
+    function claimTokens(address _token) external;
+}
+
+interface ApproveAndCallFallBack {
+    function receiveApproval(
+        address from,
+        uint256 _amount,
+        address _token,
+        bytes calldata _data
+    ) external;
+}
+
+/**
+ * @author Ricardo Guilherme Schmidt (Status Research & Development GmbH)
+ * StickerMarket allows any address register "StickerPack" which can be sold to any address in form of "StickerPack", an ERC721 token.
+ */
+contract StickerMarket is Controlled, TokenClaimer, ApproveAndCallFallBack {
+    event ClaimedTokens(
+        address indexed _token,
+        address indexed _controller,
+        uint256 _amount
+    );
+    event MarketState(State state);
+    event RegisterFee(uint256 value);
+    event BurnRate(uint256 value);
+
+    enum State {
+        Invalid,
+        Open,
+        BuyOnly,
+        Controlled,
+        Closed
+    }
+
+    State public state = State.Open;
+    uint256 registerFee;
+    uint256 burnRate;
+
+    //include global var to set burn rate/percentage
+    address public snt; //payment token
+    StickerPack public stickerPack;
+    StickerType public stickerType;
+
+    /**
+     * @dev Mints NFT StickerPack in `msg.sender` account, and Transfers SNT using user allowance
+     * emit NonfungibleToken.Transfer(`address(0)`, `msg.sender`, `tokenId`)
+     * @notice buy a pack from market pack owner, including a StickerPack's token in msg.sender account with same metadata of `_packId`
+     * @param _packId id of market pack
+     * @param _destination owner of token being brought
+     * @param _price agreed price
+     * @return tokenId generated StickerPack token
+     */
+    function buyToken(
+        uint256 _packId,
+        address _destination,
+        uint256 _price
+    ) external returns (uint256 tokenId);
+
+    /**
+     * @dev emits StickerMarket.Register(`packId`, `_urlHash`, `_price`, `_contenthash`)
+     * @notice Registers to sell a sticker pack
+     * @param _price cost in wei to users minting this pack
+     * @param _donate value between 0-10000 representing percentage of `_price` that is donated to StickerMarket at every buy
+     * @param _category listing category
+     * @param _owner address of the beneficiary of buys
+     * @param _contenthash EIP1577 pack contenthash for listings
+     * @param _fee Fee msg.sender agrees to pay for this registration
+     * @return packId Market position of Sticker Pack data.
+     */
+    function registerPack(
+        uint256 _price,
+        uint256 _donate,
+        bytes4[] calldata _category,
+        address _owner,
+        bytes calldata _contenthash,
+        uint256 _fee
+    ) external returns (uint256 packId);
+
+    /**
+     * @notice MiniMeToken ApproveAndCallFallBack forwarder for registerPack and buyToken
+     * @param _from account calling "approve and buy"
+     * @param _value must be exactly whats being consumed
+     * @param _token must be exactly SNT contract
+     * @param _data abi encoded call
+     */
+    function receiveApproval(
+        address _from,
+        uint256 _value,
+        address _token,
+        bytes calldata _data
+    ) external;
+
+    /**
+     * @notice changes market state, only controller can call.
+     * @param _state new state
+     */
+    function setMarketState(State _state) external;
+
+    /**
+     * @notice changes register fee, only controller can call.
+     * @param _value total SNT cost of registration
+     */
+    function setRegisterFee(uint256 _value) external;
+
+    /**
+     * @notice changes burn rate percentage, only controller can call.
+     * @param _value new value between 0 and 10000
+     */
+    function setBurnRate(uint256 _value) external;
+
+    /**
+     * @notice controller can generate packs at will
+     * @param _price cost in wei to users minting with _urlHash metadata
+     * @param _donate optional amount of `_price` that is donated to StickerMarket at every buy
+     * @param _category listing category
+     * @param _owner address of the beneficiary of buys
+     * @param _contenthash EIP1577 pack contenthash for listings
+     * @return packId Market position of Sticker Pack data.
+     */
+    function generatePack(
+        uint256 _price,
+        uint256 _donate,
+        bytes4[] calldata _category,
+        address _owner,
+        bytes calldata _contenthash
+    ) external returns (uint256 packId);
+
+    /**
+     * @notice removes all market data about a marketed pack, can only be called by market controller
+     * @param _packId pack being purged
+     * @param _limit limits categories being purged
+     */
+    function purgePack(uint256 _packId, uint256 _limit) external;
+
+    /**
+     * @notice controller can generate tokens at will
+     * @param _owner account being included new token
+     * @param _packId pack being minted
+     * @return tokenId created
+     */
+    function generateToken(address _owner, uint256 _packId)
+        external
+        returns (uint256 tokenId);
+
+    /**
+     * @notice Change controller of stickerType
+     * @param _newController new controller of stickerType.
+     */
+    function migrate(address payable _newController) external;
+
+    /**
+     * @notice This method can be used by the controller to extract mistakenly
+     *  sent tokens to this contract.
+     * @param _token The address of the token contract that you want to recover
+     *  set to 0 in case you want to extract ether.
+     */
+    function claimTokens(address _token) external;
+
+    /**
+     * @notice returns pack data of token
+     * @param _tokenId user token being queried
+     * @return categories, registration time and contenthash
+     */
+    function getTokenData(uint256 _tokenId)
+        external
+        view
+        returns (
+            bytes4[] memory category,
+            uint256 timestamp,
+            bytes memory contenthash
+        );
+
+    // For ABI/web3.js purposes
+    // fired by StickerType
+    event Register(
+        uint256 indexed packId,
+        uint256 dataPrice,
+        bytes contenthash
+    );
+    // fired by StickerPack and MiniMeToken
+    event Transfer(
+        address indexed from,
+        address indexed to,
+        uint256 indexed value
+    );
+}
+
+/**
+ * @author Ricardo Guilherme Schmidt (Status Research & Development GmbH)
+ * StickerMarket allows any address register "StickerPack" which can be sold to any address in form of "StickerPack", an ERC721 token.
+ */
+contract StickerType is Controlled, TokenClaimer, ERC721Full {
+    event Register(
+        uint256 indexed packId,
+        uint256 dataPrice,
+        bytes contenthash,
+        bool mintable
+    );
+    event PriceChanged(uint256 indexed packId, uint256 dataPrice);
+    event MintabilityChanged(uint256 indexed packId, bool mintable);
+    event ContenthashChanged(uint256 indexed packid, bytes contenthash);
+    event Categorized(bytes4 indexed category, uint256 indexed packId);
+    event Uncategorized(bytes4 indexed category, uint256 indexed packId);
+    event Unregister(uint256 indexed packId);
+
+    struct Pack {
+        bytes4[] category;
+        bool mintable;
+        uint256 timestamp;
+        uint256 price; //in "wei"
+        uint256 donate; //in "percent"
+        bytes contenthash;
+    }
+
+    mapping(uint256 => Pack) public packs;
+    uint256 public packCount; //pack registers
+
+    /**
+     * @notice controller can generate packs at will
+     * @param _price cost in wei to users minting with _urlHash metadata
+     * @param _donate optional amount of `_price` that is donated to StickerMarket at every buy
+     * @param _category listing category
+     * @param _owner address of the beneficiary of buys
+     * @param _contenthash EIP1577 pack contenthash for listings
+     * @return packId Market position of Sticker Pack data.
+     */
+    function generatePack(
+        uint256 _price,
+        uint256 _donate,
+        bytes4[] calldata _category,
+        address _owner,
+        bytes calldata _contenthash
+    ) external returns (uint256 packId);
+
+    /**
+     * @notice removes all market data about a marketed pack, can only be called by market controller
+     * @param _packId position to be deleted
+     * @param _limit limit of categories to cleanup
+     */
+    function purgePack(uint256 _packId, uint256 _limit) external;
+
+    /**
+     * @notice changes contenthash of `_packId`, can only be called by controller
+     * @param _packId which market position is being altered
+     * @param _contenthash new contenthash
+     */
+    function setPackContenthash(uint256 _packId, bytes calldata _contenthash)
+        external;
+
+    /**
+     * @notice This method can be used by the controller to extract mistakenly
+     *  sent tokens to this contract.
+     * @param _token The address of the token contract that you want to recover
+     *  set to 0 in case you want to extract ether.
+     */
+    function claimTokens(address _token) external;
+
+    /**
+     * @notice changes price of `_packId`, can only be called when market is open
+     * @param _packId pack id changing price settings
+     * @param _price cost in wei to users minting this pack
+     * @param _donate value between 0-10000 representing percentage of `_price` that is donated to StickerMarket at every buy
+     */
+    function setPackPrice(
+        uint256 _packId,
+        uint256 _price,
+        uint256 _donate
+    ) external;
+
+    /**
+     * @notice add caregory in `_packId`, can only be called when market is open
+     * @param _packId pack adding category
+     * @param _category category to list
+     */
+    function addPackCategory(uint256 _packId, bytes4 _category) external;
+
+    /**
+     * @notice remove caregory in `_packId`, can only be called when market is open
+     * @param _packId pack removing category
+     * @param _category category to unlist
+     */
+    function removePackCategory(uint256 _packId, bytes4 _category) external;
+
+    /**
+     * @notice Changes if pack is enabled for sell
+     * @param _packId position edit
+     * @param _mintable true to enable sell
+     */
+    function setPackState(uint256 _packId, bool _mintable) external;
+
+    /**
+     * @notice read available market ids in a category (might be slow)
+     * @param _category listing category
+     * @return array of market id registered
+     */
+    function getAvailablePacks(bytes4 _category)
+        external
+        view
+        returns (uint256[] memory availableIds);
+
+    /**
+     * @notice count total packs in a category
+     * @param _category listing category
+     * @return total number of packs in category
+     */
+    function getCategoryLength(bytes4 _category)
+        external
+        view
+        returns (uint256 size);
+
+    /**
+     * @notice read a packId in the category list at a specific index
+     * @param _category listing category
+     * @param _index index
+     * @return packId on index
+     */
+    function getCategoryPack(bytes4 _category, uint256 _index)
+        external
+        view
+        returns (uint256 packId);
+
+    /**
+     * @notice returns all data from pack in market
+     * @param _packId pack id being queried
+     * @return categories, owner, mintable, price, donate and contenthash
+     */
+    function getPackData(uint256 _packId)
+        external
+        view
+        returns (
+            bytes4[] memory category,
+            address owner,
+            bool mintable,
+            uint256 timestamp,
+            uint256 price,
+            bytes memory contenthash
+        );
+
+    /**
+     * @notice returns all data from pack in market
+     * @param _packId pack id being queried
+     * @return categories, owner, mintable, price, donate and contenthash
+     */
+    function getPackSummary(uint256 _packId)
+        external
+        view
+        returns (
+            bytes4[] memory category,
+            uint256 timestamp,
+            bytes memory contenthash
+        );
+
+    /**
+     * @notice returns payment data for migrated contract
+     * @param _packId pack id being queried
+     * @return owner, mintable, price and donate
+     */
+    function getPaymentData(uint256 _packId)
+        external
+        view
+        returns (
+            address owner,
+            bool mintable,
+            uint256 price,
+            uint256 donate
+        );
+}

vendor/github.com/status-im/status-go/contracts/stickers/doc.go

@@ -0,0 +1,3 @@
+package stickers
+
+//go:generate abigen -sol contracts.sol -pkg stickers -out contracts.go

vendor/github.com/status-im/status-go/contracts/uniswapV2/doc.go

@@ -0,0 +1,3 @@
+package uniswapv2
+
+//go:generate abigen --abi IUniswapV2Pair.abi --pkg uniswapv2 --out uniswapv2pair.go

vendor/github.com/status-im/status-go/contracts/uniswapV3/IUniswapV3PoolActions.abi

@@ -0,0 +1 @@
+[{"inputs":[{"internalType":"int24","name":"tickLower","type":"int24"},{"internalType":"int24","name":"tickUpper","type":"int24"},{"internalType":"uint128","name":"amount","type":"uint128"}],"name":"burn","outputs":[{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"int24","name":"tickLower","type":"int24"},{"internalType":"int24","name":"tickUpper","type":"int24"},{"internalType":"uint128","name":"amount0Requested","type":"uint128"},{"internalType":"uint128","name":"amount1Requested","type":"uint128"}],"name":"collect","outputs":[{"internalType":"uint128","name":"amount0","type":"uint128"},{"internalType":"uint128","name":"amount1","type":"uint128"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"flash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"observationCardinalityNext","type":"uint16"}],"name":"increaseObservationCardinalityNext","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint160","name":"sqrtPriceX96","type":"uint160"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"int24","name":"tickLower","type":"int24"},{"internalType":"int24","name":"tickUpper","type":"int24"},{"internalType":"uint128","name":"amount","type":"uint128"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"mint","outputs":[{"internalType":"uint256","name":"amount0","type":"uint256"},{"internalType":"uint256","name":"amount1","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"bool","name":"zeroForOne","type":"bool"},{"internalType":"int256","name":"amountSpecified","type":"int256"},{"internalType":"uint160","name":"sqrtPriceLimitX96","type":"uint160"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"swap","outputs":[{"internalType":"int256","name":"amount0","type":"int256"},{"internalType":"int256","name":"amount1","type":"int256"}],"stateMutability":"nonpayable","type":"function"}]

vendor/github.com/status-im/status-go/contracts/uniswapV3/IUniswapV3PoolDerivedState.abi

@@ -0,0 +1 @@
+[{"inputs":[{"internalType":"uint32[]","name":"secondsAgos","type":"uint32[]"}],"name":"observe","outputs":[{"internalType":"int56[]","name":"tickCumulatives","type":"int56[]"},{"internalType":"uint160[]","name":"secondsPerLiquidityCumulativeX128s","type":"uint160[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int24","name":"tickLower","type":"int24"},{"internalType":"int24","name":"tickUpper","type":"int24"}],"name":"snapshotCumulativesInside","outputs":[{"internalType":"int56","name":"tickCumulativeInside","type":"int56"},{"internalType":"uint160","name":"secondsPerLiquidityInsideX128","type":"uint160"},{"internalType":"uint32","name":"secondsInside","type":"uint32"}],"stateMutability":"view","type":"function"}]

vendor/github.com/status-im/status-go/contracts/uniswapV3/IUniswapV3PoolEvents.abi

@@ -0,0 +1 @@
+[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"int24","name":"tickLower","type":"int24"},{"indexed":true,"internalType":"int24","name":"tickUpper","type":"int24"},{"indexed":false,"internalType":"uint128","name":"amount","type":"uint128"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":true,"internalType":"int24","name":"tickLower","type":"int24"},{"indexed":true,"internalType":"int24","name":"tickUpper","type":"int24"},{"indexed":false,"internalType":"uint128","name":"amount0","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"amount1","type":"uint128"}],"name":"Collect","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint128","name":"amount0","type":"uint128"},{"indexed":false,"internalType":"uint128","name":"amount1","type":"uint128"}],"name":"CollectProtocol","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"paid0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"paid1","type":"uint256"}],"name":"Flash","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint16","name":"observationCardinalityNextOld","type":"uint16"},{"indexed":false,"internalType":"uint16","name":"observationCardinalityNextNew","type":"uint16"}],"name":"IncreaseObservationCardinalityNext","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint160","name":"sqrtPriceX96","type":"uint160"},{"indexed":false,"internalType":"int24","name":"tick","type":"int24"}],"name":"Initialize","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"int24","name":"tickLower","type":"int24"},{"indexed":true,"internalType":"int24","name":"tickUpper","type":"int24"},{"indexed":false,"internalType":"uint128","name":"amount","type":"uint128"},{"indexed":false,"internalType":"uint256","name":"amount0","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount1","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"feeProtocol0Old","type":"uint8"},{"indexed":false,"internalType":"uint8","name":"feeProtocol1Old","type":"uint8"},{"indexed":false,"internalType":"uint8","name":"feeProtocol0New","type":"uint8"},{"indexed":false,"internalType":"uint8","name":"feeProtocol1New","type":"uint8"}],"name":"SetFeeProtocol","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"int256","name":"amount0","type":"int256"},{"indexed":false,"internalType":"int256","name":"amount1","type":"int256"},{"indexed":false,"internalType":"uint160","name":"sqrtPriceX96","type":"uint160"},{"indexed":false,"internalType":"uint128","name":"liquidity","type":"uint128"},{"indexed":false,"internalType":"int24","name":"tick","type":"int24"}],"name":"Swap","type":"event"}]

vendor/github.com/status-im/status-go/contracts/uniswapV3/IUniswapV3PoolImmutables.abi

@@ -0,0 +1 @@
+[{"inputs":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fee","outputs":[{"internalType":"uint24","name":"","type":"uint24"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxLiquidityPerTick","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tickSpacing","outputs":[{"internalType":"int24","name":"","type":"int24"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token0","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token1","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

vendor/github.com/status-im/status-go/contracts/uniswapV3/IUniswapV3PoolOwnerActions.abi

@@ -0,0 +1 @@
+[{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint128","name":"amount0Requested","type":"uint128"},{"internalType":"uint128","name":"amount1Requested","type":"uint128"}],"name":"collectProtocol","outputs":[{"internalType":"uint128","name":"amount0","type":"uint128"},{"internalType":"uint128","name":"amount1","type":"uint128"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"feeProtocol0","type":"uint8"},{"internalType":"uint8","name":"feeProtocol1","type":"uint8"}],"name":"setFeeProtocol","outputs":[],"stateMutability":"nonpayable","type":"function"}]

vendor/github.com/status-im/status-go/contracts/uniswapV3/IUniswapV3PoolState.abi

@@ -0,0 +1 @@
+[{"inputs":[],"name":"feeGrowthGlobal0X128","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeGrowthGlobal1X128","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"liquidity","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"observations","outputs":[{"internalType":"uint32","name":"blockTimestamp","type":"uint32"},{"internalType":"int56","name":"tickCumulative","type":"int56"},{"internalType":"uint160","name":"secondsPerLiquidityCumulativeX128","type":"uint160"},{"internalType":"bool","name":"initialized","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"key","type":"bytes32"}],"name":"positions","outputs":[{"internalType":"uint128","name":"_liquidity","type":"uint128"},{"internalType":"uint256","name":"feeGrowthInside0LastX128","type":"uint256"},{"internalType":"uint256","name":"feeGrowthInside1LastX128","type":"uint256"},{"internalType":"uint128","name":"tokensOwed0","type":"uint128"},{"internalType":"uint128","name":"tokensOwed1","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"protocolFees","outputs":[{"internalType":"uint128","name":"token0","type":"uint128"},{"internalType":"uint128","name":"token1","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"slot0","outputs":[{"internalType":"uint160","name":"sqrtPriceX96","type":"uint160"},{"internalType":"int24","name":"tick","type":"int24"},{"internalType":"uint16","name":"observationIndex","type":"uint16"},{"internalType":"uint16","name":"observationCardinality","type":"uint16"},{"internalType":"uint16","name":"observationCardinalityNext","type":"uint16"},{"internalType":"uint8","name":"feeProtocol","type":"uint8"},{"internalType":"bool","name":"unlocked","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int16","name":"wordPosition","type":"int16"}],"name":"tickBitmap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int24","name":"tick","type":"int24"}],"name":"ticks","outputs":[{"internalType":"uint128","name":"liquidityGross","type":"uint128"},{"internalType":"int128","name":"liquidityNet","type":"int128"},{"internalType":"uint256","name":"feeGrowthOutside0X128","type":"uint256"},{"internalType":"uint256","name":"feeGrowthOutside1X128","type":"uint256"},{"internalType":"int56","name":"tickCumulativeOutside","type":"int56"},{"internalType":"uint160","name":"secondsPerLiquidityOutsideX128","type":"uint160"},{"internalType":"uint32","name":"secondsOutside","type":"uint32"},{"internalType":"bool","name":"initialized","type":"bool"}],"stateMutability":"view","type":"function"}]

vendor/github.com/status-im/status-go/contracts/uniswapV3/doc.go

@@ -0,0 +1,3 @@
+package uniswapv3
+
+//go:generate abigen --abi IUniswapV3Pool.abi --pkg uniswapv3 --out uniswapv3pool.go