Allow tx without budget

utt/admin-cli/include/admin.hpp

@@ -33,7 +33,7 @@ class Admin {
   /// [TODO-UTT] Should be performed by an admin app
   /// @brief Deploy a privacy application
   /// @return The public configuration of the deployed application
-  static bool deployApp(Channel& chan, bool budget_policy = true);
+  static bool deployApp(Channel& chan, bool budget_policy);
 
   /// @brief Request the creation of a privacy budget. The amount of the budget is predetermined by the deployed app.
   /// This operation could be performed entirely by an administrator, but we add it in the admin

utt/include/UTTParams.hpp

@@ -57,12 +57,12 @@ class UTTParams {
   UTTParams& operator=(UTTParams&&) = default;
 
   bool getBudgetPolicy() const;
+  bool budget_policy = true;
 
  private:
   friend std::ostream& ::operator<<(std::ostream& out, const libutt::api::UTTParams& params);
   friend std::istream& ::operator>>(std::istream& in, libutt::api::UTTParams& params);
   friend bool ::operator==(const libutt::api::UTTParams& params1, const libutt::api::UTTParams& params2);
   std::unique_ptr<libutt::Params> params;
-  bool budget_policy = true;
 };
 }  // namespace libutt::api

utt/include/config.hpp

@@ -62,7 +62,7 @@ class Configuration {
   /// @brief Constructs a UTT instance configuration
   /// @param n The number of validators for multiparty signature computation
   /// @param t The number of validator shares required to reconstruct a signature
-  Configuration(uint16_t n, uint16_t t, bool budget_policy = true);
+  Configuration(uint16_t n, uint16_t t, bool budget_policy);
   ~Configuration();
 
   Configuration(Configuration&& o);

utt/include/transaction.hpp

@@ -57,8 +57,7 @@ class Transaction {
               const std::vector<Coin>& input_coins,
               const std::optional<Coin>& budget_coin,
               const std::vector<std::tuple<std::string, uint64_t>>& recipients,
-              const IEncryptor& encryptor,
-              bool budget_policy = true);
+              const IEncryptor& encryptor);
   Transaction();
   Transaction(const Transaction&);
   Transaction(Transaction&&) = default;

utt/libutt/bench/BenchTxn.cpp

@@ -119,7 +119,7 @@ class BenchTxn {
       tqv.endLap();
 
       tv.startLap();
-      if (!tx.validate(p, bpk, rpk)) {
+      if (!tx.validate(p, bpk, rpk, true)) {
         testAssertFail("TXN should have verified");
       }
       tv.endLap();

utt/libutt/include/utt/Tx.h

@@ -97,7 +97,7 @@ class Tx {
 
   bool quickPayValidate(const Params& p, const RandSigPK& bpk, const RegAuthPK& rpk, bool budget_policy) const;
 
-  bool validate(const Params& p, const RandSigPK& bpk, const RegAuthPK& rpk, bool budget_policy = true) const;
+  bool validate(const Params& p, const RandSigPK& bpk, const RegAuthPK& rpk, bool budget_policy) const;
 
   /**
    * Returns the nullifiers of all coins spent by this TXN, including the budget coin's.

utt/libutt/src/BurnOp.cpp

@@ -96,7 +96,8 @@ BurnOp::BurnOp(const Params& p,
                 recip,
                 std::move(bpk),
                 rpk.vk,
-                libutt::IBEEncryptor(rpk.mpk));
+                libutt::IBEEncryptor(rpk.mpk),
+                false);
 
   assertTrue(internalTx.outs.size() == 1);
 
@@ -181,7 +182,7 @@ size_t BurnOp::getSize() const {
 bool BurnOp::validate(const Params& p, const RandSigPK& bpk, const RegAuthPK& rpk) const {
   InternalDataOfBurnOp* d = (InternalDataOfBurnOp*)this->p;
   if (d == nullptr) return false;
-  if (!d->tx.validate(p, bpk, rpk)) return false;
+  if (!d->tx.validate(p, bpk, rpk, false)) return false;
   if (d->tx.outs.size() != 1) return false;
 
   Fr hashPid = AddrSK::pidHash(d->pid);

utt/libutt/src/Simulation.cpp

@@ -51,7 +51,7 @@ Tx sendValidTxOnNetwork(const Context& ctx, const Tx& inTx) {
   testAssertEqual(inTx, outTx);
   testAssertEqual(oldHash, newHash);
 
-  if (!outTx.validate(ctx.p_, ctx.bpk_, ctx.rpk_)) {
+  if (!outTx.validate(ctx.p_, ctx.bpk_, ctx.rpk_, true)) {
     testAssertFail("TXN should have verified");
   }
 

utt/libutt/src/Tx.cpp

@@ -19,7 +19,6 @@
 
 std::ostream& operator<<(std::ostream& out, const libutt::Tx& tx) {
   out << tx.budgetPolicy << endl;
-  out << tx.is_budgeted << endl;
   out << tx.isSplitOwnCoins << endl;
   out << tx.rcm;
   out << tx.regsig;
@@ -35,8 +34,7 @@ std::ostream& operator<<(std::ostream& out, const libutt::Tx& tx) {
 std::istream& operator>>(std::istream& in, libutt::Tx& tx) {
   in >> tx.budgetPolicy;
   libff::consume_OUTPUT_NEWLINE(in);
-  in >> tx.is_budgeted;
-  libff::consume_OUTPUT_NEWLINE(in);
+
   in >> tx.isSplitOwnCoins;
   libff::consume_OUTPUT_NEWLINE(in);
   in >> tx.rcm;
@@ -46,6 +44,10 @@ std::istream& operator>>(std::istream& in, libutt::Tx& tx) {
   libutt::deserializeVector(in, tx.outs);
 
   in >> tx.budget_pi;
+
+  for (auto& txin : tx.ins) {
+    tx.is_budgeted = tx.is_budgeted || (txin.coin_type == libutt::Coin::BudgetType());
+  }
   return in;
 }
 
@@ -86,7 +88,6 @@ Tx::Tx(const Params& p,
        const RandSigPK& rpk,
        const IEncryptor& encryptor,
        bool budget_policy) {
-  budgetPolicy = budget_policy;
 #ifndef NDEBUG
   (void)bpk;
 #endif
@@ -99,10 +100,7 @@ Tx::Tx(const Params& p,
 
   isSplitOwnCoins = true;       // true when this TXN simply splits the sender's coins
   is_budgeted = b.has_value();  // true when this TXN is budgeted
-  if (!budgetPolicy && is_budgeted) {
-    logerror << "budget policy is false, but a budget coin was given" << endl;
-    throw std::runtime_error("budget policy is false, but a budget coin was given");
-  }
+
   size_t totalIn = Coin::totalValue(coins);  // total in value
   size_t totalOut = 0;                       // total out value
   size_t paidOut = 0;                        // total amount paid out to someone else
@@ -141,7 +139,16 @@ Tx::Tx(const Params& p,
       forMeOutputs.insert(j);
     }
   }
+  budgetPolicy = isSplitOwnCoins ? false : budget_policy;
+  if (!budgetPolicy && is_budgeted) {
+    logerror << "budget policy is disabled, but a budget coin was given" << endl;
+    throw std::runtime_error("budget policy is false, but a budget coin was given");
+  }
 
+  if (budgetPolicy && !is_budgeted) {
+    logerror << "budget policy is enabled, but the budget is missing" << endl;
+    throw std::runtime_error("budget policy is enabled, but the budget coin is missing");
+  }
   // are you spending more than you have?
   if (totalIn != totalOut) {
     logerror << "Total-in is " << totalIn << " but total-out is " << totalOut << endl;
@@ -384,18 +391,20 @@ bool Tx::quickPayValidate(const Params& p, const RandSigPK& bpk, const RegAuthPK
     return false;
   }
 
-  if (budget_policy) {
-    if (!budgetPolicy) {
-      logerror << "budget policy is enforced but the transaction's budget policy is false" << endl;
-      return false;
-    }
-  }
-
   if (budget_policy && !isSplitOwnCoins && !is_budgeted) {
     logerror << "budget policy is enforced and budget is needed, but the transaction doesn't have a budget coin"
              << endl;
     return false;
   }
+  if (!budget_policy && !isSplitOwnCoins && is_budgeted) {
+    logerror << "budget policy is disabled and budget is not needed, but the transaction does have a budget coin"
+             << endl;
+    return false;
+  }
+
+  if ((budget_policy && !budgetPolicy) || (!budget_policy && budgetPolicy)) {
+    logerror << "mismatch between transaction's budget policy and the configuration budget policy" << endl;
+  }
 
   assertTrue(!is_budgeted || budget_pi.has_value());
 

utt/libutt/src/api/transaction.cpp

@@ -21,8 +21,7 @@ Transaction::Transaction(const UTTParams& d,
                          const std::vector<Coin>& coins,
                          const std::optional<Coin>& bc,
                          const std::vector<std::tuple<std::string, uint64_t>>& recipients,
-                         const IEncryptor& encryptor,
-                         bool budget_policy) {
+                         const IEncryptor& encryptor) {
   Fr fr_pidhash;
   fr_pidhash.from_words(cid.getPidHash());
   Fr prf;
@@ -59,7 +58,7 @@ Transaction::Transaction(const UTTParams& d,
                            std::nullopt,
                            rpk.vk,
                            encryptor,
-                           budget_policy));
+                           d.getBudgetPolicy()));
 }
 Transaction::Transaction() { tx_.reset(new libutt::Tx()); }
 Transaction::Transaction(const Transaction& other) {

utt/libutt/test/TestTxn.cpp

@@ -131,7 +131,7 @@ void testBudgeted2to2Txn(size_t thresh, size_t n, size_t numCycles, bool isBudge
           testAssertFail("TXN should have QuickPay-verified");
         }
       } else {
-        if (!tx.validate(p, bpk, rpk)) {
+        if (!tx.validate(p, bpk, rpk, true)) {
           testAssertFail("TXN should have verified");
         }
       }

utt/tests/TestUttNewApi.cpp

@@ -238,7 +238,7 @@ TEST_F(ibe_based_test_system_minted, test_invalid_burn) {
 }
 
 TEST_F(ibe_based_test_system, test_serialization_configuration) {
-  auto config = libutt::api::Configuration((uint16_t)n, (uint16_t)thresh);
+  auto config = libutt::api::Configuration((uint16_t)n, (uint16_t)thresh, true);
   ASSERT_TRUE(config.isValid());
   auto serialized_config = libutt::api::serialize<libutt::api::Configuration>(config);
   auto deserialized_config = libutt::api::deserialize<libutt::api::Configuration>(serialized_config);
@@ -566,24 +566,38 @@ TEST_F(ibe_based_test_system_minted, test_transaction_without_budget) {
   for (size_t i = 0; i < clients.size(); i++) {
     auto& issuer = clients[i];
     auto& receiver = clients[(i + 1) % clients.size()];
+    // We let the client to cheat and create a non-budgeted transaction
+    d.budget_policy = false;
     Transaction tx(d,
                    issuer,
                    {coins[issuer.getPid()].front()},
                    std::nullopt,
                    {{issuer.getPid(), 50}, {receiver.getPid(), 50}},
-                   *(encryptors_.at((i + 1) % clients.size())),
-                   true);
-    for (auto& b : banks) {
-      ASSERT_FALSE(b->validate(d, tx));
-    }
+                   *(encryptors_.at((i + 1) % clients.size())));
 
     ASSERT_ANY_THROW(Transaction(d,
                                  issuer,
                                  {coins[issuer.getPid()].front()},
                                  {bcoins[issuer.getPid()].front()},
                                  {{issuer.getPid(), 50}, {receiver.getPid(), 50}},
-                                 *(encryptors_.at((i + 1) % clients.size())),
-                                 false));
+                                 *(encryptors_.at((i + 1) % clients.size()))));
+
+    d.budget_policy = true;
+    for (auto& b : banks) {
+      ASSERT_FALSE(b->validate(d, tx));
+    }
+
+    Transaction tx2(d,
+                    issuer,
+                    {coins[issuer.getPid()].front()},
+                    {bcoins[issuer.getPid()].front()},
+                    {{issuer.getPid(), 50}, {receiver.getPid(), 50}},
+                    *(encryptors_.at((i + 1) % clients.size())));
+
+    d.budget_policy = false;
+    for (auto& b : banks) {
+      ASSERT_FALSE(b->validate(d, tx2));
+    }
   }
 }
 
@@ -600,8 +614,7 @@ TEST_F(ibe_based_test_system_minted_budget_policy_disabled, test_transaction) {
                    {coins[issuer.getPid()].front()},
                    std::nullopt,
                    {{issuer.getPid(), 50}, {receiver.getPid(), 50}},
-                   *(encryptors_.at((i + 1) % clients.size())),
-                   false);
+                   *(encryptors_.at((i + 1) % clients.size())));
     coins[issuer.getPid()].erase(coins[issuer.getPid()].begin());
     std::map<size_t, std::vector<types::Signature>> shares;
     std::vector<uint16_t> shares_signers;