lotus-sdk/dist/lib/p2p/swapsig/types.d.ts

Central repository for several classes of tools for integrating with, and building for, the Lotusia ecosystem

import type { PublicKey } from '../../bitcore/publickey.js';
import type { Address } from '../../bitcore/address.js';
import type { Script } from '../../bitcore/script.js';
import type { Transaction } from '../../bitcore/transaction/index.js';
export declare enum SwapPhase {
    DISCOVERY = "discovery",
    REGISTRATION = "registration",
    SETUP = "setup",
    SETUP_CONFIRM = "setup-confirm",
    REVEAL = "reveal",
    SETTLEMENT = "settlement",
    SETTLEMENT_CONFIRM = "settlement-confirm",
    COMPLETE = "complete",
    ABORTED = "aborted"
}
export interface SwapSigSigningMetadata {
    transactionType: 'swap';
    swapPhase: SwapPhase.SETTLEMENT;
    swapPoolId: string;
    outputIndex?: number;
    transactionHex?: string;
    taprootKeyPath?: boolean;
    [key: string]: unknown;
}
export interface GroupSizeStrategy {
    groupSize: number;
    groupCount: number;
    anonymityPerGroup: number;
    reasoning: string;
    recommendedRounds: number;
}
export interface BurnConfig {
    burnPercentage: number;
    minimumBurn: number;
    maximumBurn: number;
    burnIdentifier: string;
    poolIdInBurn: boolean;
    version: number;
}
export declare const DEFAULT_BURN_CONFIG: BurnConfig;
export interface ParticipantInput {
    txId: string;
    outputIndex: number;
    amount: number;
    script: Script;
    address: Address;
}
export interface SwapParticipant {
    peerId: string;
    participantIndex: number;
    publicKey: PublicKey;
    input: ParticipantInput;
    ownershipProof: Buffer;
    finalOutputEncrypted: Buffer;
    finalOutputCommitment: Buffer;
    finalAddress?: Address;
    setupTxId?: string;
    setupConfirmed: boolean;
    joinedAt: number;
}
export interface SharedOutput {
    signers: PublicKey[];
    participantIndices?: number[];
    aggregatedKey: PublicKey;
    taprootAddress: Address;
    amount: number;
    txId?: string;
    outputIndex: number;
    confirmed?: boolean;
    receiverIndex?: number;
    receiverAddress?: Address;
    settlementTxId?: string;
    settlementConfirmed?: boolean;
}
export interface SettlementInfo {
    receiverIndex: number;
    sourceOutputIndex: number;
    sourceOutput: SharedOutput;
    finalDestination: Address;
    requestId?: string;
    sessionId?: string;
    signers: PublicKey[];
    transaction?: Transaction;
    txId?: string;
    confirmed: boolean;
}
export interface SwapPool {
    poolId: string;
    creatorPeerId: string;
    denomination: number;
    minParticipants: number;
    maxParticipants: number;
    feeRate: number;
    feePerParticipant: number;
    burnConfig: BurnConfig;
    groupSizeStrategy?: GroupSizeStrategy;
    participants: SwapParticipant[];
    participantMap: Map<string, SwapParticipant>;
    outputGroups: number[][];
    sharedOutputs: SharedOutput[];
    settlementMapping: Map<number, SettlementInfo>;
    setupTransactions: (Transaction | undefined)[];
    settlementTransactions: (Transaction | undefined)[];
    settlementSessions: Map<string, string>;
    phase: SwapPhase;
    createdAt: number;
    startedAt?: number;
    completedAt?: number;
    setupTimeout: number;
    settlementTimeout: number;
    aborted: boolean;
    abortReason?: string;
}
export interface SwapPoolAnnouncement {
    poolId: string;
    denomination: number;
    minParticipants: number;
    maxParticipants: number;
    currentParticipants: number;
    burnConfig: BurnConfig;
    createdAt: number;
    expiresAt: number;
    setupTimeout: number;
    settlementTimeout: number;
    creatorPeerId: string;
    creatorSignature: Buffer;
}
export interface CreatePoolParams {
    denomination: number;
    minParticipants?: number;
    maxParticipants?: number;
    feeRate?: number;
    burnPercentage?: number;
    setupTimeout?: number;
    settlementTimeout?: number;
}
export interface PoolDiscoveryFilters {
    denomination?: number;
    minParticipants?: number;
    maxParticipants?: number;
}
export declare enum SwapSigEvent {
    POOL_CREATED = "pool:created",
    POOL_JOINED = "pool:joined",
    POOL_ABORTED = "pool:aborted",
    POOL_COMPLETE = "pool:complete",
    POOL_PHASE_CHANGED = "pool:phase-changed",
    PARTICIPANT_JOINED = "participant:joined",
    PARTICIPANT_DROPPED = "participant:dropped",
    SETUP_TX_BROADCAST = "setup:tx-broadcast",
    SETUP_CONFIRMED = "setup:confirmed",
    SETUP_COMPLETE = "setup:complete",
    DESTINATION_REVEALED = "destination:revealed",
    REVEAL_COMPLETE = "reveal:complete",
    SWAPSIG_REQUEST_JOINED = "swapsig:request-joined",
    SWAPSIG_SESSION_READY = "swapsig:session-ready",
    SWAPSIG_SESSION_COMPLETE = "swapsig:session-complete",
    SETTLEMENT_TX_BROADCAST = "settlement:tx-broadcast",
    SETTLEMENT_CONFIRMED = "settlement:confirmed",
    SETTLEMENT_COMPLETE = "settlement:complete"
}
export type SwapSigEventMap = {
    [SwapSigEvent.POOL_CREATED]: (pool: SwapPool) => void;
    [SwapSigEvent.POOL_JOINED]: (poolId: string, participantIndex: number) => void;
    [SwapSigEvent.POOL_ABORTED]: (poolId: string, reason: string) => void;
    [SwapSigEvent.POOL_COMPLETE]: (poolId: string) => void;
    [SwapSigEvent.POOL_PHASE_CHANGED]: (poolId: string, newPhase: SwapPhase, oldPhase: SwapPhase) => void;
    [SwapSigEvent.PARTICIPANT_JOINED]: (poolId: string, participant: SwapParticipant) => void;
    [SwapSigEvent.PARTICIPANT_DROPPED]: (poolId: string, peerId: string) => void;
    [SwapSigEvent.SETUP_TX_BROADCAST]: (poolId: string, participantIndex: number, txId: string) => void;
    [SwapSigEvent.SETUP_CONFIRMED]: (poolId: string, participantIndex: number) => void;
    [SwapSigEvent.SETUP_COMPLETE]: (poolId: string) => void;
    [SwapSigEvent.DESTINATION_REVEALED]: (poolId: string, participantIndex: number, address: Address) => void;
    [SwapSigEvent.REVEAL_COMPLETE]: (poolId: string) => void;
    [SwapSigEvent.SWAPSIG_REQUEST_JOINED]: (requestId: string, poolId: string) => void;
    [SwapSigEvent.SWAPSIG_SESSION_READY]: (sessionId: string, requestId: string) => void;
    [SwapSigEvent.SWAPSIG_SESSION_COMPLETE]: (sessionId: string) => void;
    [SwapSigEvent.SETTLEMENT_TX_BROADCAST]: (poolId: string, outputIndex: number, txId: string) => void;
    [SwapSigEvent.SETTLEMENT_CONFIRMED]: (poolId: string, outputIndex: number) => void;
    [SwapSigEvent.SETTLEMENT_COMPLETE]: (poolId: string) => void;
};
export declare enum SwapSigMessageType {
    POOL_ANNOUNCE = "swapsig:pool-announce",
    POOL_JOIN = "swapsig:pool-join",
    PARTICIPANT_REGISTERED = "swapsig:participant-registered",
    REGISTRATION_ACK = "swapsig:registration-ack",
    SETUP_TX_BROADCAST = "swapsig:setup-tx-broadcast",
    SETUP_CONFIRMED = "swapsig:setup-confirmed",
    SETUP_COMPLETE = "swapsig:setup-complete",
    DESTINATION_REVEAL = "swapsig:destination-reveal",
    REVEAL_COMPLETE = "swapsig:reveal-complete",
    SETTLEMENT_TX_BROADCAST = "swapsig:settlement-tx-broadcast",
    SETTLEMENT_CONFIRMED = "swapsig:settlement-confirmed",
    SETTLEMENT_COMPLETE = "swapsig:settlement-complete",
    POOL_ABORT = "swapsig:pool-abort",
    PARTICIPANT_DROPPED = "swapsig:participant-dropped"
}
export interface SwapSigMessage {
    type: SwapSigMessageType;
    poolId: string;
    from: string;
    payload: unknown;
    timestamp: number;
    messageId: string;
}
export interface PoolStats {
    poolId: string;
    phase: SwapPhase;
    participants: number;
    denomination: number;
    totalBurned: number;
    totalFees: number;
    anonymitySet: number;
    duration?: number;
    setupDuration?: number;
    settlementDuration?: number;
}
//# sourceMappingURL=types.d.ts.map