command

Documentation

Index

• Variables

Variables

var Balance = &cobra.Command{
	Use:   "balance",
	Short: "Prints stake balance of a peer",
	RunE: func(cmd *cobra.Command, args []string) error {
		proxy, err := makeCtrlProxy(cmd)
		if err != nil {
			return err
		}
		defer proxy.Close()

		var id hash.Peer
		hex, err := cmd.Flags().GetString("peer")
		if err != nil || hex == "self" {
			id, err = proxy.GetSelfID()
		} else {
			id = hash.HexToPeer(hex)
		}
		if err != nil {
			return err
		}

		balance, err := proxy.StakeOf(id)
		if err != nil {
			return err
		}

		cmd.Printf("balance of %s == %d\n", id.Hex(), balance)
		return nil
	},
}

Balance prints stake balance of a peer.

var (
	// ErrOneArgument returns when command expects exactly one
	// argument.
	ErrOneArgument = errors.New("expected exactly one argument")
)

var ID = &cobra.Command{
	Use:   "id",
	Short: "Prints id of the node",
	RunE: func(cmd *cobra.Command, args []string) error {
		proxy, err := makeCtrlProxy(cmd)
		if err != nil {
			return err
		}
		defer proxy.Close()

		id, err := proxy.GetSelfID()
		if err != nil {
			return err
		}

		cmd.Println(id.Hex())
		return nil
	},
}

ID prints id of the node.

var Info = &cobra.Command{
	Use:   "info",
	Short: "Info returns information about transactions",
	RunE: func(cmd *cobra.Command, args []string) error {
		proxy, err := makeCtrlProxy(cmd)
		if err != nil {
			return err
		}
		defer proxy.Close()

		for _, hex := range args {
			tx, err := proxy.GetTransaction(hash.HexToTransactionHash(hex))
			if err != nil {
				return err
			}

			if tx == nil {
				cmd.Printf("transfer %s not found\n", hex)
				return nil
			}

			cmd.Printf("transfer %d to %s\n",
				tx.Amount,
				tx.Receiver.Hex(),
			)
		}

		return nil
	},
}

Info returns information about transaction.

var LogLevel = &cobra.Command{
	Use:   "log-level",
	Short: "Sets logger log level",
	RunE: func(cmd *cobra.Command, args []string) error {
		proxy, err := makeCtrlProxy(cmd)
		if err != nil {
			return err
		}
		defer proxy.Close()

		if len(args) != 1 {
			return ErrOneArgument
		}

		if err := proxy.SetLogLevel(args[0]); err != nil {
			return err
		}

		cmd.Println("ok")
		return nil
	},
}

LogLevel sets logger log level.

var Start = &cobra.Command{
	Use:   "start",
	Short: "Starts lachesis node",
	RunE: func(cmd *cobra.Command, args []string) error {
		logLevel, err := cmd.Flags().GetString("log")
		if err != nil {
			return err
		}
		logger.GetLevel(logLevel)

		fakegen, err := cmd.Flags().GetString("fakegen")
		if err != nil {
			return err
		}

		num, total, err := parseFakeGen(fakegen)
		if err != nil {
			return err
		}

		var db *badger.DB
		dbdir, err := cmd.Flags().GetString("db")
		if err != nil {
			return err
		}
		if dbdir != "inmemory" {
			db, err = ondiskDB(dbdir)
			if err != nil {
				return err
			}
		}

		net, keys := lachesis.FakeNet(total)
		conf := lachesis.DefaultConfig()
		conf.Net = net

		l := lachesis.New(db, "", keys[num], conf)
		l.Start()
		defer l.Stop()

		hosts, err := cmd.Flags().GetStringSlice("peer")
		if err != nil {
			return err
		}
		l.AddPeers(trim(hosts)...)

		dsn, err := cmd.Flags().GetString("dsn")
		if err != nil {
			return err
		}
		logger.SetDSN(dsn)

		wait()

		return nil
	},
}

Start starts lachesis node.

var Transfer = &cobra.Command{
	Use:   "transfer",
	Short: "Transfers a balance amount to given receiver",
	RunE: func(cmd *cobra.Command, args []string) error {
		amount, err := cmd.Flags().GetUint64("amount")
		if err != nil {
			return err
		}
		index, err := cmd.Flags().GetUint64("index")
		if err != nil {
			return err
		}
		hex, err := cmd.Flags().GetString("receiver")
		if err != nil {
			return err
		}
		receiver := hash.HexToPeer(hex)

		proxy, err := makeCtrlProxy(cmd)
		if err != nil {
			return err
		}
		defer proxy.Close()

		h, err := proxy.SendTo(receiver, index, amount, 0)
		if err != nil {
			return err
		}

		cmd.Println(h.Hex())
		return nil
	},
}

Transfer makes a transaction for stake transfer.