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

     1  package actor
     2  
     3  import (
     4  	"errors"
     5  	"testing"
     6  
     7  	"github.com/nspcc-dev/neo-go/pkg/core/transaction"
     8  	"github.com/nspcc-dev/neo-go/pkg/neorpc/result"
     9  	"github.com/nspcc-dev/neo-go/pkg/util"
    10  	"github.com/stretchr/testify/require"
    11  )
    12  
    13  func TestCalculateValidUntilBlock(t *testing.T) {
    14  	client, acc := testRPCAndAccount(t)
    15  	a, err := NewSimple(client, acc)
    16  	require.NoError(t, err)
    17  
    18  	client.err = errors.New("error")
    19  	_, err = a.CalculateValidUntilBlock()
    20  	require.Error(t, err)
    21  
    22  	client.err = nil
    23  	client.bCount.Store(42)
    24  	vub, err := a.CalculateValidUntilBlock()
    25  	require.NoError(t, err)
    26  	require.Equal(t, uint32(42+7+1), vub)
    27  
    28  	client.version.Protocol.ValidatorsHistory = map[uint32]uint32{
    29  		0:  7,
    30  		40: 4,
    31  		80: 10,
    32  	}
    33  	a, err = NewSimple(client, acc)
    34  	require.NoError(t, err)
    35  
    36  	vub, err = a.CalculateValidUntilBlock()
    37  	require.NoError(t, err)
    38  	require.Equal(t, uint32(42+4+1), vub)
    39  
    40  	client.bCount.Store(101)
    41  	vub, err = a.CalculateValidUntilBlock()
    42  	require.NoError(t, err)
    43  	require.Equal(t, uint32(101+10+1), vub)
    44  }
    45  
    46  func TestMakeUnsigned(t *testing.T) {
    47  	client, acc := testRPCAndAccount(t)
    48  	a, err := NewSimple(client, acc)
    49  	require.NoError(t, err)
    50  
    51  	// Bad parameters.
    52  	script := []byte{1, 2, 3}
    53  	_, err = a.MakeUnsignedUncheckedRun(script, -1, nil)
    54  	require.Error(t, err)
    55  	_, err = a.MakeUnsignedUncheckedRun([]byte{}, 1, nil)
    56  	require.Error(t, err)
    57  	_, err = a.MakeUnsignedUncheckedRun(nil, 1, nil)
    58  	require.Error(t, err)
    59  
    60  	// RPC error.
    61  	client.err = errors.New("err")
    62  	_, err = a.MakeUnsignedUncheckedRun(script, 1, nil)
    63  	require.Error(t, err)
    64  
    65  	// Good unchecked.
    66  	client.netFee = 42
    67  	client.bCount.Store(100500)
    68  	client.err = nil
    69  	tx, err := a.MakeUnsignedUncheckedRun(script, 1, nil)
    70  	require.NoError(t, err)
    71  	require.Equal(t, script, tx.Script)
    72  	require.Equal(t, 1, len(tx.Signers))
    73  	require.Equal(t, acc.Contract.ScriptHash(), tx.Signers[0].Account)
    74  	require.Equal(t, 1, len(tx.Scripts))
    75  	require.Equal(t, acc.Contract.Script, tx.Scripts[0].VerificationScript)
    76  	require.Nil(t, tx.Scripts[0].InvocationScript)
    77  
    78  	// Bad run.
    79  	client.err = errors.New("")
    80  	_, err = a.MakeUnsignedRun(script, nil)
    81  	require.Error(t, err)
    82  
    83  	// Faulted run.
    84  	client.invRes = &result.Invoke{State: "FAULT", GasConsumed: 3, Script: script}
    85  	client.err = nil
    86  	_, err = a.MakeUnsignedRun(script, nil)
    87  	require.Error(t, err)
    88  
    89  	// Good run.
    90  	client.invRes = &result.Invoke{State: "HALT", GasConsumed: 3, Script: script}
    91  	_, err = a.MakeUnsignedRun(script, nil)
    92  	require.NoError(t, err)
    93  
    94  	// Tuned.
    95  	opts := Options{
    96  		Attributes: []transaction.Attribute{{Type: transaction.HighPriority}},
    97  	}
    98  	a, err = NewTuned(client, a.signers, opts)
    99  	require.NoError(t, err)
   100  
   101  	tx, err = a.MakeUnsignedRun(script, nil)
   102  	require.NoError(t, err)
   103  	require.True(t, tx.HasAttribute(transaction.HighPriority))
   104  }
   105  
   106  func TestMakeSigned(t *testing.T) {
   107  	client, acc := testRPCAndAccount(t)
   108  	a, err := NewSimple(client, acc)
   109  	require.NoError(t, err)
   110  
   111  	// Bad script.
   112  	_, err = a.MakeUncheckedRun(nil, 0, nil, nil)
   113  	require.Error(t, err)
   114  
   115  	// Good, no hook.
   116  	script := []byte{1, 2, 3}
   117  	_, err = a.MakeUncheckedRun(script, 0, nil, nil)
   118  	require.NoError(t, err)
   119  
   120  	// Bad, can't sign because of a hook.
   121  	_, err = a.MakeUncheckedRun(script, 0, nil, func(t *transaction.Transaction) error {
   122  		t.Signers = append(t.Signers, transaction.Signer{})
   123  		return nil
   124  	})
   125  	require.Error(t, err)
   126  
   127  	// Bad, hook returns an error.
   128  	_, err = a.MakeUncheckedRun(script, 0, nil, func(t *transaction.Transaction) error {
   129  		return errors.New("")
   130  	})
   131  	require.Error(t, err)
   132  
   133  	// Good with a hook.
   134  	tx, err := a.MakeUncheckedRun(script, 0, nil, func(t *transaction.Transaction) error {
   135  		t.ValidUntilBlock = 777
   136  		return nil
   137  	})
   138  	require.NoError(t, err)
   139  	require.Equal(t, uint32(777), tx.ValidUntilBlock)
   140  
   141  	// Tuned.
   142  	opts := Options{
   143  		Modifier: func(t *transaction.Transaction) error {
   144  			t.ValidUntilBlock = 888
   145  			return nil
   146  		},
   147  	}
   148  	at, err := NewTuned(client, a.signers, opts)
   149  	require.NoError(t, err)
   150  
   151  	tx, err = at.MakeUncheckedRun(script, 0, nil, nil)
   152  	require.NoError(t, err)
   153  	require.Equal(t, uint32(888), tx.ValidUntilBlock)
   154  
   155  	// Checked
   156  
   157  	// Bad, invocation fails.
   158  	client.err = errors.New("")
   159  	_, err = a.MakeTunedRun(script, nil, func(r *result.Invoke, t *transaction.Transaction) error {
   160  		return nil
   161  	})
   162  	require.Error(t, err)
   163  
   164  	// Bad, hook returns an error.
   165  	client.err = nil
   166  	client.invRes = &result.Invoke{State: "HALT", GasConsumed: 3, Script: script}
   167  	_, err = a.MakeTunedRun(script, nil, func(r *result.Invoke, t *transaction.Transaction) error {
   168  		return errors.New("")
   169  	})
   170  	require.Error(t, err)
   171  
   172  	// Good, no hook.
   173  	_, err = a.MakeTunedRun(script, []transaction.Attribute{{Type: transaction.HighPriority}}, nil)
   174  	require.NoError(t, err)
   175  	_, err = a.MakeRun(script)
   176  	require.NoError(t, err)
   177  
   178  	// Bad, invocation returns FAULT.
   179  	client.invRes = &result.Invoke{State: "FAULT", GasConsumed: 3, Script: script}
   180  	_, err = a.MakeTunedRun(script, nil, nil)
   181  	require.Error(t, err)
   182  
   183  	// Good, invocation returns FAULT, but callback ignores it.
   184  	_, err = a.MakeTunedRun(script, nil, func(r *result.Invoke, t *transaction.Transaction) error {
   185  		return nil
   186  	})
   187  	require.NoError(t, err)
   188  
   189  	// Good, via call and with a callback.
   190  	_, err = a.MakeTunedCall(util.Uint160{}, "something", []transaction.Attribute{{Type: transaction.HighPriority}}, func(r *result.Invoke, t *transaction.Transaction) error {
   191  		return nil
   192  	}, "param", 1)
   193  	require.NoError(t, err)
   194  
   195  	// Bad, it still is a FAULT.
   196  	_, err = a.MakeCall(util.Uint160{}, "method")
   197  	require.Error(t, err)
   198  
   199  	// Good.
   200  	client.invRes = &result.Invoke{State: "HALT", GasConsumed: 3, Script: script}
   201  	_, err = a.MakeCall(util.Uint160{}, "method", 1)
   202  	require.NoError(t, err)
   203  
   204  	// Tuned.
   205  	opts = Options{
   206  		CheckerModifier: func(r *result.Invoke, t *transaction.Transaction) error {
   207  			t.ValidUntilBlock = 888
   208  			return nil
   209  		},
   210  	}
   211  	at, err = NewTuned(client, a.signers, opts)
   212  	require.NoError(t, err)
   213  
   214  	tx, err = at.MakeRun(script)
   215  	require.NoError(t, err)
   216  	require.Equal(t, uint32(888), tx.ValidUntilBlock)
   217  }