@pezkuwi/types 16.5.5 → 16.5.6

package/cjs/metadata/v13/toV14.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toV14 = toV14;
+const util_1 = require("@pezkuwi/util");
+const alias_js_1 = require("../../interfaces/alias.js");
+const definitions_js_1 = require("../../interfaces/runtime/definitions.js");
+const BOXES = [['<', '>'], ['<', ','], [',', '>'], ['(', ')'], ['(', ','], [',', ','], [',', ')']];
+/**
+ * Creates a compatible type mapping
+ * @internal
+ **/
+function compatType(specs, _type) {
+    const type = _type.toString();
+    const index = specs.findIndex(({ def }) => def.HistoricMetaCompat === type);
+    if (index !== -1) {
+        return index;
+    }
+    return specs.push({
+        def: {
+            HistoricMetaCompat: type
+        }
+    }) - 1;
+}
+function compatTypes(specs, ...types) {
+    for (let i = 0, count = types.length; i < count; i++) {
+        compatType(specs, types[i]);
+    }
+}
+function makeTupleType(specs, entries) {
+    return specs.push({
+        def: {
+            Tuple: entries
+        }
+    }) - 1;
+}
+function makeVariantType(modName, variantType, specs, variants) {
+    return specs.push({
+        def: {
+            Variant: { variants }
+        },
+        path: [`pallet_${modName.toString()}`, 'pallet', variantType]
+    }) - 1;
+}
+/**
+ * @internal
+ * generate & register the OriginCaller type
+ **/
+function registerOriginCaller(registry, modules, metaVersion) {
+    registry.register({
+        OriginCaller: {
+            _enum: modules
+                .map((mod, index) => [
+                mod.name.toString(),
+                metaVersion >= 12
+                    ? mod.index.toNumber()
+                    : index
+            ])
+                .sort((a, b) => a[1] - b[1])
+                .reduce((result, [name, index]) => {
+                for (let i = Object.keys(result).length; i < index; i++) {
+                    result[`Empty${i}`] = 'Null';
+                }
+                result[name] = definitions_js_1.knownOrigins[name] || 'Null';
+                return result;
+            }, {})
+        }
+    });
+}
+/**
+ * Find and apply the correct type override
+ * @internal
+ **/
+function setTypeOverride(sectionTypes, types) {
+    types.forEach((type) => {
+        const override = Object.keys(sectionTypes).find((aliased) => type.eq(aliased));
+        if (override) {
+            type.setOverride(sectionTypes[override]);
+        }
+        else {
+            // FIXME: NOT happy with this approach, but gets over the initial hump cased by (Vec<Announcement>,BalanceOf)
+            const orig = type.toString();
+            const alias = Object
+                .entries(sectionTypes)
+                .reduce((result, [src, dst]) => BOXES.reduce((result, [a, z]) => result.replace(`${a}${src}${z}`, `${a}${dst}${z}`), result), orig);
+            if (orig !== alias) {
+                type.setOverride(alias);
+            }
+        }
+    });
+}
+/**
+ * Apply module-specific type overrides (always be done as part of toV14)
+ * @internal
+ **/
+function convertCalls(specs, registry, modName, calls, sectionTypes) {
+    const variants = calls.map(({ args, docs, name }, index) => {
+        setTypeOverride(sectionTypes, args.map(({ type }) => type));
+        return registry.createTypeUnsafe('SiVariant', [{
+                docs,
+                fields: args.map(({ name, type }) => registry.createTypeUnsafe('SiField', [{ name, type: compatType(specs, type) }])),
+                index,
+                name
+            }]);
+    });
+    return registry.createTypeUnsafe('PezpalletCallMetadataV14', [{
+            type: makeVariantType(modName, 'Call', specs, variants)
+        }]);
+}
+/**
+ * Apply module-specific type overrides (always be done as part of toV14)
+ * @internal
+ */
+function convertConstants(specs, registry, constants, sectionTypes) {
+    return constants.map(({ docs, name, type, value }) => {
+        setTypeOverride(sectionTypes, [type]);
+        return registry.createTypeUnsafe('PezpalletConstantMetadataV14', [{
+                docs,
+                name,
+                type: compatType(specs, type),
+                value
+            }]);
+    });
+}
+/**
+ * Apply module-specific type overrides (always be done as part of toV14)
+ * @internal
+ */
+function convertErrors(specs, registry, modName, errors, _sectionTypes) {
+    const variants = errors.map(({ docs, name }, index) => registry.createTypeUnsafe('SiVariant', [{
+            docs,
+            fields: [],
+            index,
+            name
+        }]));
+    return registry.createTypeUnsafe('PezpalletErrorMetadataV14', [{
+            type: makeVariantType(modName, 'Error', specs, variants)
+        }]);
+}
+/**
+ * Apply module-specific type overrides (always be done as part of toV14)
+ * @internal
+ **/
+function convertEvents(specs, registry, modName, events, sectionTypes) {
+    const variants = events.map(({ args, docs, name }, index) => {
+        setTypeOverride(sectionTypes, args);
+        return registry.createTypeUnsafe('SiVariant', [{
+                docs,
+                fields: args.map((t) => registry.createTypeUnsafe('SiField', [{ type: compatType(specs, t) }])),
+                index,
+                name
+            }]);
+    });
+    return registry.createTypeUnsafe('PezpalletEventMetadataV14', [{
+            type: makeVariantType(modName, 'Event', specs, variants)
+        }]);
+}
+function createMapEntry(specs, registry, sectionTypes, { hashers, isLinked, isOptional, keys, value }) {
+    setTypeOverride(sectionTypes, [value, ...(Array.isArray(keys) ? keys : [keys])]);
+    return registry.createTypeUnsafe('StorageEntryTypeV14', [{
+            Map: {
+                hashers,
+                key: hashers.length === 1
+                    ? compatType(specs, keys[0])
+                    : makeTupleType(specs, keys.map((t) => compatType(specs, t))),
+                value: isLinked
+                    // For previous-generation linked-map support, the actual storage result
+                    // is a Tuple with the value and the Linkage (Option appears in teh value-part only)
+                    ? compatType(specs, `(${isOptional ? `Option<${value.toString()}>` : value.toString()}, Linkage<${keys[0].toString()}>)`)
+                    : compatType(specs, value)
+            }
+        }]);
+}
+/**
+ * Apply module-specific storage type overrides (always part of toV14)
+ * @internal
+ **/
+function convertStorage(specs, registry, { items, prefix }, sectionTypes) {
+    return registry.createTypeUnsafe('PezpalletStorageMetadataV14', [{
+            items: items.map(({ docs, fallback, modifier, name, type }) => {
+                let entryType;
+                if (type.isPlain) {
+                    const plain = type.asPlain;
+                    setTypeOverride(sectionTypes, [plain]);
+                    entryType = registry.createTypeUnsafe('StorageEntryTypeV14', [{
+                            Plain: compatType(specs, plain)
+                        }]);
+                }
+                else if (type.isMap) {
+                    const map = type.asMap;
+                    entryType = createMapEntry(specs, registry, sectionTypes, {
+                        hashers: [map.hasher],
+                        isLinked: map.linked.isTrue,
+                        isOptional: modifier.isOptional,
+                        keys: [map.key],
+                        value: map.value
+                    });
+                }
+                else if (type.isDoubleMap) {
+                    const dm = type.asDoubleMap;
+                    entryType = createMapEntry(specs, registry, sectionTypes, {
+                        hashers: [dm.hasher, dm.key2Hasher],
+                        isLinked: false,
+                        isOptional: modifier.isOptional,
+                        keys: [dm.key1, dm.key2],
+                        value: dm.value
+                    });
+                }
+                else {
+                    const nm = type.asNMap;
+                    entryType = createMapEntry(specs, registry, sectionTypes, {
+                        hashers: nm.hashers,
+                        isLinked: false,
+                        isOptional: modifier.isOptional,
+                        keys: nm.keyVec,
+                        value: nm.value
+                    });
+                }
+                return registry.createTypeUnsafe('StorageEntryMetadataV14', [{
+                        docs,
+                        fallback,
+                        modifier,
+                        name,
+                        type: entryType
+                    }]);
+            }),
+            prefix
+        }]);
+}
+/** @internal */
+function convertExtrinsic(registry, { signedExtensions, version }) {
+    return registry.createTypeUnsafe('ExtrinsicMetadataV14', [{
+            signedExtensions: signedExtensions.map((identifier) => ({
+                identifier,
+                type: 0 // we don't map the fields at all
+            })),
+            type: 0, // Map to extrinsic like in v14?
+            version
+        }]);
+}
+/** @internal */
+function createPezpallet(specs, registry, mod, { calls, constants, errors, events, storage }) {
+    const sectionTypes = (0, alias_js_1.getAliasTypes)(registry, (0, util_1.stringCamelCase)(mod.name));
+    return registry.createTypeUnsafe('PezpalletMetadataV14', [{
+            calls: calls && convertCalls(specs, registry, mod.name, calls, sectionTypes),
+            constants: convertConstants(specs, registry, constants, sectionTypes),
+            errors: errors && convertErrors(specs, registry, mod.name, errors, sectionTypes),
+            events: events && convertEvents(specs, registry, mod.name, events, sectionTypes),
+            index: mod.index,
+            name: mod.name,
+            storage: storage && convertStorage(specs, registry, storage, sectionTypes)
+        }]);
+}
+/**
+ * Convert the Metadata to v14
+ * @internal
+ **/
+function toV14(registry, v13, metaVersion) {
+    const specs = [];
+    // position 0 always has Null, additionally add internal defaults
+    compatTypes(specs, 'Null', 'u8', 'u16', 'u32', 'u64');
+    registerOriginCaller(registry, v13.modules, metaVersion);
+    const extrinsic = convertExtrinsic(registry, v13.extrinsic);
+    const pallets = v13.modules.map((mod) => createPezpallet(specs, registry, mod, {
+        calls: mod.calls.unwrapOr(null),
+        constants: mod.constants,
+        errors: mod.errors.length ? mod.errors : null,
+        events: mod.events.unwrapOr(null),
+        storage: mod.storage.unwrapOr(null)
+    }));
+    return registry.createTypeUnsafe('MetadataV14', [{
+            extrinsic,
+            lookup: {
+                types: specs.map((type, id) => registry.createTypeUnsafe('PortableType', [{ id, type }]))
+            },
+            pallets
+        }]);
+}

package/cjs/metadata/v14/toV15.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toV15 = toV15;
+const util_1 = require("@pezkuwi/util");
+/**
+ * Convert the Metadata to v15
+ * @internal
+ **/
+function toV15(registry, v14, _) {
+    // V15 is mostly equivalent to v14 however it does add
+    //
+    // 1. The top-level apis entry - it is assumed that in usage we would
+    //    just check for all-empty (like this would construct)
+    // 2. A docs param on the pallet itself
+    // 3. Additional extrinsic parameters
+    //
+    // A straight conversion with createTypeUndafe magic fills in details
+    // We need the UncheckedExtrinsic to extract the types, at least for v14
+    // which does have these details embedded (previous-gen won't populate)
+    const unchecked = v14.lookup.paramTypes.PezspRuntimeUncheckedExtrinsic;
+    return registry.createTypeUnsafe('MetadataV15', [
+        (0, util_1.objectSpread)({}, v14, {
+            extrinsic: registry.createTypeUnsafe('ExtrinsicMetadataV15', [
+                (0, util_1.objectSpread)({}, v14.extrinsic, {
+                    addressType: unchecked?.[0].type.unwrapOr(0),
+                    callType: unchecked?.[1].type.unwrapOr(0),
+                    extraType: unchecked?.[3].type.unwrapOr(0),
+                    signatureType: unchecked?.[2].type.unwrapOr(0)
+                })
+            ]),
+            outerEnums: registry.createTypeUnsafe('OuterEnums15', [{
+                    // FIXME We need to extract & add the errorType in here
+                    // (these doesn't seem to be an esay way to detect & extract it)
+                    callType: unchecked?.[1].type.unwrapOr(0),
+                    eventType: v14.lookup.paramTypes.PezframeSystemEventRecord?.[0].type.unwrapOr(0)
+                }])
+        })
+    ]);
+}

package/cjs/metadata/v15/toV16.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toV16 = toV16;
+const util_1 = require("@pezkuwi/util");
+function palletsFromV15(registry, palletV15) {
+    const deprecationInfo = registry.createTypeUnsafe('ItemDeprecationInfoV16', ['NotDeprecated']);
+    const associatedTypes = registry.createTypeUnsafe('Vec<PezpalletAssociatedTypeMetadataV16>', [[]]);
+    const viewFunctions = registry.createTypeUnsafe('Vec<PezpalletViewFunctionMetadataV16>', [[]]);
+    return registry.createTypeUnsafe('PezpalletMetadataV16', [
+        (0, util_1.objectSpread)({}, palletV15, {
+            associatedTypes,
+            calls: palletV15.calls.isSome ? convertCalls(registry, palletV15.calls.unwrap()) : null,
+            constants: convertConstants(registry, palletV15.constants),
+            deprecationInfo,
+            errors: palletV15.errors.isSome ? converErrors(registry, palletV15.errors.unwrap()) : null,
+            events: palletV15.events.isSome ? convertEvents(registry, palletV15.events.unwrap()) : null,
+            storage: palletV15.storage.isSome ? convertStorage(registry, palletV15.storage.unwrap()) : null,
+            viewFunctions
+        })
+    ]);
+}
+function convertStorage(registry, storage) {
+    const deprecationInfo = registry.createTypeUnsafe('ItemDeprecationInfoV16', ['NotDeprecated']);
+    const items = storage.items.map((item) => registry.createTypeUnsafe('StorageEntryMetadataV16', [
+        (0, util_1.objectSpread)({}, item, { deprecationInfo })
+    ]));
+    return registry.createTypeUnsafe('PezpalletStorageMetadataV16', [{
+            items: registry.createTypeUnsafe('Vec<StorageEntryMetadataV16>', [items]),
+            prefix: storage.prefix
+        }]);
+}
+function convertCalls(registry, calls) {
+    const deprecationInfo = registry.createTypeUnsafe('EnumDeprecationInfoV16', []);
+    return registry.createTypeUnsafe('PezpalletCallMetadataV16', [{
+            deprecationInfo,
+            type: calls.type
+        }]);
+}
+function convertEvents(registry, events) {
+    const deprecationInfo = registry.createTypeUnsafe('EnumDeprecationInfoV16', []);
+    return registry.createTypeUnsafe('PezpalletEventMetadataV16', [{
+            deprecationInfo,
+            type: events.type
+        }]);
+}
+function convertConstants(registry, constants) {
+    const deprecationInfo = registry.createTypeUnsafe('ItemDeprecationInfoV16', ['NotDeprecated']);
+    return registry.createTypeUnsafe('Vec<PezpalletConstantMetadataV16>', [
+        constants.map((constant) => registry.createTypeUnsafe('PezpalletConstantMetadataV16', [
+            (0, util_1.objectSpread)({}, constant, { deprecationInfo })
+        ]))
+    ]);
+}
+function converErrors(registry, errors) {
+    const deprecationInfo = registry.createTypeUnsafe('EnumDeprecationInfoV16', []);
+    return registry.createTypeUnsafe('PezpalletErrorMetadataV16', [{
+            deprecationInfo,
+            type: errors.type
+        }]);
+}
+function extrinsicFromV15(registry, extrinsicV15) {
+    const transactionExtensions = extrinsicV15.signedExtensions.map(({ additionalSigned, identifier, type }) => registry.createTypeUnsafe('TransactionExtensionMetadataV16', [{
+            identifier,
+            implict: additionalSigned,
+            type
+        }]));
+    const indexes = transactionExtensions.map((_, i) => registry.createTypeUnsafe('Compact<u32>', [i]));
+    const transactionExtensionsByVersion = registry.createTypeUnsafe('BTreeMap<u8, Vec<Compact<u32>>>', [new Map([[registry.createTypeUnsafe('u8', [extrinsicV15.version]), registry.createTypeUnsafe('Vec<Compact<u32>>', [indexes])]])]);
+    return registry.createTypeUnsafe('ExtrinsicMetadataV16', [
+        {
+            addressType: extrinsicV15.addressType,
+            callType: extrinsicV15.callType,
+            signatureType: extrinsicV15.signatureType,
+            transactionExtensions,
+            transactionExtensionsByVersion,
+            versions: [extrinsicV15.version]
+        }
+    ]);
+}
+function apisFromV15(registry, runtimeApiV15) {
+    const deprecationInfo = registry.createTypeUnsafe('ItemDeprecationInfoV16', ['NotDeprecated']);
+    const methods = runtimeApiV15.methods.map((method) => registry.createTypeUnsafe('RuntimeApiMethodMetadataV16', [(0, util_1.objectSpread)({}, method, { deprecationInfo })]));
+    return registry.createTypeUnsafe('RuntimeApiMetadataV16', [
+        (0, util_1.objectSpread)({}, runtimeApiV15, {
+            deprecationInfo,
+            methods,
+            version: registry.createTypeUnsafe('Compact<u32>', [0])
+        })
+    ]);
+}
+/**
+ * Convert the Metadata to v16
+ * @internal
+ **/
+function toV16(registry, v15, _) {
+    const pallets = v15.pallets.map((pallet) => {
+        return palletsFromV15(registry, pallet);
+    });
+    const extrinsic = extrinsicFromV15(registry, v15.extrinsic);
+    const apis = v15.apis.map((runtimeApi) => apisFromV15(registry, runtimeApi));
+    return registry.createTypeUnsafe('MetadataV16', [
+        (0, util_1.objectSpread)({}, v15, {
+            apis,
+            extrinsic,
+            pallets
+        })
+    ]);
+}

package/cjs/metadata/v16/toLatest.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toLatest = toLatest;
+/**
+ * Convert the Metadata (which is an alias) to latest
+ * @internal
+ **/
+function toLatest(_registry, v16, _metaVersion) {
+    return v16;
+}

package/cjs/metadata/v9/toV10.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toV10 = toV10;
+const util_1 = require("@pezkuwi/util");
+/** @internal */
+function createStorageHasher(registry, hasher) {
+    // Blake2_128_Concat has been added at index 2, so we increment all the
+    // indexes greater than 2
+    if (hasher.toNumber() >= 2) {
+        return registry.createTypeUnsafe('StorageHasherV10', [hasher.toNumber() + 1]);
+    }
+    return registry.createTypeUnsafe('StorageHasherV10', [hasher]);
+}
+/** @internal */
+function createStorageType(registry, entryType) {
+    if (entryType.isMap) {
+        return [(0, util_1.objectSpread)({}, entryType.asMap, {
+                hasher: createStorageHasher(registry, entryType.asMap.hasher)
+            }), 1];
+    }
+    if (entryType.isDoubleMap) {
+        return [(0, util_1.objectSpread)({}, entryType.asDoubleMap, {
+                hasher: createStorageHasher(registry, entryType.asDoubleMap.hasher),
+                key2Hasher: createStorageHasher(registry, entryType.asDoubleMap.key2Hasher)
+            }), 2];
+    }
+    return [entryType.asPlain, 0];
+}
+/** @internal */
+function convertModule(registry, mod) {
+    const storage = mod.storage.unwrapOr(null);
+    return registry.createTypeUnsafe('ModuleMetadataV10', [(0, util_1.objectSpread)({}, mod, {
+            storage: storage
+                ? (0, util_1.objectSpread)({}, storage, {
+                    items: storage.items.map((item) => (0, util_1.objectSpread)({}, item, {
+                        type: registry.createTypeUnsafe('StorageEntryTypeV10', createStorageType(registry, item.type))
+                    }))
+                })
+                : null
+        })]);
+}
+/** @internal */
+function toV10(registry, { modules }) {
+    return registry.createTypeUnsafe('MetadataV10', [{
+            modules: modules.map((mod) => convertModule(registry, mod))
+        }]);
+}

package/cjs/metadata/versions.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TO_CALLS_VERSION = exports.LATEST_VERSION = exports.KNOWN_VERSIONS = void 0;
+exports.KNOWN_VERSIONS = [16, 15, 14, 13, 12, 11, 10, 9];
+exports.LATEST_VERSION = exports.KNOWN_VERSIONS[0];
+exports.TO_CALLS_VERSION = 14; // LATEST_VERSION;

package/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/cjs/packageDetect.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const packageInfo_1 = require("@pezkuwi/types-codec/cjs/packageInfo");
+const packageInfo_2 = require("@pezkuwi/types-create/cjs/packageInfo");
+const util_1 = require("@pezkuwi/util");
+const packageInfo_js_1 = require("./packageInfo.js");
+(0, util_1.detectPackage)(packageInfo_js_1.packageInfo, null, [packageInfo_1.packageInfo, packageInfo_2.packageInfo]);

package/cjs/packageInfo.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageInfo = void 0;
+exports.packageInfo = { name: '@pezkuwi/types', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '16.5.4' };

package/cjs/primitive/Data.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Data = void 0;
+const types_codec_1 = require("@pezkuwi/types-codec");
+const util_1 = require("@pezkuwi/util");
+/** @internal */
+function decodeDataU8a(registry, value) {
+    const indicator = value[0];
+    if (!indicator) {
+        return [undefined, undefined];
+    }
+    else if (indicator >= 1 && indicator <= 33) {
+        const length = indicator - 1;
+        const data = value.subarray(1, length + 1);
+        // in this case, we are passing a Raw back (since we have no length)
+        return [registry.createTypeUnsafe('Raw', [data]), 1];
+    }
+    else if (indicator >= 34 && indicator <= 37) {
+        return [value.subarray(1, 32 + 1), indicator - 32]; // 34 becomes 2
+    }
+    throw new Error(`Unable to decode Data, invalid indicator byte ${indicator}`);
+}
+/** @internal */
+function decodeData(registry, value) {
+    if ((0, util_1.isU8a)(value) || (0, util_1.isString)(value)) {
+        return decodeDataU8a(registry, (0, util_1.u8aToU8a)(value));
+    }
+    else if (!value) {
+        return [undefined, undefined];
+    }
+    // assume we have an Enum or an  object input, handle this via the normal Enum decoding
+    return [value, undefined];
+}
+/**
+ * @name Data
+ * @description
+ * A [[Data]] container with node, raw or hashed data
+ */
+class Data extends types_codec_1.Enum {
+    constructor(registry, value) {
+        super(registry, {
+            None: 'Null', // 0
+            Raw: 'Bytes', // 1
+            // eslint-disable-next-line sort-keys
+            BlakeTwo256: 'H256', // 2
+            Sha256: 'H256', // 3
+            // eslint-disable-next-line sort-keys
+            Keccak256: 'H256', // 4
+            ShaThree256: 'H256' // 5
+        }, ...decodeData(registry, value));
+        if (this.isRaw && this.asRaw.length > 32) {
+            throw new Error('Data.Raw values are limited to a maximum length of 32 bytes');
+        }
+    }
+    get asBlakeTwo256() {
+        return this.value;
+    }
+    get asKeccak256() {
+        return this.value;
+    }
+    get asRaw() {
+        return this.value;
+    }
+    get asSha256() {
+        return this.value;
+    }
+    get asShaThree256() {
+        return this.value;
+    }
+    get isBlakeTwo256() {
+        return this.index === 2;
+    }
+    get isKeccak256() {
+        return this.index === 4;
+    }
+    get isNone() {
+        return this.index === 0;
+    }
+    get isRaw() {
+        return this.index === 1;
+    }
+    get isSha256() {
+        return this.index === 3;
+    }
+    get isShaThree256() {
+        return this.index === 5;
+    }
+    /**
+     * @description The encoded length
+     */
+    get encodedLength() {
+        return this.toU8a().length;
+    }
+    /**
+     * @description Encodes the value as a Uint8Array as per the SCALE specifications
+     */
+    toU8a() {
+        if (this.index === 0) {
+            return new Uint8Array(1);
+        }
+        else if (this.index === 1) {
+            // don't add the length, just the data
+            const data = this.value.toU8a(true);
+            const length = Math.min(data.length, 32);
+            const u8a = new Uint8Array(length + 1);
+            u8a.set([length + 1], 0);
+            u8a.set(data.subarray(0, length), 1);
+            return u8a;
+        }
+        // otherwise we simply have a hash
+        const u8a = new Uint8Array(33);
+        u8a.set([this.index + 32], 0);
+        u8a.set(this.value.toU8a(), 1);
+        return u8a;
+    }
+}
+exports.Data = Data;