github.com/0chain/gosdk@v1.17.11/znft/storageerc721random.go (about)

     1  package znft
     2  
     3  import (
     4  	"context"
     5  	"math/big"
     6  
     7  	"github.com/ethereum/go-ethereum/common"
     8  
     9  	"github.com/pkg/errors"
    10  
    11  	storageerc721random "github.com/0chain/gosdk/znft/contracts/dstorageerc721random/binding"
    12  )
    13  
    14  // Solidity Functions
    15  // function mintOwner(uint256 amount)
    16  // function mint(uint256 amount)
    17  // function reveal(uint256[] calldata tokens) external returns (bytes32)
    18  // function tokenURI(uint256 tokenId) returns (string memory)
    19  // function tokenURIFallback(uint256 tokenId) returns (string memory)
    20  // function setHidden(string calldata hidden_)
    21  // function setPack(address pack_)
    22  // function setRevealable(bool status_)
    23  
    24  type IStorageECR721Random interface {
    25  	MintOwner(amount *big.Int) error
    26  	Mint(amount *big.Int) error
    27  	Reveal(tokens []*big.Int) error
    28  	TokenURI(token *big.Int) (string, error)
    29  	TokenURIFallback(token *big.Int) (string, error)
    30  	SetHidden(hidden string) error
    31  	SetPack(address common.Address) error
    32  	SetRevealable(status bool) error
    33  	Price() (*big.Int, error)
    34  }
    35  
    36  var (
    37  	_ IStorageECR721Random = (*StorageECR721Random)(nil)
    38  )
    39  
    40  type StorageECR721Random struct {
    41  	session *storageerc721random.BindingSession
    42  	ctx     context.Context
    43  }
    44  
    45  func (s *StorageECR721Random) MintOwner(amount *big.Int) error {
    46  	evmTr, err := s.session.MintOwner(amount)
    47  	if err != nil {
    48  		err = errors.Wrapf(err, "failed to execute %s", MintOwner)
    49  		Logger.Error(err)
    50  		return err
    51  	}
    52  
    53  	Logger.Info("Executed ", MintOwner, " hash: ", evmTr.Hash())
    54  
    55  	return nil
    56  }
    57  
    58  func (s *StorageECR721Random) Mint(amount *big.Int) error {
    59  	evmTr, err := s.session.Mint(amount)
    60  	if err != nil {
    61  		err = errors.Wrapf(err, "failed to execute %s", Mint)
    62  		Logger.Error(err)
    63  		return err
    64  	}
    65  
    66  	Logger.Info("Executed ", Mint, "hash: ", evmTr.Hash())
    67  
    68  	return nil
    69  }
    70  
    71  func (s *StorageECR721Random) Reveal(tokens []*big.Int) error {
    72  	evmTr, err := s.session.Reveal(tokens)
    73  	if err != nil {
    74  		err = errors.Wrapf(err, "failed to execute %s", "Reveal")
    75  		Logger.Error(err)
    76  		return err
    77  	}
    78  
    79  	Logger.Info("Executed Reveal, hash: ", evmTr.Hash())
    80  
    81  	return nil
    82  }
    83  
    84  func (s *StorageECR721Random) TokenURI(token *big.Int) (string, error) {
    85  	tokenURI, err := s.session.TokenURI(token)
    86  	if err != nil {
    87  		err = errors.Wrapf(err, "failed to read %s", TokenURI)
    88  		Logger.Error(err)
    89  		return "", err
    90  	}
    91  
    92  	return tokenURI, nil
    93  }
    94  
    95  func (s *StorageECR721Random) TokenURIFallback(token *big.Int) (string, error) {
    96  	tokenURI, err := s.session.TokenURIFallback(token)
    97  	if err != nil {
    98  		err = errors.Wrapf(err, "failed to read %s", TokenURIFallback)
    99  		Logger.Error(err)
   100  		return "", err
   101  	}
   102  
   103  	return tokenURI, nil
   104  }
   105  
   106  func (s *StorageECR721Random) SetHidden(hidden string) error {
   107  	evmTr, err := s.session.SetHidden(hidden)
   108  	if err != nil {
   109  		err = errors.Wrapf(err, "failed to execute %s", "SetHidden")
   110  		Logger.Error(err)
   111  		return err
   112  	}
   113  
   114  	Logger.Info("Executed SetHidden, hash: ", evmTr.Hash())
   115  
   116  	return nil
   117  }
   118  
   119  func (s *StorageECR721Random) SetPack(address common.Address) error {
   120  	evmTr, err := s.session.SetPack(address)
   121  	if err != nil {
   122  		err = errors.Wrapf(err, "failed to execute %s", "SetPack")
   123  		Logger.Error(err)
   124  		return err
   125  	}
   126  
   127  	Logger.Info("Executed SetPack, hash: ", evmTr.Hash())
   128  
   129  	return nil
   130  }
   131  
   132  func (s *StorageECR721Random) SetRevealable(status bool) error {
   133  	evmTr, err := s.session.SetRevealable(status)
   134  	if err != nil {
   135  		err = errors.Wrapf(err, "failed to execute %s", "SetRevealable")
   136  		Logger.Error(err)
   137  		return err
   138  	}
   139  
   140  	Logger.Info("Executed SetRevealable, hash: ", evmTr.Hash())
   141  
   142  	return nil
   143  }
   144  
   145  func (s *StorageECR721Random) Price() (*big.Int, error) {
   146  	price, err := s.session.Price()
   147  	if err != nil {
   148  		err = errors.Wrapf(err, "failed to execute %s", "SetMax")
   149  		Logger.Error(err)
   150  		return price, err
   151  	}
   152  
   153  	return price, nil
   154  }