@invisible-labs/sdk 0.6.0-devnet.1

package/dist/lp.d.ts

@@ -0,0 +1,388 @@
+import { S as Session } from './session-DFuy54C-.js';
+
+declare const lpPositionCodeBrand: unique symbol;
+type LpPositionCode = string & {
+    readonly [lpPositionCodeBrand]: "LpPositionCode";
+};
+type LpPositionCodeAuth = {
+    readonly code: LpPositionCode;
+    readonly lpPositionId: string;
+    readonly authPublicKey: Uint8Array;
+    readonly authPrivateKeyPkcs8: Uint8Array;
+    readonly refillPublicKey: Uint8Array;
+    readonly withdrawalCommitment: Uint8Array;
+};
+declare function generateLpPositionCode(lpPositionId: string): Promise<LpPositionCodeAuth>;
+declare function deriveLpPositionCodeAuth(input: string): Promise<LpPositionCodeAuth>;
+declare function normalizeLpPositionCode(input: string): LpPositionCode;
+declare function bytesToHex(bytes: Uint8Array): string;
+declare function signLpCommandBytes(auth: LpPositionCodeAuth, bytes: Uint8Array): Promise<Uint8Array>;
+
+type SourceLiquidityUse = "not_materialized" | "available" | "locked_for_payout" | "pending_finality" | "spent" | "released";
+type LpInventoryShard = {
+    kind: "lp";
+    lpPositionId: string;
+    shardId: string;
+    index: number;
+    address: string;
+    amountLamports: number;
+    requiredLamports?: number;
+    status: "PREGENERATED" | "FUNDING_QUEUED" | "FUNDED" | "COOLING" | "AVAILABLE" | "RESERVED" | "RETIRED" | "REDEEMED";
+    fundingTxSignature?: string;
+    payoutTxSignature?: string;
+    coolingUntilMs?: number;
+};
+type LpPositionView = {
+    id: string;
+    status: "dkg_pending" | "active" | "withdrawing" | "closed";
+    targetShardCount: number;
+    authPublicKey: string;
+    refillPublicKey: string;
+    withdrawalCommitment: string;
+    committedLamports: number;
+    earnedLamports: number;
+    refillThreshold: number;
+    shards: LpInventoryShard[];
+    createdAt: number;
+    actorSync?: LpActorSyncView;
+};
+type LpActorSyncView = {
+    lpPositionId: string;
+    status: "idle" | "settling" | "reimbursement_due";
+    sourceLiquidityUse: SourceLiquidityUse;
+    redeemableProjectionAvailable: boolean;
+    redeemablePrincipalLamports: number;
+    redeemableFeeLamports: number;
+    lifetimeEarnedLamports: number;
+    redeemablePrincipalSourceCount: number;
+    redeemableFeeSourceCount: number;
+    pendingReservationCount: number;
+    reservedPayoutLamports: number;
+    estimatedNetworkFeeLamports: number;
+    reimbursementDueCount: number;
+    reimbursementDueSourceCount: number;
+    reimbursementDuePayoutLamports: number;
+    reimbursementDueNetworkFeeLamports: number;
+    withdrawalRequestedLamports: number;
+    withdrawalLandedLamports: number;
+    withdrawalLandedFeeLamports: number;
+    withdrawalCanceledLamports: number;
+    withdrawalNetworkFeeLossLamports: number;
+    withdrawalTxHashes: string[];
+    redemptionHistory?: LpRedemptionHistoryView[];
+    redemptionHistoryHasMore?: boolean;
+    redemptionHistoryNextCursor?: string;
+    stateVersion: number;
+    updatedAtMs: number;
+};
+type LpRedemptionHistoryView = {
+    redemptionId: string;
+    state: "requested" | "match_requested" | "reserved" | "pending" | "confirmed" | "rejected";
+    acceptedLamports: number;
+    acceptedDepositPrincipalLamports: number;
+    acceptedEarnedFeeLamports: number;
+    landedLamports: number;
+    landedDepositPrincipalLamports: number;
+    landedEarnedFeeLamports: number;
+    canceledLamports: number;
+    canceledDepositPrincipalLamports: number;
+    canceledEarnedFeeLamports: number;
+    networkFeeLamports: number;
+    networkFeeLossLamports: number;
+    failedAttempts: number;
+    destinationAddresses: string[];
+    destinationCount: number;
+    txSignatures: string[];
+    txSignatureCount: number;
+    detailsTruncated: boolean;
+    stateVersion: number;
+    createdAtMs: number;
+    updatedAtMs: number;
+};
+type OpenLpPositionInput = {
+    lpPositionId: string;
+    authPublicKey: number[];
+    refillPublicKey: number[];
+    withdrawalCommitment: number[];
+    committedLamports: number;
+    shardCount: number;
+    shardAmountLamports: number;
+    refillThreshold: number;
+    addresses: string[];
+    createdAtMs: number;
+};
+type RefillLpPositionInput = {
+    lpPositionId: string;
+    shardCount: number;
+    shardAmountLamports: number;
+    addresses: string[];
+    authorizedAtMs: number;
+};
+type FundingConfirmationInput = {
+    lpPositionId: string;
+    shardId: string;
+    amountLamports: number;
+    fundingTxSignature: string;
+};
+type LpTopUpRequest$1 = {
+    topUpId: string;
+    positionId: string;
+    depositAddress: string;
+    expiresAtMs: number;
+    status: "watching" | "funded" | "expired";
+};
+type FinalizeLpDkgBatchInput = {
+    lpPositionId: string;
+    startIndex: number;
+    addresses: string[];
+    finalizedAtMs: number;
+};
+type LpWithdrawalExecutionView = {
+    withdrawalId: string;
+    txSignatures: string[];
+};
+type LpDkgClient = {
+    initDkg(input: {
+        lpPositionId: string;
+        index: number;
+    }, auth: LpPositionCodeAuth): Promise<{
+        sessionId: string;
+    }>;
+    dkgRound1(input: {
+        sessionId: string;
+        package: number[];
+    }, auth: LpPositionCodeAuth): Promise<{
+        package: Uint8Array;
+        round2ForLp: Uint8Array;
+    }>;
+    dkgRound2(input: {
+        sessionId: string;
+        package: number[];
+        delegatedShare: number[];
+    }, auth: LpPositionCodeAuth): Promise<{
+        address: string;
+        jointPubkey: Uint8Array;
+        shardId: string;
+        index: number;
+    }>;
+};
+type LpCoordinatorClient = LpDkgClient & {
+    openPosition(input: OpenLpPositionInput, auth: LpPositionCodeAuth): Promise<LpPositionView>;
+    getPosition(lpPositionId: string, auth: LpPositionCodeAuth): Promise<LpPositionView>;
+    finalizeDkgBatch(input: FinalizeLpDkgBatchInput, auth: LpPositionCodeAuth): Promise<LpPositionView>;
+    refillPosition(input: RefillLpPositionInput, auth: LpPositionCodeAuth): Promise<LpPositionView>;
+    reconcileFunding(lpPositionId: string, auth: LpPositionCodeAuth): Promise<LpPositionView>;
+    planFunding(input: {
+        lpPositionId: string;
+        shardCount: number;
+        nowMs: number;
+    }, auth: LpPositionCodeAuth): Promise<LpInventoryShard[]>;
+    confirmFunding(input: FundingConfirmationInput, auth: LpPositionCodeAuth): Promise<LpInventoryShard>;
+    prepareTopUp(lpPositionId: string, auth: LpPositionCodeAuth): Promise<LpTopUpRequest$1>;
+    getTopUpStatus(input: {
+        lpPositionId: string;
+        topUpId: string;
+    }, auth: LpPositionCodeAuth): Promise<LpTopUpRequest$1>;
+    makeAvailable(input: {
+        lpPositionId: string;
+        shardId: string;
+    }, auth: LpPositionCodeAuth): Promise<LpInventoryShard>;
+    executeWithdrawal(input: {
+        lpPositionId: string;
+        destinationAddresses: string[];
+        depositPrincipalLamports: number;
+        earnedFeeLamports: number;
+        requestedAtMs: number;
+        allowManyToOne?: boolean;
+    }, auth: LpPositionCodeAuth): Promise<LpWithdrawalExecutionView>;
+};
+
+declare const LP_REDEMPTION_RECONCILING_MESSAGE = "LP redemption is still settling on the coordinator; it will reconcile from sync";
+declare const LP_MISSING_POSITION_CODE_MESSAGE = "Save or recover the LP Position Code before using LP funds";
+type LpLifecycleDkgProgress = {
+    readonly phase: "dkg";
+    readonly lpPositionId: string;
+    readonly startIndex: number;
+    readonly targetShardCount: number;
+    readonly completed: number;
+    readonly total: number;
+};
+interface CreatePositionArgs {
+    readonly committedLamports?: number;
+    readonly shardCount?: number;
+    readonly refillThreshold?: number;
+    readonly feePolicy?: unknown;
+    /**
+     * Called after SDK-owned code generation and before the coordinator open call.
+     * Use this to show/save the code if coordinator intake fails.
+     */
+    readonly onPositionCode?: (code: LpGeneratedPositionCode) => void;
+}
+interface LpGeneratedPositionCode {
+    readonly positionId: string;
+    readonly lpPositionCode: string;
+}
+interface CreatePositionResult {
+    readonly positionId: string;
+    /** Shown once at onboarding; treat like a seed phrase. */
+    readonly lpPositionCode: string;
+    readonly position: LpPositionView;
+}
+interface CompleteDkgBatchOptions {
+    readonly onProgress?: (progress: LpLifecycleDkgProgress) => void;
+    readonly onPosition?: (position: LpPositionView) => void;
+    readonly concurrency?: number;
+    readonly workerFactory?: () => Worker;
+}
+interface InitialFundingPlan {
+    readonly address: string;
+    readonly requiredLamports: number;
+    readonly qrPayload: string;
+    readonly position: LpPositionView;
+}
+interface LpTopUpRequest {
+    readonly topUpId: string;
+    readonly positionId: string;
+    readonly depositAddress: string;
+    readonly expiresAtMs: number;
+    readonly status: "watching" | "funded" | "expired";
+}
+interface WithdrawPositionArgs {
+    /** Accepted LP deposit-principal bucket claim. Computed from the position when omitted. */
+    readonly depositPrincipalLamports?: number;
+    /** Accepted earned-fee bucket claim. Computed from the position when omitted. */
+    readonly earnedFeeLamports?: number;
+    readonly destinationAddresses: string[];
+    /** Required to accept a privacy-degrading single-destination withdrawal. */
+    readonly allowManyToOne?: boolean;
+}
+interface RefillArgs {
+    readonly shardCount?: number;
+    readonly onProgress?: (progress: LpLifecycleDkgProgress) => void;
+    readonly onPosition?: (position: LpPositionView) => void;
+    readonly workerFactory?: () => Worker;
+}
+interface WithdrawalExecution {
+    readonly withdrawalId: string;
+    readonly txSignatures: string[];
+}
+interface LpWithdrawalRecord {
+    readonly redemptionId: string;
+    readonly lpPositionId: string;
+    readonly requestedAt: number;
+    readonly status: "pending" | "reconciling" | "confirmed" | "failed";
+    readonly destinationAddresses: string[];
+    readonly destinationCount?: number;
+    readonly txSignatureCount?: number;
+    readonly detailsTruncated?: boolean;
+    readonly acceptedLamports?: number;
+    readonly requestedTargetLamports: number;
+    readonly landedBaselineLamports: number;
+    readonly landedFeeBaselineLamports?: number;
+    readonly redeemedLamports: number;
+    readonly txSignatures: string[];
+    readonly txSignatureBaseline: string[];
+    readonly coordinatorStateVersion?: number;
+    readonly error?: string;
+}
+interface WithdrawPositionResult {
+    readonly execution: WithdrawalExecution;
+    readonly position: LpPositionView;
+    readonly redemption: LpWithdrawalRecord;
+}
+interface WithdrawalConfirmation {
+    readonly withdrawalId: string;
+    readonly txSignatures: string[];
+    readonly redeemedLamports: number;
+}
+interface LpLifecycleRuntime {
+    readonly coordinatorClient?: LpCoordinatorClient;
+    readonly workerFactory?: () => Worker;
+    readonly useDeterministicTestAddresses?: boolean;
+    readonly nowMs?: () => number;
+    readonly idFactory?: () => string;
+    readonly sleep?: (delayMs: number) => Promise<void>;
+    readonly dkgConcurrency?: number;
+    readonly withdrawalConfirmationPollIntervalMs?: number;
+    readonly withdrawalConfirmationTimeoutMs?: number;
+}
+interface WaitForWithdrawalConfirmationOptions {
+    readonly onPosition?: (position: LpPositionView) => void;
+    readonly onRedemptionUpdate?: (record: LpWithdrawalRecord) => void;
+    readonly redemptionRecord?: LpWithdrawalRecord;
+}
+interface WaitForTopUpOptions {
+    readonly signal?: AbortSignal;
+    readonly pollIntervalMs?: number;
+    readonly positionId?: string;
+}
+declare function isLpRedemptionReconcilingError(error: unknown): boolean;
+declare function isLpPositionAuthMissingError(error: unknown): boolean;
+interface LpLifecycleClient {
+    createPosition(args?: CreatePositionArgs): Promise<CreatePositionResult>;
+    recoverPosition(args: {
+        readonly code: string;
+    }): Promise<LpPositionView>;
+    confirmPositionCodeSaved(positionId: string): void;
+    completeDkgBatch(positionId: string, options?: CompleteDkgBatchOptions): Promise<LpPositionView>;
+    refreshPosition(positionId: string): Promise<LpPositionView>;
+    refill(positionId: string, args?: RefillArgs): Promise<LpPositionView>;
+    prepareInitialFunding(positionId: string): Promise<InitialFundingPlan | null>;
+    prepareTopUp(positionId: string): Promise<LpTopUpRequest>;
+    waitForTopUp(topUpId: string, options?: WaitForTopUpOptions): Promise<LpTopUpRequest>;
+    reconcileFunding(positionId: string): Promise<LpPositionView>;
+    withdrawPosition(positionId: string, args: WithdrawPositionArgs): Promise<WithdrawPositionResult>;
+    waitForWithdrawalConfirmation(positionId: string, execution: WithdrawalExecution, options?: WaitForWithdrawalConfirmationOptions): Promise<WithdrawalConfirmation>;
+    withdrawFees(positionId: string, args: {
+        readonly destination: string;
+    }): Promise<never>;
+    listPositions(): Promise<LpPositionView[]>;
+}
+declare function createLpLifecycleClient(session: Session, runtime?: LpLifecycleRuntime): LpLifecycleClient;
+declare function defaultLpLifecycleClient(session: Session): LpLifecycleClient;
+
+declare const LP_COMMAND_REQUEST_TIMEOUT_MS = 120000;
+declare function createLpCoordinatorClient(session: Session): LpCoordinatorClient;
+
+type LpDkgProgress = {
+    completed: number;
+    total: number;
+    address: string;
+};
+type CreateLpDkgBatchInput = {
+    lpPositionId: string;
+    startIndex: number;
+    count: number;
+    auth: LpPositionCodeAuth;
+    client: LpCoordinatorClient;
+    concurrency?: number;
+    workerFactory?: () => Worker;
+    useDeterministicTestAddresses?: boolean;
+    onProgress?: (progress: LpDkgProgress) => void;
+};
+declare function createLpDkgBatch(input: CreateLpDkgBatchInput): Promise<string[]>;
+
+declare function createPosition(session: Session, args?: CreatePositionArgs): Promise<CreatePositionResult>;
+declare function recoverPosition(session: Session, args: {
+    readonly code: string;
+}): Promise<LpPositionView>;
+declare function confirmPositionCodeSaved(session: Session, positionId: string): void;
+declare function completeDkgBatch(session: Session, positionId: string, opts?: CompleteDkgBatchOptions): Promise<LpPositionView>;
+declare function refreshPosition(session: Session, positionId: string): Promise<LpPositionView>;
+declare function refill(session: Session, positionId: string, args?: RefillArgs): Promise<LpPositionView>;
+declare function prepareInitialFunding(session: Session, positionId: string): Promise<InitialFundingPlan | null>;
+declare function prepareTopUp(session: Session, positionId: string): Promise<LpTopUpRequest>;
+declare function waitForTopUp(session: Session, topUpId: string, options?: WaitForTopUpOptions): Promise<LpTopUpRequest>;
+declare function reconcileFunding(session: Session, positionId: string): Promise<LpPositionView>;
+declare function withdrawPosition(session: Session, positionId: string, args: WithdrawPositionArgs): Promise<WithdrawPositionResult>;
+declare function waitForWithdrawalConfirmation(session: Session, positionId: string, execution: WithdrawalExecution, options?: WaitForWithdrawalConfirmationOptions): Promise<WithdrawalConfirmation>;
+/**
+ * LP fee withdrawal is coordinator-pending. The SDK validates the local input
+ * and returns a typed `VERSION_NOT_SUPPORTED` routing error until advertised.
+ */
+declare function withdrawFees(session: Session, positionId: string, args: {
+    readonly destination: string;
+}): Promise<never>;
+declare function listPositions(session: Session): Promise<LpPositionView[]>;
+
+export { type CompleteDkgBatchOptions, type CreateLpDkgBatchInput, type CreatePositionArgs, type CreatePositionResult, type FinalizeLpDkgBatchInput, type FundingConfirmationInput, type InitialFundingPlan, LP_COMMAND_REQUEST_TIMEOUT_MS, LP_MISSING_POSITION_CODE_MESSAGE, LP_REDEMPTION_RECONCILING_MESSAGE, type LpActorSyncView, type LpCoordinatorClient, type LpDkgClient, type LpDkgProgress, type LpInventoryShard, type LpLifecycleClient, type LpLifecycleDkgProgress, type LpLifecycleRuntime, type LpPositionCode, type LpPositionCodeAuth, type LpPositionView, type LpRedemptionHistoryView, type LpTopUpRequest, type LpWithdrawalExecutionView, type LpWithdrawalRecord, type OpenLpPositionInput, type RefillArgs, type RefillLpPositionInput, type SourceLiquidityUse, type WaitForTopUpOptions, type WaitForWithdrawalConfirmationOptions, type WithdrawPositionArgs, type WithdrawPositionResult, type WithdrawalConfirmation, type WithdrawalExecution, bytesToHex, completeDkgBatch, confirmPositionCodeSaved, createLpCoordinatorClient, createLpDkgBatch, createLpLifecycleClient, createPosition, defaultLpLifecycleClient, deriveLpPositionCodeAuth, generateLpPositionCode, isLpPositionAuthMissingError, isLpRedemptionReconcilingError, listPositions, normalizeLpPositionCode, prepareInitialFunding, prepareTopUp, reconcileFunding, recoverPosition, refill, refreshPosition, signLpCommandBytes, waitForTopUp, waitForWithdrawalConfirmation, withdrawFees, withdrawPosition };