Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

test: add extreme case tests #971

Merged
merged 1 commit into from
Aug 26, 2024
Merged

test: add extreme case tests #971

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
24 changes: 24 additions & 0 deletions packages/lsp26-contracts/contracts/mock/InfiniteLoopURD.sol
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,24 @@
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.17;

// interfaces
import {
ILSP1UniversalReceiver
} from "@lukso/lsp1-contracts/contracts/ILSP1UniversalReceiver.sol";

contract InfiniteLoopURD is ILSP1UniversalReceiver {
uint256 public counter;

function supportsInterface(bytes4) external pure returns (bool) {
return true;
}

function universalReceiver(
bytes32,
bytes memory
) external payable returns (bytes memory) {
while (true) {
++counter;
}
}
}
26 changes: 26 additions & 0 deletions packages/lsp26-contracts/contracts/mock/ReturnBomb.sol
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,26 @@
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.17;

// interfaces
import {
ILSP1UniversalReceiver
} from "@lukso/lsp1-contracts/contracts/ILSP1UniversalReceiver.sol";

contract ReturnBomb is ILSP1UniversalReceiver {
uint256 public counter;

function supportsInterface(bytes4) external pure returns (bool) {
return true;
}

function universalReceiver(
bytes32,
bytes memory
) external payable returns (bytes memory) {
++counter;
// solhint-disable-next-line no-inline-assembly
assembly {
revert(0, 10000)
}
}
}
23 changes: 23 additions & 0 deletions packages/lsp26-contracts/contracts/mock/SelfDestructOnInterfaceCheck.sol
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,23 @@
// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.17;

// interfaces
import {
ILSP1UniversalReceiver
} from "@lukso/lsp1-contracts/contracts/ILSP1UniversalReceiver.sol";

contract SelfDestructOnInterfaceCheck is ILSP1UniversalReceiver {
uint256 public counter;

function supportsInterface(bytes4) external returns (bool) {
selfdestruct(payable(msg.sender));
return true;
}

function universalReceiver(
bytes32,
bytes memory
) external payable returns (bytes memory) {
return "";
}
}
96 changes: 96 additions & 0 deletions packages/lsp26-contracts/tests/LSP26FollowerSystem.test.ts
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,6 +15,12 @@ import {
LSP0ERC725Account__factory,
RevertOnFollow__factory,
RevertOnFollow,
ReturnBomb__factory,
ReturnBomb,
SelfDestructOnInterfaceCheck__factory,
SelfDestructOnInterfaceCheck,
InfiniteLoopURD,
InfiniteLoopURD__factory,
} from '../types';

describe('testing `LSP26FollowerSystem`', () => {
Expand Down Expand Up @@ -115,6 +121,96 @@ describe('testing `LSP26FollowerSystem`', () => {
});
});

describe('testing follow/unfollow a contract that self destructs on interface check', async () => {
let selfDestruct: SelfDestructOnInterfaceCheck;

before(async () => {
selfDestruct = await new SelfDestructOnInterfaceCheck__factory(context.owner).deploy();
});

it('should pass following', async () => {
await context.followerSystem.connect(context.owner).follow(await selfDestruct.getAddress());

expect(
await context.followerSystem.isFollowing(
context.owner.address,
await selfDestruct.getAddress(),
),
).to.be.true;
});

it('should pass unfollowing', async () => {
await context.followerSystem.connect(context.owner).unfollow(await selfDestruct.getAddress());

expect(
await context.followerSystem.isFollowing(
context.owner.address,
await selfDestruct.getAddress(),
),
).to.be.false;
});
});

describe('testing follow/unfollow a contract with return bomb', () => {
let returnBomb: ReturnBomb;

before(async () => {
returnBomb = await new ReturnBomb__factory(context.owner).deploy();
});

it('should pass following', async () => {
await context.followerSystem.connect(context.owner).follow(await returnBomb.getAddress());

expect(
await context.followerSystem.isFollowing(
context.owner.address,
await returnBomb.getAddress(),
),
).to.be.true;
});

it('should pass unfollowing', async () => {
await context.followerSystem.connect(context.owner).unfollow(await returnBomb.getAddress());

expect(
await context.followerSystem.isFollowing(
context.owner.address,
await returnBomb.getAddress(),
),
).to.be.false;
});
});

describe('testing follow/unfollow a contract that has an infinite loop in urd', () => {
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

So.. a newbie question, how does it pass with this infinite loop running?
I see we get to

ILSP1UniversalReceiver(addr).universalReceiver(
                    _TYPEID_LSP26_FOLLOW,
                    abi.encodePacked(msg.sender)
                )

In the LSP26 contract and how does it not fail meaning the loop doesn't prevent transaction from failing letting the user to follow/unfollow?

Copy link
Member Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The external call to the contract that has the unviersalReceiver function with an infinite loop reverts, but due to the fact that we call that function using try/catch and we don't do anything in the catch, it does not revert while following or unfollowing someone. Usually you would catch the revert in the catch block and do what you need to from there. In our case we want to make sure we notify yet never revert.

let infiniteLoop: InfiniteLoopURD;

before(async () => {
infiniteLoop = await new InfiniteLoopURD__factory(context.owner).deploy();
});

it('should pass following', async () => {
await context.followerSystem.connect(context.owner).follow(await infiniteLoop.getAddress());

expect(
await context.followerSystem.isFollowing(
context.owner.address,
await infiniteLoop.getAddress(),
),
).to.be.true;
});

it('should pass unfollowing', async () => {
await context.followerSystem.connect(context.owner).unfollow(await infiniteLoop.getAddress());

expect(
await context.followerSystem.isFollowing(
context.owner.address,
await infiniteLoop.getAddress(),
),
).to.be.false;
});
});

describe.skip('gas tests', () => {
const gasCostResult: {
followingGasCost?: number[];
Expand Down
Loading