cerc-io/lotus
16
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 27 Wiki Activity

update to work with chain-validation refactor

Browse Source
This commit is contained in:
frrist 2019-11-26 13:58:43 -08:00
parent b8646405ce
commit e1e295d47b
8 changed files with 171 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
chain/validation/applier.go
View File

@ -5,6 +5,7 @@ import (
vchain "github.com/filecoin-project/chain-validation/pkg/chain"
vstate "github.com/filecoin-project/chain-validation/pkg/state"
vtypes "github.com/filecoin-project/chain-validation/pkg/state/types"
"github.com/filecoin-project/lotus/chain/address"
"github.com/filecoin-project/lotus/chain/types"
@ -27,7 +28,7 @@ func (a *Applier) ApplyMessage(eCtx *vchain.ExecutionContext, state vstate.Wrapp
base := st.Cid()
randSrc := &vmRand{eCtx}
minerAddr, err := address.NewFromBytes([]byte(eCtx.MinerOwner))
minerAddr, err := address.NewFromBytes(eCtx.MinerOwner.Bytes())
if err != nil {
return vchain.MessageReceipt{}, err
}
@ -49,10 +50,10 @@ func (a *Applier) ApplyMessage(eCtx *vchain.ExecutionContext, state vstate.Wrapp
mr := vchain.MessageReceipt{
ExitCode: ret.ExitCode,
ReturnValue: ret.Return,
GasUsed: vstate.GasUnit(ret.GasUsed.Uint64()),
GasUsed: vtypes.GasUnit(ret.GasUsed.Uint64()),
}
return mr, nil
return mr, ret.ActorErr
}
type vmRand struct {

117
chain/validation/lotus_test.go
View File

@ -1,117 +0,0 @@
package validation
import (
"encoding/binary"
"math/big"
"testing"
"github.com/libp2p/go-libp2p-core/peer"
mh "github.com/multiformats/go-multihash"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/filecoin-project/chain-validation/pkg/state"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/address"
)
//
// some helpers tests to verify chain-validation can encode parameters to the CBOR lotus uses
//
func TestCBOREncodingCreateStorageMiner(t *testing.T) {
oAddr, err := state.NewActorAddress([]byte("foobar"))
require.NoError(t, err)
ownerAddr := newTestAddressWrapper(oAddr)
wAddr, err := state.NewActorAddress([]byte("barfoo"))
require.NoError(t, err)
workerAddr := newTestAddressWrapper(wAddr)
lotusPeer := RequireIntPeerID(t, 1)
bpid, err := lotusPeer.MarshalBinary()
require.NoError(t, err)
peerID := state.PeerID(bpid)
lotusSectorSize := uint64(1)
sectorSize := state.BytesAmount(big.NewInt(int64(lotusSectorSize)))
lotusParams := actors.StorageMinerConstructorParams{
Owner: ownerAddr.lotusAddr,
Worker: workerAddr.lotusAddr,
SectorSize: lotusSectorSize,
PeerID: lotusPeer,
}
lotusBytes, err := actors.SerializeParams(&lotusParams)
require.NoError(t, err)
specParams := []interface{}{ownerAddr.testAddr, workerAddr.testAddr, sectorSize, peerID}
specBytes, err := state.EncodeValues(specParams...)
require.NoError(t, err)
assert.Equal(t, specBytes, lotusBytes)
}
func TestCBOREncodingPeerID(t *testing.T) {
lotusPeer := RequireIntPeerID(t, 1)
bpid, err := lotusPeer.MarshalBinary()
require.NoError(t, err)
peerID := state.PeerID(bpid)
lotusParams := actors.UpdatePeerIDParams{
PeerID: lotusPeer,
}
lotusBytes, err := actors.SerializeParams(&lotusParams)
require.NoError(t, err)
specParams := []interface{}{peerID}
specBytes, err := state.EncodeValues(specParams...)
require.NoError(t, err)
assert.Equal(t, specBytes, lotusBytes)
}
func TestCBOREncodingUint64(t *testing.T) {
lotusSectorSize := uint64(1)
sectorSize := state.BytesAmount(big.NewInt(int64(lotusSectorSize)))
lotusParams := actors.MultiSigChangeReqParams{Req: lotusSectorSize}
lotusBytes, aerr := actors.SerializeParams(&lotusParams)
require.NoError(t, aerr)
specParams := []interface{}{sectorSize}
specBytes, err := state.EncodeValues(specParams...)
require.NoError(t, err)
assert.Equal(t, specBytes, lotusBytes)
}
type testAddressWrapper struct {
lotusAddr address.Address
testAddr state.Address
}
func newTestAddressWrapper(addr state.Address) *testAddressWrapper {
la, err := address.NewFromBytes([]byte(addr))
if err != nil {
panic(err)
}
return &testAddressWrapper{
lotusAddr: la,
testAddr: addr,
}
}
// RequireIntPeerID takes in an integer and creates a unique peer id for it.
func RequireIntPeerID(t testing.TB, i int64) peer.ID {
buf := make([]byte, 16)
n := binary.PutVarint(buf, i)
h, err := mh.Sum(buf[:n], mh.ID, -1)
require.NoError(t, err)
pid, err := peer.IDFromBytes(h)
require.NoError(t, err)
return pid
}

60
chain/validation/message.go
View File

@ -3,43 +3,43 @@ package validation
import (
"context"
"github.com/ipfs/go-cid"
"golang.org/x/xerrors"
vchain "github.com/filecoin-project/chain-validation/pkg/chain"
vactors "github.com/filecoin-project/chain-validation/pkg/state/actors"
vaddress "github.com/filecoin-project/chain-validation/pkg/state/address"
vtypes "github.com/filecoin-project/chain-validation/pkg/state/types"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/address"
"github.com/filecoin-project/lotus/chain/types"
"golang.org/x/xerrors"
"github.com/filecoin-project/chain-validation/pkg/chain"
"github.com/filecoin-project/chain-validation/pkg/state"
)
type Signer interface {
Sign(ctx context.Context, addr address.Address, msg []byte) (*types.Signature, error)
Sign(ctx context.Context, addr vaddress.Address, msg []byte) (*types.Signature, error)
}
type MessageFactory struct {
signer Signer
}
var _ chain.MessageFactory = &MessageFactory{}
var _ vchain.MessageFactory = &MessageFactory{}
func NewMessageFactory(signer Signer) *MessageFactory {
return &MessageFactory{signer}
}
func (mf *MessageFactory) MakeMessage(from, to state.Address, method chain.MethodID, nonce uint64, value, gasPrice state.AttoFIL, gasLimit state.GasUnit, params ...interface{}) (interface{}, error) {
fromDec, err := address.NewFromBytes([]byte(from))
func (mf *MessageFactory) MakeMessage(from, to vaddress.Address, method vchain.MethodID, nonce uint64, value, gasPrice vtypes.BigInt, gasLimit vtypes.GasUnit, params []byte) (interface{}, error) {
fromDec, err := address.NewFromBytes(from.Bytes())
if err != nil {
return nil, err
}
toDec, err := address.NewFromBytes([]byte(to))
if err != nil {
return nil, err
}
valueDec := types.BigInt{value}
paramsDec, err := state.EncodeValues(params...)
toDec, err := address.NewFromBytes(to.Bytes())
if err != nil {
return nil, err
}
valueDec := types.BigInt{value.Int}
if int(method) >= len(methods) {
return nil, xerrors.Errorf("No method name for method %v", method)
@ -50,34 +50,38 @@ func (mf *MessageFactory) MakeMessage(from, to state.Address, method chain.Metho
fromDec,
nonce,
valueDec,
types.BigInt{gasPrice},
types.BigInt{gasPrice.Int},
types.NewInt(uint64(gasLimit)),
methodId,
paramsDec,
params,
}
return msg, nil
}
func (mf *MessageFactory) FromSingletonAddress(addr state.SingletonActorID) state.Address {
func (mf *MessageFactory) FromSingletonAddress(addr vactors.SingletonActorID) vaddress.Address {
return fromSingletonAddress(addr)
}
func (mf *MessageFactory) FromActorCodeCid(code vactors.ActorCodeID) cid.Cid {
return fromActorCode(code)
}
// Maps method enumeration values to method names.
// This will change to a mapping to method ids when method dispatch is updated to use integers.
var methods = []uint64{
chain.NoMethod: 0,
chain.InitExec: actors.IAMethods.Exec,
vchain.NoMethod: 0,
vchain.InitExec: actors.IAMethods.Exec,
chain.StoragePowerConstructor: actors.SPAMethods.Constructor,
chain.StoragePowerCreateStorageMiner: actors.SPAMethods.CreateStorageMiner,
chain.StoragePowerUpdatePower: actors.SPAMethods.UpdateStorage,
vchain.StoragePowerConstructor: actors.SPAMethods.Constructor,
vchain.StoragePowerCreateStorageMiner: actors.SPAMethods.CreateStorageMiner,
vchain.StoragePowerUpdatePower: actors.SPAMethods.UpdateStorage,
chain.StorageMinerUpdatePeerID: actors.MAMethods.UpdatePeerID,
chain.StorageMinerGetOwner: actors.MAMethods.GetOwner,
chain.StorageMinerGetPower: actors.MAMethods.GetPower,
chain.StorageMinerGetWorkerAddr: actors.MAMethods.GetWorkerAddr,
chain.StorageMinerGetPeerID: actors.MAMethods.GetPeerID,
chain.StorageMinerGetSectorSize: actors.MAMethods.GetSectorSize,
vchain.StorageMinerUpdatePeerID: actors.MAMethods.UpdatePeerID,
vchain.StorageMinerGetOwner: actors.MAMethods.GetOwner,
vchain.StorageMinerGetPower: actors.MAMethods.GetPower,
vchain.StorageMinerGetWorkerAddr: actors.MAMethods.GetWorkerAddr,
vchain.StorageMinerGetPeerID: actors.MAMethods.GetPeerID,
vchain.StorageMinerGetSectorSize: actors.MAMethods.GetSectorSize,
// More to follow...
}

36
chain/validation/message_test.go
View File

@ -1,15 +1,19 @@
package validation
import (
"math/big"
"context"
"testing"
"github.com/filecoin-project/chain-validation/pkg/chain"
"github.com/filecoin-project/chain-validation/pkg/state"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
vchain "github.com/filecoin-project/chain-validation/pkg/chain"
vactors "github.com/filecoin-project/chain-validation/pkg/state/actors"
vaddress "github.com/filecoin-project/chain-validation/pkg/state/address"
vtypes "github.com/filecoin-project/chain-validation/pkg/state/types"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/address"
"github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/lotus/chain/wallet"
)
@ -18,17 +22,19 @@ func TestMessageFactory(t *testing.T) {
ks := wallet.NewMemKeyStore()
wallet, err := wallet.NewWallet(ks)
require.NoError(t, err)
factory := NewMessageFactory(wallet)
factory := NewMessageFactory(&walletWrapper{wallet})
gasPrice := big.NewInt(1)
gasLimit := state.GasUnit(1000)
p := chain.NewMessageProducer(factory, gasLimit, gasPrice)
gasPrice := vtypes.NewInt(1)
gasLimit := vtypes.GasUnit(1000)
p := vchain.NewMessageProducer(factory, gasLimit, gasPrice)
sender, err := wallet.GenerateKey(types.KTSecp256k1)
require.NoError(t, err)
bfAddr := factory.FromSingletonAddress(state.BurntFundsAddress)
m, err := p.Transfer(state.Address(sender.Bytes()), bfAddr, 0, 1)
bfAddr := factory.FromSingletonAddress(vactors.BurntFundsAddress)
addr, err := vaddress.NewFromBytes(sender.Bytes())
require.NoError(t, err)
m, err := p.Transfer(addr, bfAddr, 0, 1)
require.NoError(t, err)
messages := p.Messages()
@ -39,3 +45,15 @@ func TestMessageFactory(t *testing.T) {
assert.Equal(t, actors.BurntFundsAddress, msg.To)
assert.Equal(t, types.NewInt(1), msg.Value)
}
type walletWrapper struct {
w *wallet.Wallet
}
func (ww *walletWrapper) Sign(ctx context.Context, vaddr vaddress.Address, msg []byte) (*types.Signature, error) {
addr, err := address.NewFromBytes(vaddr.Bytes())
if err != nil {
return nil, err
}
return ww.w.Sign(ctx, addr, msg)
}

155
chain/validation/state.go
View File

@ -5,23 +5,27 @@ import (
"fmt"
"math/rand"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/gen"
"github.com/filecoin-project/lotus/chain/vm"
"golang.org/x/xerrors"
"github.com/ipfs/go-cid"
"github.com/ipfs/go-datastore"
"github.com/ipfs/go-hamt-ipld"
"github.com/minio/blake2b-simd"
blockstore "github.com/ipfs/go-ipfs-blockstore"
"github.com/filecoin-project/lotus/chain/address"
"github.com/filecoin-project/lotus/chain/state"
"github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/lotus/chain/wallet"
"github.com/filecoin-project/lotus/lib/crypto"
"golang.org/x/xerrors"
cbg "github.com/whyrusleeping/cbor-gen"
vstate "github.com/filecoin-project/chain-validation/pkg/state"
vactors "github.com/filecoin-project/chain-validation/pkg/state/actors"
vaddress "github.com/filecoin-project/chain-validation/pkg/state/address"
vtypes "github.com/filecoin-project/chain-validation/pkg/state/types"
"github.com/filecoin-project/lotus/chain/actors"
"github.com/filecoin-project/lotus/chain/address"
"github.com/filecoin-project/lotus/chain/gen"
"github.com/filecoin-project/lotus/chain/state"
"github.com/filecoin-project/lotus/chain/types"
"github.com/filecoin-project/lotus/chain/vm"
"github.com/filecoin-project/lotus/chain/wallet"
"github.com/filecoin-project/lotus/lib/crypto"
)
type StateWrapper struct {
@ -67,8 +71,8 @@ func (s *StateWrapper) Cid() cid.Cid {
return s.stateRoot
}
func (s *StateWrapper) Actor(addr vstate.Address) (vstate.Actor, error) {
vaddr, err := address.NewFromBytes([]byte(addr))
func (s *StateWrapper) Actor(addr vaddress.Address) (vstate.Actor, error) {
vaddr, err := address.NewFromBytes(addr.Bytes())
if err != nil {
return nil, err
}
@ -83,16 +87,16 @@ func (s *StateWrapper) Actor(addr vstate.Address) (vstate.Actor, error) {
return &actorWrapper{*fcActor}, nil
}
func (s *StateWrapper) Storage(addr vstate.Address) (vstate.Storage, error) {
func (s *StateWrapper) Storage(addr vaddress.Address) (vstate.Storage, error) {
return s.storage, nil
}
func (s *StateWrapper) NewAccountAddress() (vstate.Address, error) {
func (s *StateWrapper) NewAccountAddress() (vaddress.Address, error) {
return s.keys.NewAddress()
}
func (s *StateWrapper) SetActor(addr vstate.Address, code vstate.ActorCodeID, balance vstate.AttoFIL) (vstate.Actor, vstate.Storage, error) {
addrInt, err := address.NewFromBytes([]byte(addr))
func (s *StateWrapper) SetActor(addr vaddress.Address, code vactors.ActorCodeID, balance vtypes.BigInt) (vstate.Actor, vstate.Storage, error) {
addrInt, err := address.NewFromBytes(addr.Bytes())
if err != nil {
return nil, nil, err
}
@ -102,7 +106,7 @@ func (s *StateWrapper) SetActor(addr vstate.Address, code vstate.ActorCodeID, ba
}
actr := &actorWrapper{types.Actor{
Code: fromActorCode(code),
Balance: types.BigInt{balance},
Balance: types.BigInt{balance.Int},
Head: vm.EmptyObjectCid,
}}
// The ID-based address is dropped here, but should be reported back to the caller.
@ -113,16 +117,19 @@ func (s *StateWrapper) SetActor(addr vstate.Address, code vstate.ActorCodeID, ba
return actr, s.storage, s.flush(tree)
}
func (s *StateWrapper) SetSingletonActor(addr vstate.SingletonActorID, balance vstate.AttoFIL) (vstate.Actor, vstate.Storage, error) {
func (s *StateWrapper) SetSingletonActor(addr vactors.SingletonActorID, balance vtypes.BigInt) (vstate.Actor, vstate.Storage, error) {
vaddr := fromSingletonAddress(addr)
tree, err := state.LoadStateTree(s.cst, s.stateRoot)
if err != nil {
return nil, nil, err
}
lotusAddr, err := address.NewFromBytes([]byte(vaddr))
lotusAddr, err := address.NewFromBytes(vaddr.Bytes())
if err != nil {
return nil, nil, err
}
switch lotusAddr {
case actors.InitAddress:
initact, err := gen.SetupInitActor(s.bs, nil)
@ -162,7 +169,7 @@ func (s *StateWrapper) SetSingletonActor(addr vstate.SingletonActorID, balance v
case actors.NetworkAddress:
ntwkact := &types.Actor{
Code: actors.AccountCodeCid,
Balance: types.BigInt{balance},
Balance: types.BigInt{balance.Int},
Head: vm.EmptyObjectCid,
}
if err := tree.SetActor(actors.NetworkAddress, ntwkact); err != nil {
@ -172,7 +179,7 @@ func (s *StateWrapper) SetSingletonActor(addr vstate.SingletonActorID, balance v
case actors.BurntFundsAddress:
ntwkact := &types.Actor{
Code: actors.AccountCodeCid,
Balance: types.BigInt{balance},
Balance: types.BigInt{balance.Int},
Head: vm.EmptyObjectCid,
}
if err := tree.SetActor(actors.BurntFundsAddress, ntwkact); err != nil {
@ -184,6 +191,17 @@ func (s *StateWrapper) SetSingletonActor(addr vstate.SingletonActorID, balance v
}
}
func (s *StateWrapper) Sign(ctx context.Context, addr vaddress.Address, data []byte) (*vtypes.Signature, error) {
sig, err := s.keys.Sign(ctx, addr, data)
if err != nil {
return nil, err
}
return &vtypes.Signature{
Type: sig.Type,
Data: sig.Data,
}, nil
}
func (s *StateWrapper) Signer() *keyStore {
return s.keys
}
@ -199,44 +217,52 @@ func (s *StateWrapper) flush(tree *state.StateTree) (err error) {
//
type keyStore struct {
// Private keys by address
keys map[address.Address]types.KeyInfo
keys map[vaddress.Address]vtypes.KeyInfo
// Seed for deterministic key generation.
seed int64
}
func newKeyStore() *keyStore {
return &keyStore{
keys: make(map[address.Address]types.KeyInfo),
keys: make(map[vaddress.Address]vtypes.KeyInfo),
seed: 0,
}
}
func (s *keyStore) NewAddress() (vstate.Address, error) {
func (s *keyStore) NewAddress() (vaddress.Address, error) {
randSrc := rand.New(rand.NewSource(s.seed))
prv, err := crypto.GenerateKeyFromSeed(randSrc)
if err != nil {
return "", err
return vaddress.Undef, err
}
ki := types.KeyInfo{
vki := vtypes.KeyInfo{
PrivateKey: prv,
Type: types.KTSecp256k1,
}
key, err := wallet.NewKey(ki)
key, err := wallet.NewKey(types.KeyInfo{
Type: vki.Type,
PrivateKey: vki.PrivateKey,
})
if err != nil {
return "", err
return vaddress.Undef, err
}
s.keys[key.Address] = ki
vaddr, err := vaddress.NewFromBytes(key.Address.Bytes())
if err != nil {
return vaddress.Undef, err
}
s.keys[vaddr] = vki
s.seed++
return vstate.Address(key.Address.Bytes()), nil
return vaddress.NewFromBytes(key.Address.Bytes())
}
func (s *keyStore) Sign(ctx context.Context, addr address.Address, data []byte) (*types.Signature, error) {
func (s *keyStore) Sign(ctx context.Context, addr vaddress.Address, data []byte) (*types.Signature, error) {
ki, ok := s.keys[addr]
if !ok {
return &types.Signature{}, fmt.Errorf("unknown address %v", addr)
}
digest, err := crypto.Sign(ki.PrivateKey, data)
b2sum := blake2b.Sum256(data)
digest, err := crypto.Sign(ki.PrivateKey, b2sum[:])
if err != nil {
return &types.Signature{}, err
}
@ -266,8 +292,8 @@ func (a *actorWrapper) Nonce() uint64 {
return a.Actor.Nonce
}
func (a *actorWrapper) Balance() vstate.AttoFIL {
return a.Actor.Balance.Int
func (a *actorWrapper) Balance() vtypes.BigInt {
return vtypes.NewInt(a.Actor.Balance.Uint64())
}
@ -279,37 +305,60 @@ type directStorage struct {
cst *hamt.CborIpldStore
}
func (d *directStorage) Get(cid cid.Cid) ([]byte, error) {
panic("implement me")
func (d *directStorage) Get(c cid.Cid, out interface{}) error {
if err := d.cst.Get(context.TODO(), c, out.(cbg.CBORUnmarshaler)); err != nil {
return err
}
return nil
}
func fromActorCode(code vstate.ActorCodeID) cid.Cid {
func fromActorCode(code vactors.ActorCodeID) cid.Cid {
switch code {
case vstate.AccountActorCodeCid:
case vactors.AccountActorCodeCid:
return actors.AccountCodeCid
case vstate.StorageMinerCodeCid:
case vactors.StorageMinerCodeCid:
return actors.StorageMinerCodeCid
case vstate.MultisigActorCodeCid:
case vactors.MultisigActorCodeCid:
return actors.MultisigCodeCid
case vstate.PaymentChannelActorCodeCid:
case vactors.PaymentChannelActorCodeCid:
return actors.PaymentChannelCodeCid
default:
panic(fmt.Errorf("unknown actor code: %v", code))
}
}
func fromSingletonAddress(addr vstate.SingletonActorID) vstate.Address {
func fromSingletonAddress(addr vactors.SingletonActorID) vaddress.Address{
switch addr {
case vstate.InitAddress:
return vstate.Address(actors.InitAddress.Bytes())
case vstate.NetworkAddress:
return vstate.Address(actors.NetworkAddress.Bytes())
case vstate.StorageMarketAddress:
return vstate.Address(actors.StorageMarketAddress.Bytes())
case vstate.BurntFundsAddress:
return vstate.Address(actors.BurntFundsAddress.Bytes())
case vstate.StoragePowerAddress:
return vstate.Address(actors.StoragePowerAddress.Bytes())
case vactors.InitAddress:
out, err := vaddress.NewFromBytes(actors.InitAddress.Bytes())
if err != nil {
panic(err)
}
return out
case vactors.NetworkAddress:
out, err := vaddress.NewFromBytes(actors.NetworkAddress.Bytes())
if err != nil {
panic(err)
}
return out
case vactors.StorageMarketAddress:
out, err := vaddress.NewFromBytes(actors.StorageMarketAddress.Bytes())
if err != nil {
panic(err)
}
return out
case vactors.BurntFundsAddress:
out, err := vaddress.NewFromBytes(actors.BurntFundsAddress.Bytes())
if err != nil {
panic(err)
}
return out
case vactors.StoragePowerAddress:
out, err := vaddress.NewFromBytes(actors.StoragePowerAddress.Bytes())
if err != nil {
panic(err)
}
return out
default:
panic(fmt.Errorf("unknown singleton actor address: %v", addr))
}

3
chain/vm/validation_test.go
View File

@ -9,8 +9,9 @@ import (
)
func TestStorageMinerValidation(t *testing.T) {
t.SkipNow()
factory := validation.NewFactories()
suites.CreateStorageMinerAndUpdatePeerIDTest(t, factory)
suites.CreateStorageMinerAndUpdatePeerID(t, factory)
}

4
go.mod
View File

@ -9,8 +9,8 @@ require (
github.com/Gurpartap/async v0.0.0-20180927173644-4f7f499dd9ee
github.com/StackExchange/wmi v0.0.0-20190523213315-cbe66965904d // indirect
github.com/fatih/color v1.7.0 // indirect
github.com/filecoin-project/chain-validation v0.0.0-20191106200742-11986803c0f7
github.com/filecoin-project/filecoin-ffi v0.0.0-00010101000000-000000000000
github.com/filecoin-project/chain-validation v0.0.3
github.com/filecoin-project/filecoin-ffi v0.0.0-20191204125133-ebb3e13addf1
github.com/filecoin-project/go-amt-ipld v0.0.0-20191203073133-f941215342ed
github.com/gbrlsnchs/jwt/v3 v3.0.0-beta.1
github.com/go-ole/go-ole v1.2.4 // indirect

6
go.sum
View File

@ -76,12 +76,10 @@ github.com/eapache/queue v1.1.0/go.mod h1:6eCeP0CKFpHLu8blIFXhExK/dRa7WDZfr6jVFP
github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
github.com/fd/go-nat v1.0.0/go.mod h1:BTBu/CKvMmOMUPkKVef1pngt2WFH/lg7E6yQnulfp6E=
github.com/filecoin-project/chain-validation v0.0.0-20191106200742-11986803c0f7 h1:Ags/z6ZubzKonQ9PsY9fO439yGdVg07qpdxfv/AEUno=
github.com/filecoin-project/chain-validation v0.0.0-20191106200742-11986803c0f7/go.mod h1:0/0/QUNqpF/jVzLHFncGeT3NvGPODBhGzQlNgzmoZew=
github.com/filecoin-project/chain-validation v0.0.3 h1:luT/8kJ0WdMIqQ9Bm31W4JkuYCW0wUb26AvnD4WK59M=
github.com/filecoin-project/chain-validation v0.0.3/go.mod h1:NCEGFjcWRjb8akWFSOXvU6n2efkWIqAeOKU6o5WBGQw=
github.com/filecoin-project/go-amt-ipld v0.0.0-20191203073133-f941215342ed h1:Wt4+eF3fda6MKLjK0/zzBOxs5cUwGyucJSAfO4LnX/w=
github.com/filecoin-project/go-amt-ipld v0.0.0-20191203073133-f941215342ed/go.mod h1:KsFPWjF+UUYl6n9A+qbg4bjFgAOneicFZtDH/LQEX2U=
github.com/filecoin-project/go-leb128 v0.0.0-20190212224330-8d79a5489543 h1:aMJGfgqe1QDhAVwxRg5fjCRF533xHidiKsugk7Vvzug=
github.com/filecoin-project/go-leb128 v0.0.0-20190212224330-8d79a5489543/go.mod h1:mjrHv1cDGJWDlGmC0eDc1E5VJr8DmL9XMUcaFwiuKg8=
github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
github.com/gbrlsnchs/jwt/v3 v3.0.0-beta.1 h1:EzDjxMg43q1tA2c0MV3tNbaontnHLplHyFF6M5KiVP0=