github.com/nspcc-dev/neo-go@v0.105.2-0.20240517133400-6be757af3eba/pkg/rpcclient/neptoken/info_test.go (about)

     1  package neptoken
     2  
     3  import (
     4  	"errors"
     5  	"testing"
     6  
     7  	"github.com/google/uuid"
     8  	"github.com/nspcc-dev/neo-go/pkg/core/state"
     9  	"github.com/nspcc-dev/neo-go/pkg/core/transaction"
    10  	"github.com/nspcc-dev/neo-go/pkg/neorpc/result"
    11  	"github.com/nspcc-dev/neo-go/pkg/smartcontract"
    12  	"github.com/nspcc-dev/neo-go/pkg/smartcontract/manifest"
    13  	"github.com/nspcc-dev/neo-go/pkg/util"
    14  	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
    15  	"github.com/nspcc-dev/neo-go/pkg/wallet"
    16  	"github.com/stretchr/testify/require"
    17  )
    18  
    19  type rpcClient struct {
    20  	cnt     int
    21  	cserr   error
    22  	cs      *state.Contract
    23  	inverrs []error
    24  	invs    []*result.Invoke
    25  }
    26  
    27  func (r *rpcClient) InvokeContractVerify(contract util.Uint160, params []smartcontract.Parameter, signers []transaction.Signer, witnesses ...transaction.Witness) (*result.Invoke, error) {
    28  	panic("not implemented")
    29  }
    30  func (r *rpcClient) InvokeFunction(contract util.Uint160, operation string, params []smartcontract.Parameter, signers []transaction.Signer) (*result.Invoke, error) {
    31  	e, i := r.inverrs[r.cnt], r.invs[r.cnt]
    32  	r.cnt = (r.cnt + 1) % len(r.invs)
    33  	return i, e
    34  }
    35  func (r *rpcClient) InvokeScript(script []byte, signers []transaction.Signer) (*result.Invoke, error) {
    36  	panic("not implemented")
    37  }
    38  func (r *rpcClient) TerminateSession(sessionID uuid.UUID) (bool, error) {
    39  	panic("not implemented")
    40  }
    41  func (r *rpcClient) TraverseIterator(sessionID, iteratorID uuid.UUID, maxItemsCount int) ([]stackitem.Item, error) {
    42  	panic("not implemented")
    43  }
    44  func (r *rpcClient) GetContractStateByHash(hash util.Uint160) (*state.Contract, error) {
    45  	return r.cs, r.cserr
    46  }
    47  
    48  func TestInfo(t *testing.T) {
    49  	c := &rpcClient{}
    50  	hash := util.Uint160{1, 2, 3}
    51  
    52  	// Error on contract state.
    53  	c.cserr = errors.New("")
    54  	_, err := Info(c, hash)
    55  	require.Error(t, err)
    56  
    57  	// Error on missing standard.
    58  	c.cserr = nil
    59  	c.cs = &state.Contract{
    60  		ContractBase: state.ContractBase{
    61  			Manifest: manifest.Manifest{
    62  				Name:               "Vasiliy",
    63  				SupportedStandards: []string{"RFC 1149"},
    64  			},
    65  		},
    66  	}
    67  	_, err = Info(c, hash)
    68  	require.Error(t, err)
    69  
    70  	// Error on Symbol()
    71  	c.cs = &state.Contract{
    72  		ContractBase: state.ContractBase{
    73  			Manifest: manifest.Manifest{
    74  				Name:               "Übertoken",
    75  				SupportedStandards: []string{"NEP-17"},
    76  			},
    77  		},
    78  	}
    79  	c.inverrs = []error{errors.New(""), nil}
    80  	c.invs = []*result.Invoke{nil, nil}
    81  	_, err = Info(c, hash)
    82  	require.Error(t, err)
    83  
    84  	// Error on Decimals()
    85  	c.cnt = 0
    86  	c.inverrs[0], c.inverrs[1] = c.inverrs[1], c.inverrs[0]
    87  	c.invs[0] = &result.Invoke{
    88  		State: "HALT",
    89  		Stack: []stackitem.Item{
    90  			stackitem.Make("UBT"),
    91  		},
    92  	}
    93  	_, err = Info(c, hash)
    94  	require.Error(t, err)
    95  
    96  	// OK
    97  	c.cnt = 0
    98  	c.inverrs[1] = nil
    99  	c.invs[1] = &result.Invoke{
   100  		State: "HALT",
   101  		Stack: []stackitem.Item{
   102  			stackitem.Make(8),
   103  		},
   104  	}
   105  	ti, err := Info(c, hash)
   106  	require.NoError(t, err)
   107  	require.Equal(t, &wallet.Token{
   108  		Name:     "Übertoken",
   109  		Hash:     hash,
   110  		Decimals: 8,
   111  		Symbol:   "UBT",
   112  		Standard: "NEP-17",
   113  	}, ti)
   114  
   115  	// NEP-11
   116  	c.cs = &state.Contract{
   117  		ContractBase: state.ContractBase{
   118  			Manifest: manifest.Manifest{
   119  				Name:               "NFTizer",
   120  				SupportedStandards: []string{"NEP-11"},
   121  			},
   122  		},
   123  	}
   124  	c.cnt = 0
   125  	c.inverrs[1] = nil
   126  	c.invs[0] = &result.Invoke{
   127  		State: "HALT",
   128  		Stack: []stackitem.Item{
   129  			stackitem.Make("NZ"),
   130  		},
   131  	}
   132  	c.invs[1] = &result.Invoke{
   133  		State: "HALT",
   134  		Stack: []stackitem.Item{
   135  			stackitem.Make(0),
   136  		},
   137  	}
   138  	ti, err = Info(c, hash)
   139  	require.NoError(t, err)
   140  	require.Equal(t, &wallet.Token{
   141  		Name:     "NFTizer",
   142  		Hash:     hash,
   143  		Decimals: 0,
   144  		Symbol:   "NZ",
   145  		Standard: "NEP-11",
   146  	}, ti)
   147  }