Golang factoid.ConvertDecimal函数代码示例

// Seals the current open block, store it in db and create the next open block
func newFactoidBlock(chain *common.FctChain) block.IFBlock {

	older := FactoshisPerCredit

	cfg := util.ReReadConfig()
	FactoshisPerCredit = cfg.App.ExchangeRate

	rate := fmt.Sprintf("Current Exchange rate is %v",
		strings.TrimSpace(fct.ConvertDecimal(FactoshisPerCredit)))
	if older != FactoshisPerCredit {

		orate := fmt.Sprintf("The Exchange rate was    %v\n",
			strings.TrimSpace(fct.ConvertDecimal(older)))

		cp.CP.AddUpdate(
			"Fee",    // tag
			"status", // Category
			"Entry Credit Exchange Rate Changed", // Title
			orate+rate,
			0)
	} else {
		cp.CP.AddUpdate(
			"Fee",                        // tag
			"status",                     // Category
			"Entry Credit Exchange Rate", // Title
			rate,
			0)
	}

	// acquire the last block
	currentBlock := chain.NextBlock

	if chain.NextBlockHeight != dchain.NextDBHeight {
		panic("Factoid Block height does not match Directory Block height:" + strconv.Itoa(int(dchain.NextDBHeight)))
	}

	chain.BlockMutex.Lock()
	chain.NextBlockHeight++
	common.FactoidState.SetFactoshisPerEC(FactoshisPerCredit)
	common.FactoidState.ProcessEndOfBlock2(chain.NextBlockHeight)
	chain.NextBlock = common.FactoidState.GetCurrentBlock()
	chain.BlockMutex.Unlock()

	//Store the block in db
	db.ProcessFBlockBatch(currentBlock)
	procLog.Infof("Factoid chain: block " + strconv.FormatUint(uint64(currentBlock.GetDBHeight()), 10) + " created for chain: " + chain.ChainID.String())

	return currentBlock
}

func (b FBlock) ValidateTransaction(index int, trans fct.ITransaction) error {
	// Calculate the fee due.
	{
		err := trans.Validate(index)
		if err != nil {
			return err
		}
	}

	//Ignore coinbase transaction's signatures
	if len(b.Transactions) > 0 {
		err := trans.ValidateSignatures()
		if err != nil {
			return err
		}
	}

	fee, err := trans.CalculateFee(b.ExchRate)
	if err != nil {
		return err
	}
	tin, err := trans.TotalInputs()
	if err != nil {
		return err
	}
	tout, err := trans.TotalOutputs()
	if err != nil {
		return err
	}
	tec, err := trans.TotalECs()
	if err != nil {
		return err
	}
	sum, err := fct.ValidateAmounts(tout, tec, fee)
	if err != nil {
		return err
	}

	if tin < sum {
		return fmt.Errorf("The inputs %s do not cover the outputs %s,\n"+
			"the Entry Credit outputs %s, and the required fee %s",
			strings.TrimSpace(fct.ConvertDecimal(tin)),
			strings.TrimSpace(fct.ConvertDecimal(tout)),
			strings.TrimSpace(fct.ConvertDecimal(tec)),
			strings.TrimSpace(fct.ConvertDecimal(fee)))
	}
	return nil
}

func HandleGetFee(ctx *web.Context, k string) {

	var trans fct.ITransaction
	var err error

	key := ctx.Params["key"]

	fmt.Println("getfee", key)

	if len(key) > 0 {
		trans, err = getTransaction(ctx, key)
		if err != nil {
			reportResults(ctx, "Failure to locate the transaction", false)
			return
		}
	}

	fee, err := Wallet.GetFee()
	if err != nil {
		reportResults(ctx, err.Error(), false)
		return
	}

	if trans != nil {
		ufee, _ := trans.CalculateFee(uint64(fee))
		fee = int64(ufee)
	}

	reportResults(ctx, fmt.Sprintf("%s", strings.TrimSpace(fct.ConvertDecimal(uint64(fee)))), true)
}

func currRate(w http.ResponseWriter, r *http.Request) {
	v, err := GetRate(myState)
	if err != nil {
		fmt.Println(err)
		return
	}
	w.Write([]byte(fct.ConvertDecimal(uint64(v))))
}

func HandleFactoidSubFee(ctx *web.Context, parms string) {
	trans, key, _, address, _, ok := getParams_(ctx, parms, false)
	if !ok {
		return
	}

	name := ctx.Params["name"] // This is the name the user used.

	{
		ins, err := trans.TotalInputs()
		if err != nil {
			reportResults(ctx, err.Error(), false)
			return
		}
		outs, err := trans.TotalOutputs()
		if err != nil {
			reportResults(ctx, err.Error(), false)
			return
		}
		ecs, err := trans.TotalECs()
		if err != nil {
			reportResults(ctx, err.Error(), false)
			return
		}

		if ins != outs+ecs {
			msg := fmt.Sprintf(
				"Subfee requires that all the inputs balance the outputs.\n"+
					"The total inputs of your transaction are              %s\n"+
					"The total outputs + ecoutputs of your transaction are %s",
				fct.ConvertDecimal(ins), fct.ConvertDecimal(outs+ecs))

			reportResults(ctx, msg, false)
			return
		}
	}

	transfee, err := Wallet.FactoidSubFee(trans, key, address, name)
	if err != nil {
		reportResults(ctx, err.Error(), false)
		return
	}

	reportResults(ctx, fmt.Sprintf("Subtracted %s from %s", fct.ConvertDecimal(uint64(transfee)), name), true)
	return
}

func GetAddresses() []byte {
	values := Wallet.GetAddresses()

	ecKeys := make([]string, 0, len(values))
	fctKeys := make([]string, 0, len(values))
	ecBalances := make([]string, 0, len(values))
	fctBalances := make([]string, 0, len(values))
	fctAddresses := make([]string, 0, len(values))
	ecAddresses := make([]string, 0, len(values))

	var maxlen int
	for _, we := range values {
		if len(we.GetName()) > maxlen {
			maxlen = len(we.GetName())
		}
		var adr string
		if we.GetType() == "ec" {
			address, err := we.GetAddress()
			if err != nil {
				continue
			}
			adr = fct.ConvertECAddressToUserStr(address)
			ecAddresses = append(ecAddresses, adr)
			ecKeys = append(ecKeys, string(we.GetName()))
			bal, _ := ECBalance(adr)
			ecBalances = append(ecBalances, strconv.FormatInt(bal, 10))
		} else {
			address, err := we.GetAddress()
			if err != nil {
				continue
			}
			adr = fct.ConvertFctAddressToUserStr(address)
			fctAddresses = append(fctAddresses, adr)
			fctKeys = append(fctKeys, string(we.GetName()))
			bal, _ := FctBalance(adr)
			sbal := fct.ConvertDecimal(uint64(bal))
			fctBalances = append(fctBalances, sbal)
		}
	}
	var out bytes.Buffer
	if len(fctKeys) > 0 {
		out.WriteString("\n  Factoid Addresses\n\n")
	}
	fstr := fmt.Sprintf("%s%vs    %s38s %s14s\n", "%", maxlen+4, "%", "%")
	for i, key := range fctKeys {
		str := fmt.Sprintf(fstr, key, fctAddresses[i], fctBalances[i])
		out.WriteString(str)
	}
	if len(ecKeys) > 0 {
		out.WriteString("\n  Entry Credit Addresses\n\n")
	}
	for i, key := range ecKeys {
		str := fmt.Sprintf(fstr, key, ecAddresses[i], ecBalances[i])
		out.WriteString(str)
	}

	return out.Bytes()
}

func fctbalance(addr string) error {
	if Utility.IsValidAddress(addr) && strings.HasPrefix(addr, "EC") {
		fmt.Println("Not a valid Entry Credit Address")
		return fmt.Errorf("Not a valid Entry Credit Address")
	}

	if b, err := factom.FctBalance(addr); err != nil {
		fmt.Println("Address undefined or invalid: " + err.Error())
		return err
	} else {
		fmt.Println("Balance of ", addr, " = ", fct.ConvertDecimal(uint64(b)))
	}

	return nil
}

func fctproperties(args []string) {

	getproperties := fmt.Sprintf("http://%s/v1/properties/", serverFct)

	resp, err := http.Get(getproperties)

	if err != nil {
		fmt.Println("Get Properties failed")
		os.Exit(1)
	}
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("Failed to understand response from fctwallet")
		os.Exit(1)
	}
	resp.Body.Close()

	// We pull the fee.  If the fee isn't positive, or if we fail to marshal, then there is a failure
	type x struct {
		Response string
		Success  bool
	}

	b := new(x)
	if err := json.Unmarshal(body, b); err != nil {
		fmt.Println(err)
		os.Exit(1)
	} else if !b.Success {
		fmt.Println(b.Response)
		os.Exit(1)
	}

	top := Version / 1000000
	mid := (Version % 1000000) / 1000
	low := Version % 1000

	ret := b.Response + fmt.Sprintf("factom-cli Version: %d.%d.%d\n", top, mid, low)

	total, err := Utility.TotalFactoids()
	if err == nil {
		ret = ret + fmt.Sprintf("    Total Factoids: %s", strings.TrimSpace(fct.ConvertDecimal(total)))
	}

	fmt.Println(ret)

}

func showFee(txKey string) []byte {
	ib := myState.GetFS().GetDB().GetRaw([]byte(fct.DB_BUILD_TRANS), []byte(txKey))
	trans, ok := ib.(fct.ITransaction)
	if ib != nil && ok {

		v, err := GetRate(myState)
		if err != nil {
			fmt.Println(err)
			return []byte("...")
		}
		fee, err := trans.CalculateFee(uint64(v))
		if err != nil {
			fmt.Println(err)
			return []byte("...")
		}
		return []byte(strings.TrimSpace(fct.ConvertDecimal(fee)))
	} else {
		return []byte("...")
	}

}

func reqFee(w http.ResponseWriter, r *http.Request) {
	txKey := r.FormValue("key")

	ib := myState.GetFS().GetDB().GetRaw([]byte(fct.DB_BUILD_TRANS), []byte(txKey))
	trans, ok := ib.(fct.ITransaction)
	if ib != nil && ok {

		v, err := GetRate(myState)
		if err != nil {
			fmt.Println(err)
			return
		}
		fee, err := trans.CalculateFee(uint64(v))
		if err != nil {
			fmt.Println(err)
			return
		}
		w.Write([]byte(strings.TrimSpace(fct.ConvertDecimal(fee))))
	} else {
		w.Write([]byte("..."))
	}

}

func (Balance) Execute(state IState, args []string) (err error) {
	if len(args) != 3 {
		return fmt.Errorf("Wrong number of parameters")
	}

	var bal int64
	switch strings.ToLower(args[1]) {
	case "ec":
		bal, err = ECBalance(state, args[2])
	case "fct":
		bal, err = FctBalance(state, args[2])
	default:
		return fmt.Errorf("Invalid parameters")
	}
	if err != nil {
		return err
	}
	if args[1] == "fct" {
		fmt.Println(args[2], "=", fct.ConvertDecimal(uint64(bal)))
	} else {
		fmt.Println(args[2], "=", bal)
	}
	return nil
}

func GetBalances(state IState) []byte {
	keys, values := state.GetFS().GetDB().GetKeysValues([]byte(fct.W_NAME))

	ecKeys := make([]string, 0, len(keys))
	fctKeys := make([]string, 0, len(keys))
	ecBalances := make([]string, 0, len(keys))
	fctBalances := make([]string, 0, len(keys))
	fctAddresses := make([]string, 0, len(keys))
	ecAddresses := make([]string, 0, len(keys))

	var maxlen int
	var connect = true
	for i, k := range keys {
		if len(k) > maxlen {
			maxlen = len(k)
		}
		we, ok := values[i].(wallet.IWalletEntry)
		if !ok {
			panic("Get Addresses finds the database corrupt.  Shouldn't happen")
		}
		var adr string
		if we.GetType() == "ec" {
			address, err := we.GetAddress()
			if err != nil {
				continue
			}
			adr = fct.ConvertECAddressToUserStr(address)
			ecAddresses = append(ecAddresses, adr)
			ecKeys = append(ecKeys, string(k))
			bal, err := ECBalance(state, adr)
			if err != nil {
				connect = false
			}
			if connect {
				ecBalances = append(ecBalances, strconv.FormatInt(bal, 10))
			} else {
				ecBalances = append(ecBalances, "-")
			}
		} else {
			address, err := we.GetAddress()
			if err != nil {
				continue
			}
			adr = fct.ConvertFctAddressToUserStr(address)
			fctAddresses = append(fctAddresses, adr)
			fctKeys = append(fctKeys, string(k))
			bal, err := FctBalance(state, adr)
			if err != nil {
				connect = false
			}
			sbal := fct.ConvertDecimal(uint64(bal))
			if connect {
				fctBalances = append(fctBalances, sbal)
			} else {
				fctBalances = append(fctBalances, "-")
			}
		}
	}
	var out bytes.Buffer
	if len(fctKeys) > 0 {
		out.WriteString("\n  Factoid Addresses\n\n")
	}
	fstr := fmt.Sprintf("%s%vs    %s38s %s14s\n", "%", maxlen+4, "%", "%")
	for i, key := range fctKeys {
		str := fmt.Sprintf(fstr, key, fctAddresses[i], fctBalances[i])
		out.WriteString(str)
	}
	if len(ecKeys) > 0 {
		out.WriteString("\n  Entry Credit Addresses\n\n")
	}
	for i, key := range ecKeys {
		str := fmt.Sprintf(fstr, key, ecAddresses[i], ecBalances[i])
		out.WriteString(str)
	}
	if !connect {
		out.WriteString("Balances are unavailable;  Wallet is offline\n")
	}
	return out.Bytes()
}

func (AddFee) Execute(state IState, args []string) (err error) {

	if len(args) != 3 && len(args) != 4 {
		return fmt.Errorf("Invalid Parameters")
	}
	key := args[1]
	adr := args[2]
	rate := int64(0)
	if len(args) == 4 {
		srate, err := fct.ConvertFixedPoint(args[3])
		if err != nil {
			return fmt.Errorf("Could not parse exchange rate: %v", err)
		}
		rate, err = strconv.ParseInt(srate, 10, 64)
	} else {
		if rate, err = GetRate(state); err != nil {
			return fmt.Errorf("Could not reach the server to get the exchange rate")
		}
	}

	ib := state.GetFS().GetDB().GetRaw([]byte(fct.DB_BUILD_TRANS), []byte(key))
	trans, ok := ib.(fct.ITransaction)
	if ib == nil || !ok {
		return fmt.Errorf("Unknown Transaction")
	}

	var addr fct.IAddress

	if fct.ValidateFUserStr(adr) {
		addr = fct.NewAddress(fct.ConvertUserStrToAddress(adr))
	} else if Utility.IsValidHexAddress(adr) {
		badr, _ := hex.DecodeString(adr)
		addr = fct.NewAddress(badr)
	} else if Utility.IsValidNickname(adr) {
		we := state.GetFS().GetDB().GetRaw([]byte(fct.W_NAME), []byte(adr))
		if we != nil {
			we2 := we.(wallet.IWalletEntry)
			addr, _ = we2.GetAddress()
			adr = hex.EncodeToString(addr.Bytes())
		} else {
			return fmt.Errorf("Name is undefined.")
		}
	}

	fee, err := trans.CalculateFee(uint64(rate))
	var tin, tout, tec uint64
	if tin, err = trans.TotalInputs(); err != nil {
		return err
	}
	if tout, err = trans.TotalOutputs(); err != nil {
		return err
	}
	if tec, err = trans.TotalECs(); err != nil {
		return err
	}

	if tin != tout+tec {
		msg := fmt.Sprintf("%s Total Inputs\n", fct.ConvertDecimal(tin))
		msg += fmt.Sprintf("%s Total Outputs and Entry Credits\n", fct.ConvertDecimal(tout+tec))
		msg += fmt.Sprintf("\nThe Inputs must match the outputs to use AddFee to add the fee to an input")
		return fmt.Errorf(msg)
	}

	for _, input := range trans.GetInputs() {
		if bytes.Equal(input.GetAddress().Bytes(), addr.Bytes()) {
			input.SetAmount(input.GetAmount() + fee)
			fmt.Printf("Added fee of %v\n", strings.TrimSpace(fct.ConvertDecimal(fee)))
			break
		}
	}

	return nil
}

func (fs *Test_state) newTransaction() fct.ITransaction {
	var maxBal, sum uint64
	fs.inputAddresses = make([]fct.IAddress, 0, 20)

	for _, output := range fs.outputAddresses {
		bal := fs.GetBalance(output)
		if bal > 100000000 {
			fs.inputAddresses = append(fs.inputAddresses, output)
			sum += bal
		}
		if maxBal < bal {
			maxBal = bal
		}
	}

	avgBal := sum / uint64(len(fs.inputAddresses))

	if fs.stats.transactions == 0 {
		fs.stats.MaxBal = maxBal
		fs.stats.AvgBal = avgBal
	} else {
		fs.stats.MaxBal = (fs.stats.MaxBal*uint64(fs.stats.transactions) + maxBal) / uint64(fs.stats.transactions+1)
		fs.stats.AvgBal = (fs.stats.AvgBal*uint64(fs.stats.transactions) + avgBal) / uint64(fs.stats.transactions+1)
	}

	cp.CP.AddUpdate(
		"Test max min inputs", // tag
		"info",                // Category
		"Tests generation",    // Title
		fmt.Sprintf("Input Addresses %d\n"+
			"Total Max balance %15s, Average Balance %15s\n"+
			"Last  Max balance %15s, Average Balance %16s",
			len(fs.inputAddresses),
			strings.TrimSpace(fct.ConvertDecimal(fs.stats.MaxBal)),
			strings.TrimSpace(fct.ConvertDecimal(fs.stats.AvgBal)),
			strings.TrimSpace(fct.ConvertDecimal(maxBal)),
			strings.TrimSpace(fct.ConvertDecimal(avgBal))), // Msg
		0) // Expire

	// The following code is a function that creates an array
	// of addresses pulled from some source array of addresses
	// selected randomly.
	var makeList = func(source []fct.IAddress, cnt int) []fct.IAddress {
		adrs := make([]fct.IAddress, 0, cnt)
		for len(adrs) < cnt {
			var i int
			if len(source) == 0 {
				return adrs
			}
			i = rand.Int() % len(source)
			adr := source[i]
			adrs = append(adrs, adr)
		}
		return adrs
	}

	// Get one to five inputs, and one to five outputs
	numInputs := fs.getRnd()
	numOutputs := fs.getRnd()
	mumECOutputs := fs.getRnd()

	if avgBal > 10000000000 {
		numOutputs = 0
	} // Throw away Factoids if too much money in the system

	lim := len(fs.inputAddresses) - 2
	if lim <= 0 {
		lim = 1
	}
	numInputs = (numInputs % (lim)) + 1

	// fmt.Println("inputs outputs",numInputs,numOutputs, "limits",len(fs.inputAddresses),len(fs.outputAddresses))

	// Get my input and output addresses
	inputs := makeList(fs.inputAddresses, numInputs)
	outputs := makeList(fs.outputAddresses, numOutputs)
	ecoutputs := makeList(fs.ecoutputAddresses, mumECOutputs)
	var paid uint64
	t := fs.twallet.CreateTransaction(fs.GetTimeMilli())
	for _, adr := range inputs {
		balance := fs.GetBalance(adr)
		toPay := uint64(rand.Int63()) % (balance / 2)
		paid = toPay + paid
		fs.twallet.AddInput(t, adr, toPay)
	}

	paid = paid - fs.GetFactoshisPerEC()*uint64(len(ecoutputs))

	for _, adr := range outputs {
		fs.twallet.AddOutput(t, adr, paid/uint64(len(outputs)))
	}

	for _, adr := range ecoutputs {
		fs.twallet.AddECOutput(t, adr, fs.GetFactoshisPerEC())
	}

	fee, _ := t.CalculateFee(fs.GetFactoshisPerEC())
	toPay := t.GetInputs()[0].GetAmount()
	fs.twallet.UpdateInput(t, 0, inputs[0], toPay+fee)

//.........这里部分代码省略.........

// Specifying a fee overrides either not being connected, or the current fee.
// Params:
//   key (limit printout to this key)
//   fee (specify the transation fee)
func GetTransactions(ctx *web.Context) ([]byte, error) {
	connected := true

	var _ = connected

	exch, err := GetFee(ctx) // The Fee will be zero if we have no connection.
	if err != nil {
		connected = false
	}

	keys, transactions, err := Wallet.GetTransactions()
	if err != nil {
		return nil, err
	}

	var out bytes.Buffer
	for i, trans := range transactions {

		fee, _ := trans.CalculateFee(uint64(exch))
		cprt := ""
		cin, err := trans.TotalInputs()
		if err != nil {
			cprt = cprt + err.Error()
		}
		cout, err := trans.TotalOutputs()
		if err != nil {
			cprt = cprt + err.Error()
		}
		cecout, err := trans.TotalECs()
		if err != nil {
			cprt = cprt + err.Error()
		}

		if len(cprt) == 0 {
			v := int64(cin) - int64(cout) - int64(cecout)
			sign := ""
			if v < 0 {
				sign = "-"
				v = -v
			}
			cprt = fmt.Sprintf(" Currently will pay: %s%s",
				sign,
				strings.TrimSpace(fct.ConvertDecimal(uint64(v))))
			if sign == "-" || fee > uint64(v) {
				cprt = cprt + "\n\nWARNING: Currently your transaction fee may be too low"
			}
		}

		out.WriteString(fmt.Sprintf("%s:  Fee Due: %s  %s\n\n%s\n",
			strings.TrimSpace(strings.TrimRight(string(keys[i]), "\u0000")),
			strings.TrimSpace(fct.ConvertDecimal(fee)),
			cprt,
			transactions[i].String()))
	}

	output := out.Bytes()
	// now look for the addresses, and replace them with our names. (the transactions
	// in flight also have a Factom address... We leave those alone.

	names, vs := Wallet.GetWalletNames()

	for i, name := range names {
		we, ok := vs[i].(wallet.IWalletEntry)
		if !ok {
			return nil, fmt.Errorf("Database is corrupt")
		}

		address, err := we.GetAddress()
		if err != nil {
			continue
		} // We shouldn't get any of these, but ignore them if we do.
		adrstr := []byte(hex.EncodeToString(address.Bytes()))

		output = bytes.Replace(output, adrstr, name, -1)
	}

	return output, nil
}