wowok/dist/cjs/w/messenger/types.d.ts

Wowok Blockchain TypeScript API

import { ENTRYPOINT } from "../../client/network.js";
import type { SignatureScheme } from "../../cryptography/signature-scheme.js";
import type { AccountOrMark_Address } from "../local/index.js";
export declare enum MessageType {
    PREKEY_MESSAGE = 3,
    NORMAL_MESSAGE = 1
}
export declare enum MessageDirection {
    SENT = "sent",
    RECEIVED = "received"
}
export declare enum MessageStatus {
    PENDING = "pending",
    CONFIRMED = "confirmed",
    READ = "read",
    FAILED = "failed",
    REJECTED = "rejected",
    DECRYPTED = "decrypted",
    DECRYPT_FAILED = "decrypt_failed"
}
export interface PlaintextMessage {
    content: string;
    lastReceivedLeafIndex: number;
    createdAt: number;
    guardAddress?: string;
    passportAddress?: string;
}
export interface Message {
    messageId: string;
    fromAddress: string;
    toAddress: string;
    plaintextHash: string;
    plaintext?: string;
    guardAddress?: string;
    passportAddress?: string;
    lastReceivedLeafIndex?: number;
    direction: MessageDirection;
    status: MessageStatus;
    msgType: MessageType.PREKEY_MESSAGE | MessageType.NORMAL_MESSAGE;
    leafIndex?: number;
    prevRoot?: string;
    newRoot?: string;
    serverSignature?: string;
    serverTimestamp?: number;
    serverPublicKey?: string;
    arkConfirmed?: {
        recipient: string;
        recipientPublicKey: string;
        signature: string;
        timestamp: number;
    };
    createdAt: number;
    receivedAt?: number;
    zipMetadata?: ZipMetadata;
    proof?: string;
    decryptError?: string;
    decryptAttempts?: number;
    lastDecryptAttemptAt?: number;
    viewedAt?: number;
}
export type ZipContentType = "wts" | "wip" | "zip";
export interface ZipMetadata {
    fileName: string;
    fileSize: number;
    fileHash: string;
    contentType: ZipContentType;
    localCachePath?: string;
    downloadedAt?: number;
}
export interface MerkleProof {
    root: string;
    leafIndex: number;
    siblings: string[];
    indices: number[];
}
export interface MerkleMetadata {
    leafIndex: number;
    leafHash: string;
    newRoot: string;
    proofSiblings: string[];
    proofIndices: number[];
    prevRoot: string;
    serverTimestamp: number;
    serverSignature?: string;
    serverPublicKey?: string;
}
export interface SessionState {
    sessionId: string;
    myAddress: string;
    peerAddress: string;
    currentRoot: string;
    prevRoot: string;
    messageCount: number;
    lastLeafIndex: number;
    lastConfirmedHash: string;
    lastSyncAt: number;
    createdAt: number;
    updatedAt: number;
}
export interface ServerRegisterRequest {
    userAddress: string;
    deviceId: number;
    registrationId: number;
    identityKey: string;
    falcon512PublicKey?: string;
    x25519BindingSignature?: string;
    prekeys: PreKeyPublic[];
    pqPrekey?: PQPreKeyPublic;
    publicKey: string;
    signatureScheme: SignatureScheme;
    signature: string;
    timestamp: number;
    nonce: string;
}
export interface PQPreKeyPublic {
    keyId: number;
    publicKey: string;
    signature: string;
}
export interface PreKeyPublic {
    keyId: number;
    publicKey: string;
    signature: string;
}
export interface ServerRegisterResponse {
    success: boolean;
    uploadedCount: number;
    failedPrekeys: FailedPrekeyInfo[];
    currentTotal: number;
    maxAllowed: number;
}
export interface FailedPrekeyInfo {
    keyId: number;
    reason: string;
}
export interface UploadPreKeysRequest {
    userAddress: string;
    prekeys: PreKeyPublic[];
    publicKey: string;
    signatureScheme: SignatureScheme;
    signature: string;
    timestamp: number;
    nonce: string;
}
export interface UploadPreKeysResponse {
    success: boolean;
    uploadedCount: number;
    failedPrekeys: FailedPrekeyInfo[];
    currentTotal: number;
    maxAllowed: number;
}
export interface RemoteBundle {
    registrationId: number;
    identityKey: string;
    falcon512PublicKey?: string;
    x25519BindingSignature?: string;
    signedPrekey?: {
        keyId: number;
        publicKey: string;
        signature: string;
    };
    oneTimePrekey?: {
        keyId: number;
        publicKey: string;
        signature: string;
    };
    pqPreKey?: {
        keyId: number;
        publicKey: string;
        signature: string;
    };
}
export interface SendMessageRequest {
    sender: string;
    recipient: string;
    ciphertext: string;
    plaintextHash: string;
    clientTimestamp: number;
    msgType: MessageType.PREKEY_MESSAGE | MessageType.NORMAL_MESSAGE;
    zipMetadata?: ZipMetadata;
    guardAddress?: string;
    passportAddress?: string;
    lastReceivedLeafIndex?: number;
    signatureScheme?: SignatureScheme;
    signature?: string;
    timestamp?: number;
    nonce?: string;
    force?: boolean;
}
export interface SendMessageResponse {
    messageId: string;
    status: "confirmed" | "pending";
    merkleData?: {
        leafIndex: number;
        leafHash: string;
        prevRoot: string;
        newRoot: string;
        serverSignature: string;
        serverTimestamp: number;
        serverPublicKey: string;
    };
    pendingMerkleData?: Record<string, {
        leafIndex: number;
        leafHash: string;
        prevRoot: string;
        newRoot: string;
        serverSignature: string;
        serverTimestamp: number;
        serverPublicKey: string;
    }>;
}
export interface PullMessagesResponse {
    messages: ServerMessage[];
    total?: number;
    prekey_status?: PreKeyStatus;
}
export interface PreKeyStatus {
    currentCount: number;
    maxAllowed: number;
    threshold: number;
    shouldRefill: boolean;
    needs_replenishment?: boolean;
}
export interface ServerMessage {
    id: string;
    from: string;
    to: string;
    bodyB64: string;
    plaintextHash?: string;
    clientTimestamp?: number;
    msgType: number;
    registrationId?: number;
    merkleMetadata?: MerkleMetadata;
    zipMetadata?: ZipMetadata;
    guardAddress?: string;
    passportAddress?: string;
    verificationStatus?: string;
    lastReceivedLeafIndex?: number;
}
export interface ChainProofRequest {
    merkleRoot: string;
    sessionId: string;
    messageCount: number;
}
export interface ChainProofResponse {
    proofAddress: string;
    txHash: string;
    blockHeight: number;
    blockTimestamp: number;
}
export declare const WTS_FILE_BYTES_LIMIT: number;
export declare const WTS_MAX_MESSAGE_COUNT = 500;
export declare const NORMAL_MESSAGE_BYTES_LIMIT: number;
export declare const DEFAULT_QUERY_LIMIT = 50;
export declare const MAX_QUERY_LIMIT = 1000;
export declare const DEFAULT_DEVICE_ID = 1;
export declare const SERVER_URL = "https://messenger.wowok.net";
export declare const CHAIN_PROOF_TYPE = 1;
export declare const CURRENT_NETWORK = ENTRYPOINT.Testnet;
export interface MessengerConfig {
    prekey_count: number;
    watch_interval_ms: number;
    serverUrl?: string;
    network?: ENTRYPOINT;
    prekeyCheckIntervalMs?: number;
    defaultQueryLimit?: number;
    message_poll_default_interval_ms?: number;
    message_poll_fast_interval_ms?: number;
    prekey_poll_default_interval_ms?: number;
    prekey_poll_fast_interval_ms?: number;
    account_poll_delay_ms?: number;
    message_poll_consecutive_empty_limit?: number;
    prekey_poll_consecutive_ok_limit?: number;
    message_poll_waiting_interval_ms?: number;
}
export declare const DEFAULT_MESSENGER_CONFIG: MessengerConfig;
export interface SignedRequestBase {
    publicKey: string;
    signatureScheme: SignatureScheme;
    signature: string;
    timestamp: number;
    nonce: string;
}
export interface FetchMessagesRequest extends SignedRequestBase {
    limit?: number;
}
export interface EventStreamParams extends SignedRequestBase {
}
export interface GetBundleParams extends SignedRequestBase {
}
export type SseEventType = "NewMessage" | "PreKeyLow" | "Custom" | "ark_confirmed" | "guard_confirmed" | "guard_rejected";
export interface SseNewMessageEvent {
    type: "NewMessage";
}
export interface SseArkConfirmedEvent {
    type: "ark_confirmed";
    data: {
        message_ids: string[];
        recipient: string;
        recipient_public_key: string;
        signature: string;
        timestamp: number;
    };
}
export interface SsePreKeyLowEvent {
    type: "PreKeyLow";
    data: {
        current: number;
        threshold: number;
        max_allowed: number;
    };
}
export interface SseCustomEvent {
    type: "Custom";
    data: string;
}
export interface SseGuardConfirmedEvent {
    type: "guard_confirmed";
    data: {
        message_id: string;
        merkle_data: {
            leafIndex: number;
            leafHash: string;
            prevRoot: string;
            newRoot: string;
            serverSignature: string;
            serverTimestamp: number;
            serverPublicKey: string;
        };
        timestamp: number;
    };
}
export interface SseGuardRejectedEvent {
    type: "guard_rejected";
    data: {
        message_id: string;
        reason: string;
        timestamp: number;
    };
}
export type SseEvent = SseNewMessageEvent | SseArkConfirmedEvent | SsePreKeyLowEvent | SseCustomEvent | SseGuardConfirmedEvent | SseGuardRejectedEvent;
export interface SendMessageResult {
    messageId: string;
    status: MessageStatus;
    merkleData?: {
        leafIndex: number;
        prevRoot: string;
        newRoot: string;
        serverSignature: string;
        serverTimestamp: number;
        serverPublicKey: string;
    };
    guardList?: string[];
    lastReceivedLeafIndex?: number;
}
export interface DecryptedMessage {
    id: string;
    from: string;
    plaintext: string;
    timestamp: number;
    merkleVerified: boolean;
    merkleData?: {
        leafIndex: number;
        rootHash: string;
    };
}
export interface Empty {
}
export interface SignedRequest<T> {
    userAddress: string;
    publicKey: string;
    signatureScheme: SignatureScheme;
    signature: string;
    timestamp: number;
    nonce: string;
    data: T;
}
export declare enum MessengerErrorCode {
    PREKEYS_FULL = "PREKEYS_FULL",
    ACCOUNT_NOT_FOUND = "ACCOUNT_NOT_FOUND",
    IDENTITY_NOT_FOUND = "IDENTITY_NOT_FOUND",
    IDENTITY_CONFLICT = "IDENTITY_CONFLICT",
    SESSION_NOT_ESTABLISHED = "SESSION_NOT_ESTABLISHED",
    ENCRYPTION_FAILED = "ENCRYPTION_FAILED",
    DECRYPTION_FAILED = "DECRYPTION_FAILED",
    SERVER_ERROR = "SERVER_ERROR",
    INVALID_PROOF = "INVALID_PROOF",
    NETWORK_ERROR = "NETWORK_ERROR",
    INVALID_INPUT = "INVALID_INPUT",
    FILE_NOT_FOUND = "FILE_NOT_FOUND",
    INVALID_MESSAGE_TYPE = "INVALID_MESSAGE_TYPE",
    MESSAGE_NOT_DECRYPTED = "MESSAGE_NOT_DECRYPTED",
    HASH_MISMATCH = "HASH_MISMATCH",
    ACCOUNT_MESSENGER_NOT_ENABLED = "ACCOUNT_MESSENGER_NOT_ENABLED",
    REGISTRATION_FAILED = "REGISTRATION_FAILED"
}
export type MessageTimeField = "createdAt" | "receivedAt" | "serverTimestamp";
export type MessageContentType = "text" | "zip" | "wts" | "wip";
export interface MessageFilter {
    account?: string;
    direction?: MessageDirection;
    status?: MessageStatus;
    peerAddress?: AccountOrMark_Address;
    msgType?: MessageType;
    contentType?: MessageContentType;
    decryptedOnly?: boolean;
    confirmedOnly?: boolean;
    keyword?: string;
    sortOrder?: "asc" | "desc";
    limit?: number;
    offset?: number;
    timeField?: MessageTimeField;
    startTime?: number;
    endTime?: number;
    createdAtStart?: number;
    createdAtEnd?: number;
    receivedAtStart?: number;
    receivedAtEnd?: number;
    serverTimestampStart?: number;
    serverTimestampEnd?: number;
    arkConfirmedOnly?: boolean;
    arkTimestampStart?: number;
    arkTimestampEnd?: number;
    proofedOnly?: boolean;
    hasLastReceivedIndexOnly?: boolean;
    lastReceivedIndexMin?: number;
    lastReceivedIndexMax?: number;
    listFilterMode?: "friends" | "guard" | "stranger" | "any";
    customListFilter?: {
        includeAddresses?: string[];
        excludeAddresses?: string[];
        relation?: "union" | "intersection";
    };
    viewed?: boolean;
    viewedAtStart?: number;
    viewedAtEnd?: number;
    skipAutoMarkViewed?: boolean;
}
export declare class MessengerError extends Error {
    code: MessengerErrorCode;
    cause?: Error;
    constructor(code: MessengerErrorCode, message: string, cause?: Error);
}
export interface GuardListItem {
    guardAddress: string;
    passportValiditySeconds: number;
}
export interface ContactLists {
    friends: string[];
    guards: GuardListItem[];
    lastUpdatedAt: number;
}
export interface ContactListsSyncResult {
    success: boolean;
    friends: string[];
    guards: GuardListItem[];
    error?: string;
}
export interface MessageListResult {
    messages: Message[];
    total: number;
    offset: number;
    limit: number;
}
export interface ConversationInfo {
    peerAddress: string;
    lastMessageAt: number;
    messageCount: number;
    unreadCount: number;
    lastMessagePreview?: string;
    previewMessages?: Message[];
}
export interface ConversationsFilter {
    account?: string;
    unreadOnly?: boolean;
    startTime?: number;
    endTime?: number;
    previewMessageCount?: number;
    sortBy?: "lastMessageAt" | "unreadCount" | "messageCount";
    sortOrder?: "asc" | "desc";
    skipAutoMarkViewed?: boolean;
}
export type RangeType = "time" | "messageId" | "seqIndex";
export interface BaseRange {
    type: RangeType;
    start: number | string;
    end: number | string;
}
export interface TimeRange extends BaseRange {
    type: "time";
    start: number;
    end: number;
}
export interface MessageIdRange extends BaseRange {
    type: "messageId";
    start: string;
    end: string;
}
export interface SeqIndexRange extends BaseRange {
    type: "seqIndex";
    start: number;
    end: number;
}
export type WtsRange = TimeRange | MessageIdRange | SeqIndexRange;
export interface WtsGenerationParams {
    myAccount: string;
    peerAccount: AccountOrMark_Address;
    range?: WtsRange;
    excludePlaintext?: boolean;
    outputDir: string;
}
export interface WtsFileResult {
    files: string[];
    totalMessageCount: number;
    timeRange: {
        start: number;
        end: number;
    };
}
export declare const WTS_SCHEMA_URL = "https://github.com/wowok-ai/docs/blob/main/WTS.md";
export interface WtsSession {
    id: string;
    participants: string[];
}
export interface WtsMessage {
    id: string;
    from: string;
    to: string;
    plaintext?: string;
    plaintextHash: string;
    clientTimestamp: number;
    timestamp: number;
    leafIndex: number;
    prevRoot: string;
    merkleRoot: string;
    serverSignature: string;
    serverPublicKeyIndex: number;
    guardAddress?: string;
    passportAddress?: string;
    lastReceivedLeafIndex?: number;
    arkConfirmed?: {
        recipient: string;
        recipientPublicKey: string;
        signature: string;
        timestamp: number;
    };
    msgType?: MessageType;
    zipMetadata?: ZipMetadata;
}
export interface WtsPayload {
    session: WtsSession;
    messages: WtsMessage[];
}
export interface WtsSignature {
    value: string;
    publicKey: string;
    algorithm: "Falcon512";
    address?: string;
}
export interface WtsServerPublicKey {
    publicKey: string;
    keyId?: string;
    validFrom: number;
    validUntil?: number;
    algorithm?: string;
}
export interface WtsMeta {
    type: "wts";
    version: string;
    created: string;
    hash: string;
    algorithm: "sha256";
    startTime: number;
    endTime: number;
    messageCount: number;
    merkleRoot: string;
    creator: string;
    participant: string;
    serverPublicKeys?: WtsServerPublicKey[];
    signature?: WtsSignature | WtsSignature[];
}
export interface WtsFile {
    wts: string;
    payload: WtsPayload;
    meta: WtsMeta;
}
export interface WtsSignatureVerification {
    publicKey: string;
    address?: string;
    valid: boolean;
}
export interface WtsVerificationResult {
    valid: boolean;
    error?: string;
    hashValid?: boolean;
    hasSignature?: boolean;
    signatureValid?: boolean;
    signatures?: WtsSignatureVerification[];
}
export interface WtsToHtmlOptions {
    title?: string;
    theme?: "light" | "dark";
    outputPath?: string;
}
export interface AddListRequest {
    addresses: string[];
}
export interface AddGuardListRequest {
    guards: GuardListItem[];
}
export interface RemoveListRequest {
    addresses: string[];
}
export interface ClearListRequest {
}
export interface ExistListRequest {
    addresses: string[];
}
export interface AddressExistence {
    address: string;
    exists: boolean;
}
export interface ListOperationResponse {
    success: boolean;
    operation: string;
    modifiedCount: number;
    currentCount: number;
    maxCount: number;
    invalidAddresses?: string[];
    existResults?: AddressExistence[];
    message?: string;
    currentList?: string[];
    currentGuardList?: GuardListItem[];
}
export interface UpdateSettingsRequest extends SignedRequestBase {
    allowStrangerMessages?: boolean;
    maxInboxSize?: number;
}
export interface GetSettingsRequest extends SignedRequestBase {
}
export interface GetSettingsResponse {
    allowStrangerMessages?: boolean;
    maxInboxSize?: number;
    minUserInboxSize: number;
    maxUserInboxSize: number;
    defaultAllowStrangerMessages: boolean;
}