netmap: Make NewEpoch callback mechanism more generic

Do not hardcode container and balance contract as a `NewEpoch` events
receivers in the netmap contract. Use the netmap's registration method on a
deploy stage instead. Closes #327.

Signed-off-by: Pavel Karpy <[email protected]>

balance/balance_contract.go

@@ -75,6 +75,8 @@ func _deploy(data any, isUpdate bool) {
 			switchToNotary(ctx)
 		}
 
+		common.RegisterNewEpochHook()
+
 		return
 	}
 

balance/config.yml

@@ -2,7 +2,7 @@ name: "NeoFS Balance"
 supportedstandards: ["NEP-17"]
 safemethods: ["balanceOf", "decimals", "symbol", "totalSupply", "version"]
 permissions:
-  - methods: ["update"]
+  - methods: ["update", "registerNewEpochRecipient"]
 events:
   - name: Lock
     parameters:

common/netmap.go

@@ -0,0 +1,39 @@
+package common
+
+import (
+	"github.com/nspcc-dev/neo-go/pkg/interop"
+	"github.com/nspcc-dev/neo-go/pkg/interop/contract"
+	"github.com/nspcc-dev/neo-go/pkg/interop/convert"
+	"github.com/nspcc-dev/neo-go/pkg/interop/lib/address"
+	"github.com/nspcc-dev/neo-go/pkg/interop/native/management"
+	"github.com/nspcc-dev/neo-go/pkg/interop/native/std"
+	"github.com/nspcc-dev/neo-go/pkg/interop/runtime"
+)
+
+// RegisterNewEpochHook registers calling contract as a NewEpoch
+// callback requester. Netmap contract's address is taken from the
+// NNS contract, therefore, it must be presented and filled with
+// netmap information for correct RegisterNewEpochHook call; otherwise
+// successive call is not guaranteed.
+// Caller must have `NewEpoch` method with a single numeric argument.
+func RegisterNewEpochHook() {
+	nnsContract := management.GetContractByID(1)
+	if nnsContract == nil {
+		panic("missing NNS contract")
+	}
+
+	resolveRes := contract.Call(nnsContract.Hash, "resolve", contract.ReadOnly, "netmap.neofs", 16)
+	records := resolveRes.([]string)
+	if len(records) == 0 {
+		panic("did not find a record of the Proxy contract in the NNS")
+	}
+
+	var netmapContract interop.Hash160
+	if len(records[0]) == 2*interop.Hash160Len {
+		netmapContract = convert.ToBytes(std.Atoi(records[0], 16))
+	} else {
+		netmapContract = address.ToHash160(records[0])
+	}
+
+	contract.Call(netmapContract, "registerNewEpochRecipient", contract.All, runtime.GetExecutingScriptHash())
+}

container/config.yml

@@ -2,7 +2,7 @@ name: "NeoFS Container"
 safemethods: ["alias", "count", "containersOf", "get", "owner", "list", "eACL", "getContainerSize", "listContainerSizes", "iterateContainerSizes", "iterateAllContainerSizes", "version"]
 permissions:
   - methods: ["update", "addKey", "transferX",
-              "register", "registerTLD", "addRecord", "deleteRecords"]
+              "register", "registerTLD", "addRecord", "deleteRecords", "registerNewEpochRecipient"]
 events:
   - name: PutSuccess
     parameters:

container/container_contract.go

@@ -138,6 +138,8 @@ func _deploy(data any, isUpdate bool) {
 			switchToNotary(ctx)
 		}
 
+		common.RegisterNewEpochHook()
+
 		return
 	}
 

netmap/config.yml

@@ -17,3 +17,7 @@ events:
     parameters:
       - name: epoch
         type: Integer
+  - name: NewEpochHookRegistration
+    parameters:
+      - name: registree
+        type: Hash160

netmap/netmap_contract.go

@@ -73,7 +73,8 @@ const (
 	containerContractKey = "containerScriptHash"
 	balanceContractKey   = "balanceScriptHash"
 
-	cleanupEpochMethod = "newEpoch"
+	newEpochRecipientsKey = "newEpochRecipients"
+	cleanupEpochMethod    = "newEpoch"
 
 	// nodeKeyOffset is an offset in a serialized node info representation (V2 format)
 	// marking the start of the node's public key.
@@ -601,6 +602,23 @@ func ListConfig() []record {
 	return config
 }
 
+// RegisterNewEpochRecipient registers passed contract as a NewEpoch event
+// receiver. Such a contract must have a `NewEpoch` method with a single numeric
+// argument. Transactions that call RegisterNewEpochRecipient must be witnessed
+// by the Alphabet.
+// Produces `NewEpochHookRegistration` notification event with a just registered
+// recipient in a success case.
+func RegisterNewEpochRecipient(contract interop.Hash160) {
+	common.CheckAlphabetWitness(common.AlphabetAddress())
+
+	ctx := storage.GetContext()
+	key := append([]byte(newEpochRecipientsKey), contract...)
+
+	storage.Put(ctx, key, 1)
+
+	runtime.Notify("NewEpochHookRegistration", contract)
+}
+
 // Version returns the version of the contract.
 func Version() int {
 	return common.Version
@@ -685,9 +703,9 @@ func setConfig(ctx storage.Context, key, val any) {
 }
 
 func cleanup(ctx storage.Context, epoch int) {
-	balanceContractAddr := storage.Get(ctx, balanceContractKey).(interop.Hash160)
-	contract.Call(balanceContractAddr, cleanupEpochMethod, contract.All, epoch)
-
-	containerContractAddr := storage.Get(ctx, containerContractKey).(interop.Hash160)
-	contract.Call(containerContractAddr, cleanupEpochMethod, contract.All, epoch)
+	it := storage.Find(ctx, newEpochRecipientsKey, storage.RemovePrefix|storage.KeysOnly)
+	for iterator.Next(it) {
+		contractHash := iterator.Value(it).(interop.Hash160)
+		contract.Call(contractHash, cleanupEpochMethod, contract.All, epoch)
+	}
 }