feat: decode pending blobs

Author: dtbuchholz

foundry.toml

@@ -8,6 +8,7 @@ extra_output = ["storageLayout"]
 gas_reports = ["Hoku"]
 ffi = true
 ast = true
+via_ir = true
 
 [fmt]
 # These are all the `forge fmt` defaults

src/BlobManager.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.26;
 
 import {IBlobManager} from "./interfaces/IBlobManager.sol";
-import {AddBlobParams, Blob, BlobStatus, StorageStats, SubnetStats} from "./types/BlobTypes.sol";
+import {AddBlobParams, Blob, BlobStatus, BlobTuple, StorageStats, SubnetStats} from "./types/BlobTypes.sol";
 import {LibBlob} from "./util/LibBlob.sol";
 
 contract BlobManager is IBlobManager {
@@ -21,7 +21,7 @@ contract BlobManager is IBlobManager {
     }
 
     /// @dev See {ICredit-getPendingBlobs}.
-    function getPendingBlobs(uint32 size) external view returns (bytes memory) {
+    function getPendingBlobs(uint32 size) external view returns (BlobTuple[] memory blobs) {
         return LibBlob.getPendingBlobs(size);
     }
 

src/interfaces/IBlobManager.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: MIT OR Apache-2.0
 pragma solidity ^0.8.26;
 
-import {AddBlobParams, Blob, BlobStatus, StorageStats, SubnetStats} from "../types/BlobTypes.sol";
+import {AddBlobParams, Blob, BlobStatus, BlobTuple, StorageStats, SubnetStats} from "../types/BlobTypes.sol";
 
 /// @dev Hoku Blobs actor EVM interface for managing and querying information about blogs/storage.
 /// See Rust implementation for details:
@@ -30,8 +30,8 @@ interface IBlobManager {
 
     /// @dev Get a list of pending blobs.
     /// @param size Maximum number of pending blobs to return.
-    /// @return List of pending blobs encoded as bytes.
-    function getPendingBlobs(uint32 size) external view returns (bytes memory);
+    /// @return blobs List of pending blobs.
+    function getPendingBlobs(uint32 size) external view returns (BlobTuple[] memory blobs);
 
     /// @dev Get the total count of pending blobs.
     /// @return Total number of pending blobs.

src/types/BlobTypes.sol

@@ -138,7 +138,6 @@ struct AddBlobParams {
 struct Blob {
     uint64 size;
     string metadataHash;
-    // TODO: decode the following from Rust type: HashMap<Address, SubscriptionGroup>
     Subscriber[] subscribers;
     BlobStatus status;
 }
@@ -171,7 +170,7 @@ struct SubscriptionGroup {
     // of the encoding/decoding logic works...except you might see odd decoding with a bucket-backed blob, like a
     // subscription ID of `��0������䣱p�V�%���?��:\u{8}4T�~��V`.
     string subscriptionId;
-    bytes subscription; // TODO: update type
+    Subscription subscription;
 }
 
 /// @dev A subscription to a blob.
@@ -200,9 +199,19 @@ struct Delegate {
 }
 
 /// @dev Pending blob information. Represents a Rust `(Hash, HashSet<(Address, SubscriptionId, PublicKey)>)`
-/// @param blobHash (bytes): The blob hash.
-/// @param sourceInfo (Subscription[]): The pending subscriptions.
-struct PendingBlob {
-    bytes blobHash;
-    bytes sourceInfo;
+/// @param blobHash (string): The blob hash.
+/// @param sourceInfo (BlobSourceInfo[]): The source information for the blob.
+struct BlobTuple {
+    string blobHash;
+    BlobSourceInfo sourceInfo;
+}
+
+/// @dev Source information for a blob.
+/// @param subscriber (address): The subscriber address.
+/// @param subscriptionId (string): The subscription ID.
+/// @param source (string): The source Iroh node ID used for ingestion.
+struct BlobSourceInfo {
+    address subscriber;
+    string subscriptionId;
+    string source;
 }

src/util/LibBlob.sol

@@ -8,12 +8,16 @@ import {
     Approvals,
     Balance,
     Blob,
+    BlobSourceInfo,
     BlobStatus,
+    BlobTuple,
     CreditApproval,
     CreditStats,
+    Delegate,
     StorageStats,
     SubnetStats,
     Subscriber,
+    Subscription,
     SubscriptionGroup
 } from "../types/BlobTypes.sol";
 import {KeyValue} from "../types/CommonTypes.sol";
@@ -122,16 +126,55 @@ library LibBlob {
     /// @param data The encoded subscription ID.
     /// @return decoded The decoded subscription ID.
     function decodeSubscriptionId(bytes memory data) internal view returns (string memory) {
-        // If the leading indicator is `a1`, it's a mapping with a single key-value pair; else, default
-        if (data[0] == hex"a1") {
-            // Decode the mapping with Key and subscription ID bytes (a single key-value pair)
-            bytes[2][] memory decoded = data.decodeCborMappingToBytes();
-            // Second value is the subscription ID bytes (ignore the first value `Key` key)
-            bytes memory subscriptionId = decoded[0][1].decodeCborBytesArrayToBytes();
-            return string(subscriptionId);
-        } else {
+        // If not a mapping with key-value pair, return default
+        if (data[0] != hex"a1") {
             return "Default";
         }
+
+        // Decode the mapping and return subscription ID bytes
+        bytes[2][] memory decoded = data.decodeCborMappingToBytes();
+        return string(decoded[0][1].decodeCborBytesArrayToBytes());
+    }
+
+    /// @dev Decode a delegate from CBOR.
+    /// @param data The encoded CBOR array of a delegate.
+    /// @return origin The delegate origin address
+    /// @return caller The delegate caller address
+    function decodeDelegate(bytes memory data) internal view returns (address origin, address caller) {
+        if (data[0] == hex"00" || data[0] == hex"f6") {
+            return (address(0), address(0));
+        }
+        bytes[] memory decoded = data.decodeCborArrayToBytes();
+        origin = decoded[0].decodeCborAddress();
+        caller = decoded[1].decodeCborAddress();
+    }
+
+    /// @dev Decode a subscription from CBOR.
+    /// @param data The encoded CBOR array of a subscription.
+    /// @return subscription The decoded subscription.
+    function decodeSubscription(bytes memory data) internal view returns (Subscription memory subscription) {
+        bytes[] memory decoded = data.decodeCborArrayToBytes();
+        subscription.added = decoded[0].decodeCborBytesToUint64();
+        subscription.expiry = decoded[1].decodeCborBytesToUint64();
+        subscription.autoRenew = decoded[2].decodeCborBool();
+        subscription.source = string(decoded[3].decodeCborBlobHashOrNodeId());
+        (subscription.delegate.origin, subscription.delegate.caller) = decodeDelegate(decoded[4]);
+        subscription.failed = decoded[5].decodeCborBool();
+    }
+
+    /// @dev Decode a subscription group from CBOR.
+    /// @param subscriptionGroupBytes The encoded subscription group bytes
+    /// @return group The decoded subscription group
+    function decodeSubscriptionGroup(bytes[2][] memory subscriptionGroupBytes)
+        internal
+        view
+        returns (SubscriptionGroup[] memory group)
+    {
+        group = new SubscriptionGroup[](subscriptionGroupBytes.length);
+        for (uint256 j = 0; j < subscriptionGroupBytes.length; j++) {
+            group[j].subscriptionId = decodeSubscriptionId(subscriptionGroupBytes[j][0]);
+            group[j].subscription = decodeSubscription(subscriptionGroupBytes[j][1]);
+        }
     }
 
     /// @dev Decode subscribers from CBOR.
@@ -142,12 +185,7 @@ library LibBlob {
         subscribers = new Subscriber[](decoded.length);
         for (uint256 i = 0; i < decoded.length; i++) {
             subscribers[i].subscriber = decoded[i][0].decodeCborAddress();
-            bytes[2][] memory subscriptionGroupBytes = decoded[i][1].decodeCborMappingToBytes();
-            subscribers[i].subscriptionGroup = new SubscriptionGroup[](subscriptionGroupBytes.length);
-            for (uint256 j = 0; j < subscriptionGroupBytes.length; j++) {
-                subscribers[i].subscriptionGroup[j].subscriptionId = decodeSubscriptionId(subscriptionGroupBytes[j][0]);
-                subscribers[i].subscriptionGroup[j].subscription = subscriptionGroupBytes[j][1];
-            }
+            subscribers[i].subscriptionGroup = decodeSubscriptionGroup(decoded[i][1].decodeCborMappingToBytes());
         }
     }
 
@@ -157,12 +195,38 @@ library LibBlob {
     function decodeBlob(bytes memory data) internal view returns (Blob memory blob) {
         bytes[] memory decoded = data.decodeCborArrayToBytes();
         if (decoded.length == 0) return blob;
+
         blob.size = decoded[0].decodeCborBytesToUint64();
-        blob.metadataHash = string(decoded[1].decodeBlobHash());
+        blob.metadataHash = string(decoded[1].decodeCborBlobHashOrNodeId());
         blob.subscribers = decodeSubscribers(decoded[2]);
         blob.status = decodeBlobStatus(decoded[3]);
     }
 
+    /// @dev Decode a blob source info from CBOR.
+    /// @param data The encoded CBOR array of a blob source info.
+    /// @return sourceInfo The decoded blob source info.
+    function decodeBlobSourceInfo(bytes memory data) internal view returns (BlobSourceInfo memory sourceInfo) {
+        bytes[] memory decodedOuter = data.decodeCborArrayToBytes();
+        bytes[] memory decodedInner = decodedOuter[0].decodeCborArrayToBytes();
+        sourceInfo.subscriber = decodedInner[0].decodeCborAddress();
+        sourceInfo.subscriptionId = decodeSubscriptionId(decodedInner[1]);
+        sourceInfo.source = string(decodedInner[2].decodeCborBlobHashOrNodeId());
+    }
+
+    /// @dev Decode pending blobs from CBOR.
+    /// @param data The encoded CBOR array of pending blobs.
+    /// @return blobs The decoded pending blobs.
+    function decodePendingBlobs(bytes memory data) internal view returns (BlobTuple[] memory blobs) {
+        bytes[] memory decoded = data.decodeCborArrayToBytes();
+        if (decoded.length == 0) return blobs;
+        blobs = new BlobTuple[](decoded.length);
+        for (uint256 i = 0; i < decoded.length; i++) {
+            bytes[] memory blobTuple = decoded[i].decodeCborArrayToBytes();
+            blobs[i].blobHash = string(blobTuple[0].decodeCborBlobHashOrNodeId());
+            blobs[i].sourceInfo = decodeBlobSourceInfo(blobTuple[1]);
+        }
+    }
+
     /// @dev Helper function to encode approve credit params.
     /// @param from (address): Account address that is approving the credit.
     /// @param receiver (address): Account address that is receiving the approval.
@@ -328,12 +392,20 @@ library LibBlob {
         return accountToBalance(account);
     }
 
+    /// @dev Get a blob.
+    /// @param blobHash The hash of the blob.
+    /// @return blob The blob.
     function getBlob(string memory blobHash) external view returns (Blob memory blob) {
         bytes memory params = blobHash.encodeCborBlobHashOrNodeId();
         bytes memory data = LibWasm.readFromWasmActor(ACTOR_ID, METHOD_GET_BLOB, params);
         return decodeBlob(data);
     }
 
+    /// @dev Get the status of a blob.
+    /// @param subscriber The address of the subscriber.
+    /// @param blobHash The hash of the blob.
+    /// @param subscriptionId The subscription ID.
+    /// @return status The status of the blob.
     function getBlobStatus(address subscriber, string memory blobHash, string memory subscriptionId)
         external
         view
@@ -348,16 +420,24 @@ library LibBlob {
         return decodeBlobStatus(data);
     }
 
-    function getPendingBlobs(uint32 size) external view returns (bytes memory) {
+    /// @dev Get pending blobs.
+    /// @param size The size of the blobs to get.
+    /// @return blobs The pending blobs.
+    function getPendingBlobs(uint32 size) external view returns (BlobTuple[] memory blobs) {
         bytes memory params = size.encodeCborUint64();
-        return LibWasm.readFromWasmActor(ACTOR_ID, METHOD_GET_PENDING_BLOBS, params);
+        bytes memory data = LibWasm.readFromWasmActor(ACTOR_ID, METHOD_GET_PENDING_BLOBS, params);
+        return decodePendingBlobs(data);
     }
 
+    /// @dev Get the number of pending blobs.
+    /// @return count The number of pending blobs.
     function getPendingBlobsCount() external view returns (uint64) {
         bytes memory data = LibWasm.readFromWasmActor(ACTOR_ID, METHOD_GET_PENDING_BLOBS_COUNT);
         return data.decodeCborBytesToUint64();
     }
 
+    /// @dev Get the number of pending bytes.
+    /// @return count The number of pending bytes.
     function getPendingBytesCount() external view returns (uint64) {
         bytes memory data = LibWasm.readFromWasmActor(ACTOR_ID, METHOD_GET_PENDING_BYTES_COUNT);
         return data.decodeCborBytesToUint64();

src/util/LibBucket.sol

@@ -103,8 +103,8 @@ library LibBucket {
         bytes[] memory decoded = data.decodeCborArrayToBytes();
         if (decoded.length == 0) return value;
         value = Value({
-            blobHash: string(decoded[0].decodeBlobHash()),
-            recoveryHash: string(decoded[1].decodeBlobHash()),
+            blobHash: string(decoded[0].decodeCborBlobHashOrNodeId()),
+            recoveryHash: string(decoded[1].decodeCborBlobHashOrNodeId()),
             size: decoded[2].decodeCborBytesToUint64(),
             expiry: decoded[3].decodeCborBytesToUint64(),
             metadata: decodeMetadata(decoded[4])

src/util/LibWasm.sol

@@ -113,6 +113,15 @@ library LibWasm {
         return ByteParser.bytesToBigNumber(data);
     }
 
+    /// @dev Decode CBOR encoded boolean.
+    /// @param data The encoded CBOR boolean.
+    /// @return result The decoded boolean.
+    function decodeCborBool(bytes memory data) internal pure returns (bool) {
+        // In CBOR, `0xf5` is true, `0xf4` is false; in practice, it may decode to `0x01` for true and `0x00` for false
+        // This happens when `decodeCborArrayToBytes` is used to unpack a boolean value, so we need to handle both.
+        return data[0] == 0x01 || data[0] == 0xf5;
+    }
+
     /// @dev Decode CBOR encoded Filecoin address bytes to an Ethereum address.
     /// @param addr The encoded CBOR Filecoin address. Example: 0x040a15d34aaf54267db7d7c367839aaf71a00a2c6a65
     /// @return result The decoded Ethereum address. Example: 0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65
@@ -266,7 +275,7 @@ library LibWasm {
     /// @dev Decode a CBOR encoded blob hash to a string (a Rust Iroh hash value `Hash(pub [u8; 32])`).
     /// @param value The encoded CBOR blob hash (e.g,. `0x9820188e184c...`)
     /// @return result The decoded blob hash as base32 encoded bytes.
-    function decodeBlobHash(bytes memory value) internal pure returns (bytes memory) {
+    function decodeCborBlobHashOrNodeId(bytes memory value) internal pure returns (bytes memory) {
         bytes memory decoded = decodeCborFixedArrayToBytes(value);
         return Base32.encode(decoded);
     }