Contract one time oracle query

src/Qubic.vcxproj

@@ -96,6 +96,7 @@
     <ClInclude Include="oracle_core\oracle_engine.h" />
     <ClInclude Include="oracle_core\oracle_interfaces_def.h" />
     <ClInclude Include="oracle_core\oracle_transactions.h" />
+    <ClInclude Include="oracle_interfaces\Mock.h" />
     <ClInclude Include="oracle_interfaces\Price.h" />
     <ClInclude Include="platform\assert.h" />
     <ClInclude Include="platform\concurrency.h" />

src/Qubic.vcxproj.filters

@@ -332,6 +332,9 @@
     <ClInclude Include="contract_core\execution_time_accumulator.h">
       <Filter>contract_core</Filter>
     </ClInclude>
+    <ClInclude Include="oracle_interfaces\Mock.h">
+      <Filter>oracle_interfaces</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Filter Include="platform">
@@ -382,4 +385,4 @@
       <Filter>platform</Filter>
     </MASM>
   </ItemGroup>
-</Project>
+</Project>

src/contract_core/contract_def.h

@@ -441,3 +441,48 @@ static void initializeContracts()
 #endif
 }
 
+// Class for registering and looking up user procedures independently of input type, for example for notifications
+class UserProcedureRegistry
+{
+public:
+    struct UserProcedureData
+    {
+        USER_PROCEDURE procedure;
+        unsigned int contractIndex;
+        unsigned int localsSize;
+        unsigned short inputSize;
+        unsigned short outputSize;
+    };
+
+    void init()
+    {
+        setMemory(*this, 0);
+    }
+
+    bool add(unsigned int procedureId, const UserProcedureData& data)
+    {
+        const unsigned int cnt = (unsigned int)idToIndex.population();
+        if (cnt >= idToIndex.capacity())
+            return false;
+
+        copyMemory(userProcData[cnt], data);
+        idToIndex.set(procedureId, cnt);
+
+        return true;
+    }
+
+    const UserProcedureData* get(unsigned int procedureId) const
+    {
+        unsigned int idx;
+        if (!idToIndex.get(procedureId, idx))
+            return nullptr;
+        return userProcData + idx;
+    }
+
+protected:
+    UserProcedureData userProcData[MAX_CONTRACT_PROCEDURES_REGISTERED];
+    QPI::HashMap<unsigned int, unsigned int, MAX_CONTRACT_PROCEDURES_REGISTERED> idToIndex;
+};
+
+// For registering and looking up user procedures independently of input type (for notifications), initialized by initContractExec()
+GLOBAL_VAR_DECL UserProcedureRegistry* userProcedureRegistry GLOBAL_VAR_INIT(nullptr);

src/contract_core/contract_exec.h

@@ -192,6 +192,12 @@ static bool initContractExec()
     if (!contractActionTracker.allocBuffer())
         return false;
 
+    if (!allocPoolWithErrorLog(L"userProcedureRegistry", sizeof(*userProcedureRegistry), (void**)&userProcedureRegistry, __LINE__))
+    {
+        return false;
+    }
+    userProcedureRegistry->init();
+
     return true;
 }
 
@@ -218,6 +224,9 @@ static void deinitContractExec()
         freePool(contractStateChangeFlags);
     }
 
+    if (userProcedureRegistry)
+        freePool(userProcedureRegistry);
+
     contractActionTracker.freeBuffer();
 }
 
@@ -917,6 +926,16 @@ void QPI::QpiContextForInit::__registerUserProcedure(USER_PROCEDURE userProcedur
     contractUserProcedureLocalsSizes[_currentContractIndex][inputType] = localsSize;
 }
 
+void QPI::QpiContextForInit::__registerUserProcedureNotification(USER_PROCEDURE userProcedure, unsigned int procedureId, unsigned short inputSize, unsigned short outputSize, unsigned int localsSize) const
+{
+    ASSERT(userProcedureRegistry);
+    if (!userProcedureRegistry->add(procedureId, { userProcedure, _currentContractIndex, localsSize, inputSize, outputSize }))
+    {
+#if !defined(NDEBUG)
+        addDebugMessage(L"__registerUserProcedureNotification() failed. You should increase MAX_CONTRACT_PROCEDURES_REGISTERED.");
+#endif
+    }
+}
 
 
 // QPI context used to call contract system procedure from qubic core (contract processor)
@@ -1266,15 +1285,6 @@ struct QpiContextUserFunctionCall : public QPI::QpiContextFunctionCall
 };
 
 
-struct UserProcedureNotification
-{
-    unsigned int contractIndex;
-    USER_PROCEDURE procedure;
-    const void* inputPtr;
-    unsigned short inputSize;
-    unsigned int localsSize;
-};
-
 // QPI context used to call contract user procedure as a notification from qubic core (contract processor).
 // This means, it isn't triggered by a transaction, but following an event after having setup the notification
 // callback in the contract code.
@@ -1283,16 +1293,16 @@ struct UserProcedureNotification
 // The procedure pointer, the expected inputSize, and the expected localsSize, which are passed via
 // UserProcedureNotification, must be consistent. The code using notifications is responible for ensuring that.
 // Use cases:
-// - oracle notifications (managed by oracleEngine)
+// - oracle notifications (managed by oracleEngine and userProcedureRegistry)
 struct QpiContextUserProcedureNotificationCall : public QPI::QpiContextProcedureCall
 {
-    QpiContextUserProcedureNotificationCall(const UserProcedureNotification& notification) : QPI::QpiContextProcedureCall(notif.contractIndex, NULL_ID, 0, USER_PROCEDURE_NOTIFICATION_CALL),  notif(notification)
+    QpiContextUserProcedureNotificationCall(const UserProcedureRegistry::UserProcedureData& notification) : QPI::QpiContextProcedureCall(notification.contractIndex, NULL_ID, 0, USER_PROCEDURE_NOTIFICATION_CALL),  notif(notification)
     {
         contractActionTracker.init();
     }
 
     // Run user procedure notification
-    void call()
+    void call(const void* inputPtr)
     {
         ASSERT(_currentContractIndex < contractCount);
 
@@ -1330,7 +1340,7 @@ struct QpiContextUserProcedureNotificationCall : public QPI::QpiContextProcedure
             __qpiAbort(ContractErrorAllocInputOutputFailed);
         }
         char* locals = input + notif.inputSize;
-        copyMem(input, notif.inputPtr, notif.inputSize);
+        copyMem(input, inputPtr, notif.inputSize);
         setMem(locals, notif.localsSize, 0);
 
         // call user procedure
@@ -1353,5 +1363,5 @@ struct QpiContextUserProcedureNotificationCall : public QPI::QpiContextProcedure
     }
 
 private:
-    const UserProcedureNotification& notif;
+    const UserProcedureRegistry::UserProcedureData& notif;
 };

src/contract_core/execution_time_accumulator.h

@@ -59,7 +59,7 @@ class ExecutionTimeAccumulator
             math_lib::sadd(contractExecutionTimePerPhase[contractExecutionTimeActiveArrayIndex][contractIndex], timeMicroSeconds);
         RELEASE(lock);
 
-#if !defined(NDEBUG) && !defined(NO_UEFI)
+#if !defined(NDEBUG) && !defined(NO_UEFI) && 0
         CHAR16 dbgMsgBuf[128];
         setText(dbgMsgBuf, L"Execution time added for contract ");
         appendNumber(dbgMsgBuf, contractIndex, FALSE);

src/contract_core/pre_qpi_def.h

@@ -27,6 +27,9 @@ constexpr unsigned short MAX_NESTED_CONTRACT_CALLS = 10;
 // Size of the contract action tracker, limits the number of transfers that one contract call can execute.
 constexpr unsigned long long CONTRACT_ACTION_TRACKER_SIZE = 16 * 1024 * 1024;
 
+// Maximum number of contract procedures that may be registered, e.g. for user procedure notifications
+constexpr unsigned int MAX_CONTRACT_PROCEDURES_REGISTERED = 16 * 1024;
+
 
 static void __beginFunctionOrProcedure(const unsigned int); // TODO: more human-readable form of function ID?
 static void __endFunctionOrProcedure(const unsigned int);

src/contract_core/qpi_oracle_impl.h

@@ -6,9 +6,10 @@
 
 
 template <typename OracleInterface, typename ContractStateType, typename LocalsType>
-QPI::sint64 QPI::QpiContextProcedureCall::queryOracle(
+QPI::sint64 QPI::QpiContextProcedureCall::__qpiQueryOracle(
 	const OracleInterface::OracleQuery& query,
-	void (*notificationCallback)(const QPI::QpiContextProcedureCall& qpi, ContractStateType& state, QPI::OracleNotificationInput<OracleInterface>& input, QPI::NoData& output, LocalsType& locals),
+	void (*notificationProcPtr)(const QPI::QpiContextProcedureCall& qpi, ContractStateType& state, OracleNotificationInput<OracleInterface>& input, NoData& output, LocalsType& locals),
+	unsigned int notificationProcId, 
 	uint32 timeoutMillisec
 ) const
 {
@@ -28,9 +29,16 @@ QPI::sint64 QPI::QpiContextProcedureCall::queryOracle(
 	const QPI::uint16 contractIndex = static_cast<QPI::uint16>(this->_currentContractIndex);
 
 	// check callback
-	if (!notificationCallback || ContractStateType::__contract_index != contractIndex)
+	if (!notificationProcPtr || ContractStateType::__contract_index != contractIndex)
 		return -1;
 
+	// check vs registry of user procedures for notification
+	const UserProcedureRegistry::UserProcedureData* procData;
+	if (!userProcedureRegistry || !(procData = userProcedureRegistry->get(notificationProcId)) || procData->procedure != (USER_PROCEDURE)notificationProcPtr)
+		return -1;
+	ASSERT(procData->inputSize == sizeof(OracleNotificationInput<OracleInterface>));
+	ASSERT(procData->localsSize == sizeof(LocalsType));
+
 	// get and destroy fee (not adding to contracts execution fee reserve)
 	sint64 fee = OracleInterface::getQueryFee(query);
 	int contractSpectrumIdx = ::spectrumIndex(this->_currentContractId);
@@ -39,8 +47,7 @@ QPI::sint64 QPI::QpiContextProcedureCall::queryOracle(
 		// try to start query
 		QPI::sint64 queryId = oracleEngine.startContractQuery(
 			contractIndex, OracleInterface::oracleInterfaceIndex,
-			&query, sizeof(query), timeoutMillisec,
-			(USER_PROCEDURE)notificationCallback, sizeof(LocalsType));
+			&query, sizeof(query), timeoutMillisec, notificationProcId);
 		if (queryId >= 0)
 		{
 			// success
@@ -55,17 +62,18 @@ QPI::sint64 QPI::QpiContextProcedureCall::queryOracle(
 	input->queryId = -1;
 	QPI::NoData output;
 	auto* locals = (LocalsType*)__qpiAllocLocals(sizeof(LocalsType));
-	notificationCallback(*this, *state, *input, output, *locals);
+	notificationProcPtr(*this, *state, *input, output, *locals);
 	__qpiFreeLocals();
 	__qpiFreeLocals();
 	return -1;
 }
 
 template <typename OracleInterface, typename ContractStateType, typename LocalsType>
-inline QPI::sint32 QPI::QpiContextProcedureCall::subscribeOracle(
+inline QPI::sint32 QPI::QpiContextProcedureCall::__qpiSubscribeOracle(
 	const OracleInterface::OracleQuery& query,
-	void (*notificationCallback)(const QPI::QpiContextProcedureCall& qpi, ContractStateType& state, OracleNotificationInput<OracleInterface>& input, NoData& output, LocalsType& locals),
+	void (*notificationProcPtr)(const QPI::QpiContextProcedureCall& qpi, ContractStateType& state, OracleNotificationInput<OracleInterface>& input, NoData& output, LocalsType& locals),
 	QPI::uint32 notificationIntervalInMilliseconds,
+	unsigned int notificationProcId,
 	bool notifyWithPreviousReply
 ) const
 {
@@ -85,20 +93,16 @@ inline bool QPI::QpiContextProcedureCall::unsubscribeOracle(
 template <typename OracleInterface>
 bool QPI::QpiContextFunctionCall::getOracleQuery(QPI::sint64 queryId, OracleInterface::OracleQuery& query) const
 {
-	// TODO
-	return false;
+	return oracleEngine.getOracleQuery(queryId, &query, sizeof(query));
 }
 
 template <typename OracleInterface>
 bool QPI::QpiContextFunctionCall::getOracleReply(QPI::sint64 queryId, OracleInterface::OracleReply& reply) const
 {
-	// TODO
-	return false;
+	return oracleEngine.getOracleReply(queryId, &reply, sizeof(reply));
 }
 
-template <typename OracleInterface>
 inline QPI::uint8 QPI::QpiContextFunctionCall::getOracleQueryStatus(sint64 queryId) const
 {
-	// TODO
-	return ORACLE_QUERY_STATUS_UNKNOWN;
+	return oracleEngine.getOracleReplygetOracleQueryStatus(queryId);
 }