l1-lottery-contracts/build/src/Proofs/DistributionProof.d.ts

This repo contains smart contracts and related scripts for ZkNoid L1 Lottery proposed [here](https://forums.minaprotocol.com/t/zknoid-l1-lottery/6269)

import { Field, SelfProof } from 'o1js';
import { Ticket } from '../Structs/Ticket.js';
import { UInt64 } from 'o1js';
import { MerkleMap20Witness } from '../Structs/CustomMerkleMap.js';
declare const DistributionProofPublicInput_base: (new (value: {
    winningCombination: import("o1js/dist/node/lib/provable/field.js").Field;
    ticket: Ticket;
    valueWitness: MerkleMap20Witness;
}) => {
    winningCombination: import("o1js/dist/node/lib/provable/field.js").Field;
    ticket: Ticket;
    valueWitness: MerkleMap20Witness;
}) & {
    _isStruct: true;
} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf.js").Provable<{
    winningCombination: import("o1js/dist/node/lib/provable/field.js").Field;
    ticket: Ticket;
    valueWitness: MerkleMap20Witness;
}, {
    winningCombination: bigint;
    ticket: {
        numbers: bigint[];
        owner: {
            x: bigint;
            isOdd: boolean;
        };
        amount: bigint;
    };
    valueWitness: {
        isLefts: boolean[];
        siblings: bigint[];
    };
}>, "fromFields"> & {
    fromFields: (fields: import("o1js/dist/node/lib/provable/field.js").Field[]) => {
        winningCombination: import("o1js/dist/node/lib/provable/field.js").Field;
        ticket: Ticket;
        valueWitness: MerkleMap20Witness;
    };
} & {
    fromValue: (value: {
        winningCombination: string | number | bigint | import("o1js/dist/node/lib/provable/field.js").Field;
        ticket: Ticket | {
            numbers: import("o1js").UInt32[] | bigint[];
            owner: import("o1js").PublicKey | {
                x: Field | bigint;
                isOdd: import("o1js").Bool | boolean;
            };
            amount: bigint | UInt64;
        };
        valueWitness: MerkleMap20Witness | {
            isLefts: import("o1js/dist/node/lib/provable/bool.js").Bool[] | boolean[];
            siblings: import("o1js/dist/node/lib/provable/field.js").Field[] | bigint[];
        };
    }) => {
        winningCombination: import("o1js/dist/node/lib/provable/field.js").Field;
        ticket: Ticket;
        valueWitness: MerkleMap20Witness;
    };
    toInput: (x: {
        winningCombination: import("o1js/dist/node/lib/provable/field.js").Field;
        ticket: Ticket;
        valueWitness: MerkleMap20Witness;
    }) => {
        fields?: Field[] | undefined;
        packed?: [Field, number][] | undefined;
    };
    toJSON: (x: {
        winningCombination: import("o1js/dist/node/lib/provable/field.js").Field;
        ticket: Ticket;
        valueWitness: MerkleMap20Witness;
    }) => {
        winningCombination: string;
        ticket: {
            numbers: string[];
            owner: string;
            amount: string;
        };
        valueWitness: {
            isLefts: boolean[];
            siblings: string[];
        };
    };
    fromJSON: (x: {
        winningCombination: string;
        ticket: {
            numbers: string[];
            owner: string;
            amount: string;
        };
        valueWitness: {
            isLefts: boolean[];
            siblings: string[];
        };
    }) => {
        winningCombination: import("o1js/dist/node/lib/provable/field.js").Field;
        ticket: Ticket;
        valueWitness: MerkleMap20Witness;
    };
    empty: () => {
        winningCombination: import("o1js/dist/node/lib/provable/field.js").Field;
        ticket: Ticket;
        valueWitness: MerkleMap20Witness;
    };
};
export declare class DistributionProofPublicInput extends DistributionProofPublicInput_base {
}
declare const DistributionProofPublicOutput_base: (new (value: {
    root: import("o1js/dist/node/lib/provable/field.js").Field;
    total: UInt64;
}) => {
    root: import("o1js/dist/node/lib/provable/field.js").Field;
    total: UInt64;
}) & {
    _isStruct: true;
} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf.js").Provable<{
    root: import("o1js/dist/node/lib/provable/field.js").Field;
    total: UInt64;
}, {
    root: bigint;
    total: bigint;
}>, "fromFields"> & {
    fromFields: (fields: import("o1js/dist/node/lib/provable/field.js").Field[]) => {
        root: import("o1js/dist/node/lib/provable/field.js").Field;
        total: UInt64;
    };
} & {
    fromValue: (value: {
        root: string | number | bigint | import("o1js/dist/node/lib/provable/field.js").Field;
        total: bigint | UInt64;
    }) => {
        root: import("o1js/dist/node/lib/provable/field.js").Field;
        total: UInt64;
    };
    toInput: (x: {
        root: import("o1js/dist/node/lib/provable/field.js").Field;
        total: UInt64;
    }) => {
        fields?: Field[] | undefined;
        packed?: [Field, number][] | undefined;
    };
    toJSON: (x: {
        root: import("o1js/dist/node/lib/provable/field.js").Field;
        total: UInt64;
    }) => {
        root: string;
        total: string;
    };
    fromJSON: (x: {
        root: string;
        total: string;
    }) => {
        root: import("o1js/dist/node/lib/provable/field.js").Field;
        total: UInt64;
    };
    empty: () => {
        root: import("o1js/dist/node/lib/provable/field.js").Field;
        total: UInt64;
    };
};
export declare class DistributionProofPublicOutput extends DistributionProofPublicOutput_base {
}
export declare const init: (input: DistributionProofPublicInput) => Promise<DistributionProofPublicOutput>;
export declare const addTicket: (input: DistributionProofPublicInput, prevProof: SelfProof<DistributionProofPublicInput, DistributionProofPublicOutput>) => Promise<DistributionProofPublicOutput>;
export declare const DistributionProgram: {
    name: string;
    compile: (options?: {
        cache?: import("o1js").Cache;
        forceRecompile?: boolean;
        proofsEnabled?: boolean;
    }) => Promise<{
        verificationKey: {
            data: string;
            hash: Field;
        };
    }>;
    verify: (proof: import("o1js").Proof<DistributionProofPublicInput, DistributionProofPublicOutput>) => Promise<boolean>;
    digest: () => Promise<string>;
    analyzeMethods: () => Promise<{
        init: {
            rows: number;
            digest: string;
            gates: import("o1js/dist/node/snarky.js").Gate[];
            publicInputSize: number;
            print(): void;
            summary(): Partial<Record<import("o1js/dist/node/snarky.js").GateType | "Total rows", number>>;
        };
        addTicket: {
            rows: number;
            digest: string;
            gates: import("o1js/dist/node/snarky.js").Gate[];
            publicInputSize: number;
            print(): void;
            summary(): Partial<Record<import("o1js/dist/node/snarky.js").GateType | "Total rows", number>>;
        };
    }>;
    publicInputType: typeof DistributionProofPublicInput;
    publicOutputType: typeof DistributionProofPublicOutput;
    privateInputTypes: {
        init: [];
        addTicket: [typeof SelfProof];
    };
    rawMethods: {
        init: (publicInput: DistributionProofPublicInput, ...args: [] & any[]) => Promise<DistributionProofPublicOutput>;
        addTicket: (publicInput: DistributionProofPublicInput, ...args: [SelfProof<unknown, unknown>] & any[]) => Promise<DistributionProofPublicOutput>;
    };
    proofsEnabled: boolean;
    setProofsEnabled(proofsEnabled: boolean): void;
} & {
    init: (publicInput: DistributionProofPublicInput, ...args: [] & any[]) => Promise<import("o1js").Proof<DistributionProofPublicInput, DistributionProofPublicOutput>>;
    addTicket: (publicInput: DistributionProofPublicInput, ...args: [SelfProof<unknown, unknown>] & any[]) => Promise<import("o1js").Proof<DistributionProofPublicInput, DistributionProofPublicOutput>>;
};
declare const DistributionProof_base: {
    new ({ proof, publicInput, publicOutput, maxProofsVerified, }: {
        proof: unknown;
        publicInput: DistributionProofPublicInput;
        publicOutput: DistributionProofPublicOutput;
        maxProofsVerified: 0 | 2 | 1;
    }): {
        verify(): void;
        verifyIf(condition: import("o1js/dist/node/lib/provable/bool.js").Bool): void;
        publicInput: DistributionProofPublicInput;
        publicOutput: DistributionProofPublicOutput;
        proof: unknown;
        maxProofsVerified: 0 | 2 | 1;
        shouldVerify: import("o1js/dist/node/lib/provable/bool.js").Bool;
        toJSON(): import("o1js").JsonProof;
    };
    publicInputType: typeof DistributionProofPublicInput;
    publicOutputType: typeof DistributionProofPublicOutput;
    tag: () => {
        name: string;
        publicInputType: typeof DistributionProofPublicInput;
        publicOutputType: typeof DistributionProofPublicOutput;
    };
    fromJSON<S extends (new (...args: any) => import("o1js").Proof<unknown, unknown>) & {
        prototype: import("o1js").Proof<any, any>;
        fromJSON: typeof import("o1js").Proof.fromJSON;
        dummy: typeof import("o1js").Proof.dummy;
        publicInputType: import("o1js").FlexibleProvablePure<any>;
        publicOutputType: import("o1js").FlexibleProvablePure<any>;
        tag: () => {
            name: string;
        };
    } & {
        prototype: import("o1js").Proof<unknown, unknown>;
    }>(this: S, { maxProofsVerified, proof: proofString, publicInput: publicInputJson, publicOutput: publicOutputJson, }: import("o1js").JsonProof): Promise<import("o1js").Proof<import("o1js").InferProvable<S["publicInputType"]>, import("o1js").InferProvable<S["publicOutputType"]>>>;
    dummy<Input, OutPut>(publicInput: Input, publicOutput: OutPut, maxProofsVerified: 0 | 2 | 1, domainLog2?: number): Promise<import("o1js").Proof<Input, OutPut>>;
};
export declare class DistributionProof extends DistributionProof_base {
}
export {};