Merge pull request #2961 from filecoin-project/asr/genesis-premined

Revise TotalCircSupply

chain/gen/genesis/genesis.go

@@ -323,13 +323,13 @@ func VerifyPreSealedData(ctx context.Context, cs *store.ChainStore, stateroot ci
 	var sum abi.PaddedPieceSize
 
 	vmopt := vm.VMOpts{
-		StateBase:  stateroot,
+		StateBase:      stateroot,
-		Epoch:      0,
+		Epoch:          0,
-		Rand:       &fakeRand{},
+		Rand:           &fakeRand{},
-		Bstore:     cs.Blockstore(),
+		Bstore:         cs.Blockstore(),
-		Syscalls:   mkFakedSigSyscalls(cs.VMSys()),
+		Syscalls:       mkFakedSigSyscalls(cs.VMSys()),
-		VestedCalc: nil,
+		CircSupplyCalc: nil,
-		BaseFee:    types.NewInt(0),
+		BaseFee:        types.NewInt(0),
 	}
 	vm, err := vm.NewVM(&vmopt)
 	if err != nil {

chain/gen/genesis/miners.go

@@ -57,18 +57,18 @@ func mkFakedSigSyscalls(base vm.SyscallBuilder) vm.SyscallBuilder {
 }
 
 func SetupStorageMiners(ctx context.Context, cs *store.ChainStore, sroot cid.Cid, miners []genesis.Miner) (cid.Cid, error) {
-	vc := func(context.Context, abi.ChainEpoch) (abi.TokenAmount, error) {
+	csc := func(context.Context, abi.ChainEpoch, *state.StateTree) (abi.TokenAmount, error) {
 		return big.Zero(), nil
 	}
 
 	vmopt := &vm.VMOpts{
-		StateBase:  sroot,
+		StateBase:      sroot,
-		Epoch:      0,
+		Epoch:          0,
-		Rand:       &fakeRand{},
+		Rand:           &fakeRand{},
-		Bstore:     cs.Blockstore(),
+		Bstore:         cs.Blockstore(),
-		Syscalls:   mkFakedSigSyscalls(cs.VMSys()),
+		Syscalls:       mkFakedSigSyscalls(cs.VMSys()),
-		VestedCalc: vc,
+		CircSupplyCalc: csc,
-		BaseFee:    types.NewInt(0),
+		BaseFee:        types.NewInt(0),
 	}
 
 	vm, err := vm.NewVM(vmopt)

chain/stmgr/call.go

@@ -23,13 +23,13 @@ func (sm *StateManager) CallRaw(ctx context.Context, msg *types.Message, bstate
 	defer span.End()
 
 	vmopt := &vm.VMOpts{
-		StateBase:  bstate,
+		StateBase:      bstate,
-		Epoch:      bheight,
+		Epoch:          bheight,
-		Rand:       r,
+		Rand:           r,
-		Bstore:     sm.cs.Blockstore(),
+		Bstore:         sm.cs.Blockstore(),
-		Syscalls:   sm.cs.VMSys(),
+		Syscalls:       sm.cs.VMSys(),
-		VestedCalc: sm.GetVestedFunds,
+		CircSupplyCalc: sm.GetCirculatingSupply,
-		BaseFee:    types.NewInt(0),
+		BaseFee:        types.NewInt(0),
 	}
 
 	vmi, err := vm.NewVM(vmopt)
@@ -124,13 +124,13 @@ func (sm *StateManager) CallWithGas(ctx context.Context, msg *types.Message, pri
 	}
 
 	vmopt := &vm.VMOpts{
-		StateBase:  state,
+		StateBase:      state,
-		Epoch:      ts.Height() + 1,
+		Epoch:          ts.Height() + 1,
-		Rand:       r,
+		Rand:           r,
-		Bstore:     sm.cs.Blockstore(),
+		Bstore:         sm.cs.Blockstore(),
-		Syscalls:   sm.cs.VMSys(),
+		Syscalls:       sm.cs.VMSys(),
-		VestedCalc: sm.GetVestedFunds,
+		CircSupplyCalc: sm.GetCirculatingSupply,
-		BaseFee:    ts.Blocks()[0].ParentBaseFee,
+		BaseFee:        ts.Blocks()[0].ParentBaseFee,
 	}
 	vmi, err := vm.NewVM(vmopt)
 	if err != nil {

chain/stmgr/stmgr.go

@@ -3,6 +3,7 @@ package stmgr
 import (
 	"context"
 	"fmt"
+	"github.com/filecoin-project/specs-actors/actors/builtin/power"
 	"sync"
 
 	"github.com/filecoin-project/specs-actors/actors/builtin/multisig"
@@ -42,7 +43,7 @@ type StateManager struct {
 	stlk          sync.Mutex
 	genesisMsigLk sync.Mutex
 	newVM         func(*vm.VMOpts) (*vm.VM, error)
-	genesisMsigs  []multisig.State
+	genInfo       *genesisInfo
 }
 
 func NewStateManager(cs *store.ChainStore) *StateManager {
@@ -146,13 +147,13 @@ type ExecCallback func(cid.Cid, *types.Message, *vm.ApplyRet) error
 func (sm *StateManager) ApplyBlocks(ctx context.Context, parentEpoch abi.ChainEpoch, pstate cid.Cid, bms []store.BlockMessages, epoch abi.ChainEpoch, r vm.Rand, cb ExecCallback, baseFee abi.TokenAmount) (cid.Cid, cid.Cid, error) {
 
 	vmopt := &vm.VMOpts{
-		StateBase:  pstate,
+		StateBase:      pstate,
-		Epoch:      epoch,
+		Epoch:          epoch,
-		Rand:       r,
+		Rand:           r,
-		Bstore:     sm.cs.Blockstore(),
+		Bstore:         sm.cs.Blockstore(),
-		Syscalls:   sm.cs.VMSys(),
+		Syscalls:       sm.cs.VMSys(),
-		VestedCalc: sm.GetVestedFunds,
+		CircSupplyCalc: sm.GetCirculatingSupply,
-		BaseFee:    baseFee,
+		BaseFee:        baseFee,
 	}
 
 	vmi, err := sm.newVM(vmopt)
@@ -773,12 +774,24 @@ func (sm *StateManager) SetVMConstructor(nvm func(*vm.VMOpts) (*vm.VM, error)) {
 	sm.newVM = nvm
 }
 
-type GenesisMsigEntry struct {
+type genesisInfo struct {
-	totalFunds abi.TokenAmount
+	genesisMsigs []multisig.State
-	unitVest   abi.TokenAmount
+	// info about the Accounts in the genesis state
+	genesisActors      []genesisActor
+	genesisPledge      abi.TokenAmount
+	genesisMarketFunds abi.TokenAmount
 }
 
-func (sm *StateManager) setupGenesisMsigs(ctx context.Context) error {
+type genesisActor struct {
+	addr    address.Address
+	initBal abi.TokenAmount
+}
+
+// sets up information about the non-multisig actors in the genesis state
+func (sm *StateManager) setupGenesisActors(ctx context.Context) error {
+
+	gi := genesisInfo{}
+
 	gb, err := sm.cs.GetGenesis()
 	if err != nil {
 		return xerrors.Errorf("getting genesis block: %w", err)
@@ -794,6 +807,22 @@ func (sm *StateManager) setupGenesisMsigs(ctx context.Context) error {
 		return xerrors.Errorf("getting genesis tipset state: %w", err)
 	}
 
+	cst := cbor.NewCborStore(sm.cs.Blockstore())
+	sTree, err := state.LoadStateTree(cst, st)
+	if err != nil {
+		return xerrors.Errorf("loading state tree: %w", err)
+	}
+
+	gi.genesisMarketFunds, err = getFilMarketLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis market funds: %w", err)
+	}
+
+	gi.genesisPledge, err = getFilPowerLocked(ctx, sTree)
+	if err != nil {
+		return xerrors.Errorf("setting up genesis pledge: %w", err)
+	}
+
 	r, err := adt.AsMap(sm.cs.Store(ctx), st)
 	if err != nil {
 		return xerrors.Errorf("getting genesis actors: %w", err)
@@ -820,40 +849,178 @@ func (sm *StateManager) setupGenesisMsigs(ctx context.Context) error {
 				totalsByEpoch[s.UnlockDuration] = s.InitialBalance
 			}
 
+		} else if act.Code == builtin.AccountActorCodeID {
+			// should only ever be "faucet" accounts in testnets
+			kaddr, err := address.NewFromBytes([]byte(k))
+			if err != nil {
+				return xerrors.Errorf("decoding address: %w", err)
+			}
+
+			kid, err := sTree.LookupID(kaddr)
+			if err != nil {
+				return xerrors.Errorf("resolving address: %w", err)
+			}
+
+			gi.genesisActors = append(gi.genesisActors, genesisActor{
+				addr:    kid,
+				initBal: act.Balance,
+			})
 		}
 		return nil
 	})
 
 	if err != nil {
-		return xerrors.Errorf("error setting up composite genesis multisigs: %w", err)
+		return xerrors.Errorf("error setting up genesis infos: %w", err)
 	}
 
-	sm.genesisMsigs = make([]multisig.State, 0, len(totalsByEpoch))
+	gi.genesisMsigs = make([]multisig.State, 0, len(totalsByEpoch))
 	for k, v := range totalsByEpoch {
 		ns := multisig.State{
 			InitialBalance: v,
 			UnlockDuration: k,
 			PendingTxns:    cid.Undef,
 		}
-		sm.genesisMsigs = append(sm.genesisMsigs, ns)
+		gi.genesisMsigs = append(gi.genesisMsigs, ns)
 	}
 
+	sm.genInfo = &gi
+
 	return nil
 }
 
-func (sm *StateManager) GetVestedFunds(ctx context.Context, height abi.ChainEpoch) (abi.TokenAmount, error) {
+// GetVestedFunds returns all funds that have "left" actors that are in the genesis state:
-	sm.genesisMsigLk.Lock()
+// - For Multisigs, it counts the actual amounts that have vested at the given epoch
-	defer sm.genesisMsigLk.Unlock()
+// - For Accounts, it counts max(currentBalance - genesisBalance, 0).
-	if sm.genesisMsigs == nil {
+func (sm *StateManager) GetFilVested(ctx context.Context, height abi.ChainEpoch, st *state.StateTree) (abi.TokenAmount, error) {
-		err := sm.setupGenesisMsigs(ctx)
-		if err != nil {
-			return big.Zero(), xerrors.Errorf("failed to setup genesis msig entries: %w", err)
-		}
-	}
 	vf := big.Zero()
-	for _, v := range sm.genesisMsigs {
+	for _, v := range sm.genInfo.genesisMsigs {
 		au := big.Sub(v.InitialBalance, v.AmountLocked(height))
 		vf = big.Add(vf, au)
 	}
+
+	// these should only ever be "faucet" accounts in testnets
+	for _, v := range sm.genInfo.genesisActors {
+		act, err := st.GetActor(v.addr)
+		if err != nil {
+			return big.Zero(), xerrors.Errorf("failed to get actor: %w", err)
+		}
+
+		diff := big.Sub(v.initBal, act.Balance)
+		if diff.GreaterThan(big.Zero()) {
+			vf = big.Add(vf, diff)
+		}
+	}
+
+	vf = big.Add(vf, sm.genInfo.genesisPledge)
+	vf = big.Add(vf, sm.genInfo.genesisMarketFunds)
+
 	return vf, nil
 }
+
+func GetFilMined(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
+	ractor, err := st.GetActor(builtin.RewardActorAddr)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to load reward actor state: %w", err)
+	}
+
+	var rst reward.State
+	if err := st.Store.Get(ctx, ractor.Head, &rst); err != nil {
+		return big.Zero(), xerrors.Errorf("failed to load reward state: %w", err)
+	}
+
+	return rst.TotalMined, nil
+}
+
+func getFilMarketLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
+	mactor, err := st.GetActor(builtin.StorageMarketActorAddr)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to load market actor: %w", err)
+	}
+
+	var mst market.State
+	if err := st.Store.Get(ctx, mactor.Head, &mst); err != nil {
+		return big.Zero(), xerrors.Errorf("failed to load market state: %w", err)
+	}
+
+	fml := types.BigAdd(mst.TotalClientLockedCollateral, mst.TotalProviderLockedCollateral)
+	fml = types.BigAdd(fml, mst.TotalClientStorageFee)
+	return fml, nil
+}
+
+func getFilPowerLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
+	pactor, err := st.GetActor(builtin.StoragePowerActorAddr)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to load power actor: %w", err)
+	}
+
+	var pst power.State
+	if err := st.Store.Get(ctx, pactor.Head, &pst); err != nil {
+		return big.Zero(), xerrors.Errorf("failed to load power state: %w", err)
+	}
+	return pst.TotalPledgeCollateral, nil
+}
+
+func (sm *StateManager) GetFilLocked(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
+
+	filMarketLocked, err := getFilMarketLocked(ctx, st)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to get filMarketLocked: %w", err)
+	}
+
+	filPowerLocked, err := getFilPowerLocked(ctx, st)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to get filPowerLocked: %w", err)
+	}
+
+	return types.BigAdd(filMarketLocked, filPowerLocked), nil
+}
+
+func GetFilBurnt(ctx context.Context, st *state.StateTree) (abi.TokenAmount, error) {
+	burnt, err := st.GetActor(builtin.BurntFundsActorAddr)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to load burnt actor: %w", err)
+	}
+
+	return burnt.Balance, nil
+}
+
+func (sm *StateManager) GetCirculatingSupply(ctx context.Context, height abi.ChainEpoch, st *state.StateTree) (abi.TokenAmount, error) {
+	sm.genesisMsigLk.Lock()
+	defer sm.genesisMsigLk.Unlock()
+	if sm.genInfo == nil {
+		err := sm.setupGenesisActors(ctx)
+		if err != nil {
+			return big.Zero(), xerrors.Errorf("failed to setup genesis information: %w", err)
+		}
+	}
+
+	filVested, err := sm.GetFilVested(ctx, height, st)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to calculate filVested: %w", err)
+	}
+
+	filMined, err := GetFilMined(ctx, st)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to calculate filMined: %w", err)
+	}
+
+	filBurnt, err := GetFilBurnt(ctx, st)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to calculate filBurnt: %w", err)
+	}
+
+	filLocked, err := sm.GetFilLocked(ctx, st)
+	if err != nil {
+		return big.Zero(), xerrors.Errorf("failed to calculate filLocked: %w", err)
+	}
+
+	ret := types.BigAdd(filVested, filMined)
+	ret = types.BigSub(ret, filBurnt)
+	ret = types.BigSub(ret, filLocked)
+
+	if ret.LessThan(big.Zero()) {
+		ret = big.Zero()
+	}
+
+	return ret, nil
+}

chain/stmgr/utils.go

@@ -15,7 +15,6 @@ import (
 	"github.com/filecoin-project/go-bitfield"
 	"github.com/filecoin-project/sector-storage/ffiwrapper"
 	"github.com/filecoin-project/specs-actors/actors/abi"
-	"github.com/filecoin-project/specs-actors/actors/abi/big"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
 	"github.com/filecoin-project/specs-actors/actors/builtin/account"
 	"github.com/filecoin-project/specs-actors/actors/builtin/cron"
@@ -441,13 +440,13 @@ func ComputeState(ctx context.Context, sm *StateManager, height abi.ChainEpoch,
 
 	r := store.NewChainRand(sm.cs, ts.Cids(), height)
 	vmopt := &vm.VMOpts{
-		StateBase:  base,
+		StateBase:      base,
-		Epoch:      height,
+		Epoch:          height,
-		Rand:       r,
+		Rand:           r,
-		Bstore:     sm.cs.Blockstore(),
+		Bstore:         sm.cs.Blockstore(),
-		Syscalls:   sm.cs.VMSys(),
+		Syscalls:       sm.cs.VMSys(),
-		VestedCalc: sm.GetVestedFunds,
+		CircSupplyCalc: sm.GetCirculatingSupply,
-		BaseFee:    ts.Blocks()[0].ParentBaseFee,
+		BaseFee:        ts.Blocks()[0].ParentBaseFee,
 	}
 	vmi, err := vm.NewVM(vmopt)
 	if err != nil {
@@ -593,40 +592,6 @@ func MinerGetBaseInfo(ctx context.Context, sm *StateManager, bcn beacon.RandomBe
 	}, nil
 }
 
-func (sm *StateManager) CirculatingSupply(ctx context.Context, ts *types.TipSet) (abi.TokenAmount, error) {
-	if ts == nil {
-		ts = sm.cs.GetHeaviestTipSet()
-	}
-
-	st, _, err := sm.TipSetState(ctx, ts)
-	if err != nil {
-		return big.Zero(), err
-	}
-
-	r := store.NewChainRand(sm.cs, ts.Cids(), ts.Height())
-	vmopt := &vm.VMOpts{
-		StateBase:  st,
-		Epoch:      ts.Height(),
-		Rand:       r,
-		Bstore:     sm.cs.Blockstore(),
-		Syscalls:   sm.cs.VMSys(),
-		VestedCalc: sm.GetVestedFunds,
-		BaseFee:    ts.Blocks()[0].ParentBaseFee,
-	}
-	vmi, err := vm.NewVM(vmopt)
-	if err != nil {
-		return big.Zero(), err
-	}
-
-	unsafeVM := &vm.UnsafeVM{VM: vmi}
-	rt := unsafeVM.MakeRuntime(ctx, &types.Message{
-		GasLimit: 100e6,
-		From:     builtin.SystemActorAddr,
-	}, builtin.SystemActorAddr, 0, 0, 0)
-
-	return rt.TotalFilCircSupply(), nil
-}
-
 type methodMeta struct {
 	Name string
 
@@ -693,30 +658,3 @@ func MinerHasMinPower(ctx context.Context, sm *StateManager, addr address.Addres
 
 	return ps.MinerNominalPowerMeetsConsensusMinimum(sm.ChainStore().Store(ctx), addr)
 }
-
-func GetCirculatingSupply(ctx context.Context, sm *StateManager, ts *types.TipSet) (abi.TokenAmount, error) {
-	if ts == nil {
-		ts = sm.cs.GetHeaviestTipSet()
-	}
-
-	r := store.NewChainRand(sm.cs, ts.Cids(), ts.Height())
-	vmopt := &vm.VMOpts{
-		StateBase:  ts.ParentState(),
-		Epoch:      ts.Height(),
-		Rand:       r,
-		Bstore:     sm.cs.Blockstore(),
-		Syscalls:   sm.cs.VMSys(),
-		VestedCalc: sm.GetVestedFunds,
-		BaseFee:    ts.Blocks()[0].ParentBaseFee,
-	}
-	vmi, err := vm.NewVM(vmopt)
-	if err != nil {
-		return abi.NewTokenAmount(0), err
-	}
-
-	uvm := &vm.UnsafeVM{vmi}
-
-	rt := uvm.MakeRuntime(ctx, &types.Message{From: builtin.InitActorAddr, GasLimit: 10000000}, builtin.InitActorAddr, 0, 0, 0)
-
-	return rt.TotalFilCircSupply(), nil
-}

chain/validation/applier.go

@@ -148,13 +148,13 @@ func (a *Applier) applyMessage(epoch abi.ChainEpoch, lm types.ChainMsg) (vtypes.
 	base := a.stateWrapper.Root()
 
 	vmopt := &vm.VMOpts{
-		StateBase:  base,
+		StateBase:      base,
-		Epoch:      epoch,
+		Epoch:          epoch,
-		Rand:       &vmRand{},
+		Rand:           &vmRand{},
-		Bstore:     a.stateWrapper.bs,
+		Bstore:         a.stateWrapper.bs,
-		Syscalls:   a.syscalls,
+		Syscalls:       a.syscalls,
-		VestedCalc: nil,
+		CircSupplyCalc: nil,
-		BaseFee:    abi.NewTokenAmount(100),
+		BaseFee:        abi.NewTokenAmount(100),
 	}
 
 	lotusVM, err := vm.NewVM(vmopt)

chain/vm/runtime.go

@@ -8,13 +8,10 @@ import (
 	gruntime "runtime"
 	"time"
 
-	samarket "github.com/filecoin-project/specs-actors/actors/builtin/market"
-
 	"github.com/filecoin-project/go-address"
 	"github.com/filecoin-project/specs-actors/actors/abi"
 	"github.com/filecoin-project/specs-actors/actors/abi/big"
 	"github.com/filecoin-project/specs-actors/actors/builtin"
-	sapower "github.com/filecoin-project/specs-actors/actors/builtin/power"
 	"github.com/filecoin-project/specs-actors/actors/crypto"
 	"github.com/filecoin-project/specs-actors/actors/runtime"
 	vmr "github.com/filecoin-project/specs-actors/actors/runtime"
@@ -61,62 +58,12 @@ type Runtime struct {
 }
 
 func (rt *Runtime) TotalFilCircSupply() abi.TokenAmount {
-
+	cs, err := rt.vm.GetCircSupply(rt.ctx)
-	filVested, err := rt.vm.GetVestedFunds(rt.ctx)
 	if err != nil {
-		rt.Abortf(exitcode.ErrIllegalState, "failed to get vested funds for computing total supply: %s", err)
+		rt.Abortf(exitcode.ErrIllegalState, "failed to get total circ supply: %s", err)
 	}
 
-	rew, err := rt.state.GetActor(builtin.RewardActorAddr)
+	return cs
-	if err != nil {
-		rt.Abortf(exitcode.ErrIllegalState, "failed to get reward actor for computing total supply: %s", err)
-	}
-
-	filMined := types.BigSub(types.FromFil(build.FilAllocStorageMining), rew.Balance)
-	if filMined.LessThan(big.Zero()) {
-		filMined = big.Zero()
-	}
-
-	burnt, err := rt.state.GetActor(builtin.BurntFundsActorAddr)
-	if err != nil {
-		rt.Abortf(exitcode.ErrIllegalState, "failed to get reward actor for computing total supply: %s", err)
-	}
-
-	filBurned := burnt.Balance
-
-	market, err := rt.state.GetActor(builtin.StorageMarketActorAddr)
-	if err != nil {
-		rt.Abortf(exitcode.ErrIllegalState, "failed to get reward actor for computing total supply: %s", err)
-	}
-
-	var mst samarket.State
-	if err := rt.cst.Get(rt.ctx, market.Head, &mst); err != nil {
-		rt.Abortf(exitcode.ErrIllegalState, "failed to get market state: %s", err)
-	}
-
-	filMarketLocked := types.BigAdd(mst.TotalClientLockedCollateral, mst.TotalProviderLockedCollateral)
-	filMarketLocked = types.BigAdd(filMarketLocked, mst.TotalClientStorageFee)
-
-	power, err := rt.state.GetActor(builtin.StoragePowerActorAddr)
-	if err != nil {
-		rt.Abortf(exitcode.ErrIllegalState, "failed to get reward actor for computing total supply: %s", err)
-	}
-
-	var pst sapower.State
-	if err := rt.cst.Get(rt.ctx, power.Head, &pst); err != nil {
-		rt.Abortf(exitcode.ErrIllegalState, "failed to get storage power state: %s", err)
-	}
-
-	filLocked := types.BigAdd(filMarketLocked, pst.TotalPledgeCollateral)
-
-	ret := types.BigAdd(filVested, filMined)
-	ret = types.BigSub(ret, filBurned)
-	ret = types.BigSub(ret, filLocked)
-
-	if ret.LessThan(big.Zero()) {
-		ret = big.Zero()
-	}
-	return ret
 }
 
 func (rt *Runtime) ResolveAddress(addr address.Address) (ret address.Address, ok bool) {

chain/vm/vm.go

@@ -140,30 +140,30 @@ func (vm *UnsafeVM) MakeRuntime(ctx context.Context, msg *types.Message, origin
 	return vm.VM.makeRuntime(ctx, msg, origin, originNonce, usedGas, nac)
 }
 
-type VestedCalculator func(context.Context, abi.ChainEpoch) (abi.TokenAmount, error)
+type CircSupplyCalculator func(context.Context, abi.ChainEpoch, *state.StateTree) (abi.TokenAmount, error)
 
 type VM struct {
-	cstate      *state.StateTree
+	cstate         *state.StateTree
-	base        cid.Cid
+	base           cid.Cid
-	cst         *cbor.BasicIpldStore
+	cst            *cbor.BasicIpldStore
-	buf         *bufbstore.BufferedBS
+	buf            *bufbstore.BufferedBS
-	blockHeight abi.ChainEpoch
+	blockHeight    abi.ChainEpoch
-	inv         *Invoker
+	inv            *Invoker
-	rand        Rand
+	rand           Rand
-	vc          VestedCalculator
+	circSupplyCalc CircSupplyCalculator
-	baseFee     abi.TokenAmount
+	baseFee        abi.TokenAmount
 
 	Syscalls SyscallBuilder
 }
 
 type VMOpts struct {
-	StateBase  cid.Cid
+	StateBase      cid.Cid
-	Epoch      abi.ChainEpoch
+	Epoch          abi.ChainEpoch
-	Rand       Rand
+	Rand           Rand
-	Bstore     bstore.Blockstore
+	Bstore         bstore.Blockstore
-	Syscalls   SyscallBuilder
+	Syscalls       SyscallBuilder
-	VestedCalc VestedCalculator
+	CircSupplyCalc CircSupplyCalculator
-	BaseFee    abi.TokenAmount
+	BaseFee        abi.TokenAmount
 }
 
 func NewVM(opts *VMOpts) (*VM, error) {
@@ -175,16 +175,16 @@ func NewVM(opts *VMOpts) (*VM, error) {
 	}
 
 	return &VM{
-		cstate:      state,
+		cstate:         state,
-		base:        opts.StateBase,
+		base:           opts.StateBase,
-		cst:         cst,
+		cst:            cst,
-		buf:         buf,
+		buf:            buf,
-		blockHeight: opts.Epoch,
+		blockHeight:    opts.Epoch,
-		inv:         NewInvoker(),
+		inv:            NewInvoker(),
-		rand:        opts.Rand, // TODO: Probably should be a syscall
+		rand:           opts.Rand, // TODO: Probably should be a syscall
-		vc:          opts.VestedCalc,
+		circSupplyCalc: opts.CircSupplyCalc,
-		Syscalls:    opts.Syscalls,
+		Syscalls:       opts.Syscalls,
-		baseFee:     opts.BaseFee,
+		baseFee:        opts.BaseFee,
 	}, nil
 }
 
@@ -714,8 +714,8 @@ func (vm *VM) SetInvoker(i *Invoker) {
 	vm.inv = i
 }
 
-func (vm *VM) GetVestedFunds(ctx context.Context) (abi.TokenAmount, error) {
+func (vm *VM) GetCircSupply(ctx context.Context) (abi.TokenAmount, error) {
-	return vm.vc(ctx, vm.blockHeight)
+	return vm.circSupplyCalc(ctx, vm.blockHeight, vm.cstate)
 }
 
 func (vm *VM) incrementNonce(addr address.Address) error {

node/impl/full/state.go

@@ -1071,7 +1071,7 @@ func (a *StateAPI) StateMinerInitialPledgeCollateral(ctx context.Context, maddr
 
 	duration := pci.Expiration - ts.Height() // NB: not exactly accurate, but should always lead us to *over* estimate, not under
 
-	circSupply, err := a.StateManager.CirculatingSupply(ctx, ts)
+	circSupply, err := a.StateCirculatingSupply(ctx, ts.Key())
 	if err != nil {
 		return big.Zero(), xerrors.Errorf("getting circulating supply: %w", err)
 	}
@@ -1175,7 +1175,7 @@ func (a *StateAPI) StateDealProviderCollateralBounds(ctx context.Context, size a
 		return api.DealCollateralBounds{}, xerrors.Errorf("getting power and reward actor states: %w")
 	}
 
-	circ, err := a.StateManager.CirculatingSupply(ctx, ts)
+	circ, err := a.StateCirculatingSupply(ctx, ts.Key())
 	if err != nil {
 		return api.DealCollateralBounds{}, xerrors.Errorf("getting total circulating supply: %w")
 	}
@@ -1193,5 +1193,13 @@ func (a *StateAPI) StateCirculatingSupply(ctx context.Context, tsk types.TipSetK
 		return abi.TokenAmount{}, xerrors.Errorf("loading tipset %s: %w", tsk, err)
 	}
 
-	return stmgr.GetCirculatingSupply(ctx, a.StateManager, ts)
+	st, _, err := a.StateManager.TipSetState(ctx, ts)
+	if err != nil {
+		return big.Zero(), err
+	}
+
+	cst := cbor.NewCborStore(a.Chain.Blockstore())
+	sTree, err := state.LoadStateTree(cst, st)
+
+	return a.StateManager.GetCirculatingSupply(ctx, ts.Height(), sTree)
 }