lotus/cmd/lotus-storage-miner/init.go

669 lines
18 KiB
Go
Raw Normal View History

2019-07-19 09:24:11 +00:00
package main
import (
2020-03-06 08:06:59 +00:00
"bytes"
"context"
2019-10-03 00:02:06 +00:00
"crypto/rand"
"encoding/binary"
"encoding/json"
"fmt"
2020-02-27 21:45:31 +00:00
"io/ioutil"
"os"
"path/filepath"
2020-02-27 21:45:31 +00:00
"strconv"
"github.com/docker/go-units"
"github.com/google/uuid"
2019-11-16 06:47:04 +00:00
"github.com/ipfs/go-datastore"
"github.com/libp2p/go-libp2p-core/crypto"
"github.com/libp2p/go-libp2p-core/peer"
"github.com/mitchellh/go-homedir"
"github.com/urfave/cli/v2"
2020-06-05 22:59:01 +00:00
"golang.org/x/xerrors"
2019-07-19 09:24:11 +00:00
2020-03-17 20:19:52 +00:00
"github.com/filecoin-project/go-address"
cborutil "github.com/filecoin-project/go-cbor-util"
paramfetch "github.com/filecoin-project/go-paramfetch"
sectorstorage "github.com/filecoin-project/sector-storage"
"github.com/filecoin-project/sector-storage/ffiwrapper"
"github.com/filecoin-project/sector-storage/stores"
2020-03-17 20:19:52 +00:00
"github.com/filecoin-project/specs-actors/actors/abi"
"github.com/filecoin-project/specs-actors/actors/builtin"
"github.com/filecoin-project/specs-actors/actors/builtin/market"
miner2 "github.com/filecoin-project/specs-actors/actors/builtin/miner"
"github.com/filecoin-project/specs-actors/actors/builtin/power"
crypto2 "github.com/filecoin-project/specs-actors/actors/crypto"
lapi "github.com/filecoin-project/lotus/api"
"github.com/filecoin-project/lotus/build"
"github.com/filecoin-project/lotus/chain/actors"
2020-08-06 01:14:13 +00:00
"github.com/filecoin-project/lotus/chain/gen/slashfilter"
"github.com/filecoin-project/lotus/chain/types"
lcli "github.com/filecoin-project/lotus/cli"
"github.com/filecoin-project/lotus/genesis"
2019-11-25 04:45:13 +00:00
"github.com/filecoin-project/lotus/miner"
"github.com/filecoin-project/lotus/node/modules"
"github.com/filecoin-project/lotus/node/modules/dtypes"
"github.com/filecoin-project/lotus/node/repo"
2019-11-25 04:45:13 +00:00
"github.com/filecoin-project/lotus/storage"
sealing "github.com/filecoin-project/storage-fsm"
2019-07-19 09:24:11 +00:00
)
var initCmd = &cli.Command{
Name: "init",
Usage: "Initialize a lotus miner repo",
Flags: []cli.Flag{
&cli.StringFlag{
Name: "actor",
Usage: "specify the address of an already created miner actor",
},
&cli.BoolFlag{
2019-09-26 20:57:20 +00:00
Name: "genesis-miner",
Usage: "enable genesis mining (DON'T USE ON BOOTSTRAPPED NETWORK)",
Hidden: true,
},
&cli.BoolFlag{
Name: "create-worker-key",
Usage: "create separate worker key",
},
&cli.StringFlag{
2019-09-26 20:57:20 +00:00
Name: "worker",
Aliases: []string{"w"},
2019-09-26 20:57:20 +00:00
Usage: "worker key to use (overrides --create-worker-key)",
},
&cli.StringFlag{
2019-09-26 20:57:20 +00:00
Name: "owner",
Aliases: []string{"o"},
2019-09-26 20:57:20 +00:00
Usage: "owner key to use",
},
&cli.StringFlag{
Name: "sector-size",
Usage: "specify sector size to use",
Value: units.BytesSize(float64(build.DefaultSectorSize())),
},
2020-03-03 22:19:22 +00:00
&cli.StringSliceFlag{
2019-11-25 04:45:13 +00:00
Name: "pre-sealed-sectors",
Usage: "specify set of presealed sectors for starting as a genesis miner",
},
&cli.StringFlag{
Name: "pre-sealed-metadata",
Usage: "specify the metadata file for the presealed sectors",
},
2019-12-04 16:53:32 +00:00
&cli.BoolFlag{
Name: "nosync",
Usage: "don't check full-node sync status",
},
&cli.BoolFlag{
Name: "symlink-imported-sectors",
Usage: "attempt to symlink to presealed sectors instead of copying them into place",
},
&cli.BoolFlag{
Name: "no-local-storage",
Usage: "don't use storageminer repo for sector storage",
},
&cli.StringFlag{
Name: "gas-price",
Usage: "set gas price for initialization messages in AttoFIL",
Value: "0",
},
},
2019-07-19 09:24:11 +00:00
Action: func(cctx *cli.Context) error {
log.Info("Initializing lotus miner")
2019-07-19 09:24:11 +00:00
sectorSizeInt, err := units.RAMInBytes(cctx.String("sector-size"))
if err != nil {
return err
}
ssize := abi.SectorSize(sectorSizeInt)
2019-12-04 19:44:15 +00:00
gasPrice, err := types.BigFromString(cctx.String("gas-price"))
if err != nil {
return xerrors.Errorf("failed to parse gas-price flag: %s", err)
}
symlink := cctx.Bool("symlink-imported-sectors")
if symlink {
log.Info("will attempt to symlink to imported sectors")
}
ctx := lcli.ReqContext(cctx)
2019-10-02 17:20:30 +00:00
log.Info("Checking proof parameters")
if err := paramfetch.GetParams(ctx, build.ParametersJSON(), uint64(ssize)); err != nil {
2019-10-02 17:20:30 +00:00
return xerrors.Errorf("fetching proof parameters: %w", err)
}
2019-12-04 00:25:18 +00:00
log.Info("Trying to connect to full node RPC")
api, closer, err := lcli.GetFullNodeAPI(cctx) // TODO: consider storing full node address in config
if err != nil {
return err
}
defer closer()
log.Info("Checking full node sync status")
2019-12-04 16:53:32 +00:00
if !cctx.Bool("genesis-miner") && !cctx.Bool("nosync") {
2019-12-04 00:25:18 +00:00
if err := lcli.SyncWait(ctx, api); err != nil {
return xerrors.Errorf("sync wait: %w", err)
}
}
2019-10-02 20:29:40 +00:00
log.Info("Checking if repo exists")
2020-07-08 10:38:59 +00:00
repoPath := cctx.String(FlagMinerRepo)
r, err := repo.NewFS(repoPath)
2019-07-19 09:24:11 +00:00
if err != nil {
return err
}
2019-07-23 21:54:54 +00:00
ok, err := r.Exists()
if err != nil {
return err
}
if ok {
2020-07-08 10:38:59 +00:00
return xerrors.Errorf("repo at '%s' is already initialized", cctx.String(FlagMinerRepo))
2019-07-19 09:24:11 +00:00
}
log.Info("Checking full node version")
v, err := api.Version(ctx)
if err != nil {
return err
}
if !v.APIVersion.EqMajorMinor(build.APIVersion) {
return xerrors.Errorf("Remote API version didn't match (local %s, remote %s)", build.APIVersion, v.APIVersion)
}
log.Info("Initializing repo")
2019-11-12 17:59:38 +00:00
if err := r.Init(repo.StorageMiner); err != nil {
2019-07-19 09:24:11 +00:00
return err
}
{
lr, err := r.Lock(repo.StorageMiner)
if err != nil {
return err
}
var localPaths []stores.LocalPath
2020-02-27 21:45:31 +00:00
if pssb := cctx.StringSlice("pre-sealed-sectors"); len(pssb) != 0 {
log.Infof("Setting up storage config with presealed sectors: %v", pssb)
for _, psp := range pssb {
psp, err := homedir.Expand(psp)
if err != nil {
return err
}
localPaths = append(localPaths, stores.LocalPath{
Path: psp,
})
2020-03-03 22:19:22 +00:00
}
}
2019-11-30 23:17:50 +00:00
if !cctx.Bool("no-local-storage") {
2020-03-19 15:10:19 +00:00
b, err := json.MarshalIndent(&stores.LocalStorageMeta{
2020-03-13 11:59:19 +00:00
ID: stores.ID(uuid.New().String()),
2020-03-05 19:21:06 +00:00
Weight: 10,
CanSeal: true,
CanStore: true,
}, "", " ")
if err != nil {
return xerrors.Errorf("marshaling storage config: %w", err)
}
2020-03-05 19:21:06 +00:00
if err := ioutil.WriteFile(filepath.Join(lr.Path(), "sectorstore.json"), b, 0644); err != nil {
2020-03-09 06:13:22 +00:00
return xerrors.Errorf("persisting storage metadata (%s): %w", filepath.Join(lr.Path(), "sectorstore.json"), err)
2020-03-05 19:21:06 +00:00
}
localPaths = append(localPaths, stores.LocalPath{
Path: lr.Path(),
})
}
if err := lr.SetStorage(func(sc *stores.StorageConfig) {
2020-03-09 19:22:30 +00:00
sc.StoragePaths = append(sc.StoragePaths, localPaths...)
}); err != nil {
2020-03-03 22:19:22 +00:00
return xerrors.Errorf("set storage config: %w", err)
}
2019-11-30 23:17:50 +00:00
if err := lr.Close(); err != nil {
return err
}
2019-11-25 04:45:13 +00:00
}
if err := storageMinerInit(ctx, cctx, api, r, ssize, gasPrice); err != nil {
2020-07-08 10:38:59 +00:00
log.Errorf("Failed to initialize lotus-miner: %+v", err)
2019-11-16 06:47:04 +00:00
path, err := homedir.Expand(repoPath)
if err != nil {
return err
}
2019-11-16 06:47:04 +00:00
log.Infof("Cleaning up %s after attempt...", path)
if err := os.RemoveAll(path); err != nil {
log.Errorf("Failed to clean up failed storage repo: %s", err)
}
return xerrors.Errorf("Storage-miner init failed")
2019-07-25 12:50:34 +00:00
}
// TODO: Point to setting storage price, maybe do it interactively or something
log.Info("Miner successfully created, you can now start it with 'lotus-miner run'")
2019-07-25 12:50:34 +00:00
return nil
},
}
2019-07-25 12:50:34 +00:00
func migratePreSealMeta(ctx context.Context, api lapi.FullNode, metadata string, maddr address.Address, mds dtypes.MetadataDS) error {
metadata, err := homedir.Expand(metadata)
2019-11-30 09:25:31 +00:00
if err != nil {
return xerrors.Errorf("expanding preseal dir: %w", err)
}
b, err := ioutil.ReadFile(metadata)
if err != nil {
return xerrors.Errorf("reading preseal metadata: %w", err)
}
psm := map[string]genesis.Miner{}
if err := json.Unmarshal(b, &psm); err != nil {
return xerrors.Errorf("unmarshaling preseal metadata: %w", err)
}
meta, ok := psm[maddr.String()]
if !ok {
return xerrors.Errorf("preseal file didn't contain metadata for miner %s", maddr)
}
maxSectorID := abi.SectorNumber(0)
for _, sector := range meta.Sectors {
sectorKey := datastore.NewKey(sealing.SectorStorePrefix).ChildString(fmt.Sprint(sector.SectorID))
dealID, err := findMarketDealID(ctx, api, sector.Deal)
if err != nil {
return xerrors.Errorf("finding storage deal for pre-sealed sector %d: %w", sector.SectorID, err)
}
2020-02-27 21:45:31 +00:00
commD := sector.CommD
commR := sector.CommR
info := &sealing.SectorInfo{
2020-04-06 22:31:33 +00:00
State: sealing.Proving,
SectorNumber: sector.SectorID,
Pieces: []sealing.Piece{
{
Piece: abi.PieceInfo{
Size: abi.PaddedPieceSize(meta.SectorSize),
PieceCID: commD,
},
DealInfo: &sealing.DealInfo{
DealID: dealID,
DealSchedule: sealing.DealSchedule{
StartEpoch: sector.Deal.StartEpoch,
EndEpoch: sector.Deal.EndEpoch,
},
},
},
},
2020-02-27 21:45:31 +00:00
CommD: &commD,
CommR: &commR,
Proof: nil,
TicketValue: abi.SealRandomness{},
TicketEpoch: 0,
PreCommitMessage: nil,
SeedValue: abi.InteractiveSealRandomness{},
SeedEpoch: 0,
CommitMessage: nil,
}
b, err := cborutil.Dump(info)
if err != nil {
return err
}
if err := mds.Put(sectorKey, b); err != nil {
return err
}
if sector.SectorID > maxSectorID {
maxSectorID = sector.SectorID
}
2020-02-21 18:20:22 +00:00
/* // TODO: Import deals into market
2020-02-10 18:21:10 +00:00
pnd, err := cborutil.AsIpld(sector.Deal)
if err != nil {
return err
}
2020-02-10 18:21:10 +00:00
dealKey := datastore.NewKey(deals.ProviderDsPrefix).ChildString(pnd.Cid().String())
deal := &deals.MinerDeal{
MinerDeal: storagemarket.MinerDeal{
2020-02-21 18:20:22 +00:00
ClientDealProposal: sector.Deal,
2020-02-10 18:21:10 +00:00
ProposalCid: pnd.Cid(),
State: storagemarket.StorageDealActive,
Ref: &storagemarket.DataRef{Root: proposalCid}, // TODO: This is super wrong, but there
// are no params for CommP CIDs, we can't recover unixfs cid easily,
// and this isn't even used after the deal enters Complete state
DealID: dealID,
},
}
b, err = cborutil.Dump(deal)
if err != nil {
return err
}
if err := mds.Put(dealKey, b); err != nil {
return err
2020-02-21 18:20:22 +00:00
}*/
}
buf := make([]byte, binary.MaxVarintLen64)
size := binary.PutUvarint(buf, uint64(maxSectorID))
2020-05-19 23:24:59 +00:00
return mds.Put(datastore.NewKey(modules.StorageCounterDSPrefix), buf[:size])
}
2020-02-25 20:35:15 +00:00
func findMarketDealID(ctx context.Context, api lapi.FullNode, deal market.DealProposal) (abi.DealID, error) {
// TODO: find a better way
// (this is only used by genesis miners)
deals, err := api.StateMarketDeals(ctx, types.EmptyTSK)
if err != nil {
return 0, xerrors.Errorf("getting market deals: %w", err)
}
for k, v := range deals {
2020-02-10 18:21:10 +00:00
if v.Proposal.PieceCID.Equals(deal.PieceCID) {
id, err := strconv.ParseUint(k, 10, 64)
return abi.DealID(id), err
}
}
return 0, xerrors.New("deal not found")
}
func storageMinerInit(ctx context.Context, cctx *cli.Context, api lapi.FullNode, r repo.Repo, ssize abi.SectorSize, gasPrice types.BigInt) error {
2019-11-16 06:47:04 +00:00
lr, err := r.Lock(repo.StorageMiner)
if err != nil {
return err
}
defer lr.Close() //nolint:errcheck
2019-11-16 06:47:04 +00:00
log.Info("Initializing libp2p identity")
p2pSk, err := makeHostKey(lr)
if err != nil {
2019-11-15 03:19:16 +00:00
return xerrors.Errorf("make host key: %w", err)
}
peerid, err := peer.IDFromPrivateKey(p2pSk)
if err != nil {
2019-11-15 03:19:16 +00:00
return xerrors.Errorf("peer ID from private key: %w", err)
}
2019-07-25 12:50:34 +00:00
mds, err := lr.Datastore("/metadata")
if err != nil {
return err
}
var addr address.Address
if act := cctx.String("actor"); act != "" {
a, err := address.NewFromString(act)
2019-07-25 12:50:34 +00:00
if err != nil {
2019-11-15 03:19:16 +00:00
return xerrors.Errorf("failed parsing actor flag value (%q): %w", act, err)
2019-07-25 12:50:34 +00:00
}
2019-11-25 04:45:13 +00:00
if cctx.Bool("genesis-miner") {
if err := mds.Put(datastore.NewKey("miner-address"), a.Bytes()); err != nil {
return err
}
2020-04-10 21:29:05 +00:00
spt, err := ffiwrapper.SealProofTypeFromSectorSize(ssize)
if err != nil {
return err
}
2020-03-17 20:19:52 +00:00
mid, err := address.IDFromAddress(a)
if err != nil {
return xerrors.Errorf("getting id address: %w", err)
}
sa, err := modules.StorageAuth(ctx, api)
if err != nil {
return err
}
2020-03-26 02:50:56 +00:00
smgr, err := sectorstorage.New(ctx, lr, stores.NewIndex(), &ffiwrapper.Config{
SealProofType: spt,
}, sectorstorage.SealerConfig{10, true, true, true, true}, nil, sa)
if err != nil {
return err
}
2020-04-17 14:47:19 +00:00
epp, err := storage.NewWinningPoStProver(api, smgr, ffiwrapper.ProofVerifier, dtypes.MinerID(mid))
if err != nil {
return err
}
2019-11-25 04:45:13 +00:00
2020-08-06 01:14:13 +00:00
m := miner.NewMiner(api, epp, a, slashfilter.New(mds))
2019-11-25 04:45:13 +00:00
{
if err := m.Start(ctx); err != nil {
2019-11-25 04:45:13 +00:00
return xerrors.Errorf("failed to start up genesis miner: %w", err)
}
cerr := configureStorageMiner(ctx, api, a, peerid, gasPrice)
2019-11-25 04:45:13 +00:00
if err := m.Stop(ctx); err != nil {
log.Error("failed to shut down miner: ", err)
}
if cerr != nil {
return xerrors.Errorf("failed to configure miner: %w", cerr)
2019-11-25 04:45:13 +00:00
}
}
if pssb := cctx.String("pre-sealed-metadata"); pssb != "" {
pssb, err := homedir.Expand(pssb)
if err != nil {
return err
}
log.Infof("Importing pre-sealed sector metadata for %s", a)
if err := migratePreSealMeta(ctx, api, pssb, a, mds); err != nil {
return xerrors.Errorf("migrating presealed sector metadata: %w", err)
}
}
return nil
}
if pssb := cctx.String("pre-sealed-metadata"); pssb != "" {
pssb, err := homedir.Expand(pssb)
if err != nil {
return err
}
log.Infof("Importing pre-sealed sector metadata for %s", a)
if err := migratePreSealMeta(ctx, api, pssb, a, mds); err != nil {
return xerrors.Errorf("migrating presealed sector metadata: %w", err)
}
2019-12-02 12:51:16 +00:00
}
if err := configureStorageMiner(ctx, api, a, peerid, gasPrice); err != nil {
return xerrors.Errorf("failed to configure miner: %w", err)
}
addr = a
} else {
a, err := createStorageMiner(ctx, api, peerid, gasPrice, cctx)
if err != nil {
2020-03-06 08:06:59 +00:00
return xerrors.Errorf("creating miner failed: %w", err)
2019-07-25 12:50:34 +00:00
}
addr = a
}
2019-07-25 12:50:34 +00:00
log.Infof("Created new miner: %s", addr)
2019-11-25 04:45:13 +00:00
if err := mds.Put(datastore.NewKey("miner-address"), addr.Bytes()); err != nil {
return err
}
return nil
}
2019-07-25 12:50:34 +00:00
2019-10-03 00:02:06 +00:00
func makeHostKey(lr repo.LockedRepo) (crypto.PrivKey, error) {
pk, _, err := crypto.GenerateEd25519Key(rand.Reader)
if err != nil {
return nil, err
}
ks, err := lr.KeyStore()
if err != nil {
return nil, err
}
kbytes, err := pk.Bytes()
if err != nil {
return nil, err
}
if err := ks.Put("libp2p-host", types.KeyInfo{
Type: "libp2p-host",
PrivateKey: kbytes,
}); err != nil {
return nil, err
}
return pk, nil
}
func configureStorageMiner(ctx context.Context, api lapi.FullNode, addr address.Address, peerid peer.ID, gasPrice types.BigInt) error {
mi, err := api.StateMinerInfo(ctx, addr, types.EmptyTSK)
if err != nil {
return xerrors.Errorf("getWorkerAddr returned bad address: %w", err)
}
2020-06-05 20:06:11 +00:00
enc, err := actors.SerializeParams(&miner2.ChangePeerIDParams{NewID: abi.PeerID(peerid)})
if err != nil {
return err
}
msg := &types.Message{
To: addr,
From: mi.Worker,
2020-02-21 18:20:22 +00:00
Method: builtin.MethodsMiner.ChangePeerID,
Params: enc,
2019-08-16 22:10:34 +00:00
Value: types.NewInt(0),
GasPrice: gasPrice,
GasLimit: 0,
}
2019-09-17 08:15:26 +00:00
smsg, err := api.MpoolPushMessage(ctx, msg)
if err != nil {
return err
}
2019-08-16 22:10:34 +00:00
log.Info("Waiting for message: ", smsg.Cid())
2020-06-03 21:42:06 +00:00
ret, err := api.StateWaitMsg(ctx, smsg.Cid(), build.MessageConfidence)
if err != nil {
return err
}
if ret.Receipt.ExitCode != 0 {
return xerrors.Errorf("update peer id message failed with exit code %d", ret.Receipt.ExitCode)
}
return nil
}
2019-07-25 12:50:34 +00:00
func createStorageMiner(ctx context.Context, api lapi.FullNode, peerid peer.ID, gasPrice types.BigInt, cctx *cli.Context) (address.Address, error) {
log.Info("Creating StorageMarket.CreateStorageMiner message")
2019-07-25 12:50:34 +00:00
2020-03-06 22:23:21 +00:00
var err error
var owner address.Address
if cctx.String("owner") != "" {
owner, err = address.NewFromString(cctx.String("owner"))
} else {
owner, err = api.WalletDefaultAddress(ctx)
}
if err != nil {
return address.Undef, err
}
2019-07-25 12:50:34 +00:00
ssize, err := units.RAMInBytes(cctx.String("sector-size"))
if err != nil {
return address.Undef, fmt.Errorf("failed to parse sector size: %w", err)
}
worker := owner
if cctx.String("worker") != "" {
worker, err = address.NewFromString(cctx.String("worker"))
} else if cctx.Bool("create-worker-key") { // TODO: Do we need to force this if owner is Secpk?
2020-02-21 18:20:22 +00:00
worker, err = api.WalletNew(ctx, crypto2.SigTypeBLS)
}
// TODO: Transfer some initial funds to worker
if err != nil {
return address.Undef, err
}
2019-07-25 12:50:34 +00:00
collateral, err := api.StatePledgeCollateral(ctx, types.EmptyTSK)
if err != nil {
return address.Undef, err
}
2019-07-25 12:50:34 +00:00
2020-04-29 18:06:05 +00:00
spt, err := ffiwrapper.SealProofTypeFromSectorSize(abi.SectorSize(ssize))
if err != nil {
return address.Undef, err
}
2020-02-21 18:20:22 +00:00
params, err := actors.SerializeParams(&power.CreateMinerParams{
2020-04-29 18:06:05 +00:00
Owner: owner,
Worker: worker,
SealProofType: spt,
2020-06-05 20:06:11 +00:00
Peer: abi.PeerID(peerid),
})
if err != nil {
return address.Undef, err
}
2019-07-25 12:50:34 +00:00
2019-09-17 08:15:26 +00:00
createStorageMinerMsg := &types.Message{
2020-02-25 20:54:58 +00:00
To: builtin.StoragePowerActorAddr,
From: owner,
Value: types.BigAdd(collateral, types.BigDiv(collateral, types.NewInt(100))),
2019-07-25 12:50:34 +00:00
2020-02-21 18:20:22 +00:00
Method: builtin.MethodsPower.CreateMiner,
Params: params,
GasLimit: 0,
GasPrice: gasPrice,
}
2019-07-25 12:50:34 +00:00
2019-09-17 08:15:26 +00:00
signed, err := api.MpoolPushMessage(ctx, createStorageMinerMsg)
if err != nil {
return address.Undef, err
}
2019-09-17 08:15:26 +00:00
log.Infof("Pushed StorageMarket.CreateStorageMiner, %s to Mpool", signed.Cid())
log.Infof("Waiting for confirmation")
2020-06-03 21:42:06 +00:00
mw, err := api.StateWaitMsg(ctx, signed.Cid(), build.MessageConfidence)
if err != nil {
return address.Undef, err
}
if mw.Receipt.ExitCode != 0 {
return address.Undef, xerrors.Errorf("create miner failed: exit code %d", mw.Receipt.ExitCode)
}
2020-03-06 08:06:59 +00:00
var retval power.CreateMinerReturn
if err := retval.UnmarshalCBOR(bytes.NewReader(mw.Receipt.Return)); err != nil {
return address.Undef, err
}
log.Infof("New miners address is: %s (%s)", retval.IDAddress, retval.RobustAddress)
2020-03-06 22:23:21 +00:00
return retval.IDAddress, nil
2019-07-19 09:24:11 +00:00
}