diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 2794d7526e7..e79e3502d7d 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -186,7 +186,7 @@ jobs: echo -e "path< uint64(math.MaxInt64) { + return nil, xerrors.Errorf("transaction ID %d is out of range for int64", id) + } + params := multisig0.TxnIDParams{ID: multisig0.TxnID(id)} + if data != nil { + if data.Requester.Protocol() != address.ID { + return nil, xerrors.Errorf("proposer address must be an ID address, was %s", data.Requester) + } + if data.Value.Sign() == -1 { + return nil, xerrors.Errorf("proposal value must be non-negative, was %s", data.Value) + } + if data.To == address.Undef { + return nil, xerrors.Errorf("proposed destination address must be set") + } + pser, err := data.Serialize() + if err != nil { + return nil, err + } + hash := blake2b.Sum256(pser) + params.ProposalHash = hash[:] + } + + return actors.SerializeParams(¶ms) +} {{end}} diff --git a/chain/actors/builtin/multisig/message0.go b/chain/actors/builtin/multisig/message0.go index 7dbdf444ce2..ae383b56571 100644 --- a/chain/actors/builtin/multisig/message0.go +++ b/chain/actors/builtin/multisig/message0.go @@ -1,6 +1,9 @@ package multisig import ( + "math" + + "golang.org/x/crypto/blake2b" "golang.org/x/xerrors" "github.com/filecoin-project/go-address" @@ -140,3 +143,29 @@ func (m message0) Cancel(msig address.Address, txID uint64, hashData *ProposalHa Params: enc, }, nil } + +func txnParams(id uint64, data *ProposalHashData) ([]byte, error) { + if id > uint64(math.MaxInt64) { + return nil, xerrors.Errorf("transaction ID %d is out of range for int64", id) + } + params := multisig0.TxnIDParams{ID: multisig0.TxnID(id)} + if data != nil { + if data.Requester.Protocol() != address.ID { + return nil, xerrors.Errorf("proposer address must be an ID address, was %s", data.Requester) + } + if data.Value.Sign() == -1 { + return nil, xerrors.Errorf("proposal value must be non-negative, was %s", data.Value) + } + if data.To == address.Undef { + return nil, xerrors.Errorf("proposed destination address must be set") + } + pser, err := data.Serialize() + if err != nil { + return nil, err + } + hash := blake2b.Sum256(pser) + params.ProposalHash = hash[:] + } + + return actors.SerializeParams(¶ms) +} diff --git a/chain/actors/builtin/multisig/message10.go b/chain/actors/builtin/multisig/message10.go index 4ea8c705d69..20884441d0f 100644 --- a/chain/actors/builtin/multisig/message10.go +++ b/chain/actors/builtin/multisig/message10.go @@ -8,7 +8,7 @@ import ( actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" multisig10 "github.com/filecoin-project/go-state-types/builtin/v10/multisig" - init14 "github.com/filecoin-project/go-state-types/builtin/v14/init" + init15 "github.com/filecoin-project/go-state-types/builtin/v15/init" "github.com/filecoin-project/go-state-types/manifest" "github.com/filecoin-project/lotus/chain/actors" @@ -57,7 +57,7 @@ func (m message10) Create( } // new actors are created by invoking 'exec' on the init actor with the constructor params - execParams := &init14.ExecParams{ + execParams := &init15.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/message11.go b/chain/actors/builtin/multisig/message11.go index 2a8309a1aeb..abd35889281 100644 --- a/chain/actors/builtin/multisig/message11.go +++ b/chain/actors/builtin/multisig/message11.go @@ -8,7 +8,7 @@ import ( actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" multisig11 "github.com/filecoin-project/go-state-types/builtin/v11/multisig" - init14 "github.com/filecoin-project/go-state-types/builtin/v14/init" + init15 "github.com/filecoin-project/go-state-types/builtin/v15/init" "github.com/filecoin-project/go-state-types/manifest" "github.com/filecoin-project/lotus/chain/actors" @@ -57,7 +57,7 @@ func (m message11) Create( } // new actors are created by invoking 'exec' on the init actor with the constructor params - execParams := &init14.ExecParams{ + execParams := &init15.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/message12.go b/chain/actors/builtin/multisig/message12.go index 8599a1f83a7..731cc2fbd02 100644 --- a/chain/actors/builtin/multisig/message12.go +++ b/chain/actors/builtin/multisig/message12.go @@ -8,7 +8,7 @@ import ( actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" multisig12 "github.com/filecoin-project/go-state-types/builtin/v12/multisig" - init14 "github.com/filecoin-project/go-state-types/builtin/v14/init" + init15 "github.com/filecoin-project/go-state-types/builtin/v15/init" "github.com/filecoin-project/go-state-types/manifest" "github.com/filecoin-project/lotus/chain/actors" @@ -57,7 +57,7 @@ func (m message12) Create( } // new actors are created by invoking 'exec' on the init actor with the constructor params - execParams := &init14.ExecParams{ + execParams := &init15.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/message13.go b/chain/actors/builtin/multisig/message13.go index 0484ba0eb4b..932225be5c5 100644 --- a/chain/actors/builtin/multisig/message13.go +++ b/chain/actors/builtin/multisig/message13.go @@ -8,7 +8,7 @@ import ( actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" multisig13 "github.com/filecoin-project/go-state-types/builtin/v13/multisig" - init14 "github.com/filecoin-project/go-state-types/builtin/v14/init" + init15 "github.com/filecoin-project/go-state-types/builtin/v15/init" "github.com/filecoin-project/go-state-types/manifest" "github.com/filecoin-project/lotus/chain/actors" @@ -57,7 +57,7 @@ func (m message13) Create( } // new actors are created by invoking 'exec' on the init actor with the constructor params - execParams := &init14.ExecParams{ + execParams := &init15.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/message14.go b/chain/actors/builtin/multisig/message14.go index fc56c6060a0..0ba5e04326d 100644 --- a/chain/actors/builtin/multisig/message14.go +++ b/chain/actors/builtin/multisig/message14.go @@ -7,8 +7,8 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" - init14 "github.com/filecoin-project/go-state-types/builtin/v14/init" multisig14 "github.com/filecoin-project/go-state-types/builtin/v14/multisig" + init15 "github.com/filecoin-project/go-state-types/builtin/v15/init" "github.com/filecoin-project/go-state-types/manifest" "github.com/filecoin-project/lotus/chain/actors" @@ -57,7 +57,7 @@ func (m message14) Create( } // new actors are created by invoking 'exec' on the init actor with the constructor params - execParams := &init14.ExecParams{ + execParams := &init15.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/message15.go b/chain/actors/builtin/multisig/message15.go new file mode 100644 index 00000000000..3c4a4c29310 --- /dev/null +++ b/chain/actors/builtin/multisig/message15.go @@ -0,0 +1,77 @@ +package multisig + +import ( + "golang.org/x/xerrors" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + builtintypes "github.com/filecoin-project/go-state-types/builtin" + init15 "github.com/filecoin-project/go-state-types/builtin/v15/init" + multisig15 "github.com/filecoin-project/go-state-types/builtin/v15/multisig" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init" + "github.com/filecoin-project/lotus/chain/types" +) + +type message15 struct{ message0 } + +func (m message15) Create( + signers []address.Address, threshold uint64, + unlockStart, unlockDuration abi.ChainEpoch, + initialAmount abi.TokenAmount, +) (*types.Message, error) { + + lenAddrs := uint64(len(signers)) + + if lenAddrs < threshold { + return nil, xerrors.Errorf("cannot require signing of more addresses than provided for multisig") + } + + if threshold == 0 { + threshold = lenAddrs + } + + if m.from == address.Undef { + return nil, xerrors.Errorf("must provide source address") + } + + // Set up constructor parameters for multisig + msigParams := &multisig15.ConstructorParams{ + Signers: signers, + NumApprovalsThreshold: threshold, + UnlockDuration: unlockDuration, + StartEpoch: unlockStart, + } + + enc, actErr := actors.SerializeParams(msigParams) + if actErr != nil { + return nil, actErr + } + + code, ok := actors.GetActorCodeID(actorstypes.Version15, manifest.MultisigKey) + if !ok { + return nil, xerrors.Errorf("failed to get multisig code ID") + } + + // new actors are created by invoking 'exec' on the init actor with the constructor params + execParams := &init15.ExecParams{ + CodeCID: code, + ConstructorParams: enc, + } + + enc, actErr = actors.SerializeParams(execParams) + if actErr != nil { + return nil, actErr + } + + return &types.Message{ + To: init_.Address, + From: m.from, + Method: builtintypes.MethodsInit.Exec, + Params: enc, + Value: initialAmount, + }, nil +} diff --git a/chain/actors/builtin/multisig/message8.go b/chain/actors/builtin/multisig/message8.go index 49cd24c3db7..d2c7e5531ec 100644 --- a/chain/actors/builtin/multisig/message8.go +++ b/chain/actors/builtin/multisig/message8.go @@ -7,7 +7,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" - init14 "github.com/filecoin-project/go-state-types/builtin/v14/init" + init15 "github.com/filecoin-project/go-state-types/builtin/v15/init" multisig8 "github.com/filecoin-project/go-state-types/builtin/v8/multisig" "github.com/filecoin-project/go-state-types/manifest" @@ -57,7 +57,7 @@ func (m message8) Create( } // new actors are created by invoking 'exec' on the init actor with the constructor params - execParams := &init14.ExecParams{ + execParams := &init15.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/message9.go b/chain/actors/builtin/multisig/message9.go index 66d6990e4e5..0dcad5b45ef 100644 --- a/chain/actors/builtin/multisig/message9.go +++ b/chain/actors/builtin/multisig/message9.go @@ -7,7 +7,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" - init14 "github.com/filecoin-project/go-state-types/builtin/v14/init" + init15 "github.com/filecoin-project/go-state-types/builtin/v15/init" multisig9 "github.com/filecoin-project/go-state-types/builtin/v9/multisig" "github.com/filecoin-project/go-state-types/manifest" @@ -57,7 +57,7 @@ func (m message9) Create( } // new actors are created by invoking 'exec' on the init actor with the constructor params - execParams := &init14.ExecParams{ + execParams := &init15.ExecParams{ CodeCID: code, ConstructorParams: enc, } diff --git a/chain/actors/builtin/multisig/multisig.go b/chain/actors/builtin/multisig/multisig.go index 54fdcea2654..ddd4be932f5 100644 --- a/chain/actors/builtin/multisig/multisig.go +++ b/chain/actors/builtin/multisig/multisig.go @@ -5,14 +5,13 @@ import ( "github.com/ipfs/go-cid" cbg "github.com/whyrusleeping/cbor-gen" - "golang.org/x/crypto/blake2b" "golang.org/x/xerrors" "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" builtintypes "github.com/filecoin-project/go-state-types/builtin" - msig14 "github.com/filecoin-project/go-state-types/builtin/v14/multisig" + msig15 "github.com/filecoin-project/go-state-types/builtin/v15/multisig" "github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/manifest" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin" @@ -57,6 +56,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version14: return load14(store, act.Head) + case actorstypes.Version15: + return load15(store, act.Head) + } } @@ -133,6 +135,9 @@ func MakeState(store adt.Store, av actorstypes.Version, signers []address.Addres case actorstypes.Version14: return make14(store, signers, threshold, startEpoch, unlockDuration, initialBalance) + case actorstypes.Version15: + return make15(store, signers, threshold, startEpoch, unlockDuration, initialBalance) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -159,7 +164,7 @@ type State interface { GetState() interface{} } -type Transaction = msig14.Transaction +type Transaction = msig15.Transaction var Methods = builtintypes.MethodsMultisig @@ -207,6 +212,9 @@ func Message(version actorstypes.Version, from address.Address) MessageBuilder { case actorstypes.Version14: return message14{message0{from}} + + case actorstypes.Version15: + return message15{message0{from}} default: panic(fmt.Sprintf("unsupported actors version: %d", version)) } @@ -230,33 +238,10 @@ type MessageBuilder interface { } // this type is the same between v0 and v2 -type ProposalHashData = msig14.ProposalHashData -type ProposeReturn = msig14.ProposeReturn -type ProposeParams = msig14.ProposeParams -type ApproveReturn = msig14.ApproveReturn - -func txnParams(id uint64, data *ProposalHashData) ([]byte, error) { - params := msig14.TxnIDParams{ID: msig14.TxnID(id)} - if data != nil { - if data.Requester.Protocol() != address.ID { - return nil, xerrors.Errorf("proposer address must be an ID address, was %s", data.Requester) - } - if data.Value.Sign() == -1 { - return nil, xerrors.Errorf("proposal value must be non-negative, was %s", data.Value) - } - if data.To == address.Undef { - return nil, xerrors.Errorf("proposed destination address must be set") - } - pser, err := data.Serialize() - if err != nil { - return nil, err - } - hash := blake2b.Sum256(pser) - params.ProposalHash = hash[:] - } - - return actors.SerializeParams(¶ms) -} +type ProposalHashData = msig15.ProposalHashData +type ProposeReturn = msig15.ProposeReturn +type ProposeParams = msig15.ProposeParams +type ApproveReturn = msig15.ApproveReturn func AllCodes() []cid.Cid { return []cid.Cid{ @@ -274,5 +259,6 @@ func AllCodes() []cid.Cid { (&state12{}).Code(), (&state13{}).Code(), (&state14{}).Code(), + (&state15{}).Code(), } } diff --git a/chain/actors/builtin/multisig/v15.go b/chain/actors/builtin/multisig/v15.go new file mode 100644 index 00000000000..63489b3d863 --- /dev/null +++ b/chain/actors/builtin/multisig/v15.go @@ -0,0 +1,138 @@ +package multisig + +import ( + "bytes" + "encoding/binary" + "fmt" + + "github.com/ipfs/go-cid" + cbg "github.com/whyrusleeping/cbor-gen" + "golang.org/x/xerrors" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + builtin15 "github.com/filecoin-project/go-state-types/builtin" + msig15 "github.com/filecoin-project/go-state-types/builtin/v15/multisig" + adt15 "github.com/filecoin-project/go-state-types/builtin/v15/util/adt" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" +) + +var _ State = (*state15)(nil) + +func load15(store adt.Store, root cid.Cid) (State, error) { + out := state15{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make15(store adt.Store, signers []address.Address, threshold uint64, startEpoch abi.ChainEpoch, unlockDuration abi.ChainEpoch, initialBalance abi.TokenAmount) (State, error) { + out := state15{store: store} + out.State = msig15.State{} + out.State.Signers = signers + out.State.NumApprovalsThreshold = threshold + out.State.StartEpoch = startEpoch + out.State.UnlockDuration = unlockDuration + out.State.InitialBalance = initialBalance + + em, err := adt15.StoreEmptyMap(store, builtin15.DefaultHamtBitwidth) + if err != nil { + return nil, err + } + + out.State.PendingTxns = em + + return &out, nil +} + +type state15 struct { + msig15.State + store adt.Store +} + +func (s *state15) LockedBalance(currEpoch abi.ChainEpoch) (abi.TokenAmount, error) { + return s.State.AmountLocked(currEpoch - s.State.StartEpoch), nil +} + +func (s *state15) StartEpoch() (abi.ChainEpoch, error) { + return s.State.StartEpoch, nil +} + +func (s *state15) UnlockDuration() (abi.ChainEpoch, error) { + return s.State.UnlockDuration, nil +} + +func (s *state15) InitialBalance() (abi.TokenAmount, error) { + return s.State.InitialBalance, nil +} + +func (s *state15) Threshold() (uint64, error) { + return s.State.NumApprovalsThreshold, nil +} + +func (s *state15) Signers() ([]address.Address, error) { + return s.State.Signers, nil +} + +func (s *state15) ForEachPendingTxn(cb func(id int64, txn Transaction) error) error { + arr, err := adt15.AsMap(s.store, s.State.PendingTxns, builtin15.DefaultHamtBitwidth) + if err != nil { + return err + } + var out msig15.Transaction + return arr.ForEach(&out, func(key string) error { + txid, n := binary.Varint([]byte(key)) + if n <= 0 { + return xerrors.Errorf("invalid pending transaction key: %v", key) + } + return cb(txid, (Transaction)(out)) //nolint:unconvert + }) +} + +func (s *state15) PendingTxnChanged(other State) (bool, error) { + other15, ok := other.(*state15) + if !ok { + // treat an upgrade as a change, always + return true, nil + } + return !s.State.PendingTxns.Equals(other15.PendingTxns), nil +} + +func (s *state15) transactions() (adt.Map, error) { + return adt15.AsMap(s.store, s.PendingTxns, builtin15.DefaultHamtBitwidth) +} + +func (s *state15) decodeTransaction(val *cbg.Deferred) (Transaction, error) { + var tx msig15.Transaction + if err := tx.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil { + return Transaction{}, err + } + return Transaction(tx), nil +} + +func (s *state15) GetState() interface{} { + return &s.State +} + +func (s *state15) ActorKey() string { + return manifest.MultisigKey +} + +func (s *state15) ActorVersion() actorstypes.Version { + return actorstypes.Version15 +} + +func (s *state15) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/paych/message15.go b/chain/actors/builtin/paych/message15.go new file mode 100644 index 00000000000..71e8ce21894 --- /dev/null +++ b/chain/actors/builtin/paych/message15.go @@ -0,0 +1,109 @@ +package paych + +import ( + "golang.org/x/xerrors" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + builtin15 "github.com/filecoin-project/go-state-types/builtin" + init15 "github.com/filecoin-project/go-state-types/builtin/v15/init" + paych15 "github.com/filecoin-project/go-state-types/builtin/v15/paych" + paychtypes "github.com/filecoin-project/go-state-types/builtin/v8/paych" + + "github.com/filecoin-project/lotus/chain/actors" + init_ "github.com/filecoin-project/lotus/chain/actors/builtin/init" + "github.com/filecoin-project/lotus/chain/types" +) + +type message15 struct{ from address.Address } + +func (m message15) Create(to address.Address, initialAmount abi.TokenAmount) (*types.Message, error) { + + actorCodeID, ok := actors.GetActorCodeID(actorstypes.Version15, "paymentchannel") + if !ok { + return nil, xerrors.Errorf("error getting actor paymentchannel code id for actor version %d", 15) + } + + params, aerr := actors.SerializeParams(&paych15.ConstructorParams{From: m.from, To: to}) + if aerr != nil { + return nil, aerr + } + enc, aerr := actors.SerializeParams(&init15.ExecParams{ + CodeCID: actorCodeID, + ConstructorParams: params, + }) + if aerr != nil { + return nil, aerr + } + + return &types.Message{ + To: init_.Address, + From: m.from, + Value: initialAmount, + Method: builtin15.MethodsInit.Exec, + Params: enc, + }, nil +} + +func (m message15) Update(paych address.Address, sv *paychtypes.SignedVoucher, secret []byte) (*types.Message, error) { + params, aerr := actors.SerializeParams(&paych15.UpdateChannelStateParams{ + + Sv: toV15SignedVoucher(*sv), + + Secret: secret, + }) + if aerr != nil { + return nil, aerr + } + + return &types.Message{ + To: paych, + From: m.from, + Value: abi.NewTokenAmount(0), + Method: builtin15.MethodsPaych.UpdateChannelState, + Params: params, + }, nil +} + +func toV15SignedVoucher(sv paychtypes.SignedVoucher) paych15.SignedVoucher { + merges := make([]paych15.Merge, len(sv.Merges)) + for i := range sv.Merges { + merges[i] = paych15.Merge{ + Lane: sv.Merges[i].Lane, + Nonce: sv.Merges[i].Nonce, + } + } + + return paych15.SignedVoucher{ + ChannelAddr: sv.ChannelAddr, + TimeLockMin: sv.TimeLockMin, + TimeLockMax: sv.TimeLockMax, + SecretHash: sv.SecretHash, + Extra: (*paych15.ModVerifyParams)(sv.Extra), + Lane: sv.Lane, + Nonce: sv.Nonce, + Amount: sv.Amount, + MinSettleHeight: sv.MinSettleHeight, + Merges: merges, + Signature: sv.Signature, + } +} + +func (m message15) Settle(paych address.Address) (*types.Message, error) { + return &types.Message{ + To: paych, + From: m.from, + Value: abi.NewTokenAmount(0), + Method: builtin15.MethodsPaych.Settle, + }, nil +} + +func (m message15) Collect(paych address.Address) (*types.Message, error) { + return &types.Message{ + To: paych, + From: m.from, + Value: abi.NewTokenAmount(0), + Method: builtin15.MethodsPaych.Collect, + }, nil +} diff --git a/chain/actors/builtin/paych/paych.go b/chain/actors/builtin/paych/paych.go index 1f79c6d08ad..110edfd285b 100644 --- a/chain/actors/builtin/paych/paych.go +++ b/chain/actors/builtin/paych/paych.go @@ -59,6 +59,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version14: return load14(store, act.Head) + case actorstypes.Version15: + return load15(store, act.Head) + } } @@ -185,6 +188,9 @@ func Message(version actorstypes.Version, from address.Address) MessageBuilder { case actorstypes.Version14: return message14{from} + case actorstypes.Version15: + return message15{from} + default: panic(fmt.Sprintf("unsupported actors version: %d", version)) } @@ -229,5 +235,6 @@ func AllCodes() []cid.Cid { (&state12{}).Code(), (&state13{}).Code(), (&state14{}).Code(), + (&state15{}).Code(), } } diff --git a/chain/actors/builtin/paych/v15.go b/chain/actors/builtin/paych/v15.go new file mode 100644 index 00000000000..939113c46cb --- /dev/null +++ b/chain/actors/builtin/paych/v15.go @@ -0,0 +1,135 @@ +package paych + +import ( + "fmt" + + "github.com/ipfs/go-cid" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + "github.com/filecoin-project/go-state-types/big" + paych15 "github.com/filecoin-project/go-state-types/builtin/v15/paych" + adt15 "github.com/filecoin-project/go-state-types/builtin/v15/util/adt" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" +) + +var _ State = (*state15)(nil) + +func load15(store adt.Store, root cid.Cid) (State, error) { + out := state15{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make15(store adt.Store) (State, error) { + out := state15{store: store} + out.State = paych15.State{} + return &out, nil +} + +type state15 struct { + paych15.State + store adt.Store + lsAmt *adt15.Array +} + +// Channel owner, who has funded the actor +func (s *state15) From() (address.Address, error) { + return s.State.From, nil +} + +// Recipient of payouts from channel +func (s *state15) To() (address.Address, error) { + return s.State.To, nil +} + +// Height at which the channel can be `Collected` +func (s *state15) SettlingAt() (abi.ChainEpoch, error) { + return s.State.SettlingAt, nil +} + +// Amount successfully redeemed through the payment channel, paid out on `Collect()` +func (s *state15) ToSend() (abi.TokenAmount, error) { + return s.State.ToSend, nil +} + +func (s *state15) getOrLoadLsAmt() (*adt15.Array, error) { + if s.lsAmt != nil { + return s.lsAmt, nil + } + + // Get the lane state from the chain + lsamt, err := adt15.AsArray(s.store, s.State.LaneStates, paych15.LaneStatesAmtBitwidth) + if err != nil { + return nil, err + } + + s.lsAmt = lsamt + return lsamt, nil +} + +// Get total number of lanes +func (s *state15) LaneCount() (uint64, error) { + lsamt, err := s.getOrLoadLsAmt() + if err != nil { + return 0, err + } + return lsamt.Length(), nil +} + +func (s *state15) GetState() interface{} { + return &s.State +} + +// Iterate lane states +func (s *state15) ForEachLaneState(cb func(idx uint64, dl LaneState) error) error { + // Get the lane state from the chain + lsamt, err := s.getOrLoadLsAmt() + if err != nil { + return err + } + + // Note: we use a map instead of an array to store laneStates because the + // client sets the lane ID (the index) and potentially they could use a + // very large index. + var ls paych15.LaneState + return lsamt.ForEach(&ls, func(i int64) error { + return cb(uint64(i), &laneState15{ls}) + }) +} + +type laneState15 struct { + paych15.LaneState +} + +func (ls *laneState15) Redeemed() (big.Int, error) { + return ls.LaneState.Redeemed, nil +} + +func (ls *laneState15) Nonce() (uint64, error) { + return ls.LaneState.Nonce, nil +} + +func (s *state15) ActorKey() string { + return manifest.PaychKey +} + +func (s *state15) ActorVersion() actorstypes.Version { + return actorstypes.Version15 +} + +func (s *state15) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/power/power.go b/chain/actors/builtin/power/power.go index b08f6589909..64e9a8989c1 100644 --- a/chain/actors/builtin/power/power.go +++ b/chain/actors/builtin/power/power.go @@ -9,7 +9,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" "github.com/filecoin-project/go-state-types/big" - builtin14 "github.com/filecoin-project/go-state-types/builtin" + builtin15 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/manifest" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin" @@ -27,8 +27,8 @@ import ( ) var ( - Address = builtin14.StoragePowerActorAddr - Methods = builtin14.MethodsPower + Address = builtin15.StoragePowerActorAddr + Methods = builtin15.MethodsPower ) func Load(store adt.Store, act *types.Actor) (State, error) { @@ -60,6 +60,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version14: return load14(store, act.Head) + case actorstypes.Version15: + return load15(store, act.Head) + } } @@ -136,6 +139,9 @@ func MakeState(store adt.Store, av actorstypes.Version) (State, error) { case actorstypes.Version14: return make14(store) + case actorstypes.Version15: + return make15(store) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -204,5 +210,6 @@ func AllCodes() []cid.Cid { (&state12{}).Code(), (&state13{}).Code(), (&state14{}).Code(), + (&state15{}).Code(), } } diff --git a/chain/actors/builtin/power/v15.go b/chain/actors/builtin/power/v15.go new file mode 100644 index 00000000000..a31f4ad3985 --- /dev/null +++ b/chain/actors/builtin/power/v15.go @@ -0,0 +1,207 @@ +package power + +import ( + "bytes" + "fmt" + + "github.com/ipfs/go-cid" + cbg "github.com/whyrusleeping/cbor-gen" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + builtin15 "github.com/filecoin-project/go-state-types/builtin" + power15 "github.com/filecoin-project/go-state-types/builtin/v15/power" + adt15 "github.com/filecoin-project/go-state-types/builtin/v15/util/adt" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" + "github.com/filecoin-project/lotus/chain/actors/builtin" +) + +var _ State = (*state15)(nil) + +func load15(store adt.Store, root cid.Cid) (State, error) { + out := state15{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make15(store adt.Store) (State, error) { + out := state15{store: store} + + s, err := power15.ConstructState(store) + if err != nil { + return nil, err + } + + out.State = *s + + return &out, nil +} + +type state15 struct { + power15.State + store adt.Store +} + +func (s *state15) TotalLocked() (abi.TokenAmount, error) { + return s.TotalPledgeCollateral, nil +} + +func (s *state15) TotalPower() (Claim, error) { + return Claim{ + RawBytePower: s.TotalRawBytePower, + QualityAdjPower: s.TotalQualityAdjPower, + }, nil +} + +// Committed power to the network. Includes miners below the minimum threshold. +func (s *state15) TotalCommitted() (Claim, error) { + return Claim{ + RawBytePower: s.TotalBytesCommitted, + QualityAdjPower: s.TotalQABytesCommitted, + }, nil +} + +func (s *state15) MinerPower(addr address.Address) (Claim, bool, error) { + claims, err := s.claims() + if err != nil { + return Claim{}, false, err + } + var claim power15.Claim + ok, err := claims.Get(abi.AddrKey(addr), &claim) + if err != nil { + return Claim{}, false, err + } + return Claim{ + RawBytePower: claim.RawBytePower, + QualityAdjPower: claim.QualityAdjPower, + }, ok, nil +} + +func (s *state15) MinerNominalPowerMeetsConsensusMinimum(a address.Address) (bool, error) { + return s.State.MinerNominalPowerMeetsConsensusMinimum(s.store, a) +} + +func (s *state15) TotalPowerSmoothed() (builtin.FilterEstimate, error) { + return builtin.FilterEstimate(s.State.ThisEpochQAPowerSmoothed), nil +} + +func (s *state15) MinerCounts() (uint64, uint64, error) { + return uint64(s.State.MinerAboveMinPowerCount), uint64(s.State.MinerCount), nil +} + +func (s *state15) ListAllMiners() ([]address.Address, error) { + claims, err := s.claims() + if err != nil { + return nil, err + } + + var miners []address.Address + err = claims.ForEach(nil, func(k string) error { + a, err := address.NewFromBytes([]byte(k)) + if err != nil { + return err + } + miners = append(miners, a) + return nil + }) + if err != nil { + return nil, err + } + + return miners, nil +} + +func (s *state15) ForEachClaim(cb func(miner address.Address, claim Claim) error) error { + claims, err := s.claims() + if err != nil { + return err + } + + var claim power15.Claim + return claims.ForEach(&claim, func(k string) error { + a, err := address.NewFromBytes([]byte(k)) + if err != nil { + return err + } + return cb(a, Claim{ + RawBytePower: claim.RawBytePower, + QualityAdjPower: claim.QualityAdjPower, + }) + }) +} + +func (s *state15) ClaimsChanged(other State) (bool, error) { + other15, ok := other.(*state15) + if !ok { + // treat an upgrade as a change, always + return true, nil + } + return !s.State.Claims.Equals(other15.State.Claims), nil +} + +func (s *state15) SetTotalQualityAdjPower(p abi.StoragePower) error { + s.State.TotalQualityAdjPower = p + return nil +} + +func (s *state15) SetTotalRawBytePower(p abi.StoragePower) error { + s.State.TotalRawBytePower = p + return nil +} + +func (s *state15) SetThisEpochQualityAdjPower(p abi.StoragePower) error { + s.State.ThisEpochQualityAdjPower = p + return nil +} + +func (s *state15) SetThisEpochRawBytePower(p abi.StoragePower) error { + s.State.ThisEpochRawBytePower = p + return nil +} + +func (s *state15) GetState() interface{} { + return &s.State +} + +func (s *state15) claims() (adt.Map, error) { + return adt15.AsMap(s.store, s.Claims, builtin15.DefaultHamtBitwidth) +} + +func (s *state15) decodeClaim(val *cbg.Deferred) (Claim, error) { + var ci power15.Claim + if err := ci.UnmarshalCBOR(bytes.NewReader(val.Raw)); err != nil { + return Claim{}, err + } + return fromV15Claim(ci), nil +} + +func fromV15Claim(v15 power15.Claim) Claim { + return Claim{ + RawBytePower: v15.RawBytePower, + QualityAdjPower: v15.QualityAdjPower, + } +} + +func (s *state15) ActorKey() string { + return manifest.PowerKey +} + +func (s *state15) ActorVersion() actorstypes.Version { + return actorstypes.Version15 +} + +func (s *state15) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/registry.go b/chain/actors/builtin/registry.go index bbded891955..0286c35d6d4 100644 --- a/chain/actors/builtin/registry.go +++ b/chain/actors/builtin/registry.go @@ -90,6 +90,22 @@ import ( reward14 "github.com/filecoin-project/go-state-types/builtin/v14/reward" system14 "github.com/filecoin-project/go-state-types/builtin/v14/system" verifreg14 "github.com/filecoin-project/go-state-types/builtin/v14/verifreg" + account15 "github.com/filecoin-project/go-state-types/builtin/v15/account" + cron15 "github.com/filecoin-project/go-state-types/builtin/v15/cron" + datacap15 "github.com/filecoin-project/go-state-types/builtin/v15/datacap" + eam15 "github.com/filecoin-project/go-state-types/builtin/v15/eam" + ethaccount15 "github.com/filecoin-project/go-state-types/builtin/v15/ethaccount" + evm15 "github.com/filecoin-project/go-state-types/builtin/v15/evm" + _init15 "github.com/filecoin-project/go-state-types/builtin/v15/init" + market15 "github.com/filecoin-project/go-state-types/builtin/v15/market" + miner15 "github.com/filecoin-project/go-state-types/builtin/v15/miner" + multisig15 "github.com/filecoin-project/go-state-types/builtin/v15/multisig" + paych15 "github.com/filecoin-project/go-state-types/builtin/v15/paych" + placeholder15 "github.com/filecoin-project/go-state-types/builtin/v15/placeholder" + power15 "github.com/filecoin-project/go-state-types/builtin/v15/power" + reward15 "github.com/filecoin-project/go-state-types/builtin/v15/reward" + system15 "github.com/filecoin-project/go-state-types/builtin/v15/system" + verifreg15 "github.com/filecoin-project/go-state-types/builtin/v15/verifreg" account8 "github.com/filecoin-project/go-state-types/builtin/v8/account" cron8 "github.com/filecoin-project/go-state-types/builtin/v8/cron" _init8 "github.com/filecoin-project/go-state-types/builtin/v8/init" @@ -857,6 +873,110 @@ func MakeRegistry(av actorstypes.Version) []RegistryEntry { } } + case actorstypes.Version15: + for key, codeID := range codeIDs { + switch key { + case manifest.AccountKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: account15.Methods, + state: new(account15.State), + }) + case manifest.CronKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: cron15.Methods, + state: new(cron15.State), + }) + case manifest.InitKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: _init15.Methods, + state: new(_init15.State), + }) + case manifest.MarketKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: market15.Methods, + state: new(market15.State), + }) + case manifest.MinerKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: miner15.Methods, + state: new(miner15.State), + }) + case manifest.MultisigKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: multisig15.Methods, + state: new(multisig15.State), + }) + case manifest.PaychKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: paych15.Methods, + state: new(paych15.State), + }) + case manifest.PowerKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: power15.Methods, + state: new(power15.State), + }) + case manifest.RewardKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: reward15.Methods, + state: new(reward15.State), + }) + case manifest.SystemKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: system15.Methods, + state: new(system15.State), + }) + case manifest.VerifregKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: verifreg15.Methods, + state: new(verifreg15.State), + }) + case manifest.DatacapKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: datacap15.Methods, + state: new(datacap15.State), + }) + + case manifest.EvmKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: evm15.Methods, + state: new(evm15.State), + }) + case manifest.EamKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: eam15.Methods, + state: nil, + }) + case manifest.PlaceholderKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: placeholder15.Methods, + state: nil, + }) + case manifest.EthAccountKey: + registry = append(registry, RegistryEntry{ + code: codeID, + methods: ethaccount15.Methods, + state: nil, + }) + + } + } + default: panic("expected version v8 and up only, use specs-actors for v0-7") } diff --git a/chain/actors/builtin/reward/reward.go b/chain/actors/builtin/reward/reward.go index 18860769ca1..b3021b82960 100644 --- a/chain/actors/builtin/reward/reward.go +++ b/chain/actors/builtin/reward/reward.go @@ -6,7 +6,7 @@ import ( "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin14 "github.com/filecoin-project/go-state-types/builtin" + builtin15 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/manifest" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin" @@ -25,8 +25,8 @@ import ( ) var ( - Address = builtin14.RewardActorAddr - Methods = builtin14.MethodsReward + Address = builtin15.RewardActorAddr + Methods = builtin15.MethodsReward ) func Load(store adt.Store, act *types.Actor) (State, error) { @@ -58,6 +58,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version14: return load14(store, act.Head) + case actorstypes.Version15: + return load15(store, act.Head) + } } @@ -134,6 +137,9 @@ func MakeState(store adt.Store, av actorstypes.Version, currRealizedPower abi.St case actorstypes.Version14: return make14(store, currRealizedPower) + case actorstypes.Version15: + return make15(store, currRealizedPower) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -180,5 +186,6 @@ func AllCodes() []cid.Cid { (&state12{}).Code(), (&state13{}).Code(), (&state14{}).Code(), + (&state15{}).Code(), } } diff --git a/chain/actors/builtin/reward/v15.go b/chain/actors/builtin/reward/v15.go new file mode 100644 index 00000000000..1b781f462a4 --- /dev/null +++ b/chain/actors/builtin/reward/v15.go @@ -0,0 +1,120 @@ +package reward + +import ( + "fmt" + + "github.com/ipfs/go-cid" + + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + miner15 "github.com/filecoin-project/go-state-types/builtin/v15/miner" + reward15 "github.com/filecoin-project/go-state-types/builtin/v15/reward" + smoothing15 "github.com/filecoin-project/go-state-types/builtin/v15/util/smoothing" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" + "github.com/filecoin-project/lotus/chain/actors/builtin" +) + +var _ State = (*state15)(nil) + +func load15(store adt.Store, root cid.Cid) (State, error) { + out := state15{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make15(store adt.Store, currRealizedPower abi.StoragePower) (State, error) { + out := state15{store: store} + out.State = *reward15.ConstructState(currRealizedPower) + return &out, nil +} + +type state15 struct { + reward15.State + store adt.Store +} + +func (s *state15) ThisEpochReward() (abi.TokenAmount, error) { + return s.State.ThisEpochReward, nil +} + +func (s *state15) ThisEpochRewardSmoothed() (builtin.FilterEstimate, error) { + + return builtin.FilterEstimate{ + PositionEstimate: s.State.ThisEpochRewardSmoothed.PositionEstimate, + VelocityEstimate: s.State.ThisEpochRewardSmoothed.VelocityEstimate, + }, nil + +} + +func (s *state15) ThisEpochBaselinePower() (abi.StoragePower, error) { + return s.State.ThisEpochBaselinePower, nil +} + +func (s *state15) TotalStoragePowerReward() (abi.TokenAmount, error) { + return s.State.TotalStoragePowerReward, nil +} + +func (s *state15) EffectiveBaselinePower() (abi.StoragePower, error) { + return s.State.EffectiveBaselinePower, nil +} + +func (s *state15) EffectiveNetworkTime() (abi.ChainEpoch, error) { + return s.State.EffectiveNetworkTime, nil +} + +func (s *state15) CumsumBaseline() (reward15.Spacetime, error) { + return s.State.CumsumBaseline, nil +} + +func (s *state15) CumsumRealized() (reward15.Spacetime, error) { + return s.State.CumsumRealized, nil +} + +func (s *state15) InitialPledgeForPower(qaPower abi.StoragePower, networkTotalPledge abi.TokenAmount, networkQAPower *builtin.FilterEstimate, circSupply abi.TokenAmount) (abi.TokenAmount, error) { + return miner15.InitialPledgeForPower( + qaPower, + s.State.ThisEpochBaselinePower, + s.State.ThisEpochRewardSmoothed, + smoothing15.FilterEstimate{ + PositionEstimate: networkQAPower.PositionEstimate, + VelocityEstimate: networkQAPower.VelocityEstimate, + }, + circSupply, + ), nil +} + +func (s *state15) PreCommitDepositForPower(networkQAPower builtin.FilterEstimate, sectorWeight abi.StoragePower) (abi.TokenAmount, error) { + return miner15.PreCommitDepositForPower(s.State.ThisEpochRewardSmoothed, + smoothing15.FilterEstimate{ + PositionEstimate: networkQAPower.PositionEstimate, + VelocityEstimate: networkQAPower.VelocityEstimate, + }, + sectorWeight), nil +} + +func (s *state15) GetState() interface{} { + return &s.State +} + +func (s *state15) ActorKey() string { + return manifest.RewardKey +} + +func (s *state15) ActorVersion() actorstypes.Version { + return actorstypes.Version15 +} + +func (s *state15) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/system/system.go b/chain/actors/builtin/system/system.go index 8f72f717244..5bb1fe44dd0 100644 --- a/chain/actors/builtin/system/system.go +++ b/chain/actors/builtin/system/system.go @@ -5,7 +5,7 @@ import ( "golang.org/x/xerrors" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin14 "github.com/filecoin-project/go-state-types/builtin" + builtin15 "github.com/filecoin-project/go-state-types/builtin" "github.com/filecoin-project/go-state-types/manifest" builtin0 "github.com/filecoin-project/specs-actors/actors/builtin" builtin2 "github.com/filecoin-project/specs-actors/v2/actors/builtin" @@ -21,7 +21,7 @@ import ( ) var ( - Address = builtin14.SystemActorAddr + Address = builtin15.SystemActorAddr ) func Load(store adt.Store, act *types.Actor) (State, error) { @@ -53,6 +53,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version14: return load14(store, act.Head) + case actorstypes.Version15: + return load15(store, act.Head) + } } @@ -129,6 +132,9 @@ func MakeState(store adt.Store, av actorstypes.Version, builtinActors cid.Cid) ( case actorstypes.Version14: return make14(store, builtinActors) + case actorstypes.Version15: + return make15(store, builtinActors) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -159,5 +165,6 @@ func AllCodes() []cid.Cid { (&state12{}).Code(), (&state13{}).Code(), (&state14{}).Code(), + (&state15{}).Code(), } } diff --git a/chain/actors/builtin/system/v15.go b/chain/actors/builtin/system/v15.go new file mode 100644 index 00000000000..9a5da9ad000 --- /dev/null +++ b/chain/actors/builtin/system/v15.go @@ -0,0 +1,72 @@ +package system + +import ( + "fmt" + + "github.com/ipfs/go-cid" + + actorstypes "github.com/filecoin-project/go-state-types/actors" + system15 "github.com/filecoin-project/go-state-types/builtin/v15/system" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" +) + +var _ State = (*state15)(nil) + +func load15(store adt.Store, root cid.Cid) (State, error) { + out := state15{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make15(store adt.Store, builtinActors cid.Cid) (State, error) { + out := state15{store: store} + out.State = system15.State{ + BuiltinActors: builtinActors, + } + return &out, nil +} + +type state15 struct { + system15.State + store adt.Store +} + +func (s *state15) GetState() interface{} { + return &s.State +} + +func (s *state15) GetBuiltinActors() cid.Cid { + + return s.State.BuiltinActors + +} + +func (s *state15) SetBuiltinActors(c cid.Cid) error { + + s.State.BuiltinActors = c + return nil + +} + +func (s *state15) ActorKey() string { + return manifest.SystemKey +} + +func (s *state15) ActorVersion() actorstypes.Version { + return actorstypes.Version15 +} + +func (s *state15) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/verifreg/v15.go b/chain/actors/builtin/verifreg/v15.go new file mode 100644 index 00000000000..017e0cc743e --- /dev/null +++ b/chain/actors/builtin/verifreg/v15.go @@ -0,0 +1,196 @@ +package verifreg + +import ( + "fmt" + + "github.com/ipfs/go-cid" + "golang.org/x/xerrors" + + "github.com/filecoin-project/go-address" + "github.com/filecoin-project/go-state-types/abi" + actorstypes "github.com/filecoin-project/go-state-types/actors" + "github.com/filecoin-project/go-state-types/big" + builtin15 "github.com/filecoin-project/go-state-types/builtin" + adt15 "github.com/filecoin-project/go-state-types/builtin/v15/util/adt" + verifreg15 "github.com/filecoin-project/go-state-types/builtin/v15/verifreg" + verifreg9 "github.com/filecoin-project/go-state-types/builtin/v9/verifreg" + "github.com/filecoin-project/go-state-types/manifest" + + "github.com/filecoin-project/lotus/chain/actors" + "github.com/filecoin-project/lotus/chain/actors/adt" +) + +var _ State = (*state15)(nil) + +func load15(store adt.Store, root cid.Cid) (State, error) { + out := state15{store: store} + err := store.Get(store.Context(), root, &out) + if err != nil { + return nil, err + } + return &out, nil +} + +func make15(store adt.Store, rootKeyAddress address.Address) (State, error) { + out := state15{store: store} + + s, err := verifreg15.ConstructState(store, rootKeyAddress) + if err != nil { + return nil, err + } + + out.State = *s + + return &out, nil +} + +type state15 struct { + verifreg15.State + store adt.Store +} + +func (s *state15) RootKey() (address.Address, error) { + return s.State.RootKey, nil +} + +func (s *state15) VerifiedClientDataCap(addr address.Address) (bool, abi.StoragePower, error) { + + return false, big.Zero(), xerrors.Errorf("unsupported in actors v15") + +} + +func (s *state15) VerifierDataCap(addr address.Address) (bool, abi.StoragePower, error) { + return getDataCap(s.store, actors.Version15, s.verifiers, addr) +} + +func (s *state15) RemoveDataCapProposalID(verifier address.Address, client address.Address) (bool, uint64, error) { + return getRemoveDataCapProposalID(s.store, actors.Version15, s.removeDataCapProposalIDs, verifier, client) +} + +func (s *state15) ForEachVerifier(cb func(addr address.Address, dcap abi.StoragePower) error) error { + return forEachCap(s.store, actors.Version15, s.verifiers, cb) +} + +func (s *state15) ForEachClient(cb func(addr address.Address, dcap abi.StoragePower) error) error { + + return xerrors.Errorf("unsupported in actors v15") + +} + +func (s *state15) verifiedClients() (adt.Map, error) { + + return nil, xerrors.Errorf("unsupported in actors v15") + +} + +func (s *state15) verifiers() (adt.Map, error) { + return adt15.AsMap(s.store, s.Verifiers, builtin15.DefaultHamtBitwidth) +} + +func (s *state15) removeDataCapProposalIDs() (adt.Map, error) { + return adt15.AsMap(s.store, s.RemoveDataCapProposalIDs, builtin15.DefaultHamtBitwidth) +} + +func (s *state15) GetState() interface{} { + return &s.State +} + +func (s *state15) GetAllocation(clientIdAddr address.Address, allocationId verifreg9.AllocationId) (*Allocation, bool, error) { + + alloc, ok, err := s.FindAllocation(s.store, clientIdAddr, verifreg15.AllocationId(allocationId)) + return (*Allocation)(alloc), ok, err +} + +func (s *state15) GetAllocations(clientIdAddr address.Address) (map[AllocationId]Allocation, error) { + + v15Map, err := s.LoadAllocationsToMap(s.store, clientIdAddr) + + retMap := make(map[AllocationId]Allocation, len(v15Map)) + for k, v := range v15Map { + retMap[AllocationId(k)] = Allocation(v) + } + + return retMap, err + +} + +func (s *state15) GetAllAllocations() (map[AllocationId]Allocation, error) { + + v15Map, err := s.State.GetAllAllocations(s.store) + + retMap := make(map[AllocationId]Allocation, len(v15Map)) + for k, v := range v15Map { + retMap[AllocationId(k)] = Allocation(v) + } + + return retMap, err + +} + +func (s *state15) GetClaim(providerIdAddr address.Address, claimId verifreg9.ClaimId) (*Claim, bool, error) { + + claim, ok, err := s.FindClaim(s.store, providerIdAddr, verifreg15.ClaimId(claimId)) + return (*Claim)(claim), ok, err + +} + +func (s *state15) GetClaims(providerIdAddr address.Address) (map[ClaimId]Claim, error) { + + v15Map, err := s.LoadClaimsToMap(s.store, providerIdAddr) + + retMap := make(map[ClaimId]Claim, len(v15Map)) + for k, v := range v15Map { + retMap[ClaimId(k)] = Claim(v) + } + + return retMap, err + +} + +func (s *state15) GetAllClaims() (map[ClaimId]Claim, error) { + + v15Map, err := s.State.GetAllClaims(s.store) + + retMap := make(map[ClaimId]Claim, len(v15Map)) + for k, v := range v15Map { + retMap[ClaimId(k)] = Claim(v) + } + + return retMap, err + +} + +func (s *state15) GetClaimIdsBySector(providerIdAddr address.Address) (map[abi.SectorNumber][]ClaimId, error) { + + v15Map, err := s.LoadClaimsToMap(s.store, providerIdAddr) + + retMap := make(map[abi.SectorNumber][]ClaimId) + for k, v := range v15Map { + claims, ok := retMap[v.Sector] + if !ok { + retMap[v.Sector] = []ClaimId{ClaimId(k)} + } else { + retMap[v.Sector] = append(claims, ClaimId(k)) + } + } + + return retMap, err + +} + +func (s *state15) ActorKey() string { + return manifest.VerifregKey +} + +func (s *state15) ActorVersion() actorstypes.Version { + return actorstypes.Version15 +} + +func (s *state15) Code() cid.Cid { + code, ok := actors.GetActorCodeID(s.ActorVersion(), s.ActorKey()) + if !ok { + panic(fmt.Errorf("didn't find actor %v code id for actor version %d", s.ActorKey(), s.ActorVersion())) + } + + return code +} diff --git a/chain/actors/builtin/verifreg/verifreg.go b/chain/actors/builtin/verifreg/verifreg.go index 97976852fc6..02e3f961dbf 100644 --- a/chain/actors/builtin/verifreg/verifreg.go +++ b/chain/actors/builtin/verifreg/verifreg.go @@ -7,7 +7,7 @@ import ( "github.com/filecoin-project/go-address" "github.com/filecoin-project/go-state-types/abi" actorstypes "github.com/filecoin-project/go-state-types/actors" - builtin14 "github.com/filecoin-project/go-state-types/builtin" + builtin15 "github.com/filecoin-project/go-state-types/builtin" verifregtypes "github.com/filecoin-project/go-state-types/builtin/v9/verifreg" "github.com/filecoin-project/go-state-types/cbor" "github.com/filecoin-project/go-state-types/manifest" @@ -25,8 +25,8 @@ import ( ) var ( - Address = builtin14.VerifiedRegistryActorAddr - Methods = builtin14.MethodsVerifiedRegistry + Address = builtin15.VerifiedRegistryActorAddr + Methods = builtin15.MethodsVerifiedRegistry ) func Load(store adt.Store, act *types.Actor) (State, error) { @@ -58,6 +58,9 @@ func Load(store adt.Store, act *types.Actor) (State, error) { case actorstypes.Version14: return load14(store, act.Head) + case actorstypes.Version15: + return load15(store, act.Head) + } } @@ -134,6 +137,9 @@ func MakeState(store adt.Store, av actorstypes.Version, rootKeyAddress address.A case actorstypes.Version14: return make14(store, rootKeyAddress) + case actorstypes.Version15: + return make15(store, rootKeyAddress) + } return nil, xerrors.Errorf("unknown actor version %d", av) } @@ -177,6 +183,7 @@ func AllCodes() []cid.Cid { (&state12{}).Code(), (&state13{}).Code(), (&state14{}).Code(), + (&state15{}).Code(), } } diff --git a/chain/actors/policy/policy.go b/chain/actors/policy/policy.go index ac410e8ca83..1f488518dea 100644 --- a/chain/actors/policy/policy.go +++ b/chain/actors/policy/policy.go @@ -11,6 +11,7 @@ import ( builtin12 "github.com/filecoin-project/go-state-types/builtin" builtin13 "github.com/filecoin-project/go-state-types/builtin" builtin14 "github.com/filecoin-project/go-state-types/builtin" + builtin15 "github.com/filecoin-project/go-state-types/builtin" builtin8 "github.com/filecoin-project/go-state-types/builtin" builtin9 "github.com/filecoin-project/go-state-types/builtin" market10 "github.com/filecoin-project/go-state-types/builtin/v10/market" @@ -27,8 +28,11 @@ import ( verifreg13 "github.com/filecoin-project/go-state-types/builtin/v13/verifreg" market14 "github.com/filecoin-project/go-state-types/builtin/v14/market" miner14 "github.com/filecoin-project/go-state-types/builtin/v14/miner" - paych14 "github.com/filecoin-project/go-state-types/builtin/v14/paych" verifreg14 "github.com/filecoin-project/go-state-types/builtin/v14/verifreg" + market15 "github.com/filecoin-project/go-state-types/builtin/v15/market" + miner15 "github.com/filecoin-project/go-state-types/builtin/v15/miner" + paych15 "github.com/filecoin-project/go-state-types/builtin/v15/paych" + verifreg15 "github.com/filecoin-project/go-state-types/builtin/v15/verifreg" market8 "github.com/filecoin-project/go-state-types/builtin/v8/market" miner8 "github.com/filecoin-project/go-state-types/builtin/v8/miner" verifreg8 "github.com/filecoin-project/go-state-types/builtin/v8/verifreg" @@ -67,14 +71,14 @@ import ( ) const ( - ChainFinality = miner14.ChainFinality + ChainFinality = miner15.ChainFinality SealRandomnessLookback = ChainFinality - PaychSettleDelay = paych14.SettleDelay - MaxPreCommitRandomnessLookback = builtin14.EpochsInDay + SealRandomnessLookback + PaychSettleDelay = paych15.SettleDelay + MaxPreCommitRandomnessLookback = builtin15.EpochsInDay + SealRandomnessLookback ) var ( - MarketDefaultAllocationTermBuffer = market14.MarketDefaultAllocationTermBuffer + MarketDefaultAllocationTermBuffer = market15.MarketDefaultAllocationTermBuffer ) // SetSupportedProofTypes sets supported proof types, across all actor versions. @@ -193,11 +197,13 @@ func SetPreCommitChallengeDelay(delay abi.ChainEpoch) { miner14.PreCommitChallengeDelay = delay + miner15.PreCommitChallengeDelay = delay + } func GetPreCommitChallengeDelay() abi.ChainEpoch { // TODO: this function shouldn't really exist. Instead, the API should expose the precommit delay. - return miner14.PreCommitChallengeDelay + return miner15.PreCommitChallengeDelay } // SetConsensusMinerMinPower sets the minimum power of an individual miner must @@ -259,6 +265,10 @@ func SetConsensusMinerMinPower(p abi.StoragePower) { policy.ConsensusMinerMinPower = p } + for _, policy := range builtin15.PoStProofPolicies { + policy.ConsensusMinerMinPower = p + } + } // SetMinVerifiedDealSize sets the minimum size of a verified deal. This should @@ -293,6 +303,8 @@ func SetMinVerifiedDealSize(size abi.StoragePower) { verifreg14.MinVerifiedDealSize = size + verifreg15.MinVerifiedDealSize = size + } func GetMaxProveCommitDuration(ver actorstypes.Version, t abi.RegisteredSealProof) (abi.ChainEpoch, error) { @@ -354,6 +366,10 @@ func GetMaxProveCommitDuration(ver actorstypes.Version, t abi.RegisteredSealProo return miner14.MaxProveCommitDuration[t], nil + case actorstypes.Version15: + + return miner15.MaxProveCommitDuration[t], nil + default: return 0, xerrors.Errorf("unsupported actors version") } @@ -429,6 +445,11 @@ func SetProviderCollateralSupplyTarget(num, denom big.Int) { Denominator: denom, } + market15.ProviderCollateralSupplyTarget = builtin15.BigFrac{ + Numerator: num, + Denominator: denom, + } + } func DealProviderCollateralBounds( @@ -512,13 +533,18 @@ func DealProviderCollateralBounds( min, max := market14.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil) return min, max, nil + case actorstypes.Version15: + + min, max := market15.DealProviderCollateralBounds(size, verified, rawBytePower, qaPower, baselinePower, circulatingFil) + return min, max, nil + default: return big.Zero(), big.Zero(), xerrors.Errorf("unsupported actors version") } } func DealDurationBounds(pieceSize abi.PaddedPieceSize) (min, max abi.ChainEpoch) { - return market14.DealDurationBounds(pieceSize) + return market15.DealDurationBounds(pieceSize) } // SetWPoStChallengeWindow sets the challenge window and scales the proving period to match (such @@ -615,6 +641,13 @@ func SetWPoStChallengeWindow(period abi.ChainEpoch) { // scale it if we're scaling the challenge period. miner14.WPoStDisputeWindow = period * 30 + miner15.WPoStChallengeWindow = period + miner15.WPoStProvingPeriod = period * abi.ChainEpoch(miner15.WPoStPeriodDeadlines) + + // by default, this is 2x finality which is 30 periods. + // scale it if we're scaling the challenge period. + miner15.WPoStDisputeWindow = period * 30 + } func GetWinningPoStSectorSetLookback(nwVer network.Version) abi.ChainEpoch { @@ -675,6 +708,9 @@ func GetMaxSectorExpirationExtension(nv network.Version) (abi.ChainEpoch, error) case actorstypes.Version14: return miner14.MaxSectorExpirationExtension, nil + case actorstypes.Version15: + return miner15.MaxSectorExpirationExtension, nil + default: return 0, xerrors.Errorf("unsupported network version") } @@ -682,11 +718,11 @@ func GetMaxSectorExpirationExtension(nv network.Version) (abi.ChainEpoch, error) } func GetMinSectorExpiration() abi.ChainEpoch { - return miner14.MinSectorExpiration + return miner15.MinSectorExpiration } func GetMaxPoStPartitions(nv network.Version, p abi.RegisteredPoStProof) (int, error) { - sectorsPerPart, err := builtin14.PoStProofWindowPoStPartitionSectors(p) + sectorsPerPart, err := builtin15.PoStProofWindowPoStPartitionSectors(p) if err != nil { return 0, err } @@ -695,7 +731,7 @@ func GetMaxPoStPartitions(nv network.Version, p abi.RegisteredPoStProof) (int, e return 0, err } - return min(miner14.PoStedPartitionsMax, int(uint64(maxSectors)/sectorsPerPart)), nil + return min(miner15.PoStedPartitionsMax, int(uint64(maxSectors)/sectorsPerPart)), nil } func GetDefaultAggregationProof() abi.RegisteredAggregationProof { @@ -707,7 +743,7 @@ func GetSectorMaxLifetime(proof abi.RegisteredSealProof, nwVer network.Version) return builtin4.SealProofPoliciesV0[proof].SectorMaxLifetime } - return builtin14.SealProofPoliciesV11[proof].SectorMaxLifetime + return builtin15.SealProofPoliciesV11[proof].SectorMaxLifetime } func GetAddressedSectorsMax(nwVer network.Version) (int, error) { @@ -759,6 +795,9 @@ func GetAddressedSectorsMax(nwVer network.Version) (int, error) { case actorstypes.Version14: return miner14.AddressedSectorsMax, nil + case actorstypes.Version15: + return miner15.AddressedSectorsMax, nil + default: return 0, xerrors.Errorf("unsupported network version") } @@ -828,6 +867,10 @@ func GetDeclarationsMax(nwVer network.Version) (int, error) { return miner14.DeclarationsMax, nil + case actorstypes.Version15: + + return miner15.DeclarationsMax, nil + default: return 0, xerrors.Errorf("unsupported network version") } @@ -896,6 +939,10 @@ func AggregateProveCommitNetworkFee(nwVer network.Version, aggregateSize int, ba return miner14.AggregateProveCommitNetworkFee(aggregateSize, baseFee), nil + case actorstypes.Version15: + + return miner15.AggregateProveCommitNetworkFee(aggregateSize, baseFee), nil + default: return big.Zero(), xerrors.Errorf("unsupported network version") } @@ -964,6 +1011,10 @@ func AggregatePreCommitNetworkFee(nwVer network.Version, aggregateSize int, base return miner14.AggregatePreCommitNetworkFee(aggregateSize, baseFee), nil + case actorstypes.Version15: + + return miner15.AggregatePreCommitNetworkFee(aggregateSize, baseFee), nil + default: return big.Zero(), xerrors.Errorf("unsupported network version") } diff --git a/chain/actors/version.go b/chain/actors/version.go index b67a4ef2166..86199d0cf17 100644 --- a/chain/actors/version.go +++ b/chain/actors/version.go @@ -14,9 +14,9 @@ const ({{range .actorVersions}} /* inline-gen start */ -var LatestVersion = 14 +var LatestVersion = 15 -var Versions = []int{0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14} +var Versions = []int{0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15} const ( Version0 Version = 0 @@ -33,6 +33,7 @@ const ( Version12 Version = 12 Version13 Version = 13 Version14 Version = 14 + Version15 Version = 15 ) /* inline-gen end */ diff --git a/chain/consensus/compute_state.go b/chain/consensus/compute_state.go index 1bdd47de4cc..62a4c495138 100644 --- a/chain/consensus/compute_state.go +++ b/chain/consensus/compute_state.go @@ -55,6 +55,7 @@ func NewActorRegistry() *vm.ActorRegistry { inv.Register(actorstypes.Version12, vm.ActorsVersionPredicate(actorstypes.Version12), builtin.MakeRegistry(actorstypes.Version12)) inv.Register(actorstypes.Version13, vm.ActorsVersionPredicate(actorstypes.Version13), builtin.MakeRegistry(actorstypes.Version13)) inv.Register(actorstypes.Version14, vm.ActorsVersionPredicate(actorstypes.Version14), builtin.MakeRegistry(actorstypes.Version14)) + inv.Register(actorstypes.Version15, vm.ActorsVersionPredicate(actorstypes.Version15), builtin.MakeRegistry(actorstypes.Version15)) return inv } diff --git a/chain/consensus/filcns/upgrades.go b/chain/consensus/filcns/upgrades.go index f6d65ed5b3b..e39767d82ce 100644 --- a/chain/consensus/filcns/upgrades.go +++ b/chain/consensus/filcns/upgrades.go @@ -30,6 +30,7 @@ import ( system12 "github.com/filecoin-project/go-state-types/builtin/v12/system" nv22 "github.com/filecoin-project/go-state-types/builtin/v13/migration" nv23 "github.com/filecoin-project/go-state-types/builtin/v14/migration" + nv24 "github.com/filecoin-project/go-state-types/builtin/v15/migration" nv17 "github.com/filecoin-project/go-state-types/builtin/v9/migration" "github.com/filecoin-project/go-state-types/manifest" "github.com/filecoin-project/go-state-types/migration" @@ -317,6 +318,17 @@ func DefaultUpgradeSchedule() stmgr.UpgradeSchedule { StopWithin: 10, }}, Expensive: true, + }, { + Height: buildconstants.UpgradeTuktukHeight, + Network: network.Version24, + Migration: UpgradeActorsV15, + PreMigrations: []stmgr.PreMigration{{ + PreMigration: PreUpgradeActorsV15, + StartWithin: 120, + DontStartWithin: 15, + StopWithin: 10, + }}, + Expensive: true, }, } @@ -2588,6 +2600,108 @@ func upgradeActorsV14Common( return newRoot, nil } +func PreUpgradeActorsV15(ctx context.Context, sm *stmgr.StateManager, cache stmgr.MigrationCache, root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) error { + // Use half the CPUs for pre-migration, but leave at least 3. + workerCount := MigrationMaxWorkerCount + if workerCount <= 4 { + workerCount = 1 + } else { + workerCount /= 2 + } + + lbts, lbRoot, err := stmgr.GetLookbackTipSetForRound(ctx, sm, ts, epoch) + if err != nil { + return xerrors.Errorf("error getting lookback ts for premigration: %w", err) + } + + config := migration.Config{ + MaxWorkers: uint(workerCount), + ProgressLogPeriod: time.Minute * 5, + } + + _, err = upgradeActorsV15Common(ctx, sm, cache, lbRoot, epoch, lbts, config) + return err +} + +func UpgradeActorsV15(ctx context.Context, sm *stmgr.StateManager, cache stmgr.MigrationCache, cb stmgr.ExecMonitor, + root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet) (cid.Cid, error) { + // Use all the CPUs except 2. + workerCount := MigrationMaxWorkerCount - 3 + if workerCount <= 0 { + workerCount = 1 + } + config := migration.Config{ + MaxWorkers: uint(workerCount), + JobQueueSize: 1000, + ResultQueueSize: 100, + ProgressLogPeriod: 10 * time.Second, + } + newRoot, err := upgradeActorsV15Common(ctx, sm, cache, root, epoch, ts, config) + if err != nil { + return cid.Undef, xerrors.Errorf("migrating actors vXX state: %w", err) + } + return newRoot, nil +} + +func upgradeActorsV15Common( + ctx context.Context, sm *stmgr.StateManager, cache stmgr.MigrationCache, + root cid.Cid, epoch abi.ChainEpoch, ts *types.TipSet, + config migration.Config, +) (cid.Cid, error) { + writeStore := blockstore.NewAutobatch(ctx, sm.ChainStore().StateBlockstore(), units.GiB/4) + adtStore := store.ActorStore(ctx, writeStore) + // ensure that the manifest is loaded in the blockstore + if err := bundle.LoadBundles(ctx, writeStore, actorstypes.Version15); err != nil { + return cid.Undef, xerrors.Errorf("failed to load manifest bundle: %w", err) + } + + // Load the state root. + var stateRoot types.StateRoot + if err := adtStore.Get(ctx, root, &stateRoot); err != nil { + return cid.Undef, xerrors.Errorf("failed to decode state root: %w", err) + } + + if stateRoot.Version != types.StateTreeVersion5 { + return cid.Undef, xerrors.Errorf( + "expected state root version 5 for actors vXX+1 upgrade, got %d", + stateRoot.Version, + ) + } + + manifest, ok := actors.GetManifest(actorstypes.Version15) + if !ok { + return cid.Undef, xerrors.Errorf("no manifest CID for vXX+1 upgrade") + } + + // Perform the migration + newHamtRoot, err := nv24.MigrateStateTree(ctx, adtStore, manifest, stateRoot.Actors, epoch, config, + migrationLogger{}, cache) + if err != nil { + return cid.Undef, xerrors.Errorf("upgrading to actors vXX+1: %w", err) + } + + // Persist the result. + newRoot, err := adtStore.Put(ctx, &types.StateRoot{ + Version: types.StateTreeVersion5, + Actors: newHamtRoot, + Info: stateRoot.Info, + }) + if err != nil { + return cid.Undef, xerrors.Errorf("failed to persist new state root: %w", err) + } + + // Persists the new tree and shuts down the flush worker + if err := writeStore.Flush(ctx); err != nil { + return cid.Undef, xerrors.Errorf("writeStore flush failed: %w", err) + } + + if err := writeStore.Shutdown(ctx); err != nil { + return cid.Undef, xerrors.Errorf("writeStore shutdown failed: %w", err) + } + + return newRoot, nil +} + //////////////////// // Example upgrade function if upgrade requires only code changes diff --git a/chain/state/statetree.go b/chain/state/statetree.go index 591ef46bf34..de822003306 100644 --- a/chain/state/statetree.go +++ b/chain/state/statetree.go @@ -157,7 +157,7 @@ func VersionForNetwork(ver network.Version) (types.StateTreeVersion, error) { case network.Version13, network.Version14, network.Version15, network.Version16, network.Version17: return types.StateTreeVersion4, nil - case network.Version18, network.Version19, network.Version20, network.Version21, network.Version22, network.Version23: + case network.Version18, network.Version19, network.Version20, network.Version21, network.Version22, network.Version23, network.Version24: return types.StateTreeVersion5, nil default: diff --git a/cmd/lotus-shed/invariants.go b/cmd/lotus-shed/invariants.go index 378f6af5843..91db29e613b 100644 --- a/cmd/lotus-shed/invariants.go +++ b/cmd/lotus-shed/invariants.go @@ -20,6 +20,7 @@ import ( v12 "github.com/filecoin-project/go-state-types/builtin/v12" v13 "github.com/filecoin-project/go-state-types/builtin/v13" v14 "github.com/filecoin-project/go-state-types/builtin/v14" + v15 "github.com/filecoin-project/go-state-types/builtin/v15" v8 "github.com/filecoin-project/go-state-types/builtin/v8" v9 "github.com/filecoin-project/go-state-types/builtin/v9" @@ -198,6 +199,11 @@ var invariantsCmd = &cli.Command{ if err != nil { return xerrors.Errorf("checking state invariants: %w", err) } + case actorstypes.Version15: + messages, err = v15.CheckStateInvariants(actorTree, abi.ChainEpoch(epoch), actorCodeCids) + if err != nil { + return xerrors.Errorf("checking state invariants: %w", err) + } default: return xerrors.Errorf("unsupported actor version: %v", av) } diff --git a/cmd/lotus-shed/migrations.go b/cmd/lotus-shed/migrations.go index 24110860404..3ebdd11260d 100644 --- a/cmd/lotus-shed/migrations.go +++ b/cmd/lotus-shed/migrations.go @@ -37,6 +37,7 @@ import ( market13 "github.com/filecoin-project/go-state-types/builtin/v13/market" adt13 "github.com/filecoin-project/go-state-types/builtin/v13/util/adt" v14 "github.com/filecoin-project/go-state-types/builtin/v14" + v15 "github.com/filecoin-project/go-state-types/builtin/v15" market8 "github.com/filecoin-project/go-state-types/builtin/v8/market" adt8 "github.com/filecoin-project/go-state-types/builtin/v8/util/adt" v9 "github.com/filecoin-project/go-state-types/builtin/v9" @@ -294,6 +295,8 @@ func getMigrationFuncsForNetwork(nv network.Version) (UpgradeActorsFunc, PreUpgr return filcns.UpgradeActorsV13, filcns.PreUpgradeActorsV13, checkNv22Invariants, nil case network.Version23: return filcns.UpgradeActorsV14, filcns.PreUpgradeActorsV14, checkNv23Invariants, nil + case network.Version24: + return filcns.UpgradeActorsV15, filcns.PreUpgradeActorsV15, checkNv24Invariants, nil default: return nil, nil, nil, xerrors.Errorf("migration not implemented for nv%d", nv) } @@ -622,6 +625,39 @@ func printMarketActorDiff(ctx context.Context, cst *cbornode.BasicIpldStore, nv return nil } +func checkNv24Invariants(ctx context.Context, oldStateRootCid cid.Cid, newStateRootCid cid.Cid, bs blockstore.Blockstore, epoch abi.ChainEpoch) error { + + actorStore := store.ActorStore(ctx, bs) + startTime := time.Now() + + // Load the new state root. + var newStateRoot types.StateRoot + if err := actorStore.Get(ctx, newStateRootCid, &newStateRoot); err != nil { + return xerrors.Errorf("failed to decode state root: %w", err) + } + + actorCodeCids, err := actors.GetActorCodeIDs(actorstypes.Version14) + if err != nil { + return err + } + newActorTree, err := builtin.LoadTree(actorStore, newStateRoot.Actors) + if err != nil { + return err + } + messages, err := v15.CheckStateInvariants(newActorTree, epoch, actorCodeCids) + if err != nil { + return xerrors.Errorf("checking state invariants: %w", err) + } + + for _, message := range messages.Messages() { + fmt.Println("got the following error: ", message) + } + + fmt.Println("completed invariant checks, took ", time.Since(startTime)) + + return nil +} + func checkNv23Invariants(ctx context.Context, oldStateRootCid cid.Cid, newStateRootCid cid.Cid, bs blockstore.Blockstore, epoch abi.ChainEpoch) error { actorStore := store.ActorStore(ctx, bs) diff --git a/documentation/en/api-v0-methods-miner.md b/documentation/en/api-v0-methods-miner.md index 0bf4d3325c8..3eacfe15865 100644 --- a/documentation/en/api-v0-methods-miner.md +++ b/documentation/en/api-v0-methods-miner.md @@ -400,7 +400,7 @@ Inputs: ], "Bw==", 10101, - 23 + 24 ] ``` diff --git a/documentation/en/api-v0-methods.md b/documentation/en/api-v0-methods.md index 1302f15d981..b34c7ca5565 100644 --- a/documentation/en/api-v0-methods.md +++ b/documentation/en/api-v0-methods.md @@ -3655,7 +3655,7 @@ Perms: read Inputs: ```json [ - 23 + 24 ] ``` @@ -3670,7 +3670,7 @@ Perms: read Inputs: ```json [ - 23 + 24 ] ``` @@ -4483,7 +4483,8 @@ Response: "UpgradeWatermelonHeight": 10101, "UpgradeDragonHeight": 10101, "UpgradePhoenixHeight": 10101, - "UpgradeWaffleHeight": 10101 + "UpgradeWaffleHeight": 10101, + "UpgradeTuktukHeight": 10101 }, "Eip155ChainID": 123 } @@ -5409,7 +5410,7 @@ Inputs: ] ``` -Response: `23` +Response: `24` ### StateReadState StateReadState returns the indicated actor's state. diff --git a/documentation/en/api-v1-unstable-methods.md b/documentation/en/api-v1-unstable-methods.md index da322b4882d..65ad97216e0 100644 --- a/documentation/en/api-v1-unstable-methods.md +++ b/documentation/en/api-v1-unstable-methods.md @@ -5564,7 +5564,7 @@ Perms: read Inputs: ```json [ - 23 + 24 ] ``` @@ -5579,7 +5579,7 @@ Perms: read Inputs: ```json [ - 23 + 24 ] ``` @@ -6490,7 +6490,8 @@ Response: "UpgradeWatermelonHeight": 10101, "UpgradeDragonHeight": 10101, "UpgradePhoenixHeight": 10101, - "UpgradeWaffleHeight": 10101 + "UpgradeWaffleHeight": 10101, + "UpgradeTuktukHeight": 10101 }, "Eip155ChainID": 123 } @@ -7470,7 +7471,7 @@ Inputs: ] ``` -Response: `23` +Response: `24` ### StateReadState StateReadState returns the indicated actor's state. diff --git a/extern/filecoin-ffi b/extern/filecoin-ffi index d041c9ab85e..605ca1bb734 160000 --- a/extern/filecoin-ffi +++ b/extern/filecoin-ffi @@ -1 +1 @@ -Subproject commit d041c9ab85e68cfb57daf5fbaedeeee0f72cb5ad +Subproject commit 605ca1bb734f33d56a7eb4a86e450cca4450aaa5 diff --git a/gen/inlinegen-data.json b/gen/inlinegen-data.json index fd5569436c3..59112f29065 100644 --- a/gen/inlinegen-data.json +++ b/gen/inlinegen-data.json @@ -1,7 +1,7 @@ { - "actorVersions": [0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14], - "latestActorsVersion": 14, + "actorVersions": [0, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15], + "latestActorsVersion": 15, - "networkVersions": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23], - "latestNetworkVersion": 23 + "networkVersions": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], + "latestNetworkVersion": 24 } diff --git a/go.mod b/go.mod index d21a5e1e502..0c3d8b40a5d 100644 --- a/go.mod +++ b/go.mod @@ -37,7 +37,7 @@ require ( github.com/fatih/color v1.15.0 github.com/filecoin-project/filecoin-ffi v1.28.0-rc2 github.com/filecoin-project/go-address v1.1.0 - github.com/filecoin-project/go-amt-ipld/v4 v4.3.0 + github.com/filecoin-project/go-amt-ipld/v4 v4.4.0 github.com/filecoin-project/go-bitfield v0.2.4 github.com/filecoin-project/go-cbor-util v0.0.1 github.com/filecoin-project/go-commp-utils/v2 v2.1.0 @@ -48,7 +48,7 @@ require ( github.com/filecoin-project/go-jsonrpc v0.6.0 github.com/filecoin-project/go-padreader v0.0.1 github.com/filecoin-project/go-paramfetch v0.0.4 - github.com/filecoin-project/go-state-types v0.14.0 + github.com/filecoin-project/go-state-types v0.15.0-dev github.com/filecoin-project/go-statemachine v1.0.3 github.com/filecoin-project/go-statestore v0.2.0 github.com/filecoin-project/go-storedcounter v0.1.0 @@ -153,15 +153,15 @@ require ( go.uber.org/fx v1.22.1 go.uber.org/multierr v1.11.0 go.uber.org/zap v1.27.0 - golang.org/x/crypto v0.27.0 + golang.org/x/crypto v0.26.0 golang.org/x/mod v0.20.0 - golang.org/x/net v0.29.0 + golang.org/x/net v0.28.0 golang.org/x/sync v0.8.0 - golang.org/x/sys v0.25.0 - golang.org/x/term v0.24.0 - golang.org/x/time v0.6.0 + golang.org/x/sys v0.23.0 + golang.org/x/term v0.23.0 + golang.org/x/time v0.5.0 golang.org/x/tools v0.24.0 - golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da + golang.org/x/xerrors v0.0.0-20240716161551-93cc26a95ae9 gopkg.in/cheggaaa/pb.v1 v1.0.28 gotest.tools v2.2.0+incompatible ) @@ -195,8 +195,6 @@ require ( github.com/filecoin-project/go-amt-ipld/v2 v2.1.0 // indirect github.com/filecoin-project/go-amt-ipld/v3 v3.1.0 // indirect github.com/filecoin-project/go-clock v0.1.0 // indirect - github.com/filecoin-project/go-commp-utils v0.1.4 // indirect - github.com/filecoin-project/go-commp-utils/nonffi v0.0.0-20240802040721-2a04ffc8ffe8 // indirect github.com/filecoin-project/go-fil-commp-hashhash v0.2.0 // indirect github.com/filecoin-project/go-hamt-ipld v0.1.5 // indirect github.com/filecoin-project/go-hamt-ipld/v2 v2.0.0 // indirect diff --git a/go.sum b/go.sum index 9dcc39b5d3a..5662340e79e 100644 --- a/go.sum +++ b/go.sum @@ -248,8 +248,8 @@ github.com/filecoin-project/go-amt-ipld/v3 v3.0.0/go.mod h1:Qa95YNAbtoVCTSVtX38a github.com/filecoin-project/go-amt-ipld/v3 v3.1.0 h1:ZNJ9tEG5bE72vBWYiuh5bkxJVM3ViHNOmQ7qew9n6RE= github.com/filecoin-project/go-amt-ipld/v3 v3.1.0/go.mod h1:UjM2QhDFrrjD5s1CdnkJkat4ga+LqZBZgTMniypABRo= github.com/filecoin-project/go-amt-ipld/v4 v4.0.0/go.mod h1:gF053YQ4BIpzTNDoEwHZas7U3oAwncDVGvOHyY8oDpE= -github.com/filecoin-project/go-amt-ipld/v4 v4.3.0 h1:bY42N1gR0DqrLMCKUPzX1VhYVgXaETQm0Um4ohvyEP8= -github.com/filecoin-project/go-amt-ipld/v4 v4.3.0/go.mod h1:39Ep/yBbF6xN94WevLG9qSbglBJepHa5zeEbAE1pYsc= +github.com/filecoin-project/go-amt-ipld/v4 v4.4.0 h1:6kvvMeSpIy4GTU5t3vPHZgWYIMRzGRKLJ73s/cltsoc= +github.com/filecoin-project/go-amt-ipld/v4 v4.4.0/go.mod h1:msgmUxTyRBZ6iXt+5dnUDnIb7SEFqdPsbB1wyo/G3ts= github.com/filecoin-project/go-bitfield v0.2.0/go.mod h1:CNl9WG8hgR5mttCnUErjcQjGvuiZjRqK9rHVBsQF4oM= github.com/filecoin-project/go-bitfield v0.2.3/go.mod h1:CNl9WG8hgR5mttCnUErjcQjGvuiZjRqK9rHVBsQF4oM= github.com/filecoin-project/go-bitfield v0.2.4 h1:uZ7MeE+XfM5lqrHJZ93OnhQKc/rveW8p9au0C68JPgk= @@ -259,10 +259,6 @@ github.com/filecoin-project/go-cbor-util v0.0.1 h1:E1LYZYTtjfAQwCReho0VXvbu8t3CY github.com/filecoin-project/go-cbor-util v0.0.1/go.mod h1:pqTiPHobNkOVM5thSRsHYjyQfq7O5QSCMhvuu9JoDlg= github.com/filecoin-project/go-clock v0.1.0 h1:SFbYIM75M8NnFm1yMHhN9Ahy3W5bEZV9gd6MPfXbKVU= github.com/filecoin-project/go-clock v0.1.0/go.mod h1:4uB/O4PvOjlx1VCMdZ9MyDZXRm//gkj1ELEbxfI1AZs= -github.com/filecoin-project/go-commp-utils v0.1.4 h1:/WSsrAb0xupo+aRWRyD80lRUXAXJvYoTgDQS1pYZ1Mk= -github.com/filecoin-project/go-commp-utils v0.1.4/go.mod h1:Sekocu5q9b4ECAUFu853GFUbm8I7upAluummHFe2kFo= -github.com/filecoin-project/go-commp-utils/nonffi v0.0.0-20240802040721-2a04ffc8ffe8 h1:jAG2g1Fs/qoDSSaI8JaP/KmqR+QQ8IVQ6k9xKONa72M= -github.com/filecoin-project/go-commp-utils/nonffi v0.0.0-20240802040721-2a04ffc8ffe8/go.mod h1:kU2KuSPLB+Xz4FEbVE0abzSN4l6irZ8tqgcYWPVDftU= github.com/filecoin-project/go-commp-utils/v2 v2.1.0 h1:KWNRalUp2bhN1SW7STsJS2AHs9mnfGKk9LnQgzDe+gI= github.com/filecoin-project/go-commp-utils/v2 v2.1.0/go.mod h1:NbxJYlhxtWaNhlVCj/gysLNu26kYII83IV5iNrAO9iI= github.com/filecoin-project/go-crypto v0.0.0-20191218222705-effae4ea9f03/go.mod h1:+viYnvGtUTgJRdy6oaeF4MTFKAfatX071MPDPBL11EQ= @@ -293,8 +289,8 @@ github.com/filecoin-project/go-state-types v0.0.0-20200928172055-2df22083d8ab/go github.com/filecoin-project/go-state-types v0.0.0-20201102161440-c8033295a1fc/go.mod h1:ezYnPf0bNkTsDibL/psSz5dy4B5awOJ/E7P2Saeep8g= github.com/filecoin-project/go-state-types v0.1.0/go.mod h1:ezYnPf0bNkTsDibL/psSz5dy4B5awOJ/E7P2Saeep8g= github.com/filecoin-project/go-state-types v0.1.6/go.mod h1:UwGVoMsULoCK+bWjEdd/xLCvLAQFBC7EDT477SKml+Q= -github.com/filecoin-project/go-state-types v0.14.0 h1:JFw8r/LA0/Hvu865Yn2Gz3R5e2woItKeHTgbT4VsXoU= -github.com/filecoin-project/go-state-types v0.14.0/go.mod h1:cDbxwjbmVtV+uNi5D/cFtxKlsRqibnQNlz7xQA1EqYg= +github.com/filecoin-project/go-state-types v0.15.0-dev h1:6lR4q5QSCUqOEfy2RWEsOLADd82T/K9CwGNMj27Fpwo= +github.com/filecoin-project/go-state-types v0.15.0-dev/go.mod h1:dMXsOsurh57in11qTmPpYyrhGQAOhVtHQXnyV0X+QQk= github.com/filecoin-project/go-statemachine v1.0.3 h1:N07o6alys+V1tNoSTi4WuuoeNC4erS/6jE74+NsgQuk= github.com/filecoin-project/go-statemachine v1.0.3/go.mod h1:jZdXXiHa61n4NmgWFG4w8tnqgvZVHYbJ3yW7+y8bF54= github.com/filecoin-project/go-statestore v0.1.0/go.mod h1:LFc9hD+fRxPqiHiaqUEZOinUJB4WARkRfNl10O7kTnI= @@ -1439,8 +1435,8 @@ golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98y golang.org/x/crypto v0.18.0/go.mod h1:R0j02AL6hcrfOiy9T4ZYp/rcWeMxM3L6QYxlOuEG1mg= golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU= golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs= -golang.org/x/crypto v0.27.0 h1:GXm2NjJrPaiv/h1tb2UH8QfgC/hOf/+z0p6PT8o1w7A= -golang.org/x/crypto v0.27.0/go.mod h1:1Xngt8kV6Dvbssa53Ziq6Eqn0HqbZi5Z6R0ZpwQzt70= +golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw= +golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= @@ -1539,8 +1535,8 @@ golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI= golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY= golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= golang.org/x/net v0.22.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= -golang.org/x/net v0.29.0 h1:5ORfpBpCs4HzDYoodCDBbwHzdR5UrLBZ3sOnUJmFoHo= -golang.org/x/net v0.29.0/go.mod h1:gLkgy8jTGERgjzMic6DS9+SP0ajcu6Xu3Orq/SpETg0= +golang.org/x/net v0.28.0 h1:a9JDOJc5GMUJ0+UDqmLT86WiEy7iWyIhz8gz8E4e5hE= +golang.org/x/net v0.28.0/go.mod h1:yqtgsTWOOnlGLG9GFRrK3++bGOUEkNBoHZc8MEDWPNg= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20181017192945-9dcd33a902f4/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20181203162652-d668ce993890/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= @@ -1658,8 +1654,8 @@ golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.16.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= -golang.org/x/sys v0.25.0 h1:r+8e+loiHxRqhXVl6ML1nO3l1+oFoWbnlu2Ehimmi34= -golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.23.0 h1:YfKFowiIMvtgl1UERQoTPPToxltDeZfbj4H7dVUCwmM= +golang.org/x/sys v0.23.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= @@ -1673,8 +1669,8 @@ golang.org/x/term v0.11.0/go.mod h1:zC9APTIj3jG3FdV/Ons+XE1riIZXG4aZ4GTHiPZJPIU= golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY= golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk= golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58= -golang.org/x/term v0.24.0 h1:Mh5cbb+Zk2hqqXNO7S1iTjEphVL+jb8ZWaqh/g+JWkM= -golang.org/x/term v0.24.0/go.mod h1:lOBK/LVxemqiMij05LGJ0tzNr8xlmwBRJ81PX6wVLH8= +golang.org/x/term v0.23.0 h1:F6D4vR+EHoL9/sWAWgAR1H2DcHr4PareCbAaCo1RpuU= +golang.org/x/term v0.23.0/go.mod h1:DgV24QBUrK6jhZXl+20l6UWznPlwAHm1Q1mGHtydmSk= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -1694,8 +1690,8 @@ golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxb golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/time v0.6.0 h1:eTDhh4ZXt5Qf0augr54TN6suAUudPcawVZeIAPU7D4U= -golang.org/x/time v0.6.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= +golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= +golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180828015842-6cd1fcedba52/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= @@ -1757,8 +1753,8 @@ golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8T golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da h1:noIWHXmPHxILtqtCOPIhSt0ABwskkZKjD3bXGnZGpNY= -golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= +golang.org/x/xerrors v0.0.0-20240716161551-93cc26a95ae9 h1:LLhsEBxRTBLuKlQxFBYUOU8xyFgXv6cOTp2HASDlsDk= +golang.org/x/xerrors v0.0.0-20240716161551-93cc26a95ae9/go.mod h1:NDW/Ps6MPRej6fsCIbMTohpP40sJ/P/vI1MoTEGwX90= gonum.org/v1/gonum v0.15.0 h1:2lYxjRbTYyxkJxlhC+LvJIx3SsANPdRybu1tGj9/OrQ= gonum.org/v1/gonum v0.15.0/go.mod h1:xzZVBJBtS+Mz4q0Yl2LJTk+OxOg4jiXZ7qBoM0uISGo= google.golang.org/api v0.0.0-20180910000450-7ca32eb868bf/go.mod h1:4mhQ8q/RsB7i+udVvVy5NUi08OU8ZlA0gRVgrF7VFY0= diff --git a/itests/kit/ensemble_opts_nv.go b/itests/kit/ensemble_opts_nv.go index 03239efe95a..758d8faafb8 100644 --- a/itests/kit/ensemble_opts_nv.go +++ b/itests/kit/ensemble_opts_nv.go @@ -35,12 +35,12 @@ func LatestActorsAt(upgradeHeight abi.ChainEpoch) EnsembleOpt { }) /* inline-gen start */ return UpgradeSchedule(stmgr.Upgrade{ - Network: network.Version22, + Network: network.Version23, Height: -1, }, stmgr.Upgrade{ - Network: network.Version23, + Network: network.Version24, Height: upgradeHeight, - Migration: filcns.UpgradeActorsV14, + Migration: filcns.UpgradeActorsV15, }) /* inline-gen end */ } diff --git a/itests/migration_test.go b/itests/migration_test.go index ddf997212d7..d6a8a962c9f 100644 --- a/itests/migration_test.go +++ b/itests/migration_test.go @@ -18,7 +18,7 @@ import ( miner11 "github.com/filecoin-project/go-state-types/builtin/v11/miner" power11 "github.com/filecoin-project/go-state-types/builtin/v11/power" adt11 "github.com/filecoin-project/go-state-types/builtin/v11/util/adt" - account "github.com/filecoin-project/go-state-types/builtin/v14/account" + account "github.com/filecoin-project/go-state-types/builtin/v15/account" markettypes "github.com/filecoin-project/go-state-types/builtin/v9/market" migration "github.com/filecoin-project/go-state-types/builtin/v9/migration/test" miner9 "github.com/filecoin-project/go-state-types/builtin/v9/miner" diff --git a/node/impl/full/state.go b/node/impl/full/state.go index 0c70d66a915..7f56c14912d 100644 --- a/node/impl/full/state.go +++ b/node/impl/full/state.go @@ -1964,6 +1964,7 @@ func (a *StateAPI) StateGetNetworkParams(ctx context.Context) (*api.NetworkParam UpgradeDragonHeight: buildconstants.UpgradeDragonHeight, UpgradePhoenixHeight: buildconstants.UpgradePhoenixHeight, UpgradeWaffleHeight: buildconstants.UpgradeWaffleHeight, + UpgradeTuktukHeight: buildconstants.UpgradeTuktukHeight, }, }, nil }