ir/container: Implement iterative background structuring in contract

Within nspcc-dev/neofs-contract#449, there is
a need to store containers as VM structs. Since
nspcc-dev/neofs-contract#534, struct items are
stored for new containers. This also needs to be done for containers
created before the upgrade.

Since doing this in a contract update transaction turned out to be too
GAS-intensive, this implements structuring through the IR background
process. Specialized method is called iteratively doing the same thing,
but for several containers at a time.

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

Author: cthulhu-rider

CHANGELOG.md

@@ -6,6 +6,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)
+- IR structures containers in the contract iteratively (#3670)
 
 ### Fixed
 

pkg/innerring/innerring.go

@@ -88,7 +88,8 @@ type (
 		withoutMainNet       bool
 
 		// runtime processors
-		netmapProcessor *netmap.Processor
+		netmapProcessor    *netmap.Processor
+		containerProcessor *container.Processor
 
 		workers []func(context.Context)
 
@@ -229,6 +230,12 @@ func (s *Server) Start(ctx context.Context, intError chan<- error) (err error) {
 	go s.fsChainListener.ListenWithError(ctx, fsChainErr)  // listen for neo:fs events
 	go s.mainnetListener.ListenWithError(ctx, mainnnetErr) // listen for neo:mainnet events
 
+	go func() {
+		if err := s.containerProcessor.AddContainerStructs(ctx); err != nil {
+			fsChainErr <- fmt.Errorf("structurize containers in the contract: %w", err)
+		}
+	}()
+
 	s.startWorkers(ctx)
 
 	return nil
@@ -820,7 +827,7 @@ func New(ctx context.Context, log *zap.Logger, cfg *config.Config, errChan chan<
 	}
 
 	// container processor
-	containerProcessor, err := container.New(&container.Params{
+	server.containerProcessor, err = container.New(&container.Params{
 		Log:             log,
 		PoolSize:        cfg.Workers.Container,
 		AlphabetState:   server,
@@ -833,7 +840,7 @@ func New(ctx context.Context, log *zap.Logger, cfg *config.Config, errChan chan<
 		return nil, err
 	}
 
-	err = bindFSChainProcessor(containerProcessor, server)
+	err = bindFSChainProcessor(server.containerProcessor, server)
 	if err != nil {
 		return nil, err
 	}

pkg/innerring/processors/container/processor.go

@@ -1,9 +1,13 @@
 package container
 
 import (
+	"context"
 	"errors"
 	"fmt"
+	"time"
 
+	"github.com/nspcc-dev/neo-go/pkg/neorpc"
+	"github.com/nspcc-dev/neo-go/pkg/vm/vmstate"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/client/container"
 	fschaincontracts "github.com/nspcc-dev/neofs-node/pkg/morph/contracts"
 	"github.com/nspcc-dev/neofs-node/pkg/morph/event"
@@ -171,6 +175,10 @@ func (cp *Processor) ListenerNotaryParsers() []event.NotaryParserInfo {
 	p.SetParser(containerEvent.ParseObjectPut)
 	pp = append(pp, p)
 
+	// migrate protobuf->struct
+	p.SetRequestType(fschaincontracts.AddContainerStructsMethod)
+	p.SetParser(containerEvent.RestoreAddStructsRequest)
+
 	return pp
 }
 
@@ -232,10 +240,71 @@ func (cp *Processor) ListenerNotaryHandlers() []event.NotaryHandlerInfo {
 	h.SetHandler(cp.handleObjectPut)
 	hh = append(hh, h)
 
+	// migrate protobuf->struct
+	h.SetRequestType(fschaincontracts.AddContainerStructsMethod)
+	h.SetHandler(func(ev event.Event) {
+		cp.log.Info("received notary tx migrating containers' protobuf->struct, signing...")
+
+		req := ev.(containerEvent.AddStructsRequest)
+		err := cp.cnrClient.Morph().NotarySignAndInvokeTX(&req.MainTransaction, false)
+		if err != nil {
+			cp.log.Error("failed to sign notary tx migrating containers' protobuf->struct", zap.Error(err))
+			return
+		}
+
+		cp.log.Info("notary tx migrating containers' protobuf->struct signed successfully")
+	})
+
 	return hh
 }
 
 // TimersHandlers for the 'Timers' event producer.
 func (cp *Processor) TimersHandlers() []event.NotificationHandlerInfo {
 	return nil
 }
+
+// AddContainerStructs iteratively calls the contract to add structured storage
+// items for containers.
+func (cp *Processor) AddContainerStructs(ctx context.Context) error {
+	cp.log.Info("structuring containers in the contract...")
+
+	cnrContract := cp.cnrClient.ContractAddress()
+	fsChain := cp.cnrClient.Morph()
+	for ; ; time.Sleep(5 * time.Second) {
+		txRes, err := fsChain.CallNotary(ctx, cnrContract, fschaincontracts.AddContainerStructsMethod)
+		if err != nil {
+			if !errors.Is(err, neorpc.ErrInsufficientFunds) {
+				return fmt.Errorf("notary call %s contract method: %w", fschaincontracts.AddContainerStructsMethod, err)
+			}
+
+			cp.log.Warn("not enough GAS for notary call, will try again later",
+				zap.String("method", fschaincontracts.AddContainerStructsMethod), zap.Error(err))
+			continue
+		}
+
+		txs := txRes.Container.StringLE()
+
+		if !txRes.VMState.HasFlag(vmstate.Halt) {
+			cp.log.Warn("non-HALT VM state, will try again later",
+				zap.String("method", fschaincontracts.AddContainerStructsMethod), zap.Stringer("state", txRes.VMState),
+				zap.String("exception", txRes.FaultException), zap.String("tx", txs))
+			continue
+		}
+
+		if len(txRes.Stack) == 0 {
+			return fmt.Errorf("empty stack in %s call result, tx %s", fschaincontracts.AddContainerStructsMethod, txs)
+		}
+
+		b, err := txRes.Stack[0].TryBool()
+		if err != nil {
+			return fmt.Errorf("convert stack item in %s call result to bool (tx %s); %w", fschaincontracts.AddContainerStructsMethod, txs, err)
+		}
+
+		if !b {
+			cp.log.Warn("all containers have been successfully structured in the contract, interrupt", zap.String("tx", txs))
+			return nil
+		}
+
+		cp.log.Info("more containers have been successfully structured in the contract, continue", zap.String("tx", txs))
+	}
+}

pkg/morph/client/notary.go

@@ -13,6 +13,7 @@ import (
 
 	"github.com/cenkalti/backoff/v4"
 	"github.com/nspcc-dev/neo-go/pkg/core/native/noderoles"
+	"github.com/nspcc-dev/neo-go/pkg/core/state"
 	"github.com/nspcc-dev/neo-go/pkg/core/transaction"
 	"github.com/nspcc-dev/neo-go/pkg/crypto/hash"
 	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
@@ -323,6 +324,13 @@ func (c *Client) NotaryInvoke(ctx context.Context, contract util.Uint160, await
 	return c.notaryInvoke(false, true, contract, await, nonce, vub, method, args...)
 }
 
+// CallNotary calls contract method requiring Alphabet witness using Notary
+// service and returns transaction result.
+func (c *Client) CallNotary(_ context.Context, contract util.Uint160, method string, args ...any) (*state.AppExecResult, error) {
+	_, res, err := c._notaryInvoke(false, true, contract, true, 0, nil, method, args...)
+	return res, err
+}
+
 // NotaryInvokeNotAlpha does the same as NotaryInvoke but does not use client's
 // private key in Invocation script. It means that main TX of notary request is
 // not expected to be signed by the current node.
@@ -484,15 +492,20 @@ func (c *Client) notaryInvokeAsCommittee(method string, nonce, vub uint32, args
 }
 
 func (c *Client) notaryInvoke(committee, invokedByAlpha bool, contract util.Uint160, await bool, nonce uint32, vub *uint32, method string, args ...any) (util.Uint256, error) {
+	txHash, _, err := c._notaryInvoke(committee, invokedByAlpha, contract, await, nonce, vub, method, args)
+	return txHash, err
+}
+
+func (c *Client) _notaryInvoke(committee, invokedByAlpha bool, contract util.Uint160, await bool, nonce uint32, vub *uint32, method string, args ...any) (util.Uint256, *state.AppExecResult, error) {
 	var conn = c.conn.Load()
 
 	if conn == nil {
-		return util.Uint256{}, ErrConnectionLost
+		return util.Uint256{}, nil, ErrConnectionLost
 	}
 
 	alphabetList, err := c.notary.alphabetSource() // prepare arguments for test invocation
 	if err != nil {
-		return util.Uint256{}, err
+		return util.Uint256{}, nil, err
 	}
 
 	var until uint32
@@ -502,18 +515,18 @@ func (c *Client) notaryInvoke(committee, invokedByAlpha bool, contract util.Uint
 	} else {
 		until, err = c.notaryTxValidationLimit(conn)
 		if err != nil {
-			return util.Uint256{}, err
+			return util.Uint256{}, nil, err
 		}
 	}
 
 	cosigners, err := c.notaryCosigners(invokedByAlpha, alphabetList, committee)
 	if err != nil {
-		return util.Uint256{}, err
+		return util.Uint256{}, nil, err
 	}
 
 	nAct, err := notary.NewActor(conn.client, cosigners, c.acc)
 	if err != nil {
-		return util.Uint256{}, err
+		return util.Uint256{}, nil, err
 	}
 
 	mainH, fbH, untilActual, err := nAct.Notarize(nAct.MakeTunedCall(contract, method, nil, func(r *result.Invoke, t *transaction.Transaction) error {
@@ -530,8 +543,10 @@ func (c *Client) notaryInvoke(committee, invokedByAlpha bool, contract util.Uint
 
 		return nil
 	}, args...))
+
+	var res *state.AppExecResult
 	if await {
-		_, err = nAct.WaitSuccess(mainH, fbH, untilActual, err)
+		res, err = nAct.WaitSuccess(mainH, fbH, untilActual, err)
 	}
 
 	if err != nil {
@@ -544,10 +559,10 @@ func (c *Client) notaryInvoke(committee, invokedByAlpha bool, contract util.Uint
 				zap.String("fallback_hash", fbH.StringLE()),
 			)
 
-			return util.Uint256{}, nil
+			return util.Uint256{}, res, nil
 		}
 
-		return util.Uint256{}, err
+		return util.Uint256{}, nil, err
 	}
 
 	c.logger.Debug("notary request invoked",
@@ -556,7 +571,7 @@ func (c *Client) notaryInvoke(committee, invokedByAlpha bool, contract util.Uint
 		zap.String("tx_hash", mainH.StringLE()),
 		zap.String("fallback_hash", fbH.StringLE()))
 
-	return mainH, nil
+	return mainH, res, nil
 }
 
 func (c *Client) runAlphabetNotaryScript(script []byte, nonce uint32) error {

pkg/morph/contracts/methods.go

@@ -14,6 +14,7 @@ const (
 	GetTakenSpaceByUserMethod     = "getTakenSpaceByUser"
 	GetContainerQuotaMethod       = "containerQuota"
 	GetUserQuotaMethod            = "userQuota"
+	AddContainerStructsMethod     = "addStructs"
 )
 
 // CreateContainerParams are parameters of [CreateContainerMethod].

pkg/morph/event/container/notary_requests.go

@@ -199,3 +199,23 @@ func RestorePutContainerEACLRequest(notaryReq event.NotaryEvent) (event.Event, e
 
 	return res, nil
 }
+
+// AddStructsRequest wraps container protobuf->struct migration request to
+// provide app-internal event.
+type AddStructsRequest struct {
+	event.Event
+	MainTransaction transaction.Transaction
+}
+
+// RestoreAddStructsRequest restores [AddStructsRequest] from the
+// notary one.
+func RestoreAddStructsRequest(notaryReq event.NotaryEvent) (event.Event, error) {
+	_, err := getArgsFromEvent(notaryReq, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	return AddStructsRequest{
+		MainTransaction: *notaryReq.Raw().MainTransaction,
+	}, nil
+}