115 lines
3.8 KiB
Solidity
115 lines
3.8 KiB
Solidity
// SPDX-License-Identifier: Unlicense
|
|
pragma solidity ^0.8.24;
|
|
|
|
import "./core/DAO.sol";
|
|
import "./Availability.sol";
|
|
|
|
contract Rollup is Availability {
|
|
constructor(DAO dao) Availability(dao) {}
|
|
|
|
struct BatchItem {
|
|
address sender;
|
|
address worker;
|
|
uint stakeAmount;
|
|
uint fee;
|
|
string postId;
|
|
}
|
|
|
|
mapping(uint => BatchItem) public items;
|
|
uint public itemCount;
|
|
address public batchWorker;
|
|
uint batchWorkerStakeIndex;
|
|
|
|
event BatchItemAdded(string postId, address sender, uint fee);
|
|
event BatchWorkerAssigned(address batchWorker);
|
|
|
|
/// Instead of initiating a validation pool, call this method to include
|
|
/// the stakes and fee in the next batch validation pool
|
|
function addItem(
|
|
address author,
|
|
uint stakeAmount,
|
|
string calldata postId
|
|
) public payable {
|
|
BatchItem storage item = items[itemCount++];
|
|
item.sender = msg.sender;
|
|
item.worker = author;
|
|
item.stakeAmount = stakeAmount;
|
|
item.fee = msg.value;
|
|
item.postId = postId;
|
|
emit BatchItemAdded(postId, item.sender, item.fee);
|
|
}
|
|
|
|
/// To be called by the currently assigned batch worker,
|
|
/// If no batch worker has been assigned this may be called by anybody,
|
|
/// but it will only succeed if it is able to assign a new worker.
|
|
function submitBatch(
|
|
string calldata batchPostId,
|
|
string[] calldata batchItems,
|
|
uint poolDuration
|
|
) public returns (uint poolIndex) {
|
|
if (batchWorker != address(0)) {
|
|
require(
|
|
msg.sender == batchWorker,
|
|
"Batch result must be submitted by current batch worker"
|
|
);
|
|
}
|
|
require(batchItems.length <= itemCount, "Batch size too large");
|
|
// Make sure all batch items match
|
|
for (uint i = 0; i < batchItems.length; i++) {
|
|
require(
|
|
keccak256(bytes(batchItems[i])) ==
|
|
keccak256(bytes(items[i].postId)),
|
|
"Batch item mismatch"
|
|
);
|
|
}
|
|
// initiate a validation pool for this batch
|
|
uint fee;
|
|
for (uint i = 0; i < batchItems.length; i++) {
|
|
fee += items[i].fee;
|
|
}
|
|
poolIndex = dao.initiateValidationPool{value: fee}(
|
|
batchPostId,
|
|
poolDuration,
|
|
[uint256(1), uint256(3)],
|
|
[uint256(1), uint256(2)],
|
|
100,
|
|
true,
|
|
false,
|
|
""
|
|
);
|
|
// Include all the availability stakes from the batched work
|
|
for (uint i = 0; i < batchItems.length; i++) {
|
|
dao.delegatedStakeOnValidationPool(
|
|
poolIndex,
|
|
items[i].worker,
|
|
items[i].stakeAmount,
|
|
true
|
|
);
|
|
}
|
|
// Include availability stakes from the batch worker
|
|
if (batchWorker != address(0)) {
|
|
dao.delegatedStakeOnValidationPool(
|
|
poolIndex,
|
|
batchWorker,
|
|
stakes[batchWorkerStakeIndex].amount,
|
|
true
|
|
);
|
|
}
|
|
if (batchItems.length < itemCount) {
|
|
// Some items were added after this batch was computed.
|
|
// Keep them in the queue to be included in the next batch.
|
|
for (uint i = 0; i < itemCount - batchItems.length; i++) {
|
|
items[i] = items[batchItems.length + i];
|
|
}
|
|
itemCount = itemCount - batchItems.length;
|
|
} else {
|
|
// Reset item count so we can start the next batch
|
|
itemCount = 0;
|
|
}
|
|
// Select the next worker
|
|
batchWorkerStakeIndex = assignWork();
|
|
batchWorker = stakes[batchWorkerStakeIndex].worker;
|
|
emit BatchWorkerAssigned(batchWorker);
|
|
}
|
|
}
|