frostfs-node/pkg/morph/client/static.go

package client

import (
	"errors"

	"github.com/nspcc-dev/neo-go/pkg/encoding/fixedn"
	"github.com/nspcc-dev/neo-go/pkg/util"
	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
)

// StaticClient is a wrapper over Neo:Morph client
// that invokes single smart contract methods with fixed fee.
//
// Working static client must be created via constructor NewStatic.
// Using the StaticClient that has been created with new(StaticClient)
// expression (or just declaring a StaticClient variable) is unsafe
// and can lead to panic.
type StaticClient struct {
	tryNotary bool

	client *Client // neo-go client instance

	scScriptHash util.Uint160 // contract script-hash

	fee fixedn.Fixed8 // invocation fee
}

type staticOpts struct {
	tryNotary bool
}

// StaticClientOption allows to set an optional
// parameter of StaticClient.
type StaticClientOption func(*staticOpts)

func defaultStaticOpts() *staticOpts {
	return new(staticOpts)
}

// TryNotaryInvoke returns option to enable
// notary invocation tries.
func TryNotary() StaticClientOption {
	return func(o *staticOpts) {
		o.tryNotary = true
	}
}

// ErrNilStaticClient is returned by functions that expect
// a non-nil StaticClient pointer, but received nil.
var ErrNilStaticClient = errors.New("static client is nil")

// NewStatic creates, initializes and returns the StaticClient instance.
//
// If provided Client instance is nil, ErrNilClient is returned.
func NewStatic(client *Client, scriptHash util.Uint160, fee fixedn.Fixed8, opts ...StaticClientOption) (*StaticClient, error) {
	if client == nil {
		return nil, ErrNilClient
	}

	o := defaultStaticOpts()

	for i := range opts {
		opts[i](o)
	}

	return &StaticClient{
		tryNotary:    o.tryNotary,
		client:       client,
		scScriptHash: scriptHash,
		fee:          fee,
	}, nil
}

// Invoke calls Invoke method of Client with static internal script hash and fee.
// Supported args types are the same as in Client.
//
// If TryNotary is provided, calls NotaryInvoke on Client.
func (s StaticClient) Invoke(method string, args ...interface{}) error {
	if s.tryNotary {
		return s.client.NotaryInvoke(s.scScriptHash, s.fee, method, args...)
	}

	return s.client.Invoke(
		s.scScriptHash,
		s.fee,
		method,
		args...,
	)
}

// TestInvoke calls TestInvoke method of Client with static internal script hash.
func (s StaticClient) TestInvoke(method string, args ...interface{}) ([]stackitem.Item, error) {
	return s.client.TestInvoke(
		s.scScriptHash,
		method,
		args...,
	)
}

// NotaryInvoke calls NotaryInvoke method of Client with static internal
// script hash. Panics if notary support was not enabled in underlying
// morph client.
//
// Deprecated: provide TryNotary() option to NewStatic and use Invoke.
func (s StaticClient) NotaryInvoke(method string, args ...interface{}) error {
	if s.client.notary == nil {
		panic(notaryNotEnabledPanicMsg)
	}
	return s.client.notaryInvoke(
		false,
		s.scScriptHash,
		method,
		args...,
	)
}