mina-attestations/build/src/provable-factory.js

Private Attestations on Mina

import { assert, assertHasProperty, hasProperty } from "./util.js";
export { ProvableFactory };
const factories = new Map();
const ProvableFactory = {
    register(name, factory, serialize) {
        assert(!factories.has(name), 'Factory already registered');
        factories.set(name, { base: factory.Base, ...serialize });
    },
    getRegistered(value) {
        let entry;
        for (let [key, factory] of factories.entries()) {
            if (value instanceof factory.base) {
                entry = [key, factory];
            }
        }
        return entry;
    },
    tryToJSON(constructor) {
        if (!hasProperty(constructor, 'prototype'))
            return undefined;
        let entry = ProvableFactory.getRegistered(constructor.prototype);
        if (entry === undefined)
            return undefined;
        let [key, factory] = entry;
        let json = factory.typeToJSON(constructor);
        return { _type: key, ...json, _isFactory: true };
    },
    tryValueToJSON(value) {
        let entry = ProvableFactory.getRegistered(value);
        if (entry === undefined)
            return undefined;
        let [key, factory] = entry;
        let serializedType = factory.typeToJSON(value.constructor);
        return {
            _type: key,
            ...serializedType,
            value: factory.valueToJSON(value.constructor, value),
            _isFactory: true,
        };
    },
    isSerialized(json) {
        return hasProperty(json, '_isFactory') && json._isFactory === true;
    },
    fromJSON(json) {
        assertHasProperty(json, '_type');
        assert(typeof json._type === 'string', 'Invalid type');
        let factory = factories.get(json._type);
        assert(factory !== undefined, `Type '${json._type}' not registered`);
        let validated = factory.typeSchema.parse(json);
        return factory.typeFromJSON(validated);
    },
    valueFromJSON(json) {
        assertHasProperty(json, '_type');
        assert(typeof json._type === 'string', 'Invalid type');
        let factory = factories.get(json._type);
        assert(factory !== undefined, `Type '${json._type}' not registered`);
        let validated = factory.typeSchema.parse(json);
        let type = factory.typeFromJSON(validated);
        assertHasProperty(json, 'value');
        let value = factory.valueSchema.parse(json.value);
        return factory.valueFromJSON(type, value);
    },
};
//# sourceMappingURL=provable-factory.js.map