func FactoidAddInput(key, name, amount string) {
msg, valid := ValidateKey(key)
if !valid {
fmt.Println(msg)
os.Exit(1)
}
amt, err := factoid.ConvertFixedPoint(amount)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
ramt, err := strconv.ParseInt(amt, 10, 64)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
_, err = factoid.ValidateAmounts(uint64(ramt))
if err != nil {
fmt.Println(err)
os.Exit(1)
}
str := fmt.Sprintf("http://%s/v1/factoid-add-input/?key=%s&name=%s&amount=%s",
serverfactoid, key, name, amt)
SendCommand(false, str)
return
}
func FactoidAddFee(trans fct.ITransaction, key string, address fct.IAddress, name string) (uint64, error) {
{
ins, err := trans.TotalInputs()
if err != nil {
return 0, err
}
outs, err := trans.TotalOutputs()
if err != nil {
return 0, err
}
ecs, err := trans.TotalECs()
if err != nil {
return 0, err
}
if ins != outs+ecs {
return 0, fmt.Errorf("Inputs and outputs don't add up")
}
}
ok := Utility.IsValidKey(key)
if !ok {
return 0, fmt.Errorf("Invalid name for transaction")
}
fee, err := GetFee()
if err != nil {
return 0, err
}
transfee, err := trans.CalculateFee(uint64(fee))
if err != nil {
return 0, err
}
adr, err := factoidState.GetWallet().GetAddressHash(address)
if err != nil {
return 0, err
}
for _, input := range trans.GetInputs() {
if input.GetAddress().IsSameAs(adr) {
amt, err := fct.ValidateAmounts(input.GetAmount(), transfee)
if err != nil {
return 0, err
}
input.SetAmount(amt)
return transfee, nil
}
}
return 0, fmt.Errorf("%s is not an input to the transaction.", key)
}
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
}
// Returns an error message about what is wrong with the transaction if it is
// invalid, otherwise you are good to go.
func (fs *FactoidState) Validate(index int, trans fct.ITransaction) error {
err := fs.currentBlock.ValidateTransaction(index, trans)
if err != nil {
return err
}
var sums = make(map[[32]byte]uint64, 10) // Look at the sum of an address's inputs
for _, input := range trans.GetInputs() { // to a transaction.
bal, err := fct.ValidateAmounts(sums[input.GetAddress().Fixed()], input.GetAmount())
if err != nil {
return err
}
if bal > fs.GetBalance(input.GetAddress()) {
return fmt.Errorf("Not enough funds in input addresses for the transaction")
}
sums[input.GetAddress().Fixed()] = bal
}
return nil
}
func fctaddoutput(args []string) {
os.Args = args
flag.Parse()
args = flag.Args()
if len(args) < 3 {
fmt.Println("Expecting a 1) transaction key, 2) an Address or Address name, and 3) an amount.")
os.Exit(1)
}
// localhost:8089/v1/factoid-add-input/?key=<key>&name=<name or address>&amount=<amount>
msg, valid := ValidateKey(args[0])
if !valid {
fmt.Println(msg)
os.Exit(1)
}
amt, err := fct.ConvertFixedPoint(args[2])
if err != nil {
fmt.Println("Invalid format for a number: ", args[2])
man("addoutput")
os.Exit(1)
}
ramt, err := strconv.ParseInt(amt, 10, 64)
if err != nil {
fmt.Println(err)
os.Exit(1)
}
_, err = fct.ValidateAmounts(uint64(ramt))
if err != nil {
fmt.Println(err)
os.Exit(1)
}
str := fmt.Sprintf("http://%s/v1/factoid-add-output/?key=%s&name=%s&amount=%s",
serverFct, args[0], args[1], amt)
postCmd(str)
return
}
// Returns an error message about what is wrong with the transaction if it is
// invalid, otherwise you are good to go.
func (fs *AssetState) Validate(trans fct.ITransaction) error {
if err := trans.ValidateSignatures(); err != nil {
return err
}
var sums = make(map[fct.IAddress]uint64, 10)
for _, input := range trans.GetInputs() {
bal, err := fct.ValidateAmounts(
sums[input.GetAddress()], // Will be zero the first time around
input.GetAmount()) // Get this amount, check against bounds
if err != nil {
return err
}
if bal > fs.GetBalance(input.GetAddress()) {
return fmt.Errorf("Not enough funds in input addresses for the transaction")
}
sums[input.GetAddress()] = bal
}
return nil
}