Skip to content

Commit

Permalink
Merge pull request #82 from mangata-finance/feature/timestamp
Browse files Browse the repository at this point in the history 
Feature/timestamp
  • Loading branch information
@mateuszaaa
mateuszaaa authored Apr 4, 2024
2 parents ee58c46 + dec74ae commit f8bfb89
Show file tree
Hide file tree
Showing 6 changed files with 44,022 additions and 22,562 deletions.
49 changes: 37 additions & 12 deletions rolldown-contract/src/rolldown.sol
View file
Original file line number Diff line number Diff line change
Expand Up @@ -39,6 +39,11 @@ contract RollDown {
address tokenAddress,
uint256 amount
);
event FundsReturned(
address depositRecipient,
address tokenAddress,
uint256 amount
);
event cancelAndCalculatedHash(bytes32 cancelHash, bytes32 calculatedHash);

enum Origin {
Expand All @@ -56,27 +61,27 @@ contract RollDown {
address depositRecipient;
address tokenAddress;
uint256 amount;
bytes32 blockHash;
uint256 timeStamp;
}

struct L2UpdatesToRemove {
RequestId requestId;
uint256[] l2UpdatesToRemove;
bytes32 blockHash;
uint256 timeStamp;
}

struct CancelResolution {
RequestId requestId;
uint256 l2RequestId;
bool cancelJustified;
bytes32 blockHash;
uint256 timeStamp;
}

struct WithdrawalResolution {
RequestId requestId;
uint256 l2RequestId;
bool status;
bytes32 blockHash;
uint256 timeStamp;
}

struct L1Update {
Expand Down Expand Up @@ -150,13 +155,13 @@ contract RollDown {
"Token transfer failed"
);

bytes32 blockHash = blockhash(block.number);
uint256 timeStamp = block.timestamp;
Deposit memory depositRequest = Deposit({
requestId: RequestId({origin: Origin.L1, id: counter++}),
depositRecipient: depositRecipient,
tokenAddress: tokenAddress,
amount: amount,
blockHash: blockHash
timeStamp: timeStamp
});
// Add the new request to the mapping
deposits[depositRequest.requestId.id] = depositRequest;
Expand Down Expand Up @@ -343,7 +348,7 @@ contract RollDown {
l2UpdatesToRemove[rid] = L2UpdatesToRemove({
requestId: RequestId({origin: Origin.L1, id: rid}),
l2UpdatesToRemove: l2UpdatesToBeRemoved,
blockHash: blockhash(block.number)
timeStamp: block.timestamp
});
lastProcessedUpdate_origin_l1 += l2UpdatesToBeRemoved.length;
emit L2UpdatesToRemovedAcceptedIntoQueue(rid, l2UpdatesToBeRemoved);
Expand All @@ -353,7 +358,7 @@ contract RollDown {
function process_l2_update_requests_results(
UpdateType[] memory order,
RequestResult[] calldata results
) private view returns (uint256[] memory) {
) private returns (uint256[] memory) {
if (results.length == 0) {
return new uint256[](0);
}
Expand All @@ -378,6 +383,9 @@ contract RollDown {
l2UpdatesToBeRemovedTemp[updatesToBeRemovedCounter++] = (
element.originRequestId
);
if (element.updateType == UpdateType.DEPOSIT){
process_l2_update_deposit(element);
}
} else {
revert("unknown request type");
}
Expand All @@ -401,13 +409,13 @@ contract RollDown {
cancel.range.end
);
bytes32 correct_hash = keccak256(abi.encode(pending));
bytes32 blockHash = blockhash(block.number);
uint256 timeStamp = block.timestamp;

CancelResolution memory resolution = CancelResolution({
requestId: RequestId({origin: Origin.L1, id: counter++}),
l2RequestId: cancel.requestId.id,
cancelJustified: correct_hash == cancel.hash,
blockHash: blockHash
timeStamp: timeStamp
});

cancelResolutions[resolution.requestId.id] = resolution;
Expand All @@ -422,13 +430,13 @@ contract RollDown {
) private {
IERC20 token = IERC20(withdrawal.tokenAddress);
bool status = token.balanceOf(address(this)) >= withdrawal.amount;
bytes32 blockHash = blockhash(block.number);
uint256 timeStamp = block.timestamp;

WithdrawalResolution memory resolution = WithdrawalResolution({
requestId: RequestId({origin: Origin.L1, id: counter++}),
l2RequestId: withdrawal.requestId.id,
status: status,
blockHash: blockHash
timeStamp: timeStamp
});

withdrawalResolutions[resolution.requestId.id] = resolution;
Expand All @@ -447,6 +455,23 @@ contract RollDown {
}
}

function process_l2_update_deposit(
RequestResult memory depositResult
) private {
if (!depositResult.status) {
uint256 requestId = depositResult.requestId.id;
Deposit memory theDeposit = deposits[requestId];
IERC20 token = IERC20(theDeposit.tokenAddress);
token.transfer(theDeposit.depositRecipient, theDeposit.amount);

emit FundsReturned(
theDeposit.depositRecipient,
theDeposit.tokenAddress,
theDeposit.amount
);
}
}

function getPendingRequests(
uint256 start,
uint256 end
Expand Down
82 changes: 77 additions & 5 deletions rolldown-contract/test/rolldown.t.sol
View file
Original file line number Diff line number Diff line change
Expand Up @@ -182,14 +182,14 @@ contract RollDownTest is Test {
depositRecipient: 0x0000000000000000000000000000000000000002,
tokenAddress: 0x0000000000000000000000000000000000000003,
amount: 4,
blockHash: 0x0000000000000000000000000000000000000000000000000000000000000005
timeStamp: 1
});

l1Update.pendingCancelResultions[0] = RollDown.CancelResolution({
requestId: RollDown.RequestId({id: 6, origin: RollDown.Origin.L1}),
l2RequestId: 7,
cancelJustified: true,
blockHash: 0x0000000000000000000000000000000000000000000000000000000000000008
timeStamp: 2
});

l1Update.pendingWithdrawalResolutions[0] = RollDown
Expand All @@ -200,20 +200,20 @@ contract RollDownTest is Test {
}),
l2RequestId: 10,
status: true,
blockHash: 0x000000000000000000000000000000000000000000000000000000000000000b
timeStamp: 3
});

uint256[] memory l2UpdatesToRemove = new uint256[](1);
l2UpdatesToRemove[0] = 13;
l1Update.pendingL2UpdatesToRemove[0] = RollDown.L2UpdatesToRemove({
requestId: RollDown.RequestId({id: 12, origin: RollDown.Origin.L1}),
l2UpdatesToRemove: l2UpdatesToRemove,
blockHash: 0x000000000000000000000000000000000000000000000000000000000000000e
timeStamp: 4
});

assertEq(
keccak256(abi.encode(l1Update)),
0x5129c9a6605d367397902fa839ef429af9abed97f0dd36e3b1973939817d40dc
0x6ebab65d2a7e2e2ac74b0415ccb2943ed7818bec57609986ab154b6880311c89
);
}

Expand Down Expand Up @@ -958,4 +958,76 @@ contract RollDownTest is Test {
});
rollDown.update_l1_from_l2(l2Update2);
}

function testNonsuccessfullDepositHandling() public {
// Arrange
address payable alice = users[0];
token = new MyERC20();
address tokenAddress = address(token);
uint256 amount = 10;
deal(tokenAddress, alice, 100 ether);
uint256 aliceBalanceBefore = token.balanceOf(alice);
uint256 contractBalanceBefore = token.balanceOf(address(rollDown));

// Act
vm.startPrank(alice);
token.approve(address(rollDown), amount);
rollDown.deposit(tokenAddress, 10);
uint256 aliceBalanceAfterDeposit = token.balanceOf(alice);
uint256 contractAfterDeposit = token.balanceOf(address(rollDown));

RollDown.L2Update memory l2Update;
l2Update.results = new RollDown.RequestResult[](1);
l2Update.results[0] = RollDown.RequestResult({
requestId: RollDown.RequestId({id: 1, origin: RollDown.Origin.L2}),
originRequestId: 1,
updateType: RollDown.UpdateType.DEPOSIT,
status: false
});
rollDown.update_l1_from_l2(l2Update);
uint256 aliceBalanceAfterDepositUpdate = token.balanceOf(alice);
uint256 contractAfterDepositUpdate = token.balanceOf(address(rollDown));
vm.stopPrank();

assertEq(aliceBalanceBefore - aliceBalanceAfterDeposit, 10);
assertEq(contractAfterDeposit - contractBalanceBefore, 10);
assertEq(aliceBalanceBefore - aliceBalanceAfterDepositUpdate, 0);
assertEq(contractBalanceBefore - contractAfterDepositUpdate, 0);
}

function testSuccessfullDepositHandling() public {
// Arrange
address payable alice = users[0];
token = new MyERC20();
address tokenAddress = address(token);
uint256 amount = 10;
deal(tokenAddress, alice, 100 ether);
uint256 aliceBalanceBefore = token.balanceOf(alice);
uint256 contractBalanceBefore = token.balanceOf(address(rollDown));

// Act
vm.startPrank(alice);
token.approve(address(rollDown), amount);
rollDown.deposit(tokenAddress, 10);
uint256 aliceBalanceAfterDeposit = token.balanceOf(alice);
uint256 contractAfterDeposit = token.balanceOf(address(rollDown));

RollDown.L2Update memory l2Update;
l2Update.results = new RollDown.RequestResult[](1);
l2Update.results[0] = RollDown.RequestResult({
requestId: RollDown.RequestId({id: 1, origin: RollDown.Origin.L2}),
originRequestId: 1,
updateType: RollDown.UpdateType.DEPOSIT,
status: true
});
rollDown.update_l1_from_l2(l2Update);
uint256 aliceBalanceAfterDepositUpdate = token.balanceOf(alice);
uint256 contractAfterDepositUpdate = token.balanceOf(address(rollDown));
vm.stopPrank();

assertEq(aliceBalanceBefore - aliceBalanceAfterDeposit, 10);
assertEq(contractAfterDeposit - contractBalanceBefore, 10);
assertEq(aliceBalanceBefore - aliceBalanceAfterDepositUpdate, 10);
assertEq(contractAfterDepositUpdate - contractBalanceBefore, 10);
}
}
60 changes: 30 additions & 30 deletions rollup-sequencer/package-lock.json
View file

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

4 changes: 2 additions & 2 deletions rollup-sequencer/package.json
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,8 +19,8 @@
"typescript": "5.3.2"
},
"dependencies": {
"@mangata-finance/sdk": "2.2.1-eth-rollup-develop.13",
"@mangata-finance/types": "2.2.3-eth-rollup-develop.20",
"@mangata-finance/sdk": "2.2.1-eth-rollup-develop.20",
"@mangata-finance/types": "2.2.3-eth-rollup-develop.27",
"@polkadot/api": "^10.12.2",
"dotenv": "^16.3.1",
"viem": "^1.19.11"
Expand Down
Loading

0 comments on commit f8bfb89

Please sign in to comment.