transform

main.go

package transform

import (
	"github.com/spf13/cobra"
	"github.com/tendermint/go-amino"
	"github.com/irisnet/irishub/codec"
	"github.com/irisnet/irishub/app"

	"github.com/irisnet/irishub/server"
	"github.com/spf13/viper"
	"github.com/tendermint/tendermint/libs/cli"
	"github.com/tendermint/tendermint/types"
	"io/ioutil"
	sdk "github.com/irisnet/irishub/types"

	"fmt"
	"github.com/irisnet/irishub/client/context"
	"github.com/irisnet/irishub/client/utils"
	"github.com/irisnet/irishub/app/v0"
	tool "github.com/irisnet/irishub/server/init"
	"github.com/tendermint/tendermint/libs/common"
	"os"
)

func init() {
	cobra.EnableCommandSorting = false
	cdc := app.MakeLatestCodec()
	ctx := server.NewDefaultContext()
	RootCmd.AddCommand(runTxCmd(ctx, cdc))

}

var RootCmd = &cobra.Command{
	Use:          "genesis",
	Short:        "Iris genesis tranform tool",
	SilenceUsage: true,
}

func runTxCmd(ctx *server.Context, cdc *codec.Codec) *cobra.Command {
	cmd := &cobra.Command{
		Use:   "transform",
		Short: "transform a genesis.json file",
		Args:  cobra.ExactArgs(1),
		RunE: func(_ *cobra.Command, args []string) error {
			tokenUnit := args[0]
			//filePath := args[1]
			config := ctx.Config
			config.SetRoot(viper.GetString(cli.HomeFlag))


			cliCtx := context.NewCLIContext().
				WithCodec(cdc).
				WithLogger(os.Stdout).
				WithAccountDecoder(utils.GetAccountDecoder(cdc))

			genFile := config.GenesisFile()
			if !common.FileExists(genFile) {
				return fmt.Errorf("%s does not exist, run `iris init` first", genFile)
			}
			genDoc, err := loadGenesisDoc(cdc, genFile)
			if err != nil {
				return err
			}
			var genesisState v0.GenesisFileState
			if err = cdc.UnmarshalJSON(genDoc.AppState, &genesisState); err != nil {
				return err
			}

			coinType, err := cliCtx.GetCoinType("iris")


			//transform accounts
			length := len(genesisState.Accounts)
			for i := 0;i<length;i++{
				var result []string
				coins := genesisState.Accounts[i].Coins
				for _,c := range coins{

					newCoin,_ := coinType.Convert(c,tokenUnit)
					result = append(result,newCoin)

					if err != nil {
						return err
					}

				}
				genesisState.Accounts[i].Coins = result

			}


            //transform gov

			//critical_min_deposit

			//genesisState.GovData.Params.CriticalMinDeposit = transformCoin(genesisState.GovData.Params.CriticalMinDeposit,ctx,cdc,"iris")
			//
			////important_min_deposit
			//
			//genesisState.GovData.Params.ImportantMinDeposit = transformCoin(genesisState.GovData.Params.ImportantMinDeposit,ctx,cdc,"iris")
			//
			////normal_min_deposit
			//
			//genesisState.GovData.Params.NormalMinDeposit = transformCoin(genesisState.GovData.Params.NormalMinDeposit,ctx,cdc,"iris")

			appStateJSON, err := cdc.MarshalJSON(genesisState)
			if err != nil {
				return err
			}
			return tool.ExportGenesisFileWithTime(genFile, genDoc.ChainID, nil, appStateJSON,genDoc.GenesisTime)

		},
	}

	cmd.Flags().String(cli.HomeFlag, app.DefaultNodeHome, "node's home directory")
	return cmd
}

func loadGenesisDoc(cdc *amino.Codec, genFile string) (genDoc types.GenesisDoc, err error) {
	genContents, err := ioutil.ReadFile(genFile)
	if err != nil {
		return genDoc, err
	}

	if err := cdc.UnmarshalJSON(genContents, &genDoc); err != nil {
		return genDoc, err
	}

	return genDoc, err
}

func transformCoin(input sdk.Coins,ctx *server.Context, cdc *codec.Codec,tokenUnit string) sdk.Coins {

	var newDeposit sdk.Coins

	cliCtx := context.NewCLIContext().
		WithCodec(cdc).
		WithLogger(os.Stdout).
		WithAccountDecoder(utils.GetAccountDecoder(cdc))

	coinType, err := cliCtx.GetCoinType("iris")
	if err != nil {
		return nil
	}

	for _,d := range input{

		newCoin,err := coinType.Convert(d.String(),tokenUnit)
		denom, amt, err := sdk.GetCoin(newCoin)
		amount,_ := sdk.NewIntFromString(amt)
		if err != nil {
			return nil
		}
		coin := sdk.NewCoin(denom,amount)
		newDeposit = append(newDeposit,coin)

	}

	return newDeposit
}

package main

import (
"os"

"github.com/spf13/cobra"
debugcmd "github.com/irisnet/irishub/tools/debug"
"github.com/irisnet/irishub/app"
"github.com/tendermint/tendermint/libs/cli"
"github.com/irisnet/irishub/tools/transform"

)

func init() {
// sdk.InitBech32Prefix()
rootCmd.AddCommand(debugcmd.RootCmd)
rootCmd.AddCommand(transform.RootCmd)
}

var rootCmd = &cobra.Command{
Use: "iristool",
Short: "Iris tool",
SilenceUsage: true,
}

func main() {
executor := cli.PrepareMainCmd(rootCmd, "IRIS", app.DefaultNodeHome)
err := executor.Execute()
if err != nil {
os.Exit(1)
}
os.Exit(0)
}