@arkade-os/sdk 0.4.45 → 0.4.47

package/dist/index-Cm2fGeox.d.ts

@@ -1,259 +0,0 @@
-import { q as RelativeTimelock, V as VtxoScript, r as TapLeafScript, b3 as ContractHandler, bf as Discoverable } from './ark-C-PjOngm.js';
-import { D as DefaultVtxo, a as DelegateVtxo } from './delegate-BKNqva1j.js';
-import { Bytes } from '@scure/btc-signer/utils.js';
-
-/** Virtual Hash Time Lock Contract (VHTLC) namespace. */
-declare namespace VHTLC {
-    interface Options {
-        sender: Bytes;
-        receiver: Bytes;
-        server: Bytes;
-        preimageHash: Bytes;
-        refundLocktime: bigint;
-        unilateralClaimDelay: RelativeTimelock;
-        unilateralRefundDelay: RelativeTimelock;
-        unilateralRefundWithoutReceiverDelay: RelativeTimelock;
-    }
-    /**
-     * Virtual Hash Time Lock Contract (VHTLC) script implementation.
-     *
-     * VHTLC enables atomic swaps and conditional payments in the Arkade protocol.
-     * It provides multiple spending paths:
-     *
-     * - **claim**: Receiver can claim funds by revealing the preimage
-     * - **refund**: Sender and receiver can collaboratively refund
-     * - **refundWithoutReceiver**: Sender can refund after locktime expires
-     * - **unilateralClaim**: Receiver can claim unilaterally after delay
-     * - **unilateralRefund**: Sender and receiver can refund unilaterally after delay
-     * - **unilateralRefundWithoutReceiver**: Sender can refund unilaterally after delay
-     *
-     * @example
-     * ```typescript
-     * const vhtlc = new VHTLC.Script({
-     *   sender: alicePubKey,
-     *   receiver: bobPubKey,
-     *   server: serverPubKey,
-     *   preimageHash: hash160(secret),
-     *   refundLocktime: BigInt(chainTip + 10),
-     *   unilateralClaimDelay: { type: 'blocks', value: 100n },
-     *   unilateralRefundDelay: { type: 'blocks', value: 102n },
-     *   unilateralRefundWithoutReceiverDelay: { type: 'blocks', value: 103n }
-     * });
-     * ```
-     */
-    class Script extends VtxoScript {
-        readonly options: Options;
-        readonly claimScript: string;
-        readonly refundScript: string;
-        readonly refundWithoutReceiverScript: string;
-        readonly unilateralClaimScript: string;
-        readonly unilateralRefundScript: string;
-        readonly unilateralRefundWithoutReceiverScript: string;
-        /** Create a VHTLC script from the supplied participant keys, hash, and timelocks. */
-        constructor(options: Options);
-        /** Return the collaborative claim tapleaf script. */
-        claim(): TapLeafScript;
-        /** Return the collaborative refund tapleaf script. */
-        refund(): TapLeafScript;
-        /** Return the refund-without-receiver tapleaf script. */
-        refundWithoutReceiver(): TapLeafScript;
-        /** Return the unilateral claim tapleaf script. */
-        unilateralClaim(): TapLeafScript;
-        /** Return the unilateral refund tapleaf script. */
-        unilateralRefund(): TapLeafScript;
-        /** Return the unilateral refund-without-receiver tapleaf script. */
-        unilateralRefundWithoutReceiver(): TapLeafScript;
-    }
-}
-
-/**
- * Registry for contract handlers.
- *
- * Each contract type ("default", "vhtlc", etc.) has a handler that knows
- * how to create VtxoScripts, serialize params, and select spending paths.
- *
- * @example
- * ```typescript
- * // Register a custom handler
- * contractHandlers.register(myCustomHandler);
- *
- * // Get handler for a type
- * const handler = contractHandlers.get("vhtlc");
- * const script = handler.createScript(contract.params);
- * ```
- */
-declare class ContractHandlerRegistry {
-    private handlers;
-    /**
-     * Register a contract handler.
-     *
-     * @param handler - The handler to register
-     * @throws If a handler for this type is already registered
-     */
-    register(handler: ContractHandler<unknown>): void;
-    /**
-     * Get a handler by type.
-     *
-     * @param type - The contract type
-     * @returns The handler, or undefined if not found
-     */
-    get(type: string): ContractHandler<unknown> | undefined;
-    /**
-     * Get a handler by type, throwing if not found.
-     *
-     * @param type - The contract type
-     * @returns The handler
-     * @throws If no handler is registered for this type
-     */
-    getOrThrow(type: string): ContractHandler<unknown>;
-    /**
-     * Check if a handler is registered.
-     *
-     * @param type - The contract type
-     */
-    has(type: string): boolean;
-    /**
-     * Get all registered types.
-     */
-    getRegisteredTypes(): string[];
-    /**
-     * Unregister a handler (mainly for testing).
-     */
-    unregister(type: string): boolean;
-    /**
-     * Clear all handlers (mainly for testing).
-     */
-    clear(): void;
-}
-/**
- * Global registry of contract handlers.
- */
-declare const contractHandlers: ContractHandlerRegistry;
-
-/**
- * Typed parameters for DefaultVtxo contracts.
- */
-interface DefaultContractParams {
-    pubKey: Uint8Array;
-    serverPubKey: Uint8Array;
-    csvTimelock: RelativeTimelock;
-}
-/**
- * Handler for default wallet VTXOs.
- *
- * Default contracts use the standard forfeit + exit tapscript:
- * - forfeit: (Alice + Server) multisig for collaborative spending
- * - exit: (Alice) + CSV timelock for unilateral exit
- */
-declare const DefaultContractHandler: ContractHandler<DefaultContractParams, DefaultVtxo.Script> & Discoverable;
-
-/**
- * Typed parameters for DelegateVtxo contracts.
- */
-interface DelegateContractParams {
-    pubKey: Uint8Array;
-    serverPubKey: Uint8Array;
-    delegatePubKey: Uint8Array;
-    csvTimelock: RelativeTimelock;
-}
-/**
- * Handler for delegate wallet virtual outputs.
- *
- * Delegate contracts extend the default tapscript with an additional delegate path:
- * - forfeit: (Alice + Server) multisig for collaborative spending
- * - exit: (Alice) + CSV timelock for unilateral exit
- * - delegate: (Alice + Delegate + Server) multisig for delegated renewal
- */
-declare const DelegateContractHandler: ContractHandler<DelegateContractParams, DelegateVtxo.Script> & Discoverable;
-
-/**
- * Typed parameters for VHTLC contracts.
- */
-interface VHTLCContractParams {
-    sender: Uint8Array;
-    receiver: Uint8Array;
-    server: Uint8Array;
-    preimageHash: Uint8Array;
-    refundLocktime: bigint;
-    unilateralClaimDelay: RelativeTimelock;
-    unilateralRefundDelay: RelativeTimelock;
-    unilateralRefundWithoutReceiverDelay: RelativeTimelock;
-}
-/**
- * Handler for Virtual Hash Time Lock Contract (VHTLC).
- *
- * VHTLC supports multiple spending paths:
- *
- * Collaborative paths (with server):
- * - claim: Receiver + Server with preimage
- * - refund: Sender + Receiver + Server
- * - refundWithoutReceiver: Sender + Server after CLTV locktime
- *
- * Unilateral paths (without server):
- * - unilateralClaim: Receiver with preimage after CSV delay
- * - unilateralRefund: Sender + Receiver after CSV delay
- * - unilateralRefundWithoutReceiver: Sender after CSV delay
- */
-declare const VHTLCContractHandler: ContractHandler<VHTLCContractParams, VHTLC.Script>;
-
-/**
- * Typed parameters for boarding contracts.
- *
- * Boarding reuses the exact `default` contract parameter shape
- * (`pubKey` / `serverPubKey` / `csvTimelock`) rather than inventing
- * boarding-specific names — the boarding semantics come from the
- * contract type and from populating `csvTimelock` with the server's
- * boarding-exit delay (`ArkInfo.boardingExitDelay`) instead of the
- * offchain unilateral-exit delay.
- */
-type BoardingContractParams = DefaultContractParams;
-/**
- * Handler for the boarding contract (registered type `boarding`).
- *
- * The boarding contract derives the on-chain Bitcoin address used to
- * board funds onto Arkade. It shares the exact `DefaultVtxo.Script`
- * shape with the `default` contract — a Taproot output co-owned by the
- * wallet and the Ark server, with a CSV exit path back to the wallet —
- * and therefore reuses the `default` handler's path logic (forfeit via
- * server cooperation, exit after the boarding CSV).
- *
- * Boarding semantics come entirely from the contract type and from
- * sourcing the CSV timelock from the server's boarding-exit delay
- * (`ArkInfo.boardingExitDelay`), not from renamed parameters. The
- * offchain `default` contract is built from `ArkInfo.unilateralExitDelay`
- * instead, so the two share a script shape but differ in their CSV
- * timelock value. Parameters round-trip through the same
- * `timelockToSequence` / `sequenceToTimelock` helpers and BIP68 sequence
- * encoding as `default` / `delegate`.
- *
- * Like `default` / `delegate`, the boarding handler implements
- * {@link Discoverable.discoverAt} so `wallet.restore()` can rediscover
- * used boarding indices from authoritative on-chain data. It differs from
- * the L2 handlers in its source of truth: boarding probes the **on-chain**
- * UTXO set at its P2TR address (`OnchainProvider.getCoins`) rather than the
- * Ark indexer, and builds its candidate from the boarding-exit CSV
- * (`deps.boardingTimelock`). When boarding discovery is not plumbed (no
- * `deps.boardingTimelock` / `deps.onchainNetwork`) `discoverAt` no-ops.
- *
- * Identity & the default/boarding collision: a contract's `script` (pkScript)
- * is its unique identity — a script owns exactly one repository row. `boarding`
- * is a first-class type with its own row **when its script is distinct** from
- * the wallet's `default` baseline — the real-world case, since a sound Ark
- * server keeps boardingExitDelay strictly longer than unilateralExitDelay (equal
- * delays would expose the provider to a double-spend). Should those delays ever
- * coincide (a misconfigured/malicious server), the boarding script is
- * byte-identical to the default script. `discoverAt` does NOT pre-coalesce that
- * collision: it always emits `type: "boarding"`, and the single shared row is
- * resolved FIRST-WINS at the persistence layer
- * ({@link ContractManager.upsertContract}) — whichever purpose is persisted
- * first keeps the row, and the scan deliberately probes boarding first
- * (see docs/hd-wallets_onchain_rotation_collision_fix.md §5.1–5.2). Either way
- * the funds are equally spendable through the shared `DefaultVtxo.Script` paths.
- * Consumers must NOT rely on `contract.type === "boarding"` to identify the
- * boarding purpose — resolve the boarding script via
- * `wallet.getBoardingAddress()` / `wallet.boardingTapscript` (which never depend
- * on the persisted contract's type) and match by script when needed.
- */
-declare const BoardingContractHandler: ContractHandler<BoardingContractParams, DefaultVtxo.Script> & Discoverable;
-
-export { BoardingContractHandler as B, DefaultContractHandler as D, VHTLC as V, type BoardingContractParams as a, type DefaultContractParams as b, DelegateContractHandler as c, type DelegateContractParams as d, VHTLCContractHandler as e, type VHTLCContractParams as f, contractHandlers as g };