solidity-scale-codec 0.1.2 → 0.2.0

package/src/Xcm/v3/MaybeErrorCode/MaybeErrorCodeCodec.sol

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {U8Arr} from "../../../Scale/Array.sol";
+import {MaybeErrorCode, MaybeErrorCodeType} from "./MaybeErrorCode.sol";
+
+/// @title SCALE Codec for XCM v3 `MaybeErrorCode`
+/// @notice SCALE-compliant encoder/decoder for the `MaybeErrorCode` type.
+/// @dev SCALE reference: https://docs.polkadot.com/polkadot-protocol/basics/data-encoding
+/// @dev XCM v3 reference: https://paritytech.github.io/polkadot-sdk/master/staging_xcm/v3/index.html
+library MaybeErrorCodeCodec {
+    error InvalidMaybeErrorCodeLength();
+    error InvalidMaybeErrorCodeType(uint8 meType);
+
+    /// @notice Encodes a `MaybeErrorCode` struct into SCALE bytes.
+    /// @param me The `MaybeErrorCode` struct to encode.
+    /// @return SCALE-encoded bytes representing the `MaybeErrorCode`.
+    function encode(
+        MaybeErrorCode memory me
+    ) internal pure returns (bytes memory) {
+        return abi.encodePacked(uint8(me.meType), me.payload);
+    }
+
+    /// @notice Returns the number of bytes that a `MaybeErrorCode` would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `MaybeErrorCode`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size.
+    /// @return The number of bytes occupied by the encoded `MaybeErrorCode`.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (data.length < offset + 1) revert InvalidMaybeErrorCodeLength();
+        uint8 meType = uint8(data[offset]);
+        if (meType == uint8(MaybeErrorCodeType.Success)) {
+            return 1;
+        } else if (
+            meType == uint8(MaybeErrorCodeType.Error) ||
+            meType == uint8(MaybeErrorCodeType.TruncatedError)
+        ) {
+            return 1 + U8Arr.encodedSizeAt(data, offset + 1);
+        } else {
+            revert InvalidMaybeErrorCodeType(meType);
+        }
+    }
+
+    /// @notice Decodes a `MaybeErrorCode` from SCALE bytes starting at the beginning.
+    /// @param data The byte sequence containing the encoded `MaybeErrorCode`.
+    /// @return me The decoded `MaybeErrorCode` struct.
+    /// @return bytesRead The number of bytes read.
+    function decode(
+        bytes memory data
+    ) internal pure returns (MaybeErrorCode memory me, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes a `MaybeErrorCode` from SCALE bytes starting at a given offset.
+    /// @param data The byte sequence containing the encoded `MaybeErrorCode`.
+    /// @param offset The starting index in `data` from which to decode.
+    /// @return me The decoded `MaybeErrorCode` struct.
+    /// @return bytesRead The number of bytes read.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (MaybeErrorCode memory me, uint256 bytesRead) {
+        if (data.length < offset + 1) revert InvalidMaybeErrorCodeLength();
+        uint8 meType = uint8(data[offset]);
+        if (meType > uint8(MaybeErrorCodeType.TruncatedError))
+            revert InvalidMaybeErrorCodeType(meType);
+        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];
+        }
+        me = MaybeErrorCode({
+            meType: MaybeErrorCodeType(meType),
+            payload: payload
+        });
+        bytesRead = size;
+    }
+
+    /// @notice Decodes the dispatch error bytes from an `Error` or `TruncatedError` MaybeErrorCode.
+    /// @param me The `MaybeErrorCode` struct to decode. Must be of type `Error` or `TruncatedError`.
+    /// @return errorBytes The decoded dispatch error bytes.
+    function decodeError(
+        MaybeErrorCode memory me
+    ) internal pure returns (uint8[] memory errorBytes) {
+        if (
+            me.meType != MaybeErrorCodeType.Error &&
+            me.meType != MaybeErrorCodeType.TruncatedError
+        ) revert InvalidMaybeErrorCodeType(uint8(me.meType));
+        (errorBytes, ) = U8Arr.decode(me.payload);
+    }
+}

package/src/Xcm/v5/Asset/Asset.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {AssetId} from "../AssetId/AssetId.sol";
+import {Fungibility} from "../Fungibility/Fungibility.sol";
+
+/// @notice Either an amount of a single fungible asset, or a single well-identified non-fungible asset.
+struct Asset {
+    /// @custom:property The overall asset identity (aka class, in the case of a non-fungible).
+    AssetId id;
+    /// @custom:property The fungibility of the asset, which contains either the amount (in the case of a fungible asset) or the instance ID, the secondary asset identifier.
+    Fungibility fungibility;
+}

package/src/Xcm/v5/Asset/AssetCodec.sol

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {AssetId} from "../AssetId/AssetId.sol";
+import {AssetIdCodec} from "../AssetId/AssetIdCodec.sol";
+import {Fungibility} from "../Fungibility/Fungibility.sol";
+import {FungibilityCodec} from "../Fungibility/FungibilityCodec.sol";
+import {Asset} from "./Asset.sol";
+
+/// @title SCALE Codec for XCM v5 `Asset`
+/// @notice SCALE-compliant encoder/decoder for the `Asset` 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 AssetCodec {
+    /// @notice Encodes an `Asset` struct into bytes.
+    /// @param asset The `Asset` struct to encode.
+    /// @return SCALE-encoded byte sequence representing the `Asset`.
+    function encode(Asset memory asset) internal pure returns (bytes memory) {
+        bytes memory encodedId = AssetIdCodec.encode(asset.id);
+        bytes memory encodedFungibility = FungibilityCodec.encode(
+            asset.fungibility
+        );
+        return abi.encodePacked(encodedId, encodedFungibility);
+    }
+
+    /// @notice Returns the number of bytes that an `Asset` struct would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `Asset`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `Asset`.
+    /// @return The number of bytes that the `Asset` struct would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        uint256 idSize = AssetIdCodec.encodedSizeAt(data, offset);
+        uint256 fungibilitySize = FungibilityCodec.encodedSizeAt(
+            data,
+            offset + idSize
+        );
+        return idSize + fungibilitySize;
+    }
+
+    /// @notice Decodes an `Asset` struct from bytes starting at the beginning of the data.
+    /// @param data The byte sequence containing the encoded `Asset`.
+    /// @return asset The decoded `Asset` struct.
+    /// @return bytesRead The total number of bytes read from `data` to decode the `Asset`.
+    function decode(
+        bytes memory data
+    ) internal pure returns (Asset memory asset, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `Asset` struct from bytes starting at a given offset.
+    /// @param data The byte sequence containing the encoded `Asset`.
+    /// @param offset The starting index in `data` from which to decode the `Asset`.
+    /// @return asset The decoded `Asset` struct.
+    /// @return bytesRead The total number of bytes read from `data` to decode the `Asset`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (Asset memory asset, uint256 bytesRead) {
+        (AssetId memory id, uint256 idBytesRead) = AssetIdCodec.decodeAt(
+            data,
+            offset
+        );
+        (
+            Fungibility memory fungibility,
+            uint256 fungibilityBytesRead
+        ) = FungibilityCodec.decodeAt(data, offset + idBytesRead);
+        asset = Asset({id: id, fungibility: fungibility});
+        bytesRead = idBytesRead + fungibilityBytesRead;
+    }
+}

package/src/Xcm/v5/AssetFilter/AssetFilter.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Assets} from "../Assets/Assets.sol";
+import {AssetsCodec} from "../Assets/AssetsCodec.sol";
+import {WildAsset} from "../WildAsset/WildAsset.sol";
+import {WildAssetCodec} from "../WildAsset/WildAssetCodec.sol";
+
+/// @notice Discriminant for the type of asset filter being specified in an `AssetFilter`.
+enum AssetFilterType {
+    /// @custom:variant Specify the filter as being everything contained by the given `Assets` inner.
+    Definite,
+    /// @custom:variant Specify the filter as the given `WildAsset` wildcard.
+    Wild
+}
+
+/// @notice `Asset` collection, defined either by a number of `Assets` or a single wildcard.
+struct AssetFilter {
+    /// @custom:property The type of asset filter, determining how to interpret the payload. See `AssetFilterType` enum for possible values.
+    AssetFilterType afType;
+    /// @custom:property The encoded payload containing the asset filter data, whose structure depends on the `afType`.
+    bytes payload;
+}
+
+/// @notice Parameters for the `Definite` variant.
+struct DefiniteParams {
+    /// @custom:property The concrete assets used by the filter.
+    Assets assets;
+}
+
+/// @notice Parameters for the `Wild` variant.
+struct WildParams {
+    /// @custom:property The wildcard asset selector.
+    WildAsset wA;
+}
+
+// ============ Factory Functions ============
+
+/// @notice Creates an `AssetFilter` struct representing the `Definite` variant, which matches all assets contained by the given `Assets` inner.
+/// @param params Parameters for the definite variant.
+/// @return An `AssetFilter` with the `Assets` variant and the given `Assets` inner as its payload.
+function definite(
+    DefiniteParams memory params
+) pure returns (AssetFilter memory) {
+    return
+        AssetFilter({
+            afType: AssetFilterType.Definite,
+            payload: AssetsCodec.encode(params.assets)
+        });
+}
+
+/// @notice Creates an `AssetFilter` struct representing the `Wild` variant, which matches all assets contained by the given `WildAsset` wildcard.
+/// @param params Parameters for the wild variant.
+/// @return An `AssetFilter` with the `Wild` variant and the given `WildAsset` wildcard as its payload.
+function wild(WildParams memory params) pure returns (AssetFilter memory) {
+    return
+        AssetFilter({
+            afType: AssetFilterType.Wild,
+            payload: WildAssetCodec.encode(params.wA)
+        });
+}

package/src/Xcm/v5/AssetFilter/AssetFilterCodec.sol

@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Assets} from "../Assets/Assets.sol";
+import {AssetsCodec} from "../Assets/AssetsCodec.sol";
+import {WildAsset} from "../WildAsset/WildAsset.sol";
+import {WildAssetCodec} from "../WildAsset/WildAssetCodec.sol";
+import {AssetFilter, AssetFilterType} from "./AssetFilter.sol";
+
+/// @title SCALE Codec for XCM v5 `AssetFilter`
+/// @notice SCALE-compliant encoder/decoder for the `AssetFilter` 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 AssetFilterCodec {
+    error InvalidAssetFilterLength();
+    error InvalidAssetFilterType(uint8 afType);
+    error InvalidAssetFilterPayload();
+
+    /// @notice Encodes an `AssetFilter` struct into a SCALE-compliant byte array.
+    /// @param assetFilter The `AssetFilter` struct to encode.
+    /// @return A byte array containing the SCALE-encoded representation of the `AssetFilter`.
+    function encode(
+        AssetFilter memory assetFilter
+    ) internal pure returns (bytes memory) {
+        return abi.encodePacked(uint8(assetFilter.afType), assetFilter.payload);
+    }
+
+    /// @notice Returns the number of bytes that a `AssetFilter` struct would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `AssetFilter`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `AssetFilter`.
+    /// @return The number of bytes that the `AssetFilter` struct would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        if (data.length < offset + 1) {
+            revert InvalidAssetFilterLength();
+        }
+        uint8 afType = uint8(data[offset]);
+        if (afType == uint8(AssetFilterType.Definite)) {
+            return 1 + AssetsCodec.encodedSizeAt(data, offset + 1);
+        } else if (afType == uint8(AssetFilterType.Wild)) {
+            return 1 + WildAssetCodec.encodedSizeAt(data, offset + 1);
+        } else {
+            revert InvalidAssetFilterType(afType);
+        }
+    }
+
+    /// @notice Decodes an `AssetFilter` struct from a SCALE-encoded byte array starting at the beginning of the data.
+    /// @param data The byte sequence containing the encoded `AssetFilter`.
+    /// @return assetFilter The decoded `AssetFilter` struct.
+    function decode(
+        bytes memory data
+    ) internal pure returns (AssetFilter memory) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `AssetFilter` struct from a SCALE-encoded byte array starting at a given offset.
+    /// @param data The byte sequence containing the encoded `AssetFilter`.
+    /// @param offset The starting index in `data` from which to decode the `AssetFilter`.
+    /// @return assetFilter The decoded `AssetFilter` struct.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (AssetFilter memory assetFilter) {
+        if (data.length < offset + 1) {
+            revert InvalidAssetFilterLength();
+        }
+        uint8 afType = uint8(data[offset]);
+        uint256 payloadLength = encodedSizeAt(data, offset) - 1; // Subtract 1 byte for the afType
+        if (data.length < offset + 1 + payloadLength) {
+            revert InvalidAssetFilterLength();
+        }
+        bytes memory payload = new bytes(payloadLength);
+        for (uint256 i = 0; i < payloadLength; i++) {
+            payload[i] = data[offset + 1 + i];
+        }
+        assetFilter.afType = AssetFilterType(afType);
+        assetFilter.payload = payload;
+    }
+
+    /// @notice Extracs the inner `Assets` collection. Reverts if the `AssetFilter` is not of the `Definite` variant.
+    /// @param assetFilter The `AssetFilter` struct to decode, which must have the `Definite` variant.
+    /// @return assets The `Assets` collection contained within the `AssetFilter` if it is of the `Definite` variant.
+    function asDefinite(
+        AssetFilter memory assetFilter
+    ) internal pure returns (Assets memory assets) {
+        if (assetFilter.afType != AssetFilterType.Definite) {
+            revert InvalidAssetFilterPayload();
+        }
+        (assets, ) = AssetsCodec.decode(assetFilter.payload);
+    }
+
+    /// @notice Extracts the inner `WildAsset` wildcard. Reverts if the `AssetFilter` is not of the `Wild` variant.
+    /// @param assetFilter The `AssetFilter` struct to decode, which must have the `Wild` variant.
+    /// @return wA The `WildAsset` wildcard contained within the `AssetFilter` if it is of the `Wild` variant.
+    function asWild(
+        AssetFilter memory assetFilter
+    ) internal pure returns (WildAsset memory wA) {
+        if (assetFilter.afType != AssetFilterType.Wild) {
+            revert InvalidAssetFilterPayload();
+        }
+        (wA, ) = WildAssetCodec.decode(assetFilter.payload);
+    }
+}

package/src/Xcm/v5/AssetId/AssetId.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Location} from "../Location/Location.sol";
+
+/// @notice Location to identify an asset.
+struct AssetId {
+    /// @custom:property The location of the asset.
+    Location location;
+}

package/src/Xcm/v5/AssetId/AssetIdCodec.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Location} from "../Location/Location.sol";
+import {LocationCodec} from "../Location/LocationCodec.sol";
+import {AssetId} from "./AssetId.sol";
+
+/// @title SCALE Codec for XCM v5 `AssetId`
+/// @notice SCALE-compliant encoder/decoder for the `AssetId` 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 AssetIdCodec {
+    /// @notice Encodes an `AssetId` struct into bytes.
+    /// @param assetId The `AssetId` struct to encode.
+    /// @return SCALE-encoded byte sequence representing the `AssetId`.
+    function encode(
+        AssetId memory assetId
+    ) internal pure returns (bytes memory) {
+        return LocationCodec.encode(assetId.location);
+    }
+
+    /// @notice Returns the number of bytes that an `AssetId` struct would occupy when SCALE-encoded.
+    /// @param data The byte sequence containing the encoded `AssetId`.
+    /// @param offset The starting index in `data` from which to calculate the encoded size of the `AssetId`.
+    /// @return The number of bytes that the `AssetId` struct would occupy when SCALE-encoded.
+    function encodedSizeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (uint256) {
+        return LocationCodec.encodedSizeAt(data, offset);
+    }
+
+    /// @notice Decodes an `AssetId` struct from bytes starting at the beginning of the data.
+    /// @param data The byte sequence containing the encoded `AssetId`.
+    /// @return assetId The decoded `AssetId` struct.
+    /// @return bytesRead The total number of bytes read from `data` to decode the `AssetId`.
+    function decode(
+        bytes memory data
+    ) internal pure returns (AssetId memory assetId, uint256 bytesRead) {
+        return decodeAt(data, 0);
+    }
+
+    /// @notice Decodes an `AssetId` struct from bytes starting at a given offset.
+    /// @param data The byte sequence containing the encoded `AssetId`.
+    /// @param offset The starting index in `data` from which to decode the `AssetId`.
+    /// @return assetId The decoded `AssetId` struct.
+    /// @return bytesRead The total number of bytes read from `data` to decode the `AssetId`.
+    function decodeAt(
+        bytes memory data,
+        uint256 offset
+    ) internal pure returns (AssetId memory assetId, uint256 bytesRead) {
+        (Location memory location, uint256 locationBytesRead) = LocationCodec
+            .decodeAt(data, offset);
+        assetId = AssetId({location: location});
+        bytesRead = locationBytesRead;
+    }
+}

package/src/Xcm/v5/AssetInstance/AssetInstance.sol

@@ -0,0 +1,139 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.28;
+
+import {Compact} from "../../../Scale/Compact.sol";
+import {Bytes4} from "../../../Scale/Bytes/Bytes4.sol";
+import {Bytes8} from "../../../Scale/Bytes/Bytes8.sol";
+import {Bytes16} from "../../../Scale/Bytes/Bytes16.sol";
+import {Bytes32} from "../../../Scale/Bytes/Bytes32.sol";
+
+using Bytes4 for bytes4;
+using Bytes8 for bytes8;
+using Bytes16 for bytes16;
+using Bytes32 for bytes32;
+
+/// @dev Discriminant for the different types of AssetInstances in XCM v5.
+enum AssetInstanceType {
+    /// @custom:variant Used if the non-fungible asset class has only one instance.
+    Undefined,
+    /// @custom:variant A compact index up to 2^128 - 1.
+    Index,
+    /// @custom:variant A 4-byte fixed-length datum.
+    Array4,
+    /// @custom:variant An 8-byte fixed-length datum.
+    Array8,
+    /// @custom:variant A 16-byte fixed-length datum.
+    Array16,
+    /// @custom:variant A 32-byte fixed-length datum.
+    Array32
+}
+
+/// @notice A general identifier for an instance of a non-fungible asset class.
+struct AssetInstance {
+    /// @custom:property The type of asset instance, determining how to interpret the payload. See `AssetInstanceType` enum for possible values.
+    AssetInstanceType iType;
+    /// @custom:property The encoded payload containing the asset instance data, whose structure depends on the `iType`.
+    bytes payload;
+}
+
+/// @notice Parameters for the `Index` variant.
+struct IndexParams {
+    /// @custom:property The compact index value.
+    uint128 idx;
+}
+
+/// @notice Parameters for the `Array4` variant.
+struct Array4Params {
+    /// @custom:property The 4-byte fixed data.
+    bytes4 data;
+}
+
+/// @notice Parameters for the `Array8` variant.
+struct Array8Params {
+    /// @custom:property The 8-byte fixed data.
+    bytes8 data;
+}
+
+/// @notice Parameters for the `Array16` variant.
+struct Array16Params {
+    /// @custom:property The 16-byte fixed data.
+    bytes16 data;
+}
+
+/// @notice Parameters for the `Array32` variant.
+struct Array32Params {
+    /// @custom:property The 32-byte fixed data.
+    bytes32 data;
+}
+
+// ============ Factory Functions ============
+
+/// @notice Creates an `Undefined` asset instance.
+/// @return An `AssetInstance` struct with type `Undefined` and an empty payload.
+function undefined() pure returns (AssetInstance memory) {
+    return
+        AssetInstance({
+            iType: AssetInstanceType.Undefined,
+            payload: new bytes(0)
+        });
+}
+
+/// @notice Creates an `Index` asset instance with the given index value.
+/// @param params Parameters for the index variant.
+/// @return An `AssetInstance` struct with type `Index` and the provided index value encoded in the payload.
+function index(IndexParams memory params) pure returns (AssetInstance memory) {
+    bytes memory payload = Compact.encode(params.idx);
+    return AssetInstance({iType: AssetInstanceType.Index, payload: payload});
+}
+
+/// @notice Creates an `Array4` asset instance with the given 4-byte data.
+/// @param params Parameters for the array4 variant.
+/// @return An `AssetInstance` struct with type `Array4` and the provided data encoded in the payload.
+function array4(
+    Array4Params memory params
+) pure returns (AssetInstance memory) {
+    return
+        AssetInstance({
+            iType: AssetInstanceType.Array4,
+            payload: params.data.encode()
+        });
+}
+
+/// @notice Creates an `Array8` asset instance with the given 8-byte data.
+/// @param params Parameters for the array8 variant.
+/// @return An `AssetInstance` struct with type `Array8` and the provided data encoded in the payload.
+function array8(
+    Array8Params memory params
+) pure returns (AssetInstance memory) {
+    return
+        AssetInstance({
+            iType: AssetInstanceType.Array8,
+            payload: params.data.encode()
+        });
+}
+
+/// @notice Creates an `Array16` asset instance with the given 16-byte data.
+/// @param params Parameters for the array16 variant.
+/// @return An `AssetInstance` struct with type `Array16` and the provided data encoded in the payload.
+function array16(
+    Array16Params memory params
+) pure returns (AssetInstance memory) {
+    return
+        AssetInstance({
+            iType: AssetInstanceType.Array16,
+            payload: params.data.encode()
+        });
+}
+
+/// @notice Creates an `Array32` asset instance with the given 32-byte data.
+/// @param params Parameters for the array32 variant.
+/// @return An `AssetInstance` struct with type `Array32` and the provided data encoded in the payload.
+function array32(
+    Array32Params memory params
+) pure returns (AssetInstance memory) {
+    return
+        AssetInstance({
+            iType: AssetInstanceType.Array32,
+            payload: params.data.encode()
+        });
+}