Add teleportation unit tests to test/AnlogTokenV2.t.sol (#15)

* add test_TeleportOut_Below_ED()

* add test_TeleportOut_Low_Value()

* add test_TeleportOut() (rough match 4 GmpCreated)

save

use analog-gmp from branch

save

test_TeleportOut

* add test_TeleportIn()

* enhance test_TeleportOut(): exact match

Author: agryaznov

.gitmodules

@@ -10,3 +10,4 @@
 [submodule "lib/analog-gmp"]
 	path = lib/analog-gmp
 	url = https://github.com/Analog-Labs/analog-gmp
+	branch = ag/fix

lib/analog-gmp

@@ -5,12 +5,30 @@ import {Test, console} from "forge-std/Test.sol";
 import {Upgrades, Options} from "openzeppelin-foundry-upgrades/Upgrades.sol";
 import {PausableUpgradeable} from "@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol";
 import {IAccessControl} from "@openzeppelin/contracts/access/IAccessControl.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {AnlogTokenV2} from "../src/AnlogTokenV2.sol";
 
+import {
+    IGateway,
+    IExecutor,
+    Gateway,
+    Route,
+    NetworkID,
+    ERC1967,
+    TssKey,
+    GmpMessage,
+    Signature
+} from "analog-gmp/src/Gateway.sol";
+import {GmpMessage, PrimitiveUtils, GmpSender, GmpStatus} from "analog-gmp/src/Primitives.sol";
+import {TestUtils, SigningKey, SigningUtils} from "analog-gmp/test/TestUtils.sol";
+
 /// @notice OZ ERC20 and its presets are covered with Hardhat tests.
 /// Hence we keep these few basic tests here more as a boilerplate for
 /// the future tests for custom added fetaures.
 contract AnlogTokenV2Test is Test {
+    using PrimitiveUtils for GmpMessage;
+    using SigningUtils for SigningKey;
+
     AnlogTokenV2 public token;
 
     address constant MINTER = address(0);
@@ -21,13 +39,23 @@ contract AnlogTokenV2Test is Test {
 
     // Teleport-related
     address constant GATEWAY = 0xEb73D0D236DE8F8D09dc6A52916e5849ff1E8dfA;
+    // ERC-1967 storage slot for admin address:
+    // 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103
+    // Can be queried with
+    // cast storage 0xEb73D0D236DE8F8D09dc6A52916e5849ff1E8dfA 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103 -r $SEPOLIA_RPC_URL
+    address constant GW_ADMIN = 0x38a78edA59AC73A95281Cb009A5EF986e320509F;
     uint16 constant TIMECHAIN_ID = 1000;
     uint256 constant MIN_TELEPORT_VAL = 1000000000000;
 
     // fork testing
     string SEPOLIA_RPC_URL = vm.envString("SEPOLIA_RPC_URL");
     uint256 sepoliaFork;
 
+    // Chronicle TSS Secret
+    uint256 private constant SECRET = 0x42;
+    address private constant SIGNER_ADDRESS = 0x2e234DAe75C793f67A35089C9d99245E1C58470b;
+    uint256 private constant SIGNING_NONCE = 0x69;
+
     /// @notice deploys an UUPS proxy.
     /// Here we start with the V1 implementation right away.
     /// For V0->V1 upgrade see another test.
@@ -46,6 +74,29 @@ contract AnlogTokenV2Test is Test {
         token = AnlogTokenV2(proxy);
     }
 
+    modifier setRoute() {
+        Route memory route = Route(NetworkID.wrap(1000), 15_000_000, 0, bytes32(bytes20(address(42))), 1, 1);
+        address payable gw = payable(GATEWAY);
+
+        vm.prank(GW_ADMIN);
+        Gateway(gw).setRoute(route);
+
+        _;
+    }
+
+    modifier setShard() {
+        Route memory route = Route(NetworkID.wrap(1000), 15_000_000, 0, bytes32(bytes20(address(42))), 1, 1);
+        address payable gw = payable(GATEWAY);
+
+        SigningKey memory signer = TestUtils.createSigner(SECRET);
+        TssKey memory shardKey = TssKey({yParity: signer.yParity() == 28 ? 3 : 2, xCoord: signer.xCoord()});
+
+        vm.prank(GW_ADMIN);
+        Gateway(gw).setShard(shardKey);
+
+        _;
+    }
+
     modifier preMint(address to, uint256 amount) {
         assertEq(token.totalSupply(), 0);
         vm.prank(MINTER);
@@ -61,6 +112,13 @@ contract AnlogTokenV2Test is Test {
         _;
     }
 
+    function sign(GmpMessage memory gmp) internal pure returns (Signature memory) {
+        bytes32 hash = gmp.eip712hash();
+        SigningKey memory signer = TestUtils.createSigner(SECRET);
+        (uint256 e, uint256 s) = signer.signPrehashed(hash, SIGNING_NONCE);
+        return Signature({xCoord: signer.xCoord(), e: e, s: s});
+    }
+
     function test_name_and_ticker() public view {
         assertEq(token.name(), "Wrapped Analog One Token");
         assertEq(token.symbol(), "WANLOG");
@@ -160,4 +218,94 @@ contract AnlogTokenV2Test is Test {
         );
         token.unpause();
     }
+
+    function test_TeleportOut_Below_ED() public preMint(address(this), MIN_TELEPORT_VAL - 1) {
+        bytes32 dest = bytes32(bytes20(UPGRADER));
+        vm.expectRevert("value below minimum required");
+        token.teleport(dest, MIN_TELEPORT_VAL - 1);
+    }
+
+    function test_TeleportOut_Low_Value() public preMint(address(this), MIN_TELEPORT_VAL) setRoute {
+        bytes32 dest = bytes32(bytes20(uint160(UPGRADER)));
+
+        vm.expectEmit(address(token));
+        emit IERC20.Transfer(address(this), address(0), MIN_TELEPORT_VAL);
+        vm.expectRevert("insufficient tx value");
+        token.teleport(dest, MIN_TELEPORT_VAL);
+    }
+
+    function test_TeleportOut() public preMint(address(this), MIN_TELEPORT_VAL) setRoute {
+        address payable gw = payable(GATEWAY);
+        bytes32 dest = bytes32(uint256(uint160(UPGRADER)));
+        uint256 cost = token.estimateTeleportCost();
+
+        GmpSender source = GmpSender.wrap(bytes32(uint256(uint160(SIGNER_ADDRESS))));
+
+        AnlogTokenV2.OutboundTeleportCommand memory command =
+            AnlogTokenV2.OutboundTeleportCommand(address(this), dest, MIN_TELEPORT_VAL);
+
+        GmpMessage memory gmp = GmpMessage({
+            source: source,
+            srcNetwork: Gateway(gw).networkId(),
+            dest: address(0),
+            destNetwork: TIMECHAIN_ID,
+            gasLimit: 100_000,
+            nonce: 0,
+            data: abi.encode(command)
+        });
+
+        bytes32 messageID = gmp.eip712hash();
+
+        vm.expectEmit(address(token));
+        emit IERC20.Transfer(address(this), address(0), MIN_TELEPORT_VAL);
+
+        vm.expectEmit(true, true, true, true, address(GATEWAY));
+        emit IGateway.GmpCreated(
+            messageID,
+            GmpSender.unwrap(gmp.source),
+            gmp.dest,
+            gmp.destNetwork,
+            gmp.gasLimit,
+            179835,
+            gmp.nonce,
+            gmp.data
+        );
+
+        vm.expectEmit(true, true, true, true, address(token));
+        emit AnlogTokenV2.OutboundTransfer(messageID, address(this), dest, MIN_TELEPORT_VAL);
+
+        token.teleport{value: cost}(dest, MIN_TELEPORT_VAL);
+    }
+
+    function test_TeleportIn() public setRoute setShard {
+        address payable gw = payable(GATEWAY);
+        GmpSender source = GmpSender.wrap(bytes32(uint256(uint160(0))));
+
+        AnlogTokenV2.InboundTeleportCommand memory command =
+            AnlogTokenV2.InboundTeleportCommand(GmpSender.unwrap(source), UPGRADER, MIN_TELEPORT_VAL);
+
+        GmpMessage memory gmp = GmpMessage({
+            source: source,
+            srcNetwork: TIMECHAIN_ID,
+            dest: address(token),
+            destNetwork: Gateway(gw).networkId(),
+            gasLimit: 100_000,
+            nonce: 0,
+            data: abi.encode(command)
+        });
+
+        assertEq(token.totalSupply(), 0);
+
+        Signature memory sig = sign(gmp);
+        bytes32 messageID = gmp.eip712hash();
+
+        vm.expectEmit(true, true, true, true, GATEWAY);
+        emit IExecutor.GmpExecuted(messageID, gmp.source, gmp.dest, GmpStatus.SUCCESS, bytes32(MIN_TELEPORT_VAL));
+
+        Gateway(gw).execute(sig, gmp);
+        assertTrue(Gateway(gw).gmpInfo(messageID).status == GmpStatus.SUCCESS, "failed to execute GMP message");
+
+        assertEq(token.balanceOf(UPGRADER), MIN_TELEPORT_VAL);
+        assertEq(token.totalSupply(), MIN_TELEPORT_VAL);
+    }
 }