@kronsdk/kron-sdk 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,1098 @@
+import { K as Kaspa } from './kaspa.types-DkjvUkCM.js';
+import * as vendor_kaspa_kaspa_js from 'vendor/kaspa/kaspa.js';
+import '../vendor/kaspa/kaspa.js';
+
+declare const SCALE$1 = 1000000n;
+declare const FEE_OUT_MIN = 20000000n;
+declare const MAX_KAS = 900000000000000n;
+/** Live curve state for quoting. realKas/graduationKas are sompi; vKas is in SCALE units; tokenReserve whole. */
+type CpState$1 = {
+    realKas: bigint;
+    tokenReserve: bigint;
+    vKas: bigint;
+    graduationKas: bigint;
+    creatorFeeBps: bigint;
+    platformFeeBps: bigint;
+};
+declare const DEFAULT_SLIPPAGE_BPS = 100;
+/** Minimum acceptable output after a slippage tolerance (bps). `out` is tokenOut (buy) or net KAS (sell). */
+declare const minOutWithSlippage: (out: bigint, bps: number) => bigint;
+type CpBuyQuote = {
+    kasIn: bigint;
+    tokenOut: bigint;
+    creatorFee: bigint;
+    platformFee: bigint;
+    fee: bigint;
+    total: bigint;
+    newRealKas: bigint;
+    newTokenReserve: bigint;
+};
+type CpSellQuote = {
+    tokenIn: bigint;
+    kasOut: bigint;
+    creatorFee: bigint;
+    platformFee: bigint;
+    fee: bigint;
+    net: bigint;
+    newRealKas: bigint;
+    newTokenReserve: bigint;
+};
+/** Buy: spend `kasInSompi` into the reserve (floored to a SCALE step) → tokenOut, plus the fee on top. */
+declare function quoteCpBuy(s: CpState$1, kasInSompi: bigint): CpBuyQuote | null;
+/** Sell: return `tokenIn` tokens to inventory → kasOut sompi (a SCALE step), minus the fee. */
+declare function quoteCpSell(s: CpState$1, tokenIn: bigint): CpSellQuote | null;
+/** Marginal price in sompi per token: (vKas + realKas/SCALE) · SCALE / tokenReserve. */
+declare function cpPrice(s: CpState$1): number;
+/** Progress to graduation (0..100), measured by KAS raised vs the target. */
+declare function cpProgress(s: CpState$1): number;
+/** Tokens sold so far (circulating from the curve) = initial inventory − current inventory. */
+declare const cpSold: (initialInventory: bigint, tokenReserve: bigint) => bigint;
+
+type cpCurve_CpBuyQuote = CpBuyQuote;
+type cpCurve_CpSellQuote = CpSellQuote;
+declare const cpCurve_DEFAULT_SLIPPAGE_BPS: typeof DEFAULT_SLIPPAGE_BPS;
+declare const cpCurve_FEE_OUT_MIN: typeof FEE_OUT_MIN;
+declare const cpCurve_MAX_KAS: typeof MAX_KAS;
+declare const cpCurve_cpPrice: typeof cpPrice;
+declare const cpCurve_cpProgress: typeof cpProgress;
+declare const cpCurve_cpSold: typeof cpSold;
+declare const cpCurve_minOutWithSlippage: typeof minOutWithSlippage;
+declare const cpCurve_quoteCpBuy: typeof quoteCpBuy;
+declare const cpCurve_quoteCpSell: typeof quoteCpSell;
+declare namespace cpCurve {
+  export { type cpCurve_CpBuyQuote as CpBuyQuote, type cpCurve_CpSellQuote as CpSellQuote, type CpState$1 as CpState, cpCurve_DEFAULT_SLIPPAGE_BPS as DEFAULT_SLIPPAGE_BPS, cpCurve_FEE_OUT_MIN as FEE_OUT_MIN, cpCurve_MAX_KAS as MAX_KAS, SCALE$1 as SCALE, cpCurve_cpPrice as cpPrice, cpCurve_cpProgress as cpProgress, cpCurve_cpSold as cpSold, cpCurve_minOutWithSlippage as minOutWithSlippage, cpCurve_quoteCpBuy as quoteCpBuy, cpCurve_quoteCpSell as quoteCpSell };
+}
+
+type K$7 = Kaspa;
+/** 8-byte little-endian encoding of a non-negative int (encode_fixed_size_value for `int`, width 8). */
+declare function int8LE(v: bigint): Uint8Array;
+/**
+ * A SilverScript ScriptBuilder wrapper that records pushes in the compiler's order, then drains to hex.
+ * Use the scalar push helpers for struct fields / scalar args and the column helpers for struct arrays,
+ * then `selector()` (if multi-entrypoint) and `redeem()` last (the standard P2SH spend layout).
+ */
+declare class SigScriptBuilder {
+    sb: any;
+    constructor(k: K$7);
+    /** int scalar (minimal CScriptNum). */
+    int(v: bigint): this;
+    /** bool scalar → 1|0 via addI64 (matches push_sigscript_arg Bool). */
+    bool(b: boolean): this;
+    /** single byte → addData([b]). */
+    byte(b: number): this;
+    /** raw bytes (byte[N], pubkey, sig, byte[]) → addData. */
+    data(bytes: Uint8Array): this;
+    /** a column of N values pushed as one fixed-width-concatenated array item (encode_array_literal). */
+    column(items: Uint8Array[]): this;
+    /** the entrypoint selector (branch index). Omit for single-entrypoint contracts. */
+    selector(index: number): this;
+    /** the P2SH redeem script (pushed last; the VM pops it, hash-checks, then runs it on the arg stack). */
+    redeem(script: Uint8Array): this;
+    /** finalize → signature-script hex. */
+    drain(): string;
+}
+
+type sigscript_SigScriptBuilder = SigScriptBuilder;
+declare const sigscript_SigScriptBuilder: typeof SigScriptBuilder;
+declare const sigscript_int8LE: typeof int8LE;
+declare namespace sigscript {
+  export { sigscript_SigScriptBuilder as SigScriptBuilder, sigscript_int8LE as int8LE };
+}
+
+type K$6 = Kaspa;
+/** SDK ScriptPublicKey instance, or a plain {version, script-hex} object. Kept loose, matching SDK style. */
+type Spk$5 = any;
+/** The genesis outpoint = the spending tx's FIRST input outpoint (`tx.inputs[0]`). */
+type GenesisOutpoint = {
+    transactionId: string;
+    index: number;
+};
+/** An output the genesis outpoint authorizes for covenant-id derivation (its index + the output itself). */
+type AuthOutput = {
+    index: number;
+    value: bigint;
+    scriptPublicKey: Spk$5;
+};
+/**
+ * Compute the KIP-20 genesis covenant-id (32-byte hex, no 0x) for a covenant UTXO created by a tx whose
+ * first input is `genesisOutpoint` and whose authorized outputs are `authOutputs`. Byte-exact with
+ * consensus. Used to:
+ *  - bind the curve `C` ↔ its token `A` (curve_cp `init`),
+ *  - pre-compute the pool covenant-id `P` a graduation will assign,
+ *  - derive a freshly-created covenant's own id client-side before broadcast.
+ */
+declare function genesisCovenantId(k: K$6, genesisOutpoint: GenesisOutpoint, authOutputs: AuthOutput[]): string;
+/** Covenant-ids are byte[32] in the covenants; convert between the hex form and bytes for state encoding. */
+declare const covidToBytes: (covidHex: string) => Uint8Array;
+declare const bytesToCovid: (u8: Uint8Array) => string;
+/** The all-zero covenant-id placeholder (a curve's `tokenCovid` before `init` binds it; ZERO_COVID). */
+declare const ZERO_COVID: string;
+
+type genesis_AuthOutput = AuthOutput;
+type genesis_GenesisOutpoint = GenesisOutpoint;
+declare const genesis_ZERO_COVID: typeof ZERO_COVID;
+declare const genesis_bytesToCovid: typeof bytesToCovid;
+declare const genesis_covidToBytes: typeof covidToBytes;
+declare const genesis_genesisCovenantId: typeof genesisCovenantId;
+declare namespace genesis {
+  export { type genesis_AuthOutput as AuthOutput, type genesis_GenesisOutpoint as GenesisOutpoint, genesis_ZERO_COVID as ZERO_COVID, genesis_bytesToCovid as bytesToCovid, genesis_covidToBytes as covidToBytes, genesis_genesisCovenantId as genesisCovenantId };
+}
+
+type K$5 = Kaspa;
+type Spk$4 = any;
+/** A covenant UTXO being spent, already carrying its signature script (no wallet signature needed). */
+type CovInput = {
+    transactionId: string;
+    index: number;
+    value: bigint;
+    scriptPublicKey: Spk$4;
+    /** the covenant signature script (hex): <args> [selector] <redeem>, or kcc20 <transfer args> <redeem>. */
+    signatureScript: string;
+    /** redeem script bytes (kept so a caller can re-derive / inspect the spend). */
+    redeem: Uint8Array;
+    /** what this input is, for assembly/debugging: 'curve' | 'minterBranch' | 'burn' | 'pool' | 'poolToken'. */
+    role: string;
+};
+/** A covenant-required output (value + scriptPublicKey). */
+type CovOutput = {
+    value: bigint;
+    scriptPublicKey: Spk$4;
+    role: string;
+};
+/** A complete covenant action: the inputs it spends + the outputs it must create + computed economics. */
+type CovenantSpend = {
+    kind: 'init' | 'initVested' | 'buy' | 'sell' | 'graduate' | 'swapKasForToken' | 'swapTokenForKas' | 'addLiquidity' | 'removeLiquidity' | 'bindLp' | 'claim' | 'claimFinal';
+    inputs: CovInput[];
+    outputs: CovOutput[];
+    economics: Record<string, bigint>;
+    /** covenant-ids this action establishes/uses (hex): the bound token `A`, a new pool `P`, the curve `C`. */
+    covids?: {
+        tokenCovid?: string;
+        poolCovid?: string;
+        curveCovid?: string;
+    };
+};
+/** A funding UTXO entry (SDK UtxoEntryReference from rpc.getUtxosByAddresses, or a plain IUtxoEntry). */
+type FundingEntry = any;
+type AssembledNativeTx = {
+    transaction: any;
+    /** indices of inputs the trader/wallet must sign (the covenant inputs come first and are pre-scripted). */
+    fundingInputIndexes: number[];
+    totalIn: bigint;
+    covenantOut: bigint;
+    change: bigint;
+};
+/**
+ * Assemble a complete tx: the spend's covenant inputs (pre-scripted) + the trader's funding inputs + a
+ * change output. `networkFee` is caller-provided (derive from the node; KIP-9 storage mass depends on
+ * output values, so the node confirms the exact fee/change at broadcast). Covenant inputs carry sigOpCount
+ * 0 (no checkSig on the accept path used here); funding inputs are signed via signFundingInputs.
+ */
+declare function assembleNativeTx(k: K$5, opts: {
+    spend: CovenantSpend;
+    fundingEntries: FundingEntry[];
+    changeAddress: string;
+    networkFee: bigint;
+}): AssembledNativeTx;
+/** Sign the trader's funding inputs (P2PK) in place; covenant inputs are left untouched (pre-scripted). */
+declare function signFundingInputs(k: K$5, tx: any, privKey: any, fundingInputIndexes: number[]): any;
+/**
+ * Shape the assembled tx for a signPskt-style wallet bridge. Returns the tx JSON the wallet deserializes
+ * plus the inputs it should sign (the trader's P2PK funding inputs only).
+ */
+declare function toPsktJson(asm: AssembledNativeTx, sighashType?: number): {
+    txJsonString: string;
+    signInputs: {
+        index: number;
+        sighashType: number;
+    }[];
+};
+/**
+ * The local side of a signPskt-style wallet bridge: deserialize a tx (Safe JSON), sign ONLY the listed
+ * inputs with `privKey` (the user's P2PK inputs — funding, or the co-present presence input that authorizes
+ * a sell/transfer of an address-owned token), reserialize to Safe JSON. Covenant inputs (not listed) are
+ * left untouched: their transition rules — or the presence-based ownership check against a co-present
+ * signed P2PK input — authorize them, so the wallet never signs a covenant P2SH input directly. This is
+ * exactly what an extension wallet's native `signPskt({ txJsonString, options: { signInputs } })` does; use
+ * this function to emulate that bridge with a raw key (e.g. for a backend bot holding its own key).
+ */
+declare function signPsktWithKey(k: K$5, txJsonString: string, signInputs: {
+    index: number;
+}[], privKey: any): string;
+
+type spend_AssembledNativeTx = AssembledNativeTx;
+type spend_CovInput = CovInput;
+type spend_CovOutput = CovOutput;
+type spend_CovenantSpend = CovenantSpend;
+type spend_FundingEntry = FundingEntry;
+declare const spend_assembleNativeTx: typeof assembleNativeTx;
+declare const spend_signFundingInputs: typeof signFundingInputs;
+declare const spend_signPsktWithKey: typeof signPsktWithKey;
+declare const spend_toPsktJson: typeof toPsktJson;
+declare namespace spend {
+  export { type spend_AssembledNativeTx as AssembledNativeTx, type spend_CovInput as CovInput, type spend_CovOutput as CovOutput, type spend_CovenantSpend as CovenantSpend, type spend_FundingEntry as FundingEntry, spend_assembleNativeTx as assembleNativeTx, spend_signFundingInputs as signFundingInputs, spend_signPsktWithKey as signPsktWithKey, spend_toPsktJson as toPsktJson };
+}
+
+type K$4 = Kaspa;
+type Spk$3 = any;
+/** kcc20 identifierType (ownership mode) values — dispatched by `transfer`'s checkSigs. */
+declare const IDENTIFIER: {
+    readonly PUBKEY: 0;
+    readonly SCRIPT_HASH: 1;
+    readonly COVENANT_ID: 2;
+    readonly ADDRESS: 3;
+};
+type IdentifierType = (typeof IDENTIFIER)[keyof typeof IDENTIFIER];
+/** A kcc20 token balance's full state (the 4 reference fields). `ownerIdentifier` is 32 bytes. */
+type Kcc20State = {
+    ownerIdentifier: Uint8Array;
+    identifierType: IdentifierType;
+    amount: bigint;
+    isMinter: boolean;
+};
+/** Compiled token template: silverc output at the genesis state + the (maxIns,maxOuts) it was built for. */
+type Kcc20Template = {
+    script: Uint8Array;
+    stateStart: number;
+    maxIns: number;
+    maxOuts: number;
+};
+/** Produce the kcc20 redeem script for `state` by splicing the 46-byte region. Byte-identical to silverc. */
+declare function materializeKcc20Script(tpl: Kcc20Template, state: Kcc20State): Uint8Array;
+/** Token P2SH scriptPublicKey for a redeem script. */
+declare const kcc20Spk: (k: K$4, redeem: Uint8Array) => Spk$3;
+/** Token P2SH scriptPublicKey for a balance state (materialize → P2SH). */
+declare const kcc20SpkForState: (k: K$4, tpl: Kcc20Template, state: Kcc20State) => Spk$3;
+/** Token P2SH address (where this balance lives) for a balance state. */
+declare function kcc20Address(k: K$4, tpl: Kcc20Template, state: Kcc20State, network: string): string;
+/** A balance owned by a covenant-id `C` (mode 0x02): spendable only in a tx that also spends an input
+ *  carrying `C`. This is how the curve owns its minter branch and the pool owns its token UTXO. */
+declare const covenantIdOwned: (covid32: Uint8Array, amount: bigint, isMinter?: boolean) => Kcc20State;
+/** A balance owned by a 32-byte x-only pubkey (mode 0x00): a user's normal holding (needs a signature). */
+declare const pubkeyOwned: (pubkey32: Uint8Array, amount: bigint) => Kcc20State;
+/** A balance owned by a 32-byte P2SH script-hash (mode 0x01): needs a matching P2SH input in the tx. */
+declare const scriptHashOwned: (hash32: Uint8Array, amount: bigint) => Kcc20State;
+/** A balance owned by a normal ADDRESS (mode 0x03, presence-based): spendable when the tx carries a
+ *  co-present input at the owner's P2PK address (a wallet-signed input). The token UTXO itself carries NO
+ *  signature, so sell/transfer work with existing wallets via a signPskt-style bridge. owner = x-only pubkey. */
+declare const addressPresenceOwned: (pubkey32: Uint8Array, amount: bigint) => Kcc20State;
+/** Push a SINGLE `State`/`TokenState` struct arg field-by-field (declared order, scalar rules) — used by
+ *  entrypoints whose covenant takes individual structs (e.g. curve buy/sell/graduate, pool swap). */
+declare function pushKcc20StateScalar(b: SigScriptBuilder, st: Kcc20State): void;
+/** Push a `State[]` arg column-major (owners ‖ types ‖ amounts ‖ isMinters), per build_sig_script. */
+declare function pushKcc20States(b: SigScriptBuilder, states: Kcc20State[]): void;
+/**
+ * Build the kcc20 `transfer` signature script for a token covenant input:
+ *   <newStates column-major> <sigs> <witnesses> <redeem>   (single entrypoint → no selector)
+ * `witnesses[i]` is the tx-input index that authorizes input i (for covenant-id ownership, the input
+ * carrying that covenant id). `sigs` are 65-byte Schnorr sigs (empty for covenant-id-only ownership).
+ */
+declare function transferSigScript(k: K$4, redeem: Uint8Array, newStates: Kcc20State[], witnesses: number[], sigs?: Uint8Array[]): string;
+
+declare const kcc20Tx_IDENTIFIER: typeof IDENTIFIER;
+type kcc20Tx_IdentifierType = IdentifierType;
+type kcc20Tx_Kcc20State = Kcc20State;
+type kcc20Tx_Kcc20Template = Kcc20Template;
+declare const kcc20Tx_addressPresenceOwned: typeof addressPresenceOwned;
+declare const kcc20Tx_covenantIdOwned: typeof covenantIdOwned;
+declare const kcc20Tx_kcc20Address: typeof kcc20Address;
+declare const kcc20Tx_kcc20Spk: typeof kcc20Spk;
+declare const kcc20Tx_kcc20SpkForState: typeof kcc20SpkForState;
+declare const kcc20Tx_materializeKcc20Script: typeof materializeKcc20Script;
+declare const kcc20Tx_pubkeyOwned: typeof pubkeyOwned;
+declare const kcc20Tx_pushKcc20StateScalar: typeof pushKcc20StateScalar;
+declare const kcc20Tx_pushKcc20States: typeof pushKcc20States;
+declare const kcc20Tx_scriptHashOwned: typeof scriptHashOwned;
+declare const kcc20Tx_transferSigScript: typeof transferSigScript;
+declare namespace kcc20Tx {
+  export { kcc20Tx_IDENTIFIER as IDENTIFIER, type kcc20Tx_IdentifierType as IdentifierType, type kcc20Tx_Kcc20State as Kcc20State, type kcc20Tx_Kcc20Template as Kcc20Template, kcc20Tx_addressPresenceOwned as addressPresenceOwned, kcc20Tx_covenantIdOwned as covenantIdOwned, kcc20Tx_kcc20Address as kcc20Address, kcc20Tx_kcc20Spk as kcc20Spk, kcc20Tx_kcc20SpkForState as kcc20SpkForState, kcc20Tx_materializeKcc20Script as materializeKcc20Script, kcc20Tx_pubkeyOwned as pubkeyOwned, kcc20Tx_pushKcc20StateScalar as pushKcc20StateScalar, kcc20Tx_pushKcc20States as pushKcc20States, kcc20Tx_scriptHashOwned as scriptHashOwned, kcc20Tx_transferSigScript as transferSigScript };
+}
+
+type K$3 = Kaspa;
+type Spk$2 = any;
+/** pool entrypoint selectors (declaration order in amm_pool_cp_v3.sil). */
+declare const POOL_CP_SELECTOR: {
+    readonly swapKasForToken: 0;
+    readonly swapTokenForKas: 1;
+    readonly addLiquidity: 2;
+    readonly removeLiquidity: 3;
+    readonly bindLp: 4;
+};
+/** the LP-share token's FIXED total supply S_MAX (== MAX_SHARES in amm_pool_cp_v3.sil). */
+declare const MAX_SHARES = 10000000n;
+/** Compiled pool template (silverc output; one template per (lockedShares,bps...) — only state varies). */
+type PoolCpTemplate = {
+    script: Uint8Array;
+    stateStart: number;
+};
+/** Pool state: KAS reserve (SCALE units; pool UTXO value == kasReserve·SCALE), token reserve, the token
+ *  covid A, issued LP shares, and the LP-share token covid L (ZERO until bindLp). */
+type PoolCpState = {
+    kasReserve: bigint;
+    tokenReserve: bigint;
+    tokenCovid: Uint8Array;
+    totalShares: bigint;
+    lpCovid: Uint8Array;
+};
+/** Produce the pool redeem script for `state` by splicing the 93-byte region. Byte-identical to silverc. */
+declare function materializePoolCpScript(tpl: PoolCpTemplate, state: PoolCpState): Uint8Array;
+declare const poolCpSpk: (k: K$3, redeem: Uint8Array) => Spk$2;
+declare const poolCpSpkForState: (k: K$3, tpl: PoolCpTemplate, state: PoolCpState) => Spk$2;
+declare function poolCpAddress(k: K$3, tpl: PoolCpTemplate, state: PoolCpState, network: string): string;
+/** Fixed per-pool fee schedule (baked into the redeem script by silverc; the builder needs them for quotes). */
+type PoolCpParams = {
+    creatorFeeOwner: Uint8Array;
+    platformFeeOwner: Uint8Array;
+    creatorFeeBps: bigint;
+    platformFeeBps: bigint;
+    lpFeeBps: bigint;
+    lockedShares: bigint;
+};
+/** The live pool UTXO (value = kasReserve·SCALE) + its P-owned token-A reserve UTXO. */
+type PoolCpUtxo = {
+    transactionId: string;
+    index: number;
+    state: PoolCpState;
+    /** the pool's token-A reserve UTXO (kcc20 owned by the pool covid P, amount = tokenReserve). */
+    tokenUtxo: {
+        transactionId: string;
+        index: number;
+        value: bigint;
+    };
+};
+/** The pool's P-owned LP-share (L) inventory UTXO (amount = the unissued shares the pool holds). */
+type PoolLpInventoryUtxo = {
+    transactionId: string;
+    index: number;
+    value: bigint;
+    amount: bigint;
+};
+type PoolCpBuyQuote = {
+    kasInUnits: bigint;
+    kasIn: bigint;
+    tokenOut: bigint;
+    creatorFee: bigint;
+    creatorFloorRent: bigint;
+    platformFee: bigint;
+    lpFee: bigint;
+    creatorOut: bigint;
+    platformOut: bigint;
+    total: bigint;
+    newKas: bigint;
+    newToken: bigint;
+};
+type PoolCpSellQuote = {
+    tokenIn: bigint;
+    kasOutUnits: bigint;
+    kasOut: bigint;
+    creatorFee: bigint;
+    creatorFloorRent: bigint;
+    platformFee: bigint;
+    lpFee: bigint;
+    creatorOut: bigint;
+    platformOut: bigint;
+    net: bigint;
+    newKas: bigint;
+    newToken: bigint;
+};
+/** Buy from the pool: spend `kasInSompi` (floored to a SCALE step) → tokenOut, retaining the voluntary LP fee in-pool. */
+declare function quotePoolCpBuy(state: PoolCpState, p: PoolCpParams, kasInSompi: bigint): PoolCpBuyQuote | null;
+/** Sell to the pool: fold `tokenIn` tokens in → kasOut sompi (a SCALE step), retaining the voluntary LP fee in-pool. */
+declare function quotePoolCpSell(state: PoolCpState, p: PoolCpParams, tokenIn: bigint): PoolCpSellQuote | null;
+type AddLiquidityQuote = {
+    dKas: bigint;
+    dToken: bigint;
+    dShares: bigint;
+    newKas: bigint;
+    newToken: bigint;
+    newShares: bigint;
+};
+type RemoveLiquidityQuote = {
+    dShares: bigint;
+    dKas: bigint;
+    dToken: bigint;
+    newKas: bigint;
+    newToken: bigint;
+    newShares: bigint;
+};
+/** The smallest deposit (in SCALE units) that mints ≥ 1 LP share at the current ratio. The covenant floors
+ *  dShares = floor(totalShares·dKas/kasReserve), so dShares ≥ 1 ⟺ dKas ≥ ceil(kasReserve/totalShares). ANY dKas
+ *  at/above this deposits — the old exact-integer lcm "step" (which could force a near-whole-pool minimum when the
+ *  reserves were coprime to totalShares) is gone now that addLiquidity is floored like removeLiquidity. */
+declare function addMinDKas(state: PoolCpState): bigint;
+/** Clamp a desired `dKas` to a valid deposit: unchanged if ≥ the minimum (see addMinDKas), else 0 (too small to
+ *  mint an integer share). No down-stepping — every value at/above the min is valid now that the covenant floors. */
+declare function snapAddDKas(state: PoolCpState, desiredDKas: bigint): bigint;
+/** Size a balanced deposit from `dKas` (SCALE units), FLOORED to match the covenant: dShares =
+ *  floor(totalShares·dKas/kasReserve) (the depositor never gets more than their KAS-contribution fraction, so
+ *  existing LPs aren't diluted), dToken = ceil(tokenReserve·dShares/totalShares) (they supply ≥ the proportional
+ *  token). Any dKas ≥ addMinDKas works; throws only if dKas rounds to 0 shares. */
+declare function quoteAddLiquidity(state: PoolCpState, dKas: bigint): AddLiquidityQuote;
+/** The smallest withdrawable dShares — the floored covenant only needs the payout to round to ≥ 1 on BOTH sides
+ *  (dKas ≥ 1 ⟺ dShares ≥ ⌈totalShares/kasReserve⌉; dToken ≥ 1 likewise). No exact-integer "step" exists anymore,
+ *  so any dShares at/above this withdraws (the old lcm-step that could strand a voluntary LP is gone). */
+declare function removeMinDShares(state: PoolCpState): bigint;
+/** Clamp a desired `dShares` to a withdrawable amount: returns it unchanged if ≥ the minimum (see removeMinDShares),
+ *  else 0 (too small to round to ≥ 1 of either side). No down-stepping — every value at/above the min is valid. */
+declare function snapRemoveDShares(state: PoolCpState, desiredDShares: bigint): bigint;
+/** Compute a FLOORED-proportional withdrawal for `dShares` (matches the covenant): dKas/dToken are floored, so
+ *  the sub-unit remainder stays in the pool. Throws only if dShares is non-positive, would dip below the locked
+ *  floor (totalShares − dShares < lockedShares), or is so small the floored payout rounds to < 1 of either side. */
+declare function quoteRemoveLiquidity(state: PoolCpState, p: Pick<PoolCpParams, 'lockedShares'>, dShares: bigint): RemoveLiquidityQuote;
+/**
+ * addLiquidity — deposit dKas (SCALE units) + dToken at the current ratio, receive dShares of L moved out of
+ * the pool's inventory. The LP must supply a token-A UTXO of EXACTLY dToken (full-UTXO deposit — the covenant
+ * allows only ONE covid-A output, the grown pool reserve) and a co-present P2PK input at `presenceWitnessIdx`.
+ *
+ * Inputs:  [0]=pool [1]=LP token-A deposit(presence, =dToken) [2]=pool token-A reserve(P) [3]=pool L inventory(P)
+ * Outputs: [0]=pool(grown) [1]=pool token-A reserve(P, newToken) [2]=reduced pool L inventory(P) [3]=LP dShares(presence)
+ */
+declare function buildAddLiquidity(k: K$3, tpl: PoolCpTemplate, tokenTpl: Kcc20Template, utxo: PoolCpUtxo, lpInventory: PoolLpInventoryUtxo, poolCovid: Uint8Array, lpDepositToken: {
+    transactionId: string;
+    index: number;
+    value: bigint;
+    state: Kcc20State;
+}, lpPubkey: Uint8Array, q: AddLiquidityQuote, presenceWitnessIdx: number, opts?: {
+    tokenDust?: bigint;
+}): CovenantSpend;
+/**
+ * removeLiquidity — return dShares of L to the pool inventory, withdraw a strictly-proportional dKas + dToken.
+ * The withdrawn KAS is the tx change (the pool value drops by dKas·SCALE). The LP must supply an L UTXO of
+ * EXACTLY dShares (full-UTXO) and a co-present P2PK input at `presenceWitnessIdx`. The covenant floor guard
+ * (totalShares − dShares ≥ lockedShares) makes the graduation floor un-withdrawable.
+ *
+ * Inputs:  [0]=pool [1]=pool token-A reserve(P) [2]=LP L shares(presence, =dShares)
+ * Outputs: [0]=pool(shrunk) [1]=pool token-A reserve(P, newToken) [2]=LP withdrawn token(presence, dToken)
+ *          [3]=dShares returned to the pool L inventory(P)
+ */
+declare function buildRemoveLiquidity(k: K$3, tpl: PoolCpTemplate, tokenTpl: Kcc20Template, utxo: PoolCpUtxo, lpShares: {
+    transactionId: string;
+    index: number;
+    value: bigint;
+    state: Kcc20State;
+}, poolCovid: Uint8Array, lpPubkey: Uint8Array, q: RemoveLiquidityQuote, presenceWitnessIdx: number, opts?: {
+    tokenDust?: bigint;
+}): CovenantSpend;
+/** The result of buildBindLp: the spend + the freshly-derived L covid + the inventory the pool now holds. */
+type BindLpResult = CovenantSpend & {
+    lpCovidHex: string;
+    lpInventoryAmount: bigint;
+};
+/**
+ * bindLp — runs once on a freshly-graduated pool (lpCovid == ZERO, totalShares == lockedShares). Genesis-mints
+ * the FIXED supply (MAX_SHARES) of the LP-share token L: the floor (lockedShares) is burned to an unspendable
+ * ZERO-covid owner, the rest (MAX_SHARES − lockedShares) seeds the pool's inventory (owned by the pool covid
+ * P). L carries NO minter branch → its supply is fixed forever (mint-renounced, like token A's init). The pool
+ * continuation carries lpCovid = the new L genesis covid; value + reserves + totalShares are unchanged.
+ *
+ * Inputs:  [0]=pool (lpCovid == ZERO)
+ * Outputs: [0]=pool(lpCovid bound) [1]=locked floor L(ZERO-owned, lockedShares) [2]=pool L inventory(P-owned)
+ */
+declare function buildBindLp(k: K$3, tpl: PoolCpTemplate, tokenTpl: Kcc20Template, utxo: PoolCpUtxo, poolCovid: Uint8Array, lockedShares: bigint, opts?: {
+    tokenDust?: bigint;
+}): BindLpResult;
+
+type poolCpTx_AddLiquidityQuote = AddLiquidityQuote;
+type poolCpTx_BindLpResult = BindLpResult;
+declare const poolCpTx_MAX_SHARES: typeof MAX_SHARES;
+declare const poolCpTx_POOL_CP_SELECTOR: typeof POOL_CP_SELECTOR;
+type poolCpTx_PoolCpBuyQuote = PoolCpBuyQuote;
+type poolCpTx_PoolCpParams = PoolCpParams;
+type poolCpTx_PoolCpSellQuote = PoolCpSellQuote;
+type poolCpTx_PoolCpState = PoolCpState;
+type poolCpTx_PoolCpTemplate = PoolCpTemplate;
+type poolCpTx_PoolCpUtxo = PoolCpUtxo;
+type poolCpTx_PoolLpInventoryUtxo = PoolLpInventoryUtxo;
+type poolCpTx_RemoveLiquidityQuote = RemoveLiquidityQuote;
+declare const poolCpTx_addMinDKas: typeof addMinDKas;
+declare const poolCpTx_buildAddLiquidity: typeof buildAddLiquidity;
+declare const poolCpTx_buildBindLp: typeof buildBindLp;
+declare const poolCpTx_buildRemoveLiquidity: typeof buildRemoveLiquidity;
+declare const poolCpTx_materializePoolCpScript: typeof materializePoolCpScript;
+declare const poolCpTx_poolCpAddress: typeof poolCpAddress;
+declare const poolCpTx_poolCpSpk: typeof poolCpSpk;
+declare const poolCpTx_poolCpSpkForState: typeof poolCpSpkForState;
+declare const poolCpTx_quoteAddLiquidity: typeof quoteAddLiquidity;
+declare const poolCpTx_quotePoolCpBuy: typeof quotePoolCpBuy;
+declare const poolCpTx_quotePoolCpSell: typeof quotePoolCpSell;
+declare const poolCpTx_quoteRemoveLiquidity: typeof quoteRemoveLiquidity;
+declare const poolCpTx_removeMinDShares: typeof removeMinDShares;
+declare const poolCpTx_snapAddDKas: typeof snapAddDKas;
+declare const poolCpTx_snapRemoveDShares: typeof snapRemoveDShares;
+declare namespace poolCpTx {
+  export { type poolCpTx_AddLiquidityQuote as AddLiquidityQuote, type poolCpTx_BindLpResult as BindLpResult, poolCpTx_MAX_SHARES as MAX_SHARES, poolCpTx_POOL_CP_SELECTOR as POOL_CP_SELECTOR, type poolCpTx_PoolCpBuyQuote as PoolCpBuyQuote, type poolCpTx_PoolCpParams as PoolCpParams, type poolCpTx_PoolCpSellQuote as PoolCpSellQuote, type poolCpTx_PoolCpState as PoolCpState, type poolCpTx_PoolCpTemplate as PoolCpTemplate, type poolCpTx_PoolCpUtxo as PoolCpUtxo, type poolCpTx_PoolLpInventoryUtxo as PoolLpInventoryUtxo, type poolCpTx_RemoveLiquidityQuote as RemoveLiquidityQuote, poolCpTx_addMinDKas as addMinDKas, poolCpTx_buildAddLiquidity as buildAddLiquidity, poolCpTx_buildBindLp as buildBindLp, poolCpTx_buildRemoveLiquidity as buildRemoveLiquidity, poolCpTx_materializePoolCpScript as materializePoolCpScript, poolCpTx_poolCpAddress as poolCpAddress, poolCpTx_poolCpSpk as poolCpSpk, poolCpTx_poolCpSpkForState as poolCpSpkForState, poolCpTx_quoteAddLiquidity as quoteAddLiquidity, poolCpTx_quotePoolCpBuy as quotePoolCpBuy, poolCpTx_quotePoolCpSell as quotePoolCpSell, poolCpTx_quoteRemoveLiquidity as quoteRemoveLiquidity, poolCpTx_removeMinDShares as removeMinDShares, poolCpTx_snapAddDKas as snapAddDKas, poolCpTx_snapRemoveDShares as snapRemoveDShares };
+}
+
+type K$2 = Kaspa;
+type Spk$1 = any;
+declare const SCALE = 1000000n;
+declare const SELECTOR: {
+    readonly init: 0;
+    readonly buy: 1;
+    readonly sell: 2;
+    readonly graduate: 3;
+    readonly initVested: 4;
+};
+/** Fixed per-token curve parameters (baked into the redeem script by silverc). */
+type CpParams = {
+    creatorFeeOwner: Uint8Array;
+    platformFeeOwner: Uint8Array;
+    vKas: bigint;
+    graduationKas: bigint;
+    creatorFeeBps: bigint;
+    platformFeeBps: bigint;
+    graduationFeeBps: bigint;
+};
+type CpTemplate = {
+    script: Uint8Array;
+    stateStart: number;
+    params: CpParams;
+};
+type CpCurveState = {
+    graduated: boolean;
+    tokenCovid: Uint8Array;
+};
+/** The live curve UTXO. `realKas` (sompi) = its value = KAS raised. */
+type CpCurveUtxo = {
+    transactionId: string;
+    index: number;
+    realKas: bigint;
+    state: CpCurveState;
+};
+/** The curve's C-owned token inventory UTXO (covid A). `amount` = tokens remaining. */
+type CpInventoryUtxo = {
+    transactionId: string;
+    index: number;
+    value: bigint;
+    amount: bigint;
+};
+declare function materializeCpScript(tpl: CpTemplate, state: CpCurveState): Uint8Array;
+declare const cpSpk: (k: K$2, redeem: Uint8Array) => Spk$1;
+declare const cpSpkForState: (k: K$2, tpl: CpTemplate, state: CpCurveState) => Spk$1;
+declare function cpAddress(k: K$2, tpl: CpTemplate, state: CpCurveState, network: string): string;
+/** Fee output scriptPublicKey: P2PK (`<32-byte pubkey> OP_CHECKSIG`). */
+declare function p2pkSpk(k: K$2, pubkey: Uint8Array): Spk$1;
+declare function buildCpBuy(k: K$2, tpl: CpTemplate, tokenTpl: Kcc20Template, utxo: CpCurveUtxo, inventory: CpInventoryUtxo, curveCovid: Uint8Array, buyerPubkey: Uint8Array, kasIn: bigint, tokenOut: bigint, opts?: {
+    tokenDust?: bigint;
+}): CovenantSpend;
+declare function buildCpSell(k: K$2, tpl: CpTemplate, tokenTpl: Kcc20Template, utxo: CpCurveUtxo, sellerToken: {
+    transactionId: string;
+    index: number;
+    value: bigint;
+    state: Kcc20State;
+}, inventory: CpInventoryUtxo, curveCovid: Uint8Array, tokenIn: bigint, kasOut: bigint, presenceWitnessIdx: number, opts?: {
+    tokenDust?: bigint;
+}): CovenantSpend;
+declare function buildCpGraduate(k: K$2, tpl: CpTemplate, tokenTpl: Kcc20Template, poolTemplate: PoolCpTemplate, utxo: CpCurveUtxo, inventory: CpInventoryUtxo, curveCovid: Uint8Array, poolLockedShares: bigint, opts?: {
+    lockedCurveValue?: bigint;
+    tokenDust?: bigint;
+}): CovenantSpend;
+/**
+ * Split a presence-owned token UTXO into [sellAmount, change], both still presence-owned by the same holder —
+ * a plain conserving kcc20 transfer authorized by a co-present P2PK input at `presenceWitnessIdx`. Lets a
+ * holder sell an ARBITRARY amount on covenants that require full-UTXO sells (curve/pool): split, then sell the
+ * `sellAmount` piece. No curve/pool involved — just the token covenant.
+ */
+declare function buildSplitToken(k: K$2, tokenTpl: Kcc20Template, sellerToken: {
+    transactionId: string;
+    index: number;
+    value: bigint;
+    state: Kcc20State;
+}, sellAmount: bigint, presenceWitnessIdx: number, opts?: {
+    tokenDust?: bigint;
+}): CovenantSpend;
+/**
+ * Consolidate several presence-owned token UTXOs (same owner) into ONE — a conserving kcc20 transfer (N covid-A
+ * inputs → 1 output) authorized by a single co-present P2PK input at `presenceWitnessIdx`. Lets a holder merge
+ * many small buys into one piece so a later sell needs just one (or two) inputs. No curve/pool involved.
+ */
+declare function buildConsolidate(k: K$2, tokenTpl: Kcc20Template, tokens: {
+    transactionId: string;
+    index: number;
+    value: bigint;
+    state: Kcc20State;
+}[], presenceWitnessIdx: number, opts?: {
+    tokenDust?: bigint;
+}): CovenantSpend;
+
+type curveCpTx_CpCurveState = CpCurveState;
+type curveCpTx_CpCurveUtxo = CpCurveUtxo;
+type curveCpTx_CpInventoryUtxo = CpInventoryUtxo;
+type curveCpTx_CpParams = CpParams;
+type curveCpTx_CpTemplate = CpTemplate;
+declare const curveCpTx_SCALE: typeof SCALE;
+declare const curveCpTx_SELECTOR: typeof SELECTOR;
+declare const curveCpTx_buildConsolidate: typeof buildConsolidate;
+declare const curveCpTx_buildCpBuy: typeof buildCpBuy;
+declare const curveCpTx_buildCpGraduate: typeof buildCpGraduate;
+declare const curveCpTx_buildCpSell: typeof buildCpSell;
+declare const curveCpTx_buildSplitToken: typeof buildSplitToken;
+declare const curveCpTx_cpAddress: typeof cpAddress;
+declare const curveCpTx_cpSpk: typeof cpSpk;
+declare const curveCpTx_cpSpkForState: typeof cpSpkForState;
+declare const curveCpTx_materializeCpScript: typeof materializeCpScript;
+declare const curveCpTx_p2pkSpk: typeof p2pkSpk;
+declare namespace curveCpTx {
+  export { type curveCpTx_CpCurveState as CpCurveState, type curveCpTx_CpCurveUtxo as CpCurveUtxo, type curveCpTx_CpInventoryUtxo as CpInventoryUtxo, type curveCpTx_CpParams as CpParams, type curveCpTx_CpTemplate as CpTemplate, curveCpTx_SCALE as SCALE, curveCpTx_SELECTOR as SELECTOR, curveCpTx_buildConsolidate as buildConsolidate, curveCpTx_buildCpBuy as buildCpBuy, curveCpTx_buildCpGraduate as buildCpGraduate, curveCpTx_buildCpSell as buildCpSell, curveCpTx_buildSplitToken as buildSplitToken, curveCpTx_cpAddress as cpAddress, curveCpTx_cpSpk as cpSpk, curveCpTx_cpSpkForState as cpSpkForState, curveCpTx_materializeCpScript as materializeCpScript, curveCpTx_p2pkSpk as p2pkSpk };
+}
+
+type K$1 = Kaspa;
+type PoolCpV3Template = PoolCpTemplate;
+type PoolCpV3State = PoolCpState;
+type PoolV3Params = PoolCpParams;
+type PoolCpV3Utxo = PoolCpUtxo;
+declare const materializePoolCpV3Script: typeof materializePoolCpScript;
+declare const poolCpV3Spk: (k: typeof vendor_kaspa_kaspa_js, redeem: Uint8Array) => any;
+declare const poolCpV3SpkForState: (k: typeof vendor_kaspa_kaspa_js, tpl: PoolCpTemplate, state: PoolCpState) => any;
+declare const poolCpV3Address: typeof poolCpAddress;
+declare const quotePoolV3Buy: typeof quotePoolCpBuy;
+declare const quotePoolV3Sell: typeof quotePoolCpSell;
+/** v3 pool entrypoint selectors (same declaration order as v2). */
+declare const POOL_V3_SELECTOR: {
+    readonly swapKasForToken: 0;
+    readonly swapTokenForKas: 1;
+    readonly addLiquidity: 2;
+    readonly removeLiquidity: 3;
+    readonly bindLp: 4;
+};
+/** swapKasForToken (v3 — MERGE): buy `q.tokenOut`, optionally merging the buyer's EXISTING token UTXO(s)
+ *  (`mergeTokens`, presence-owned, authorized by the co-present P2PK at `presenceWitnessIdx`) into ONE trader
+ *  output of amount `tokenOut + Σ(existing)`. With no mergeTokens it's a plain buy. Outputs: [0]=pool [1]=pool
+ *  token(P) [2]=trader token(presence, merged) [3]=creatorFee [4]=platformFee. kcc20 conservation pins the merge. */
+declare function buildPoolV3SwapKasForToken(k: K$1, tpl: PoolCpV3Template, tokenTpl: Kcc20Template, params: PoolV3Params, utxo: PoolCpV3Utxo, poolCovid: Uint8Array, traderPubkey: Uint8Array, q: PoolCpBuyQuote, mergeTokens?: {
+    transactionId: string;
+    index: number;
+    value: bigint;
+    state: Kcc20State;
+}[], presenceWitnessIdx?: number, opts?: {
+    tokenDust?: bigint;
+}): CovenantSpend;
+/** swapTokenForKas (v3 — FRACTIONAL): fold `q.tokenIn` of the trader's piece(s) into the pool, getting kasOut;
+ *  the UNSOLD remainder (Σ trader inputs − q.tokenIn) returns as ONE presence-owned change output (placed LAST).
+ *  Outputs: [0]=pool [1]=pool token(P) [2]=creatorFee [3]=platformFee [4]=OPTIONAL trader change(presence). */
+declare function buildPoolV3SwapTokenForKas(k: K$1, tpl: PoolCpV3Template, tokenTpl: Kcc20Template, params: PoolV3Params, utxo: PoolCpV3Utxo, poolCovid: Uint8Array, traderPubkey: Uint8Array, traderTokens: {
+    transactionId: string;
+    index: number;
+    value: bigint;
+    state: Kcc20State;
+}[], q: PoolCpSellQuote, presenceWitnessIdx: number, opts?: {
+    tokenDust?: bigint;
+}): CovenantSpend;
+
+declare const poolCpV3Tx_POOL_V3_SELECTOR: typeof POOL_V3_SELECTOR;
+type poolCpV3Tx_PoolCpV3State = PoolCpV3State;
+type poolCpV3Tx_PoolCpV3Template = PoolCpV3Template;
+type poolCpV3Tx_PoolCpV3Utxo = PoolCpV3Utxo;
+type poolCpV3Tx_PoolV3Params = PoolV3Params;
+declare const poolCpV3Tx_buildPoolV3SwapKasForToken: typeof buildPoolV3SwapKasForToken;
+declare const poolCpV3Tx_buildPoolV3SwapTokenForKas: typeof buildPoolV3SwapTokenForKas;
+declare const poolCpV3Tx_materializePoolCpV3Script: typeof materializePoolCpV3Script;
+declare const poolCpV3Tx_poolCpV3Address: typeof poolCpV3Address;
+declare const poolCpV3Tx_poolCpV3Spk: typeof poolCpV3Spk;
+declare const poolCpV3Tx_poolCpV3SpkForState: typeof poolCpV3SpkForState;
+declare const poolCpV3Tx_quotePoolV3Buy: typeof quotePoolV3Buy;
+declare const poolCpV3Tx_quotePoolV3Sell: typeof quotePoolV3Sell;
+declare namespace poolCpV3Tx {
+  export { poolCpV3Tx_POOL_V3_SELECTOR as POOL_V3_SELECTOR, type poolCpV3Tx_PoolCpV3State as PoolCpV3State, type poolCpV3Tx_PoolCpV3Template as PoolCpV3Template, type poolCpV3Tx_PoolCpV3Utxo as PoolCpV3Utxo, type poolCpV3Tx_PoolV3Params as PoolV3Params, poolCpV3Tx_buildPoolV3SwapKasForToken as buildPoolV3SwapKasForToken, poolCpV3Tx_buildPoolV3SwapTokenForKas as buildPoolV3SwapTokenForKas, poolCpV3Tx_materializePoolCpV3Script as materializePoolCpV3Script, poolCpV3Tx_poolCpV3Address as poolCpV3Address, poolCpV3Tx_poolCpV3Spk as poolCpV3Spk, poolCpV3Tx_poolCpV3SpkForState as poolCpV3SpkForState, poolCpV3Tx_quotePoolV3Buy as quotePoolV3Buy, poolCpV3Tx_quotePoolV3Sell as quotePoolV3Sell };
+}
+
+type K = Kaspa;
+type Spk = any;
+declare const VEST_SELECTOR: {
+    readonly claim: 0;
+    readonly claimFinal: 1;
+};
+/** Tokens vested by DAA score `daaScore` (linear from startScore over durationScore; capped at total). Mirrors
+ *  the covenant's cross-multiplied bound exactly, so the flow can offer `vested − claimed` to claim. */
+declare function vestedAmount(total: bigint, startScore: number, durationScore: number, daaScore: number): bigint;
+/** Fixed per-token vesting parameters (baked into the lock script by silverc). */
+type VestingParams = {
+    creatorIdentifier: string;
+    total: number;
+    startScore: number;
+    durationScore: number;
+};
+type VestingTemplate = {
+    script: Uint8Array;
+    stateStart: number;
+    stateLen: number;
+    params: VestingParams;
+};
+declare function materializeVestingScript(tpl: VestingTemplate, claimed: bigint): Uint8Array;
+declare const vestingSpk: (k: K, redeem: Uint8Array) => Spk;
+declare const vestingSpkForState: (k: K, tpl: VestingTemplate, claimed: bigint) => Spk;
+type VestUtxo = {
+    transactionId: string;
+    index: number;
+    value: bigint;
+};
+/**
+ * Partial claim: release `release` (0 < release < remaining) to the creator's presence, re-lock the rest under
+ * V. inputs [vesting(0), lockedToken(1)]; outputs [vesting cont(0), relock(1, A/V-owned), recipient(2, A/creator)].
+ * The flow must set tx.lockTime = current DAA score (consensus blocks the tx until then; the covenant reads it).
+ */
+declare function buildVestingClaim(k: K, vestTpl: VestingTemplate, tokenTpl: Kcc20Template, vestingUtxo: VestUtxo, lockedToken: VestUtxo, vestingCovid: Uint8Array, creatorPubkey: Uint8Array, claimed: bigint, release: bigint, opts?: {
+    tokenDust?: bigint;
+}): CovenantSpend;
+/** Final claim: once fully vested, pay ALL remaining to the creator and continue V with claimed=total (husk).
+ *  inputs [vesting(0), lockedToken(1)]; outputs [vesting cont(0), recipient(1, A/creator)]. */
+declare function buildVestingClaimFinal(k: K, vestTpl: VestingTemplate, tokenTpl: Kcc20Template, vestingUtxo: VestUtxo, lockedToken: VestUtxo, vestingCovid: Uint8Array, creatorPubkey: Uint8Array, claimed: bigint, opts?: {
+    tokenDust?: bigint;
+}): CovenantSpend;
+
+declare const vestingTx_VEST_SELECTOR: typeof VEST_SELECTOR;
+type vestingTx_VestUtxo = VestUtxo;
+type vestingTx_VestingParams = VestingParams;
+type vestingTx_VestingTemplate = VestingTemplate;
+declare const vestingTx_buildVestingClaim: typeof buildVestingClaim;
+declare const vestingTx_buildVestingClaimFinal: typeof buildVestingClaimFinal;
+declare const vestingTx_materializeVestingScript: typeof materializeVestingScript;
+declare const vestingTx_vestedAmount: typeof vestedAmount;
+declare const vestingTx_vestingSpk: typeof vestingSpk;
+declare const vestingTx_vestingSpkForState: typeof vestingSpkForState;
+declare namespace vestingTx {
+  export { vestingTx_VEST_SELECTOR as VEST_SELECTOR, type vestingTx_VestUtxo as VestUtxo, type vestingTx_VestingParams as VestingParams, type vestingTx_VestingTemplate as VestingTemplate, vestingTx_buildVestingClaim as buildVestingClaim, vestingTx_buildVestingClaimFinal as buildVestingClaimFinal, vestingTx_materializeVestingScript as materializeVestingScript, vestingTx_vestedAmount as vestedAmount, vestingTx_vestingSpk as vestingSpk, vestingTx_vestingSpkForState as vestingSpkForState };
+}
+
+type Provider = string;
+type Connected = {
+    provider: Provider;
+    address: string;
+};
+/** Which of the optional signing capabilities a given adapter instance actually implements. Check this
+ *  before relying on a method — an adapter that returns `signPskt: false` will throw if you call it anyway. */
+type WalletCapabilities = {
+    signPskt: boolean;
+    getXOnlyPublicKey: boolean;
+    signMessage: boolean;
+    reconnect: boolean;
+};
+interface WalletAdapter {
+    readonly provider: Provider;
+    readonly label: string;
+    isAvailable(): boolean;
+    /** Which optional methods this adapter actually implements (vs. throws on call). */
+    capabilities(): WalletCapabilities;
+    /** Connect/authorize; resolves to the active kaspa:/kaspatest: address. */
+    connect(): Promise<string>;
+    /** Silently restore a prior session on page load WITHOUT prompting the user (an already-authorized
+     *  accounts lookup with no popup, if the wallet supports one). Resolves to the address, or null if there
+     *  is nothing to restore. */
+    reconnect?(): Promise<string | null>;
+    getAddress(): string | null;
+    /**
+     * The signPskt wallet bridge: sign ONLY the listed inputs (the user's P2PK inputs) of a tx (Safe JSON)
+     * and return the signed tx (Safe JSON). Covenant inputs are never signed by the wallet — their
+     * transition rules / presence-based ownership authorize them. This is what makes sell/transfer work with
+     * existing wallets without KRON ever holding a key. See ../native/spend.ts `toPsktJson`.
+     */
+    signPskt?(txJsonString: string, signInputs: {
+        index: number;
+        sighashType?: number;
+    }[]): Promise<string>;
+    /** The connected account's 32-byte x-only pubkey hex (the curve/pool fee owner at deploy, or a
+     *  presence-owned token's owner identifier). null if unavailable. */
+    getXOnlyPublicKey?(): Promise<string | null>;
+    /** Sign a UTF-8 message with the account key (KIP-5 Kaspa message-signing scheme — see README "Message
+     *  signing"). Returns the Schnorr signature hex + the signer's x-only pubkey hex. null if unavailable. */
+    signMessage?(message: string): Promise<{
+        signature: string;
+        publicKey: string;
+    } | null>;
+    disconnect(): void;
+}
+/** Thrown by a wallet adapter method that exists on the interface but isn't implemented by a given wallet.
+ *  Distinct from a generic Error so callers can detect "not supported" vs. "failed". */
+declare class WalletCapabilityError extends Error {
+    readonly provider: Provider;
+    readonly method: string;
+    constructor(provider: Provider, method: string, hint?: string);
+}
+
+/**
+ * ExampleWalletAdapter — a template, not a real integration. It assumes a provider shaped like:
+ *   requestAccounts(): Promise<string[]>
+ *   getAccounts(): Promise<string[]>                          // already-authorized, no popup
+ *   signPskt({ txJsonString, options: { signInputs } }): Promise<string | { txJsonString }>
+ *   getPublicKey(): Promise<string>                            // compressed hex
+ *   signMessage(text: string): Promise<string>                 // KIP-5 scheme
+ * If your wallet's provider looks different (a different method name, a different sighash encoding, a
+ * different signing call shape entirely), adapt the method bodies accordingly — the `WalletAdapter`
+ * interface only constrains what you expose, not how you get there.
+ */
+declare class ExampleWalletAdapter implements WalletAdapter {
+    readonly provider = "exampleWallet";
+    readonly label = "Example Wallet (template)";
+    private address;
+    isAvailable(): boolean;
+    capabilities(): WalletCapabilities;
+    connect(): Promise<string>;
+    reconnect(): Promise<string | null>;
+    getAddress(): string | null;
+    signPskt(txJsonString: string, signInputs: {
+        index: number;
+        sighashType?: number;
+    }[]): Promise<string>;
+    getXOnlyPublicKey(): Promise<string | null>;
+    signMessage(message: string): Promise<{
+        signature: string;
+        publicKey: string;
+    } | null>;
+    disconnect(): void;
+}
+
+type index$1_Connected = Connected;
+type index$1_ExampleWalletAdapter = ExampleWalletAdapter;
+declare const index$1_ExampleWalletAdapter: typeof ExampleWalletAdapter;
+type index$1_Provider = Provider;
+type index$1_WalletAdapter = WalletAdapter;
+type index$1_WalletCapabilities = WalletCapabilities;
+type index$1_WalletCapabilityError = WalletCapabilityError;
+declare const index$1_WalletCapabilityError: typeof WalletCapabilityError;
+declare namespace index$1 {
+  export { type index$1_Connected as Connected, index$1_ExampleWalletAdapter as ExampleWalletAdapter, type index$1_Provider as Provider, type index$1_WalletAdapter as WalletAdapter, type index$1_WalletCapabilities as WalletCapabilities, index$1_WalletCapabilityError as WalletCapabilityError };
+}
+
+type CpState = {
+    realKas: number;
+    tokenReserve: number;
+    graduated: boolean;
+    poolTokenReserve?: number;
+    poolKas?: number;
+    poolTotalShares?: number;
+    poolLpCovid?: string;
+};
+type TokenInfo = {
+    tick: string;
+    name: string;
+    dec: number;
+    max: string;
+    minted: string;
+    holderTotal: number;
+    covenantId: string;
+    curveCovenantId: string;
+    poolCovenantId: string | null;
+    graduated: boolean;
+    tokenReserve: string;
+    cpState: CpState;
+    price?: number;
+    change24h?: number;
+    volume24h?: number;
+    volumeTotal?: number;
+    trades24h?: number;
+    tradesTotal?: number;
+    tvl?: number;
+    reserveKas?: string;
+};
+type Balance = {
+    tick: string;
+    balance: string;
+    dec: number;
+};
+type TokenUtxo = {
+    outpoint: {
+        transactionId: string;
+        index: number;
+    };
+    amount: string;
+    scriptPublicKey: string;
+    redeemScriptHex: string;
+    ownerAddress: string;
+};
+type PoolHead = {
+    pool: {
+        transactionId: string;
+        index: number;
+    };
+    poolToken: {
+        transactionId: string;
+        index: number;
+    };
+    reserves: {
+        kasReserve: string;
+        tokenReserve: string;
+        totalShares: string;
+        lpCovid: string | null;
+    };
+};
+type LpUtxo = {
+    outpoint: {
+        transactionId: string;
+        index: number;
+    };
+    amount: string;
+};
+type LpEarnings = {
+    tick: string;
+    address: string;
+    earnedKas: string;
+};
+type IndexerInfo = {
+    tokenTotal: number;
+    daaScore: number;
+    synced: boolean;
+    network: string;
+};
+type Trade = Record<string, unknown>;
+type Holder = {
+    address: string;
+    balance: string;
+};
+type Ohlc = {
+    t: number;
+    o: number;
+    h: number;
+    l: number;
+    c: number;
+    v: number;
+};
+declare class IndexerClient {
+    private baseUrl;
+    /** @param baseUrl e.g. 'https://idx.kron.technology/v1/kcc20' (TN10) — no default baked in; pass the
+     *  network-appropriate URL explicitly (mainnet endpoints publish separately at launch). */
+    constructor(baseUrl: string);
+    info(): Promise<IndexerInfo>;
+    markets(opts?: {
+        kind?: 'curve' | 'pool';
+    }): Promise<TokenInfo[]>;
+    topTraders(): Promise<unknown[]>;
+    token(tick: string): Promise<TokenInfo>;
+    balance(tick: string, address: string): Promise<Balance>;
+    tokenlist(address: string): Promise<Balance[]>;
+    tokenUtxos(tick: string, address: string): Promise<TokenUtxo[]>;
+    holders(tick: string): Promise<Holder[]>;
+    trades(tick: string, opts?: {
+        offset?: number;
+        limit?: number;
+    }): Promise<Trade[]>;
+    ohlc(tick: string, opts: {
+        interval: string;
+        from?: number;
+        to?: number;
+    }): Promise<Ohlc[]>;
+    addressTrades(address: string): Promise<Trade[]>;
+    poolhead(tick: string): Promise<PoolHead>;
+    lpUtxos(tick: string, address: string): Promise<LpUtxo[]>;
+    lpEarnings(tick: string, address: string): Promise<LpEarnings>;
+    /**
+     * Subscribe to the SSE update stream (all tokens, or one if `tick` is given). Returns an unsubscribe
+     * function. Browser: uses the native EventSource. Node: pass an EventSource-compatible constructor (e.g.
+     * the `eventsource` npm package) via `EventSourceImpl` — Node has no built-in EventSource on most
+     * supported versions.
+     */
+    stream(onUpdate: (data: unknown) => void, opts?: {
+        tick?: string;
+        EventSourceImpl?: typeof EventSource;
+    }): () => void;
+}
+
+type CpCurveParamsRecord = {
+    creatorFeeOwner: string;
+    platformFeeOwner: string;
+    vKas: number;
+    graduationKas: number;
+    creatorFeeBps: number;
+    platformFeeBps: number;
+    graduationFeeBps: number;
+    dexCreatorFeeBps: number;
+    dexPlatformFeeBps: number;
+    dexLpFeeBps?: number;
+    poolLockedShares?: number;
+    vestingCovid?: string;
+};
+type RegistryToken = {
+    tick: string;
+    name: string;
+    creator: string;
+    txid: string;
+    dec: number;
+    max: string;
+    description?: string;
+    image?: string;
+    links?: {
+        website?: string;
+        x?: string;
+        telegram?: string;
+    };
+    cp: {
+        curveParams: CpCurveParamsRecord;
+        tokenCovid?: string;
+        curveCovid?: string;
+        poolCovid?: string;
+        genesisTxid?: string;
+    };
+    chainVerified?: boolean;
+};
+declare class RegistryClient {
+    private baseUrl;
+    /** @param baseUrl e.g. 'https://api.kron.technology' (TN10) */
+    constructor(baseUrl: string);
+    tokens(): Promise<RegistryToken[]>;
+}
+
+type SequencerHead = {
+    head: {
+        poolOutpoint: {
+            transactionId: string;
+            index: number;
+        };
+        poolTokenOutpoint: {
+            transactionId: string;
+            index: number;
+        };
+        reserves: {
+            kasReserve: string;
+            tokenReserve: string;
+            totalShares: string;
+            lpCovid: string | null;
+        };
+    };
+    depth: number;
+};
+type SubmitResult = {
+    ok: true;
+    txid: string;
+    position: number;
+} | {
+    ok: false;
+    reason: string;
+    retry: boolean;
+};
+declare class SequencerClient {
+    private baseUrl;
+    /** @param baseUrl e.g. 'https://seq.kron.technology' (TN10) */
+    constructor(baseUrl: string);
+    health(): Promise<{
+        ok: boolean;
+    }>;
+    /** The in-flight head + queue depth for a pool — use this instead of the indexer's confirmed `poolhead`
+     *  when the pool is busy, so you build on the latest unconfirmed state. */
+    head(poolP2sh: string): Promise<SequencerHead>;
+    /** Enqueue a signed swap tx built against a `head()` snapshot. A 409-shaped `{ok:false, retry:true}`
+     *  means `prevHead` is stale — re-fetch `head()` and rebuild. */
+    submit(body: {
+        pool: string;
+        signedTx: string;
+        prevHead: SequencerHead['head'];
+        declaredReserves: {
+            kasReserve: string;
+            tokenReserve: string;
+            totalShares: string;
+            lpCovid: string | null;
+        };
+    }): Promise<SubmitResult>;
+    /** SSE: head changes for a pool. Same Node-EventSource caveat as IndexerClient.stream. */
+    events(poolP2sh: string, onEvent: (data: unknown) => void, EventSourceImpl?: typeof EventSource): () => void;
+}
+
+type index_IndexerClient = IndexerClient;
+declare const index_IndexerClient: typeof IndexerClient;
+type index_RegistryClient = RegistryClient;
+declare const index_RegistryClient: typeof RegistryClient;
+type index_SequencerClient = SequencerClient;
+declare const index_SequencerClient: typeof SequencerClient;
+declare namespace index {
+  export { index_IndexerClient as IndexerClient, index_RegistryClient as RegistryClient, index_SequencerClient as SequencerClient };
+}
+
+export { index as client, cpCurve as curve, curveCpTx as curveCp, genesis, kcc20Tx as kcc20, poolCpTx as poolCp, poolCpV3Tx as poolCpV3, sigscript, spend, vestingTx as vesting, index$1 as wallet };