Merge pull request #612 from qubic/develop (Release v1.266.0)

Release v1.266.0

Author: Franziska-Mueller

README.md

@@ -162,7 +162,8 @@ We cannot support you in any case. You are welcome to provide updates, bug fixes
 
 ## More Documentation
 - [How to contribute](doc/contributing.md)
-- [Developing a smart contract ](doc/contracts.md)
+- [Developing a smart contract](doc/contracts.md)
 - [Qubic protocol](doc/protocol.md)
 - [Custom mining](doc/custom_mining.md)
 - [Seamless epoch transition](SEAMLESS.md)
+- [Proposals and voting](doc/contracts_proposals.md)

doc/contracts.md

@@ -243,9 +243,12 @@ They are defined with the following macros:
 8. `POST_RELEASE_SHARES()`: Called after asset management rights were transferred from this contract to another contract that called `qpi.acquireShare()`
 9. `POST_ACQUIRE_SHARES()`: Called after asset management rights were transferred to this contract from another contract that called `qpi.releaseShare()`.
 10. `POST_INCOMING_TRANSFER()`: Called after QUs have been transferred to this contract. [More details...](#callback-post_incoming_transfer)
+11. `SET_SHAREHOLDER_PROPOSAL()`: Called if another contracts tries to set a shareholder proposal in this contract by calling `qpi.setShareholderProposal()`.
+12. `SET_SHAREHOLDER_VOTES()`: Called if another contracts tries to set a shareholder proposal in this contract by calling `qpi.setShareholderVotes()`.
 
 System procedures 1 to 5 have no input and output.
 The input and output of system procedures 6 to 9 are discussed in the section about [management rights transfer](#management-rights-transfer).
+The system procedure 11 and 12 are discussed in the section about [contracts as shareholder of other contracts](contracts_proposals.md#contracts-as-shareholders-of-other-contracts)
 
 The contract state is passed to each of the procedures as a reference named `state`.
 And it can be modified (in contrast to contract functions).
@@ -295,6 +298,10 @@ QX rejects all attempts (`qpi.acquireShares()`) of other contracts to acquire ri
 
 TODO
 
+In the universe, NULL_ID is only used for owner / possessor for temporary entries during the IPO between issuing a contract asset and transferring the ownership/possession.
+Further, NULL_ID is used for burning asset shares by transferring ownership / possession to NULL_ID.
+
+
 ### Management rights transfer
 
 There are two ways of transferring asset management rights:
@@ -546,6 +553,16 @@ That is, calls to these QPI procedures will fail to prevent nested callbacks.
 If you invoke a user procedure from the callback, the fee / invocation reward cannot be transferred.
 In consequence, the procedure is executed but with `qpi.invocationReward() == 0`.
 
+### Proposals and voting
+
+Proposals and voting are the on-chain way of decision-making, implemented in contracts.
+The function, macros, and data structures provided by the QPI for implementing proposal voting in smart contracts are quite complex.
+That is why they are described in a [separate document](contracts_proposals.md).
+
+CFB has an alternative idea for proposal-free voting on shareholder variables that is supposed to be used in the contracts QX, RANDOM, and MLM.
+It has not been implemented yet.
+https://github.com/qubic/core/issues/574
+
 
 ## Restrictions of C++ Language Features
 

doc/contracts_proposals.md

@@ -26,6 +26,7 @@
     <ClInclude Include="contracts\Qdraw.h" />
     <ClInclude Include="contracts\Qswap.h" />
     <ClInclude Include="contracts\RandomLottery.h" />
+    <ClInclude Include="contracts\RandomLottery_v1.h" />
     <ClInclude Include="contracts\SupplyWatcher.h" />
     <ClInclude Include="contracts\EmptyTemplate.h" />
     <ClInclude Include="contracts\GeneralQuorumProposal.h" />
@@ -50,6 +51,7 @@
     <ClInclude Include="contract_core\contract_def.h" />
     <ClInclude Include="contract_core\contract_exec.h" />
     <ClInclude Include="contract_core\ipo.h" />
+    <ClInclude Include="contract_core\pre_qpi_def.h" />
     <ClInclude Include="contract_core\qpi_asset_impl.h" />
     <ClInclude Include="contract_core\qpi_collection_impl.h" />
     <ClInclude Include="contract_core\qpi_ipo_impl.h" />

src/Qubic.vcxproj

@@ -285,6 +285,12 @@
     <ClInclude Include="contracts\RandomLottery.h">
       <Filter>contracts</Filter>
     </ClInclude>
+    <ClInclude Include="contract_core\pre_qpi_def.h">
+      <Filter>contract_core</Filter>
+    </ClInclude>
+    <ClInclude Include="contracts\RandomLottery_v1.h">
+      <Filter>contracts</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Filter Include="platform">

src/Qubic.vcxproj.filters

@@ -112,7 +112,7 @@ struct AssetStorage
             PROFILE_SCOPE();
 
             reset();
-            for (int index = 0; index < ASSETS_CAPACITY; index++)
+            for (int index = ASSETS_CAPACITY - 1; index >= 0; index--)
             {
                 switch (assets[index].varStruct.issuance.type)
                 {

src/assets/assets.h

@@ -2,6 +2,7 @@
 
 #include "platform/global_var.h"
 #include "platform/memory_util.h"
+#include "platform/assert.h"
 
 #include "network_messages/entity.h"
 #include "network_messages/assets.h"
@@ -35,7 +36,10 @@ static void deinitCommonBuffers()
     }
 }
 
-static void* __scratchpad()
+static void* __scratchpad(unsigned long long sizeToMemsetZero)
 {
+    ASSERT(sizeToMemsetZero <= reorgBufferSize);
+    if (sizeToMemsetZero)
+        setMem(reorgBuffer, sizeToMemsetZero, 0);
     return reorgBuffer;
 }

src/common_buffers.h

@@ -1,6 +1,4 @@
 #pragma once
-#include "network_messages/common_def.h"
-#include "platform/m256.h"
 
 ////////// Smart contracts \\\\\\\\\\
 
@@ -10,61 +8,10 @@
 // Additionally, most types, functions, and variables of the core have to be defined after including
 // the contract to keep them unavailable in the contract code.
 
-namespace QPI
-{
-    struct QpiContextProcedureCall;
-    struct QpiContextFunctionCall;
-}
-
-// TODO: add option for having locals to SYSTEM and EXPAND procedures
-typedef void (*SYSTEM_PROCEDURE)(const QPI::QpiContextProcedureCall&, void* state, void* input, void* output, void* locals);
-typedef void (*EXPAND_PROCEDURE)(const QPI::QpiContextFunctionCall&, void*, void*); // cannot not change anything except state
-typedef void (*USER_FUNCTION)(const QPI::QpiContextFunctionCall&, void* state, void* input, void* output, void* locals);
-typedef void (*USER_PROCEDURE)(const QPI::QpiContextProcedureCall&, void* state, void* input, void* output, void* locals);
-
-constexpr unsigned long long MAX_CONTRACT_STATE_SIZE = 1073741824;
-
-// Maximum size of local variables that may be used by a contract function or procedure
-// If increased, the size of contractLocalsStack should be increased as well.
-constexpr unsigned int MAX_SIZE_OF_CONTRACT_LOCALS = 32 * 1024;
-
-// TODO: make sure the limit of nested calls is not violated
-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;
-
-
-static void __beginFunctionOrProcedure(const unsigned int); // TODO: more human-readable form of function ID?
-static void __endFunctionOrProcedure(const unsigned int);
-template <typename T> static m256i __K12(T);
-template <typename T> static void __logContractDebugMessage(unsigned int, T&);
-template <typename T> static void __logContractErrorMessage(unsigned int, T&);
-template <typename T> static void __logContractInfoMessage(unsigned int, T&);
-template <typename T> static void __logContractWarningMessage(unsigned int, T&);
-static void* __scratchpad();    // TODO: concurrency support (n buffers for n allowed concurrent contract executions)
-// static void* __tryAcquireScratchpad(unsigned int size);  // Thread-safe, may return nullptr if no appropriate buffer is available
-// static void __ReleaseScratchpad(void*);
-
-template <unsigned int functionOrProcedureId>
-struct __FunctionOrProcedureBeginEndGuard
-{
-    // Constructor calling __beginFunctionOrProcedure()
-    __FunctionOrProcedureBeginEndGuard()
-    {
-        __beginFunctionOrProcedure(functionOrProcedureId);
-    }
-
-    // Destructor making sure __endFunctionOrProcedure() is called for every return path
-    ~__FunctionOrProcedureBeginEndGuard()
-    {
-        __endFunctionOrProcedure(functionOrProcedureId);
-    }
-};
-
 
 // With no other includes before, the following are the only headers available to contracts.
 // When adding something, be cautious to keep access of contracts limited to safe features only.
+#include "pre_qpi_def.h"
 #include "contracts/qpi.h"
 #include "qpi_proposal_voting.h"
 
@@ -222,7 +169,11 @@ struct __FunctionOrProcedureBeginEndGuard
 #define CONTRACT_INDEX RL_CONTRACT_INDEX
 #define CONTRACT_STATE_TYPE RL
 #define CONTRACT_STATE2_TYPE RL2
-#include "contracts/RandomLottery.h"
+#ifdef RL_V1
+    #include "contracts/RandomLottery_v1.h"
+#else
+    #include "contracts/RandomLottery.h"
+#endif
 
 #undef CONTRACT_INDEX
 #undef CONTRACT_STATE_TYPE
@@ -283,6 +234,8 @@ constexpr unsigned short TESTEXD_CONTRACT_INDEX = (CONTRACT_INDEX + 1);
 #undef POST_RELEASE_SHARES
 #undef POST_ACQUIRE_SHARES
 #undef POST_INCOMING_TRANSFER
+#undef SET_SHAREHOLDER_PROPOSAL
+#undef SET_SHAREHOLDER_VOTES
 
 
 // The following are included after the contracts to keep their definitions and dependencies
@@ -336,8 +289,8 @@ constexpr struct ContractDescription
     {"QBOND", 182, 10000, sizeof(QBOND)}, // proposal in epoch 180, IPO in 181, construction and first use in 182
     // new contracts should be added above this line
 #ifdef INCLUDE_CONTRACT_TEST_EXAMPLES
-    {"TESTEXA", 138, 10000, sizeof(IPO)},
-    {"TESTEXB", 138, 10000, sizeof(IPO)},
+    {"TESTEXA", 138, 10000, sizeof(TESTEXA)},
+    {"TESTEXB", 138, 10000, sizeof(TESTEXB)},
     {"TESTEXC", 138, 10000, sizeof(IPO)},
     {"TESTEXD", 155, 10000, sizeof(IPO)},
 #endif
@@ -377,6 +330,8 @@ enum SystemProcedureID
     POST_RELEASE_SHARES,
     POST_ACQUIRE_SHARES,
     POST_INCOMING_TRANSFER,
+    SET_SHAREHOLDER_PROPOSAL,
+    SET_SHAREHOLDER_VOTES,
     contractSystemProcedureCount,
 };
 
@@ -414,6 +369,10 @@ if (!contractName::__postReleaseSharesEmpty) contractSystemProcedures[contractIn
 contractSystemProcedureLocalsSizes[contractIndex][POST_RELEASE_SHARES] = contractName::__postReleaseSharesLocalsSize; \
 if (!contractName::__postIncomingTransferEmpty) contractSystemProcedures[contractIndex][POST_INCOMING_TRANSFER] = (SYSTEM_PROCEDURE)contractName::__postIncomingTransfer;\
 contractSystemProcedureLocalsSizes[contractIndex][POST_INCOMING_TRANSFER] = contractName::__postIncomingTransferLocalsSize; \
+if (!contractName::__setShareholderProposalEmpty) contractSystemProcedures[contractIndex][SET_SHAREHOLDER_PROPOSAL] = (SYSTEM_PROCEDURE)contractName::__setShareholderProposal;\
+contractSystemProcedureLocalsSizes[contractIndex][SET_SHAREHOLDER_PROPOSAL] = contractName::__setShareholderProposalLocalsSize; \
+if (!contractName::__setShareholderVotesEmpty) contractSystemProcedures[contractIndex][SET_SHAREHOLDER_VOTES] = (SYSTEM_PROCEDURE)contractName::__setShareholderVotes;\
+contractSystemProcedureLocalsSizes[contractIndex][SET_SHAREHOLDER_VOTES] = contractName::__setShareholderVotesLocalsSize; \
 if (!contractName::__expandEmpty) contractExpandProcedures[contractIndex] = (EXPAND_PROCEDURE)contractName::__expand;\
 QpiContextForInit qpi(contractIndex); \
 contractName::__registerUserFunctionsAndProcedures(qpi); \

src/contract_core/contract_def.h

@@ -72,6 +72,7 @@ enum ContractCallbacksRunningFlags
     NoContractCallback = 0,
     ContractCallbackManagementRightsTransfer = 1,
     ContractCallbackPostIncomingTransfer = 2,
+    ContractCallbackShareholderProposalAndVoting = 4,
 };
 
 
@@ -609,7 +610,7 @@ void QPI::QpiContextProcedureCall::__qpiReleaseStateForWriting(unsigned int cont
 
 // Used to run a special system procedure from within a contract for example in asset management rights transfer
 template <unsigned int sysProcId, typename InputType, typename OutputType>
-void QPI::QpiContextProcedureCall::__qpiCallSystemProc(unsigned int sysProcContractIndex, InputType& input, OutputType& output, QPI::sint64 invocationReward) const
+bool QPI::QpiContextProcedureCall::__qpiCallSystemProc(unsigned int sysProcContractIndex, InputType& input, OutputType& output, QPI::sint64 invocationReward) const
 {
     // Make sure this function is used with an expected combination of sysProcId, input,
     // and output
@@ -619,6 +620,8 @@ void QPI::QpiContextProcedureCall::__qpiCallSystemProc(unsigned int sysProcContr
         || (sysProcId == POST_RELEASE_SHARES && sizeof(InputType) == sizeof(QPI::PostManagementRightsTransfer_input) && sizeof(OutputType) == sizeof(QPI::NoData))
         || (sysProcId == POST_ACQUIRE_SHARES && sizeof(InputType) == sizeof(QPI::PostManagementRightsTransfer_input) && sizeof(OutputType) == sizeof(QPI::NoData))
         || (sysProcId == POST_INCOMING_TRANSFER && sizeof(InputType) == sizeof(QPI::PostIncomingTransfer_input) && sizeof(OutputType) == sizeof(QPI::NoData))
+        || (sysProcId == SET_SHAREHOLDER_PROPOSAL && sizeof(InputType) == sizeof(QPI::SET_SHAREHOLDER_PROPOSAL_input) && sizeof(OutputType) == sizeof(QPI::SET_SHAREHOLDER_PROPOSAL_output))
+        || (sysProcId == SET_SHAREHOLDER_VOTES && sizeof(InputType) == sizeof(QPI::SET_SHAREHOLDER_VOTES_input) && sizeof(OutputType) == sizeof(QPI::SET_SHAREHOLDER_VOTES_output))
         , "Unsupported __qpiCallSystemProc() call"
     );
 
@@ -627,7 +630,8 @@ void QPI::QpiContextProcedureCall::__qpiCallSystemProc(unsigned int sysProcContr
     ASSERT(sysProcContractIndex < contractCount);
     ASSERT(contractStates[sysProcContractIndex] != nullptr);
     if (sysProcId == PRE_RELEASE_SHARES || sysProcId == PRE_ACQUIRE_SHARES
-        || sysProcId == POST_RELEASE_SHARES || sysProcId == POST_ACQUIRE_SHARES)
+        || sysProcId == POST_RELEASE_SHARES || sysProcId == POST_ACQUIRE_SHARES
+        || sysProcId == SET_SHAREHOLDER_PROPOSAL || sysProcId == SET_SHAREHOLDER_VOTES)
     {
         ASSERT(sysProcContractIndex != _currentContractIndex);
     }
@@ -637,14 +641,22 @@ void QPI::QpiContextProcedureCall::__qpiCallSystemProc(unsigned int sysProcContr
 
     // Empty procedures lead to null pointer in contractSystemProcedures -> return default output (all zero/false)
     if (!contractSystemProcedures[sysProcContractIndex][sysProcId])
-        return;
+    {
+        // Returning false informs the caller that the system procedure isn't defined, which is useful if the
+        // zeroed output does not indicate an error but is a valid output value.
+        return false;
+    }
 
     // Set flags of callbacks currently running (to prevent deadlocks and nested calling of QPI functions)
     auto contractCallbacksRunningBefore = contractCallbacksRunning;
     if (sysProcId == POST_INCOMING_TRANSFER)
     {
         contractCallbacksRunning |= ContractCallbackPostIncomingTransfer;
     }
+    else if (sysProcId == SET_SHAREHOLDER_PROPOSAL || sysProcId == SET_SHAREHOLDER_VOTES)
+    {
+        contractCallbacksRunning |= ContractCallbackShareholderProposalAndVoting;
+    }
     else if (sysProcId == PRE_RELEASE_SHARES || sysProcId == PRE_ACQUIRE_SHARES
         || sysProcId == POST_RELEASE_SHARES || sysProcId == POST_ACQUIRE_SHARES)
     {
@@ -676,6 +688,8 @@ void QPI::QpiContextProcedureCall::__qpiCallSystemProc(unsigned int sysProcContr
 
     // Restore flags of callbacks currently running
     contractCallbacksRunning = contractCallbacksRunningBefore;
+
+    return true;
 }
 
 // If dest is a contract, notify contract by running system procedure POST_INCOMING_TRANSFER
@@ -693,6 +707,70 @@ void QPI::QpiContextProcedureCall::__qpiNotifyPostIncomingTransfer(const QPI::id
     __qpiCallSystemProc<POST_INCOMING_TRANSFER>(destContractIndex, input, output, 0);
 }
 
+inline uint16 QPI::QpiContextProcedureCall::setShareholderProposal(
+    uint16 contractIndex,
+    const Array<uint8, 1024>& proposalDataBuffer,
+    sint64 invocationReward
+) const
+{
+    // prevent nested calling from callbacks
+    if (contractCallbacksRunning & ContractCallbackShareholderProposalAndVoting)
+    {
+        return INVALID_PROPOSAL_INDEX;
+    }
+
+    // check for invalid inputs
+    if (contractIndex == _currentContractIndex
+        || contractIndex == 0
+        || contractIndex >= contractCount
+        || invocationReward < 0)
+    {
+        return INVALID_PROPOSAL_INDEX;
+    }
+
+    // Copy proposalDataBuffer, because procedures are allowed to change their input
+    Array<uint8, 1024> inputBuffer = proposalDataBuffer;
+
+    // run SET_SHAREHOLDER_PROPOSAL callback in other contract
+    uint16 outputProposalIndex;
+    if (!__qpiCallSystemProc<SET_SHAREHOLDER_PROPOSAL>(contractIndex, inputBuffer, outputProposalIndex, invocationReward))
+        return INVALID_PROPOSAL_INDEX;
+
+    return outputProposalIndex;
+}
+
+inline bool QPI::QpiContextProcedureCall::setShareholderVotes(
+    uint16 contractIndex,
+    const ProposalMultiVoteDataV1& shareholderVoteData,
+    sint64 invocationReward
+) const
+{
+    // prevent nested calling from callbacks
+    if (contractCallbacksRunning & ContractCallbackShareholderProposalAndVoting)
+    {
+        return false;
+    }
+
+    // check for invalid inputs
+    if (contractIndex == _currentContractIndex
+        || contractIndex == 0
+        || contractIndex >= contractCount
+        || invocationReward < 0)
+    {
+        return false;
+    }
+
+    // Copy proposalDataBuffer, because procedures are allowed to change their input
+    ProposalMultiVoteDataV1 inputVote = shareholderVoteData;
+
+    // run SET_SHAREHOLDER_VOTES callback in other contract
+    bit success; // initialized with zero by __qpiCallSystemProc
+    __qpiCallSystemProc<SET_SHAREHOLDER_VOTES>(contractIndex, inputVote, success, invocationReward);
+
+    return success;
+}
+
+
 // Enter endless loop leading to timeout
 // -> TODO: unlock everything in case of function entry point, maybe retry later in case of deadlock handling
 // -> TODO: rollback of contract actions on contractProcessor()