ir/container: Handle creation request calling new CreateV2 method

Will become available with nspcc-dev/neofs-contract#534
upgrade.

Signed-off-by: Leonard Lyubich <leonard@morphbits.io>

Author: cthulhu-rider

CHANGELOG.md

@@ -5,6 +5,7 @@ Changelog for NeoFS Node
 
 ### Added
 - SN now supports new `getInfo` and `createV2` methods of the Container contract (#3670)
+- IR now supports container creation requests submitted via new `createV2` contract method (#3670)
 
 ### Fixed
 

pkg/innerring/processors/container/handlers.go

@@ -11,6 +11,15 @@ import (
 	"go.uber.org/zap"
 )
 
+func (cp *Processor) handleCreationRequest(ev event.Event) {
+	err := cp.pool.Submit(func() { cp.processCreateContainerRequest(ev.(containerEvent.CreateContainerV2Request)) })
+	if err != nil {
+		// there system can be moved into controlled degradation stage
+		cp.log.Warn("container processor worker pool drained",
+			zap.Int("capacity", cp.pool.Cap()))
+	}
+}
+
 func (cp *Processor) handlePut(ev event.Event) {
 	req, ok := ev.(containerEvent.CreateContainerRequest)
 	if !ok {

pkg/innerring/processors/container/process_container.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/nspcc-dev/neo-go/pkg/core/transaction"
 	"github.com/nspcc-dev/neo-go/pkg/network/payload"
+	fschaincontracts "github.com/nspcc-dev/neofs-node/pkg/morph/contracts"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/event"
 	containerEvent "github.com/nspcc-dev/neofs-node/pkg/morph/event/container"
 	containerSDK "github.com/nspcc-dev/neofs-sdk-go/container"
@@ -15,6 +16,31 @@ import (
 	"go.uber.org/zap"
 )
 
+func (cp *Processor) processCreateContainerRequest(req containerEvent.CreateContainerV2Request) {
+	if !cp.alphabetState.IsAlphabet() {
+		cp.log.Info("non alphabet mode, ignore container creation request")
+		return
+	}
+
+	cnr, err := fschaincontracts.ContainerFromStruct(req.Container)
+	if err != nil {
+		cp.log.Error("invalid container struct in creation request", zap.Error(err))
+		return
+	}
+
+	cnrBytes := cnr.Marshal()
+	id := cid.NewFromMarshalledContainer(cnrBytes)
+
+	err = cp.checkPutContainer(cnr, cnrBytes, req.SessionToken, req.InvocationScript, req.VerificationScript, "", "")
+	if err != nil {
+		cp.log.Error("container creation request failed check",
+			zap.Stringer("container", id), zap.Error(err))
+		return
+	}
+
+	cp.approvePutContainer(req.MainTransaction, cnr, id)
+}
+
 // putEvent is a common interface of Put and PutNamed event.
 type putEvent interface {
 	event.Event

pkg/innerring/processors/container/processor.go

@@ -137,6 +137,10 @@ func (cp *Processor) ListenerNotaryParsers() []event.NotaryParserInfo {
 	p.SetParser(containerEvent.RestoreCreateContainerRequest)
 	pp = append(pp, p)
 
+	p.SetRequestType(fschaincontracts.CreateContainerV2Method)
+	p.SetParser(containerEvent.RestoreCreateContainerV2Request)
+	pp = append(pp, p)
+
 	// container delete
 	p.SetRequestType(containerEvent.DeleteNotaryEvent)
 	p.SetParser(containerEvent.ParseDeleteNotary)
@@ -194,6 +198,10 @@ func (cp *Processor) ListenerNotaryHandlers() []event.NotaryHandlerInfo {
 	h.SetHandler(cp.handlePut)
 	hh = append(hh, h)
 
+	h.SetRequestType(fschaincontracts.CreateContainerV2Method)
+	h.SetHandler(cp.handleCreationRequest)
+	hh = append(hh, h)
+
 	// container delete
 	h.SetRequestType(containerEvent.DeleteNotaryEvent)
 	h.SetHandler(cp.handleDelete)

pkg/morph/contracts/models.go

@@ -22,6 +22,11 @@ func ContainerFromStackItem(item stackitem.Item) (container.Container, error) {
 		return container.Container{}, err
 	}
 
+	return ContainerFromStruct(contractStruct)
+}
+
+// ContainerFromStruct decodes container from contract structure.
+func ContainerFromStruct(contractStruct containerrpc.ContainerInfo) (container.Container, error) {
 	mjr, mnr, err := containerVersionFromStruct(contractStruct.Version)
 	if err != nil {
 		return container.Container{}, err

pkg/morph/event/container/notary_requests.go

@@ -4,27 +4,85 @@ import (
 	"fmt"
 
 	"github.com/nspcc-dev/neo-go/pkg/core/transaction"
+	"github.com/nspcc-dev/neo-go/pkg/vm"
 	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
+	containerrpc "github.com/nspcc-dev/neofs-contract/rpc/container"
 	fschaincontracts "github.com/nspcc-dev/neofs-node/pkg/morph/contracts"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/event"
 )
 
 func getArgsFromEvent(ne event.NotaryEvent, expectedNum int) ([]event.Op, error) {
 	args := ne.Params()
 	if len(args) != expectedNum {
-		return nil, fmt.Errorf("wrong/unsupported arg num %d instead of %d", len(args), expectedNum)
+		return nil, newWrongArgNumError(expectedNum, len(args))
 	}
 	return args, nil
 }
 
 func getValueFromArg[T any](args []event.Op, i int, desc string, typ stackitem.Type, f func(event.Op) (T, error)) (v T, err error) {
 	v, err = f(args[i])
 	if err != nil {
-		return v, fmt.Errorf("arg#%d (%s, %s): %w", i, typ, desc, err)
+		return v, wrapInvalidArgError(i, typ, desc, err)
 	}
 	return v, nil
 }
 
+func wrapInvalidArgError(i int, typ stackitem.Type, desc string, err error) error {
+	return fmt.Errorf("arg#%d (%s, %s): %w", i, typ, desc, err)
+}
+
+func newWrongArgNumError(expected, actual int) error {
+	return fmt.Errorf("wrong/unsupported arg num %d instead of %d", actual, expected)
+}
+
+// CreateContainerRequest wraps container creation request to provide
+// app-internal event.
+type CreateContainerV2Request struct {
+	event.Event
+	MainTransaction transaction.Transaction
+
+	Container          containerrpc.ContainerInfo
+	InvocationScript   []byte
+	VerificationScript []byte
+	SessionToken       []byte
+}
+
+// RestoreCreateContainerV2Request restores [CreateContainerV2Request] from the
+// notary one.
+func RestoreCreateContainerV2Request(notaryReq event.NotaryEvent) (event.Event, error) {
+	testVM := vm.New()
+	testVM.LoadScript(notaryReq.ArgumentScript())
+
+	if err := testVM.Run(); err != nil {
+		return nil, fmt.Errorf("exec script on test VM: %w", err)
+	}
+
+	stack := testVM.Estack()
+	const argNum = 4
+	if got := stack.Len(); got != argNum {
+		return nil, newWrongArgNumError(argNum, got)
+	}
+
+	var res CreateContainerV2Request
+	var err error
+
+	if err = res.Container.FromStackItem(stack.Pop().Item()); err != nil {
+		return nil, wrapInvalidArgError(argNum-1, stackitem.StructT, "container", err)
+	}
+	if res.InvocationScript, err = stack.Pop().Item().TryBytes(); err != nil {
+		return nil, wrapInvalidArgError(argNum-2, stackitem.ByteArrayT, "invocation script", err)
+	}
+	if res.VerificationScript, err = stack.Pop().Item().TryBytes(); err != nil {
+		return nil, wrapInvalidArgError(argNum-3, stackitem.ByteArrayT, "verification script", err)
+	}
+	if res.SessionToken, err = stack.Pop().Item().TryBytes(); err != nil {
+		return nil, wrapInvalidArgError(argNum-4, stackitem.ByteArrayT, "session token", err)
+	}
+	res.MainTransaction = *notaryReq.Raw().MainTransaction
+
+	return res, nil
+}
+
 // CreateContainerRequest wraps container creation request to provide
 // app-internal event.
 type CreateContainerRequest struct {