mina-attestations/build/src/context.js

Private Attestations on Mina

import { Field, Poseidon } from 'o1js';
import { prefixes } from "./constants.js";
import { hashString } from "./dynamic/dynamic-hash.js";
import { deserializeProvableValue, serializeProvableField, serializeProvablePublicKey, } from "./serialize-provable.js";
import { assert } from "./util.js";
export { computeHttpsContext, computeZkAppContext, hashContext, serializeInputContext, deserializeHttpsContext, deserializeZkAppContext, };
// type-level assertions
true;
true;
function computeNonce(serverNonce, clientNonce) {
    return Poseidon.hashWithPrefix(prefixes.nonce, [serverNonce, clientNonce]);
}
function computeHttpsContext(input) {
    return {
        type: input.type,
        vkHash: input.vkHash,
        nonce: computeNonce(input.serverNonce, input.clientNonce),
        verifierIdentity: hashString(input.verifierIdentity),
        action: hashString(input.action),
        claims: input.claims,
    };
}
function computeZkAppContext(input) {
    return {
        type: input.type,
        vkHash: input.vkHash,
        nonce: computeNonce(input.serverNonce, input.clientNonce),
        verifierIdentity: hashZkAppIdentity(input.verifierIdentity),
        action: hashString(input.action),
        claims: input.claims,
    };
}
function hashContext(input) {
    return Poseidon.hashWithPrefix(prefixes.context, [
        hashString(input.type),
        input.vkHash,
        input.nonce,
        input.verifierIdentity,
        input.action,
        input.claims,
    ]);
}
function hashZkAppIdentity(identity) {
    return Poseidon.hashWithPrefix(prefixes.zkappIdentity, [
        networkToField(identity.network),
        ...identity.publicKey.toFields(),
        identity.tokenId,
    ]);
}
function networkToField(network) {
    if (network === 'mainnet')
        return Field(0);
    if (network === 'devnet')
        return Field(1);
    return hashString(network.custom);
}
// serialization
function serializeInputContext(context) {
    if (context === undefined)
        return null;
    let serverNonce = serializeProvableField(context.serverNonce);
    if (context.type === 'https') {
        return { type: context.type, serverNonce, action: context.action };
    }
    if (context.type === 'zk-app') {
        let { publicKey, tokenId, network } = context.verifierIdentity;
        return {
            type: context.type,
            serverNonce,
            action: context.action,
            verifierIdentity: {
                publicKey: serializeProvablePublicKey(publicKey),
                tokenId: serializeProvableField(tokenId),
                network,
            },
        };
    }
    throw Error(`Unsupported context type: ${context.type}`);
}
function deserializeHttpsContext(context) {
    assert(context?.type === 'https');
    return {
        type: context.type,
        action: context.action,
        serverNonce: deserializeProvableValue(context.serverNonce),
    };
}
function deserializeZkAppContext(context) {
    assert(context?.type === 'zk-app');
    return {
        type: context.type,
        action: context.action,
        serverNonce: deserializeProvableValue(context.serverNonce),
        verifierIdentity: {
            publicKey: deserializeProvableValue(context.verifierIdentity.publicKey),
            tokenId: deserializeProvableValue(context.verifierIdentity.tokenId),
            network: context.verifierIdentity.network,
        },
    };
}
//# sourceMappingURL=context.js.map