package communitytokens import ( "context" "fmt" "math/big" "strings" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/accounts/abi/bind" "github.com/ethereum/go-ethereum/core/types" "github.com/status-im/status-go/contracts/community-tokens/assets" "github.com/status-im/status-go/contracts/community-tokens/collectibles" "github.com/status-im/status-go/contracts/community-tokens/mastertoken" "github.com/status-im/status-go/contracts/community-tokens/ownertoken" "github.com/status-im/status-go/protocol/communities/token" "github.com/status-im/status-go/protocol/protobuf" "github.com/status-im/status-go/services/wallet/bigint" ) type TokenInstance interface { RemoteBurn(*bind.TransactOpts, []*big.Int) (*types.Transaction, error) Mint(*bind.TransactOpts, []string, *bigint.BigInt) (*types.Transaction, error) SetMaxSupply(*bind.TransactOpts, *big.Int) (*types.Transaction, error) PackMethod(ctx context.Context, methodName string, args ...interface{}) ([]byte, error) } // Owner Token type OwnerTokenInstance struct { TokenInstance instance *ownertoken.OwnerToken } func (t OwnerTokenInstance) RemoteBurn(transactOpts *bind.TransactOpts, tokenIds []*big.Int) (*types.Transaction, error) { return nil, fmt.Errorf("remote destruction for owner token not implemented") } func (t OwnerTokenInstance) Mint(transactOpts *bind.TransactOpts, walletAddresses []string, amount *bigint.BigInt) (*types.Transaction, error) { return nil, fmt.Errorf("minting for owner token not implemented") } func (t OwnerTokenInstance) SetMaxSupply(transactOpts *bind.TransactOpts, maxSupply *big.Int) (*types.Transaction, error) { return nil, fmt.Errorf("setting max supply for owner token not implemented") } func (t OwnerTokenInstance) PackMethod(ctx context.Context, methodName string, args ...interface{}) ([]byte, error) { ownerTokenABI, err := abi.JSON(strings.NewReader(ownertoken.OwnerTokenABI)) if err != nil { return []byte{}, err } return ownerTokenABI.Pack(methodName, args...) } // Master Token type MasterTokenInstance struct { TokenInstance instance *mastertoken.MasterToken api *API } func (t MasterTokenInstance) RemoteBurn(transactOpts *bind.TransactOpts, tokenIds []*big.Int) (*types.Transaction, error) { return t.instance.RemoteBurn(transactOpts, tokenIds) } func (t MasterTokenInstance) Mint(transactOpts *bind.TransactOpts, walletAddresses []string, amount *bigint.BigInt) (*types.Transaction, error) { usersAddresses := t.api.PrepareMintCollectiblesData(walletAddresses, amount) return t.instance.MintTo(transactOpts, usersAddresses) } func (t MasterTokenInstance) SetMaxSupply(transactOpts *bind.TransactOpts, maxSupply *big.Int) (*types.Transaction, error) { return t.instance.SetMaxSupply(transactOpts, maxSupply) } func (t MasterTokenInstance) PackMethod(ctx context.Context, methodName string, args ...interface{}) ([]byte, error) { masterTokenABI, err := abi.JSON(strings.NewReader(mastertoken.MasterTokenABI)) if err != nil { return []byte{}, err } return masterTokenABI.Pack(methodName, args...) } // Collectible type CollectibleInstance struct { TokenInstance instance *collectibles.Collectibles api *API } func (t CollectibleInstance) RemoteBurn(transactOpts *bind.TransactOpts, tokenIds []*big.Int) (*types.Transaction, error) { return t.instance.RemoteBurn(transactOpts, tokenIds) } func (t CollectibleInstance) Mint(transactOpts *bind.TransactOpts, walletAddresses []string, amount *bigint.BigInt) (*types.Transaction, error) { usersAddresses := t.api.PrepareMintCollectiblesData(walletAddresses, amount) return t.instance.MintTo(transactOpts, usersAddresses) } func (t CollectibleInstance) SetMaxSupply(transactOpts *bind.TransactOpts, maxSupply *big.Int) (*types.Transaction, error) { return t.instance.SetMaxSupply(transactOpts, maxSupply) } func (t CollectibleInstance) PackMethod(ctx context.Context, methodName string, args ...interface{}) ([]byte, error) { collectiblesABI, err := abi.JSON(strings.NewReader(collectibles.CollectiblesABI)) if err != nil { return []byte{}, err } return collectiblesABI.Pack(methodName, args...) } // Asset type AssetInstance struct { TokenInstance instance *assets.Assets api *API } func (t AssetInstance) RemoteBurn(transactOpts *bind.TransactOpts, tokenIds []*big.Int) (*types.Transaction, error) { return nil, fmt.Errorf("remote destruction for assets not implemented") } // The amount should be in smallest denomination of the asset (like wei) with decimal = 18, eg. // if we want to mint 2.34 of the token, then amount should be 234{16 zeros}. func (t AssetInstance) Mint(transactOpts *bind.TransactOpts, walletAddresses []string, amount *bigint.BigInt) (*types.Transaction, error) { usersAddresses, amountsList := t.api.PrepareMintAssetsData(walletAddresses, amount) return t.instance.MintTo(transactOpts, usersAddresses, amountsList) } func (t AssetInstance) SetMaxSupply(transactOpts *bind.TransactOpts, maxSupply *big.Int) (*types.Transaction, error) { return t.instance.SetMaxSupply(transactOpts, maxSupply) } func (t AssetInstance) PackMethod(ctx context.Context, methodName string, args ...interface{}) ([]byte, error) { assetsABI, err := abi.JSON(strings.NewReader(assets.AssetsABI)) if err != nil { return []byte{}, err } return assetsABI.Pack(methodName, args...) } // creator func NewTokenInstance(api *API, chainID uint64, contractAddress string) (TokenInstance, error) { tokenType, err := api.s.db.GetTokenType(chainID, contractAddress) if err != nil { return nil, err } privLevel, err := api.s.db.GetTokenPrivilegesLevel(chainID, contractAddress) if err != nil { return nil, err } switch { case privLevel == token.OwnerLevel: contractInst, err := api.NewOwnerTokenInstance(chainID, contractAddress) if err != nil { return nil, err } return &OwnerTokenInstance{instance: contractInst}, nil case privLevel == token.MasterLevel: contractInst, err := api.NewMasterTokenInstance(chainID, contractAddress) if err != nil { return nil, err } return &MasterTokenInstance{instance: contractInst}, nil case tokenType == protobuf.CommunityTokenType_ERC721: contractInst, err := api.NewCollectiblesInstance(chainID, contractAddress) if err != nil { return nil, err } return &CollectibleInstance{instance: contractInst}, nil case tokenType == protobuf.CommunityTokenType_ERC20: contractInst, err := api.NewAssetsInstance(chainID, contractAddress) if err != nil { return nil, err } return &AssetInstance{instance: contractInst}, nil } return nil, fmt.Errorf("unknown type of contract: chain=%v, address=%v", chainID, contractAddress) }