commands

Documentation

Index

• Variables
• func DaemonIsRunning() (bool, error)
• func GetNode(env cmds.Environment) *core.ToychainNode
• type CommandEnv
  • func (ce *CommandEnv) Context() context.Context

Variables

var AddrsCmd = &cmds.Command{
	Subcommands: map[string]*cmds.Command{
		"new":    AddrsNewCmd,
		"list":   AddrsListCmd,
		"lookup": AddrsLookupCmd,
	},
}

var AddrsListCmd = &cmds.Command{
	Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) {
		tch := GetNode(env)
		re.Emit(tch.Addresses)
	},
	Type: []types.Address{},
	Encoders: cmds.EncoderMap{
		cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
			addrs, ok := v.(*[]types.Address)
			if !ok {
				return fmt.Errorf("unexpected type: %T", v)
			}

			for _, a := range *addrs {
				_, err := fmt.Fprintln(w, a.String())
				if err != nil {
					return err
				}
			}
			return nil
		}),
	},
}

var AddrsLookupCmd = &cmds.Command{
	Arguments: []cmdkit.Argument{
		cmdkit.StringArg("address", true, false, "address to find peerID for"),
	},
	Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) {
		tch := GetNode(env)

		address, err := types.ParseAddress(req.Arguments[0])
		if err != nil {
			re.SetError(err, cmdkit.ErrNormal)
			return
		}

		v, err := tch.Lookup.Lookup(address)
		if err != nil {
			re.SetError(err, cmdkit.ErrNormal)
			return
		}
		re.Emit(v.Pretty())
	},
	Type: string(""),
	Encoders: cmds.EncoderMap{
		cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
			pid, ok := v.(string)
			if !ok {
				return fmt.Errorf("unexpected type: %T", v)
			}

			_, err := fmt.Fprintln(w, pid)
			if err != nil {
				return err
			}
			return nil
		}),
	},
}

var AddrsNewCmd = &cmds.Command{
	Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) {
		tch := GetNode(env)
		naddr := core.CreateNewAddress()
		tch.Addresses = append(tch.Addresses, naddr)
		re.Emit(naddr)
	},
	Type: types.Address(""),
	Encoders: cmds.EncoderMap{
		cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
			a, ok := v.(*types.Address)
			if !ok {
				return fmt.Errorf("unexpected type: %T", v)
			}

			_, err := fmt.Fprintln(w, a.String())
			return err
		}),
	},
}

var BitswapCmd = &cmds.Command{
	Subcommands: map[string]*cmds.Command{
		"wantlist": BitswapWantlistCmd,
	},
}

var BitswapWantlistCmd = &cmds.Command{
	Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) {
		tch := GetNode(env)
		re.Emit(tch.Bitswap.GetWantlist())
	},
	Type: []*cid.Cid{},
	Encoders: cmds.EncoderMap{
		cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
			wants, ok := v.(*[]cid.Cid)
			if !ok {
				return fmt.Errorf("unexpected type: %T", v)
			}

			for _, want := range *wants {
				_, err := fmt.Fprintln(w, want.String())
				if err != nil {
					return err
				}
			}
			return nil
		}),
	},
}

var DaemonCmd = &cmds.Command{
	Helptext: cmdkit.HelpText{
		Tagline: "run the toychain daemon",
	},
	Arguments: []cmdkit.Argument{
		cmdkit.StringArg("bootstrap", false, true, "nodes to bootstrap to"),
	},
	Run: daemonRun,
}

var DagCmd = &cmds.Command{
	Subcommands: map[string]*cmds.Command{
		"get": DagGetCmd,
	},
}

var DagGetCmd = &cmds.Command{
	Arguments: []cmdkit.Argument{
		cmdkit.StringArg("object", true, false, "ref of node to get"),
	},
	Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) {
		tch := GetNode(env)

		res := resolver.NewBasicResolver(tch.DAG)

		p, err := path.ParsePath(req.Arguments[0])
		if err != nil {
			re.SetError(err, cmdkit.ErrNormal)
			return
		}

		nd, err := res.ResolvePath(req.Context, p)
		if err != nil {
			re.SetError(err, cmdkit.ErrNormal)
			return
		}

		re.Emit(nd)
	},
}

var IdCmd = &cmds.Command{
	Options: []cmdkit.Option{

		cmdkit.StringOption("format", "f", "specify an output format"),
	},
	Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) {
		tch := GetNode(env)

		var out idOutput
		for _, a := range tch.Host.Addrs() {
			out.Addresses = append(out.Addresses, a.String())
		}
		out.ID = tch.Host.ID().Pretty()

		re.Emit(&out)
	},
	Type: idOutput{},
	Encoders: cmds.EncoderMap{
		cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
			val, ok := v.(*idOutput)
			if !ok {
				return fmt.Errorf("unexpected type: %T", v)
			}

			format, found := req.Options["format"].(string)
			if found {
				output := format
				output = strings.Replace(output, "<id>", val.ID, -1)
				output = strings.Replace(output, "<aver>", val.AgentVersion, -1)
				output = strings.Replace(output, "<pver>", val.ProtocolVersion, -1)
				output = strings.Replace(output, "<pubkey>", val.PublicKey, -1)
				output = strings.Replace(output, "<addrs>", strings.Join(val.Addresses, "\n"), -1)
				output = strings.Replace(output, "\\n", "\n", -1)
				output = strings.Replace(output, "\\t", "\t", -1)
				_, err := fmt.Fprintln(w, output)
				return err
			} else {

				marshaled, err := json.MarshalIndent(val, "", "\t")
				if err != nil {
					return err
				}
				marshaled = append(marshaled, byte('\n'))
				_, err = w.Write(marshaled)
				return err
			}
		}),
	},
}

var RootCmd = &cmds.Command{
	Options: []cmdkit.Option{
		cmdkit.StringOption("api", "set the api port to use").WithDefault(":3453"),
		cmds.OptionEncodingType,
	},
	Subcommands: make(map[string]*cmds.Command),
}

var SwarmCmd = &cmds.Command{
	Helptext: cmdkit.HelpText{
		Tagline: "Interact with the swarm.",
		ShortDescription: `
'toychain swarm' is a tool to manipulate the libp2p swarm. The swarm is the
component that opens, listens for, and maintains connections to other
libp2p peers on the internet.
`,
	},
	Subcommands: map[string]*cmds.Command{

		"connect": swarmConnectCmd,
	},
}

var WalletCmd = &cmds.Command{
	Subcommands: map[string]*cmds.Command{
		"send":    WalletSendCmd,
		"balance": WalletGetBalanceCmd,
	},
}

var WalletGetBalanceCmd = &cmds.Command{
	Arguments: []cmdkit.Argument{
		cmdkit.StringArg("account", false, false, "account to get balance of"),
	},
	Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) {
		tch := GetNode(env)

		addr := tch.Addresses[0]
		if len(req.Arguments) > 0 {
			a, err := types.ParseAddress(req.Arguments[0])
			if err != nil {
				re.SetError(err, cmdkit.ErrNormal)
				return
			}
			addr = a
		}

		stroot := tch.StateMgr.GetStateRoot()
		act, err := stroot.GetActor(req.Context, contract.ToychainContractAddr)
		if err != nil {
			re.SetError(err, cmdkit.ErrNormal)
			return
		}

		ct, err := stroot.GetContract(req.Context, act.Code)
		if err != nil {
			re.SetError(err, cmdkit.ErrNormal)
			return
		}

		cst, err := stroot.LoadContractState(req.Context, act.Memory)
		if err != nil {
			re.SetError(err, cmdkit.ErrNormal)
			return
		}

		cctx := &contract.CallContext{Ctx: req.Context, ContractState: cst}
		val, err := ct.Call(cctx, "getBalance", []interface{}{addr})
		if err != nil {
			re.SetError(err, cmdkit.ErrNormal)
			return
		}

		re.Emit(val)
	},
	Type: big.Int{},
	Encoders: cmds.EncoderMap{
		cmds.Text: cmds.MakeEncoder(func(req *cmds.Request, w io.Writer, v interface{}) error {
			val, ok := v.(*big.Int)
			if !ok {
				return fmt.Errorf("got unexpected type: %T", v)
			}
			fmt.Fprintln(w, val.String())
			return nil
		}),
	},
}

var WalletSendCmd = &cmds.Command{
	Arguments: []cmdkit.Argument{
		cmdkit.StringArg("value", true, false, "amount to send"),
		cmdkit.StringArg("to", true, false, "actor to send transaction to"),
	},
	Run: func(req *cmds.Request, re cmds.ResponseEmitter, env cmds.Environment) {
		tch := GetNode(env)

		amount, ok := big.NewInt(0).SetString(req.Arguments[0], 10)
		if !ok {
			re.SetError("failed to parse amount", cmdkit.ErrNormal)
			return
		}
		toaddr, err := types.ParseAddress(req.Arguments[1])
		if err != nil {
			re.SetError(err, cmdkit.ErrNormal)
			return
		}

		from := tch.Addresses[0]

		nonce, err := tch.StateMgr.GetStateRoot().NonceForActor(req.Context, from)
		if err != nil {
			re.SetError(err, cmdkit.ErrNormal)
			return
		}

		tx := &types.Transaction{
			From:   from,
			To:     contract.ToychainContractAddr,
			Nonce:  nonce,
			Method: "transfer",
			Params: []interface{}{toaddr, amount},
		}

		tch.SendNewTransaction(tx)
	},
}

TODO: this command should exist in some form, but its really specialized. The issue is that its really 'call transfer on the toychain token contract and send tokens from our default account to a given actor'.

Functions

func DaemonIsRunning

func DaemonIsRunning() (bool, error)

func GetNode

func GetNode(env cmds.Environment) *core.ToychainNode

Types

type CommandEnv

type CommandEnv struct {
	Node *core.ToychainNode
	// contains filtered or unexported fields
}

func (*CommandEnv) Context

func (ce *CommandEnv) Context() context.Context