From 455f91fdfd5d3ddc5bd020c64e32517e18b27305 Mon Sep 17 00:00:00 2001 From: N-010 Date: Thu, 5 Mar 2026 18:09:02 +0300 Subject: [PATCH 1/3] Update from CFB --- src/contracts/Random.h | 273 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 264 insertions(+), 9 deletions(-) diff --git a/src/contracts/Random.h b/src/contracts/Random.h index e62340d70..84c6ce60d 100644 --- a/src/contracts/Random.h +++ b/src/contracts/Random.h @@ -9,23 +9,278 @@ struct RANDOM : public ContractBase public: struct RevealAndCommit_input { - bit_4096 revealedBits; - id committedDigest; + bit_4096 reveal; + id commit; }; struct RevealAndCommit_output { }; private: - uint64 _earnedAmount; - uint64 _distributedAmount; - uint64 _burnedAmount; + uint64 earnedAmount; + uint64 distributedAmount; + uint64 burnedAmount; - uint32 _bitFee; // Amount of qus + uint32 bitFee; // Amount of qus - PUBLIC_PROCEDURE(RevealAndCommit) + Array populations; // 3 + Array providers; // 3 * 1365 + Array collateralTiers; // 3 * 1365 + Array commits; // 3 * 1365 + Array reveals; // 3 * 1365 + bit_4096 revealOrCommitFlags; // 3 * 1365 + Array entropy; // 3 * 10 + + struct RevealAndCommit_locals + { + bit_4096 zeroReveal; // TODO: Use a constant from either QPI or global state + uint32 stream; + uint32 collateralTier; + uint32 i; + }; + + PUBLIC_PROCEDURE_WITH_LOCALS(RevealAndCommit) { - qpi.transfer(qpi.invocator(), qpi.invocationReward()); + // TODO: Reject transactions from smart contracts! + + switch (qpi.invocationReward()) + { + case 1: locals.collateralTier = 0; break; + + case 10: locals.collateralTier = 1; break; + + case 100: locals.collateralTier = 2; break; + + case 1000: locals.collateralTier = 3; break; + + case 10000: locals.collateralTier = 4; break; + + case 100000: locals.collateralTier = 5; break; + + case 1000000: locals.collateralTier = 6; break; + + case 10000000: locals.collateralTier = 7; break; + + case 100000000: locals.collateralTier = 8; break; + + case 1000000000: locals.collateralTier = 9; break; + + default: qpi.transfer(qpi.invocator(), qpi.invocationReward()); return; + } + + locals.stream = mod(qpi.tick(), 3); + + if (input.reveal != locals.zeroReveal) // Don't need to initialize [locals.zeroReveal] because locals struct has been zeroed (bad practice, + // but it's for spreading awareness about this nuance) + { + for (; locals.i < state.populations.get(locals.stream); + locals.i++) // Don't need to initialize [locals.i] because locals struct has been zeroed (bad practice, but it's for spreading + // awareness about this nuance) + { + if (qpi.invocator() == state.providers.get(locals.stream * 1365 + locals.i) && + locals.collateralTier == state.collateralTiers.get(locals.stream * 1365 + locals.i)) + { + break; + } + } + if (locals.i == state.populations.get(locals.stream) || state.reveals.get(locals.stream * 1365 + locals.i) != locals.zeroReveal || + qpi.K12(input.reveal) != state.commits.get(locals.stream * 1365 + locals.i)) + { + qpi.transfer(qpi.invocator(), qpi.invocationReward()); + return; + } + + state.reveals.set(locals.stream * 1365 + locals.i, input.reveal); + state.revealOrCommitFlags.set(locals.stream * 1365 + locals.i, 1); + } + + if (input.commit == id::zero()) + { + qpi.transfer(qpi.invocator(), qpi.invocationReward()); + return; + } + + for (locals.i = 0; locals.i < state.populations.get(locals.stream); locals.i++) + { + if (qpi.invocator() == state.providers.get(locals.stream * 1365 + locals.i) && + locals.collateralTier == state.collateralTiers.get(locals.stream * 1365 + locals.i)) + { + break; + } + } + if (locals.i == state.populations.get(locals.stream)) + { + if (locals.i == 1365) + { + qpi.transfer(qpi.invocator(), qpi.invocationReward()); + return; + } + + state.providers.set(locals.stream * 1365 + locals.i, qpi.invocator()); + state.collateralTiers.set(locals.stream * 1365 + locals.i, locals.collateralTier); + state.populations.set(locals.stream, locals.i + 1); + } + else + { + if (state.reveals.get(locals.stream * 1365 + locals.i) == locals.zeroReveal) + { + qpi.transfer(qpi.invocator(), qpi.invocationReward()); + return; + } + } + state.commits.set(locals.stream * 1365 + locals.i, input.commit); + state.revealOrCommitFlags.set(locals.stream * 1365 + locals.i, 1); + } + + struct END_TICK_locals + { + bit_4096 zeroReveal; // TODO: Use a constant from either QPI or global state + bit_4096 entropy; + id collateralRecipient; + uint32 stream; + uint32 i, j; + uint16 collateralTierFlags; + }; + + END_TICK_WITH_LOCALS() + { + locals.stream = mod(qpi.tick(), 3); + + for (; locals.i < 10; locals.i++) // Don't need to initialize [locals.i] because locals struct has been zeroed (bad practice, but it's for + // spreading awareness about this nuance) + { + state.entropy.set(locals.stream * 10 + locals.i, + locals.zeroReveal); // Don't need to initialize [locals.zeroReveal] because locals struct has been zeroed (bad practice, + // but it's for spreading awareness about this nuance) + } + + for (locals.i = 0; locals.i < state.populations.get(locals.stream); locals.i++) + { + if (state.revealOrCommitFlags.get(locals.stream * 1365 + locals.i)) + { + break; + } + } + if (locals.i == state.populations.get(locals.stream)) // Nobody provided their reveal, that tick was probably empty + { + while (locals.i--) + { + switch (state.collateralTiers.get(locals.stream * 1365 + locals.i)) + { + case 0: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 1); break; + + case 1: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 10); break; + + case 2: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 100); break; + + case 3: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 1000); break; + + case 4: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 10000); break; + + case 5: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 100000); break; + + case 6: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 1000000); break; + + case 7: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 10000000); break; + + case 8: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 100000000); break; + + default: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 1000000000); + } + state.providers.set(locals.stream * 1365 + locals.i, id::zero()); + state.collateralTiers.set(locals.stream * 1365 + locals.i, 0); + // Don't need to zero [state.reveals], they are all-zeros anyway + state.commits.set(locals.stream * 1365 + locals.i, id::zero()); + } + state.populations.set(locals.stream, 0); + } + else + { + // Don't need to initialize [locals.collateralTierFlags] because locals struct has been zeroed (bad practice, but it's for spreading + // awareness about this nuance) + + for (locals.i = state.populations.get(locals.stream); locals.i--;) + { + if (state.revealOrCommitFlags.get(locals.stream * 1365 + locals.i)) + { + locals.collateralRecipient = state.providers.get(locals.stream * 1365 + locals.i); + } + else + { + locals.collateralRecipient = id::zero(); + } + + switch (state.collateralTiers.get(locals.stream * 1365 + locals.i)) + { + case 0: qpi.transfer(locals.collateralRecipient, 1); break; + + case 1: qpi.transfer(locals.collateralRecipient, 10); break; + + case 2: qpi.transfer(locals.collateralRecipient, 100); break; + + case 3: qpi.transfer(locals.collateralRecipient, 1000); break; + + case 4: qpi.transfer(locals.collateralRecipient, 10000); break; + + case 5: qpi.transfer(locals.collateralRecipient, 100000); break; + + case 6: qpi.transfer(locals.collateralRecipient, 1000000); break; + + case 7: qpi.transfer(locals.collateralRecipient, 10000000); break; + + case 8: qpi.transfer(locals.collateralRecipient, 100000000); break; + + default: qpi.transfer(locals.collateralRecipient, 1000000000); + } + + if (locals.collateralRecipient == id::zero()) + { + locals.collateralTierFlags |= (1 << state.collateralTiers.get(locals.stream * 1365 + locals.i)); + + state.providers.set(locals.stream * 1365 + locals.i, + state.providers.get(locals.stream * 1365 + state.populations.get(locals.stream))); + state.providers.set(locals.stream * 1365 + state.populations.get(locals.stream), id::zero()); + + state.collateralTiers.set(locals.stream * 1365 + locals.i, + state.collateralTiers.get(locals.stream * 1365 + state.populations.get(locals.stream))); + state.collateralTiers.set(locals.stream * 1365 + state.populations.get(locals.stream), 0); + + state.reveals.set(locals.stream * 1365 + locals.i, + state.reveals.get(locals.stream * 1365 + state.populations.get(locals.stream))); + state.reveals.set(locals.stream * 1365 + state.populations.get(locals.stream), locals.zeroReveal); + + state.commits.set(locals.stream * 1365 + locals.i, + state.commits.get(locals.stream * 1365 + state.populations.get(locals.stream))); + state.commits.set(locals.stream * 1365 + state.populations.get(locals.stream), id::zero()); + + state.populations.set(locals.stream, state.populations.get(locals.stream) - 1); + } + else + { + if (!(locals.collateralTierFlags & (1 << state.collateralTiers.get(locals.stream * 1365 + locals.i)))) + { + locals.entropy = state.entropy.get(locals.stream * 10 + state.collateralTiers.get(locals.stream * 1365 + locals.i)); + for (locals.j = 0; locals.j < 4096; locals.j++) + { + locals.entropy.set(locals.j, + locals.entropy.get(locals.j) ^ state.reveals.get(locals.stream * 1365 + locals.i).get(locals.j)); + } + state.entropy.set(locals.stream * 10 + state.collateralTiers.get(locals.stream * 1365 + locals.i), locals.entropy); + state.reveals.set(locals.stream * 1365 + locals.i, locals.zeroReveal); + } + } + + state.revealOrCommitFlags.set(locals.stream * 1365 + locals.i, 0); + } + + for (locals.i = 0; locals.i < 10; locals.i++) + { + if (locals.collateralTierFlags & (1 << state.collateralTiers.get(locals.stream * 1365 + locals.i))) + { + state.entropy.set(locals.stream * 10 + locals.i, locals.zeroReveal); + } + } + } } REGISTER_USER_FUNCTIONS_AND_PROCEDURES() @@ -35,6 +290,6 @@ struct RANDOM : public ContractBase INITIALIZE() { - state._bitFee = 1000; + state.bitFee = 1000; } }; From c39ca24a8ce4ae51a0eb5787fa75d792fd1035eb Mon Sep 17 00:00:00 2001 From: N-010 Date: Thu, 12 Mar 2026 14:22:57 +0300 Subject: [PATCH 2/3] Adds StateData --- src/contracts/Random.h | 188 ++++++++++++++++++++++------------------- 1 file changed, 101 insertions(+), 87 deletions(-) diff --git a/src/contracts/Random.h b/src/contracts/Random.h index 84c6ce60d..632b66d8b 100644 --- a/src/contracts/Random.h +++ b/src/contracts/Random.h @@ -12,25 +12,11 @@ struct RANDOM : public ContractBase bit_4096 reveal; id commit; }; + struct RevealAndCommit_output { }; -private: - uint64 earnedAmount; - uint64 distributedAmount; - uint64 burnedAmount; - - uint32 bitFee; // Amount of qus - - Array populations; // 3 - Array providers; // 3 * 1365 - Array collateralTiers; // 3 * 1365 - Array commits; // 3 * 1365 - Array reveals; // 3 * 1365 - bit_4096 revealOrCommitFlags; // 3 * 1365 - Array entropy; // 3 * 10 - struct RevealAndCommit_locals { bit_4096 zeroReveal; // TODO: Use a constant from either QPI or global state @@ -39,6 +25,24 @@ struct RANDOM : public ContractBase uint32 i; }; + struct StateData + { + uint64 earnedAmount; + uint64 distributedAmount; + uint64 burnedAmount; + + uint32 bitFee; // Amount of qus + + Array populations; // 3 + Array providers; // 3 * 1365 + Array collateralTiers; // 3 * 1365 + Array commits; // 3 * 1365 + Array reveals; // 3 * 1365 + bit_4096 revealOrCommitFlags; // 3 * 1365 + Array entropy; // 3 * 10 + }; + +private: PUBLIC_PROCEDURE_WITH_LOCALS(RevealAndCommit) { // TODO: Reject transactions from smart contracts! @@ -70,28 +74,30 @@ struct RANDOM : public ContractBase locals.stream = mod(qpi.tick(), 3); - if (input.reveal != locals.zeroReveal) // Don't need to initialize [locals.zeroReveal] because locals struct has been zeroed (bad practice, - // but it's for spreading awareness about this nuance) + if (input.reveal != locals.zeroReveal) // Don't need to initialize [locals.zeroReveal] because + // locals struct has been zeroed (bad practice, but + // it's for spreading awareness about this nuance) { - for (; locals.i < state.populations.get(locals.stream); - locals.i++) // Don't need to initialize [locals.i] because locals struct has been zeroed (bad practice, but it's for spreading - // awareness about this nuance) + for (; locals.i < state.get().populations.get(locals.stream); locals.i++) // Don't need to initialize [locals.i] because locals + // struct has been zeroed (bad practice, but it's for + // spreading awareness about this nuance) { - if (qpi.invocator() == state.providers.get(locals.stream * 1365 + locals.i) && - locals.collateralTier == state.collateralTiers.get(locals.stream * 1365 + locals.i)) + if (qpi.invocator() == state.get().providers.get(locals.stream * 1365 + locals.i) && + locals.collateralTier == state.get().collateralTiers.get(locals.stream * 1365 + locals.i)) { break; } } - if (locals.i == state.populations.get(locals.stream) || state.reveals.get(locals.stream * 1365 + locals.i) != locals.zeroReveal || - qpi.K12(input.reveal) != state.commits.get(locals.stream * 1365 + locals.i)) + if (locals.i == state.get().populations.get(locals.stream) || + state.get().reveals.get(locals.stream * 1365 + locals.i) != locals.zeroReveal || + qpi.K12(input.reveal) != state.get().commits.get(locals.stream * 1365 + locals.i)) { qpi.transfer(qpi.invocator(), qpi.invocationReward()); return; } - state.reveals.set(locals.stream * 1365 + locals.i, input.reveal); - state.revealOrCommitFlags.set(locals.stream * 1365 + locals.i, 1); + state.mut().reveals.set(locals.stream * 1365 + locals.i, input.reveal); + state.mut().revealOrCommitFlags.set(locals.stream * 1365 + locals.i, 1); } if (input.commit == id::zero()) @@ -100,15 +106,15 @@ struct RANDOM : public ContractBase return; } - for (locals.i = 0; locals.i < state.populations.get(locals.stream); locals.i++) + for (locals.i = 0; locals.i < state.get().populations.get(locals.stream); locals.i++) { - if (qpi.invocator() == state.providers.get(locals.stream * 1365 + locals.i) && - locals.collateralTier == state.collateralTiers.get(locals.stream * 1365 + locals.i)) + if (qpi.invocator() == state.get().providers.get(locals.stream * 1365 + locals.i) && + locals.collateralTier == state.get().collateralTiers.get(locals.stream * 1365 + locals.i)) { break; } } - if (locals.i == state.populations.get(locals.stream)) + if (locals.i == state.get().populations.get(locals.stream)) { if (locals.i == 1365) { @@ -116,20 +122,20 @@ struct RANDOM : public ContractBase return; } - state.providers.set(locals.stream * 1365 + locals.i, qpi.invocator()); - state.collateralTiers.set(locals.stream * 1365 + locals.i, locals.collateralTier); - state.populations.set(locals.stream, locals.i + 1); + state.mut().providers.set(locals.stream * 1365 + locals.i, qpi.invocator()); + state.mut().collateralTiers.set(locals.stream * 1365 + locals.i, locals.collateralTier); + state.mut().populations.set(locals.stream, locals.i + 1); } else { - if (state.reveals.get(locals.stream * 1365 + locals.i) == locals.zeroReveal) + if (state.get().reveals.get(locals.stream * 1365 + locals.i) == locals.zeroReveal) { qpi.transfer(qpi.invocator(), qpi.invocationReward()); return; } } - state.commits.set(locals.stream * 1365 + locals.i, input.commit); - state.revealOrCommitFlags.set(locals.stream * 1365 + locals.i, 1); + state.mut().commits.set(locals.stream * 1365 + locals.i, input.commit); + state.mut().revealOrCommitFlags.set(locals.stream * 1365 + locals.i, 1); } struct END_TICK_locals @@ -146,71 +152,76 @@ struct RANDOM : public ContractBase { locals.stream = mod(qpi.tick(), 3); - for (; locals.i < 10; locals.i++) // Don't need to initialize [locals.i] because locals struct has been zeroed (bad practice, but it's for + for (; locals.i < 10; locals.i++) // Don't need to initialize [locals.i] because locals + // struct has been zeroed (bad practice, but it's for // spreading awareness about this nuance) { - state.entropy.set(locals.stream * 10 + locals.i, - locals.zeroReveal); // Don't need to initialize [locals.zeroReveal] because locals struct has been zeroed (bad practice, - // but it's for spreading awareness about this nuance) + state.mut().entropy.set(locals.stream * 10 + locals.i, + locals.zeroReveal); // Don't need to initialize [locals.zeroReveal] + // because locals struct has been zeroed (bad + // practice, but it's for spreading awareness + // about this nuance) } - for (locals.i = 0; locals.i < state.populations.get(locals.stream); locals.i++) + for (locals.i = 0; locals.i < state.get().populations.get(locals.stream); locals.i++) { - if (state.revealOrCommitFlags.get(locals.stream * 1365 + locals.i)) + if (state.get().revealOrCommitFlags.get(locals.stream * 1365 + locals.i)) { break; } } - if (locals.i == state.populations.get(locals.stream)) // Nobody provided their reveal, that tick was probably empty + if (locals.i == state.get().populations.get(locals.stream)) // Nobody provided their reveal, that + // tick was probably empty { while (locals.i--) { - switch (state.collateralTiers.get(locals.stream * 1365 + locals.i)) + switch (state.get().collateralTiers.get(locals.stream * 1365 + locals.i)) { - case 0: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 1); break; + case 0: qpi.transfer(state.get().providers.get(locals.stream * 1365 + locals.i), 1); break; - case 1: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 10); break; + case 1: qpi.transfer(state.get().providers.get(locals.stream * 1365 + locals.i), 10); break; - case 2: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 100); break; + case 2: qpi.transfer(state.get().providers.get(locals.stream * 1365 + locals.i), 100); break; - case 3: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 1000); break; + case 3: qpi.transfer(state.get().providers.get(locals.stream * 1365 + locals.i), 1000); break; - case 4: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 10000); break; + case 4: qpi.transfer(state.get().providers.get(locals.stream * 1365 + locals.i), 10000); break; - case 5: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 100000); break; + case 5: qpi.transfer(state.get().providers.get(locals.stream * 1365 + locals.i), 100000); break; - case 6: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 1000000); break; + case 6: qpi.transfer(state.get().providers.get(locals.stream * 1365 + locals.i), 1000000); break; - case 7: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 10000000); break; + case 7: qpi.transfer(state.get().providers.get(locals.stream * 1365 + locals.i), 10000000); break; - case 8: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 100000000); break; + case 8: qpi.transfer(state.get().providers.get(locals.stream * 1365 + locals.i), 100000000); break; - default: qpi.transfer(state.providers.get(locals.stream * 1365 + locals.i), 1000000000); + default: qpi.transfer(state.get().providers.get(locals.stream * 1365 + locals.i), 1000000000); } - state.providers.set(locals.stream * 1365 + locals.i, id::zero()); - state.collateralTiers.set(locals.stream * 1365 + locals.i, 0); + state.mut().providers.set(locals.stream * 1365 + locals.i, id::zero()); + state.mut().collateralTiers.set(locals.stream * 1365 + locals.i, 0); // Don't need to zero [state.reveals], they are all-zeros anyway - state.commits.set(locals.stream * 1365 + locals.i, id::zero()); + state.mut().commits.set(locals.stream * 1365 + locals.i, id::zero()); } - state.populations.set(locals.stream, 0); + state.mut().populations.set(locals.stream, 0); } else { - // Don't need to initialize [locals.collateralTierFlags] because locals struct has been zeroed (bad practice, but it's for spreading - // awareness about this nuance) + // Don't need to initialize [locals.collateralTierFlags] because locals + // struct has been zeroed (bad practice, but it's for spreading awareness + // about this nuance) - for (locals.i = state.populations.get(locals.stream); locals.i--;) + for (locals.i = state.get().populations.get(locals.stream); locals.i--;) { - if (state.revealOrCommitFlags.get(locals.stream * 1365 + locals.i)) + if (state.get().revealOrCommitFlags.get(locals.stream * 1365 + locals.i)) { - locals.collateralRecipient = state.providers.get(locals.stream * 1365 + locals.i); + locals.collateralRecipient = state.get().providers.get(locals.stream * 1365 + locals.i); } else { locals.collateralRecipient = id::zero(); } - switch (state.collateralTiers.get(locals.stream * 1365 + locals.i)) + switch (state.get().collateralTiers.get(locals.stream * 1365 + locals.i)) { case 0: qpi.transfer(locals.collateralRecipient, 1); break; @@ -235,49 +246,52 @@ struct RANDOM : public ContractBase if (locals.collateralRecipient == id::zero()) { - locals.collateralTierFlags |= (1 << state.collateralTiers.get(locals.stream * 1365 + locals.i)); + locals.collateralTierFlags |= (1 << state.get().collateralTiers.get(locals.stream * 1365 + locals.i)); - state.providers.set(locals.stream * 1365 + locals.i, - state.providers.get(locals.stream * 1365 + state.populations.get(locals.stream))); - state.providers.set(locals.stream * 1365 + state.populations.get(locals.stream), id::zero()); + state.mut().providers.set(locals.stream * 1365 + locals.i, + state.get().providers.get(locals.stream * 1365 + state.get().populations.get(locals.stream))); + state.mut().providers.set(locals.stream * 1365 + state.get().populations.get(locals.stream), id::zero()); - state.collateralTiers.set(locals.stream * 1365 + locals.i, - state.collateralTiers.get(locals.stream * 1365 + state.populations.get(locals.stream))); - state.collateralTiers.set(locals.stream * 1365 + state.populations.get(locals.stream), 0); + state.mut().collateralTiers.set( + locals.stream * 1365 + locals.i, + state.get().collateralTiers.get(locals.stream * 1365 + state.get().populations.get(locals.stream))); + state.mut().collateralTiers.set(locals.stream * 1365 + state.get().populations.get(locals.stream), 0); - state.reveals.set(locals.stream * 1365 + locals.i, - state.reveals.get(locals.stream * 1365 + state.populations.get(locals.stream))); - state.reveals.set(locals.stream * 1365 + state.populations.get(locals.stream), locals.zeroReveal); + state.mut().reveals.set(locals.stream * 1365 + locals.i, + state.get().reveals.get(locals.stream * 1365 + state.get().populations.get(locals.stream))); + state.mut().reveals.set(locals.stream * 1365 + state.get().populations.get(locals.stream), locals.zeroReveal); - state.commits.set(locals.stream * 1365 + locals.i, - state.commits.get(locals.stream * 1365 + state.populations.get(locals.stream))); - state.commits.set(locals.stream * 1365 + state.populations.get(locals.stream), id::zero()); + state.mut().commits.set(locals.stream * 1365 + locals.i, + state.get().commits.get(locals.stream * 1365 + state.get().populations.get(locals.stream))); + state.mut().commits.set(locals.stream * 1365 + state.get().populations.get(locals.stream), id::zero()); - state.populations.set(locals.stream, state.populations.get(locals.stream) - 1); + state.mut().populations.set(locals.stream, state.get().populations.get(locals.stream) - 1); } else { - if (!(locals.collateralTierFlags & (1 << state.collateralTiers.get(locals.stream * 1365 + locals.i)))) + if (!(locals.collateralTierFlags & (1 << state.get().collateralTiers.get(locals.stream * 1365 + locals.i)))) { - locals.entropy = state.entropy.get(locals.stream * 10 + state.collateralTiers.get(locals.stream * 1365 + locals.i)); + locals.entropy = + state.get().entropy.get(locals.stream * 10 + state.get().collateralTiers.get(locals.stream * 1365 + locals.i)); for (locals.j = 0; locals.j < 4096; locals.j++) { locals.entropy.set(locals.j, - locals.entropy.get(locals.j) ^ state.reveals.get(locals.stream * 1365 + locals.i).get(locals.j)); + locals.entropy.get(locals.j) ^ state.get().reveals.get(locals.stream * 1365 + locals.i).get(locals.j)); } - state.entropy.set(locals.stream * 10 + state.collateralTiers.get(locals.stream * 1365 + locals.i), locals.entropy); - state.reveals.set(locals.stream * 1365 + locals.i, locals.zeroReveal); + state.mut().entropy.set(locals.stream * 10 + state.get().collateralTiers.get(locals.stream * 1365 + locals.i), + locals.entropy); + state.mut().reveals.set(locals.stream * 1365 + locals.i, locals.zeroReveal); } } - state.revealOrCommitFlags.set(locals.stream * 1365 + locals.i, 0); + state.mut().revealOrCommitFlags.set(locals.stream * 1365 + locals.i, 0); } for (locals.i = 0; locals.i < 10; locals.i++) { - if (locals.collateralTierFlags & (1 << state.collateralTiers.get(locals.stream * 1365 + locals.i))) + if (locals.collateralTierFlags & (1 << state.get().collateralTiers.get(locals.stream * 1365 + locals.i))) { - state.entropy.set(locals.stream * 10 + locals.i, locals.zeroReveal); + state.mut().entropy.set(locals.stream * 10 + locals.i, locals.zeroReveal); } } } @@ -290,6 +304,6 @@ struct RANDOM : public ContractBase INITIALIZE() { - state.bitFee = 1000; + state.mut().bitFee = 1000; } }; From 39a91b04cfd9fdb82f60ce4b6a0124f54824e3d7 Mon Sep 17 00:00:00 2001 From: N-010 Date: Tue, 17 Mar 2026 11:38:28 +0300 Subject: [PATCH 3/3] Fixes loop --- src/contracts/Random.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/contracts/Random.h b/src/contracts/Random.h index 632b66d8b..290b92585 100644 --- a/src/contracts/Random.h +++ b/src/contracts/Random.h @@ -289,7 +289,7 @@ struct RANDOM : public ContractBase for (locals.i = 0; locals.i < 10; locals.i++) { - if (locals.collateralTierFlags & (1 << state.get().collateralTiers.get(locals.stream * 1365 + locals.i))) + if (locals.collateralTierFlags & (1 << locals.i)) { state.mut().entropy.set(locals.stream * 10 + locals.i, locals.zeroReveal); }