hack: allow sending from f4 addresses (#9533)

chain/actors/builtin/builtin.go

@@ -125,6 +125,15 @@ func IsBuiltinActor(c cid.Cid) bool {
 	return false
 }
 
+func IsEmbryo(c cid.Cid) bool {
+	name, _, ok := actors.GetActorMetaByCode(c)
+	if ok {
+		return name == "embryo"
+	}
+
+	return false
+}
+
 func IsAccountActor(c cid.Cid) bool {
 	name, _, ok := actors.GetActorMetaByCode(c)
 	if ok {

chain/consensus/filcns/filecoin.go

@@ -14,6 +14,7 @@ import (
 	cbor "github.com/ipfs/go-ipld-cbor"
 	logging "github.com/ipfs/go-log/v2"
 	pubsub "github.com/libp2p/go-libp2p-pubsub"
+	"github.com/multiformats/go-varint"
 	cbg "github.com/whyrusleeping/cbor-gen"
 	"go.opencensus.io/stats"
 	"go.opencensus.io/trace"
@@ -21,6 +22,7 @@ import (
 
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/go-state-types/abi"
+	builtintypes "github.com/filecoin-project/go-state-types/builtin"
 	"github.com/filecoin-project/go-state-types/crypto"
 	"github.com/filecoin-project/go-state-types/network"
 	blockadt "github.com/filecoin-project/specs-actors/actors/util/adt"
@@ -434,6 +436,19 @@ func (filec *FilecoinEC) VerifyWinningPoStProof(ctx context.Context, nv network.
 	return nil
 }
 
+func isValidForSending(act *types.Actor) bool {
+	if builtin.IsAccountActor(act.Code) {
+		return true
+	}
+
+	// HACK: Allow Eth embryos to send messages
+	if !builtin.IsEmbryo(act.Code) || act.Address == nil || act.Address.Protocol() != address.Delegated {
+		return false
+	}
+	id, _, err := varint.FromUvarint(act.Address.Payload())
+	return err == nil && id == builtintypes.EthereumAddressManagerActorID
+}
+
 // TODO: We should extract this somewhere else and make the message pool and miner use the same logic
 func (filec *FilecoinEC) checkBlockMessages(ctx context.Context, b *types.FullBlock, baseTs *types.TipSet) error {
 	{
@@ -506,7 +521,7 @@ func (filec *FilecoinEC) checkBlockMessages(ctx context.Context, b *types.FullBl
 				return xerrors.Errorf("failed to get actor: %w", err)
 			}
 
-			if !builtin.IsAccountActor(act.Code) {
+			if !isValidForSending(act) {
 				return xerrors.New("Sender must be an account actor")
 			}
 			nonces[sender] = act.Nonce

chain/messagepool/messagepool_test.go

@@ -162,7 +162,7 @@ func (tma *testMpoolAPI) GetActorAfter(addr address.Address, ts *types.TipSet) (
 }
 
 func (tma *testMpoolAPI) StateAccountKeyAtFinality(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error) {
-	if addr.Protocol() != address.BLS && addr.Protocol() != address.SECP256K1 {
+	if addr.Protocol() != address.BLS && addr.Protocol() != address.SECP256K1 && addr.Protocol() != address.Delegated {
 		return address.Undef, fmt.Errorf("given address was not a key addr")
 	}
 	return addr, nil

chain/stmgr/call.go

@@ -278,7 +278,14 @@ func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, pri
 				Data: make([]byte, 65),
 			},
 		}
-
+	case address.Delegated:
+		msgApply = &types.SignedMessage{
+			Message: *msg,
+			Signature: crypto.Signature{
+				Type: crypto.SigTypeDelegated,
+				Data: make([]byte, 65),
+			},
+		}
 	}
 
 	// If the fee cap is set to zero, make gas free.

chain/stmgr/stmgr.go

@@ -211,7 +211,7 @@ func (sm *StateManager) Beacon() beacon.Schedule {
 // Uses the `TipSet` `ts` to generate the VM state.
 func (sm *StateManager) ResolveToKeyAddress(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error) {
 	switch addr.Protocol() {
-	case address.BLS, address.SECP256K1:
+	case address.BLS, address.SECP256K1, address.Delegated:
 		return addr, nil
 	case address.Actor:
 		return address.Undef, xerrors.New("cannot resolve actor address to key address")
@@ -253,7 +253,7 @@ func (sm *StateManager) ResolveToKeyAddress(ctx context.Context, addr address.Ad
 // It should not be used for consensus-critical subsystems.
 func (sm *StateManager) ResolveToKeyAddressAtFinality(ctx context.Context, addr address.Address, ts *types.TipSet) (address.Address, error) {
 	switch addr.Protocol() {
-	case address.BLS, address.SECP256K1:
+	case address.BLS, address.SECP256K1, address.Delegated:
 		return addr, nil
 	case address.Actor:
 		return address.Undef, xerrors.New("cannot resolve actor address to key address")

chain/vm/vm.go

@@ -30,7 +30,6 @@ import (
 	"github.com/filecoin-project/lotus/chain/actors/adt"
 	"github.com/filecoin-project/lotus/chain/actors/aerrors"
 	"github.com/filecoin-project/lotus/chain/actors/builtin"
-	"github.com/filecoin-project/lotus/chain/actors/builtin/account"
 	"github.com/filecoin-project/lotus/chain/actors/builtin/reward"
 	"github.com/filecoin-project/lotus/chain/state"
 	"github.com/filecoin-project/lotus/chain/types"
@@ -47,7 +46,7 @@ var (
 
 // ResolveToKeyAddr returns the public key type of address (`BLS`/`SECP256K1`) of an account actor identified by `addr`.
 func ResolveToKeyAddr(state types.StateTree, cst cbor.IpldStore, addr address.Address) (address.Address, error) {
-	if addr.Protocol() == address.BLS || addr.Protocol() == address.SECP256K1 {
+	if addr.Protocol() == address.BLS || addr.Protocol() == address.SECP256K1 || addr.Protocol() == address.Delegated {
 		return addr, nil
 	}
 
@@ -55,13 +54,10 @@ func ResolveToKeyAddr(state types.StateTree, cst cbor.IpldStore, addr address.Ad
 	if err != nil {
 		return address.Undef, xerrors.Errorf("failed to find actor: %s", addr)
 	}
-
+	if act.Address == nil {
-	aast, err := account.Load(adt.WrapStore(context.TODO(), cst), act)
+		return address.Undef, xerrors.Errorf("actor doesn't have expected address: %s", addr)
-	if err != nil {
-		return address.Undef, xerrors.Errorf("failed to get account actor state for %s: %w", addr, err)
 	}
-
+	return *act.Address, nil
-	return aast.PubkeyAddress()
 }
 
 var (