mina-attestations/build/src/operation.d.ts

Private Attestations on Mina

import { Bool, Field, PublicKey } from 'o1js';
import { ProvableType } from './o1js-missing.ts';
import { NestedProvable } from './nested.ts';
import { DynamicArray } from './dynamic/dynamic-array.ts';
import { DynamicRecord } from './dynamic/dynamic-record.ts';
import type { Input, RootValue, RootType } from './program-spec.ts';
import type { CredentialSpec, CredentialType } from './credential.ts';
import type { NativeWitness } from './credential-native.ts';
import { type ImportedWitness } from './credential-imported.ts';
import { Numeric, type NumericMaximum } from './dynamic/gadgets-numeric.ts';
export { Node, Operation };
export { type CredentialNode, type InputToNode, root };
declare const Operation: {
    owner: Node<PublicKey>;
    constant<Data>(data: Data): Node<Data>;
    issuer: typeof issuer;
    issuerPublicKey: typeof issuerPublicKey;
    verificationKeyHash: typeof verificationKeyHash;
    publicInput: typeof publicInput;
    property: typeof property;
    record: typeof record;
    equals: typeof equals;
    equalsOneOf: typeof equalsOneOf;
    lessThan: typeof lessThan;
    lessThanEq: typeof lessThanEq;
    add: typeof add;
    sub: typeof sub;
    mul: typeof mul;
    div: typeof div;
    and: typeof and;
    or: typeof or;
    not: typeof not;
    hash: typeof hash;
    hashWithPrefix: typeof hashWithPrefix;
    ifThenElse: typeof ifThenElse;
    compute: typeof compute;
};
type CredentialNode<Data = any, Witness = WitnessAny> = {
    type: 'credential';
    credentialKey: string;
    credentialType: CredentialType;
    data?: Data;
    witness?: Witness;
};
type Node<Data = any> = {
    type: 'constant';
    data: Data;
} | {
    type: 'root';
    input: Record<string, Input>;
} | {
    type: 'owner';
} | CredentialNode<Data> | {
    type: 'issuer';
    credentialKey: string;
} | {
    type: 'issuerPublicKey';
    credentialKey: string;
} | {
    type: 'verificationKeyHash';
    credentialKey: string;
} | {
    type: 'publicInput';
    credentialKey: string;
} | {
    type: 'property';
    key: string;
    inner: Node;
} | {
    type: 'record';
    data: Record<string, Node>;
} | {
    type: 'equals';
    left: Node;
    right: Node;
} | {
    type: 'equalsOneOf';
    input: Node;
    options: Node[] | Node<any[]> | Node<DynamicArray>;
} | {
    type: 'lessThan';
    left: Node<Numeric>;
    right: Node<Numeric>;
} | {
    type: 'lessThanEq';
    left: Node<Numeric>;
    right: Node<Numeric>;
} | {
    type: 'add';
    left: Node<Numeric>;
    right: Node<Numeric>;
} | {
    type: 'sub';
    left: Node<Numeric>;
    right: Node<Numeric>;
} | {
    type: 'mul';
    left: Node<Numeric>;
    right: Node<Numeric>;
} | {
    type: 'div';
    left: Node<Numeric>;
    right: Node<Numeric>;
} | {
    type: 'and';
    inputs: Node<Bool>[];
} | {
    type: 'or';
    left: Node<Bool>;
    right: Node<Bool>;
} | {
    type: 'not';
    inner: Node<Bool>;
} | {
    type: 'hash';
    inputs: Node[];
    prefix?: string;
} | {
    type: 'ifThenElse';
    condition: Node<Bool>;
    thenNode: Node;
    elseNode: Node;
} | {
    type: 'compute';
    inputs: readonly Node[];
    computation: (...inputs: any[]) => any;
    outputType: ProvableType;
};
type GetData<T extends Input> = T extends Input<infer Data> ? Data : never;
type InputToNode<T extends Input> = T extends CredentialSpec<infer Witness, infer Data> ? CredentialNode<Data, Witness> : Node<GetData<T>>;
declare const Node: {
    eval: typeof evalNode;
    evalType: typeof evalNodeType;
};
declare function evalNode<Data>(root: RootValue, node: Node<Data>): Data;
declare function evalNodeType(rootType: RootType, node: Node): NestedProvable;
declare function root<Inputs extends Record<string, Input>>(inputs: Inputs): Node<{
    [K in keyof Inputs]: Node<GetData<Inputs[K]>>;
}>;
declare function property<K extends string, Data extends {
    [key in K]: any;
}>(node: Node<Data | DynamicRecord<Data>>, key: K): Node<Data[K]>;
declare function record<Nodes extends Record<string, Node>>(nodes: Nodes): Node<{
    [K in keyof Nodes]: Nodes[K] extends Node<infer Data> ? Data : never;
}>;
declare function equals<Data>(left: Node<Data>, right: Node<Data>): Node<Bool>;
declare function equalsOneOf<Data>(input: Node<Data>, options: Node<Data>[] | Node<Data[]> | Node<DynamicArray<Data>>): Node<Bool>;
declare function lessThan<Left extends Numeric, Right extends Numeric>(left: Node<Left>, right: Node<Right>): Node<Bool>;
declare function lessThanEq<Left extends Numeric, Right extends Numeric>(left: Node<Left>, right: Node<Right>): Node<Bool>;
declare function add<Left extends Numeric, Right extends Numeric>(left: Node<Left>, right: Node<Right>): Node<NumericMaximum<Left | Right>>;
declare function sub<Left extends Numeric, Right extends Numeric>(left: Node<Left>, right: Node<Right>): Node<NumericMaximum<Left | Right>>;
declare function mul<Left extends Numeric, Right extends Numeric>(left: Node<Left>, right: Node<Right>): Node<NumericMaximum<Left | Right>>;
declare function div<Left extends Numeric, Right extends Numeric>(left: Node<Left>, right: Node<Right>): Node<NumericMaximum<Left | Right>>;
declare function and(...inputs: Node<Bool>[]): Node<Bool>;
declare function or(left: Node<Bool>, right: Node<Bool>): Node<Bool>;
declare function not(inner: Node<Bool>): Node<Bool>;
declare function hash(...inputs: Node[]): Node<Field>;
declare function hashWithPrefix(prefix: string, ...inputs: Node[]): Node<Field>;
declare function ifThenElse<Data>(condition: Node<Bool>, thenNode: Node<Data>, elseNode: Node<Data>): Node<Data>;
declare function compute<Inputs extends readonly Node[], Output>(inputs: [...Inputs], outputType: ProvableType<Output>, computation: (...args: {
    [K in keyof Inputs]: Inputs[K] extends Node<infer T> ? T : never;
}) => Output): Node<Output>;
declare function issuer(credential: CredentialNode): Node<Field>;
declare function issuerPublicKey({ credentialType, credentialKey, }: CredentialNode<any, NativeWitness>): Node<PublicKey>;
declare function verificationKeyHash({ credentialType, credentialKey, }: CredentialNode<any, ImportedWitness>): Node<Field>;
declare function publicInput<Input>({ credentialType, credentialKey, }: CredentialNode<any, ImportedWitness<Input>>): Node<Input>;
type WitnessAny = NativeWitness | ImportedWitness | undefined;