@pezkuwi/types 16.5.5 → 16.5.6

package/cjs/metadata/decorate/storage/util.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRuntimeFunction = createRuntimeFunction;
+const types_create_1 = require("@pezkuwi/types-create");
+const createFunction_js_1 = require("./createFunction.js");
+function findSiPrimitive(registry, type) {
+    const prim = type.toLowerCase();
+    return registry.lookup.types.find((t) => (t.type.def.isPrimitive &&
+        t.type.def.asPrimitive.toString().toLowerCase() === prim) || (t.type.def.isHistoricMetaCompat &&
+        t.type.def.asHistoricMetaCompat.toString().toLowerCase() === prim));
+}
+function findSiType(registry, type) {
+    let portable = findSiPrimitive(registry, type);
+    // some types are either Sequence or Arrays, cater for these
+    // specifically (these all come from the base bizinikiwi known keys)
+    if (!portable && (type === 'Bytes' || type.startsWith('[u8;'))) {
+        const u8 = findSiPrimitive(registry, 'u8');
+        if (u8) {
+            if (type === 'Bytes') {
+                portable = registry.lookup.types.find((t) => (t.type.def.isSequence &&
+                    t.type.def.asSequence.type.eq(u8.id)) || (t.type.def.isHistoricMetaCompat &&
+                    t.type.def.asHistoricMetaCompat.eq(type)));
+            }
+            else {
+                const td = (0, types_create_1.getTypeDef)(type);
+                portable = registry.lookup.types.find((t) => (t.type.def.isArray &&
+                    t.type.def.asArray.eq({
+                        len: td.length,
+                        type: u8.id
+                    })) || (t.type.def.isHistoricMetaCompat &&
+                    t.type.def.asHistoricMetaCompat.eq(type)));
+            }
+        }
+    }
+    if (!portable) {
+        // Not fatal, however if this happens the storage key using this
+        // type will not return valid values, rather it will most probably
+        // be decoded incorrectly
+        console.warn(`Unable to map ${type} to a lookup index`);
+    }
+    return portable;
+}
+/** @internal */
+function createRuntimeFunction({ method, prefix, section }, key, { docs, type }) {
+    return (registry) => (0, createFunction_js_1.createFunction)(registry, {
+        meta: registry.createTypeUnsafe('StorageEntryMetadataLatest', [{
+                docs: registry.createTypeUnsafe('Vec<Text>', [[docs]]),
+                modifier: registry.createTypeUnsafe('StorageEntryModifierLatest', ['Required']),
+                name: registry.createTypeUnsafe('Text', [method]),
+                toJSON: () => key,
+                type: registry.createTypeUnsafe('StorageEntryTypeLatest', [{ Plain: findSiType(registry, type)?.id || 0 }])
+            }]),
+        method,
+        prefix,
+        section
+    }, { key, skipHashing: true });
+}

package/cjs/metadata/decorate/types.d.ts

@@ -0,0 +1,33 @@
+import type { AnyTuple, Codec, Registry } from '@pezkuwi/types-codec/types';
+import type { DispatchErrorModule, DispatchErrorModuleU8, DispatchErrorModuleU8a, ErrorMetadataLatest, EventMetadataLatest, PezpalletConstantMetadataLatest } from '../../interfaces/index.js';
+import type { StorageEntry } from '../../primitive/types.js';
+import type { CallFunction, IEvent, IEventLike } from '../../types/index.js';
+export interface ConstantCodec extends Codec {
+    readonly meta: PezpalletConstantMetadataLatest;
+}
+export interface IsError {
+    readonly meta: ErrorMetadataLatest;
+    is: (moduleError: DispatchErrorModule | DispatchErrorModuleU8 | DispatchErrorModuleU8a) => boolean;
+}
+export interface IsEvent<T extends AnyTuple, N = unknown> {
+    readonly meta: EventMetadataLatest;
+    is: (event: IEventLike) => event is IEvent<T, N>;
+}
+export type ModuleConstants = Record<string, ConstantCodec>;
+export type ModuleErrors = Record<string, IsError>;
+export type ModuleEvents = Record<string, IsEvent<AnyTuple>>;
+export type ModuleExtrinsics = Record<string, CallFunction>;
+export type ModuleStorage = Record<string, StorageEntry>;
+export type Constants = Record<string, ModuleConstants>;
+export type Errors = Record<string, ModuleErrors>;
+export type Events = Record<string, ModuleEvents>;
+export type Extrinsics = Record<string, ModuleExtrinsics>;
+export type Storage = Record<string, ModuleStorage>;
+export interface DecoratedMeta {
+    readonly consts: Constants;
+    readonly errors: Errors;
+    readonly events: Events;
+    readonly query: Storage;
+    readonly registry: Registry;
+    readonly tx: Extrinsics;
+}

package/cjs/metadata/decorate/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/metadata/decorate/util.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectNameToString = exports.objectNameToCamel = void 0;
+const util_1 = require("@pezkuwi/util");
+function convert(fn) {
+    return ({ name }) => fn(name);
+}
+exports.objectNameToCamel = convert(util_1.stringCamelCase);
+exports.objectNameToString = convert((n) => n.toString());

package/cjs/metadata/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortableRegistry = exports.Metadata = exports.expandMetadata = exports.decorateStorage = exports.decorateExtrinsics = exports.decorateConstants = void 0;
+var index_js_1 = require("./decorate/index.js");
+Object.defineProperty(exports, "decorateConstants", { enumerable: true, get: function () { return index_js_1.decorateConstants; } });
+Object.defineProperty(exports, "decorateExtrinsics", { enumerable: true, get: function () { return index_js_1.decorateExtrinsics; } });
+Object.defineProperty(exports, "decorateStorage", { enumerable: true, get: function () { return index_js_1.decorateStorage; } });
+Object.defineProperty(exports, "expandMetadata", { enumerable: true, get: function () { return index_js_1.expandMetadata; } });
+var Metadata_js_1 = require("./Metadata.js");
+Object.defineProperty(exports, "Metadata", { enumerable: true, get: function () { return Metadata_js_1.Metadata; } });
+var index_js_2 = require("./PortableRegistry/index.js");
+Object.defineProperty(exports, "PortableRegistry", { enumerable: true, get: function () { return index_js_2.PortableRegistry; } });

package/cjs/metadata/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/metadata/util/extractTypes.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTypes = extractTypes;
+const types_create_1 = require("@pezkuwi/types-create");
+function extractSubSingle(_, { sub }) {
+    const { lookupName, type } = sub;
+    return extractTypes([lookupName || type]);
+}
+function extractSubArray(_, { sub }) {
+    return extractTypes(sub.map(({ lookupName, type }) => lookupName || type));
+}
+function unhandled(type, { info }) {
+    throw new Error(`Unhandled: Unable to create and validate type from ${type} (info=${types_create_1.TypeDefInfo[info]})`);
+}
+const mapping = {
+    [types_create_1.TypeDefInfo.BTreeMap]: extractSubArray,
+    [types_create_1.TypeDefInfo.BTreeSet]: extractSubSingle,
+    [types_create_1.TypeDefInfo.Compact]: extractSubSingle,
+    [types_create_1.TypeDefInfo.DoNotConstruct]: unhandled,
+    [types_create_1.TypeDefInfo.Enum]: extractSubArray,
+    [types_create_1.TypeDefInfo.HashMap]: extractSubArray,
+    [types_create_1.TypeDefInfo.Int]: unhandled,
+    [types_create_1.TypeDefInfo.Linkage]: extractSubSingle,
+    [types_create_1.TypeDefInfo.Null]: unhandled,
+    [types_create_1.TypeDefInfo.Option]: extractSubSingle,
+    [types_create_1.TypeDefInfo.Plain]: (_, typeDef) => typeDef.lookupName || typeDef.type,
+    [types_create_1.TypeDefInfo.Range]: extractSubSingle,
+    [types_create_1.TypeDefInfo.RangeInclusive]: extractSubSingle,
+    [types_create_1.TypeDefInfo.Result]: extractSubArray,
+    [types_create_1.TypeDefInfo.Set]: extractSubArray,
+    [types_create_1.TypeDefInfo.Si]: unhandled,
+    [types_create_1.TypeDefInfo.Struct]: extractSubArray,
+    [types_create_1.TypeDefInfo.Tuple]: extractSubArray,
+    [types_create_1.TypeDefInfo.UInt]: unhandled,
+    [types_create_1.TypeDefInfo.Vec]: extractSubSingle,
+    [types_create_1.TypeDefInfo.VecFixed]: extractSubSingle,
+    [types_create_1.TypeDefInfo.WrapperKeepOpaque]: extractSubSingle,
+    [types_create_1.TypeDefInfo.WrapperOpaque]: extractSubSingle
+};
+/** @internal */
+function extractTypes(types) {
+    const count = types.length;
+    const result = new Array(count);
+    for (let i = 0; i < count; i++) {
+        const type = types[i];
+        const typeDef = (0, types_create_1.getTypeDef)(type);
+        result[i] = mapping[typeDef.info](type, typeDef);
+    }
+    return result;
+}

package/cjs/metadata/util/flattenUniq.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenUniq = flattenUniq;
+/** @internal */
+function flattenUniq(list, result = []) {
+    for (let i = 0, count = list.length; i < count; i++) {
+        const entry = list[i];
+        if (Array.isArray(entry)) {
+            flattenUniq(entry, result);
+        }
+        else {
+            result.push(entry);
+        }
+    }
+    return [...new Set(result)];
+}

package/cjs/metadata/util/getSiName.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSiName = getSiName;
+function getSiName(lookup, type) {
+    const typeDef = lookup.getTypeDef(type);
+    return typeDef.lookupName || typeDef.type;
+}

package/cjs/metadata/util/getUniqTypes.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUniqTypes = getUniqTypes;
+const flattenUniq_js_1 = require("./flattenUniq.js");
+const validateTypes_js_1 = require("./validateTypes.js");
+/** @internal */
+function extractTypes(lookup, types) {
+    return types.map(({ type }) => lookup.getTypeDef(type).type);
+}
+/** @internal */
+function extractFieldTypes(lookup, type) {
+    return lookup.getSiType(type).def.asVariant.variants.map(({ fields }) => extractTypes(lookup, fields));
+}
+/** @internal */
+function getPezpalletNames({ lookup, pallets }) {
+    return pallets.reduce((all, { calls, constants, events, storage }) => {
+        all.push([extractTypes(lookup, constants)]);
+        if (calls.isSome) {
+            all.push(extractFieldTypes(lookup, calls.unwrap().type));
+        }
+        if (events.isSome) {
+            all.push(extractFieldTypes(lookup, events.unwrap().type));
+        }
+        if (storage.isSome) {
+            all.push(storage.unwrap().items.map(({ type }) => {
+                if (type.isPlain) {
+                    return [lookup.getTypeDef(type.asPlain).type];
+                }
+                const { hashers, key, value } = type.asMap;
+                return hashers.length === 1
+                    ? [
+                        lookup.getTypeDef(value).type,
+                        lookup.getTypeDef(key).type
+                    ]
+                    : [
+                        lookup.getTypeDef(value).type,
+                        ...lookup.getSiType(key).def.asTuple.map((t) => lookup.getTypeDef(t).type)
+                    ];
+            }));
+        }
+        return all;
+    }, []);
+}
+/** @internal */
+function getUniqTypes(registry, meta, throwError) {
+    return (0, validateTypes_js_1.validateTypes)(registry, throwError, (0, flattenUniq_js_1.flattenUniq)(getPezpalletNames(meta)));
+}

package/cjs/metadata/util/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTypes = exports.toCallsOnly = exports.getUniqTypes = exports.getSiName = exports.flattenUniq = void 0;
+var flattenUniq_js_1 = require("./flattenUniq.js");
+Object.defineProperty(exports, "flattenUniq", { enumerable: true, get: function () { return flattenUniq_js_1.flattenUniq; } });
+var getSiName_js_1 = require("./getSiName.js");
+Object.defineProperty(exports, "getSiName", { enumerable: true, get: function () { return getSiName_js_1.getSiName; } });
+var getUniqTypes_js_1 = require("./getUniqTypes.js");
+Object.defineProperty(exports, "getUniqTypes", { enumerable: true, get: function () { return getUniqTypes_js_1.getUniqTypes; } });
+var toCallsOnly_js_1 = require("./toCallsOnly.js");
+Object.defineProperty(exports, "toCallsOnly", { enumerable: true, get: function () { return toCallsOnly_js_1.toCallsOnly; } });
+var validateTypes_js_1 = require("./validateTypes.js");
+Object.defineProperty(exports, "validateTypes", { enumerable: true, get: function () { return validateTypes_js_1.validateTypes; } });

package/cjs/metadata/util/testUtil.d.ts

@@ -0,0 +1,10 @@
+import type { Registry } from '@pezkuwi/types-codec/types';
+import type { MetaVersionAll } from '../versions.js';
+import type { Check } from './types.js';
+/** @internal */
+export declare function decodeLatestMeta(registry: Registry, type: string, version: MetaVersionAll, { data }: Check): void;
+/** @internal */
+export declare function toLatest(registry: Registry, version: MetaVersionAll, { data }: Check, withThrow?: boolean): void;
+/** @internal */
+export declare function defaultValues(registry: Registry, { data, fails }: Check, withThrow: boolean | undefined, withFallbackCheck: boolean | undefined, version: MetaVersionAll): void;
+export declare function testMeta(version: MetaVersionAll, matchers: Record<string, Check>, withFallback?: boolean): void;

package/cjs/metadata/util/testUtil.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeLatestMeta = decodeLatestMeta;
+exports.toLatest = toLatest;
+exports.defaultValues = defaultValues;
+exports.testMeta = testMeta;
+const tslib_1 = require("tslib");
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../../create/index.js");
+const index_js_2 = require("../../util/index.js");
+const Metadata_js_1 = require("../Metadata.js");
+const getUniqTypes_js_1 = require("./getUniqTypes.js");
+function getJsonName(version, type, sub) {
+    return new URL(`../../../../types-support/src/metadata/v${version}/${type}-${sub}.json`, import.meta.url);
+}
+function writeJson(json, version, type, sub) {
+    node_fs_1.default.writeFileSync(getJsonName(version, type, sub), (0, util_1.stringify)(json, 2), { flag: 'w' });
+}
+function readJson(version, type, sub) {
+    return JSON.parse(node_fs_1.default.readFileSync(getJsonName(version, type, sub), 'utf-8'));
+}
+function handleMetadata(registry, version, data) {
+    let metadata;
+    if (version > 15) {
+        const opaqueMetadata = registry.createType('Option<OpaqueMetadata>', registry.createType('Raw', data).toU8a()).unwrap();
+        metadata = new Metadata_js_1.Metadata(registry, opaqueMetadata.toHex());
+    }
+    else {
+        try {
+            metadata = new Metadata_js_1.Metadata(registry, data);
+        }
+        catch {
+            const opaqueMetadata = registry.createType('Option<OpaqueMetadata>', registry.createType('Raw', data).toU8a()).unwrap();
+            metadata = new Metadata_js_1.Metadata(registry, opaqueMetadata.toHex());
+        }
+    }
+    return metadata;
+}
+/** @internal */
+function decodeLatestMeta(registry, type, version, { data }) {
+    const metadata = handleMetadata(registry, version, data);
+    registry.setMetadata(metadata);
+    it('decodes latest bizinikiwi properly', () => {
+        const json = metadata.toJSON();
+        delete json.metadata[`v${metadata.version}`].lookup;
+        expect(metadata.version).toBe(version);
+        try {
+            expect(json).toEqual(readJson(version, type, 'json'));
+        }
+        catch (error) {
+            if (process.env['GITHUB_REPOSITORY']) {
+                throw error;
+            }
+            console.error(error);
+            writeJson(json, version, type, 'json');
+        }
+    });
+    if (version >= 14) {
+        it('decodes latest types correctly', () => {
+            const json = metadata.asLatest.lookup.types.toJSON();
+            try {
+                expect(json).toEqual(readJson(version, type, 'types'));
+            }
+            catch (error) {
+                if (process.env['GITHUB_REPOSITORY']) {
+                    throw error;
+                }
+                console.error(error);
+                writeJson(json, version, type, 'types');
+            }
+        });
+    }
+}
+/** @internal */
+function toLatest(registry, version, { data }, withThrow = true) {
+    it(`converts v${version} to latest`, () => {
+        const metadata = handleMetadata(registry, version, data);
+        registry.setMetadata(metadata);
+        const latest = metadata.asLatest;
+        if (metadata.version < 14) {
+            (0, getUniqTypes_js_1.getUniqTypes)(registry, latest, withThrow);
+        }
+    });
+}
+/** @internal */
+function defaultValues(registry, { data, fails = [] }, withThrow = true, withFallbackCheck = false, version) {
+    describe('storage with default values', () => {
+        const metadata = handleMetadata(registry, version, data);
+        const { pallets } = metadata.asLatest;
+        pallets.filter(({ storage }) => storage.isSome).forEach(({ name, storage }) => {
+            const sectionName = (0, util_1.stringCamelCase)(name);
+            storage.unwrap().items.forEach(({ fallback, modifier, name, type }) => {
+                const inner = (0, index_js_2.unwrapStorageType)(registry, type, modifier.isOptional);
+                const location = `${sectionName}.${(0, util_1.stringCamelCase)(name)}: ${inner}`;
+                it(location, () => {
+                    expect(() => {
+                        try {
+                            const instance = registry.createTypeUnsafe(registry.createLookupType((0, index_js_2.unwrapStorageSi)(type)), [(0, util_1.hexToU8a)(fallback.toHex())], { isOptional: modifier.isOptional });
+                            if (withFallbackCheck) {
+                                const [hexType, hexOrig] = [(0, util_1.u8aToHex)(instance.toU8a()), (0, util_1.u8aToHex)(fallback.toU8a(true))];
+                                if (hexType !== hexOrig) {
+                                    throw new Error(`Fallback does not match (${((hexOrig.length - 2) / 2) - ((hexType.length - 2) / 2)} bytes missing): ${hexType} !== ${hexOrig}`);
+                                }
+                            }
+                        }
+                        catch (error) {
+                            const message = `${location}:: ${error.message}`;
+                            if (withThrow && !fails.some((f) => location.includes(f))) {
+                                throw new Error(message);
+                            }
+                            else {
+                                console.warn(message);
+                            }
+                        }
+                    }).not.toThrow();
+                });
+            });
+        });
+    });
+}
+function serialize(registry, { data }, version) {
+    const metadata = handleMetadata(registry, version, data);
+    if (version < 15) {
+        it('serializes to hex in the same form as retrieved', () => {
+            expect(metadata.toHex()).toEqual(data);
+        });
+        // NOTE Assuming the first passes this is actually something that doesn't test
+        // anything new. If the first line in this function passed and the above values
+        // are equivalent, this would be as well.
+        it.skip('can construct from a re-serialized form', () => {
+            expect(() => new Metadata_js_1.Metadata(registry, metadata.toHex())).not.toThrow();
+        });
+        // as used in the extension
+        it('can construct from asCallsOnly.toHex()', () => {
+            expect(() => new Metadata_js_1.Metadata(registry, metadata.asCallsOnly.toHex())).not.toThrow();
+        });
+    }
+}
+function testMeta(version, matchers, withFallback = true) {
+    describe(`MetadataV${version}`, () => {
+        for (const [type, matcher] of Object.entries(matchers)) {
+            const registry = new index_js_1.TypeRegistry();
+            describe(type, () => {
+                serialize(registry, matcher, version);
+                decodeLatestMeta(registry, type, version, matcher);
+                toLatest(registry, version, matcher);
+                defaultValues(registry, matcher, true, withFallback, version);
+            });
+        }
+    });
+}

package/cjs/metadata/util/toCallsOnly.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCallsOnly = toCallsOnly;
+const util_1 = require("@pezkuwi/util");
+function trimDocs(docs) {
+    const strings = docs.map((d) => d.toString().trim());
+    const firstEmpty = strings.findIndex((d) => !d.length);
+    return firstEmpty === -1
+        ? strings
+        : strings.slice(0, firstEmpty);
+}
+/** @internal */
+function toCallsOnly(registry, { extrinsic, lookup, pallets }) {
+    return registry.createTypeUnsafe('MetadataLatest', [{
+            extrinsic,
+            lookup: {
+                types: lookup.types.map(({ id, type }) => registry.createTypeUnsafe('PortableType', [{
+                        id,
+                        type: (0, util_1.objectSpread)({}, type, { docs: trimDocs(type.docs) })
+                    }]))
+            },
+            pallets: pallets.map(({ calls, index, name }) => ({
+                calls: registry.createTypeUnsafe('Option<PezpalletCallMetadataLatest>', [calls.unwrapOr(null)]),
+                index,
+                name
+            }))
+        }]).toJSON();
+}

package/cjs/metadata/util/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/metadata/util/validateTypes.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTypes = validateTypes;
+const util_1 = require("@pezkuwi/util");
+const extractTypes_js_1 = require("./extractTypes.js");
+const flattenUniq_js_1 = require("./flattenUniq.js");
+const l = (0, util_1.logger)('metadata');
+/** @internal */
+function validateTypes(registry, throwError, types) {
+    const missing = (0, flattenUniq_js_1.flattenUniq)((0, extractTypes_js_1.extractTypes)(types))
+        .filter((type) => !registry.hasType(type) &&
+        !registry.isLookupType(type))
+        .sort();
+    if (missing.length !== 0) {
+        const message = `Unknown types found, no types for ${missing.join(', ')}`;
+        if (throwError) {
+            throw new Error(message);
+        }
+        else {
+            l.warn(message);
+        }
+    }
+    return types;
+}

package/cjs/metadata/v10/toV11.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toV11 = toV11;
+/** @internal */
+function toV11(registry, { modules }) {
+    return registry.createTypeUnsafe('MetadataV11', [{
+            // This is new in V11, pass V0 here - something non-existing, telling the API to use
+            // the fallback for this information (on-chain detection)
+            extrinsic: {
+                signedExtensions: [],
+                version: 0
+            },
+            modules
+        }]);
+}

package/cjs/metadata/v11/toV12.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toV12 = toV12;
+const util_1 = require("@pezkuwi/util");
+/**
+ * @internal
+ **/
+function toV12(registry, { extrinsic, modules }) {
+    return registry.createTypeUnsafe('MetadataV12', [{
+            extrinsic,
+            modules: modules.map((mod) => registry.createTypeUnsafe('ModuleMetadataV12', [(0, util_1.objectSpread)({}, mod, { index: 255 })]))
+        }]);
+}

package/cjs/metadata/v12/toV13.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toV13 = toV13;
+/**
+ * @internal
+ **/
+function toV13(registry, v12) {
+    return registry.createTypeUnsafe('MetadataV13', [v12]);
+}