vault

Documentation

Index

• Variables
• type VaultAddrCmdRet
• type VaultBalanceCmdRet
• type VaultDepositCmdRet
• type VaultUpgradeCmdRet
• type VaultWbttBalanceCmdRet
• type VaultWithdrawCmdRet

Variables

var VaultAddrCmd = &cmds.Command{
	Helptext: cmds.HelpText{
		Tagline: "Get vault address.",
	},
	RunTimeout: 5 * time.Minute,
	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
		err := utils.CheckSimpleMode(env)
		if err != nil {
			return err
		}

		addr := chain.SettleObject.VaultService.Address()

		return cmds.EmitOnce(res, &VaultAddrCmdRet{
			Addr: addr.String(),
		})
	},
	Type: &VaultAddrCmdRet{},
	Encoders: cmds.EncoderMap{
		cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *VaultAddrCmdRet) error {
			_, err := fmt.Fprintf(w, "the vault addr: %s", out.Addr)
			return err
		}),
	},
}

var VaultBalanceAllCmd = &cmds.Command{
	Helptext: cmds.HelpText{
		Tagline: "Get vault balance.",
	},
	RunTimeout: 5 * time.Minute,
	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
		err := utils.CheckSimpleMode(env)
		if err != nil {
			return err
		}

		mp := make(map[string]*big.Int, 0)
		for k, tokenAddr := range tokencfg.MpTokenAddr {
			balance, err := chain.SettleObject.VaultService.AvailableBalance(context.Background(), tokenAddr)
			if err != nil {
				return err
			}

			mp[k] = balance
		}

		return cmds.EmitOnce(res, &mp)
	},
	Type: &VaultBalanceCmdRet{},
	Encoders: cmds.EncoderMap{
		cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *VaultBalanceCmdRet) error {
			_, err := fmt.Fprintf(w, "the vault available balance: %v\n", out.Balance)
			return err
		}),
	},
}

var VaultBalanceCmd = &cmds.Command{
	Helptext: cmds.HelpText{
		Tagline: "Get vault balance.",
	},
	RunTimeout: 5 * time.Minute,
	Options: []cmds.Option{
		cmds.StringOption(tokencfg.TokenTypeName, "tk", "file storage with token type,default WBTT, other TRX/USDD/USDT.").WithDefault("WBTT"),
	},
	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
		err := utils.CheckSimpleMode(env)
		if err != nil {
			return err
		}

		tokenStr := req.Options[tokencfg.TokenTypeName].(string)

		token, bl := tokencfg.MpTokenAddr[tokenStr]
		if !bl {
			return errors.New("your input token is none. ")
		}

		balance, err := chain.SettleObject.VaultService.AvailableBalance(context.Background(), token)
		if err != nil {
			return err
		}

		return cmds.EmitOnce(res, &VaultBalanceCmdRet{
			Balance: balance,
		})
	},
	Type: &VaultBalanceCmdRet{},
	Encoders: cmds.EncoderMap{
		cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *VaultBalanceCmdRet) error {
			_, err := fmt.Fprintf(w, "the vault available balance: %v\n", out.Balance)
			return err
		}),
	},
}

var VaultCmd = &cmds.Command{
	Helptext: cmds.HelpText{
		Tagline: "Interact with vault services on BTFS.",
		ShortDescription: `
Vault services include balance, address, withdraw, deposit operations.`,
	},
	Subcommands: map[string]*cmds.Command{
		"balance":     VaultBalanceCmd,
		"balance_all": VaultBalanceAllCmd,
		"address":     VaultAddrCmd,
		"withdraw":    VaultWithdrawCmd,
		"deposit":     VaultDepositCmd,
		"wbttbalance": VaultWbttBalanceCmd,
		"upgrade":     VaultUpgradeCmd,
	},
}

var VaultDepositCmd = &cmds.Command{
	Helptext: cmds.HelpText{
		Tagline: "Deposit from beneficiary to vault contract account.",
	},
	Arguments: []cmds.Argument{
		cmds.StringArg("amount", true, false, "deposit amount."),
	},
	Options: []cmds.Option{
		cmds.StringOption(tokencfg.TokenTypeName, "tk", "file storage with token type,default WBTT, other TRX/USDD/USDT.").WithDefault("WBTT"),
	},
	RunTimeout: 5 * time.Minute,
	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
		err := utils.CheckSimpleMode(env)
		if err != nil {
			return err
		}

		argAmount := utils.RemoveSpaceAndComma(req.Arguments[0])
		amount, ok := new(big.Int).SetString(argAmount, 10)
		if !ok {
			return fmt.Errorf("amount:%s cannot be parsed", req.Arguments[0])
		}

		tokenStr := req.Options[tokencfg.TokenTypeName].(string)

		token, bl := tokencfg.MpTokenAddr[tokenStr]
		if !bl {
			return errors.New("your input token is none. ")
		}

		hash, err := chain.SettleObject.VaultService.Deposit(context.Background(), amount, token)
		if err != nil {
			return err
		}

		return cmds.EmitOnce(res, &VaultDepositCmdRet{
			Hash: hash.String(),
		})
	},
	Type: &VaultDepositCmdRet{},
	Encoders: cmds.EncoderMap{
		cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *VaultDepositCmdRet) error {
			_, err := fmt.Fprintf(w, "the hash of transaction: %s\n", out.Hash)
			return err
		}),
	},
}

var VaultUpgradeCmd = &cmds.Command{
	Helptext: cmds.HelpText{
		Tagline: "Upgrade vault contract to the latest version",
		ShortDescription: `
If peers are using different vault versions, they can't upload/receive files to/from each other.
So we highly recommend you to upgrade your vault to the latest version. Finally, upgrading only
upgrade your vault contract's version, and won't modify any data in your vault.`,
	},
	RunTimeout: 5 * time.Minute,
	Type:       &VaultUpgradeCmdRet{},
	Encoders: cmds.EncoderMap{
		cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *VaultUpgradeCmdRet) error {
			if out.Upgraded {
				fmt.Fprintf(w, "vault version upgraded from %s to %s successfully\n", out.OldVaultImpl, out.NewVaultImpl)
			} else {
				fmt.Fprintf(w, "%s\n", out.Description)
			}
			return nil
		}),
	},
	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
		err := utils.CheckSimpleMode(env)
		if err != nil {
			return err
		}

		oldImpl, newImpl, err := chain.SettleObject.VaultService.UpgradeTo(context.Background(), chain.ChainObject.Chainconfig.VaultLogicAddress)
		upgraded := true
		description := ""
		if err != nil {
			upgraded = false
			description = fmt.Sprintf("%v", err)
		}
		return cmds.EmitOnce(res, &VaultUpgradeCmdRet{
			Upgraded:     upgraded,
			Description:  description,
			OldVaultImpl: fmt.Sprintf("%s", oldImpl),
			NewVaultImpl: fmt.Sprintf("%s", newImpl),
		})
	},
}

var VaultWbttBalanceCmd = &cmds.Command{
	Helptext: cmds.HelpText{
		Tagline: "Get wbtt balance by addr.",
	},
	Arguments: []cmds.Argument{
		cmds.StringArg("addr", true, false, "wbtt token address"),
	},
	RunTimeout: 5 * time.Minute,
	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
		err := utils.CheckSimpleMode(env)
		if err != nil {
			return err
		}

		addr := req.Arguments[0]
		balance, err := chain.SettleObject.VaultService.WBTTBalanceOf(context.Background(), common.HexToAddress(addr))
		if err != nil {
			return err
		}

		return cmds.EmitOnce(res, &VaultBalanceCmdRet{
			Balance: balance,
		})
	},
	Type: &VaultWbttBalanceCmdRet{},
	Encoders: cmds.EncoderMap{
		cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *VaultWbttBalanceCmdRet) error {
			_, err := fmt.Fprintf(w, "the balance is: %v\n", out.Balance)
			return err
		}),
	},
}

var VaultWithdrawCmd = &cmds.Command{
	Helptext: cmds.HelpText{
		Tagline: "Withdraw from vault contract account to beneficiary.",
	},
	Arguments: []cmds.Argument{
		cmds.StringArg("amount", true, false, "withdraw amount."),
	},
	Options: []cmds.Option{
		cmds.StringOption(tokencfg.TokenTypeName, "tk", "file storage with token type,default WBTT, other TRX/USDD/USDT.").WithDefault("WBTT"),
	},
	RunTimeout: 5 * time.Minute,
	Run: func(req *cmds.Request, res cmds.ResponseEmitter, env cmds.Environment) error {
		err := utils.CheckSimpleMode(env)
		if err != nil {
			return err
		}

		argAmount := utils.RemoveSpaceAndComma(req.Arguments[0])
		amount, ok := new(big.Int).SetString(argAmount, 10)
		if !ok {
			return fmt.Errorf("amount:%s cannot be parsed", req.Arguments[0])
		}

		tokenStr := req.Options[tokencfg.TokenTypeName].(string)

		token, bl := tokencfg.MpTokenAddr[tokenStr]
		if !bl {
			return errors.New("your input token is none. ")
		}

		hash, err := chain.SettleObject.VaultService.Withdraw(context.Background(), amount, token)
		if err != nil {
			return err
		}

		return cmds.EmitOnce(res, &VaultWithdrawCmdRet{
			Hash: hash.String(),
		})
	},
	Type: &VaultWithdrawCmdRet{},
	Encoders: cmds.EncoderMap{
		cmds.Text: cmds.MakeTypedEncoder(func(req *cmds.Request, w io.Writer, out *VaultWithdrawCmdRet) error {
			_, err := fmt.Fprintf(w, "the hash of transaction: %s", out.Hash)
			return err
		}),
	},
}

Types

type VaultAddrCmdRet

type VaultAddrCmdRet struct {
	Addr string `json:"addr"`
}

type VaultBalanceCmdRet

type VaultBalanceCmdRet struct {
	Balance *big.Int `json:"balance"`
}

type VaultDepositCmdRet

type VaultDepositCmdRet struct {
	Hash string `json:"hash"`
}

type VaultUpgradeCmdRet

type VaultUpgradeCmdRet struct {
	Upgraded     bool   `json:"upgraded"`
	Description  string `json:"Description"`
	OldVaultImpl string `json:"OldVaultImpl"`
	NewVaultImpl string `json:"NewVaultImpl"`
}

type VaultWbttBalanceCmdRet

type VaultWbttBalanceCmdRet struct {
	Balance *big.Int `json:"balance"`
}

type VaultWithdrawCmdRet

type VaultWithdrawCmdRet struct {
	Hash string `json:"hash"`
}