diff --git a/VERSION b/VERSION index 33017898b..ab05b5cba 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -0.159.11 +0.160.0 diff --git a/contracts/assets/Assets.go b/contracts/assets/Assets.go new file mode 100644 index 000000000..470ad1573 --- /dev/null +++ b/contracts/assets/Assets.go @@ -0,0 +1,1087 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package assets + +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 +) + +// AssetsABI is the input ABI used to generate the binding from. +const AssetsABI = "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"_name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"_symbol\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"_maxSupply\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"maxSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"addresses\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"amounts\",\"type\":\"uint256[]\"}],\"name\":\"mintTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"newMaxSupply\",\"type\":\"uint256\"}],\"name\":\"setMaxSupply\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" + +// AssetsBin is the compiled bytecode used for deploying new contracts. +var AssetsBin = "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" + +// DeployAssets deploys a new Ethereum contract, binding an instance of Assets to it. +func DeployAssets(auth *bind.TransactOpts, backend bind.ContractBackend, _name string, _symbol string, _maxSupply *big.Int) (common.Address, *types.Transaction, *Assets, error) { + parsed, err := abi.JSON(strings.NewReader(AssetsABI)) + if err != nil { + return common.Address{}, nil, nil, err + } + + address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(AssetsBin), backend, _name, _symbol, _maxSupply) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &Assets{AssetsCaller: AssetsCaller{contract: contract}, AssetsTransactor: AssetsTransactor{contract: contract}, AssetsFilterer: AssetsFilterer{contract: contract}}, nil +} + +// Assets is an auto generated Go binding around an Ethereum contract. +type Assets struct { + AssetsCaller // Read-only binding to the contract + AssetsTransactor // Write-only binding to the contract + AssetsFilterer // Log filterer for contract events +} + +// AssetsCaller is an auto generated read-only Go binding around an Ethereum contract. +type AssetsCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// AssetsTransactor is an auto generated write-only Go binding around an Ethereum contract. +type AssetsTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// AssetsFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type AssetsFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// AssetsSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type AssetsSession struct { + Contract *Assets // 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 +} + +// AssetsCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type AssetsCallerSession struct { + Contract *AssetsCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// AssetsTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type AssetsTransactorSession struct { + Contract *AssetsTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// AssetsRaw is an auto generated low-level Go binding around an Ethereum contract. +type AssetsRaw struct { + Contract *Assets // Generic contract binding to access the raw methods on +} + +// AssetsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type AssetsCallerRaw struct { + Contract *AssetsCaller // Generic read-only contract binding to access the raw methods on +} + +// AssetsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type AssetsTransactorRaw struct { + Contract *AssetsTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewAssets creates a new instance of Assets, bound to a specific deployed contract. +func NewAssets(address common.Address, backend bind.ContractBackend) (*Assets, error) { + contract, err := bindAssets(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &Assets{AssetsCaller: AssetsCaller{contract: contract}, AssetsTransactor: AssetsTransactor{contract: contract}, AssetsFilterer: AssetsFilterer{contract: contract}}, nil +} + +// NewAssetsCaller creates a new read-only instance of Assets, bound to a specific deployed contract. +func NewAssetsCaller(address common.Address, caller bind.ContractCaller) (*AssetsCaller, error) { + contract, err := bindAssets(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &AssetsCaller{contract: contract}, nil +} + +// NewAssetsTransactor creates a new write-only instance of Assets, bound to a specific deployed contract. +func NewAssetsTransactor(address common.Address, transactor bind.ContractTransactor) (*AssetsTransactor, error) { + contract, err := bindAssets(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &AssetsTransactor{contract: contract}, nil +} + +// NewAssetsFilterer creates a new log filterer instance of Assets, bound to a specific deployed contract. +func NewAssetsFilterer(address common.Address, filterer bind.ContractFilterer) (*AssetsFilterer, error) { + contract, err := bindAssets(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &AssetsFilterer{contract: contract}, nil +} + +// bindAssets binds a generic wrapper to an already deployed contract. +func bindAssets(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := abi.JSON(strings.NewReader(AssetsABI)) + 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 (_Assets *AssetsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Assets.Contract.AssetsCaller.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 (_Assets *AssetsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Assets.Contract.AssetsTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Assets *AssetsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Assets.Contract.AssetsTransactor.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 (_Assets *AssetsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _Assets.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 (_Assets *AssetsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Assets.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_Assets *AssetsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _Assets.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 (_Assets *AssetsCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { + var out []interface{} + err := _Assets.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 (_Assets *AssetsSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _Assets.Contract.Allowance(&_Assets.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 (_Assets *AssetsCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { + return _Assets.Contract.Allowance(&_Assets.CallOpts, owner, spender) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_Assets *AssetsCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { + var out []interface{} + err := _Assets.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 (_Assets *AssetsSession) BalanceOf(account common.Address) (*big.Int, error) { + return _Assets.Contract.BalanceOf(&_Assets.CallOpts, account) +} + +// BalanceOf is a free data retrieval call binding the contract method 0x70a08231. +// +// Solidity: function balanceOf(address account) view returns(uint256) +func (_Assets *AssetsCallerSession) BalanceOf(account common.Address) (*big.Int, error) { + return _Assets.Contract.BalanceOf(&_Assets.CallOpts, account) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_Assets *AssetsCaller) Decimals(opts *bind.CallOpts) (uint8, error) { + var out []interface{} + err := _Assets.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 (_Assets *AssetsSession) Decimals() (uint8, error) { + return _Assets.Contract.Decimals(&_Assets.CallOpts) +} + +// Decimals is a free data retrieval call binding the contract method 0x313ce567. +// +// Solidity: function decimals() view returns(uint8) +func (_Assets *AssetsCallerSession) Decimals() (uint8, error) { + return _Assets.Contract.Decimals(&_Assets.CallOpts) +} + +// MaxSupply is a free data retrieval call binding the contract method 0xd5abeb01. +// +// Solidity: function maxSupply() view returns(uint256) +func (_Assets *AssetsCaller) MaxSupply(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Assets.contract.Call(opts, &out, "maxSupply") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// MaxSupply is a free data retrieval call binding the contract method 0xd5abeb01. +// +// Solidity: function maxSupply() view returns(uint256) +func (_Assets *AssetsSession) MaxSupply() (*big.Int, error) { + return _Assets.Contract.MaxSupply(&_Assets.CallOpts) +} + +// MaxSupply is a free data retrieval call binding the contract method 0xd5abeb01. +// +// Solidity: function maxSupply() view returns(uint256) +func (_Assets *AssetsCallerSession) MaxSupply() (*big.Int, error) { + return _Assets.Contract.MaxSupply(&_Assets.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_Assets *AssetsCaller) Name(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _Assets.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 (_Assets *AssetsSession) Name() (string, error) { + return _Assets.Contract.Name(&_Assets.CallOpts) +} + +// Name is a free data retrieval call binding the contract method 0x06fdde03. +// +// Solidity: function name() view returns(string) +func (_Assets *AssetsCallerSession) Name() (string, error) { + return _Assets.Contract.Name(&_Assets.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Assets *AssetsCaller) Owner(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _Assets.contract.Call(opts, &out, "owner") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Assets *AssetsSession) Owner() (common.Address, error) { + return _Assets.Contract.Owner(&_Assets.CallOpts) +} + +// Owner is a free data retrieval call binding the contract method 0x8da5cb5b. +// +// Solidity: function owner() view returns(address) +func (_Assets *AssetsCallerSession) Owner() (common.Address, error) { + return _Assets.Contract.Owner(&_Assets.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_Assets *AssetsCaller) Symbol(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _Assets.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 (_Assets *AssetsSession) Symbol() (string, error) { + return _Assets.Contract.Symbol(&_Assets.CallOpts) +} + +// Symbol is a free data retrieval call binding the contract method 0x95d89b41. +// +// Solidity: function symbol() view returns(string) +func (_Assets *AssetsCallerSession) Symbol() (string, error) { + return _Assets.Contract.Symbol(&_Assets.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_Assets *AssetsCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Assets.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 (_Assets *AssetsSession) TotalSupply() (*big.Int, error) { + return _Assets.Contract.TotalSupply(&_Assets.CallOpts) +} + +// TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. +// +// Solidity: function totalSupply() view returns(uint256) +func (_Assets *AssetsCallerSession) TotalSupply() (*big.Int, error) { + return _Assets.Contract.TotalSupply(&_Assets.CallOpts) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_Assets *AssetsTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _Assets.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 (_Assets *AssetsSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _Assets.Contract.Approve(&_Assets.TransactOpts, spender, amount) +} + +// Approve is a paid mutator transaction binding the contract method 0x095ea7b3. +// +// Solidity: function approve(address spender, uint256 amount) returns(bool) +func (_Assets *AssetsTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { + return _Assets.Contract.Approve(&_Assets.TransactOpts, spender, amount) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_Assets *AssetsTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _Assets.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_Assets *AssetsSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _Assets.Contract.DecreaseAllowance(&_Assets.TransactOpts, spender, subtractedValue) +} + +// DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. +// +// Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) +func (_Assets *AssetsTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { + return _Assets.Contract.DecreaseAllowance(&_Assets.TransactOpts, spender, subtractedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_Assets *AssetsTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _Assets.contract.Transact(opts, "increaseAllowance", spender, addedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_Assets *AssetsSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _Assets.Contract.IncreaseAllowance(&_Assets.TransactOpts, spender, addedValue) +} + +// IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. +// +// Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) +func (_Assets *AssetsTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { + return _Assets.Contract.IncreaseAllowance(&_Assets.TransactOpts, spender, addedValue) +} + +// MintTo is a paid mutator transaction binding the contract method 0x69add11d. +// +// Solidity: function mintTo(address[] addresses, uint256[] amounts) returns() +func (_Assets *AssetsTransactor) MintTo(opts *bind.TransactOpts, addresses []common.Address, amounts []*big.Int) (*types.Transaction, error) { + return _Assets.contract.Transact(opts, "mintTo", addresses, amounts) +} + +// MintTo is a paid mutator transaction binding the contract method 0x69add11d. +// +// Solidity: function mintTo(address[] addresses, uint256[] amounts) returns() +func (_Assets *AssetsSession) MintTo(addresses []common.Address, amounts []*big.Int) (*types.Transaction, error) { + return _Assets.Contract.MintTo(&_Assets.TransactOpts, addresses, amounts) +} + +// MintTo is a paid mutator transaction binding the contract method 0x69add11d. +// +// Solidity: function mintTo(address[] addresses, uint256[] amounts) returns() +func (_Assets *AssetsTransactorSession) MintTo(addresses []common.Address, amounts []*big.Int) (*types.Transaction, error) { + return _Assets.Contract.MintTo(&_Assets.TransactOpts, addresses, amounts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Assets *AssetsTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Assets.contract.Transact(opts, "renounceOwnership") +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Assets *AssetsSession) RenounceOwnership() (*types.Transaction, error) { + return _Assets.Contract.RenounceOwnership(&_Assets.TransactOpts) +} + +// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. +// +// Solidity: function renounceOwnership() returns() +func (_Assets *AssetsTransactorSession) RenounceOwnership() (*types.Transaction, error) { + return _Assets.Contract.RenounceOwnership(&_Assets.TransactOpts) +} + +// SetMaxSupply is a paid mutator transaction binding the contract method 0x6f8b44b0. +// +// Solidity: function setMaxSupply(uint256 newMaxSupply) returns() +func (_Assets *AssetsTransactor) SetMaxSupply(opts *bind.TransactOpts, newMaxSupply *big.Int) (*types.Transaction, error) { + return _Assets.contract.Transact(opts, "setMaxSupply", newMaxSupply) +} + +// SetMaxSupply is a paid mutator transaction binding the contract method 0x6f8b44b0. +// +// Solidity: function setMaxSupply(uint256 newMaxSupply) returns() +func (_Assets *AssetsSession) SetMaxSupply(newMaxSupply *big.Int) (*types.Transaction, error) { + return _Assets.Contract.SetMaxSupply(&_Assets.TransactOpts, newMaxSupply) +} + +// SetMaxSupply is a paid mutator transaction binding the contract method 0x6f8b44b0. +// +// Solidity: function setMaxSupply(uint256 newMaxSupply) returns() +func (_Assets *AssetsTransactorSession) SetMaxSupply(newMaxSupply *big.Int) (*types.Transaction, error) { + return _Assets.Contract.SetMaxSupply(&_Assets.TransactOpts, newMaxSupply) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_Assets *AssetsTransactor) Transfer(opts *bind.TransactOpts, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _Assets.contract.Transact(opts, "transfer", to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_Assets *AssetsSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _Assets.Contract.Transfer(&_Assets.TransactOpts, to, amount) +} + +// Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. +// +// Solidity: function transfer(address to, uint256 amount) returns(bool) +func (_Assets *AssetsTransactorSession) Transfer(to common.Address, amount *big.Int) (*types.Transaction, error) { + return _Assets.Contract.Transfer(&_Assets.TransactOpts, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_Assets *AssetsTransactor) TransferFrom(opts *bind.TransactOpts, from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _Assets.contract.Transact(opts, "transferFrom", from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_Assets *AssetsSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _Assets.Contract.TransferFrom(&_Assets.TransactOpts, from, to, amount) +} + +// TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. +// +// Solidity: function transferFrom(address from, address to, uint256 amount) returns(bool) +func (_Assets *AssetsTransactorSession) TransferFrom(from common.Address, to common.Address, amount *big.Int) (*types.Transaction, error) { + return _Assets.Contract.TransferFrom(&_Assets.TransactOpts, from, to, amount) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Assets *AssetsTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { + return _Assets.contract.Transact(opts, "transferOwnership", newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Assets *AssetsSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Assets.Contract.TransferOwnership(&_Assets.TransactOpts, newOwner) +} + +// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. +// +// Solidity: function transferOwnership(address newOwner) returns() +func (_Assets *AssetsTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { + return _Assets.Contract.TransferOwnership(&_Assets.TransactOpts, newOwner) +} + +// AssetsApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the Assets contract. +type AssetsApprovalIterator struct { + Event *AssetsApproval // 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 *AssetsApprovalIterator) 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(AssetsApproval) + 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(AssetsApproval) + 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 *AssetsApprovalIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *AssetsApprovalIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// AssetsApproval represents a Approval event raised by the Assets contract. +type AssetsApproval 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 (_Assets *AssetsFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*AssetsApprovalIterator, 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 := _Assets.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) + if err != nil { + return nil, err + } + return &AssetsApprovalIterator{contract: _Assets.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 (_Assets *AssetsFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *AssetsApproval, 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 := _Assets.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(AssetsApproval) + if err := _Assets.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 (_Assets *AssetsFilterer) ParseApproval(log types.Log) (*AssetsApproval, error) { + event := new(AssetsApproval) + if err := _Assets.contract.UnpackLog(event, "Approval", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// AssetsOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Assets contract. +type AssetsOwnershipTransferredIterator struct { + Event *AssetsOwnershipTransferred // 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 *AssetsOwnershipTransferredIterator) 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(AssetsOwnershipTransferred) + 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(AssetsOwnershipTransferred) + 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 *AssetsOwnershipTransferredIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *AssetsOwnershipTransferredIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// AssetsOwnershipTransferred represents a OwnershipTransferred event raised by the Assets contract. +type AssetsOwnershipTransferred struct { + PreviousOwner common.Address + NewOwner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_Assets *AssetsFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*AssetsOwnershipTransferredIterator, error) { + + var previousOwnerRule []interface{} + for _, previousOwnerItem := range previousOwner { + previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + } + var newOwnerRule []interface{} + for _, newOwnerItem := range newOwner { + newOwnerRule = append(newOwnerRule, newOwnerItem) + } + + logs, sub, err := _Assets.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return &AssetsOwnershipTransferredIterator{contract: _Assets.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil +} + +// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_Assets *AssetsFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *AssetsOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { + + var previousOwnerRule []interface{} + for _, previousOwnerItem := range previousOwner { + previousOwnerRule = append(previousOwnerRule, previousOwnerItem) + } + var newOwnerRule []interface{} + for _, newOwnerItem := range newOwner { + newOwnerRule = append(newOwnerRule, newOwnerItem) + } + + logs, sub, err := _Assets.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(AssetsOwnershipTransferred) + if err := _Assets.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. +// +// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) +func (_Assets *AssetsFilterer) ParseOwnershipTransferred(log types.Log) (*AssetsOwnershipTransferred, error) { + event := new(AssetsOwnershipTransferred) + if err := _Assets.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// AssetsTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the Assets contract. +type AssetsTransferIterator struct { + Event *AssetsTransfer // 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 *AssetsTransferIterator) 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(AssetsTransfer) + 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(AssetsTransfer) + 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 *AssetsTransferIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *AssetsTransferIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// AssetsTransfer represents a Transfer event raised by the Assets contract. +type AssetsTransfer 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 (_Assets *AssetsFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*AssetsTransferIterator, 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 := _Assets.contract.FilterLogs(opts, "Transfer", fromRule, toRule) + if err != nil { + return nil, err + } + return &AssetsTransferIterator{contract: _Assets.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 (_Assets *AssetsFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *AssetsTransfer, 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 := _Assets.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(AssetsTransfer) + if err := _Assets.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 (_Assets *AssetsFilterer) ParseTransfer(log types.Log) (*AssetsTransfer, error) { + event := new(AssetsTransfer) + if err := _Assets.contract.UnpackLog(event, "Transfer", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/contracts/assets/CommunityERC20.sol b/contracts/assets/CommunityERC20.sol new file mode 100644 index 000000000..f1b4984da --- /dev/null +++ b/contracts/assets/CommunityERC20.sol @@ -0,0 +1,55 @@ +// SPDX-License-Identifier: Mozilla Public License 2.0 +pragma solidity ^0.8.17; + +import "@openzeppelin/contracts/access/Ownable.sol"; +import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; +import "@openzeppelin/contracts/utils/Context.sol"; + +contract CommunityERC20 is + Context, + Ownable, + ERC20 +{ + /** + * If we want unlimited total supply we should set maxSupply to 2^256-1. + */ + uint256 public maxSupply; + + constructor( + string memory _name, + string memory _symbol, + uint256 _maxSupply + ) ERC20(_name, _symbol) { + maxSupply = _maxSupply; + } + + // Events + + // External functions + + function setMaxSupply(uint256 newMaxSupply) external onlyOwner { + require(newMaxSupply >= totalSupply(), "MAX_SUPPLY_LOWER_THAN_TOTAL_SUPPLY"); + maxSupply = newMaxSupply; + } + + /** + * @dev Mint tokens for each address in `addresses` each one with + * an amount specified in `amounts`. + * + */ + function mintTo(address[] memory addresses, uint256[] memory amounts) external onlyOwner { + require(addresses.length == amounts.length, "WRONG_LENGTHS"); + + for (uint256 i = 0; i < addresses.length; i++) { + uint256 amount = amounts[i]; + require(totalSupply() + amount <= maxSupply, "MAX_SUPPLY_REACHED"); + _mint(addresses[i], amount); + } + } + + // Public functions + + // Internal functions + + // Private functions +} diff --git a/protocol/communities/community.go b/protocol/communities/community.go index 9efbf2a7f..8f6ce0ab6 100644 --- a/protocol/communities/community.go +++ b/protocol/communities/community.go @@ -454,6 +454,7 @@ type CommunityToken struct { ChainID int `json:"chainId"` DeployState DeployState `json:"deployState"` Base64Image string `json:"image"` + Decimals int `json:"decimals"` } type CommunitySettings struct { diff --git a/protocol/communities/manager.go b/protocol/communities/manager.go index 3cef1940b..11a815c2b 100644 --- a/protocol/communities/manager.go +++ b/protocol/communities/manager.go @@ -4022,6 +4022,7 @@ func (m *Manager) AddCommunityToken(token *CommunityToken) (*CommunityToken, err Symbol: token.Symbol, TokenType: token.TokenType, Name: token.Name, + Decimals: uint32(token.Decimals), } _, err = community.AddCommunityTokensMetadata(tokenMetadata) if err != nil { diff --git a/protocol/communities/persistence.go b/protocol/communities/persistence.go index cb66e2eba..5b1591609 100644 --- a/protocol/communities/persistence.go +++ b/protocol/communities/persistence.go @@ -1106,7 +1106,7 @@ func (p *Persistence) GetCommunityChatIDs(communityID types.HexBytes) ([]string, func (p *Persistence) GetAllCommunityTokens() ([]*CommunityToken, error) { rows, err := p.db.Query(`SELECT community_id, address, type, name, symbol, description, supply, - infinite_supply, transferable, remote_self_destruct, chain_id, deploy_state, image_base64 + infinite_supply, transferable, remote_self_destruct, chain_id, deploy_state, image_base64, decimals FROM community_tokens`) if err != nil { return nil, err @@ -1118,7 +1118,7 @@ func (p *Persistence) GetAllCommunityTokens() ([]*CommunityToken, error) { func (p *Persistence) GetCommunityTokens(communityID string) ([]*CommunityToken, error) { rows, err := p.db.Query(`SELECT community_id, address, type, name, symbol, description, supply, - infinite_supply, transferable, remote_self_destruct, chain_id, deploy_state, image_base64 + infinite_supply, transferable, remote_self_destruct, chain_id, deploy_state, image_base64, decimals FROM community_tokens WHERE community_id = ?`, communityID) if err != nil { return nil, err @@ -1135,7 +1135,7 @@ func (p *Persistence) getCommunityTokensInternal(rows *sql.Rows) ([]*CommunityTo token := CommunityToken{} err := rows.Scan(&token.CommunityID, &token.Address, &token.TokenType, &token.Name, &token.Symbol, &token.Description, &token.Supply, &token.InfiniteSupply, &token.Transferable, - &token.RemoteSelfDestruct, &token.ChainID, &token.DeployState, &token.Base64Image) + &token.RemoteSelfDestruct, &token.ChainID, &token.DeployState, &token.Base64Image, &token.Decimals) if err != nil { return nil, err } @@ -1146,10 +1146,10 @@ func (p *Persistence) getCommunityTokensInternal(rows *sql.Rows) ([]*CommunityTo func (p *Persistence) AddCommunityToken(token *CommunityToken) error { _, err := p.db.Exec(`INSERT INTO community_tokens (community_id, address, type, name, symbol, description, supply, - infinite_supply, transferable, remote_self_destruct, chain_id, deploy_state, image_base64) - VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, token.CommunityID, token.Address, token.TokenType, token.Name, + infinite_supply, transferable, remote_self_destruct, chain_id, deploy_state, image_base64, decimals) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, token.CommunityID, token.Address, token.TokenType, token.Name, token.Symbol, token.Description, token.Supply, token.InfiniteSupply, token.Transferable, token.RemoteSelfDestruct, - token.ChainID, token.DeployState, token.Base64Image) + token.ChainID, token.DeployState, token.Base64Image, token.Decimals) return err } diff --git a/protocol/communities/persistence_test.go b/protocol/communities/persistence_test.go index 31c778bc2..36973ea3d 100644 --- a/protocol/communities/persistence_test.go +++ b/protocol/communities/persistence_test.go @@ -375,7 +375,7 @@ func (s *PersistenceSuite) TestGetCommunityTokens() { s.Require().NoError(err) s.Require().Len(tokens, 0) - token := CommunityToken{ + tokenERC721 := CommunityToken{ CommunityID: "123", TokenType: protobuf.CommunityTokenType_ERC721, Address: "0x123", @@ -391,9 +391,9 @@ func (s *PersistenceSuite) TestGetCommunityTokens() { Base64Image: "ABCD", } - token2 := CommunityToken{ + tokenERC20 := CommunityToken{ CommunityID: "345", - TokenType: protobuf.CommunityTokenType_ERC721, + TokenType: protobuf.CommunityTokenType_ERC20, Address: "0x345", Name: "StatusToken", Symbol: "STT", @@ -405,17 +405,18 @@ func (s *PersistenceSuite) TestGetCommunityTokens() { ChainID: 2, DeployState: Failed, Base64Image: "QWERTY", + Decimals: 21, } - err = s.db.AddCommunityToken(&token) + err = s.db.AddCommunityToken(&tokenERC721) s.Require().NoError(err) - err = s.db.AddCommunityToken(&token2) + err = s.db.AddCommunityToken(&tokenERC20) s.Require().NoError(err) tokens, err = s.db.GetCommunityTokens("123") s.Require().NoError(err) s.Require().Len(tokens, 1) - s.Require().Equal(token, *tokens[0]) + s.Require().Equal(tokenERC721, *tokens[0]) err = s.db.UpdateCommunityTokenState(1, "0x123", Deployed) s.Require().NoError(err) @@ -423,6 +424,11 @@ func (s *PersistenceSuite) TestGetCommunityTokens() { s.Require().NoError(err) s.Require().Len(tokens, 1) s.Require().Equal(Deployed, tokens[0].DeployState) + + tokens, err = s.db.GetCommunityTokens("345") + s.Require().NoError(err) + s.Require().Len(tokens, 1) + s.Require().Equal(tokenERC20, *tokens[0]) } func (s *PersistenceSuite) TestSaveCheckChannelPermissionResponse() { diff --git a/protocol/migrations/migrations.go b/protocol/migrations/migrations.go index 5711561b5..fdda1abad 100644 --- a/protocol/migrations/migrations.go +++ b/protocol/migrations/migrations.go @@ -95,6 +95,7 @@ // 1685964183_add_chainids_to_revealed_addresses.up.sql (88B) // 1687370421_add_communities_muted_till_new.up.sql (635B) // 1687416607_add_communities_check_channel_permission_responses_table.up.sql (739B) +// 1687856939_add_community_tokens_decimals.up.sql (65B) // README.md (554B) // doc.go (850B) @@ -179,7 +180,7 @@ func _000001_initDownDbSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "000001_init.down.db.sql", size: 65, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "000001_init.down.db.sql", size: 65, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x5e, 0xbb, 0x3f, 0x1, 0x75, 0x19, 0x70, 0x86, 0xa7, 0x34, 0x40, 0x17, 0x34, 0x3e, 0x18, 0x51, 0x79, 0xd4, 0x22, 0xad, 0x8f, 0x80, 0xcc, 0xa6, 0xcc, 0x6, 0x2b, 0x62, 0x2, 0x47, 0xba, 0xf9}} return a, nil } @@ -199,7 +200,7 @@ func _000001_initUpDbSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "000001_init.up.db.sql", size: 2719, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "000001_init.up.db.sql", size: 2719, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x60, 0xdc, 0xeb, 0xe, 0xc2, 0x4f, 0x75, 0xa, 0xf6, 0x3e, 0xc7, 0xc4, 0x4, 0xe2, 0xe1, 0xa4, 0x73, 0x2f, 0x4a, 0xad, 0x1a, 0x0, 0xc3, 0x93, 0x9d, 0x77, 0x3e, 0x31, 0x91, 0x77, 0x2e, 0xc8}} return a, nil } @@ -219,7 +220,7 @@ func _000002_add_last_ens_clock_valueUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "000002_add_last_ens_clock_value.up.sql", size: 77, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "000002_add_last_ens_clock_value.up.sql", size: 77, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x4d, 0x3, 0x8f, 0xd5, 0x85, 0x83, 0x47, 0xbe, 0xf9, 0x82, 0x7e, 0x81, 0xa4, 0xbd, 0xaa, 0xd5, 0x98, 0x18, 0x5, 0x2d, 0x82, 0x42, 0x3b, 0x3, 0x50, 0xc3, 0x1e, 0x84, 0x35, 0xf, 0xb6, 0x2b}} return a, nil } @@ -239,7 +240,7 @@ func _1586358095_add_replaceUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1586358095_add_replace.up.sql", size: 224, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1586358095_add_replace.up.sql", size: 224, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd2, 0xb3, 0xa9, 0xc7, 0x7f, 0x9d, 0x8f, 0x43, 0x8c, 0x9e, 0x58, 0x8d, 0x44, 0xbc, 0xfa, 0x6b, 0x5f, 0x3f, 0x5a, 0xbe, 0xe8, 0xb1, 0x16, 0xf, 0x91, 0x2a, 0xa0, 0x71, 0xbb, 0x8d, 0x6b, 0xcb}} return a, nil } @@ -259,7 +260,7 @@ func _1588665364_add_image_dataUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1588665364_add_image_data.up.sql", size: 186, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1588665364_add_image_data.up.sql", size: 186, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd6, 0xc6, 0x35, 0xb4, 0x4c, 0x39, 0x96, 0x29, 0x30, 0xda, 0xf4, 0x8f, 0xcb, 0xf1, 0x9f, 0x84, 0xdc, 0x88, 0xd4, 0xd5, 0xbc, 0xb6, 0x5b, 0x46, 0x78, 0x67, 0x76, 0x1a, 0x5, 0x36, 0xdc, 0xe5}} return a, nil } @@ -279,7 +280,7 @@ func _1589365189_add_pow_targetUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1589365189_add_pow_target.up.sql", size: 66, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1589365189_add_pow_target.up.sql", size: 66, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x4e, 0x3a, 0xe2, 0x2e, 0x7d, 0xaf, 0xbb, 0xcc, 0x21, 0xa1, 0x7a, 0x41, 0x9a, 0xd0, 0xbb, 0xa9, 0xc8, 0x35, 0xf9, 0x32, 0x34, 0x46, 0x44, 0x9a, 0x86, 0x40, 0x7c, 0xb9, 0x23, 0xc7, 0x3, 0x3f}} return a, nil } @@ -299,7 +300,7 @@ func _1591277220_add_index_messagesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1591277220_add_index_messages.up.sql", size: 240, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1591277220_add_index_messages.up.sql", size: 240, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x9c, 0xfe, 0xbe, 0xd5, 0xb8, 0x8f, 0xdd, 0xef, 0xbb, 0xa8, 0xad, 0x7f, 0xed, 0x5b, 0x5b, 0x2f, 0xe6, 0x82, 0x27, 0x78, 0x1f, 0xb9, 0x57, 0xdc, 0x8, 0xc2, 0xb2, 0xa9, 0x9a, 0x4, 0xe1, 0x7a}} return a, nil } @@ -319,7 +320,7 @@ func _1593087212_add_mute_chat_and_raw_message_fieldsUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1593087212_add_mute_chat_and_raw_message_fields.up.sql", size: 215, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1593087212_add_mute_chat_and_raw_message_fields.up.sql", size: 215, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x73, 0x99, 0x61, 0xd1, 0xaa, 0xb4, 0xbf, 0xaf, 0xd7, 0x20, 0x17, 0x40, 0xf9, 0x2, 0xfb, 0xcc, 0x40, 0x2a, 0xd, 0x86, 0x36, 0x30, 0x88, 0x89, 0x25, 0x80, 0x42, 0xb0, 0x5b, 0xe9, 0x73, 0x78}} return a, nil } @@ -339,7 +340,7 @@ func _1595862781_add_audio_dataUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1595862781_add_audio_data.up.sql", size: 246, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1595862781_add_audio_data.up.sql", size: 246, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xae, 0xd2, 0xee, 0x55, 0xfb, 0x36, 0xa4, 0x92, 0x66, 0xe, 0x81, 0x62, 0x1e, 0x7a, 0x69, 0xa, 0xd5, 0x4b, 0xa5, 0x6a, 0x8d, 0x1d, 0xce, 0xf3, 0x3e, 0xc0, 0x5f, 0x9c, 0x66, 0x1b, 0xb4, 0xed}} return a, nil } @@ -359,7 +360,7 @@ func _1595865249_create_emoji_reactions_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1595865249_create_emoji_reactions_table.up.sql", size: 300, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1595865249_create_emoji_reactions_table.up.sql", size: 300, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x3e, 0xc5, 0x43, 0x5c, 0x3d, 0x53, 0x43, 0x2c, 0x1a, 0xa5, 0xb6, 0xbf, 0x7, 0x4, 0x5a, 0x3e, 0x40, 0x8b, 0xa4, 0x57, 0x12, 0x58, 0xbc, 0x42, 0xe2, 0xc3, 0xde, 0x76, 0x98, 0x80, 0xe2, 0xbe}} return a, nil } @@ -379,7 +380,7 @@ func _1596805115_create_group_chat_invitations_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1596805115_create_group_chat_invitations_table.up.sql", size: 231, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1596805115_create_group_chat_invitations_table.up.sql", size: 231, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x6d, 0xb1, 0x14, 0x6d, 0x54, 0x28, 0x67, 0xc3, 0x23, 0x6a, 0xfc, 0x80, 0xdf, 0x9e, 0x4c, 0x35, 0x36, 0xf, 0xf8, 0xf3, 0x5f, 0xae, 0xad, 0xb, 0xc1, 0x51, 0x8e, 0x17, 0x7, 0xe5, 0x7f, 0x91}} return a, nil } @@ -399,7 +400,7 @@ func _1597322655_add_invitation_admin_chat_fieldUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1597322655_add_invitation_admin_chat_field.up.sql", size: 54, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1597322655_add_invitation_admin_chat_field.up.sql", size: 54, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xa9, 0x7a, 0xa0, 0xf2, 0xdb, 0x13, 0x91, 0x91, 0xa8, 0x34, 0x1a, 0xa1, 0x49, 0x68, 0xd5, 0xae, 0x2c, 0xd8, 0xd5, 0xea, 0x8f, 0x8c, 0xc7, 0x2, 0x4e, 0x58, 0x2c, 0x3a, 0x14, 0xd4, 0x4f, 0x2c}} return a, nil } @@ -419,7 +420,7 @@ func _1597757544_add_nicknameUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1597757544_add_nickname.up.sql", size: 52, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1597757544_add_nickname.up.sql", size: 52, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf4, 0xa2, 0x64, 0x50, 0xc5, 0x4, 0xb9, 0x8b, 0xd1, 0x18, 0x9b, 0xc3, 0x91, 0x36, 0x2a, 0x1f, 0xc3, 0x6c, 0x2d, 0x92, 0xf8, 0x5e, 0xff, 0xb1, 0x59, 0x61, 0x2, 0x1c, 0xe1, 0x85, 0x90, 0xa4}} return a, nil } @@ -439,7 +440,7 @@ func _1598955122_add_mentionsUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1598955122_add_mentions.up.sql", size: 52, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1598955122_add_mentions.up.sql", size: 52, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x8d, 0x22, 0x17, 0x92, 0xd2, 0x11, 0x4e, 0x7, 0x93, 0x9a, 0x55, 0xfd, 0xb, 0x97, 0xc4, 0x63, 0x6a, 0x81, 0x97, 0xcd, 0xb2, 0xf8, 0x4b, 0x5f, 0x3c, 0xfa, 0x3a, 0x38, 0x53, 0x10, 0xed, 0x9d}} return a, nil } @@ -459,7 +460,7 @@ func _1599641390_add_emoji_reactions_indexUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1599641390_add_emoji_reactions_index.up.sql", size: 126, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1599641390_add_emoji_reactions_index.up.sql", size: 126, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf9, 0xd8, 0xdc, 0xa7, 0xb, 0x92, 0x7a, 0x61, 0x37, 0x24, 0x1c, 0x77, 0x5e, 0xe, 0x7e, 0xfc, 0x9f, 0x98, 0x7b, 0x65, 0xe7, 0xf9, 0x71, 0x57, 0x89, 0x2d, 0x90, 0x1b, 0xf6, 0x5e, 0x37, 0xe8}} return a, nil } @@ -479,7 +480,7 @@ func _1599720851_add_seen_index_remove_long_messagesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1599720851_add_seen_index_remove_long_messages.up.sql", size: 150, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1599720851_add_seen_index_remove_long_messages.up.sql", size: 150, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x24, 0x1c, 0xc4, 0x78, 0x91, 0xc7, 0xeb, 0xfe, 0xc8, 0xa0, 0xd8, 0x13, 0x27, 0x97, 0xc8, 0x96, 0x56, 0x97, 0x33, 0x2c, 0x1e, 0x16, 0x8a, 0xd3, 0x49, 0x99, 0x3, 0xe9, 0xbb, 0xc4, 0x5, 0x3c}} return a, nil } @@ -499,7 +500,7 @@ func _1603198582_add_profile_chat_fieldUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1603198582_add_profile_chat_field.up.sql", size: 45, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1603198582_add_profile_chat_field.up.sql", size: 45, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xaa, 0xca, 0xe, 0x46, 0xa0, 0x9, 0x9d, 0x47, 0x57, 0xe9, 0xfb, 0x17, 0xeb, 0x9c, 0xf6, 0xb8, 0x1d, 0xe9, 0xd, 0x0, 0xd5, 0xe5, 0xd8, 0x9e, 0x60, 0xa, 0xbf, 0x32, 0x2c, 0x52, 0x7f, 0x6a}} return a, nil } @@ -519,7 +520,7 @@ func _1603816533_add_linksUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1603816533_add_links.up.sql", size: 48, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1603816533_add_links.up.sql", size: 48, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc9, 0x24, 0xd6, 0x1d, 0xa, 0x83, 0x1e, 0x4d, 0xf, 0xae, 0x4d, 0x8c, 0x51, 0x32, 0xa8, 0x37, 0xb0, 0x14, 0xfb, 0x32, 0x34, 0xc8, 0xc, 0x4e, 0x5b, 0xc5, 0x15, 0x65, 0x73, 0x0, 0x0, 0x1d}} return a, nil } @@ -539,7 +540,7 @@ func _1603888149_create_chat_identity_last_published_tableUpSql() (*asset, error return nil, err } - info := bindataFileInfo{name: "1603888149_create_chat_identity_last_published_table.up.sql", size: 407, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1603888149_create_chat_identity_last_published_table.up.sql", size: 407, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x7f, 0x9, 0xf, 0xfb, 0xdb, 0x3c, 0x86, 0x70, 0x82, 0xda, 0x10, 0x25, 0xe2, 0x4e, 0x40, 0x45, 0xab, 0x8b, 0x1c, 0x91, 0x7c, 0xf1, 0x70, 0x2e, 0x81, 0xf3, 0x71, 0x45, 0xda, 0xe2, 0xa4, 0x57}} return a, nil } @@ -559,7 +560,7 @@ func _1605075346_add_communitiesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1605075346_add_communities.up.sql", size: 6971, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1605075346_add_communities.up.sql", size: 6971, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x1f, 0x64, 0xea, 0xb4, 0xae, 0x9e, 0xdb, 0x9, 0x58, 0xb6, 0x5c, 0x7a, 0x50, 0xc5, 0xfe, 0x93, 0x5d, 0x36, 0x85, 0x5d, 0x6a, 0xba, 0xc9, 0x7e, 0x84, 0xd7, 0xbf, 0x2a, 0x53, 0xf3, 0x97, 0xf1}} return a, nil } @@ -579,7 +580,7 @@ func _1610117927_add_message_cacheUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1610117927_add_message_cache.up.sql", size: 142, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1610117927_add_message_cache.up.sql", size: 142, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x34, 0xf1, 0xf0, 0x82, 0x79, 0x28, 0x19, 0xc2, 0x39, 0x6a, 0xa5, 0x96, 0x59, 0x23, 0xa0, 0xed, 0x60, 0x58, 0x86, 0x9, 0xb9, 0xad, 0xfb, 0xa, 0xe3, 0x47, 0x6e, 0xa1, 0x18, 0xe8, 0x39, 0x2c}} return a, nil } @@ -599,7 +600,7 @@ func _1610959908_add_dont_wrap_to_raw_messagesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1610959908_add_dont_wrap_to_raw_messages.up.sql", size: 83, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1610959908_add_dont_wrap_to_raw_messages.up.sql", size: 83, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x71, 0x2, 0x9a, 0xca, 0xd4, 0x38, 0x44, 0x30, 0x2b, 0xa8, 0x27, 0x32, 0x63, 0x53, 0x22, 0x60, 0x59, 0x84, 0x23, 0x96, 0x77, 0xf0, 0x56, 0xd7, 0x94, 0xe0, 0x95, 0x28, 0x6, 0x1d, 0x4e, 0xb1}} return a, nil } @@ -619,7 +620,7 @@ func _1610960912_add_send_on_personal_topicUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1610960912_add_send_on_personal_topic.up.sql", size: 82, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1610960912_add_send_on_personal_topic.up.sql", size: 82, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x77, 0xac, 0x2f, 0xc4, 0xd, 0xa7, 0x1b, 0x37, 0x30, 0xc2, 0x68, 0xee, 0xde, 0x54, 0x5e, 0xbf, 0x3f, 0xa0, 0xd6, 0xc6, 0x9f, 0xd4, 0x34, 0x12, 0x76, 0x1e, 0x66, 0x4a, 0xfc, 0xf, 0xee, 0xc9}} return a, nil } @@ -639,7 +640,7 @@ func _1612870480_add_datasync_idUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1612870480_add_datasync_id.up.sql", size: 111, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1612870480_add_datasync_id.up.sql", size: 111, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x34, 0x9a, 0xbc, 0xfa, 0xaa, 0x8c, 0x9c, 0x37, 0x67, 0x15, 0x9c, 0x7e, 0x78, 0x75, 0x66, 0x82, 0x18, 0x72, 0x10, 0xbc, 0xd4, 0xab, 0x44, 0xfe, 0x57, 0x85, 0x6d, 0x19, 0xf5, 0x96, 0x8a, 0xbe}} return a, nil } @@ -659,7 +660,7 @@ func _1614152139_add_communities_request_to_joinUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1614152139_add_communities_request_to_join.up.sql", size: 831, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1614152139_add_communities_request_to_join.up.sql", size: 831, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x11, 0x3, 0x26, 0xf9, 0x29, 0x50, 0x4f, 0xcd, 0x46, 0xe5, 0xb1, 0x6b, 0xb9, 0x2, 0x40, 0xb1, 0xdf, 0x4a, 0x4c, 0x7a, 0xda, 0x3, 0x35, 0xcd, 0x2d, 0xcc, 0x80, 0x7d, 0x57, 0x5f, 0x3, 0x5c}} return a, nil } @@ -679,7 +680,7 @@ func _1615374373_add_confirmationsUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1615374373_add_confirmations.up.sql", size: 227, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1615374373_add_confirmations.up.sql", size: 227, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xdd, 0xa6, 0x65, 0xc5, 0x1d, 0xb2, 0x77, 0x36, 0xe3, 0x79, 0xda, 0xe8, 0x7a, 0xa4, 0xdf, 0x45, 0xae, 0xd8, 0xb4, 0xba, 0x90, 0xfd, 0x74, 0x71, 0x14, 0x75, 0x73, 0x72, 0xb9, 0x9e, 0x1, 0x81}} return a, nil } @@ -699,7 +700,7 @@ func _1617694931_add_notification_centerUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1617694931_add_notification_center.up.sql", size: 572, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1617694931_add_notification_center.up.sql", size: 572, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x10, 0x45, 0xc6, 0xc9, 0x73, 0xbb, 0x1f, 0xda, 0xa3, 0x4d, 0x19, 0x98, 0x85, 0x2d, 0xca, 0xda, 0xcc, 0x3b, 0x32, 0xff, 0xc7, 0x7b, 0xe3, 0x9f, 0x9b, 0x2a, 0x93, 0xf5, 0xdf, 0x65, 0x38, 0x91}} return a, nil } @@ -719,7 +720,7 @@ func _1618923660_create_pin_messagesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1618923660_create_pin_messages.up.sql", size: 265, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1618923660_create_pin_messages.up.sql", size: 265, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x61, 0x44, 0x3a, 0xbe, 0x30, 0xd2, 0x7e, 0xc0, 0xe2, 0x8e, 0x65, 0x53, 0x54, 0xbb, 0x7a, 0x1c, 0xb3, 0x5d, 0xd2, 0xa6, 0xa9, 0x28, 0xb7, 0xa4, 0x5f, 0x8b, 0x9, 0x5f, 0x17, 0xc1, 0x85, 0x21}} return a, nil } @@ -739,7 +740,7 @@ func _1619094007_add_joined_chat_fieldUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1619094007_add_joined_chat_field.up.sql", size: 101, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1619094007_add_joined_chat_field.up.sql", size: 101, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xfa, 0x30, 0x81, 0x3a, 0x2f, 0x9f, 0xb3, 0x0, 0x55, 0x8e, 0x1d, 0xa8, 0xb0, 0x68, 0xf0, 0x40, 0x1a, 0x6c, 0xaa, 0xfc, 0x33, 0xd1, 0xd1, 0x55, 0x3f, 0xf2, 0xbd, 0x54, 0xa1, 0x2b, 0x40, 0x95}} return a, nil } @@ -759,7 +760,7 @@ func _1619099821_add_last_synced_fieldUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1619099821_add_last_synced_field.up.sql", size: 226, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1619099821_add_last_synced_field.up.sql", size: 226, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf, 0x52, 0x22, 0xe, 0x2f, 0xd7, 0x93, 0x5f, 0x42, 0xc2, 0x93, 0x4, 0x35, 0x6f, 0xc9, 0x19, 0xed, 0x6b, 0x52, 0x6f, 0xae, 0x99, 0xe2, 0x68, 0x3d, 0x4f, 0x40, 0xe, 0xe1, 0xa, 0x47, 0x21}} return a, nil } @@ -779,7 +780,7 @@ func _1621933219_add_mentionedUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1621933219_add_mentioned.up.sql", size: 70, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1621933219_add_mentioned.up.sql", size: 70, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x36, 0x76, 0x8a, 0xc9, 0x7, 0x8f, 0xa5, 0xcb, 0x12, 0x21, 0x4e, 0xfe, 0x96, 0x77, 0xcf, 0x7f, 0x76, 0x75, 0x36, 0x2c, 0xf8, 0x1d, 0x13, 0xcb, 0xcd, 0x6e, 0x70, 0xbf, 0xf5, 0x93, 0x67, 0xd1}} return a, nil } @@ -799,7 +800,7 @@ func _1622010048_add_unviewed_mentions_countUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1622010048_add_unviewed_mentions_count.up.sql", size: 114, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1622010048_add_unviewed_mentions_count.up.sql", size: 114, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x7c, 0x16, 0x85, 0xa6, 0x5b, 0xe1, 0x66, 0xb9, 0x84, 0xbe, 0x7f, 0xa, 0x77, 0x23, 0xb9, 0xef, 0x8e, 0x2, 0x8, 0xfc, 0x61, 0xb2, 0x43, 0xa9, 0x63, 0xae, 0xb4, 0xdf, 0x30, 0xb1, 0x61, 0x4b}} return a, nil } @@ -819,7 +820,7 @@ func _1622061278_add_message_activity_center_notification_fieldUpSql() (*asset, return nil, err } - info := bindataFileInfo{name: "1622061278_add_message_activity_center_notification_field.up.sql", size: 80, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1622061278_add_message_activity_center_notification_field.up.sql", size: 80, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x8, 0xc, 0xa6, 0x1f, 0xa5, 0xc6, 0x7c, 0x6f, 0xab, 0x2c, 0x2d, 0xb5, 0xa4, 0xdd, 0xc1, 0xd6, 0x44, 0x83, 0xf9, 0xb1, 0xa5, 0xce, 0x34, 0x3d, 0x2, 0xa9, 0x35, 0xcf, 0xc6, 0xb2, 0x43, 0x37}} return a, nil } @@ -839,7 +840,7 @@ func _1622464518_set_synced_to_fromUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1622464518_set_synced_to_from.up.sql", size: 105, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1622464518_set_synced_to_from.up.sql", size: 105, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x33, 0x3e, 0x2b, 0xa, 0x1e, 0xc7, 0x6d, 0x6f, 0xd1, 0x1d, 0xe8, 0x4b, 0xdd, 0x92, 0x76, 0xea, 0xf2, 0x3e, 0x15, 0x85, 0xc4, 0xc3, 0x31, 0xf1, 0xc0, 0xa2, 0xd7, 0x47, 0xde, 0x4e, 0xfd, 0xc6}} return a, nil } @@ -859,7 +860,7 @@ func _1622464519_add_chat_descriptionUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1622464519_add_chat_description.up.sql", size: 93, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1622464519_add_chat_description.up.sql", size: 93, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x36, 0x2e, 0x89, 0x31, 0xec, 0xef, 0xeb, 0x43, 0xf5, 0x96, 0x6d, 0xce, 0x91, 0x8a, 0x37, 0x2a, 0x11, 0x7a, 0x3f, 0xd9, 0x10, 0xbb, 0xa1, 0xbc, 0x7, 0xe0, 0x3b, 0xa5, 0xf4, 0xa6, 0xf4, 0xa1}} return a, nil } @@ -879,7 +880,7 @@ func _1622622253_add_pinned_by_to_pin_messagesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1622622253_add_pinned_by_to_pin_messages.up.sql", size: 52, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1622622253_add_pinned_by_to_pin_messages.up.sql", size: 52, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x9b, 0x94, 0xa3, 0x45, 0x91, 0x1e, 0x66, 0xd1, 0x96, 0x5a, 0xaf, 0xfa, 0x29, 0x39, 0xa8, 0x3a, 0x97, 0x4c, 0x65, 0x6, 0x96, 0x90, 0x4c, 0xfe, 0xce, 0x7d, 0x5d, 0xd4, 0xb3, 0x8, 0x6d, 0x5f}} return a, nil } @@ -899,7 +900,7 @@ func _1623938329_add_author_activity_center_notification_fieldUpSql() (*asset, e return nil, err } - info := bindataFileInfo{name: "1623938329_add_author_activity_center_notification_field.up.sql", size: 66, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1623938329_add_author_activity_center_notification_field.up.sql", size: 66, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x36, 0xe6, 0xa7, 0xd5, 0x26, 0xff, 0xab, 0x92, 0x88, 0xf0, 0xd3, 0x34, 0xd9, 0x2f, 0xe7, 0x18, 0x1a, 0x40, 0xf9, 0xbe, 0x8e, 0xfc, 0xd0, 0x4f, 0x1f, 0x4a, 0xb9, 0x83, 0x3f, 0xa9, 0xde, 0xb}} return a, nil } @@ -919,7 +920,7 @@ func _1623938330_add_edit_messagesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1623938330_add_edit_messages.up.sql", size: 369, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1623938330_add_edit_messages.up.sql", size: 369, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x7e, 0xd2, 0xce, 0xe, 0x5c, 0x19, 0xbe, 0x5e, 0x29, 0xbe, 0x9b, 0x31, 0x53, 0x76, 0xb2, 0xc8, 0x56, 0xf0, 0x82, 0xfe, 0x7d, 0x6c, 0xe8, 0x5c, 0xe9, 0x7a, 0x5d, 0x5, 0xc4, 0x92, 0x38, 0xe3}} return a, nil } @@ -939,7 +940,7 @@ func _1624978434_add_muted_communityUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1624978434_add_muted_community.up.sql", size: 82, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1624978434_add_muted_community.up.sql", size: 82, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x6, 0xdc, 0x6e, 0x6f, 0x97, 0xc7, 0x3d, 0x50, 0xab, 0x80, 0x87, 0x44, 0x43, 0x38, 0xe6, 0xc5, 0xc1, 0x91, 0x26, 0xf, 0x16, 0xe, 0xd9, 0x32, 0x37, 0x25, 0x96, 0x25, 0x6, 0xc8, 0xb5, 0x4a}} return a, nil } @@ -959,7 +960,7 @@ func _1625018910_add_repply_message_activity_center_notification_fieldUpSql() (* return nil, err } - info := bindataFileInfo{name: "1625018910_add_repply_message_activity_center_notification_field.up.sql", size: 86, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1625018910_add_repply_message_activity_center_notification_field.up.sql", size: 86, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf2, 0x52, 0x12, 0x40, 0xd8, 0x6f, 0x71, 0x97, 0x46, 0x39, 0xaa, 0x74, 0x41, 0xcd, 0x45, 0x4c, 0xe8, 0xd9, 0xe2, 0x56, 0x8e, 0x78, 0x18, 0x62, 0xf6, 0xa8, 0x36, 0xe9, 0x9a, 0x1f, 0xc, 0xb1}} return a, nil } @@ -979,7 +980,7 @@ func _1625762506_add_deleted_messagesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1625762506_add_deleted_messages.up.sql", size: 357, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1625762506_add_deleted_messages.up.sql", size: 357, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd5, 0x61, 0x42, 0xb6, 0x8c, 0x7f, 0x2d, 0xec, 0xa9, 0x6d, 0x3d, 0x0, 0xa3, 0x32, 0xd8, 0x4a, 0x38, 0x5c, 0x97, 0xfc, 0x68, 0xde, 0xa9, 0xb7, 0xd8, 0xde, 0xb, 0x29, 0x93, 0xdc, 0x81, 0xf8}} return a, nil } @@ -999,7 +1000,7 @@ func _1627388946_add_communities_synced_atUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1627388946_add_communities_synced_at.up.sql", size: 87, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1627388946_add_communities_synced_at.up.sql", size: 87, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc1, 0xbd, 0x9b, 0x6a, 0xc9, 0x1a, 0x7a, 0x34, 0xcf, 0x5f, 0x80, 0x9e, 0x8c, 0x1c, 0xc0, 0xec, 0x4e, 0x78, 0xb0, 0x2d, 0x15, 0x77, 0x38, 0x4a, 0x6a, 0x5, 0x84, 0xf5, 0x8d, 0x8b, 0xbe, 0x9}} return a, nil } @@ -1019,7 +1020,7 @@ func _1628280060_createUsermessagesIndexSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1628280060_create-usermessages-index.sql", size: 80, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1628280060_create-usermessages-index.sql", size: 80, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x10, 0x6f, 0x70, 0x47, 0x40, 0xab, 0xa8, 0x60, 0xe0, 0xf9, 0x8, 0x7e, 0x19, 0x9d, 0xba, 0x33, 0x16, 0xfc, 0x3c, 0xdc, 0xa8, 0xa6, 0x53, 0x61, 0x39, 0x82, 0x91, 0xcf, 0x69, 0xd8, 0xf2, 0xcf}} return a, nil } @@ -1039,7 +1040,7 @@ func _1632303896_modify_contacts_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1632303896_modify_contacts_table.up.sql", size: 1574, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1632303896_modify_contacts_table.up.sql", size: 1574, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x81, 0x1e, 0x6c, 0x3c, 0xd, 0xd7, 0x7d, 0xbb, 0x19, 0xbc, 0xe4, 0x7, 0xfd, 0xf8, 0x66, 0x6d, 0x78, 0xf6, 0x4, 0xe6, 0x51, 0xe4, 0xe6, 0xdc, 0xe, 0x5a, 0x2e, 0xac, 0xe6, 0xe7, 0x24, 0x69}} return a, nil } @@ -1059,7 +1060,7 @@ func _1633349838_add_emoji_column_in_chatsUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1633349838_add_emoji_column_in_chats.up.sql", size: 52, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1633349838_add_emoji_column_in_chats.up.sql", size: 52, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xcb, 0x33, 0xcb, 0x3b, 0xa9, 0x99, 0x77, 0x6a, 0xea, 0xc4, 0x39, 0xd7, 0xa1, 0x49, 0xa7, 0xdf, 0xff, 0x72, 0xda, 0x34, 0x21, 0x67, 0x66, 0xca, 0x65, 0x46, 0x1, 0xa6, 0x4e, 0xf9, 0x38, 0x86}} return a, nil } @@ -1079,7 +1080,7 @@ func _1634831235_add_highlight_column_in_chatsUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1634831235_add_highlight_column_in_chats.up.sql", size: 62, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1634831235_add_highlight_column_in_chats.up.sql", size: 62, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xaa, 0x63, 0x5c, 0x73, 0x19, 0x83, 0xbd, 0x35, 0x80, 0x9f, 0x66, 0xec, 0x4c, 0xbc, 0x9d, 0x2d, 0x52, 0x91, 0x6d, 0xb3, 0x2b, 0x87, 0xde, 0x24, 0x46, 0x5c, 0xd, 0xfd, 0x78, 0xf5, 0xe3, 0xe9}} return a, nil } @@ -1099,7 +1100,7 @@ func _1634896007_add_last_updated_locally_and_removedUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1634896007_add_last_updated_locally_and_removed.up.sql", size: 131, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1634896007_add_last_updated_locally_and_removed.up.sql", size: 131, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x2e, 0xa8, 0x34, 0xe2, 0xc0, 0x62, 0xc8, 0xd6, 0x5a, 0x87, 0xe3, 0x70, 0xe1, 0xc4, 0x16, 0x9c, 0x60, 0x2e, 0x98, 0xf0, 0x91, 0x84, 0xbe, 0xe0, 0xdf, 0x3e, 0x4d, 0x24, 0xc4, 0x6c, 0x40, 0x17}} return a, nil } @@ -1119,7 +1120,7 @@ func _1635840039_add_clock_read_at_column_in_chatsUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1635840039_add_clock_read_at_column_in_chats.up.sql", size: 245, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1635840039_add_clock_read_at_column_in_chats.up.sql", size: 245, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x6c, 0xba, 0x3f, 0xba, 0x1a, 0x71, 0xa8, 0x9, 0x19, 0xbe, 0x1e, 0x38, 0x50, 0x30, 0x3a, 0x52, 0x15, 0x29, 0xee, 0x49, 0x19, 0x6f, 0x53, 0xc2, 0xc6, 0x6c, 0xd9, 0x80, 0x7e, 0xb9, 0x58, 0x7a}} return a, nil } @@ -1139,7 +1140,7 @@ func _1637852321_add_received_invitation_admin_column_in_chatsUpSql() (*asset, e return nil, err } - info := bindataFileInfo{name: "1637852321_add_received_invitation_admin_column_in_chats.up.sql", size: 72, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1637852321_add_received_invitation_admin_column_in_chats.up.sql", size: 72, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x70, 0x8b, 0x92, 0x56, 0x83, 0x70, 0x7f, 0x6, 0xb2, 0xd, 0x1c, 0x2f, 0xcc, 0x93, 0xc3, 0x85, 0x8c, 0xc2, 0x38, 0x94, 0x7e, 0x88, 0x3f, 0x39, 0x34, 0xf8, 0x90, 0xcf, 0x83, 0x68, 0x3d, 0xe5}} return a, nil } @@ -1159,7 +1160,7 @@ func _1645034601_display_nameUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1645034601_display_name.up.sql", size: 110, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1645034601_display_name.up.sql", size: 110, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x15, 0xfc, 0xda, 0x70, 0x53, 0x19, 0x90, 0x20, 0x4, 0x1c, 0x99, 0x42, 0x53, 0x1a, 0xd6, 0xb8, 0xbb, 0x8a, 0xe8, 0xbe, 0xcc, 0xb7, 0xc, 0x7f, 0x73, 0x50, 0x18, 0xf1, 0x8b, 0x18, 0x54, 0x64}} return a, nil } @@ -1179,7 +1180,7 @@ func _1645034602_add_mutual_contact_requestUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1645034602_add_mutual_contact_request.up.sql", size: 454, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1645034602_add_mutual_contact_request.up.sql", size: 454, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x1a, 0xe0, 0x5d, 0x68, 0xb8, 0x50, 0xa4, 0xbb, 0x3e, 0x4f, 0x2, 0x87, 0xad, 0x87, 0x6e, 0x38, 0xdf, 0xc8, 0x4c, 0xe2, 0x5f, 0xd1, 0x6, 0xdc, 0xe7, 0xbd, 0x4a, 0x9c, 0xf3, 0x91, 0xa1, 0x51}} return a, nil } @@ -1199,7 +1200,7 @@ func _1650373957_add_contact_request_stateUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1650373957_add_contact_request_state.up.sql", size: 59, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1650373957_add_contact_request_state.up.sql", size: 59, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x5e, 0xc1, 0x3f, 0x29, 0xe, 0x19, 0x86, 0x1a, 0x4c, 0x6c, 0x2a, 0x90, 0x9d, 0xdf, 0xb1, 0xb, 0x72, 0x25, 0xcd, 0x6c, 0x5f, 0xd, 0x51, 0x9e, 0x85, 0xc0, 0x9, 0xb7, 0xbc, 0x87, 0x23, 0xec}} return a, nil } @@ -1219,7 +1220,7 @@ func _1656958989_contact_verificationUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1656958989_contact_verification.up.sql", size: 624, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1656958989_contact_verification.up.sql", size: 624, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x3a, 0x3f, 0x28, 0x38, 0x33, 0xdb, 0xe9, 0x4d, 0xc0, 0x54, 0x8c, 0x2a, 0x73, 0xc4, 0xdd, 0x5c, 0xc5, 0x1a, 0x93, 0x4b, 0x6, 0x13, 0xbe, 0x42, 0xd2, 0x7f, 0xd4, 0xc, 0xc5, 0x4e, 0x6d, 0xce}} return a, nil } @@ -1239,7 +1240,7 @@ func _1658236268_add_discord_message_authors_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1658236268_add_discord_message_authors_table.up.sql", size: 191, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1658236268_add_discord_message_authors_table.up.sql", size: 191, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x3d, 0xb7, 0xdb, 0x79, 0x1, 0x15, 0xe7, 0x76, 0x5d, 0x22, 0x54, 0x82, 0x9a, 0xbe, 0x24, 0xc1, 0x82, 0xcf, 0x67, 0x91, 0x53, 0xcc, 0xac, 0x74, 0x18, 0x61, 0x69, 0x68, 0x19, 0xca, 0x2b, 0xa8}} return a, nil } @@ -1259,7 +1260,7 @@ func _1659619997_add_discord_messages_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1659619997_add_discord_messages_table.up.sql", size: 371, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1659619997_add_discord_messages_table.up.sql", size: 371, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xde, 0x12, 0x9c, 0x96, 0xe2, 0x42, 0x3f, 0x94, 0x62, 0xc2, 0x76, 0xab, 0x3b, 0x4c, 0x85, 0x36, 0x48, 0xcc, 0x73, 0x60, 0x93, 0x5a, 0xd6, 0x7, 0xd6, 0x0, 0xee, 0x1b, 0x1e, 0x34, 0x58, 0x99}} return a, nil } @@ -1279,7 +1280,7 @@ func _1660226788_create_chat_identity_social_linksUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1660226788_create_chat_identity_social_links.up.sql", size: 318, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1660226788_create_chat_identity_social_links.up.sql", size: 318, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x3c, 0x76, 0x40, 0xe9, 0x85, 0xc4, 0x38, 0xf8, 0xe5, 0x5d, 0xe8, 0x13, 0x46, 0x1b, 0xc, 0x1, 0xe9, 0x2f, 0x74, 0xd1, 0x79, 0x59, 0xa4, 0xdb, 0x4a, 0x4a, 0xf4, 0x98, 0x58, 0x3c, 0x57, 0xd3}} return a, nil } @@ -1299,7 +1300,7 @@ func _1660226789_add_walletconnectsessions_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1660226789_add_walletconnectsessions_table.up.sql", size: 215, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1660226789_add_walletconnectsessions_table.up.sql", size: 215, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xf8, 0x5c, 0x72, 0x2, 0xed, 0x36, 0x19, 0x91, 0x4d, 0x1a, 0xc1, 0xab, 0x84, 0xfa, 0x41, 0xb1, 0x46, 0xa5, 0xdb, 0x3f, 0x76, 0x47, 0xd3, 0x75, 0x3c, 0x6a, 0x8e, 0x78, 0xe6, 0x41, 0xdc, 0x7f}} return a, nil } @@ -1319,7 +1320,7 @@ func _1661242854_add_communities_requests_to_leaveUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1661242854_add_communities_requests_to_leave.up.sql", size: 204, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1661242854_add_communities_requests_to_leave.up.sql", size: 204, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x49, 0x2e, 0x7d, 0x14, 0xef, 0x6e, 0x95, 0x4b, 0x6, 0x70, 0x2e, 0xd1, 0xf6, 0x59, 0xf9, 0xe, 0x56, 0xa, 0x9c, 0x80, 0x18, 0xca, 0xb9, 0x49, 0x19, 0xf, 0x89, 0x94, 0x36, 0x6d, 0x93, 0x9a}} return a, nil } @@ -1339,7 +1340,7 @@ func _1662044232_add_chat_imageUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1662044232_add_chat_image.up.sql", size: 49, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1662044232_add_chat_image.up.sql", size: 49, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xb3, 0x74, 0xdf, 0x50, 0x79, 0x73, 0x9e, 0xd0, 0xff, 0xa4, 0xd3, 0x87, 0xc3, 0x48, 0x31, 0x6c, 0xdf, 0xa6, 0x20, 0x85, 0xe6, 0x4e, 0x19, 0x9d, 0xef, 0xcc, 0x84, 0x2b, 0x5d, 0x44, 0x34, 0x6}} return a, nil } @@ -1359,7 +1360,7 @@ func _1662106895_add_chat_first_message_timestampUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1662106895_add_chat_first_message_timestamp.up.sql", size: 113, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1662106895_add_chat_first_message_timestamp.up.sql", size: 113, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x8b, 0x55, 0x74, 0xfa, 0xf5, 0x51, 0x85, 0x19, 0xfd, 0xfb, 0x6, 0x79, 0x4d, 0x1d, 0xd, 0x3, 0x46, 0x66, 0x34, 0x1e, 0xce, 0x91, 0x21, 0x29, 0xf6, 0x71, 0xe7, 0x31, 0x39, 0x8f, 0x9d, 0x5}} return a, nil } @@ -1379,7 +1380,7 @@ func _1662723928_add_discord_author_image_fieldsUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1662723928_add_discord_author_image_fields.up.sql", size: 75, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1662723928_add_discord_author_image_fields.up.sql", size: 75, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x1e, 0x5b, 0x48, 0x57, 0x98, 0x55, 0x9a, 0xf1, 0x75, 0xf7, 0xb5, 0x41, 0x5e, 0x96, 0xc5, 0xce, 0xfc, 0x30, 0x5c, 0x15, 0x35, 0x9e, 0x4e, 0x4a, 0x3b, 0x38, 0x42, 0xc4, 0x27, 0x3c, 0x87, 0xbf}} return a, nil } @@ -1399,7 +1400,7 @@ func _1664195977_add_deleted_for_mesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1664195977_add_deleted_for_mes.up.sql", size: 352, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1664195977_add_deleted_for_mes.up.sql", size: 352, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x7d, 0x9d, 0x13, 0x9, 0xaa, 0x44, 0x14, 0x93, 0xe2, 0xf5, 0x53, 0xb7, 0x79, 0xa8, 0x18, 0xf0, 0x6c, 0xa4, 0x9c, 0x73, 0xc1, 0xaa, 0xc5, 0x2e, 0xc5, 0x41, 0xd7, 0x24, 0xb0, 0xd7, 0xb8, 0xdf}} return a, nil } @@ -1419,7 +1420,7 @@ func _1664367420_add_discord_attachments_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1664367420_add_discord_attachments_table.up.sql", size: 350, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1664367420_add_discord_attachments_table.up.sql", size: 350, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x48, 0xe1, 0xb6, 0x4f, 0x6f, 0x92, 0x0, 0xb4, 0xf, 0x55, 0x12, 0x1c, 0x98, 0x6d, 0xbc, 0x1e, 0xfd, 0xae, 0x1c, 0xce, 0xd1, 0x3d, 0x2, 0x21, 0x2e, 0xc0, 0x13, 0xa, 0xb2, 0xec, 0x81, 0x13}} return a, nil } @@ -1439,7 +1440,7 @@ func _1665079662_add_spectated_column_in_communitiesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1665079662_add_spectated_column_in_communities.up.sql", size: 86, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1665079662_add_spectated_column_in_communities.up.sql", size: 86, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xa0, 0x5d, 0xfe, 0xe2, 0xbe, 0xdf, 0xba, 0x45, 0xe9, 0xfc, 0xa7, 0x5f, 0xda, 0x19, 0xdb, 0x40, 0x96, 0x59, 0x78, 0xa, 0xd7, 0x4a, 0xca, 0x1a, 0x93, 0xfb, 0xae, 0x6d, 0x74, 0x7, 0x36, 0xdd}} return a, nil } @@ -1459,7 +1460,7 @@ func _1665479047_add_community_id_in_notificationsUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1665479047_add_community_id_in_notifications.up.sql", size: 169, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1665479047_add_community_id_in_notifications.up.sql", size: 169, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd9, 0x8f, 0x8b, 0x1c, 0xaa, 0x6a, 0x56, 0xd6, 0xa5, 0x88, 0x57, 0x13, 0x8f, 0xea, 0xb9, 0x23, 0x82, 0x50, 0xb7, 0x65, 0x1f, 0xab, 0xfa, 0x23, 0x6f, 0x0, 0x7, 0xb6, 0x6e, 0xb5, 0x85, 0x44}} return a, nil } @@ -1479,7 +1480,7 @@ func _1665484435_add_encrypted_messagesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1665484435_add_encrypted_messages.up.sql", size: 402, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1665484435_add_encrypted_messages.up.sql", size: 402, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x8f, 0x5c, 0x1e, 0x1c, 0x7f, 0xae, 0x5f, 0xeb, 0x3c, 0x6c, 0xcd, 0xc2, 0x99, 0x48, 0x5c, 0x83, 0xa0, 0xa2, 0x97, 0x5, 0x39, 0x82, 0x71, 0x90, 0x47, 0x21, 0x84, 0x29, 0x19, 0xa4, 0x7a, 0x90}} return a, nil } @@ -1499,7 +1500,7 @@ func _1665560200_add_contact_verification_individualUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1665560200_add_contact_verification_individual.up.sql", size: 509, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1665560200_add_contact_verification_individual.up.sql", size: 509, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc5, 0xbb, 0x61, 0xfd, 0xbf, 0x33, 0x1d, 0x4e, 0x5f, 0xbd, 0x86, 0x42, 0xb0, 0x6c, 0xf7, 0x39, 0x19, 0x6e, 0x72, 0x35, 0xfd, 0x1b, 0xd6, 0xbd, 0xf6, 0x81, 0x21, 0xc4, 0xaa, 0x6, 0x62, 0x40}} return a, nil } @@ -1519,7 +1520,7 @@ func _1670921937_add_album_idUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1670921937_add_album_id.up.sql", size: 55, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1670921937_add_album_id.up.sql", size: 55, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x7e, 0xae, 0x83, 0x58, 0xb7, 0x77, 0x5, 0xca, 0xe3, 0xda, 0x32, 0x8f, 0x7b, 0xa4, 0x2f, 0x4c, 0xaf, 0x5f, 0xfa, 0x94, 0x36, 0xe4, 0xf9, 0x7, 0xc6, 0xd6, 0xb7, 0x90, 0xf3, 0xe5, 0xb5, 0x3}} return a, nil } @@ -1539,7 +1540,7 @@ func _1673373000_add_repliedUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1673373000_add_replied.up.sql", size: 67, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1673373000_add_replied.up.sql", size: 67, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd5, 0x1c, 0xae, 0xf2, 0xf, 0xb4, 0xc2, 0xba, 0x3c, 0xfe, 0x7b, 0xb0, 0xf, 0xf, 0xd5, 0xbc, 0xe2, 0xa7, 0xad, 0x50, 0xd9, 0x5a, 0xe8, 0x96, 0x22, 0x65, 0x89, 0xcf, 0x4a, 0x9a, 0x1b, 0x94}} return a, nil } @@ -1559,7 +1560,7 @@ func _1673428910_add_image_width_heightUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1673428910_add_image_width_height.up.sql", size: 117, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1673428910_add_image_width_height.up.sql", size: 117, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x74, 0xda, 0x93, 0x2a, 0x9b, 0x6b, 0xb7, 0x96, 0xcd, 0xac, 0xf, 0xaf, 0x54, 0x89, 0x9e, 0x91, 0x5b, 0xd0, 0x4a, 0xa, 0x8d, 0x9e, 0x80, 0x66, 0x26, 0x9e, 0xb5, 0xa9, 0x8, 0xec, 0x2d, 0x6c}} return a, nil } @@ -1579,7 +1580,7 @@ func _1674210659_add_contact_request_local_clockUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1674210659_add_contact_request_local_clock.up.sql", size: 691, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1674210659_add_contact_request_local_clock.up.sql", size: 691, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x92, 0x72, 0x39, 0xfe, 0x72, 0x98, 0xfc, 0x91, 0x20, 0x10, 0xe8, 0xf5, 0xac, 0x79, 0xa8, 0x1c, 0xca, 0x7b, 0x35, 0xa, 0xc1, 0x56, 0x49, 0x9a, 0xfc, 0xbd, 0x64, 0x9d, 0xdf, 0xd2, 0x60, 0x70}} return a, nil } @@ -1599,7 +1600,7 @@ func _1675212323_add_deleted_byUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1675212323_add_deleted_by.up.sql", size: 57, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1675212323_add_deleted_by.up.sql", size: 57, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x85, 0x37, 0x29, 0x2f, 0xd, 0x5a, 0xb6, 0xdb, 0xa7, 0x8, 0x86, 0xfc, 0x7a, 0x70, 0xd8, 0x4d, 0xe6, 0xf0, 0x57, 0xe7, 0xd1, 0x95, 0xd5, 0x4, 0x40, 0x2f, 0x7a, 0x5, 0x4f, 0xc2, 0x97, 0xbc}} return a, nil } @@ -1619,7 +1620,7 @@ func _1675247084_add_activity_center_statesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1675247084_add_activity_center_states.up.sql", size: 136, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1675247084_add_activity_center_states.up.sql", size: 136, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xba, 0x90, 0x7d, 0x55, 0xc7, 0x40, 0x29, 0x26, 0x97, 0x45, 0x5c, 0xdf, 0xba, 0x61, 0xb, 0xfc, 0x3d, 0x7a, 0x6c, 0x42, 0xe4, 0x95, 0x78, 0xb0, 0xc5, 0x1f, 0x73, 0xe9, 0x33, 0x51, 0xc8, 0x81}} return a, nil } @@ -1639,7 +1640,7 @@ func _1675272329_fix_protocol_migrationUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1675272329_fix_protocol_migration.up.sql", size: 183, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1675272329_fix_protocol_migration.up.sql", size: 183, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xb6, 0xe0, 0x11, 0x4c, 0x66, 0x55, 0x72, 0xd3, 0xe6, 0x98, 0xa4, 0xe7, 0x44, 0xf9, 0x3b, 0x3a, 0x3f, 0xd9, 0x91, 0x1e, 0x4f, 0xfc, 0x56, 0x63, 0xe5, 0xa4, 0x83, 0xfc, 0x7c, 0xcf, 0x18, 0x99}} return a, nil } @@ -1659,7 +1660,7 @@ func _1676998418_fix_activity_center_migrationUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1676998418_fix_activity_center_migration.up.sql", size: 178, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1676998418_fix_activity_center_migration.up.sql", size: 178, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x8a, 0xdc, 0x64, 0xb1, 0x47, 0x67, 0xda, 0x2c, 0x26, 0x29, 0x6b, 0x6f, 0xb, 0xfa, 0x45, 0xf3, 0xad, 0x8b, 0x1a, 0x5f, 0x1c, 0xed, 0xd7, 0xea, 0x54, 0xf5, 0x3f, 0xb8, 0xf6, 0xf9, 0x44, 0x53}} return a, nil } @@ -1679,7 +1680,7 @@ func _1677278861_add_deleted_column_to_activity_center_notifications_tableUpSql( return nil, err } - info := bindataFileInfo{name: "1677278861_add_deleted_column_to_activity_center_notifications_table.up.sql", size: 381, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1677278861_add_deleted_column_to_activity_center_notifications_table.up.sql", size: 381, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x38, 0x3a, 0x95, 0xaf, 0x81, 0xb0, 0x85, 0x8d, 0x73, 0xda, 0x7b, 0x2a, 0x35, 0xa6, 0xaa, 0xcc, 0x4c, 0x35, 0xa3, 0xa8, 0xbd, 0xd1, 0x37, 0xe8, 0x5d, 0x83, 0xa4, 0x33, 0x1f, 0x10, 0xe4, 0xe6}} return a, nil } @@ -1699,7 +1700,7 @@ func _1677486338_add_community_tokens_tableUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1677486338_add_community_tokens_table.up.sql", size: 527, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1677486338_add_community_tokens_table.up.sql", size: 527, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xfb, 0x7b, 0x3d, 0x7e, 0x79, 0xc4, 0x3a, 0xf1, 0xda, 0x4b, 0xc6, 0xd1, 0xd, 0xfb, 0xb2, 0xb9, 0x7f, 0x81, 0x29, 0xab, 0xd8, 0x1, 0x20, 0xd7, 0xe1, 0xaf, 0x3e, 0x67, 0x1b, 0xdb, 0xf9, 0xd5}} return a, nil } @@ -1719,7 +1720,7 @@ func _1678292329_add_collapsed_categoriesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1678292329_add_collapsed_categories.up.sql", size: 170, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1678292329_add_collapsed_categories.up.sql", size: 170, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x46, 0x63, 0x86, 0xd5, 0x7, 0xe2, 0x25, 0x15, 0x1b, 0xfe, 0xf3, 0xe, 0x50, 0x48, 0x11, 0x3c, 0x7c, 0xc6, 0xe5, 0xab, 0x8d, 0x1f, 0xe8, 0x3c, 0xcb, 0xf0, 0x8d, 0xa7, 0x49, 0x4c, 0x16, 0x4f}} return a, nil } @@ -1739,7 +1740,7 @@ func _1678800760_add_index_to_raw_messagesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1678800760_add_index_to_raw_messages.up.sql", size: 88, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1678800760_add_index_to_raw_messages.up.sql", size: 88, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x9d, 0xd9, 0x8d, 0x22, 0x46, 0xae, 0x7b, 0x53, 0x3e, 0x51, 0x39, 0xad, 0xad, 0x38, 0x50, 0x6, 0xfa, 0xb9, 0xc4, 0x9f, 0x8d, 0xd2, 0x67, 0x0, 0xef, 0x58, 0x13, 0xab, 0x6a, 0x67, 0xf3, 0x7e}} return a, nil } @@ -1759,7 +1760,7 @@ func _1678877478_add_communities_requests_to_join_revealed_addresses_tableUpSql( return nil, err } - info := bindataFileInfo{name: "1678877478_add_communities_requests_to_join_revealed_addresses_table.up.sql", size: 168, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1678877478_add_communities_requests_to_join_revealed_addresses_table.up.sql", size: 168, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x82, 0x1, 0xb4, 0xb2, 0x94, 0x25, 0xd5, 0x2e, 0x45, 0xc3, 0xb1, 0x2c, 0xeb, 0x1a, 0x52, 0xe0, 0x4b, 0x9b, 0x46, 0xf4, 0xc, 0xac, 0x1, 0x1e, 0x90, 0xbc, 0x64, 0x38, 0x10, 0xf1, 0xaf, 0xac}} return a, nil } @@ -1779,7 +1780,7 @@ func _1679326850_add_community_token_ownersUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1679326850_add_community_token_owners.up.sql", size: 206, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1679326850_add_community_token_owners.up.sql", size: 206, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xe9, 0xe6, 0x25, 0x67, 0xd1, 0xd6, 0x54, 0x88, 0xb1, 0x80, 0x1e, 0x2d, 0x9c, 0xfa, 0x1c, 0xc7, 0x63, 0x6e, 0xf9, 0x66, 0xb1, 0x68, 0xc6, 0xf8, 0x51, 0xb6, 0xd5, 0x4e, 0x93, 0x39, 0x5e, 0xc0}} return a, nil } @@ -1799,7 +1800,7 @@ func _1680011500_add_album_images_countUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1680011500_add_album_images_count.up.sql", size: 71, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1680011500_add_album_images_count.up.sql", size: 71, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x2e, 0x55, 0x99, 0x31, 0xcc, 0x80, 0x78, 0xc3, 0x51, 0x13, 0x63, 0x6f, 0x1a, 0xfd, 0x53, 0xd2, 0xf4, 0x13, 0x4b, 0xb2, 0x4f, 0x99, 0xb8, 0x7b, 0x7, 0x99, 0xb6, 0xab, 0x88, 0x2e, 0x7, 0x8}} return a, nil } @@ -1819,7 +1820,7 @@ func _1680114896_add_index_on_album_idUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1680114896_add_index_on_album_id.up.sql", size: 83, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1680114896_add_index_on_album_id.up.sql", size: 83, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xb3, 0x7e, 0xd5, 0xcd, 0x2d, 0xab, 0xd4, 0x32, 0x26, 0x50, 0x3a, 0x5b, 0x8e, 0x1c, 0xcc, 0x35, 0xf8, 0xa1, 0x2a, 0xc1, 0x23, 0xf6, 0x90, 0xfe, 0x84, 0x3, 0xde, 0x5a, 0xee, 0xc6, 0xfc, 0x2a}} return a, nil } @@ -1839,7 +1840,7 @@ func _1681655289_add_mute_tillUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1681655289_add_mute_till.up.sql", size: 51, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1681655289_add_mute_till.up.sql", size: 51, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd1, 0xbe, 0xce, 0xb8, 0xe1, 0x30, 0xe7, 0xa7, 0xe0, 0x7d, 0x97, 0xf4, 0x26, 0xb8, 0x57, 0x1d, 0x2a, 0xed, 0x18, 0xf2, 0xa, 0xe3, 0x77, 0x29, 0x18, 0x55, 0x9, 0x74, 0x2c, 0x24, 0x5a, 0x19}} return a, nil } @@ -1859,7 +1860,7 @@ func _1681934966_add_index_response_toUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1681934966_add_index_response_to.up.sql", size: 70, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1681934966_add_index_response_to.up.sql", size: 70, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x3b, 0xed, 0xa6, 0x7e, 0x51, 0xf2, 0xa1, 0x3c, 0x78, 0x9a, 0xa7, 0x7a, 0x51, 0x25, 0x7d, 0xdd, 0x4b, 0xf3, 0x45, 0xeb, 0x3f, 0xad, 0x23, 0x3e, 0xac, 0x16, 0x28, 0x62, 0x7, 0x8c, 0xe0, 0xa0}} return a, nil } @@ -1879,7 +1880,7 @@ func _1682528339_add_index_user_messages_unseenUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1682528339_add_index_user_messages_unseen.up.sql", size: 104, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1682528339_add_index_user_messages_unseen.up.sql", size: 104, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x35, 0xfa, 0x98, 0xdd, 0x74, 0x5e, 0x21, 0x1f, 0xf2, 0x56, 0x17, 0x96, 0xfe, 0xbb, 0x44, 0x4c, 0xa1, 0xd8, 0x9f, 0x2e, 0x6, 0x2f, 0xd8, 0x23, 0xec, 0x94, 0x8c, 0x53, 0xf3, 0xf0, 0x40, 0xe7}} return a, nil } @@ -1899,7 +1900,7 @@ func _1683707289_recreate_deleted_for_mesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1683707289_recreate_deleted_for_mes.up.sql", size: 408, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1683707289_recreate_deleted_for_mes.up.sql", size: 408, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x5b, 0x9d, 0xd6, 0x45, 0x41, 0x29, 0x44, 0xf6, 0x14, 0x38, 0xeb, 0xdf, 0x6b, 0x5d, 0x9c, 0x45, 0x4b, 0xc3, 0xa8, 0xbd, 0x38, 0x14, 0xd9, 0x73, 0xf1, 0x51, 0xbb, 0x9f, 0x14, 0x36, 0xf2, 0x11}} return a, nil } @@ -1919,7 +1920,7 @@ func _1683725607_mark_discord_messages_as_seenUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1683725607_mark_discord_messages_as_seen.up.sql", size: 108, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1683725607_mark_discord_messages_as_seen.up.sql", size: 108, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd7, 0x2a, 0xc3, 0x43, 0xea, 0x5e, 0x3, 0x2e, 0xce, 0x79, 0xea, 0xa5, 0x67, 0x61, 0x8c, 0xe4, 0xb9, 0xb7, 0x4d, 0xd5, 0xd5, 0xb0, 0x35, 0xc8, 0x2b, 0xa0, 0x3f, 0xd8, 0xde, 0xea, 0x4e, 0x16}} return a, nil } @@ -1939,7 +1940,7 @@ func _1684174617_add_url_previews_to_user_messagesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1684174617_add_url_previews_to_user_messages.up.sql", size: 58, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1684174617_add_url_previews_to_user_messages.up.sql", size: 58, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xdc, 0xb0, 0x72, 0xe3, 0xe4, 0xa9, 0x63, 0x82, 0xea, 0x52, 0x70, 0xb6, 0xa0, 0x73, 0x55, 0x7a, 0x78, 0xa8, 0xd2, 0xb0, 0xf4, 0x78, 0x8a, 0xd, 0x5a, 0xa2, 0x9d, 0x92, 0xdc, 0xce, 0x1c, 0x71}} return a, nil } @@ -1959,7 +1960,7 @@ func _1684175608_add_token_balancesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1684175608_add_token_balances.up.sql", size: 467, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1684175608_add_token_balances.up.sql", size: 467, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x1b, 0x4e, 0xe0, 0x48, 0x34, 0x1, 0x4d, 0x88, 0x11, 0x54, 0x20, 0x52, 0x5c, 0x57, 0x14, 0xa9, 0xa9, 0x36, 0xa4, 0x28, 0x59, 0x48, 0xa8, 0xa, 0x76, 0xec, 0x37, 0xee, 0x9e, 0xd2, 0x20, 0xaa}} return a, nil } @@ -1979,7 +1980,7 @@ func _1684979808_sync_activity_center_notificationsUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1684979808_sync_activity_center_notifications.up.sql", size: 169, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1684979808_sync_activity_center_notifications.up.sql", size: 169, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xd8, 0xf5, 0xf7, 0x94, 0xa9, 0xa1, 0x60, 0x26, 0x9d, 0xca, 0x31, 0xf, 0x14, 0xd, 0x70, 0xf8, 0xab, 0x40, 0x29, 0x73, 0x61, 0xbd, 0x1b, 0xb6, 0xc4, 0x31, 0x77, 0x9e, 0x32, 0xa8, 0xce, 0x6d}} return a, nil } @@ -1999,7 +2000,7 @@ func _1685383829_add_communities_mute_tillUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1685383829_add_communities_mute_till.up.sql", size: 69, mode: os.FileMode(0644), modTime: time.Unix(1687941008, 0)} + info := bindataFileInfo{name: "1685383829_add_communities_mute_till.up.sql", size: 69, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xbf, 0x58, 0x96, 0xe5, 0x66, 0xcb, 0xde, 0xed, 0x76, 0xb8, 0x5a, 0x86, 0x81, 0x9a, 0x60, 0x51, 0x12, 0x37, 0x54, 0x9a, 0x36, 0x3e, 0xd1, 0x4a, 0xbe, 0x9a, 0xab, 0x20, 0x7f, 0x1d, 0xf4, 0x73}} return a, nil } @@ -2019,7 +2020,7 @@ func _1685964183_add_chainids_to_revealed_addressesUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1685964183_add_chainids_to_revealed_addresses.up.sql", size: 88, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1685964183_add_chainids_to_revealed_addresses.up.sql", size: 88, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc, 0xb5, 0xa8, 0xd7, 0xad, 0x9c, 0x54, 0xa5, 0xe9, 0xdb, 0x42, 0x2d, 0xd0, 0xd7, 0x22, 0x1, 0x93, 0xf3, 0x4f, 0x53, 0xf7, 0x1e, 0xbe, 0x4b, 0xac, 0xc7, 0x63, 0x15, 0xdf, 0xe0, 0x6, 0xf8}} return a, nil } @@ -2039,7 +2040,7 @@ func _1687370421_add_communities_muted_till_newUpSql() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "1687370421_add_communities_muted_till_new.up.sql", size: 635, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1687370421_add_communities_muted_till_new.up.sql", size: 635, mode: os.FileMode(0644), modTime: time.Unix(1687875721, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x65, 0x73, 0x96, 0x1d, 0xc8, 0x3e, 0xca, 0xf5, 0xdc, 0xe3, 0xac, 0x3f, 0x9c, 0xc3, 0x67, 0x12, 0x9c, 0x19, 0x1, 0x4, 0x2b, 0xea, 0x6b, 0xe1, 0x59, 0x59, 0x89, 0x3d, 0xef, 0x4a, 0x6e, 0xbe}} return a, nil } @@ -2059,11 +2060,31 @@ func _1687416607_add_communities_check_channel_permission_responses_tableUpSql() return nil, err } - info := bindataFileInfo{name: "1687416607_add_communities_check_channel_permission_responses_table.up.sql", size: 739, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "1687416607_add_communities_check_channel_permission_responses_table.up.sql", size: 739, mode: os.FileMode(0644), modTime: time.Unix(1687875721, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xc2, 0x6, 0x3, 0x1a, 0xde, 0x9d, 0xbc, 0x50, 0x9d, 0xf1, 0x6d, 0x5a, 0x1c, 0x28, 0x92, 0x19, 0x89, 0x76, 0x4e, 0x8b, 0x60, 0xa9, 0xf, 0xe9, 0x76, 0xf1, 0xee, 0x75, 0x92, 0xbd, 0xda, 0x72}} return a, nil } +var __1687856939_add_community_tokens_decimalsUpSql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x72\xf4\x09\x71\x0d\x52\x08\x71\x74\xf2\x71\x55\x48\xce\xcf\xcd\x2d\xcd\xcb\x2c\xa9\x8c\x2f\xc9\xcf\x4e\xcd\x2b\x56\x70\x74\x71\x51\x70\xf6\xf7\x09\xf5\xf5\x53\x48\x49\x4d\xce\xcc\x4d\xcc\x29\x56\xf0\xf4\x0b\x51\x70\x71\x75\x73\x0c\xf5\x09\x51\x30\xb4\xb0\xe6\x02\x04\x00\x00\xff\xff\x00\x67\xca\x06\x41\x00\x00\x00") + +func _1687856939_add_community_tokens_decimalsUpSqlBytes() ([]byte, error) { + return bindataRead( + __1687856939_add_community_tokens_decimalsUpSql, + "1687856939_add_community_tokens_decimals.up.sql", + ) +} + +func _1687856939_add_community_tokens_decimalsUpSql() (*asset, error) { + bytes, err := _1687856939_add_community_tokens_decimalsUpSqlBytes() + if err != nil { + return nil, err + } + + info := bindataFileInfo{name: "1687856939_add_community_tokens_decimals.up.sql", size: 65, mode: os.FileMode(0644), modTime: time.Unix(1688042120, 0)} + a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x59, 0x76, 0x42, 0x70, 0xc9, 0x7b, 0x16, 0xf6, 0xfe, 0x7, 0x1c, 0x99, 0xe5, 0x38, 0xfd, 0xa0, 0x3b, 0x93, 0x40, 0xbc, 0x66, 0xc2, 0xd1, 0xdd, 0xe9, 0xc7, 0xbf, 0xae, 0x36, 0xcc, 0x46, 0x57}} + return a, nil +} + var _readmeMd = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x54\x91\xc1\xce\xd3\x30\x10\x84\xef\x7e\x8a\x91\x7a\x01\xa9\x2a\x8f\xc0\x0d\x71\x82\x03\x48\x1c\xc9\x36\x9e\x36\x96\x1c\x6f\xf0\xae\x93\xe6\xed\x91\xa3\xc2\xdf\xff\x66\xed\xd8\x33\xdf\x78\x4f\xa7\x13\xbe\xea\x06\x57\x6c\x35\x39\x31\xa7\x7b\x15\x4f\x5a\xec\x73\x08\xbf\x08\x2d\x79\x7f\x4a\x43\x5b\x86\x17\xfd\x8c\x21\xea\x56\x5e\x47\x90\x4a\x14\x75\x48\xde\x64\x37\x2c\x6a\x96\xae\x99\x48\x05\xf6\x27\x77\x13\xad\x08\xae\x8a\x51\xe7\x25\xf3\xf1\xa9\x9f\xf9\x58\x58\x2c\xad\xbc\xe0\x8b\x56\xf0\x21\x5d\xeb\x4c\x95\xb3\xae\x84\x60\xd4\xdc\xe6\x82\x5d\x1b\x36\x6d\x39\x62\x92\xf5\xb8\x11\xdb\x92\xd3\x28\xce\xe0\x13\xe1\x72\xcd\x3c\x63\xd4\x65\x87\xae\xac\xe8\xc3\x28\x2e\x67\x44\x66\x3a\x21\x25\xa2\x72\xac\x14\x67\xbc\x84\x9f\x53\x32\x8c\x52\x70\x25\x56\xd6\xfd\x8d\x05\x37\xad\x30\x9d\x9f\xa6\x86\x0f\xcd\x58\x7f\xcf\x34\x93\x3b\xed\x90\x9f\xa4\x1f\xcf\x30\x85\x4d\x07\x58\xaf\x7f\x25\xc4\x9d\xf3\x72\x64\x84\xd0\x7f\xf9\x9b\x3a\x2d\x84\xef\x85\x48\x66\x8d\xd8\x88\x9b\x8c\x8c\x98\x5b\xf6\x74\x14\x4e\x33\x0d\xc9\xe0\x93\x38\xda\x12\xc5\x69\xbd\xe4\xf0\x2e\x7a\x78\x07\x1c\xfe\x13\x9f\x91\x29\x31\x95\x7b\x7f\x62\x59\x37\xb4\xe5\x5e\x25\xfe\x33\xee\xd5\x53\x71\xd6\xda\x3a\xd8\xcb\xde\x2e\xf8\xa1\x90\x55\x53\x0c\xc7\xaa\x0d\xe9\x76\x14\x29\x1c\x7b\x68\xdd\x2f\xe1\x6f\x00\x00\x00\xff\xff\x3c\x0a\xc2\xfe\x2a\x02\x00\x00") func readmeMdBytes() ([]byte, error) { @@ -2079,7 +2100,7 @@ func readmeMd() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "README.md", size: 554, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "README.md", size: 554, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0x1c, 0x6e, 0xfb, 0xcc, 0x81, 0x94, 0x4d, 0x8c, 0xa0, 0x3b, 0x5, 0xb0, 0x18, 0xd6, 0xbb, 0xb3, 0x79, 0xc8, 0x8f, 0xff, 0xc1, 0x10, 0xf9, 0xf, 0x20, 0x1b, 0x4a, 0x74, 0x96, 0x42, 0xd7, 0xa8}} return a, nil } @@ -2099,7 +2120,7 @@ func docGo() (*asset, error) { return nil, err } - info := bindataFileInfo{name: "doc.go", size: 850, mode: os.FileMode(0644), modTime: time.Unix(1687889856, 0)} + info := bindataFileInfo{name: "doc.go", size: 850, mode: os.FileMode(0644), modTime: time.Unix(1687875194, 0)} a := &asset{bytes: bytes, info: info, digest: [32]uint8{0xa0, 0xcc, 0x41, 0xe1, 0x61, 0x12, 0x97, 0xe, 0x36, 0x8c, 0xa7, 0x9e, 0xe0, 0x6e, 0x59, 0x9e, 0xee, 0xd5, 0x4a, 0xcf, 0x1e, 0x60, 0xd6, 0xc3, 0x3a, 0xc9, 0x6c, 0xf2, 0x86, 0x5a, 0xb4, 0x1e}} return a, nil } @@ -2290,6 +2311,7 @@ var _bindata = map[string]func() (*asset, error){ "1685964183_add_chainids_to_revealed_addresses.up.sql": _1685964183_add_chainids_to_revealed_addressesUpSql, "1687370421_add_communities_muted_till_new.up.sql": _1687370421_add_communities_muted_till_newUpSql, "1687416607_add_communities_check_channel_permission_responses_table.up.sql": _1687416607_add_communities_check_channel_permission_responses_tableUpSql, + "1687856939_add_community_tokens_decimals.up.sql": _1687856939_add_community_tokens_decimalsUpSql, "README.md": readmeMd, "doc.go": docGo, } @@ -2435,6 +2457,7 @@ var _bintree = &bintree{nil, map[string]*bintree{ "1685964183_add_chainids_to_revealed_addresses.up.sql": {_1685964183_add_chainids_to_revealed_addressesUpSql, map[string]*bintree{}}, "1687370421_add_communities_muted_till_new.up.sql": {_1687370421_add_communities_muted_till_newUpSql, map[string]*bintree{}}, "1687416607_add_communities_check_channel_permission_responses_table.up.sql": {_1687416607_add_communities_check_channel_permission_responses_tableUpSql, map[string]*bintree{}}, + "1687856939_add_community_tokens_decimals.up.sql": {_1687856939_add_community_tokens_decimalsUpSql, map[string]*bintree{}}, "README.md": {readmeMd, map[string]*bintree{}}, "doc.go": {docGo, map[string]*bintree{}}, }} diff --git a/protocol/migrations/sqlite/1687856939_add_community_tokens_decimals.up.sql b/protocol/migrations/sqlite/1687856939_add_community_tokens_decimals.up.sql new file mode 100644 index 000000000..6b6ee0d20 --- /dev/null +++ b/protocol/migrations/sqlite/1687856939_add_community_tokens_decimals.up.sql @@ -0,0 +1 @@ +ALTER TABLE community_tokens ADD COLUMN decimals INT DEFAULT 18; diff --git a/protocol/protobuf/communities.pb.go b/protocol/protobuf/communities.pb.go index 89be36582..e3c92b461 100644 --- a/protocol/protobuf/communities.pb.go +++ b/protocol/protobuf/communities.pb.go @@ -236,6 +236,7 @@ type CommunityTokenMetadata struct { TokenType CommunityTokenType `protobuf:"varint,4,opt,name=tokenType,proto3,enum=protobuf.CommunityTokenType" json:"tokenType,omitempty"` Symbol string `protobuf:"bytes,5,opt,name=symbol,proto3" json:"symbol,omitempty"` Name string `protobuf:"bytes,6,opt,name=name,proto3" json:"name,omitempty"` + Decimals uint32 `protobuf:"varint,7,opt,name=decimals,proto3" json:"decimals,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -308,6 +309,13 @@ func (m *CommunityTokenMetadata) GetName() string { return "" } +func (m *CommunityTokenMetadata) GetDecimals() uint32 { + if m != nil { + return m.Decimals + } + return 0 +} + type CommunityPermissions struct { EnsOnly bool `protobuf:"varint,1,opt,name=ens_only,json=ensOnly,proto3" json:"ens_only,omitempty"` // https://gitlab.matrix.org/matrix-org/olm/blob/master/docs/megolm.md is a candidate for the algorithm to be used in case we want to have private communityal chats, lighter than pairwise encryption using the DR, less secure, but more efficient for large number of participants @@ -1651,130 +1659,130 @@ func init() { } var fileDescriptor_f937943d74c1cd8b = []byte{ - // 1991 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0x4f, 0x73, 0x23, 0x47, - 0x15, 0xcf, 0x48, 0xb2, 0x2d, 0x3d, 0x49, 0x5e, 0xb9, 0xf7, 0x8f, 0xc7, 0xde, 0xdd, 0xac, 0x77, - 0x80, 0xc2, 0x29, 0x0a, 0x6d, 0xe2, 0x40, 0xb1, 0x95, 0x40, 0x12, 0xad, 0x3c, 0x6c, 0xc4, 0xae, - 0x47, 0x4e, 0x4b, 0x9b, 0x85, 0x14, 0x30, 0xd5, 0x9e, 0x69, 0xcb, 0x5d, 0x2b, 0xcd, 0x88, 0xe9, - 0x96, 0x0b, 0x71, 0xc8, 0x89, 0x0f, 0xc1, 0x9d, 0x3b, 0x5f, 0x81, 0x03, 0x77, 0xee, 0xdc, 0xe0, - 0x42, 0x71, 0xe4, 0xc4, 0x81, 0x13, 0xd5, 0x7f, 0x66, 0x34, 0x23, 0x4b, 0xeb, 0x4d, 0x05, 0xaa, + // 1999 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0x4f, 0x73, 0x1b, 0x49, + 0x15, 0xdf, 0x91, 0x64, 0x5b, 0x7a, 0x92, 0x1c, 0xb9, 0x93, 0xd8, 0x63, 0x27, 0xd9, 0x28, 0x03, + 0x14, 0xde, 0xa2, 0x50, 0x76, 0xbd, 0x50, 0xa4, 0x76, 0x61, 0x77, 0x15, 0x79, 0xc8, 0x8a, 0xc4, + 0x23, 0x6f, 0x5b, 0xd9, 0xc0, 0x16, 0x30, 0xd5, 0x9e, 0x69, 0xcb, 0x5d, 0x91, 0x66, 0xc4, 0x74, + 0xcb, 0x85, 0x38, 0xec, 0x81, 0xe2, 0x43, 0x70, 0xe7, 0xce, 0x57, 0xe0, 0xc0, 0x9d, 0x3b, 0x37, + 0xb8, 0x71, 0xe4, 0xc4, 0x81, 0x13, 0xd5, 0x7f, 0x66, 0x34, 0x23, 0x4b, 0x49, 0xb6, 0x16, 0xaa, 0x38, 0x69, 0xde, 0xeb, 0xd7, 0xef, 0xf5, 0x7b, 0xef, 0xd7, 0xaf, 0xdf, 0x13, 0xec, 0x04, 0xf1, - 0x64, 0x32, 0x8b, 0x98, 0x60, 0x94, 0xb7, 0xa7, 0x49, 0x2c, 0x62, 0x54, 0x55, 0x3f, 0x67, 0xb3, - 0xf3, 0xfd, 0x9b, 0xc1, 0x05, 0x11, 0x3e, 0x0b, 0x69, 0x24, 0x98, 0x98, 0xeb, 0xe5, 0xfd, 0x3a, - 0x8d, 0x66, 0x13, 0x23, 0xeb, 0x5c, 0xc2, 0xc6, 0xd3, 0x84, 0x44, 0x02, 0x3d, 0x84, 0x46, 0xaa, - 0x69, 0xee, 0xb3, 0xd0, 0xb6, 0x0e, 0xac, 0xc3, 0x06, 0xae, 0x67, 0xbc, 0x5e, 0x88, 0xee, 0x42, - 0x6d, 0x42, 0x27, 0x67, 0x34, 0x91, 0xeb, 0x25, 0xb5, 0x5e, 0xd5, 0x8c, 0x5e, 0x88, 0x76, 0x61, - 0xcb, 0x18, 0xb3, 0xcb, 0x07, 0xd6, 0x61, 0x0d, 0x6f, 0x4a, 0xb2, 0x17, 0xa2, 0x5b, 0xb0, 0x11, - 0x8c, 0xe3, 0xe0, 0x95, 0x5d, 0x39, 0xb0, 0x0e, 0x2b, 0x58, 0x13, 0xce, 0xbf, 0x2d, 0xb8, 0xd1, - 0x4d, 0x75, 0x9f, 0x28, 0x25, 0xe8, 0xfb, 0xb0, 0x91, 0xc4, 0x63, 0xca, 0x6d, 0xeb, 0xa0, 0x7c, - 0xb8, 0x7d, 0xf4, 0xa0, 0x9d, 0xfa, 0xd1, 0x5e, 0x92, 0x6c, 0x63, 0x29, 0x86, 0xb5, 0x34, 0xfa, - 0x31, 0xec, 0x24, 0xf4, 0x92, 0x92, 0x31, 0x0d, 0x7d, 0x12, 0x04, 0xf1, 0x2c, 0x12, 0xdc, 0x2e, - 0x1d, 0x94, 0x0f, 0xeb, 0x47, 0x7b, 0x0b, 0x15, 0xd8, 0x88, 0x74, 0xb4, 0x04, 0x6e, 0x25, 0x45, - 0x06, 0x77, 0x2e, 0x60, 0x43, 0xe9, 0x45, 0x4d, 0xa8, 0xe1, 0xfe, 0x73, 0xd7, 0xf7, 0xfa, 0x9e, - 0xdb, 0x7a, 0x0b, 0x6d, 0x03, 0x28, 0xb2, 0xff, 0xd2, 0x73, 0x71, 0xcb, 0x42, 0xb7, 0x61, 0x47, - 0xd1, 0x27, 0x1d, 0xaf, 0xf3, 0xd4, 0xf5, 0x5f, 0x0c, 0x5c, 0x3c, 0x68, 0x95, 0xd0, 0x1e, 0xdc, - 0xd6, 0xec, 0xfe, 0xb1, 0x8b, 0x3b, 0x43, 0xd7, 0xef, 0xf6, 0xbd, 0xa1, 0xeb, 0x0d, 0x5b, 0xe5, - 0x4c, 0x43, 0xe7, 0xf8, 0xa4, 0xe7, 0xb5, 0x2a, 0xce, 0xdf, 0x4b, 0x70, 0x27, 0x73, 0x69, 0x18, - 0xbf, 0xa2, 0xd1, 0x09, 0x15, 0x24, 0x24, 0x82, 0xa0, 0x73, 0x40, 0x41, 0x1c, 0x89, 0x84, 0x04, - 0xc2, 0x27, 0x61, 0x98, 0x50, 0xce, 0x4d, 0x40, 0xea, 0x47, 0x3f, 0x58, 0x11, 0x90, 0xc2, 0xee, - 0x76, 0xd7, 0x6c, 0xed, 0xa4, 0x3b, 0xdd, 0x48, 0x24, 0x73, 0xbc, 0x13, 0x2c, 0xf3, 0xd1, 0x01, - 0xd4, 0x43, 0xca, 0x83, 0x84, 0x4d, 0x05, 0x8b, 0x23, 0x95, 0xcd, 0x1a, 0xce, 0xb3, 0x64, 0xde, - 0xd8, 0x84, 0x8c, 0xa8, 0x49, 0xa7, 0x26, 0xd0, 0x07, 0x50, 0x13, 0xd2, 0xe4, 0x70, 0x3e, 0xa5, - 0x2a, 0xa3, 0xdb, 0x47, 0xf7, 0xd6, 0x1d, 0x4b, 0xca, 0xe0, 0x85, 0x38, 0xba, 0x03, 0x9b, 0x7c, - 0x3e, 0x39, 0x8b, 0xc7, 0xf6, 0x86, 0x46, 0x88, 0xa6, 0x10, 0x82, 0x4a, 0x44, 0x26, 0xd4, 0xde, - 0x54, 0x5c, 0xf5, 0xbd, 0x7f, 0x2c, 0x23, 0xb4, 0xca, 0x19, 0xd4, 0x82, 0xf2, 0x2b, 0x3a, 0x57, - 0xf8, 0xac, 0x60, 0xf9, 0x29, 0x4f, 0x7a, 0x49, 0xc6, 0x33, 0x6a, 0xbc, 0xd0, 0xc4, 0x07, 0xa5, - 0xc7, 0x96, 0xf3, 0x57, 0x0b, 0x6e, 0x65, 0x67, 0x3a, 0xa5, 0xc9, 0x84, 0x71, 0xce, 0xe2, 0x88, - 0xa3, 0x3d, 0xa8, 0xd2, 0x88, 0xfb, 0x71, 0x34, 0xd6, 0x9a, 0xaa, 0x78, 0x8b, 0x46, 0xbc, 0x1f, - 0x8d, 0xe7, 0xc8, 0x86, 0xad, 0x69, 0xc2, 0x2e, 0x89, 0xd0, 0xfa, 0xaa, 0x38, 0x25, 0xd1, 0x8f, - 0x60, 0x93, 0x04, 0x01, 0xe5, 0x5c, 0x85, 0x64, 0xfb, 0xe8, 0x5b, 0x2b, 0x1c, 0xcf, 0x19, 0x69, - 0x77, 0x94, 0x30, 0x36, 0x9b, 0x9c, 0x21, 0x6c, 0x6a, 0x0e, 0x42, 0xb0, 0xfd, 0xc2, 0x7b, 0xe6, - 0xf5, 0x5f, 0x7a, 0x7e, 0xa7, 0xdb, 0x75, 0x07, 0x83, 0xd6, 0x5b, 0x68, 0x07, 0x9a, 0x5e, 0xdf, - 0x3f, 0x71, 0x4f, 0x9e, 0xb8, 0x78, 0xf0, 0x69, 0xef, 0xb4, 0x65, 0xa1, 0x9b, 0x70, 0xa3, 0xe7, - 0x7d, 0xde, 0x1b, 0x76, 0x86, 0xbd, 0xbe, 0xe7, 0xf7, 0xbd, 0xe7, 0x3f, 0x6b, 0x95, 0x24, 0x96, - 0xfa, 0x9e, 0x8f, 0xdd, 0xcf, 0x5e, 0xb8, 0x83, 0x61, 0xab, 0xec, 0xfc, 0xb6, 0x0c, 0x4d, 0x15, - 0xed, 0x6e, 0xc2, 0x04, 0x4d, 0x18, 0x41, 0xbf, 0x78, 0x0d, 0x84, 0xda, 0x8b, 0x23, 0x17, 0x36, - 0x7d, 0x05, 0xe4, 0xbc, 0x0b, 0x15, 0x21, 0x93, 0x5f, 0x7a, 0x83, 0xe4, 0x2b, 0xc9, 0x5c, 0xde, - 0xcb, 0x2b, 0xf3, 0x5e, 0x59, 0xe4, 0x5d, 0xca, 0x92, 0x89, 0xbc, 0x8f, 0x29, 0x46, 0x34, 0x25, - 0x6b, 0x8f, 0x02, 0x92, 0xcf, 0x42, 0x6e, 0x6f, 0x1e, 0x94, 0x0f, 0x2b, 0xb8, 0xaa, 0x18, 0xbd, - 0x90, 0xa3, 0x07, 0x50, 0x97, 0xd9, 0x9c, 0x12, 0x21, 0x68, 0x12, 0xd9, 0x5b, 0x6a, 0x27, 0xd0, - 0x88, 0x9f, 0x6a, 0x0e, 0xda, 0x87, 0x6a, 0x48, 0x03, 0x36, 0x21, 0x63, 0x6e, 0x57, 0x15, 0x70, - 0x32, 0xfa, 0xbf, 0x84, 0xb4, 0xbf, 0x95, 0xc0, 0x2e, 0x06, 0x60, 0x81, 0x04, 0xb4, 0x0d, 0x25, - 0x53, 0x51, 0x6b, 0xb8, 0xc4, 0x42, 0xf4, 0x61, 0x21, 0x84, 0xdf, 0x5e, 0x17, 0xc2, 0x85, 0x86, - 0x76, 0x2e, 0x9a, 0x1f, 0xc1, 0xb6, 0x8e, 0x44, 0x60, 0x72, 0x67, 0x97, 0x55, 0x6a, 0x77, 0xd7, - 0xa4, 0x16, 0x37, 0x45, 0x01, 0x1e, 0x7b, 0x50, 0x35, 0x85, 0x9a, 0xdb, 0x95, 0x83, 0xf2, 0x61, - 0x0d, 0x6f, 0xe9, 0x4a, 0xcd, 0xd1, 0x7d, 0x00, 0xc6, 0xfd, 0x14, 0xfd, 0x1b, 0x0a, 0xfd, 0x35, - 0xc6, 0x4f, 0x35, 0xc3, 0xf9, 0x12, 0x2a, 0xea, 0x1e, 0xdf, 0x03, 0x3b, 0x85, 0xef, 0xb0, 0xff, - 0xcc, 0xf5, 0xfc, 0x53, 0x17, 0x9f, 0xf4, 0x06, 0x83, 0x5e, 0xdf, 0x6b, 0xbd, 0x85, 0x5a, 0xd0, - 0x78, 0xe2, 0x76, 0xfb, 0x27, 0x69, 0xb9, 0xb3, 0x24, 0xb4, 0x0d, 0x47, 0xc3, 0xbb, 0x55, 0x42, - 0xb7, 0xa0, 0xd5, 0xed, 0x78, 0xfe, 0xe7, 0x3d, 0xf7, 0xa5, 0xdf, 0xfd, 0xb4, 0xe3, 0x79, 0xee, - 0xf3, 0x56, 0x19, 0xdd, 0x87, 0xbd, 0x8c, 0xdb, 0xf1, 0x8e, 0xfd, 0xd3, 0xfe, 0x60, 0x98, 0x2d, - 0x57, 0x9c, 0x7f, 0xd5, 0x72, 0xb7, 0xf9, 0xb8, 0x58, 0xaa, 0xf4, 0x13, 0x63, 0xe5, 0x9e, 0x18, - 0xe4, 0xc2, 0x96, 0x7e, 0x9d, 0xd2, 0xd7, 0xe0, 0x3b, 0x2b, 0x02, 0x9d, 0x53, 0xd3, 0xd6, 0x8f, - 0x8b, 0x41, 0x7e, 0xba, 0x17, 0x7d, 0x02, 0xf5, 0xe9, 0xe2, 0x52, 0x2b, 0x08, 0xd7, 0x8f, 0xde, - 0x7e, 0xfd, 0xd5, 0xc7, 0xf9, 0x2d, 0xe8, 0x08, 0xaa, 0xe9, 0x13, 0xac, 0x82, 0x5a, 0x3f, 0xba, - 0x93, 0xdb, 0xae, 0x62, 0xaf, 0x57, 0x71, 0x26, 0x87, 0x3e, 0x86, 0x0d, 0x99, 0x15, 0x8d, 0xf5, - 0xfa, 0xd1, 0x3b, 0xd7, 0x1c, 0x5d, 0x6a, 0x31, 0x07, 0xd7, 0xfb, 0x64, 0x9a, 0xcf, 0x48, 0xe4, - 0x8f, 0x19, 0x17, 0xf6, 0x96, 0x4e, 0xf3, 0x19, 0x89, 0x9e, 0x33, 0x2e, 0x90, 0x07, 0x10, 0x10, - 0x41, 0x47, 0x71, 0xc2, 0xa8, 0xbc, 0x0f, 0x4b, 0x85, 0x61, 0xb5, 0x81, 0x6c, 0x83, 0xb6, 0x92, - 0xd3, 0x80, 0x1e, 0x83, 0x4d, 0x92, 0xe0, 0x82, 0x5d, 0x52, 0x7f, 0x42, 0x46, 0x11, 0x15, 0x63, - 0x16, 0xbd, 0xf2, 0x75, 0x46, 0x6a, 0x2a, 0x23, 0x77, 0xcc, 0xfa, 0x49, 0xb6, 0xdc, 0x55, 0x29, - 0x7a, 0x0a, 0xdb, 0x24, 0x9c, 0xb0, 0xc8, 0xe7, 0x54, 0x08, 0x16, 0x8d, 0xb8, 0x0d, 0x2a, 0x3e, - 0x07, 0x2b, 0x4e, 0xd3, 0x91, 0x82, 0x03, 0x23, 0x87, 0x9b, 0x24, 0x4f, 0xa2, 0x6f, 0x40, 0x93, - 0x45, 0x22, 0x89, 0xfd, 0x09, 0xe5, 0x5c, 0x3e, 0x5a, 0x75, 0x75, 0xd9, 0x1a, 0x8a, 0x79, 0xa2, - 0x79, 0x52, 0x28, 0x9e, 0xe5, 0x85, 0x1a, 0x5a, 0x48, 0x31, 0x53, 0xa1, 0x7b, 0x50, 0xa3, 0x51, - 0x90, 0xcc, 0xa7, 0x82, 0x86, 0x76, 0x53, 0x5f, 0x81, 0x8c, 0x21, 0x4b, 0x96, 0x20, 0x23, 0x6e, - 0x6f, 0xab, 0x88, 0xaa, 0x6f, 0x44, 0x60, 0x47, 0x5f, 0xc8, 0x3c, 0x4c, 0x6e, 0xa8, 0xa8, 0x7e, - 0xef, 0x9a, 0xa8, 0x2e, 0x5d, 0x73, 0x13, 0xdb, 0x96, 0x58, 0x62, 0xa3, 0x9f, 0xc3, 0xde, 0xa2, - 0x39, 0x53, 0xab, 0xdc, 0x9f, 0x98, 0x47, 0xdf, 0x6e, 0x29, 0x53, 0x07, 0xd7, 0x35, 0x07, 0x78, - 0x37, 0x28, 0xf0, 0x79, 0xd6, 0x73, 0xbc, 0x0b, 0xb7, 0x48, 0x20, 0x54, 0xfa, 0x34, 0xe6, 0x7d, - 0xd5, 0x11, 0xd9, 0x3b, 0x2a, 0x77, 0x48, 0xaf, 0x99, 0xcb, 0xd1, 0x95, 0x2b, 0xfb, 0x2f, 0xa0, - 0x91, 0xbf, 0x2c, 0xf9, 0x4a, 0x59, 0xd3, 0x95, 0xf2, 0x51, 0xbe, 0x52, 0x16, 0x1a, 0xb1, 0xa5, - 0x5e, 0x2e, 0x57, 0x44, 0xf7, 0x3f, 0x03, 0x58, 0x00, 0x79, 0x85, 0xd2, 0xef, 0x16, 0x95, 0xee, - 0xae, 0x50, 0x2a, 0xf7, 0xe7, 0x55, 0x7e, 0x01, 0x37, 0x96, 0xa0, 0xbb, 0x42, 0xef, 0x7b, 0x45, - 0xbd, 0x77, 0x57, 0xe9, 0xd5, 0x4a, 0xe6, 0x79, 0xdd, 0x23, 0xb8, 0xbd, 0x32, 0x81, 0x2b, 0x2c, - 0x3c, 0x2e, 0x5a, 0x70, 0xae, 0x2f, 0xf9, 0xf9, 0xc7, 0xe5, 0x97, 0xb9, 0x76, 0xb1, 0x70, 0x0d, - 0xd0, 0x31, 0x3c, 0x98, 0xb2, 0x28, 0x05, 0xb4, 0x4f, 0xc6, 0xe3, 0x2c, 0x87, 0x34, 0x22, 0x67, - 0x63, 0x1a, 0x9a, 0xf6, 0xe6, 0xee, 0x94, 0x45, 0x06, 0xe2, 0x9d, 0xf1, 0x38, 0x4b, 0x9e, 0x12, - 0x71, 0xfe, 0x52, 0x82, 0x66, 0x21, 0x82, 0xe8, 0xa3, 0x45, 0xed, 0xd4, 0x8d, 0xc3, 0x37, 0xd7, - 0xc4, 0xfa, 0xcd, 0x8a, 0x66, 0xe9, 0xeb, 0x15, 0xcd, 0xf2, 0x1b, 0x16, 0xcd, 0x07, 0x50, 0x37, - 0x65, 0x49, 0x8d, 0x30, 0xba, 0xaf, 0x48, 0x2b, 0x95, 0x9c, 0x60, 0xf6, 0xa1, 0x3a, 0x8d, 0x39, - 0x53, 0x2d, 0xaf, 0xac, 0xc4, 0x1b, 0x38, 0xa3, 0xff, 0x47, 0x98, 0x76, 0x42, 0xd8, 0xb9, 0x02, - 0xa2, 0xe5, 0x83, 0x5a, 0x57, 0x0e, 0x9a, 0xb6, 0x46, 0xa5, 0x5c, 0x6b, 0x94, 0x3f, 0x7c, 0xb9, - 0x78, 0x78, 0xe7, 0x77, 0x16, 0xdc, 0xcc, 0xcc, 0xf4, 0xa2, 0x4b, 0x26, 0x88, 0x7a, 0x19, 0xdf, - 0x87, 0xdb, 0x8b, 0xc2, 0x91, 0x6f, 0xf8, 0xf5, 0x78, 0x77, 0x2b, 0x58, 0xf3, 0x9c, 0x8e, 0xe4, - 0x4c, 0x68, 0x66, 0x3c, 0x4d, 0xac, 0x1f, 0xf0, 0xee, 0x03, 0x4c, 0x67, 0x67, 0x63, 0x16, 0xf8, - 0x32, 0x5e, 0x15, 0xb5, 0xa7, 0xa6, 0x39, 0xcf, 0xe8, 0xdc, 0x39, 0x87, 0x1b, 0x4b, 0xb3, 0x97, - 0x6c, 0xb1, 0x4d, 0x63, 0x6a, 0x5c, 0x4f, 0x49, 0x59, 0x7d, 0x39, 0x1b, 0x45, 0x44, 0xcc, 0x12, - 0x6a, 0xcc, 0x2f, 0x18, 0xb2, 0x09, 0x0c, 0x2e, 0x08, 0xd3, 0x4d, 0x60, 0x59, 0x37, 0x81, 0x8a, - 0xd1, 0x0b, 0xb9, 0xf3, 0x4f, 0x2b, 0x77, 0x4b, 0x30, 0xfd, 0xd5, 0x8c, 0x72, 0x31, 0x8c, 0x7f, - 0x12, 0xb3, 0x75, 0xfd, 0x81, 0x99, 0x01, 0x72, 0x71, 0x96, 0x33, 0x80, 0x27, 0x43, 0xbd, 0xd6, - 0xd7, 0xe5, 0x29, 0xb9, 0x72, 0x75, 0x4a, 0x7e, 0x08, 0x8d, 0x90, 0xf1, 0xe9, 0x98, 0xcc, 0xb5, - 0xea, 0x0d, 0x33, 0x5a, 0x69, 0x9e, 0x52, 0xbf, 0x72, 0x62, 0xdd, 0xfc, 0xea, 0x13, 0xeb, 0x1f, - 0x2c, 0xb8, 0x97, 0x03, 0x57, 0x14, 0xd0, 0xf1, 0xff, 0xb5, 0xe3, 0xce, 0x3f, 0x2c, 0x78, 0x7b, - 0x75, 0x8e, 0x30, 0xe5, 0xd3, 0x38, 0xe2, 0x74, 0xcd, 0x91, 0x7f, 0x08, 0xb5, 0xcc, 0xd4, 0x6b, - 0xaa, 0x49, 0x0e, 0xc5, 0x78, 0xb1, 0x41, 0xde, 0x1c, 0x39, 0x83, 0xa9, 0x27, 0xbd, 0xac, 0xca, - 0x61, 0x46, 0x2f, 0xc0, 0x5e, 0xc9, 0x83, 0x7d, 0xd9, 0xdd, 0x8d, 0xab, 0xee, 0xde, 0x07, 0xd0, - 0xdd, 0x8e, 0x3f, 0x4b, 0x98, 0x99, 0x5d, 0x6b, 0x9a, 0xf3, 0x22, 0x61, 0x0e, 0x86, 0xdd, 0xab, - 0x9e, 0x3e, 0xa7, 0xe4, 0x72, 0x9d, 0x8b, 0xcb, 0x26, 0x4b, 0x57, 0x4c, 0x3a, 0x3f, 0x85, 0x87, - 0xb9, 0x4a, 0xa3, 0x8b, 0xf9, 0x72, 0x63, 0xb5, 0x46, 0x7b, 0xf1, 0xb4, 0xa5, 0xe5, 0xd3, 0xfe, - 0xd1, 0x82, 0xfa, 0x4b, 0xf2, 0x6a, 0x96, 0x76, 0x41, 0x2d, 0x28, 0x73, 0x36, 0x32, 0x55, 0x42, - 0x7e, 0xca, 0x9b, 0x29, 0xd8, 0x84, 0x72, 0x41, 0x26, 0x53, 0xb5, 0xbf, 0x82, 0x17, 0x0c, 0x69, - 0x54, 0xc4, 0x53, 0x16, 0xa8, 0xf0, 0x36, 0xb0, 0x26, 0xd4, 0x28, 0x4d, 0xe6, 0xe3, 0x98, 0xa4, - 0x78, 0x49, 0x49, 0xbd, 0x12, 0x86, 0x2c, 0x1a, 0x99, 0xd0, 0xa6, 0xa4, 0xac, 0x7c, 0x17, 0x84, - 0x5f, 0xa8, 0x80, 0x36, 0xb0, 0xfa, 0x46, 0x0e, 0x34, 0xc4, 0x05, 0x4b, 0xc2, 0x53, 0x92, 0xc8, - 0x38, 0x98, 0x01, 0xaf, 0xc0, 0x73, 0xbe, 0x84, 0xfd, 0x9c, 0x03, 0x69, 0x58, 0xd2, 0x16, 0xc7, - 0x86, 0xad, 0x4b, 0x9a, 0xf0, 0xb4, 0xf2, 0x35, 0x71, 0x4a, 0x4a, 0x7b, 0xe7, 0x49, 0x3c, 0x31, - 0x2e, 0xa9, 0x6f, 0x39, 0xaf, 0x89, 0x58, 0xb9, 0x52, 0xc1, 0x25, 0x11, 0x4b, 0xfb, 0x72, 0x0e, - 0xa6, 0x91, 0x18, 0x2a, 0x27, 0xe5, 0xd8, 0xd4, 0xc0, 0x05, 0x9e, 0xf3, 0x7b, 0x0b, 0xd0, 0xd5, - 0x03, 0xbc, 0xc6, 0xf0, 0x27, 0x50, 0xcd, 0x5a, 0x38, 0x8d, 0xe8, 0xdc, 0x1b, 0xbb, 0xde, 0x15, - 0x9c, 0xed, 0x42, 0xef, 0x49, 0x0d, 0x4a, 0x86, 0x9b, 0x19, 0xf0, 0xf6, 0x4a, 0x0d, 0x38, 0x13, - 0x73, 0xfe, 0x64, 0xc1, 0x83, 0xab, 0xba, 0x7b, 0x51, 0x48, 0x7f, 0xfd, 0x06, 0xb1, 0xfa, 0xfa, - 0x47, 0xbe, 0x03, 0x9b, 0xf1, 0xf9, 0x39, 0xa7, 0xc2, 0x44, 0xd7, 0x50, 0x32, 0x0b, 0x9c, 0xfd, - 0x86, 0x9a, 0xff, 0x08, 0xd5, 0xf7, 0x32, 0x46, 0x2a, 0x19, 0x46, 0x9c, 0x3f, 0x5b, 0xb0, 0xbb, - 0xc6, 0x0b, 0xf4, 0x0c, 0xaa, 0x66, 0xd8, 0x48, 0x5b, 0x97, 0x47, 0xaf, 0x3b, 0xa3, 0xda, 0xd4, - 0x36, 0x84, 0xe9, 0x62, 0x32, 0x05, 0xfb, 0xe7, 0xd0, 0x2c, 0x2c, 0xad, 0x68, 0x0a, 0x3e, 0x2e, - 0x36, 0x05, 0xef, 0x5c, 0x6b, 0x2c, 0x8b, 0xca, 0xa2, 0x49, 0x78, 0xd2, 0xfc, 0xa2, 0xde, 0x7e, - 0xf4, 0x61, 0xba, 0xf3, 0x6c, 0x53, 0x7d, 0xbd, 0xff, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x16, - 0x85, 0x6c, 0xff, 0xdc, 0x15, 0x00, 0x00, + 0x64, 0x32, 0x8b, 0x98, 0x60, 0x94, 0x77, 0xa6, 0x49, 0x2c, 0x62, 0x54, 0x55, 0x3f, 0xe7, 0xb3, + 0x8b, 0x83, 0x9b, 0xc1, 0x25, 0x11, 0x3e, 0x0b, 0x69, 0x24, 0x98, 0x98, 0xeb, 0xe5, 0x83, 0x3a, + 0x8d, 0x66, 0x13, 0x23, 0xeb, 0x5c, 0xc1, 0xc6, 0x93, 0x84, 0x44, 0x02, 0x3d, 0x80, 0x46, 0xaa, + 0x69, 0xee, 0xb3, 0xd0, 0xb6, 0xda, 0xd6, 0x61, 0x03, 0xd7, 0x33, 0x5e, 0x3f, 0x44, 0x77, 0xa0, + 0x36, 0xa1, 0x93, 0x73, 0x9a, 0xc8, 0xf5, 0x92, 0x5a, 0xaf, 0x6a, 0x46, 0x3f, 0x44, 0x7b, 0xb0, + 0x65, 0x8c, 0xd9, 0xe5, 0xb6, 0x75, 0x58, 0xc3, 0x9b, 0x92, 0xec, 0x87, 0xe8, 0x16, 0x6c, 0x04, + 0xe3, 0x38, 0x78, 0x69, 0x57, 0xda, 0xd6, 0x61, 0x05, 0x6b, 0xc2, 0xf9, 0xb7, 0x05, 0x37, 0x7a, + 0xa9, 0xee, 0x13, 0xa5, 0x04, 0x7d, 0x1f, 0x36, 0x92, 0x78, 0x4c, 0xb9, 0x6d, 0xb5, 0xcb, 0x87, + 0xdb, 0x47, 0xf7, 0x3b, 0xa9, 0x1f, 0x9d, 0x25, 0xc9, 0x0e, 0x96, 0x62, 0x58, 0x4b, 0xa3, 0x1f, + 0xc3, 0x4e, 0x42, 0xaf, 0x28, 0x19, 0xd3, 0xd0, 0x27, 0x41, 0x10, 0xcf, 0x22, 0xc1, 0xed, 0x52, + 0xbb, 0x7c, 0x58, 0x3f, 0xda, 0x5f, 0xa8, 0xc0, 0x46, 0xa4, 0xab, 0x25, 0x70, 0x2b, 0x29, 0x32, + 0xb8, 0x73, 0x09, 0x1b, 0x4a, 0x2f, 0x6a, 0x42, 0x0d, 0x0f, 0x9e, 0xb9, 0xbe, 0x37, 0xf0, 0xdc, + 0xd6, 0x5b, 0x68, 0x1b, 0x40, 0x91, 0x83, 0x17, 0x9e, 0x8b, 0x5b, 0x16, 0xba, 0x0d, 0x3b, 0x8a, + 0x3e, 0xe9, 0x7a, 0xdd, 0x27, 0xae, 0xff, 0xfc, 0xcc, 0xc5, 0x67, 0xad, 0x12, 0xda, 0x87, 0xdb, + 0x9a, 0x3d, 0x38, 0x76, 0x71, 0x77, 0xe8, 0xfa, 0xbd, 0x81, 0x37, 0x74, 0xbd, 0x61, 0xab, 0x9c, + 0x69, 0xe8, 0x1e, 0x9f, 0xf4, 0xbd, 0x56, 0xc5, 0xf9, 0x6d, 0x19, 0x76, 0x33, 0x97, 0x86, 0xf1, + 0x4b, 0x1a, 0x9d, 0x50, 0x41, 0x42, 0x22, 0x08, 0xba, 0x00, 0x14, 0xc4, 0x91, 0x48, 0x48, 0x20, + 0x7c, 0x12, 0x86, 0x09, 0xe5, 0xdc, 0x04, 0xa4, 0x7e, 0xf4, 0x83, 0x15, 0x01, 0x29, 0xec, 0xee, + 0xf4, 0xcc, 0xd6, 0x6e, 0xba, 0xd3, 0x8d, 0x44, 0x32, 0xc7, 0x3b, 0xc1, 0x32, 0x1f, 0xb5, 0xa1, + 0x1e, 0x52, 0x1e, 0x24, 0x6c, 0x2a, 0x58, 0x1c, 0xa9, 0x6c, 0xd6, 0x70, 0x9e, 0x25, 0xf3, 0xc6, + 0x26, 0x64, 0x44, 0x4d, 0x3a, 0x35, 0x81, 0x3e, 0x80, 0x9a, 0x90, 0x26, 0x87, 0xf3, 0x29, 0x55, + 0x19, 0xdd, 0x3e, 0xba, 0xbb, 0xee, 0x58, 0x52, 0x06, 0x2f, 0xc4, 0xd1, 0x2e, 0x6c, 0xf2, 0xf9, + 0xe4, 0x3c, 0x1e, 0xdb, 0x1b, 0x1a, 0x21, 0x9a, 0x42, 0x08, 0x2a, 0x11, 0x99, 0x50, 0x7b, 0x53, + 0x71, 0xd5, 0x37, 0x3a, 0x80, 0x6a, 0x48, 0x03, 0x36, 0x21, 0x63, 0x6e, 0x6f, 0xb5, 0xad, 0xc3, + 0x26, 0xce, 0xe8, 0x83, 0x63, 0x19, 0xbd, 0x55, 0x8e, 0xa2, 0x16, 0x94, 0x5f, 0xd2, 0xb9, 0xc2, + 0x6e, 0x05, 0xcb, 0x4f, 0xe9, 0xc5, 0x15, 0x19, 0xcf, 0xa8, 0xf1, 0x50, 0x13, 0x1f, 0x94, 0x1e, + 0x59, 0xce, 0xdf, 0x2c, 0xb8, 0x95, 0x9d, 0xf7, 0x94, 0x26, 0x13, 0xc6, 0x39, 0x8b, 0x23, 0x8e, + 0xf6, 0xa1, 0x4a, 0x23, 0xee, 0xc7, 0xd1, 0x58, 0x6b, 0xaa, 0xe2, 0x2d, 0x1a, 0xf1, 0x41, 0x34, + 0x9e, 0x23, 0x1b, 0xb6, 0xa6, 0x09, 0xbb, 0x22, 0x42, 0xeb, 0xab, 0xe2, 0x94, 0x44, 0x3f, 0x82, + 0x4d, 0x12, 0x04, 0x94, 0x73, 0x15, 0xae, 0xed, 0xa3, 0x6f, 0xad, 0x08, 0x4a, 0xce, 0x48, 0xa7, + 0xab, 0x84, 0xb1, 0xd9, 0xe4, 0x0c, 0x61, 0x53, 0x73, 0x10, 0x82, 0xed, 0xe7, 0xde, 0x53, 0x6f, + 0xf0, 0xc2, 0xf3, 0xbb, 0xbd, 0x9e, 0x7b, 0x76, 0xd6, 0x7a, 0x0b, 0xed, 0x40, 0xd3, 0x1b, 0xf8, + 0x27, 0xee, 0xc9, 0x63, 0x17, 0x9f, 0x7d, 0xda, 0x3f, 0x6d, 0x59, 0xe8, 0x26, 0xdc, 0xe8, 0x7b, + 0x9f, 0xf7, 0x87, 0xdd, 0x61, 0x7f, 0xe0, 0xf9, 0x03, 0xef, 0xd9, 0xcf, 0x5a, 0x25, 0x89, 0xb3, + 0x81, 0xe7, 0x63, 0xf7, 0xb3, 0xe7, 0xee, 0xd9, 0xb0, 0x55, 0x76, 0x7e, 0x57, 0x86, 0xa6, 0xca, + 0x44, 0x2f, 0x61, 0x82, 0x26, 0x8c, 0xa0, 0x5f, 0xbc, 0x02, 0x5e, 0x9d, 0xc5, 0x91, 0x0b, 0x9b, + 0xbe, 0x02, 0xaa, 0xde, 0x85, 0x8a, 0x90, 0xc0, 0x28, 0xbd, 0x01, 0x30, 0x94, 0x64, 0x0e, 0x13, + 0xe5, 0x95, 0x98, 0xa8, 0xe4, 0x30, 0xb1, 0x0b, 0x9b, 0x64, 0x22, 0xef, 0x6a, 0x8a, 0x1f, 0x4d, + 0xc9, 0xba, 0xa4, 0x40, 0xe6, 0xb3, 0x90, 0xdb, 0x9b, 0xed, 0xf2, 0x61, 0x05, 0x57, 0x15, 0xa3, + 0x1f, 0x72, 0x74, 0x1f, 0xea, 0x32, 0x9b, 0x53, 0x22, 0x04, 0x4d, 0x22, 0x85, 0xa5, 0x1a, 0x06, + 0x1a, 0xf1, 0x53, 0xcd, 0x29, 0x20, 0xad, 0xaa, 0x80, 0xf3, 0xdf, 0x46, 0xda, 0xdf, 0x4b, 0x60, + 0x17, 0x03, 0xb0, 0x40, 0x02, 0xda, 0x86, 0x92, 0xa9, 0xb6, 0x35, 0x5c, 0x62, 0x21, 0xfa, 0xb0, + 0x10, 0xc2, 0x6f, 0xaf, 0x0b, 0xe1, 0x42, 0x43, 0x27, 0x17, 0xcd, 0x8f, 0x60, 0x5b, 0x47, 0x22, + 0x30, 0xb9, 0xb3, 0xcb, 0x2a, 0xb5, 0x7b, 0x6b, 0x52, 0x8b, 0x9b, 0xa2, 0x00, 0x8f, 0x7d, 0xa8, + 0x9a, 0x22, 0xce, 0xed, 0x4a, 0xbb, 0x7c, 0x58, 0xc3, 0x5b, 0xba, 0x8a, 0x73, 0x74, 0x0f, 0x80, + 0x71, 0x3f, 0x45, 0xff, 0x86, 0x42, 0x7f, 0x8d, 0xf1, 0x53, 0xcd, 0x70, 0xbe, 0x84, 0x8a, 0xba, + 0xe3, 0x77, 0xc1, 0x4e, 0xe1, 0x3b, 0x1c, 0x3c, 0x75, 0x3d, 0xff, 0xd4, 0xc5, 0x27, 0xfd, 0xb3, + 0xb3, 0xfe, 0xc0, 0x6b, 0xbd, 0x85, 0x5a, 0xd0, 0x78, 0xec, 0xf6, 0x06, 0x27, 0x69, 0x29, 0xb4, + 0x24, 0xb4, 0x0d, 0x47, 0xc3, 0xbb, 0x55, 0x42, 0xb7, 0xa0, 0xd5, 0xeb, 0x7a, 0xfe, 0xe7, 0x7d, + 0xf7, 0x85, 0xdf, 0xfb, 0xb4, 0xeb, 0x79, 0xee, 0xb3, 0x56, 0x19, 0xdd, 0x83, 0xfd, 0x8c, 0xdb, + 0xf5, 0x8e, 0xfd, 0xd3, 0xc1, 0xd9, 0x30, 0x5b, 0xae, 0x38, 0xff, 0xaa, 0xe5, 0x6e, 0xf3, 0x71, + 0xb1, 0x8c, 0xe9, 0xe7, 0xc7, 0xca, 0x3d, 0x3f, 0xc8, 0x85, 0x2d, 0xfd, 0x72, 0xa5, 0x2f, 0xc5, + 0x77, 0x56, 0x04, 0x3a, 0xa7, 0xa6, 0xa3, 0x1f, 0x1e, 0x83, 0xfc, 0x74, 0x2f, 0xfa, 0x04, 0xea, + 0xd3, 0xc5, 0xa5, 0x56, 0x10, 0xae, 0x1f, 0xbd, 0xfd, 0xea, 0xab, 0x8f, 0xf3, 0x5b, 0xd0, 0x11, + 0x54, 0xd3, 0xe7, 0x59, 0x05, 0xb5, 0x7e, 0xb4, 0x9b, 0xdb, 0xae, 0x62, 0xaf, 0x57, 0x71, 0x26, + 0x87, 0x3e, 0x86, 0x0d, 0x99, 0x15, 0x8d, 0xf5, 0xfa, 0xd1, 0x3b, 0xaf, 0x39, 0xba, 0xd4, 0x62, + 0x0e, 0xae, 0xf7, 0xc9, 0x34, 0x9f, 0x93, 0xc8, 0x1f, 0x33, 0x2e, 0xec, 0x2d, 0x9d, 0xe6, 0x73, + 0x12, 0x3d, 0x63, 0x5c, 0x20, 0x0f, 0x20, 0x20, 0x82, 0x8e, 0xe2, 0x84, 0x51, 0x79, 0x1f, 0x96, + 0x0a, 0xc3, 0x6a, 0x03, 0xd9, 0x06, 0x6d, 0x25, 0xa7, 0x01, 0x3d, 0x02, 0x9b, 0x24, 0xc1, 0x25, + 0xbb, 0xa2, 0xfe, 0x84, 0x8c, 0x22, 0x2a, 0xc6, 0x2c, 0x7a, 0xe9, 0xeb, 0x8c, 0xd4, 0x54, 0x46, + 0x76, 0xcd, 0xfa, 0x49, 0xb6, 0xdc, 0x53, 0x29, 0x7a, 0x02, 0xdb, 0x24, 0x9c, 0xb0, 0xc8, 0xe7, + 0x54, 0x08, 0x16, 0x8d, 0xb8, 0x0d, 0x2a, 0x3e, 0xed, 0x15, 0xa7, 0xe9, 0x4a, 0xc1, 0x33, 0x23, + 0x87, 0x9b, 0x24, 0x4f, 0xa2, 0x6f, 0x40, 0x93, 0x45, 0x22, 0x89, 0xfd, 0x09, 0xe5, 0x5c, 0x3e, + 0x68, 0x75, 0x75, 0xd9, 0x1a, 0x8a, 0x79, 0xa2, 0x79, 0x52, 0x28, 0x9e, 0xe5, 0x85, 0x1a, 0x5a, + 0x48, 0x31, 0x53, 0xa1, 0xbb, 0x50, 0xa3, 0x51, 0x90, 0xcc, 0xa7, 0x82, 0x86, 0x76, 0x53, 0x5f, + 0x81, 0x8c, 0x21, 0x4b, 0x96, 0x20, 0x23, 0x6e, 0x6f, 0xab, 0x88, 0xaa, 0x6f, 0x44, 0x60, 0x47, + 0x5f, 0xc8, 0x3c, 0x4c, 0x6e, 0xa8, 0xa8, 0x7e, 0xef, 0x35, 0x51, 0x5d, 0xba, 0xe6, 0x26, 0xb6, + 0x2d, 0xb1, 0xc4, 0x46, 0x3f, 0x87, 0xfd, 0x45, 0xe3, 0xa6, 0x56, 0xb9, 0x3f, 0x31, 0x0d, 0x81, + 0xdd, 0x52, 0xa6, 0xda, 0xaf, 0x6b, 0x1c, 0xf0, 0x5e, 0x50, 0xe0, 0xf3, 0xac, 0x1f, 0x79, 0x17, + 0x6e, 0x91, 0x40, 0xa8, 0xf4, 0x69, 0xcc, 0xfb, 0xaa, 0x5b, 0xb2, 0x77, 0x54, 0xee, 0x90, 0x5e, + 0x33, 0x97, 0xa3, 0x27, 0x57, 0x0e, 0x9e, 0x43, 0x23, 0x7f, 0x59, 0xf2, 0x95, 0xb2, 0xa6, 0x2b, + 0xe5, 0xc3, 0x7c, 0xa5, 0x2c, 0x34, 0x69, 0x4b, 0x7d, 0x5e, 0xae, 0x88, 0x1e, 0x7c, 0x06, 0xb0, + 0x00, 0xf2, 0x0a, 0xa5, 0xdf, 0x2d, 0x2a, 0xdd, 0x5b, 0xa1, 0x54, 0xee, 0xcf, 0xab, 0xfc, 0x02, + 0x6e, 0x2c, 0x41, 0x77, 0x85, 0xde, 0xf7, 0x8a, 0x7a, 0xef, 0xac, 0xd2, 0xab, 0x95, 0xcc, 0xf3, + 0xba, 0x47, 0x70, 0x7b, 0x65, 0x02, 0x57, 0x58, 0x78, 0x54, 0xb4, 0xe0, 0xbc, 0xbe, 0xe4, 0xe7, + 0x1f, 0x97, 0x5f, 0xe6, 0x5a, 0xc9, 0xc2, 0x35, 0x40, 0xc7, 0x70, 0x7f, 0xca, 0xa2, 0x14, 0xd0, + 0x3e, 0x19, 0x8f, 0xb3, 0x1c, 0xd2, 0x88, 0x9c, 0x8f, 0x69, 0x68, 0xda, 0x9b, 0x3b, 0x53, 0x16, + 0x19, 0x88, 0x77, 0xc7, 0xe3, 0x2c, 0x79, 0x4a, 0xc4, 0xf9, 0x6b, 0x09, 0x9a, 0x85, 0x08, 0xa2, + 0x8f, 0x16, 0xb5, 0x53, 0x37, 0x0e, 0xdf, 0x5c, 0x13, 0xeb, 0x37, 0x2b, 0x9a, 0xa5, 0xaf, 0x57, + 0x34, 0xcb, 0x6f, 0x58, 0x34, 0xef, 0x43, 0xdd, 0x94, 0x25, 0x35, 0xde, 0xe8, 0xbe, 0x22, 0xad, + 0x54, 0x72, 0xba, 0x39, 0x80, 0xea, 0x34, 0xe6, 0x4c, 0xb5, 0xc3, 0xb2, 0x12, 0x6f, 0xe0, 0x8c, + 0xfe, 0x1f, 0x61, 0xda, 0x09, 0x61, 0xe7, 0x1a, 0x88, 0x96, 0x0f, 0x6a, 0x5d, 0x3b, 0x68, 0xda, + 0x1a, 0x95, 0x8a, 0xed, 0x72, 0x76, 0xf8, 0x72, 0xf1, 0xf0, 0xce, 0xef, 0x2d, 0xb8, 0x99, 0x99, + 0xe9, 0x47, 0x57, 0x4c, 0x10, 0xf5, 0x32, 0xbe, 0x0f, 0xb7, 0x17, 0x85, 0x23, 0x3f, 0x0c, 0xe8, + 0xd1, 0xef, 0x56, 0xb0, 0xe6, 0x39, 0x1d, 0xc9, 0x79, 0xd1, 0xcc, 0x7f, 0x9a, 0x58, 0x3f, 0xfc, + 0xdd, 0x03, 0x98, 0xce, 0xce, 0xc7, 0x2c, 0xf0, 0x65, 0xbc, 0x2a, 0x6a, 0x4f, 0x4d, 0x73, 0x9e, + 0xd2, 0xb9, 0x73, 0x01, 0x37, 0x96, 0xe6, 0x32, 0xd9, 0x62, 0x9b, 0xc6, 0xd4, 0xb8, 0x9e, 0x92, + 0xb2, 0xfa, 0x72, 0x36, 0x8a, 0x88, 0x98, 0x25, 0xd4, 0x98, 0x5f, 0x30, 0x64, 0x13, 0x18, 0x5c, + 0x12, 0xa6, 0x9b, 0xc0, 0xb2, 0x6e, 0x02, 0x15, 0xa3, 0x1f, 0x72, 0xe7, 0x9f, 0x56, 0xee, 0x96, + 0x60, 0xfa, 0xab, 0x19, 0xe5, 0x62, 0x18, 0xff, 0x24, 0x66, 0xeb, 0xfa, 0x03, 0x33, 0x03, 0xe4, + 0xe2, 0x2c, 0x67, 0x00, 0x4f, 0x86, 0x7a, 0xad, 0xaf, 0xcb, 0x13, 0x74, 0xe5, 0xfa, 0x04, 0xfd, + 0x00, 0x1a, 0x21, 0xe3, 0xd3, 0x31, 0x99, 0x6b, 0xd5, 0x1b, 0x66, 0xec, 0xd2, 0x3c, 0xa5, 0x7e, + 0xe5, 0x34, 0xbb, 0xf9, 0xd5, 0xa7, 0xd9, 0x3f, 0x5a, 0x70, 0x37, 0x07, 0xae, 0x28, 0xa0, 0xe3, + 0xff, 0x6b, 0xc7, 0x9d, 0x7f, 0x58, 0xf0, 0xf6, 0xea, 0x1c, 0x61, 0xca, 0xa7, 0x71, 0xc4, 0xe9, + 0x9a, 0x23, 0xff, 0x10, 0x6a, 0x99, 0xa9, 0x57, 0x54, 0x93, 0x1c, 0x8a, 0xf1, 0x62, 0x83, 0xbc, + 0x39, 0x72, 0x06, 0x53, 0x4f, 0x7a, 0x59, 0x95, 0xc3, 0x8c, 0x5e, 0x80, 0xbd, 0x92, 0x07, 0xfb, + 0xb2, 0xbb, 0x1b, 0xd7, 0xdd, 0xbd, 0x07, 0xa0, 0xbb, 0x1d, 0x7f, 0x96, 0x30, 0x33, 0xd7, 0xd6, + 0x34, 0xe7, 0x79, 0xc2, 0x1c, 0x0c, 0x7b, 0xd7, 0x3d, 0x7d, 0x46, 0xc9, 0xd5, 0x3a, 0x17, 0x97, + 0x4d, 0x96, 0xae, 0x99, 0x74, 0x7e, 0x0a, 0x0f, 0x72, 0x95, 0x46, 0x17, 0xf3, 0xe5, 0xc6, 0x6a, + 0x8d, 0xf6, 0xe2, 0x69, 0x4b, 0xcb, 0xa7, 0xfd, 0x93, 0x05, 0xf5, 0x17, 0xe4, 0xe5, 0x2c, 0xed, + 0x82, 0x5a, 0x50, 0xe6, 0x6c, 0x64, 0xaa, 0x84, 0xfc, 0x94, 0x37, 0x53, 0xb0, 0x09, 0xe5, 0x82, + 0x4c, 0xa6, 0x6a, 0x7f, 0x05, 0x2f, 0x18, 0xd2, 0xa8, 0x88, 0xa7, 0x2c, 0x50, 0xe1, 0x6d, 0x60, + 0x4d, 0xa8, 0x51, 0x9a, 0xcc, 0xc7, 0x31, 0x49, 0xf1, 0x92, 0x92, 0x7a, 0x25, 0x0c, 0x59, 0x34, + 0x32, 0xa1, 0x4d, 0x49, 0x59, 0xf9, 0x2e, 0x09, 0xbf, 0x54, 0x01, 0x6d, 0x60, 0xf5, 0x8d, 0x1c, + 0x68, 0x88, 0x4b, 0x96, 0x84, 0xa7, 0x24, 0x91, 0x71, 0x30, 0x03, 0x5e, 0x81, 0xe7, 0x7c, 0x09, + 0x07, 0x39, 0x07, 0xd2, 0xb0, 0xa4, 0x2d, 0x8e, 0x0d, 0x5b, 0x57, 0x34, 0xe1, 0x69, 0xe5, 0x6b, + 0xe2, 0x94, 0x94, 0xf6, 0x2e, 0x92, 0x78, 0x62, 0x5c, 0x52, 0xdf, 0x72, 0x5e, 0x13, 0xb1, 0x72, + 0xa5, 0x82, 0x4b, 0x22, 0x96, 0xf6, 0xe5, 0x1c, 0x4c, 0x23, 0x31, 0x54, 0x4e, 0xca, 0xb1, 0xa9, + 0x81, 0x0b, 0x3c, 0xe7, 0x0f, 0x16, 0xa0, 0xeb, 0x07, 0x78, 0x85, 0xe1, 0x4f, 0xa0, 0x9a, 0xb5, + 0x70, 0x1a, 0xd1, 0xb9, 0x37, 0x76, 0xbd, 0x2b, 0x38, 0xdb, 0x85, 0xde, 0x93, 0x1a, 0x94, 0x0c, + 0x37, 0x33, 0xe0, 0xed, 0x95, 0x1a, 0x70, 0x26, 0xe6, 0xfc, 0xd9, 0x82, 0xfb, 0xd7, 0x75, 0xf7, + 0xa3, 0x90, 0xfe, 0xfa, 0x0d, 0x62, 0xf5, 0xf5, 0x8f, 0xbc, 0x0b, 0x9b, 0xf1, 0xc5, 0x05, 0xa7, + 0xc2, 0x44, 0xd7, 0x50, 0x32, 0x0b, 0x9c, 0xfd, 0x86, 0x9a, 0xff, 0x0f, 0xd5, 0xf7, 0x32, 0x46, + 0x2a, 0x19, 0x46, 0x9c, 0xbf, 0x58, 0xb0, 0xb7, 0xc6, 0x0b, 0xf4, 0x14, 0xaa, 0x66, 0xd8, 0x48, + 0x5b, 0x97, 0x87, 0xaf, 0x3a, 0xa3, 0xda, 0xd4, 0x31, 0x84, 0xe9, 0x62, 0x32, 0x05, 0x07, 0x17, + 0xd0, 0x2c, 0x2c, 0xad, 0x68, 0x0a, 0x3e, 0x2e, 0x36, 0x05, 0xef, 0xbc, 0xd6, 0x58, 0x16, 0x95, + 0x45, 0x93, 0xf0, 0xb8, 0xf9, 0x45, 0xbd, 0xf3, 0xf0, 0xc3, 0x74, 0xe7, 0xf9, 0xa6, 0xfa, 0x7a, + 0xff, 0x3f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xca, 0xc3, 0x8d, 0xb3, 0xf8, 0x15, 0x00, 0x00, } diff --git a/protocol/protobuf/communities.proto b/protocol/protobuf/communities.proto index e5f93b21c..1c42cee36 100644 --- a/protocol/protobuf/communities.proto +++ b/protocol/protobuf/communities.proto @@ -32,6 +32,7 @@ message CommunityTokenMetadata { CommunityTokenType tokenType = 4; string symbol = 5; string name = 6; + uint32 decimals = 7; } message CommunityPermissions { diff --git a/services/collectibles/api.go b/services/collectibles/api.go index d57ca4c71..4fa1bc7e3 100644 --- a/services/collectibles/api.go +++ b/services/collectibles/api.go @@ -14,8 +14,10 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/log" "github.com/status-im/status-go/account" + "github.com/status-im/status-go/contracts/assets" "github.com/status-im/status-go/contracts/collectibles" "github.com/status-im/status-go/params" + "github.com/status-im/status-go/protocol/protobuf" "github.com/status-im/status-go/rpc" "github.com/status-im/status-go/services/utils" "github.com/status-im/status-go/services/wallet/bigint" @@ -27,7 +29,7 @@ func NewAPI(rpcClient *rpc.Client, accountsManager *account.GethManager, config RPCClient: rpcClient, accountsManager: accountsManager, config: config, - db: NewCollectiblesDatabase(appDb), + db: NewCommunityTokensDatabase(appDb), } } @@ -82,7 +84,7 @@ func (d *DeploymentParameters) Validate() error { return nil } -func (api *API) Deploy(ctx context.Context, chainID uint64, deploymentParameters DeploymentParameters, txArgs transactions.SendTxArgs, password string) (DeploymentDetails, error) { +func (api *API) DeployCollectibles(ctx context.Context, chainID uint64, deploymentParameters DeploymentParameters, txArgs transactions.SendTxArgs, password string) (DeploymentDetails, error) { err := deploymentParameters.Validate() if err != nil { @@ -109,12 +111,43 @@ func (api *API) Deploy(ctx context.Context, chainID uint64, deploymentParameters return DeploymentDetails{address.Hex(), tx.Hash().Hex()}, nil } +func (api *API) DeployAssets(ctx context.Context, chainID uint64, deploymentParameters DeploymentParameters, txArgs transactions.SendTxArgs, password string) (DeploymentDetails, error) { + + err := deploymentParameters.Validate() + if err != nil { + return DeploymentDetails{}, err + } + + transactOpts := txArgs.ToTransactOpts(utils.GetSigner(chainID, api.accountsManager, api.config.KeyStoreDir, txArgs.From, password)) + + ethClient, err := api.RPCClient.EthClient(chainID) + if err != nil { + log.Error(err.Error()) + return DeploymentDetails{}, err + } + + address, tx, _, err := assets.DeployAssets(transactOpts, ethClient, deploymentParameters.Name, + deploymentParameters.Symbol, deploymentParameters.GetSupply()) + if err != nil { + log.Error(err.Error()) + return DeploymentDetails{}, err + } + + return DeploymentDetails{address.Hex(), tx.Hash().Hex()}, nil +} + // Returns gas units + 10% func (api *API) DeployCollectiblesEstimate(ctx context.Context) (uint64, error) { gasAmount := uint64(1960645) return gasAmount + uint64(float32(gasAmount)*0.1), nil } +// Returns gas units + 10% +func (api *API) DeployAssetsEstimate(ctx context.Context) (uint64, error) { + gasAmount := uint64(957483) + return gasAmount + uint64(float32(gasAmount)*0.1), nil +} + func (api *API) newCollectiblesInstance(chainID uint64, contractAddress string) (*collectibles.Collectibles, error) { backend, err := api.RPCClient.EthClient(chainID) if err != nil { @@ -123,6 +156,14 @@ func (api *API) newCollectiblesInstance(chainID uint64, contractAddress string) return collectibles.NewCollectibles(common.HexToAddress(contractAddress), backend) } +func (api *API) newAssetsInstance(chainID uint64, contractAddress string) (*assets.Assets, error) { + backend, err := api.RPCClient.EthClient(chainID) + if err != nil { + return nil, err + } + return assets.NewAssets(common.HexToAddress(contractAddress), backend) +} + // if we want to mint 2 tokens to addresses ["a", "b"] we need to mint // twice to every address - we need to send to smart contract table ["a", "a", "b", "b"] func (api *API) multiplyWalletAddresses(amount int, contractAddresses []string) []string { @@ -177,6 +218,7 @@ func (api *API) EstimateMintTo(ctx context.Context, chainID uint64, contractAddr return api.estimateMethod(ctx, chainID, contractAddress, "mintTo", usersAddresses) } +// This is only ERC721 function func (api *API) RemoteBurn(ctx context.Context, chainID uint64, contractAddress string, txArgs transactions.SendTxArgs, password string, tokenIds []*bigint.BigInt) (string, error) { err := api.validateTokens(tokenIds) if err != nil { @@ -219,15 +261,32 @@ func (api *API) EstimateRemoteBurn(ctx context.Context, chainID uint64, contract func (api *API) ContractOwner(ctx context.Context, chainID uint64, contractAddress string) (string, error) { callOpts := &bind.CallOpts{Context: ctx, Pending: false} - contractInst, err := api.newCollectiblesInstance(chainID, contractAddress) + tokenType, err := api.db.GetTokenType(chainID, contractAddress) if err != nil { return "", err } - owner, err := contractInst.Owner(callOpts) - if err != nil { - return "", err + if tokenType == protobuf.CommunityTokenType_ERC721 { + contractInst, err := api.newCollectiblesInstance(chainID, contractAddress) + if err != nil { + return "", err + } + owner, err := contractInst.Owner(callOpts) + if err != nil { + return "", err + } + return owner.String(), nil + } else if tokenType == protobuf.CommunityTokenType_ERC20 { + contractInst, err := api.newAssetsInstance(chainID, contractAddress) + if err != nil { + return "", err + } + owner, err := contractInst.Owner(callOpts) + if err != nil { + return "", err + } + return owner.String(), nil } - return owner.String(), nil + return "", fmt.Errorf("unknown token type: %v", tokenType) } func (api *API) MintedCount(ctx context.Context, chainID uint64, contractAddress string) (*big.Int, error) { diff --git a/services/collectibles/database.go b/services/collectibles/database.go index 8381cf807..858512691 100644 --- a/services/collectibles/database.go +++ b/services/collectibles/database.go @@ -2,76 +2,30 @@ package collectibles import ( "database/sql" - "strings" + "fmt" + + "github.com/status-im/status-go/protocol/protobuf" ) type Database struct { db *sql.DB } -type TokenOwner struct { - Address string - Amount int -} - -func NewCollectiblesDatabase(db *sql.DB) *Database { +func NewCommunityTokensDatabase(db *sql.DB) *Database { return &Database{db: db} } -func (db *Database) GetAmount(chainID uint64, contractAddress string, owner string) (int, error) { - const selectQuery = `SELECT amount FROM community_token_owners WHERE chain_id=? AND address=? AND owner=? LIMIT 1` - rows, err := db.db.Query(selectQuery, chainID, contractAddress, owner) +func (db *Database) GetTokenType(chainID uint64, contractAddress string) (protobuf.CommunityTokenType, error) { + var result = protobuf.CommunityTokenType_UNKNOWN_TOKEN_TYPE + rows, err := db.db.Query(`SELECT type FROM community_tokens WHERE chain_id=? AND address=? LIMIT 1`, chainID, contractAddress) if err != nil { - return -1, err + return result, err } defer rows.Close() + if rows.Next() { - var amount int - err := rows.Scan(&amount) - if err != nil { - return -1, err - } - return amount, nil + err := rows.Scan(&result) + return result, err } - return 0, nil -} - -func (db *Database) setAmount(chainID uint64, contractAddress string, owner string, amount int) error { - const sqlQuery = `INSERT OR REPLACE INTO community_token_owners(chain_id, address, owner, amount) VALUES (?, ?, ?, ?)` - _, err := db.db.Exec(sqlQuery, chainID, contractAddress, owner, amount) - return err -} - -func (db *Database) AddTokenOwners(chainID uint64, contractAddress string, owners []string) error { - for _, v := range owners { - lowerVal := strings.ToLower(v) - amount, err := db.GetAmount(chainID, contractAddress, lowerVal) - if err != nil { - return err - } - err = db.setAmount(chainID, contractAddress, lowerVal, amount+1) - if err != nil { - return err - } - } - return nil -} - -func (db *Database) GetTokenOwners(chainID uint64, contractAddress string) ([]TokenOwner, error) { - const selectQuery = `SELECT owner, amount FROM community_token_owners WHERE chain_id=? AND address=?` - rows, err := db.db.Query(selectQuery, chainID, contractAddress) - if err != nil { - return nil, err - } - defer rows.Close() - var owners []TokenOwner - for rows.Next() { - var owner TokenOwner - err := rows.Scan(&owner.Address, &owner.Amount) - if err != nil { - return nil, err - } - owners = append(owners, owner) - } - return owners, nil + return result, fmt.Errorf("can't find token: chainId %v, contractAddress %v", chainID, contractAddress) } diff --git a/services/collectibles/database_test.go b/services/collectibles/database_test.go index 8f2990a65..453c11ac9 100644 --- a/services/collectibles/database_test.go +++ b/services/collectibles/database_test.go @@ -1,12 +1,15 @@ package collectibles import ( + "database/sql" "io/ioutil" "testing" "github.com/stretchr/testify/suite" "github.com/status-im/status-go/appdatabase" + "github.com/status-im/status-go/protocol/communities" + "github.com/status-im/status-go/protocol/protobuf" "github.com/status-im/status-go/protocol/sqlite" ) @@ -20,10 +23,60 @@ type DatabaseSuite struct { db *Database } +func (s *DatabaseSuite) addCommunityToken(db *sql.DB, token *communities.CommunityToken) error { + _, err := db.Exec(`INSERT INTO community_tokens (community_id, address, type, name, symbol, description, supply, + infinite_supply, transferable, remote_self_destruct, chain_id, deploy_state, image_base64, decimals) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, token.CommunityID, token.Address, token.TokenType, token.Name, + token.Symbol, token.Description, token.Supply, token.InfiniteSupply, token.Transferable, token.RemoteSelfDestruct, + token.ChainID, token.DeployState, token.Base64Image, token.Decimals) + return err +} + +func (s *DatabaseSuite) setupDatabase(db *sql.DB) error { + token721 := &communities.CommunityToken{ + CommunityID: "123", + TokenType: protobuf.CommunityTokenType_ERC721, + Address: "0x123", + Name: "StatusToken", + Symbol: "STT", + Description: "desc", + Supply: 123, + InfiniteSupply: false, + Transferable: true, + RemoteSelfDestruct: true, + ChainID: 1, + DeployState: communities.InProgress, + Base64Image: "ABCD", + } + + token20 := &communities.CommunityToken{ + CommunityID: "345", + TokenType: protobuf.CommunityTokenType_ERC20, + Address: "0x345", + Name: "StatusToken", + Symbol: "STT", + Description: "desc", + Supply: 345, + InfiniteSupply: false, + Transferable: true, + RemoteSelfDestruct: true, + ChainID: 2, + DeployState: communities.Failed, + Base64Image: "QWERTY", + Decimals: 21, + } + + err := s.addCommunityToken(db, token721) + if err != nil { + return err + } + return s.addCommunityToken(db, token20) +} + func (s *DatabaseSuite) SetupTest() { s.db = nil - dbPath, err := ioutil.TempFile("", "status-go-collectibles-db-") + dbPath, err := ioutil.TempFile("", "status-go-community-tokens-db-") s.NoError(err, "creating temp file for db") db, err := appdatabase.InitializeDB(dbPath.Name(), "", sqlite.ReducedKDFIterationsNumber) @@ -33,33 +86,20 @@ func (s *DatabaseSuite) SetupTest() { s.NoError(err, "protocol migrate") s.db = &Database{db: db} + + err = s.setupDatabase(db) + s.NoError(err, "setting up database") } -func (s *DatabaseSuite) TestAddOwner() { - owners, err := s.db.GetTokenOwners(5, "0x123") +func (s *DatabaseSuite) TestGetTokenType() { + contractType, err := s.db.GetTokenType(1, "0x123") s.Require().NoError(err) - s.Require().Len(owners, 0) + s.Equal(contractType, protobuf.CommunityTokenType_ERC721) - err = s.db.AddTokenOwners(5, "0x123", []string{"A", "B"}) + contractType, err = s.db.GetTokenType(2, "0x345") s.Require().NoError(err) - owners, err = s.db.GetTokenOwners(5, "0x123") - s.Require().NoError(err) - s.Require().Len(owners, 2) + s.Equal(contractType, protobuf.CommunityTokenType_ERC20) - s.Equal(owners[0].Amount, 1) - s.Equal(owners[1].Amount, 1) - - err = s.db.AddTokenOwners(5, "0x123", []string{"a"}) - s.Require().NoError(err) - owners, err = s.db.GetTokenOwners(5, "0x123") - s.Require().NoError(err) - s.Require().Len(owners, 2) - - amount, err := s.db.GetAmount(5, "0x123", "A") - s.Require().NoError(err) - s.Equal(amount, 2) - - amount, err = s.db.GetAmount(5, "0x123", "B") - s.Require().NoError(err) - s.Equal(amount, 1) + _, err = s.db.GetTokenType(10, "0x777") + s.Require().Error(err) }