feat: convert 'f0...' strings to eth addrs (#55)

There are two places where an `f0...` string was included in the
response data:
- `getBlob()` and the `subscriber` field
- `getAccount()` and the `to` field with a credit approval

These are now converted to EVM addresses:
- We call the FVM precompile to look up the delegated address for a
  given actor ID number
- If a value is returned, we convert it to an EVM address
- If a value is not returned, we assume it's a masked ID address and
  convert it accordingly

For example, calling `getAccount()` used to return something like this:
```
(6, 499..., 504..., 0x000..., 7200, [("f0127", ...)
```
Now, it returns an address instead of `"f0127"`:
```
(6, 499..., 504..., 0x000..., 7200, [(0x90F79bf6EB2c4f870365E785982E1f101E93b906, ...)
```

Also, the tests were failing, so the `foundry.toml` settings have been
updated to fix this.
The root cause was [here](https://github.com/hokunet/contracts/actions/runs/12779553700/job/35624355833#step:7:79)
where `LibBlob` and `LibBucket` had a negative runtime margin value,
causing the CI process to exit early.

Lastly, this includes some linting fixes are included wrt tests.

Author: dtbuchholz

README.md

@@ -385,13 +385,13 @@ We can get the credit account info for the address at `EVM_ADDRESS` (the variabl
 you could provide any account's EVM public key that exists in the subnet.
 
 ```sh
-cast abi-decode "getAccount(address)((uint64,uint256,uint256,address,uint64,(string,(uint256,uint256,uint64,uint256,uint256))[],uint64,uint256))" $(cast call --rpc-url $ETH_RPC_URL $CREDIT "getAccount(address)" $EVM_ADDRESS)
+cast abi-decode "getAccount(address)((uint64,uint256,uint256,address,uint64,(address,(uint256,uint256,uint64,uint256,uint256))[],uint64,uint256))" $(cast call --rpc-url $ETH_RPC_URL $CREDIT "getAccount(address)" $EVM_ADDRESS)
 ```
 
 This will return the following values:
 
 ```
-(6, 4999999999999999454276000000000000000000 [4.999e39], 504150000000000000000000 [5.041e23], 0x0000000000000000000000000000000000000000, 7200, [("f0127", (12345000000000000000000 [1.234e22], 987654321 [9.876e8], 11722 [1.172e4], 0, 0))], 86400 [8.64e4], 4999999984799342175554 [4.999e21])
+(6, 4999999999999999454276000000000000000000 [4.999e39], 504150000000000000000000 [5.041e23], 0x0000000000000000000000000000000000000000, 7200, [(0x90F79bf6EB2c4f870365E785982E1f101E93b906, (12345000000000000000000 [1.234e22], 987654321 [9.876e8], 11722 [1.172e4], 0, 0))], 86400 [8.64e4], 4999999984799342175554 [4.999e21])
 ```
 
 Which maps to the `Account` struct:
@@ -414,7 +414,7 @@ approvals authorized. We can expand this to be interpreted as the following:
 
 ```solidity
 struct Approval {
-    string to; // f0127
+    string to; // 0x90F79bf6EB2c4f870365E785982E1f101E93b906
     CreditApproval approval; // See CreditApproval struct below
 }
 
@@ -489,13 +489,13 @@ struct CreditApproval {
 Fetch the credit balance for the address at `EVM_ADDRESS`:
 
 ```sh
-cast abi-decode "getCreditBalance(address)((uint256,uint256,address,uint64,(string,(uint256,uint256,uint64,uint256,uint256))[],uint256))" $(cast call --rpc-url $ETH_RPC_URL $CREDIT "getCreditBalance(address)" $EVM_ADDRESS)
+cast abi-decode "getCreditBalance(address)((uint256,uint256,address,uint64,(address,(uint256,uint256,uint64,uint256,uint256))[],uint256))" $(cast call --rpc-url $ETH_RPC_URL $CREDIT "getCreditBalance(address)" $EVM_ADDRESS)
 ```
 
 This will return the following values:
 
 ```
-(5001999999999998208637000000000000000000 [5.001e39], 518400000000000000000000 [5.184e23], 0x0000000000000000000000000000000000000000, 6932, [("f0127", (0, 0, 0, 0, 0))], 1)
+(5001999999999998208637000000000000000000 [5.001e39], 518400000000000000000000 [5.184e23], 0x0000000000000000000000000000000000000000, 6932, [(0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65, (0, 0, 0, 0, 0))], 1)
 ```
 
 Which maps to the `Balance` struct:
@@ -510,7 +510,7 @@ struct Balance {
 }
 
 struct Approval {
-    string to; // f0127
+    string to; // 0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65
     CreditApproval approval; // See CreditApproval struct below
 }
 
@@ -1046,13 +1046,13 @@ This will emit an `OverwriteBlob` event and overwrite the blob in the network.
 ##### Get a blob
 
 ```sh
-cast abi-decode "getBlob(string)((uint64,string,(string,(string,(uint64,uint64,string,address,bool))[])[],uint8))" $(cast call --rpc-url $ETH_RPC_URL $BLOBS "getBlob(string)" "rzghyg4z3p6vbz5jkgc75lk64fci7kieul65o6hk6xznx7lctkmq")
+cast abi-decode "getBlob(string)((uint64,string,(address,(string,(uint64,uint64,string,address,bool))[])[],uint8))" $(cast call --rpc-url $ETH_RPC_URL $BLOBS "getBlob(string)" "rzghyg4z3p6vbz5jkgc75lk64fci7kieul65o6hk6xznx7lctkmq")
 ```
 
 This will return the following response:
 
 ```sh
-(6, "utiakbxaag7udhsriu6dm64cgr7bk4zahiudaaiwuk6rfv43r3rq", [("f0124", [("foo", (4825, 91225 [9.122e4], "cydkrslhbj4soqppzc66u6lzwxgjwgbhdlxmyeahytzqrh65qtjq", 0x0000000000000000000000000000000000000000, false))])], 2)
+(6, "utiakbxaag7udhsriu6dm64cgr7bk4zahiudaaiwuk6rfv43r3rq", [(0x90F79bf6EB2c4f870365E785982E1f101E93b906, [("foo", (4825, 91225 [9.122e4], "cydkrslhbj4soqppzc66u6lzwxgjwgbhdlxmyeahytzqrh65qtjq", 0x0000000000000000000000000000000000000000, false))])], 2)
 ```
 
 Which maps to the `Blob` struct:
@@ -1066,7 +1066,7 @@ struct Blob {
 }
 
 struct Subscriber {
-    string subscriber; // f0124
+    address subscriber; // 0x90F79bf6EB2c4f870365E785982E1f101E93b906
     SubscriptionGroup[] subscriptionGroup; // See `SubscriptionGroup` struct below
 }
 
@@ -1122,7 +1122,7 @@ cast abi-decode "getAddedBlobs(uint32)((string,(address,string,string)[])[])" $(
 This returns the values of added blobs, up to the `size` passed as the parameter:
 
 ```sh
-[("rzghyg4z3p6vbz5jkgc75lk64fci7kieul65o6hk6xznx7lctkmq", [(0x90F79bf6EB2c4f870365E785982E1f101E93b906, "Default", "cydkrslhbj4soqppzc66u6lzwxgjwgbhdlxmyeahytzqrh65qtjq")])]
+[("rzghyg4z3p6vbz5jkgc75lk64fci7kieul65o6hk6xznx7lctkmq", [(0x90F79bf6EB2c4f870365E785982E1f101E93b906, "default", "cydkrslhbj4soqppzc66u6lzwxgjwgbhdlxmyeahytzqrh65qtjq")])]
 ```
 
 Which maps to an array of the `BlobTuple` struct:
@@ -1135,7 +1135,7 @@ struct BlobTuple {
 
 struct BlobSourceInfo {
     address subscriber; // 0x90F79bf6EB2c4f870365E785982E1f101E93b906
-    string subscriptionId; // "Default"
+    string subscriptionId; // "default"
     string source; // "cydkrslhbj4soqppzc66u6lzwxgjwgbhdlxmyeahytzqrh65qtjq"
 }
 ```
@@ -1149,7 +1149,7 @@ cast abi-decode "getPendingBlobs(uint32)((string,(address,string,string)[])[])"
 This returns the values of pending blobs, up to the `size` passed as the parameter:
 
 ```sh
-[("rzghyg4z3p6vbz5jkgc75lk64fci7kieul65o6hk6xznx7lctkmq", [(0x90F79bf6EB2c4f870365E785982E1f101E93b906, "Default", "cydkrslhbj4soqppzc66u6lzwxgjwgbhdlxmyeahytzqrh65qtjq")])]
+[("rzghyg4z3p6vbz5jkgc75lk64fci7kieul65o6hk6xznx7lctkmq", [(0x90F79bf6EB2c4f870365E785982E1f101E93b906, "default", "cydkrslhbj4soqppzc66u6lzwxgjwgbhdlxmyeahytzqrh65qtjq")])]
 ```
 
 Which maps to an array of the `BlobTuple` struct:
@@ -1162,7 +1162,7 @@ struct BlobTuple {
 
 struct BlobSourceInfo {
     address subscriber; // 0x90F79bf6EB2c4f870365E785982E1f101E93b906
-    string subscriptionId; // "Default"
+    string subscriptionId; // "default"
     string source; // "cydkrslhbj4soqppzc66u6lzwxgjwgbhdlxmyeahytzqrh65qtjq"
 }
 ```

foundry.toml

@@ -6,6 +6,9 @@ test = "test"
 build_info = true
 extra_output = ["storageLayout"]
 gas_reports = ["Hoku"]
+solc_version = "0.8.26"
+optimizer = true
+optimizer_runs = 200
 ffi = true
 ast = true
 via_ir = true

src/types/BlobTypes.sol

@@ -28,11 +28,11 @@ struct Account {
 }
 
 /// @dev Credit approval from one account to another.
-/// @param to (string): Optional restriction on caller address, e.g., an object store. Use zero address if
+/// @param to (address): Optional restriction on caller address, e.g., an object store. Use zero address if
 /// unused, indicating a null value.
 /// @param approval (CreditApproval): The credit approval. See {CreditApproval} for more details.
 struct Approval {
-    string to;
+    address to;
     CreditApproval approval;
 }
 
@@ -185,10 +185,10 @@ enum BlobStatus {
 }
 
 /// @dev A subscriber and their subscription groups.
-/// @param subscriber (string): The subscriber address as a string value (e.g., "f0124").
+/// @param subscriber (address): The subscriber address.
 /// @param subscriptionGroup (SubscriptionGroup[]): The subscription groups. See {SubscriptionGroup} for more details.
 struct Subscriber {
-    string subscriber;
+    address subscriber;
     SubscriptionGroup[] subscriptionGroup;
 }
 

src/wrappers/LibBlob.sol

@@ -111,8 +111,8 @@ library LibBlob {
         bytes[2][] memory decoded = data.decodeCborMappingToBytes();
         approvals = new Approval[](decoded.length);
         for (uint256 i = 0; i < decoded.length; i++) {
-            // TODO: this address (string) value is mainnet prefixed with `f` instead of `t`
-            approvals[i].to = string(decoded[i][0]);
+            // The `to` value is an ID address string, like `f0123`, so we convert it to an address
+            approvals[i].to = decoded[i][0].decodeCborActorIdStringToAddress();
             approvals[i].approval = decodeCreditApproval(decoded[i][1]);
         }
     }
@@ -175,7 +175,8 @@ library LibBlob {
         bytes[2][] memory decoded = data.decodeCborMappingToBytes();
         subscribers = new Subscriber[](decoded.length);
         for (uint256 i = 0; i < decoded.length; i++) {
-            subscribers[i].subscriber = string(decoded[i][0]);
+            // The `subscriber` value is an ID address string, like `f0123`, so we convert it to an address
+            subscribers[i].subscriber = decoded[i][0].decodeCborActorIdStringToAddress();
             subscribers[i].subscriptionGroup = decodeSubscriptionGroup(decoded[i][1]);
         }
     }

src/wrappers/LibWasm.sol

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity ^0.8.26;
 
+import {PrecompilesAPI} from "@filecoin-solidity/v0.8/PrecompilesAPI.sol";
 import {BytesCBOR} from "@filecoin-solidity/v0.8/cbor/BytesCbor.sol";
 import {FilecoinCBOR, Misc} from "@filecoin-solidity/v0.8/cbor/FilecoinCbor.sol";
 import {CommonTypes} from "@filecoin-solidity/v0.8/types/CommonTypes.sol";
@@ -155,8 +156,9 @@ library LibWasm {
                 result := shr(96, mload(add(addr, 34)))
             }
         } else if (addr[0] == 0x00) {
-            // Otherwise, it should be an ID address
-            result = decodeCborActorIdBytesToAddress(addr);
+            // Otherwise, it should be an ID address—and we need to check if it's delegated or masked
+            uint64 actorId = decodeCborActorIdBytesToUint64(addr);
+            result = getDelegatedOrMaskedAddressFromActorId(actorId);
         } else {
             revert InvalidValue("Invalid address length or protocol");
         }
@@ -166,7 +168,24 @@ library LibWasm {
     /// @dev Decode CBOR encoded actor ID bytes to an Ethereum address.
     /// @param data The encoded CBOR actor ID bytes.
     /// @return result The decoded Ethereum address.
-    function decodeCborActorIdBytesToAddress(bytes memory data) internal view returns (address) {
+    function decodeCborActorIdStringToAddress(bytes memory data) internal view returns (address) {
+        bytes memory actorIdStr = new bytes(data.length - 1);
+        // Remove the first byte, which is the network prefix (`f`, which is 0x66)
+        assembly {
+            // Copy to the new array, starting from the second byte
+            let srcPtr := add(add(data, 32), 1) // +32 for length prefix, +1 to skip first byte
+            let destPtr := add(actorIdStr, 32) // +32 for length prefix
+            mstore(destPtr, mload(srcPtr))
+        }
+        uint64 actorId = 0;
+        for (uint64 i = 0; i < actorIdStr.length; i++) {
+            // Just subtract 0x30 to convert from ASCII to number
+            actorId = actorId * 10 + (uint8(actorIdStr[i]) - 0x30);
+        }
+        return getDelegatedOrMaskedAddressFromActorId(actorId);
+    }
+
+    function decodeCborActorIdBytesToUint64(bytes memory data) internal pure returns (uint64) {
         // First, decode the LEB128 bytes value to the actor ID
         uint64 result = 0;
         uint64 shift = 0;
@@ -180,7 +199,16 @@ library LibWasm {
             }
             shift += 7;
         }
-        return FilAddressIdConverter.toAddress(result);
+        return result;
+    }
+
+    /// @dev Get the delegated address for an actor ID, or the masked address if the actor ID is not delegated.
+    /// @param actorId The actor ID.
+    /// @return delegatedAddress The delegated address as bytes. Will be zero value if the actor ID is not delegated.
+    function getDelegatedOrMaskedAddressFromActorId(uint64 actorId) internal view returns (address) {
+        bytes memory data = PrecompilesAPI.lookupDelegatedAddress(actorId);
+        if (data.length == 0) return FilAddressIdConverter.toAddress(actorId);
+        return FilAddresses.toEthAddress(CommonTypes.FilAddress(data));
     }
 
     /// @dev Decode a CBOR encoded Wasm actor address to a string.

test/LibBlob.t.sol

@@ -66,13 +66,16 @@ contract LibBlobTest is Test {
         assertEq(account.creditSponsor, address(0));
         assertEq(account.lastDebitEpoch, 6196);
         assertEq(account.approvals.length, 2);
-        assertEq(account.approvals[0].to, "f0125");
+        // Note: tests will always show this as a masked ID address, but in reality, it's a looked up delegated address
+        // This is because tests don't access the delegated address lookup precompile via the FVM runtime
+        assertEq(account.approvals[0].to, 0xFF0000000000000000000000000000000000007D);
         assertEq(account.approvals[0].approval.creditLimit, 0);
         assertEq(account.approvals[0].approval.gasFeeLimit, 0);
         assertEq(account.approvals[0].approval.expiry, 0);
         assertEq(account.approvals[0].approval.creditUsed, 0);
         assertEq(account.approvals[0].approval.gasFeeUsed, 0);
-        assertEq(account.approvals[1].to, "f0127");
+        // Note: tests will always show this as a masked ID address, but in reality, it's a looked up delegated address
+        assertEq(account.approvals[1].to, 0xff0000000000000000000000000000000000007f);
         assertEq(account.approvals[1].approval.creditLimit, 0);
         assertEq(account.approvals[1].approval.gasFeeLimit, 0);
         assertEq(account.approvals[1].approval.expiry, 0);
@@ -85,7 +88,8 @@ contract LibBlobTest is Test {
         data =
             hex"880652000eb194f8e1ae50e56f45b07f78a0d400004b006dc68533171604000000f6191834a1656630313235854c0052b7d2dcc80cd2e4000000430003e81927844b0005650e85ae5dfb900000401a000151804b00010f0cf0647f152e0ab9";
         account = data.decodeAccount();
-        assertEq(account.approvals[0].to, "f0125");
+        // Note: tests will always show this as a masked ID address, but in reality, it's a looked up delegated address
+        assertEq(account.approvals[0].to, 0xFF0000000000000000000000000000000000007D);
         assertEq(account.approvals[0].approval.creditLimit, 100000000000000000000000000);
         assertEq(account.approvals[0].approval.gasFeeLimit, 1000);
         assertEq(account.approvals[0].approval.expiry, 10116);
@@ -174,7 +178,8 @@ contract LibBlobTest is Test {
         bytes memory data =
             hex"a1656630313234a17840343564616464393261326161373431383133323638376639613432313439306261643963356161643332656134653937623135356533373739316630306435308519021f1a0001539f982018fd18bb1871185b08188508184418a1183e182b18b518980118cb18a60218bf183b18351118720418fb18f41836188101181b18ef18941839f6f4";
         Subscriber[] memory subscribers = LibBlob.decodeSubscribers(data);
-        assertEq(subscribers[0].subscriber, "f0124");
+        // Note: tests will always show this as a masked ID address, but in reality, it's a looked up delegated address
+        assertEq(subscribers[0].subscriber, 0xFf0000000000000000000000000000000000007C);
         assertEq(
             subscribers[0].subscriptionGroup[0].subscriptionId,
             "45dadd92a2aa7418132687f9a421490bad9c5aad32ea4e97b155e37791f00d50"
@@ -192,7 +197,8 @@ contract LibBlobTest is Test {
         data =
             hex"a1656630313234a2784034316664336363386562303731323262663165356564383562306236393237666236663162336630643662313331326261366531396437646536386366373833851908eb1a00015a6b982018fd18bb1871185b08188508184418a1183e182b18b518980118cb18a60218bf183b18351118720418fb18f41836188101181b18ef18941839f6f47840343564616464393261326161373431383133323638376639613432313439306261643963356161643332656134653937623135356533373739316630306435308519021f1a0001539f982018fd18bb1871185b08188508184418a1183e182b18b518980118cb18a60218bf183b18351118720418fb18f41836188101181b18ef18941839f6f4";
         subscribers = LibBlob.decodeSubscribers(data);
-        assertEq(subscribers[0].subscriber, "f0124");
+        // Note: tests will always show this as a masked ID address, but in reality, it's a looked up delegated address
+        assertEq(subscribers[0].subscriber, 0xFf0000000000000000000000000000000000007C);
         assertEq(
             subscribers[0].subscriptionGroup[0].subscriptionId,
             "41fd3cc8eb07122bf1e5ed85b0b6927fb6f1b3f0d6b1312ba6e19d7de68cf783"
@@ -202,12 +208,13 @@ contract LibBlobTest is Test {
             "45dadd92a2aa7418132687f9a421490bad9c5aad32ea4e97b155e37791f00d50"
         );
 
-        // Two different subscribers
+        // // Two different subscribers
         data =
             hex"a2656630313234a2784034316664336363386562303731323262663165356564383562306236393237666236663162336630643662313331326261366531396437646536386366373833851908eb1a00015a6b982018fd18bb1871185b08188508184418a1183e182b18b518980118cb18a60218bf183b18351118720418fb18f41836188101181b18ef18941839f6f47840343564616464393261326161373431383133323638376639613432313439306261643963356161643332656134653937623135356533373739316630306435308519021f1a0001539f982018fd18bb1871185b08188508184418a1183e182b18b518980118cb18a60218bf183b18351118720418fb18f41836188101181b18ef18941839f6f4656630313236a1784033333566316434636333343130646136363562613133336136616339653666656536626334653861356435643239336262333966396465313266303530326438851909881a00015b08982018fd18bb1871185b08188508184418a1183e182b18b518980118cb18a60218bf183b18351118720418fb18f41836188101181b18ef18941839f6f4";
         subscribers = LibBlob.decodeSubscribers(data);
-        assertEq(subscribers[0].subscriber, "f0124");
-        assertEq(subscribers[1].subscriber, "f0126");
+        // Note: tests will always show this as a masked ID address, but in reality, it's a looked up delegated address
+        assertEq(subscribers[0].subscriber, 0xFf0000000000000000000000000000000000007C);
+        assertEq(subscribers[1].subscriber, 0xFF0000000000000000000000000000000000007e);
     }
 
     function testDecodeSubscriptionGroup() public view {
@@ -242,6 +249,7 @@ contract LibBlobTest is Test {
         assertEq(subscription.added, 2961);
         assertEq(subscription.expiry, 89361);
         assertEq(subscription.source, "7w5xcwyiqueejij6fo2zqaoluybl6ozvcfzaj67ug2aqcg7psq4q");
+        // Note: tests will always show this as a masked ID address, but in reality, it's a looked up delegated address
         assertEq(subscription.delegate, 0xFF0000000000000000000000000000000000007D);
         assertEq(subscription.failed, false);
     }

test/LibWasm.t.sol

@@ -215,6 +215,12 @@ contract LibWasmTest is Test {
         assertEq(result, "t2o4gsdesxam4qui3pnd4e54ouglffoqwecfnrdzq");
     }
 
+    function testDecodeCborActorIdStringToAddress() public view {
+        bytes memory data = bytes("f0152");
+        address result = LibWasm.decodeCborActorIdStringToAddress(data);
+        assertEq(result, 0xff00000000000000000000000000000000000098);
+    }
+
     function testDecodeCborString() public view {
         bytes memory data = hex"65696e6e6572";
         bytes memory result = LibWasm.decodeCborStringToBytes(data);