wowok/dist/passport.d.ts

Create, collaborate, and transact on your own terms with the AI-driven web3 collaboration protocol.

import { type TransactionObjectInput, Transaction as TransactionBlock, TransactionResult } from '@mysten/sui/transactions';
import { FnCallType, Protocol, ValueType, WitnessType, MODULES } from './protocol.js';
export type Guard_Query_Object = {
    target: FnCallType;
    object: TransactionObjectInput | string;
    types: string[];
    id: string;
};
interface GuardInfo {
    id: string;
    digest?: string;
    version?: string | number;
    input: DeGuardInput[];
    constant: DeGuardConstant[];
}
export interface WitnessCmd {
    witness?: WitnessType;
    cmd: number;
    witness_object?: string;
}
export type WitnessObjectInfo = {
    module: MODULES;
} | {
    module: MODULES;
    type: string;
} | {
    module: MODULES;
    type: string;
    order: string;
    order_type: string;
};
export interface DeGuardConstant {
    type: number;
    value: any;
    bWitness: boolean;
    identifier: number;
    cmd: WitnessCmd[];
    witness: WitnessType[];
    info?: WitnessObjectInfo;
}
export interface DeGuardInput {
    type: number;
    value?: any;
    identifier?: number;
    cmd?: number;
}
export interface DeGuardData extends DeGuardInput {
    child: DeGuardData[];
    ret_type?: number;
}
export interface WitnessFill {
    guard: string;
    witness?: any;
    cmd: WitnessCmd[];
    witnessTypes: WitnessType[];
    cited: number;
    type: ValueType;
    identifier: number;
    module?: MODULES;
    witness_module?: MODULES;
}
export interface PassportQuery {
    query: Guard_Query_Object[];
    info: GuardInfo[];
    witnessObjectInfo?: Map<string, WitnessObjectInfo>;
}
export declare class GuardParser {
    protected guard_list: GuardInfo[];
    protected guards: string[];
    private constructor();
    guardlist: () => GuardInfo[];
    static DeGuardObject_FromData: (guard_constants: any, guard_input_bytes: any) => {
        object: DeGuardData;
        constant: DeGuardConstant[];
    };
    static DeGuardObject: (protocol: Protocol, guard: string) => Promise<{
        object: DeGuardData;
        constant: DeGuardConstant[];
    }>;
    static ResolveData: (constants: DeGuardConstant[], stack: DeGuardData[], current: DeGuardData) => void;
    private static Parse_Guard_Helper;
    static Create: (guards: string[]) => Promise<GuardParser | undefined>;
    static RepositoryGuards: (repositories: string[]) => Promise<string[]>;
    future_fills: () => WitnessFill[];
    static parse_constant: (constants: any) => DeGuardConstant[];
    static ConstantWitnessModule(constant: DeGuardConstant): {
        module: MODULES | undefined;
        witness_module: MODULES | undefined;
    };
    static AddConstantWitness(constants: DeGuardConstant[], identifier: number, type: WitnessType): void;
    static AddConstantCmd(constants: DeGuardConstant[], identifier: number, cmd: WitnessCmd): void;
    static parse_bcs: (constants: DeGuardConstant[], chain_bytes: Uint8Array) => DeGuardInput[];
    private fetch_witness;
    done: (fill?: WitnessFill[], onPassportQueryReady?: (passport: PassportQuery | undefined) => void) => Promise<PassportQuery | undefined>;
    private done_helper;
    private object_query;
    static MAX_REPOSITORY_DEPTH: number;
}
export declare class Passport {
    static MAX_GUARD_COUNT: number;
    protected passport: TransactionResult;
    protected txb: TransactionBlock;
    get_object(): TransactionResult;
    constructor(txb: TransactionBlock, query: PassportQuery);
    destroy(): void;
    freeze(): void;
    query_result(sender: string, handleResult: OnQueryPassportResult): void;
    query_result_async: (sender: string) => Promise<QueryPassportResult | undefined>;
    private static ResolveQueryRes;
}
export interface QueryPassportResult {
    txb: TransactionBlock;
    result: boolean;
    guards: string[];
}
export type OnQueryPassportResult = (result: QueryPassportResult) => void;
export {};
//# sourceMappingURL=passport.d.ts.map