@meshsdk/midnight-setup/dist/index.d.ts

Midnight Network integration SDK for MeshSDK - https://meshjs.dev/midnight

import { ContractAddress } from '@midnight-ntwrk/compact-runtime';
import { Logger } from 'pino';
import { Observable } from 'rxjs';
import { PrivateStateProvider, ZKConfigProvider, ProofProvider, PublicDataProvider, WalletProvider, MidnightProvider } from '@midnight-ntwrk/midnight-js-types';

declare const MidnightSetupPrivateStateId = "midnight-setup-private-state";
type MidnightSetupPrivateStateId = typeof MidnightSetupPrivateStateId;
type TokenCircuitKeys = string;
interface MidnightSetupContractProviders {
    privateStateProvider: PrivateStateProvider;
    zkConfigProvider: ZKConfigProvider<TokenCircuitKeys>;
    proofProvider: ProofProvider<TokenCircuitKeys>;
    publicDataProvider: PublicDataProvider;
    walletProvider: WalletProvider;
    midnightProvider: MidnightProvider;
}
interface DeployedContract {
    deployTxData: {
        public: {
            contractAddress: string;
        };
    };
}
type ContractInstance = any;
interface QueryContractState {
    data: unknown;
    blockHeight?: number | bigint;
    blockHash?: string | Uint8Array;
}
interface ContractStateData {
    readonly address: string;
    readonly data: unknown;
    readonly blockHeight?: string;
    readonly blockHash?: string;
    readonly message?: string;
    readonly error?: string;
}
interface LedgerStateData {
    readonly address: string;
    readonly ledgerState?: {
        readonly message: string | null;
    };
    readonly blockHeight?: string;
    readonly blockHash?: string;
    readonly rawData?: unknown;
    readonly parseError?: string;
    readonly error?: string;
}
type DerivedMidnightSetupContractState = {
    readonly protocolTVL: unknown[];
    readonly projects: unknown[];
};

declare const randomNonceBytes: (length: number, logger?: Logger) => Uint8Array;
declare function hexStringToUint8Array(hexStr: string): Uint8Array;
declare const _default: {
    randomNonceBytes: (length: number, logger?: Logger) => Uint8Array;
    hexStringToUint8Array: typeof hexStringToUint8Array;
};

declare const utils_hexStringToUint8Array: typeof hexStringToUint8Array;
declare const utils_randomNonceBytes: typeof randomNonceBytes;
declare namespace utils {
  export { _default as default, utils_hexStringToUint8Array as hexStringToUint8Array, utils_randomNonceBytes as randomNonceBytes };
}

interface DeployedMidnightSetupAPI {
    readonly deployedContractAddress: ContractAddress;
    readonly state: Observable<DerivedMidnightSetupContractState>;
    getContractState: () => Promise<ContractStateData>;
    getLedgerState: () => Promise<LedgerStateData>;
}
declare class MidnightSetupAPI implements DeployedMidnightSetupAPI {
    private providers;
    readonly deployedContract: DeployedContract;
    private logger?;
    deployedContractAddress: string;
    state: Observable<DerivedMidnightSetupContractState>;
    private constructor();
    getContractState(): Promise<ContractStateData>;
    getLedgerState(): Promise<LedgerStateData>;
    static deployContract(providers: MidnightSetupContractProviders, contractInstance: ContractInstance, logger?: Logger): Promise<MidnightSetupAPI>;
    static joinContract(providers: MidnightSetupContractProviders, contractInstance: ContractInstance, contractAddress: string, logger?: Logger): Promise<MidnightSetupAPI>;
    private static getPrivateState;
}

export { type ContractInstance, type ContractStateData, type DeployedContract, type DeployedMidnightSetupAPI, type DerivedMidnightSetupContractState, type LedgerStateData, MidnightSetupAPI, type MidnightSetupContractProviders, MidnightSetupPrivateStateId, type QueryContractState, type TokenCircuitKeys, utils };