jadets/dist/index.d.mts

jade impl in typescript

import EventEmitter, { EventEmitter as EventEmitter$1 } from 'events';

interface RPCRequest {
    id: string;
    method: string;
    params?: any;
}
interface ExtendedDataResponse {
    seqnum: number;
    seqlen: number;
    data?: any;
}
interface RPCResponse {
    id: string;
    result?: any;
    error?: {
        code: number;
        message: string;
        data?: any;
    };
    seqnum?: number;
    seqlen?: number;
}
interface SerialPortOptions {
    device?: string;
    baudRate?: number;
    timeout?: number;
    bufferSize?: number;
}
interface JadeTransport extends EventEmitter {
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    sendMessage(msg: any): Promise<void>;
    onMessage(callback: (msg: any) => void): void;
}
interface IJadeInterface {
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    buildRequest(id: string, method: string, params?: any): RPCRequest;
    makeRPCCall(request: RPCRequest, long_timeout: boolean): Promise<RPCResponse>;
}
interface IJade {
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    cleanReset(): Promise<boolean>;
    ping(): Promise<0 | 1 | 2>;
    getVersionInfo(nonblocking?: boolean): Promise<any>;
    setMnemonic(mnemonic: string, passphrase?: string, temporaryWallet?: boolean): Promise<boolean>;
    authUser(network: string, http_request_fn?: (params: any) => Promise<{
        body: any;
    }>, epoch?: number): Promise<boolean>;
    addEntropy(entropy: Uint8Array): Promise<boolean>;
    setEpoch(epoch?: number): Promise<boolean>;
    logout(): Promise<boolean>;
    getXpub(network: string, path: number[]): Promise<string>;
    registerMultisig(network: string, multisigName: string | undefined, descriptor: MultisigDescriptor): Promise<boolean>;
    getMultiSigName(network: string, target: MultisigDescriptor): Promise<string | undefined>;
    getRegisteredMultisigs(): Promise<Record<string, MultisigSummary>>;
    getRegisteredMultisig(name: string, asFile?: boolean): Promise<RegisteredMultisig>;
    getReceiveAddress(network: string, options?: ReceiveOptions): Promise<string>;
    signMessage(path: number[], message: string, useAeSignatures?: boolean, aeHostCommitment?: Uint8Array, aeHostEntropy?: Uint8Array): Promise<Uint8Array | [Uint8Array, Uint8Array]>;
    signPSBT(network: string, psbt: Uint8Array): Promise<Uint8Array>;
    getMasterFingerPrint(network: string): Promise<null | string>;
}
type MultisigVariant = "sh(multi(k))" | "wsh(multi(k))" | "sh(wsh(multi(k)))" | string;
interface MultisigDescriptor {
    variant: MultisigVariant;
    sorted: boolean;
    threshold: number;
    signers: SignerDescriptor[];
    master_blinding_key?: Uint8Array;
}
interface RegisterMultisigParams {
    network: string;
    multisig_name: string;
    descriptor: MultisigDescriptor;
}
interface SignerDescriptor {
    fingerprint: Uint8Array;
    derivation: number[];
    xpub: string;
    path?: number[];
}
interface MultisigSummary {
    variant: string;
    sorted: boolean;
    threshold: number;
    num_signers: number;
    masterBlindingKey: Uint8Array;
}
interface RegisteredMultisig {
    network: string;
    descriptor: {
        variant: string;
        sorted: boolean;
        threshold: number;
        signers: SignerDescriptor[];
        masterBlindingKey?: Uint8Array;
    };
}
interface ReceiveOptions {
    path?: number[];
    paths?: number[][];
    multisigName?: string;
    descriptorName?: string;
    variant?: string;
    recoveryXpub?: Uint8Array;
    csvBlocks?: number;
    confidential?: boolean;
}
interface TestXpub {
    path: number[];
    network: 'mainnet' | 'testnet' | string;
    xpub: string;
    fingerprint: string;
}
interface TestMessage {
    path: number[];
    message: string;
    use_ae_signatures: boolean;
    output: string;
}
interface TestPSBT {
    network: string;
    psbt: Uint8Array;
    output: Uint8Array;
}
interface SignPsbtCase {
    description: string;
    input: {
        network: string;
        psbt: string;
    };
    expected_output: {
        psbt: string;
    };
}

declare class SerialTransport extends EventEmitter$1 implements JadeTransport {
    private options;
    private port;
    private reader;
    private receivedBuffer;
    constructor(options: SerialPortOptions);
    drain(): void;
    connect(): Promise<void>;
    private readLoop;
    private processReceivedData;
    private concatBuffers;
    disconnect(): Promise<void>;
    sendMessage(message: any): Promise<void>;
    onMessage(callback: (message: any) => void): void;
}

declare class TCPTransport extends EventEmitter$1 implements JadeTransport {
    private host;
    private port;
    private socket;
    private recvBuffer;
    constructor(host: string, port: number);
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    sendMessage(msg: any): Promise<void>;
    onMessage(callback: (msg: any) => void): void;
    private onData;
}

declare class JadeInterface implements IJadeInterface {
    private transport;
    constructor(transport: JadeTransport);
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    buildRequest(id: string, method: string, params?: any): RPCRequest;
    /**
     * Makes an RPC call and handles extended data responses automatically
     */
    makeRPCCall(request: RPCRequest, long_timeout?: boolean): Promise<RPCResponse>;
    /**
     * Waits for a single response message
     */
    private waitForResponse;
    /**
     * Checks if a response indicates extended data
     */
    private isExtendedDataResponse;
    /**
     * Handles extended data responses by collecting all chunks
     */
    private handleExtendedDataResponse;
    /**
     * Reassembles chunks into a complete response
     */
    private reassembleExtendedData;
    private mergeChunkData;
}

declare class Jade implements IJade {
    private iface;
    constructor(iface: IJadeInterface);
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    private _jadeRpc;
    cleanReset(): Promise<boolean>;
    ping(): Promise<0 | 1 | 2>;
    getVersionInfo(nonblocking?: boolean): Promise<any>;
    setMnemonic(mnemonic: string, passphrase?: string, temporaryWallet?: boolean): Promise<boolean>;
    authUser(network: string, http_request_fn?: (params: any) => Promise<{
        body: any;
    }>, epoch?: number): Promise<boolean>;
    addEntropy(entropy: Uint8Array): Promise<boolean>;
    logout(): Promise<boolean>;
    getXpub(network: string, path: number[]): Promise<string>;
    setEpoch(epoch?: number): Promise<boolean>;
    registerMultisig(network: string, multisigName: string | undefined, descriptor: MultisigDescriptor): Promise<boolean>;
    getRegisteredMultisigs(): Promise<Record<string, MultisigSummary>>;
    getMultiSigName(network: string, target: MultisigDescriptor): Promise<string | undefined>;
    getRegisteredMultisig(name: string, asFile?: boolean): Promise<RegisteredMultisig>;
    getReceiveAddress(network: string, opts: ReceiveOptions): Promise<string>;
    signMessage(path: number[], message: string, useAeSignatures?: boolean, aeHostCommitment?: Uint8Array, aeHostEntropy?: Uint8Array): Promise<Uint8Array | [Uint8Array, Uint8Array]>;
    signPSBT(network: string, psbt: Uint8Array): Promise<Uint8Array>;
    getMasterFingerPrint(network: string): Promise<null | string>;
}

declare function getFingerprintFromXpub(xpub: string, networkType: string): string | null;

declare function hexToBytes(hex: string): Uint8Array;

declare function base64ToBytes(b64: string): Uint8Array;

declare function bytesToBase64(bytes: Uint8Array): string;

export { type ExtendedDataResponse, type IJade, type IJadeInterface, Jade, JadeInterface, type JadeTransport, type MultisigDescriptor, type MultisigSummary, type MultisigVariant, type RPCRequest, type RPCResponse, type ReceiveOptions, type RegisterMultisigParams, type RegisteredMultisig, type SerialPortOptions, SerialTransport, type SignPsbtCase, type SignerDescriptor, TCPTransport, type TestMessage, type TestPSBT, type TestXpub, base64ToBytes, bytesToBase64, getFingerprintFromXpub, hexToBytes };