zkverifyjs/dist/esm/config/index.js

Submit proofs to zkVerify and query proof state with ease using our npm package.

import { RuntimeVersion, } from '../enums.js';
import { EZKLProcessor, FflonkProcessor, Groth16Processor, Plonky2Processor, Risc0Processor, SP1Processor, TEEProcessor, UltraHonkProcessor, UltraPlonkProcessor, } from '../proofTypes/index.js';
export const VOLTA_CHAIN_SS58_PREFIX = 251; // zkVerify specific address format
export const ZKVERIFY_CHAIN_SS58_PREFIX = 8741;
export var SupportedNetwork;
(function (SupportedNetwork) {
    SupportedNetwork["zkVerify"] = "zkVerify";
    SupportedNetwork["Volta"] = "Volta";
    SupportedNetwork["Custom"] = "Custom";
    // ADD_NEW_SUPPORTED_NETWORK
})(SupportedNetwork || (SupportedNetwork = {}));
export const SupportedNetworkConfig = {
    [SupportedNetwork.zkVerify]: {
        host: SupportedNetwork.zkVerify,
        websocket: 'wss://zkverify-rpc.zkverify.io',
        rpc: 'https://zkverify-rpc.zkverify.io',
        network: SupportedNetwork.zkVerify,
    },
    [SupportedNetwork.Volta]: {
        host: SupportedNetwork.Volta,
        websocket: 'wss://volta-rpc.zkverify.io',
        rpc: 'https://volta-rpc.zkverify.io',
        network: SupportedNetwork.Volta,
    },
    // ADD_NEW_SUPPORTED_NETWORK
    [SupportedNetwork.Custom]: {
        host: SupportedNetwork.Custom,
        websocket: '',
        rpc: '',
        network: '',
    },
};
export var ProofType;
(function (ProofType) {
    ProofType["ezkl"] = "ezkl";
    ProofType["fflonk"] = "fflonk";
    ProofType["groth16"] = "groth16";
    ProofType["plonky2"] = "plonky2";
    ProofType["risc0"] = "risc0";
    ProofType["sp1"] = "sp1";
    ProofType["ultrahonk"] = "ultrahonk";
    ProofType["ultraplonk"] = "ultraplonk";
    ProofType["tee"] = "tee";
    // ADD_NEW_PROOF_TYPE
})(ProofType || (ProofType = {}));
export const proofConfigurations = {
    [ProofType.ezkl]: {
        pallet: 'settlementEzklPallet',
        processor: EZKLProcessor,
    },
    [ProofType.fflonk]: {
        pallet: 'settlementFFlonkPallet',
        processor: FflonkProcessor,
    },
    [ProofType.groth16]: {
        pallet: 'settlementGroth16Pallet',
        processor: Groth16Processor,
    },
    [ProofType.risc0]: {
        pallet: 'settlementRisc0Pallet',
        processor: Risc0Processor,
    },
    [ProofType.ultraplonk]: {
        pallet: 'settlementUltraplonkPallet',
        processor: UltraPlonkProcessor,
    },
    [ProofType.plonky2]: {
        pallet: 'settlementPlonky2Pallet',
        processor: Plonky2Processor,
    },
    [ProofType.sp1]: {
        pallet: 'settlementSp1Pallet',
        processor: SP1Processor,
    },
    [ProofType.ultrahonk]: {
        pallet: 'settlementUltrahonkPallet',
        processor: UltraHonkProcessor,
    },
    [ProofType.tee]: {
        pallet: 'settlementTeePallet',
        processor: TEEProcessor,
    },
    // ADD_NEW_PROOF_TYPE - configurations
};
// ADD_NEW_PROOF_TYPE - options if needed.
const commonZkvTypes = {
    MerkleProof: {
        root: 'H256',
        proof: 'Vec<H256>',
        number_of_leaves: 'u32',
        leaf_index: 'u32',
        leaf: 'H256',
    },
    Curve: {
        _enum: ['Bn254', 'Bls12_381'],
    },
    Groth16Vk: {
        curve: 'Curve',
        alphaG1: 'Bytes',
        betaG2: 'Bytes',
        gammaG2: 'Bytes',
        deltaG2: 'Bytes',
        gammaAbcG1: 'Vec<Bytes>',
    },
    Plonky2Config: {
        _enum: ['Keccak', 'Poseidon'],
    },
    Plonky2Vk: {
        config: 'Plonky2Config',
        bytes: 'Bytes',
    },
    EzklVk: {
        vkBytes: 'Bytes',
    },
};
export const legacyZkvTypes = {
    ...commonZkvTypes,
    UltraHonkVk: 'Bytes',
    TeeVk: {
        tcbResponse: 'Bytes',
        certificates: 'Bytes',
    },
};
export const v1_6ZkvTypes = {
    ...commonZkvTypes,
    UltraHonkVk: {
        _enum: {
            V0_84: 'Bytes',
            V3_0: 'Bytes',
        },
    },
    TeeIntelVk: {
        tcb_response: 'Bytes',
        certificates: 'Bytes',
    },
    TeeVk: {
        _enum: {
            Intel: 'TeeIntelVk',
        },
    },
};
export const v1_6_1ZkvTypes = {
    ...commonZkvTypes,
    UltraHonkVk: {
        _enum: {
            V0_84: 'Bytes',
            V3_0: 'Bytes',
            Legacy: 'Bytes',
        },
    },
    TeeIntelVk: {
        tcb_response: 'Bytes',
        certificates: 'Bytes',
    },
    TeeVk: {
        _enum: {
            Intel: 'TeeIntelVk',
        },
    },
};
export const zkvTypes = legacyZkvTypes;
export function getZkvTypes(runtimeSpec) {
    if (runtimeSpec !== undefined &&
        runtimeSpec.specVersion >= RuntimeVersion.V1_6_1) {
        return v1_6_1ZkvTypes;
    }
    if (runtimeSpec !== undefined &&
        runtimeSpec.specVersion >= RuntimeVersion.V1_6_0) {
        return v1_6ZkvTypes;
    }
    return legacyZkvTypes;
}
export const zkvRpc = {
    aggregate: {
        statementPath: {
            description: 'Get the Merkle root and path of a aggregate statement',
            params: [
                {
                    name: 'at',
                    type: 'BlockHash',
                },
                {
                    name: 'domain_id',
                    type: 'u32',
                },
                {
                    name: 'aggregation_id',
                    type: 'u64',
                },
                {
                    name: 'statement',
                    type: 'H256',
                },
            ],
            type: 'MerkleProof',
        },
    },
    vk_hash: {
        groth16: {
            description: 'Get the hash of a Groth16 verification key',
            params: [
                {
                    name: 'vk',
                    type: 'Groth16Vk',
                },
            ],
            type: 'H256',
        },
        plonky2: {
            description: 'Get the hash of a Plonky2 verification key',
            params: [
                {
                    name: 'vk',
                    type: 'Plonky2Vk',
                },
            ],
            type: 'H256',
        },
        risc0: {
            description: 'Get the hash of a Risc0 verification key',
            params: [
                {
                    name: 'vk',
                    type: 'H256',
                },
            ],
            type: 'H256',
        },
        ultraplonk: {
            description: 'Get the hash of an UltraPLONK verification key',
            params: [
                {
                    name: 'vk',
                    type: 'Bytes',
                },
            ],
            type: 'H256',
        },
        fflonk: {
            description: 'Get the hash of a FFLONK verification key',
            params: [
                {
                    name: 'vk',
                    type: 'Bytes',
                },
            ],
            type: 'H256',
        },
        sp1: {
            description: 'Get the hash of an SP1 verification key',
            params: [
                {
                    name: 'vk',
                    type: 'H256',
                },
            ],
            type: 'H256',
        },
        ultrahonk: {
            description: 'Get the hash of an UltraHonk verification key',
            params: [
                {
                    name: 'vk',
                    type: 'UltraHonkVk',
                },
            ],
            type: 'H256',
        },
        ezkl: {
            description: 'Get the hash of an Ezkl verification key artifact',
            params: [
                {
                    name: 'vk',
                    type: 'EzklVK',
                },
            ],
            type: 'H256',
        },
        tee: {
            description: 'Get the hash of a TEE verification key',
            params: [
                {
                    name: 'vk',
                    type: 'TeeVk',
                },
            ],
            type: 'H256',
        },
        // ADD_NEW_PROOF_TYPE
    },
};
//# sourceMappingURL=index.js.map