solidity-scale-codec 0.1.2 → 0.2.0

package/src/Xcm/v5/Response/ResponseCodec.sol

@@ -0,0 +1,174 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Assets} from "../Assets/Assets.sol";
+import {AssetsCodec} from "../Assets/AssetsCodec.sol";
+import {XcmError} from "../XcmError/XcmError.sol";
+import {XcmErrorCodec} from "../XcmError/XcmErrorCodec.sol";
+import {PalletInfo} from "../PalletInfo/PalletInfo.sol";
+import {PalletInfoCodec} from "../PalletInfo/PalletInfoCodec.sol";
+import {MaybeErrorCode} from "../../v3/MaybeErrorCode/MaybeErrorCode.sol";
+import {MaybeErrorCodeCodec} from "../../v3/MaybeErrorCode/MaybeErrorCodeCodec.sol";
+import {Compact} from "../../../Scale/Compact.sol";
+import {LittleEndianU32} from "../../../LittleEndian/LittleEndianU32.sol";
+import {Response, ResponseType} from "./Response.sol";
+
+/// @title SCALE Codec for XCM v5 `Response`
+/// @notice SCALE-compliant encoder/decoder for the `Response` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+/// @dev XCM v5 reference: https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v5/index.html
+library ResponseCodec {
+    error InvalidResponseLength();
+    error InvalidResponseType(uint8 rType);
+
+    /// @notice Encodes a `Response` struct into SCALE bytes.
+    /// @param r The `Response` struct to encode.
+    /// @return SCALE-encoded bytes representing the `Response`.
+    function encode(Response memory r) internal pure returns (bytes memory) {
+        return abi.encodePacked(uint8(r.rType), r.payload);
+    }
+
+    /// @notice Returns the number of bytes that a `Response` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `Response`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size.
+    /// @return The number of bytes occupied by the encoded `Response`.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (data.length < offset + 1) revert InvalidResponseLength();
+        uint8 rType = uint8(data[offset]);
+        uint256 pos = offset + 1;
+
+        if (rType == uint8(ResponseType.Null)) {
+            return 1;
+        } else if (rType == uint8(ResponseType.Assets)) {
+            return 1 + AssetsCodec.encodedSizeAt(data, pos);
+        } else if (rType == uint8(ResponseType.ExecutionResult)) {
+            if (data.length < pos + 1) revert InvalidResponseLength();
+            uint8 isSome = uint8(data[pos]);
+            if (isSome == 0) return 2; // 1 type + 1 None byte
+            return 2 + 4 + XcmErrorCodec.encodedSizeAt(data, pos + 1 + 4);
+        } else if (rType == uint8(ResponseType.Version)) {
+            if (data.length < pos + 4) revert InvalidResponseLength();
+            return 1 + 4; // 1 type + 4 bytes for version
+        } else if (rType == uint8(ResponseType.PalletsInfo)) {
+            (uint256 count, uint256 prefixSize) = Compact.decodeAt(data, pos);
+            uint256 size = prefixSize;
+            uint256 innerPos = pos + prefixSize;
+            for (uint256 i = 0; i < count; ++i) {
+                uint256 palletSize = PalletInfoCodec.encodedSizeAt(
+                    data,
+                    innerPos
+                );
+                size += palletSize;
+                innerPos += palletSize;
+            }
+            return 1 + size;
+        } else if (rType == uint8(ResponseType.DispatchResult)) {
+            return 1 + MaybeErrorCodeCodec.encodedSizeAt(data, pos);
+        } else {
+            revert InvalidResponseType(rType);
+        }
+    }
+
+    /// @notice Decodes a `Response` from SCALE bytes starting at the beginning.
+    /// @param data The byte sequence containing the encoded `Response`.
+    /// @return r The decoded `Response` struct.
+    /// @return bytesRead The number of bytes read.
+    function decode(
+        bytes memory data
+    ) internal pure returns (Response memory r, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes a `Response` from SCALE bytes starting at a given offset.
+    /// @param data The byte sequence containing the encoded `Response`.
+    /// @param offset The starting index in `data` from which to decode.
+    /// @return r The decoded `Response` struct.
+    /// @return bytesRead The number of bytes read.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (Response memory r, uint256 bytesRead) {
+        if (data.length < offset + 1) revert InvalidResponseLength();
+        uint8 rType = uint8(data[offset]);
+        uint256 size = encodedSizeAt(data, offset);
+        uint256 payloadLength = size - 1;
+        bytes memory payload = new bytes(payloadLength);
+        for (uint256 i = 0; i < payloadLength; ++i) {
+            payload[i] = data[offset + 1 + i];
+        }
+        r = Response({rType: ResponseType(rType), payload: payload});
+        bytesRead = size;
+    }
+
+    /// @notice Decodes the `Assets` from an `Assets` response.
+    /// @param r The `Response` struct. Must be of type `Assets`.
+    /// @return The decoded `Assets`.
+    function asAssets(Response memory r) internal pure returns (Assets memory) {
+        if (r.rType != ResponseType.Assets)
+            revert InvalidResponseType(uint8(r.rType));
+        (Assets memory a, ) = AssetsCodec.decode(r.payload);
+        return a;
+    }
+
+    /// @notice Decodes the execution result from an `ExecutionResult` response.
+    /// @param r The `Response` struct. Must be of type `ExecutionResult`.
+    /// @return hasError Whether the execution result contains an error.
+    /// @return index The instruction index that caused the error. Only meaningful if `hasError` is true.
+    /// @return err The XCM error. Only meaningful if `hasError` is true.
+    function asExecutionResult(
+        Response memory r
+    ) internal pure returns (bool hasError, uint32 index, XcmError memory err) {
+        if (r.rType != ResponseType.ExecutionResult)
+            revert InvalidResponseType(uint8(r.rType));
+        if (r.payload.length < 1) revert InvalidResponseLength();
+        hasError = r.payload[0] != 0;
+        if (hasError) {
+            if (r.payload.length < 4) revert InvalidResponseLength();
+            index = LittleEndianU32.fromLittleEndian(r.payload, 1);
+            (err, ) = XcmErrorCodec.decodeAt(r.payload, 1 + 4);
+        }
+    }
+
+    /// @notice Decodes the version from a `Version` response.
+    /// @param r The `Response` struct. Must be of type `Version`.
+    /// @return The decoded version.
+    function asVersion(Response memory r) internal pure returns (uint32) {
+        if (r.rType != ResponseType.Version)
+            revert InvalidResponseType(uint8(r.rType));
+        if (r.payload.length != 4) revert InvalidResponseLength();
+        return LittleEndianU32.fromLittleEndian(r.payload, 0);
+    }
+
+    /// @notice Decodes the pallets info from a `PalletsInfo` response.
+    /// @param r The `Response` struct. Must be of type `PalletsInfo`.
+    /// @return pallets The decoded array of `PalletInfo`.
+    function asPalletsInfo(
+        Response memory r
+    ) internal pure returns (PalletInfo[] memory pallets) {
+        if (r.rType != ResponseType.PalletsInfo)
+            revert InvalidResponseType(uint8(r.rType));
+        (uint256 count, uint256 prefixSize) = Compact.decodeAt(r.payload, 0);
+        pallets = new PalletInfo[](count);
+        uint256 pos = prefixSize;
+        for (uint256 i = 0; i < count; ++i) {
+            uint256 read;
+            (pallets[i], read) = PalletInfoCodec.decodeAt(r.payload, pos);
+            pos += read;
+        }
+    }
+
+    /// @notice Decodes the dispatch result from a `DispatchResult` response.
+    /// @param r The `Response` struct. Must be of type `DispatchResult`.
+    /// @return The decoded `MaybeErrorCode`.
+    function asDispatchResult(
+        Response memory r
+    ) internal pure returns (MaybeErrorCode memory) {
+        if (r.rType != ResponseType.DispatchResult)
+            revert InvalidResponseType(uint8(r.rType));
+        (MaybeErrorCode memory me, ) = MaybeErrorCodeCodec.decode(r.payload);
+        return me;
+    }
+}

package/src/Xcm/v5/Types/QueryId.sol

@@ -0,0 +1,5 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+/// @notice An identifier for a query.
+type QueryId is uint64;

package/src/Xcm/v5/Weight/Weight.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+/// @notice Weight v2 used for measurement for an XCM execution
+struct Weight {
+    /// @custom:property The computational time used to execute some logic based on reference hardware.
+    uint64 refTime;
+    /// @custom:property The size of the proof needed to execute some logic.
+    uint64 proofSize;
+}

package/src/Xcm/v5/Weight/WeightCodec.sol

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Compact} from "../../../Scale/Compact.sol";
+import {Weight} from "./Weight.sol";
+
+/// @title SCALE Codec for XCM v5 `Weight`
+/// @notice SCALE-compliant encoder/decoder for the `Weight` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+/// @dev XCM v5 reference: https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v5/index.html
+library WeightCodec {
+    error InvalidWeightLength();
+
+    /// @notice Encodes a `Weight` struct into bytes.
+    /// @param weight The `Weight` struct to encode.
+    /// @return SCALE-encoded byte sequence representing the `Weight`.
+    function encode(Weight memory weight) internal pure returns (bytes memory) {
+        return
+            abi.encodePacked(
+                Compact.encode(weight.refTime),
+                Compact.encode(weight.proofSize)
+            );
+    }
+
+    /// @notice Returns the number of bytes that a `Weight` struct would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `Weight`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `Weight`.
+    /// @return The number of bytes that the `Weight` struct would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (offset >= data.length) {
+            revert InvalidWeightLength();
+        }
+        uint256 refTimeBytes = Compact.encodedSizeAt(data, offset);
+        offset += refTimeBytes;
+        if (offset >= data.length) {
+            revert InvalidWeightLength();
+        }
+        uint256 proofSizeBytes = Compact.encodedSizeAt(data, offset);
+        return refTimeBytes + proofSizeBytes;
+    }
+
+    /// @notice Decodes a byte sequence into a `Weight` struct.
+    /// @param data The byte sequence to decode, expected to be the SCALE encoding of a `Weight`.
+    /// @return weight The decoded `Weight` struct.
+    /// @return bytesRead The total number of bytes read from the input data to decode the `Weight`.
+    function decode(
+        bytes memory data
+    ) internal pure returns (Weight memory weight, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes a byte sequence into a `Weight` struct starting at a specific offset.
+    /// @param data The byte sequence to decode, expected to be the SCALE encoding of a `Weight`.
+    /// @param offset The byte offset in the data array to start decoding from.
+    /// @return weight The decoded `Weight` struct.
+    /// @return bytesRead The total number of bytes read from the input data to decode the `Weight`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (Weight memory weight, uint256 bytesRead) {
+        if (offset >= data.length) {
+            revert InvalidWeightLength();
+        }
+        (uint256 refTime, uint256 refTimeBytes) = Compact.decodeAt(
+            data,
+            offset
+        );
+        offset += refTimeBytes;
+        (uint256 proofSize, uint256 proofSizeBytes) = Compact.decodeAt(
+            data,
+            offset
+        );
+        if (offset + proofSizeBytes > data.length) {
+            revert InvalidWeightLength();
+        }
+        offset += proofSizeBytes;
+
+        weight = Weight({
+            refTime: uint64(refTime),
+            proofSize: uint64(proofSize)
+        });
+        bytesRead = refTimeBytes + proofSizeBytes;
+    }
+}

package/src/Xcm/v5/WeightLimit/WeightLimit.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Weight} from "../Weight/Weight.sol";
+import {WeightCodec} from "../Weight/WeightCodec.sol";
+
+/// @notice Discriminant for the `WeightLimit` enum.
+enum WeightLimitType {
+    /// @custom:variant No limit on weight.
+    Unlimited,
+    /// @custom:variant A specific weight limit.
+    Limited
+}
+
+/// @notice An optional weight limit.
+struct WeightLimit {
+    /// @custom:property The type of the weight limit. See `WeightLimitType` enum for possible values.
+    WeightLimitType wlType;
+    /// @custom:property The SCALE-encoded `Weight`. Only meaningful when `wlType` is `Limited`.
+    bytes payload;
+}
+
+/// @notice Parameters for the `Limited` variant.
+struct LimitedParams {
+    /// @custom:property Weight limit value.
+    Weight weight;
+}
+
+// ============ Factory Functions ============
+
+/// @notice Creates an `Unlimited` weight limit.
+/// @return A `WeightLimit` struct representing no limit.
+function unlimited() pure returns (WeightLimit memory) {
+    return WeightLimit({wlType: WeightLimitType.Unlimited, payload: ""});
+}
+
+/// @notice Creates a `Limited` weight limit with the given `Weight`.
+/// @param params Parameters for the limited variant.
+/// @return A `WeightLimit` struct representing the given limit.
+function limited(
+    LimitedParams memory params
+) pure returns (WeightLimit memory) {
+    return
+        WeightLimit({
+            wlType: WeightLimitType.Limited,
+            payload: WeightCodec.encode(params.weight)
+        });
+}

package/src/Xcm/v5/WeightLimit/WeightLimitCodec.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Weight} from "../Weight/Weight.sol";
+import {WeightCodec} from "../Weight/WeightCodec.sol";
+import {WeightLimit, WeightLimitType} from "./WeightLimit.sol";
+
+/// @title SCALE Codec for XCM v5 `WeightLimit`
+/// @notice SCALE-compliant encoder/decoder for the `WeightLimit` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+/// @dev XCM v5 reference: https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v5/enum.WeightLimit.html
+library WeightLimitCodec {
+    error InvalidWeightLimitLength();
+    error InvalidWeightLimitType(uint8 wlType);
+
+    /// @notice Encodes a `WeightLimit` struct into SCALE bytes.
+    /// @param wl The `WeightLimit` struct to encode.
+    /// @return SCALE-encoded bytes representing the `WeightLimit`.
+    function encode(
+        WeightLimit memory wl
+    ) internal pure returns (bytes memory) {
+        return abi.encodePacked(uint8(wl.wlType), wl.payload);
+    }
+
+    /// @notice Returns the number of bytes that a `WeightLimit` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `WeightLimit`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size.
+    /// @return The number of bytes occupied by the encoded `WeightLimit`.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (data.length < offset + 1) revert InvalidWeightLimitLength();
+        uint8 wlType = uint8(data[offset]);
+        if (wlType == uint8(WeightLimitType.Unlimited)) {
+            return 1;
+        } else if (wlType == uint8(WeightLimitType.Limited)) {
+            return 1 + WeightCodec.encodedSizeAt(data, offset + 1);
+        } else {
+            revert InvalidWeightLimitType(wlType);
+        }
+    }
+
+    /// @notice Decodes a `WeightLimit` from SCALE bytes starting at the beginning.
+    /// @param data The byte sequence containing the encoded `WeightLimit`.
+    /// @return wl The decoded `WeightLimit` struct.
+    /// @return bytesRead The number of bytes read.
+    function decode(
+        bytes memory data
+    ) internal pure returns (WeightLimit memory wl, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes a `WeightLimit` from SCALE bytes starting at a given offset.
+    /// @param data The byte sequence containing the encoded `WeightLimit`.
+    /// @param offset The starting index in `data` from which to decode.
+    /// @return wl The decoded `WeightLimit` struct.
+    /// @return bytesRead The number of bytes read.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (WeightLimit memory wl, uint256 bytesRead) {
+        if (data.length < offset + 1) revert InvalidWeightLimitLength();
+        uint8 wlType = uint8(data[offset]);
+        if (wlType > uint8(WeightLimitType.Limited))
+            revert InvalidWeightLimitType(wlType);
+        uint256 size = encodedSizeAt(data, offset);
+        uint256 payloadLength = size - 1;
+        bytes memory payload = new bytes(payloadLength);
+        for (uint256 i = 0; i < payloadLength; ++i) {
+            payload[i] = data[offset + 1 + i];
+        }
+        wl = WeightLimit({wlType: WeightLimitType(wlType), payload: payload});
+        bytesRead = size;
+    }
+
+    /// @notice Decodes the `Weight` from a `Limited` weight limit.
+    /// @param wl The `WeightLimit` struct. Must be of type `Limited`.
+    /// @return The decoded `Weight`.
+    function asWeight(
+        WeightLimit memory wl
+    ) internal pure returns (Weight memory) {
+        if (wl.wlType != WeightLimitType.Limited)
+            revert InvalidWeightLimitType(uint8(wl.wlType));
+        (Weight memory w, ) = WeightCodec.decode(wl.payload);
+        return w;
+    }
+}

package/src/Xcm/v5/WildAsset/WildAsset.sol

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Compact} from "../../../Scale/Compact.sol";
+import {AssetId} from "../AssetId/AssetId.sol";
+import {AssetIdCodec} from "../AssetId/AssetIdCodec.sol";
+import {WildFungibility} from "../WildFungibility/WildFungibility.sol";
+import {WildFungibilityCodec} from "../WildFungibility/WildFungibilityCodec.sol";
+
+/// @notice Discriminant for the type of asset being specified in a `WildAsset`.
+enum WildAssetType {
+    /// @custom:variant All assets in Holding.
+    All,
+    /// @custom:variant All assets in Holding of a given fungibility and ID.
+    AllOf,
+    /// @custom:variant All assets in Holding, up to `uint32` individual assets (different instances of non-fungibles are separate assets).
+    AllCounted,
+    /// @custom:variant All assets in Holding of a given fungibility and ID up to `count` individual assets (different instances of non-fungibles are separate assets).
+    AllOfCounted
+}
+
+/// @notice Parameters for the `AllOf` variant of `WildAsset`, specifying a particular asset class and fungibility to match against.
+struct AllOfParams {
+    /// @custom:property The asset class to match against.
+    AssetId id;
+    /// @custom:property The fungibility to match against.
+    WildFungibility fun;
+}
+
+/// @notice Parameters for the `AllOfCounted` variant of `WildAsset`, specifying a limit of assets to match against.
+struct AllOfCountedParams {
+    /// @custom:property The asset class to match against.
+    AssetId id;
+    /// @custom:property The fungibility to match against.
+    WildFungibility fun;
+    /// @custom:property The limit of assets to match against.
+    uint32 count;
+}
+
+/// @notice Parameters for the `AllCounted` variant of `WildAsset`.
+struct AllCountedParams {
+    /// @custom:property The upper bound of matched assets.
+    uint32 count;
+}
+
+/// @notice A wildcard representing a set of assets.
+struct WildAsset {
+    /// @custom:property The type of wild asset, determining how to interpret the payload. See `WildAssetType` enum for possible values.
+    WildAssetType waType;
+    /// @custom:property The encoded payload containing the wild asset data, whose structure depends on the `waType`.
+    bytes payload;
+}
+
+// ============ Factory Functions ============
+
+/// @notice Creates a `WildAsset` struct representing the `All` variant, which matches all assets in Holding.
+/// @return A `WildAsset` with the `All` variant.
+function all() pure returns (WildAsset memory) {
+    return WildAsset({waType: WildAssetType.All, payload: ""});
+}
+
+/// @notice Creates a `WildAsset` struct representing the `AllOf` variant, which matches all assets in Holding of a given fungibility and ID.
+/// @param id The `AssetId` struct specifying the asset class to match against.
+/// @param fun The `WildFungibility` struct specifying the fungibility to match against.
+/// @return A `WildAsset` with the `AllOf` variant and the encoded parameters in the payload.
+function allOf(
+    AssetId memory id,
+    WildFungibility fun
+) pure returns (WildAsset memory) {
+    return
+        WildAsset({
+            waType: WildAssetType.AllOf,
+            payload: abi.encodePacked(
+                AssetIdCodec.encode(id),
+                WildFungibilityCodec.encode(fun)
+            )
+        });
+}
+
+/// @notice Creates a `WildAsset` struct representing the `AllCounted` variant, which matches all assets in Holding, up to `uint32` individual assets (different instances of non-fungibles are separate assets).
+/// @param params Parameters for the all-counted variant.
+/// @return A `WildAsset` with the `AllOfCounted` variant and the encoded parameters in the payload.
+function allCounted(
+    AllCountedParams memory params
+) pure returns (WildAsset memory) {
+    return
+        WildAsset({
+            waType: WildAssetType.AllCounted,
+            payload: abi.encodePacked(Compact.encode(params.count))
+        });
+}
+
+/// @notice Creates a `WildAsset` struct representing the `AllOfCounted` variant, which matches all assets in Holding of a given fungibility and ID up to `count` individual assets (different instances of non-fungibles are separate assets).
+/// @param id The `AssetId` struct specifying the asset class to match against.
+/// @param fun The `WildFungibility` struct specifying the fungibility to match against.
+/// @param count The limit of assets  against.
+/// @return A `WildAsset` with the `AllOfCounted` variant and the encoded parameters in the payload.
+function allOfCounted(
+    AssetId memory id,
+    WildFungibility fun,
+    uint32 count
+) pure returns (WildAsset memory) {
+    return
+        WildAsset({
+            waType: WildAssetType.AllOfCounted,
+            payload: abi.encodePacked(
+                AssetIdCodec.encode(id),
+                WildFungibilityCodec.encode(fun),
+                Compact.encode(count)
+            )
+        });
+}