Upgrade QRP

src/contracts/QReservePool.h

@@ -1,6 +1,5 @@
 using namespace QPI;
 
-// Number of available smart contracts in the QRP contract.
 constexpr uint16 QRP_ALLOWED_SC_NUM = 128;
 constexpr uint64 QRP_QTF_INDEX = QRP_CONTRACT_INDEX + 1;
 constexpr uint64 QRP_REMOVAL_THRESHOLD_PERCENT = 75;
@@ -13,11 +12,10 @@ struct QRP : ContractBase
 {
 	enum class EReturnCode : uint8
 	{
-		SUCCESS = 0,
-		ACCESS_DENIED = 1,
-		INSUFFICIENT_RESERVE = 2,
-
-		MAX_VALUE = UINT8_MAX
+		SUCCESS,
+		ACCESS_DENIED,
+		INSUFFICIENT_RESERVE,
+		SC_NOT_FOUND,
 	};
 
 	static constexpr uint8 toReturnCode(const EReturnCode& code) { return static_cast<uint8>(code); };
@@ -94,6 +92,24 @@ struct QRP : ContractBase
 		uint64 arrayIndex;
 	};
 
+	struct SendReserve_input
+	{
+		uint64 scIndex;
+		uint64 amount;
+	};
+
+	struct SendReserve_output
+	{
+		uint8 returnCode;
+	};
+
+	struct SendReserve_locals
+	{
+		GetAvailableReserve_input getAvailableReserveInput;
+		GetAvailableReserve_output getAvailableReserveOutput;
+		id scId;
+	};
+
 	INITIALIZE()
 	{
 		// Set team/developer address (owner and team are the same for now)
@@ -111,13 +127,12 @@ struct QRP : ContractBase
 		REGISTER_USER_PROCEDURE(WithdrawReserve, 1);
 		REGISTER_USER_PROCEDURE(AddAllowedSC, 2);
 		REGISTER_USER_PROCEDURE(RemoveAllowedSC, 3);
+		REGISTER_USER_PROCEDURE(SendReserve, 4);
 		// Functions
 		REGISTER_USER_FUNCTION(GetAvailableReserve, 1);
 		REGISTER_USER_FUNCTION(GetAllowedSC, 2);
 	}
 
-	END_EPOCH() { state.allowedSmartContracts.cleanup(); }
-
 	PUBLIC_PROCEDURE_WITH_LOCALS(WithdrawReserve)
 	{
 		if (!state.allowedSmartContracts.contains(qpi.invocator()))
@@ -187,18 +202,40 @@ struct QRP : ContractBase
 		}
 	}
 
+	PUBLIC_PROCEDURE_WITH_LOCALS(SendReserve)
+	{
+		if (qpi.invocator() != state.ownerAddress)
+		{
+			output.returnCode = toReturnCode(EReturnCode::ACCESS_DENIED);
+			return;
+		}
+
+		locals.scId = id(input.scIndex, 0, 0, 0);
+
+		if (!state.allowedSmartContracts.contains(locals.scId))
+		{
+			output.returnCode = toReturnCode(EReturnCode::SC_NOT_FOUND);
+			return;
+		}
+
+		CALL(GetAvailableReserve, locals.getAvailableReserveInput, locals.getAvailableReserveOutput);
+		if (input.amount > locals.getAvailableReserveOutput.availableReserve)
+		{
+			output.returnCode = toReturnCode(EReturnCode::INSUFFICIENT_RESERVE);
+			return;
+		}
+
+		output.returnCode = toReturnCode(EReturnCode::SUCCESS);
+		qpi.transfer(locals.scId, input.amount);
+	}
+
 protected:
-	/**
-	 * @brief Address of the team managing the lottery contract.
-	 * Initialized to a zero address.
-	 */
+	/** @brief Address of the team managing the lottery contract. */
 	id teamAddress;
 
-	/**
-	 * @brief Address of the owner of the lottery contract.
-	 * Initialized to a zero address.
-	 */
+	/** @brief Address of the owner of the lottery contract. */
 	id ownerAddress;
 
+	/** @brief Smart contract whitelist: only SCs in this list can call WithdrawReserve procedure to access the reserve funds, and receive transfers from SendReserve procedure. */
 	HashSet<id, QRP_ALLOWED_SC_NUM> allowedSmartContracts;
 };

test/contract_qrp.cpp

@@ -6,15 +6,13 @@
 constexpr uint16 QRP_PROC_GET_RESERVE = 1;
 constexpr uint16 QRP_PROC_ADD_ALLOWED_SC = 2;
 constexpr uint16 QRP_PROC_REMOVE_ALLOWED_SC = 3;
+constexpr uint16 QRP_PROC_SEND_RESERVE = 4;
 
 constexpr uint16 QRP_FUNC_GET_AVAILABLE_RESERVE = 1;
 constexpr uint16 QRP_FUNC_GET_ALLOWED_SC = 2;
 
 static const id QRP_CONTRACT_ID(QRP_CONTRACT_INDEX, 0, 0, 0);
 static const id QRP_DEFAULT_SC_ID(QRP_QTF_INDEX, 0, 0, 0);
-static const id QRP_OWNER_TEAM_ADDRESS =
-    ID(_Z, _T, _Z, _E, _A, _Q, _G, _U, _P, _I, _K, _T, _X, _F, _Y, _X, _Y, _E, _I, _T, _L, _A, _K, _F, _T, _D, _X, _C, _R, _L, _W, _E, _T, _H, _N, _G,
-       _H, _D, _Y, _U, _W, _E, _Y, _Q, _N, _Q, _S, _R, _H, _O, _W, _M, _U, _J, _L, _E);
 
 class QRPChecker : public QRP
 {
@@ -67,6 +65,14 @@ class ContractTestingQRP : protected ContractTesting
 		return output;
 	}
 
+	QRP::SendReserve_output sendReserve(const id& invocator, uint64 scIndex, uint64 amount)
+	{
+		QRP::SendReserve_input input{scIndex, amount};
+		QRP::SendReserve_output output{};
+		invokeUserProcedure(QRP_CONTRACT_INDEX, QRP_PROC_SEND_RESERVE, input, output, invocator, 0);
+		return output;
+	}
+
 	QRP::GetAvailableReserve_output getAvailableReserve() const
 	{
 		QRP::GetAvailableReserve_input input{};
@@ -205,3 +211,53 @@ TEST(ContractQReservePool, OwnerAddRemove_IdempotencyAndBounds)
 	const auto rem2 = qrp.removeAllowedSC(state->owner(), newScIndex);
 	EXPECT_FALSE(state->hasAllowedSC(newScId));
 }
+
+TEST(ContractQReservePool, SendReserve_AllValidAndInvalidScenarios)
+{
+	ContractTestingQRP qrp;
+	QRPChecker* state = qrp.state();
+	const id outsider(900, 0, 0, 0);
+	static constexpr uint64 recipientScIndex = 77;
+	const id recipientSc(recipientScIndex, 0, 0, 0);
+	static constexpr uint64 unknownScIndex = 999;
+	const id unknownSc(unknownScIndex, 0, 0, 0);
+
+	qrp.fund(state->owner(), 0);
+	qrp.fund(outsider, 0);
+	qrp.fund(recipientSc, 0);
+	qrp.fund(unknownSc, 0);
+
+	// ACCESS_DENIED: only owner can invoke SendReserve.
+	const QRP::SendReserve_output& denied = qrp.sendReserve(outsider, QRP_QTF_INDEX, 1);
+	EXPECT_EQ(denied.returnCode, QRP::toReturnCode(QRP::EReturnCode::ACCESS_DENIED));
+
+	// SC_NOT_FOUND: owner invokes, but target SC is not whitelisted.
+	const QRP::SendReserve_output& notFound = qrp.sendReserve(state->owner(), unknownScIndex, 1);
+	EXPECT_EQ(notFound.returnCode, QRP::toReturnCode(QRP::EReturnCode::SC_NOT_FOUND));
+
+	// Add a new allowed SC to validate insufficient/success flows with a non-default recipient.
+	const QRP::AddAllowedSC_output& addSc = qrp.addAllowedSC(state->owner(), recipientScIndex);
+	EXPECT_EQ(addSc.returnCode, QRP::toReturnCode(QRP::EReturnCode::SUCCESS));
+	EXPECT_TRUE(state->hasAllowedSC(recipientSc));
+
+	// INSUFFICIENT_RESERVE: reserve is 0.
+	const QRP::SendReserve_output& insufficientZeroReserve = qrp.sendReserve(state->owner(), recipientScIndex, 1);
+	EXPECT_EQ(insufficientZeroReserve.returnCode, QRP::toReturnCode(QRP::EReturnCode::INSUFFICIENT_RESERVE));
+	EXPECT_EQ(qrp.balanceQrp(), 0);
+	EXPECT_EQ(qrp.balanceOf(recipientSc), 0);
+
+	qrp.fundQrp(1000);
+	EXPECT_EQ(qrp.balanceQrp(), 1000);
+
+	// INSUFFICIENT_RESERVE: requested amount is above available reserve.
+	const QRP::SendReserve_output& insufficientAboveReserve = qrp.sendReserve(state->owner(), recipientScIndex, 1001);
+	EXPECT_EQ(insufficientAboveReserve.returnCode, QRP::toReturnCode(QRP::EReturnCode::INSUFFICIENT_RESERVE));
+	EXPECT_EQ(qrp.balanceQrp(), 1000);
+	EXPECT_EQ(qrp.balanceOf(recipientSc), 0);
+
+	// SUCCESS: exact available reserve should be transferable.
+	const QRP::SendReserve_output& successExact = qrp.sendReserve(state->owner(), recipientScIndex, 1000);
+	EXPECT_EQ(successExact.returnCode, QRP::toReturnCode(QRP::EReturnCode::SUCCESS));
+	EXPECT_EQ(qrp.balanceQrp(), 0);
+	EXPECT_EQ(qrp.balanceOf(recipientSc), 1000);
+}