Manual CC & Snapdeals onboarding (No NI-Porep)

.github/workflows/test.yml

@@ -96,6 +96,7 @@ jobs:
               "itest-get_messages_in_ts": ["self-hosted", "linux", "x64", "xlarge"],
               "itest-lite_migration": ["self-hosted", "linux", "x64", "xlarge"],
               "itest-lookup_robust_address": ["self-hosted", "linux", "x64", "xlarge"],
+              "itest-manual_onboarding": ["self-hosted", "linux", "x64", "xlarge"],
               "itest-mempool": ["self-hosted", "linux", "x64", "xlarge"],
               "itest-mpool_msg_uuid": ["self-hosted", "linux", "x64", "xlarge"],
               "itest-mpool_push_with_uuid": ["self-hosted", "linux", "x64", "xlarge"],
@@ -128,6 +129,7 @@ jobs:
               "itest-deals",
               "itest-direct_data_onboard_verified",
               "itest-direct_data_onboard",
+              "itest-manual_onboarding",
               "itest-net",
               "itest-path_detach_redeclare",
               "itest-path_type_filters",

itests/kit/ensemble.go

@@ -122,17 +122,19 @@ type Ensemble struct {
 	options      *ensembleOpts
 
 	inactive struct {
-		fullnodes     []*TestFullNode
-		providernodes []*TestCurioNode
-		miners        []*TestMiner
-		workers       []*TestWorker
+		fullnodes       []*TestFullNode
+		providernodes   []*TestCurioNode
+		miners          []*TestMiner
+		unmanagedMiners []*TestUnmanagedMiner
+		workers         []*TestWorker
 	}
 	active struct {
-		fullnodes     []*TestFullNode
-		providernodes []*TestCurioNode
-		miners        []*TestMiner
-		workers       []*TestWorker
-		bms           map[*TestMiner]*BlockMiner
+		fullnodes       []*TestFullNode
+		providernodes   []*TestCurioNode
+		miners          []*TestMiner
+		unmanagedMiners []*TestUnmanagedMiner
+		workers         []*TestWorker
+		bms             map[*TestMiner]*BlockMiner
 	}
 	genesis struct {
 		version  network.Version
@@ -259,9 +261,7 @@ func (n *Ensemble) MinerEnroll(minerNode *TestMiner, full *TestFullNode, opts ..
 	tdir, err := os.MkdirTemp("", "preseal-memgen")
 	require.NoError(n.t, err)
 
-	minerCnt := len(n.inactive.miners) + len(n.active.miners)
-
-	actorAddr, err := address.NewIDAddress(genesis2.MinerStart + uint64(minerCnt))
+	actorAddr, err := address.NewIDAddress(genesis2.MinerStart + n.minerCount())
 	require.NoError(n.t, err)
 
 	if options.mainMiner != nil {
@@ -333,12 +333,25 @@ func (n *Ensemble) AddInactiveMiner(m *TestMiner) {
 	n.inactive.miners = append(n.inactive.miners, m)
 }
 
+func (n *Ensemble) AddInactiveUnmanagedMiner(m *TestUnmanagedMiner) {
+	n.inactive.unmanagedMiners = append(n.inactive.unmanagedMiners, m)
+}
+
 func (n *Ensemble) Miner(minerNode *TestMiner, full *TestFullNode, opts ...NodeOpt) *Ensemble {
 	n.MinerEnroll(minerNode, full, opts...)
 	n.AddInactiveMiner(minerNode)
 	return n
 }
 
+func (n *Ensemble) UnmanagedMiner(full *TestFullNode, opts ...NodeOpt) (*TestUnmanagedMiner, *Ensemble) {
+	actorAddr, err := address.NewIDAddress(genesis2.MinerStart + n.minerCount())
+	require.NoError(n.t, err)
+
+	minerNode := NewTestUnmanagedMiner(n.t, full, actorAddr, opts...)
+	n.AddInactiveUnmanagedMiner(minerNode)
+	return minerNode, n
+}
+
 // Worker enrolls a new worker, using the provided full node for chain
 // interactions.
 func (n *Ensemble) Worker(minerNode *TestMiner, worker *TestWorker, opts ...NodeOpt) *Ensemble {
@@ -826,6 +839,79 @@ func (n *Ensemble) Start() *Ensemble {
 	// to active, so clear the slice.
 	n.inactive.miners = n.inactive.miners[:0]
 
+	// Create all inactive manual miners.
+	for _, m := range n.inactive.unmanagedMiners {
+		proofType, err := miner.WindowPoStProofTypeFromSectorSize(m.options.sectorSize, n.genesis.version)
+		require.NoError(n.t, err)
+
+		params, aerr := actors.SerializeParams(&power3.CreateMinerParams{
+			Owner:               m.OwnerKey.Address,
+			Worker:              m.OwnerKey.Address,
+			WindowPoStProofType: proofType,
+			Peer:                abi.PeerID(m.Libp2p.PeerID),
+		})
+		require.NoError(n.t, aerr)
+
+		createStorageMinerMsg := &types.Message{
+			From:  m.OwnerKey.Address,
+			To:    power.Address,
+			Value: big.Zero(),
+
+			Method: power.Methods.CreateMiner,
+			Params: params,
+		}
+		signed, err := m.FullNode.FullNode.MpoolPushMessage(ctx, createStorageMinerMsg, &api.MessageSendSpec{
+			MsgUuid: uuid.New(),
+		})
+		require.NoError(n.t, err)
+
+		mw, err := m.FullNode.FullNode.StateWaitMsg(ctx, signed.Cid(), build.MessageConfidence, api.LookbackNoLimit, true)
+		require.NoError(n.t, err)
+		require.Equal(n.t, exitcode.Ok, mw.Receipt.ExitCode)
+
+		var retval power3.CreateMinerReturn
+		err = retval.UnmarshalCBOR(bytes.NewReader(mw.Receipt.Return))
+		require.NoError(n.t, err, "failed to create miner")
+
+		m.ActorAddr = retval.IDAddress
+
+		has, err := m.FullNode.WalletHas(ctx, m.OwnerKey.Address)
+		require.NoError(n.t, err)
+
+		// Only import the owner's full key into our companion full node, if we
+		// don't have it still.
+		if !has {
+			_, err = m.FullNode.WalletImport(ctx, &m.OwnerKey.KeyInfo)
+			require.NoError(n.t, err)
+		}
+
+		enc, err := actors.SerializeParams(&miner2.ChangePeerIDParams{NewID: abi.PeerID(m.Libp2p.PeerID)})
+		require.NoError(n.t, err)
+
+		msg := &types.Message{
+			From:   m.OwnerKey.Address,
+			To:     m.ActorAddr,
+			Method: builtin.MethodsMiner.ChangePeerID,
+			Params: enc,
+			Value:  types.NewInt(0),
+		}
+
+		_, err2 := m.FullNode.MpoolPushMessage(ctx, msg, &api.MessageSendSpec{
+			MsgUuid: uuid.New(),
+		})
+		require.NoError(n.t, err2)
+
+		minerCopy := *m.FullNode
+		minerCopy.FullNode = modules.MakeUuidWrapper(minerCopy.FullNode)
+		m.FullNode = &minerCopy
+
+		n.active.unmanagedMiners = append(n.active.unmanagedMiners, m)
+	}
+
+	// If we are here, we have processed all inactive manual miners and moved them
+	// to active, so clear the slice.
+	n.inactive.unmanagedMiners = n.inactive.unmanagedMiners[:0]
+
 	// ---------------------
 	//  WORKERS
 	// ---------------------
@@ -1055,6 +1141,10 @@ func (n *Ensemble) BeginMining(blocktime time.Duration, miners ...*TestMiner) []
 	return bms
 }
 
+func (n *Ensemble) minerCount() uint64 {
+	return uint64(len(n.inactive.miners) + len(n.active.miners) + len(n.inactive.unmanagedMiners) + len(n.active.unmanagedMiners))
+}
+
 func (n *Ensemble) generateGenesis() *genesis.Template {
 	var verifRoot = gen.DefaultVerifregRootkeyActor
 	if k := n.options.verifiedRoot.key; k != nil {