enhancement/precompile-resolveaddress

Author: Sam-wiz

README.md

@@ -67,7 +67,7 @@ Additional FVM support can be found in the [filecoin-solidity library](https://g
 | Supported | Name | Address |
 | :-------: | :--- | :------ |
 | ❌ | ResolveAddress | `0xfe00000000000000000000000000000000000001` |
-| ❌ | LookupDelegatedAddress | `0xfe00000000000000000000000000000000000002` |
+| ✅ | LookupDelegatedAddress | `0xfe00000000000000000000000000000000000002` |
 | ✅ | CallActorByAddress | `0xfe00000000000000000000000000000000000003` |
 | ✅ | CallActorById | `0xfe00000000000000000000000000000000000005` |
 | ✅ | GetBeaconRandomness | `0xfe00000000000000000000000000000000000006` |

src/FVMAddress.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+pragma solidity ^0.8.30;
+
+import {LOOKUP_DELEGATED_ADDRESS} from "./FVMPrecompiles.sol";
+
+library FVMAddress {
+    function lookupDelegatedAddress(uint64 actorId) internal view returns (bool success, bytes memory delegatedAddress) {
+        (success, delegatedAddress) = address(LOOKUP_DELEGATED_ADDRESS).staticcall(abi.encode(uint256(actorId)));
+    }
+
+    function actorIdToEthAddress(uint64 actorId) internal view returns (bool success, address ethAddress) {
+        bytes memory delegatedAddress;
+        (success, delegatedAddress) = lookupDelegatedAddress(actorId);
+
+        if (success && delegatedAddress.length == 22) {
+            if (delegatedAddress[0] == 0x04 && delegatedAddress[1] == 0x0a) {
+                assembly ("memory-safe") {
+                    ethAddress := mload(add(delegatedAddress, 22))
+                }
+                return (true, ethAddress);
+            }
+        }
+        return (false, address(0));
+    }
+}

src/mocks/FVMLookupDelegatedAddress.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+pragma solidity ^0.8.30;
+
+contract FVMLookupDelegatedAddress {
+    mapping(uint64 => bytes) public delegatedAddressMocks;
+
+    function mockLookupDelegatedAddress(uint64 actorId, bytes memory delegatedAddress) external {
+        delegatedAddressMocks[actorId] = delegatedAddress;
+    }
+
+    function mockActorIdToEthAddress(uint64 actorId, address ethAddress) external {
+        bytes memory delegatedAddress = new bytes(22);
+        delegatedAddress[0] = 0x04;
+        delegatedAddress[1] = 0x0a;
+ 
+        for (uint256 i = 0; i < 20; i++) {
+            delegatedAddress[i + 2] = bytes20(ethAddress)[i];
+        }
+
+        delegatedAddressMocks[actorId] = delegatedAddress;
+    }
+
+    fallback() external {
+        uint64 actorId;
+        assembly ("memory-safe") {
+            actorId := calldataload(0)
+        }
+
+        bytes memory delegatedAddress = delegatedAddressMocks[actorId];
+
+        assembly ("memory-safe") {
+            let len := mload(delegatedAddress)
+            if len {
+                return(add(delegatedAddress, 32), len)
+            }
+            return(0, 0)
+        }
+    }
+}

src/mocks/MockFVMTest.sol

@@ -3,18 +3,20 @@ pragma solidity ^0.8.30;
 
 import {Test} from "forge-std/Test.sol";
 
-import {CALL_ACTOR_BY_ADDRESS, CALL_ACTOR_BY_ID, GET_BEACON_RANDOMNESS} from "../FVMPrecompiles.sol";
+import {CALL_ACTOR_BY_ADDRESS, CALL_ACTOR_BY_ID, GET_BEACON_RANDOMNESS, LOOKUP_DELEGATED_ADDRESS} from "../FVMPrecompiles.sol";
 import {FVMCallActorByAddress} from "./FVMCallActorByAddress.sol";
 import {FVMCallActorById} from "./FVMCallActorById.sol";
 import {FVMGetBeaconRandomness} from "./FVMGetBeaconRandomness.sol";
+import {FVMLookupDelegatedAddress} from "./FVMLookupDelegatedAddress.sol";
 
-/// @notice Mocks the FVM precompiles for forge test
 contract MockFVMTest is Test {
     FVMGetBeaconRandomness public constant RANDOMNESS_PRECOMPILE = FVMGetBeaconRandomness(GET_BEACON_RANDOMNESS);
+    FVMLookupDelegatedAddress public constant LOOKUP_DELEGATED_ADDRESS_PRECOMPILE = FVMLookupDelegatedAddress(LOOKUP_DELEGATED_ADDRESS);
 
     function setUp() public virtual {
         vm.etch(CALL_ACTOR_BY_ADDRESS, address(new FVMCallActorByAddress()).code);
         vm.etch(CALL_ACTOR_BY_ID, address(new FVMCallActorById()).code);
         vm.etch(GET_BEACON_RANDOMNESS, address(new FVMGetBeaconRandomness()).code);
+        vm.etch(LOOKUP_DELEGATED_ADDRESS, address(new FVMLookupDelegatedAddress()).code);
     }
 }

test/Address.t.sol

@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+pragma solidity ^0.8.30;
+
+import {MockFVMTest} from "../src/mocks/MockFVMTest.sol";
+import {FVMAddress} from "../src/FVMAddress.sol";
+
+contract AddressTest is MockFVMTest {
+    using FVMAddress for uint64;
+
+    function testLookupDelegatedAddressNotFound() public view {
+        uint64 fakeActorId = 99999;
+        (bool success, bytes memory delegatedAddress) = FVMAddress.lookupDelegatedAddress(fakeActorId);
+        assertTrue(success);
+        assertEq(delegatedAddress.length, 0);
+    }
+
+    function testLookupDelegatedAddressMocked() public {
+        uint64 testActorId = 54321;
+        bytes memory expectedAddress = hex"040a1234567890abcdef1234567890abcdef1234";
+
+        LOOKUP_DELEGATED_ADDRESS_PRECOMPILE.mockLookupDelegatedAddress(testActorId, expectedAddress);
+
+        (bool success, bytes memory delegatedAddress) = FVMAddress.lookupDelegatedAddress(testActorId);
+        assertTrue(success);
+        assertEq(delegatedAddress, expectedAddress);
+    }
+
+    function testActorIdToEthAddress() public {
+        uint64 testActorId = 11111;
+        address expectedEthAddress = address(0x1234567890AbcdEF1234567890aBcdef12345678);
+
+        LOOKUP_DELEGATED_ADDRESS_PRECOMPILE.mockActorIdToEthAddress(testActorId, expectedEthAddress);
+
+        (bool success, address ethAddress) = FVMAddress.actorIdToEthAddress(testActorId);
+        assertTrue(success);
+        assertEq(ethAddress, expectedEthAddress);
+    }
+
+    function testActorIdToEthAddressNotFound() public view {
+        uint64 fakeActorId = 99999;
+        (bool success, address ethAddress) = FVMAddress.actorIdToEthAddress(fakeActorId);
+        assertFalse(success);
+        assertEq(ethAddress, address(0));
+    }
+
+    function testActorIdToEthAddressInvalidPrefix() public {
+        uint64 testActorId = 22222;
+        bytes memory invalidAddress = hex"ff0a1234567890abcdef1234567890abcdef1234";
+
+        LOOKUP_DELEGATED_ADDRESS_PRECOMPILE.mockLookupDelegatedAddress(testActorId, invalidAddress);
+
+        (bool success, address ethAddress) = FVMAddress.actorIdToEthAddress(testActorId);
+        assertFalse(success);
+        assertEq(ethAddress, address(0));
+    }
+
+    function testActorIdToEthAddressWrongLength() public {
+        uint64 testActorId = 33333;
+        bytes memory shortAddress = hex"040a12345678";
+
+        LOOKUP_DELEGATED_ADDRESS_PRECOMPILE.mockLookupDelegatedAddress(testActorId, shortAddress);
+
+        (bool success, address ethAddress) = FVMAddress.actorIdToEthAddress(testActorId);
+        assertFalse(success);
+        assertEq(ethAddress, address(0));
+    }
+}