faucet

api/client/client.go

@@ -224,44 +224,50 @@ func (c *APIClient) GetSimpleSigLockedOutputs(addr ledger.AddressED25519, maxOut
 	return ret, &retLRBID, nil
 }
 
-func (c *APIClient) GetOutputsForAmount(addr ledger.AddressED25519, amount uint64) ([]*ledger.OutputWithID, *ledger.TransactionID, error) {
+func (c *APIClient) GetOutputsForAmount(addr ledger.AddressED25519, amount uint64) ([]*ledger.OutputWithID, *ledger.TransactionID, uint64, error) {
 	path := fmt.Sprintf(api.PathGetOutputsForAmount+"?addr=%s&amount=%d", addr.Source(), amount)
 	body, err := c.getBody(path)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, 0, err
 	}
 
 	var res api.OutputList
 	err = json.Unmarshal(body, &res)
 	if err != nil {
-		return nil, nil, err
+		return nil, nil, 0, err
 	}
 	if res.Error.Error != "" {
-		return nil, nil, fmt.Errorf("from server: %s", res.Error.Error)
+		return nil, nil, 0, fmt.Errorf("from server: %s", res.Error.Error)
 	}
 
 	retLRBID, err := ledger.TransactionIDFromHexString(res.LRBID)
 	if err != nil {
-		return nil, nil, fmt.Errorf("while parsing transaction ID: %s", res.Error.Error)
+		return nil, nil, 0, fmt.Errorf("while parsing transaction ID: %s", res.Error.Error)
 	}
 
 	ret := make([]*ledger.OutputWithID, 0, len(res.Outputs))
 
+	sum := uint64(0)
 	for idStr, dataStr := range res.Outputs {
 		id, err := ledger.OutputIDFromHexString(idStr)
 		if err != nil {
-			return nil, nil, fmt.Errorf("wrong output ID data from server: %s: '%w'", idStr, err)
+			return nil, nil, 0, fmt.Errorf("wrong output ID data from server: %s: '%w'", idStr, err)
 		}
 		o, err := ledger.OutputFromHexString(dataStr)
 		if err != nil {
-			return nil, nil, fmt.Errorf("wrong output data from server: %s: '%w'", dataStr, err)
+			return nil, nil, 0, fmt.Errorf("wrong output data from server: %s: '%w'", dataStr, err)
 		}
 		ret = append(ret, &ledger.OutputWithID{
 			ID:     id,
 			Output: o,
 		})
+		sum += o.Amount()
 	}
-	return ret, &retLRBID, nil
+	if sum < amount {
+		// double check
+		return nil, nil, 0, fmt.Errorf("inconsistency: server returned not enough tokens")
+	}
+	return ret, &retLRBID, sum, nil
 }
 
 // GetChainedOutputs fetches all outputs of the account. Optionally sorts them on the server
@@ -635,18 +641,18 @@ func (c *APIClient) TransferFromED25519Wallet(par TransferFromED25519WalletParam
 		return nil, fmt.Errorf("minimum transfer amount is %d", minimumTransferAmount)
 	}
 	walletAccount := ledger.AddressED25519FromPrivateKey(par.WalletPrivateKey)
-	nowisTs := ledger.TimeNow()
-
-	walletOutputs, _, _, err := c.GetTransferableOutputs(walletAccount, par.MaxOutputs)
-
+	walletOutputs, _, _, err := c.GetOutputsForAmount(walletAccount, par.Amount+par.TagAlongFee)
+	if err != nil {
+		return nil, err
+	}
 	txBytes, err := MakeTransferTransaction(MakeTransferTransactionParams{
 		Inputs:        walletOutputs,
 		Target:        par.Target,
 		Amount:        par.Amount,
 		PrivateKey:    par.WalletPrivateKey,
 		TagAlongSeqID: par.TagAlongSeqID,
 		TagAlongFee:   par.TagAlongFee,
-		Timestamp:     nowisTs,
+		Timestamp:     ledger.TimeNow(),
 	})
 	if err != nil {
 		return nil, err

api/server/server.go

@@ -276,7 +276,7 @@ func (srv *server) getOutputsForAmount(w http.ResponseWriter, r *http.Request) {
 	})
 
 	if sum < uint64(amount) {
-		writeErr(w, "not enough tokens")
+		writeErr(w, fmt.Sprintf("not enough tokens: < than requested %s", util.Th(amount)))
 		return
 	}
 

proxi/glb/profile.go

@@ -145,7 +145,7 @@ func GetTagAlongSequencerID() *ledger.ChainID {
 		Infof("using tag_along sequencer: %s", seqIDStr)
 	}
 	if seqIDStr == "" {
-		return nil
+		return GetOwnSequencerID()
 	}
 	ret, err := ledger.ChainIDFromHexString(seqIDStr)
 	AssertNoError(err)