@qntx/spark 0.3.0 → 0.5.0

package/README.md

@@ -68,6 +68,13 @@ those inputs once. Retrying without it would select different outputs and pay tw
 Offline receive: once a transfer commits, the sender cannot cancel it and its expiry does not
 return it — `transfers.claim(transferId)`/`claimPending` can pick it up at any later time.
 
+Transaction history: `transfers.history({ limit?, offset? })` pages transfers newest-first
+(`TRANSFER`, `PREIMAGE_SWAP`, `COOPERATIVE_EXIT`, `UTXO_SWAP`), folding each entry with its SSP
+`user_request` when the counterparty is the SSP — lightning invoices, payment hashes and
+preimages, coop-exit fees and payout txids, static-deposit credits. Entries surface as
+`SparkPayment` (`send`/`receive`, `pending`/`completed`/`failed`, `spark`/`lightning`/`deposit`/
+`withdraw`); `nextOffset` is `undefined` at the end.
+
 Unilateral exit: each pre-signed transaction carries a hard deadline — once its parent confirms
 and its relative timelock passes, it must confirm within 50 blocks; otherwise the operators'
 watchtower may publish a self-fee variant instead. For intermediate nodes this strands

package/dist/{index-rHuqmVV3.d.mts → index-CsGON46O.d.mts}

@@ -1,5 +1,5 @@
 import { i as SparkOperatorConfig, n as SparkNetwork, o as Signature, r as SparkNetworkConfig } from "./lightning-address-CRULmi9v.mjs";
-import { v as SparkSigner } from "./transactions-DjTZU8ev.mjs";
+import { v as SparkSigner } from "./transactions-p89sj_IQ.mjs";
 import "@bufbuild/protobuf/codegenv2";
 import "@bufbuild/protobuf/wkt";
 import { Message, UnknownEnum } from "@bufbuild/protobuf";
@@ -332,6 +332,43 @@ type SparkTransfer = {
   readonly leaves: ReadonlyArray<SparkTransferLeaf>;
 };
 //#endregion
+//#region src/transfer/payment.d.ts
+/**
+ * One entry of `client.transfers.history`: a transfer folded with its SSP `user_request` into the
+ * wallet-facing payment shape. Mapping follows the Breez adaptor semantics; every field a consumer
+ * displays comes from authenticated SO data or the SSP record — never from host input.
+ */
+type SparkPayment = {
+  readonly id: string;
+  readonly direction: "send" | "receive";
+  readonly status: "pending" | "completed" | "failed";
+  readonly method: "spark" | "lightning" | "deposit" | "withdraw";
+  /** Sats excluding fees — the total minus the fee for outbound sends and exits. */
+  readonly amountSats: number;
+  readonly feeSats: number;
+  /** Milliseconds since the epoch; absent when the SO reports none. */
+  readonly createdAt: number | undefined;
+  readonly details: {
+    readonly kind: "spark";
+    readonly invoice?: string;
+  } | {
+    readonly kind: "lightning";
+    readonly invoice: string;
+    /** Payment hash, hex. */
+    readonly paymentHash: string;
+    /** Payment preimage, hex. */
+    readonly preimage?: string;
+    readonly description?: string;
+  } | {
+    readonly kind: "withdraw";
+    readonly txid?: string;
+  } | {
+    readonly kind: "deposit";
+    readonly txid: string;
+    readonly vout: number;
+  } | undefined;
+};
+//#endregion
 //#region src/core/bitcoin/cpfp.d.ts
 type FundingInput = {
   /** Display-order hex txid of the confirmed funding output. */
@@ -430,6 +467,19 @@ type SparkClient = {
       readonly limit?: number;
       readonly offset?: number;
     }) => Promise<ReadonlyArray<SparkTransfer>>;
+    /**
+     * Transfer history as wallet-facing payments: TRANSFER, PREIMAGE_SWAP, COOPERATIVE_EXIT and
+     * UTXO_SWAP records (newest first) folded with their SSP user requests when the counterparty is
+     * the SSP — one batched SSP call per page. `limit` is 1–100 (default 20); `nextOffset` is the
+     * offset of the next page, `undefined` at the end.
+     */
+    readonly history: (options?: {
+      readonly limit?: number;
+      readonly offset?: number;
+    }) => Promise<{
+      readonly payments: ReadonlyArray<SparkPayment>;
+      readonly nextOffset: number | undefined;
+    }>;
     /**
      * Sends exactly `amountSats` to `receiver` (a `spark1…`/`sparkrt1…` address string or a 33-byte
      * identity public key) via `start_transfer_v2` — selecting exact leaves, or swapping with the
@@ -823,4 +873,4 @@ type SparkClientOptions = {
  */
 declare function createSparkClient(options: SparkClientOptions): SparkClient;
 //#endregion
-export { CooperativeExitStatus as A, exitTransactions as C, CooperativeExitQuote as D, createMemorySparkStore as E, UnusedDepositAddress as F, SparkLeaf as I, SparkEvent as L, StaticDepositClaim as M, StaticDepositRefund as N, CooperativeExitResult as O, StaticDepositUtxo as P, ExitTransaction as S, SparkStore as T, LightningSendStatus as _, createSparkClient as a, LightningInvoice as b, buildCpfpChild as c, SparkTokenBalance as d, SparkTokenOutput as f, LightningSendOutcome as g, LightningReceiveStatus as h, SparkInvoiceStatus as i, MIN_STATIC_REFUND_FEE_SATS as j, CooperativeExitSpeed as k, SparkTransfer as l, SparkWalletSettings as m, SparkClient as n, StaticDepositClaimResult as o, SparkTokenOutputStatus as p, SparkClientOptions as r, FundingInput as s, ClaimPendingResult as t, SparkTransferLeaf as u, LightningSendStatusRequest as v, SparkExitChain as w, WatchtowerExitedLeaf as x, LightningPayment as y };
+export { CooperativeExitSpeed as A, ExitTransaction as C, createMemorySparkStore as D, SparkStore as E, StaticDepositUtxo as F, UnusedDepositAddress as I, SparkLeaf as L, MIN_STATIC_REFUND_FEE_SATS as M, StaticDepositClaim as N, CooperativeExitQuote as O, StaticDepositRefund as P, SparkEvent as R, WatchtowerExitedLeaf as S, SparkExitChain as T, LightningSendOutcome as _, createSparkClient as a, LightningPayment as b, buildCpfpChild as c, SparkTransferLeaf as d, SparkTokenBalance as f, LightningReceiveStatus as g, SparkWalletSettings as h, SparkInvoiceStatus as i, CooperativeExitStatus as j, CooperativeExitResult as k, SparkPayment as l, SparkTokenOutputStatus as m, SparkClient as n, StaticDepositClaimResult as o, SparkTokenOutput as p, SparkClientOptions as r, FundingInput as s, ClaimPendingResult as t, SparkTransfer as u, LightningSendStatus as v, exitTransactions as w, LightningInvoice as x, LightningSendStatusRequest as y };

package/dist/index.d.mts

@@ -1,11 +1,11 @@
 import { a as SparkTokenBroadcastError, i as SparkRequestError, n as SparkError, r as SparkInputError, t as SparkCryptoError } from "./index-D1fBaHTa.mjs";
 import { a as sparkNetworkConfig, i as SparkOperatorConfig, n as SparkNetwork, r as SparkNetworkConfig } from "./lightning-address-CRULmi9v.mjs";
 import { i as isExpired, n as Bolt11Network, r as decodeBolt11, t as Bolt11Invoice } from "./bolt11-DsNTTS_O.mjs";
-import { A as CooperativeExitStatus, C as exitTransactions, D as CooperativeExitQuote, E as createMemorySparkStore, F as UnusedDepositAddress, I as SparkLeaf, L as SparkEvent, M as StaticDepositClaim, N as StaticDepositRefund, O as CooperativeExitResult, P as StaticDepositUtxo, S as ExitTransaction, T as SparkStore, _ as LightningSendStatus, a as createSparkClient, b as LightningInvoice, c as buildCpfpChild, d as SparkTokenBalance, f as SparkTokenOutput, g as LightningSendOutcome, h as LightningReceiveStatus, i as SparkInvoiceStatus, j as MIN_STATIC_REFUND_FEE_SATS, k as CooperativeExitSpeed, l as SparkTransfer, m as SparkWalletSettings, n as SparkClient, o as StaticDepositClaimResult, p as SparkTokenOutputStatus, r as SparkClientOptions, s as FundingInput, t as ClaimPendingResult, u as SparkTransferLeaf, v as LightningSendStatusRequest, w as SparkExitChain, x as WatchtowerExitedLeaf, y as LightningPayment } from "./index-rHuqmVV3.mjs";
-import { n as EPHEMERAL_ANCHOR_SCRIPT, t as addressToScript, v as SparkSigner } from "./transactions-DjTZU8ev.mjs";
+import { A as CooperativeExitSpeed, C as ExitTransaction, D as createMemorySparkStore, E as SparkStore, F as StaticDepositUtxo, I as UnusedDepositAddress, L as SparkLeaf, M as MIN_STATIC_REFUND_FEE_SATS, N as StaticDepositClaim, O as CooperativeExitQuote, P as StaticDepositRefund, R as SparkEvent, S as WatchtowerExitedLeaf, T as SparkExitChain, _ as LightningSendOutcome, a as createSparkClient, b as LightningPayment, c as buildCpfpChild, d as SparkTransferLeaf, f as SparkTokenBalance, g as LightningReceiveStatus, h as SparkWalletSettings, i as SparkInvoiceStatus, j as CooperativeExitStatus, k as CooperativeExitResult, l as SparkPayment, m as SparkTokenOutputStatus, n as SparkClient, o as StaticDepositClaimResult, p as SparkTokenOutput, r as SparkClientOptions, s as FundingInput, t as ClaimPendingResult, u as SparkTransfer, v as LightningSendStatus, w as exitTransactions, x as LightningInvoice, y as LightningSendStatusRequest } from "./index-CsGON46O.mjs";
+import { n as EPHEMERAL_ANCHOR_SCRIPT, t as bitcoinAddressScript, v as SparkSigner } from "./transactions-p89sj_IQ.mjs";
 //#region src/core/invoice.d.ts
 /** Payment carried by a Spark invoice: satoshis or BTKN tokens. */
-type SparkPayment = {
+type SparkInvoicePayment = {
   readonly type: "sats";
   readonly amount?: number | undefined;
 } | {
@@ -20,7 +20,7 @@ type SparkInvoiceFields = {
   readonly version: number;
   /** UUID identifying the invoice (canonical lowercase form). */
   readonly id: string;
-  readonly payment?: SparkPayment | undefined;
+  readonly payment?: SparkInvoicePayment | undefined;
   /** At most 120 UTF-8 bytes. */
   readonly memo?: string | undefined;
   /** 33-byte compressed secp256k1 public key. */
@@ -120,4 +120,4 @@ export declare function parseSparkInvoice(text: string, options: {
   readonly now: number;
 }): ParsedSparkInvoice;
 //#endregion
-export { type Bolt11Invoice, type Bolt11Network, type ClaimPendingResult, type CooperativeExitQuote, type CooperativeExitResult, type CooperativeExitSpeed, type CooperativeExitStatus, EPHEMERAL_ANCHOR_SCRIPT, type ExitTransaction, type FundingInput, type LightningInvoice, type LightningPayment, type LightningReceiveStatus, type LightningSendOutcome, type LightningSendStatus, type LightningSendStatusRequest, MIN_STATIC_REFUND_FEE_SATS, type ParsedSparkInvoice, type SparkAddress, type SparkClient, type SparkClientOptions, SparkCryptoError, SparkError, type SparkEvent, type SparkExitChain, SparkInputError, type SparkInvoiceFields, type SparkInvoiceStatus, type SparkLeaf, type SparkNetwork, type SparkNetworkConfig, type SparkOperatorConfig, type SparkPayment, SparkRequestError, type SparkStore, type SparkTokenBalance, SparkTokenBroadcastError, type SparkTokenIdentifierData, type SparkTokenOutput, type SparkTokenOutputStatus, type SparkTransfer, type SparkTransferLeaf, type SparkWalletSettings, type StaticDepositClaim, type StaticDepositClaimResult, type StaticDepositRefund, type StaticDepositUtxo, type UnusedDepositAddress, type WatchtowerExitedLeaf, addressToScript, buildCpfpChild, createMemorySparkStore, createSparkClient, decodeBolt11, exitTransactions, isExpired, sparkNetworkConfig };
+export { type Bolt11Invoice, type Bolt11Network, type ClaimPendingResult, type CooperativeExitQuote, type CooperativeExitResult, type CooperativeExitSpeed, type CooperativeExitStatus, EPHEMERAL_ANCHOR_SCRIPT, type ExitTransaction, type FundingInput, type LightningInvoice, type LightningPayment, type LightningReceiveStatus, type LightningSendOutcome, type LightningSendStatus, type LightningSendStatusRequest, MIN_STATIC_REFUND_FEE_SATS, type ParsedSparkInvoice, type SparkAddress, type SparkClient, type SparkClientOptions, SparkCryptoError, SparkError, type SparkEvent, type SparkExitChain, SparkInputError, type SparkInvoiceFields, type SparkInvoicePayment, type SparkInvoiceStatus, type SparkLeaf, type SparkNetwork, type SparkNetworkConfig, type SparkOperatorConfig, type SparkPayment, SparkRequestError, type SparkStore, type SparkTokenBalance, SparkTokenBroadcastError, type SparkTokenIdentifierData, type SparkTokenOutput, type SparkTokenOutputStatus, type SparkTransfer, type SparkTransferLeaf, type SparkWalletSettings, type StaticDepositClaim, type StaticDepositClaimResult, type StaticDepositRefund, type StaticDepositUtxo, type UnusedDepositAddress, type WatchtowerExitedLeaf, bitcoinAddressScript, buildCpfpChild, createMemorySparkStore, createSparkClient, decodeBolt11, exitTransactions, isExpired, sparkNetworkConfig };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { a as SparkTokenBroadcastError, i as SparkRequestError, n as SparkError, r as SparkInputError, t as SparkCryptoError } from "./errors-5xLkExNL.mjs";
-import { $ as SparkAuthnService, A as EPHEMERAL_ANCHOR_SCRIPT, B as parseTransaction, Bt as TransferReceiverStatus, C as createInitialTimelockRefundTxs, Ct as InitiatePreimageSwapRequest_Reason, D as txId, Dt as RenewNodeTimelockSigningJobSchema, E as estimateVbytes, Et as Order, Ft as SparkAddressSchema, G as PartialTokenOutputSchema, Gt as SignatureScheme, Ht as TransferType, I as doesTxnNeedRenewed, It as SparkInvoiceFieldsSchema, J as SparkTokenService, K as PartialTokenTransactionSchema, L as getNextHTLCTransactionSequence, Lt as SparkService, M as computeTaprootKeyNoScript, N as p2trScriptFromPublicKey, Nt as SenderTransferPackageSchema, O as txIdInputBytes, Ot as RenewNodeZeroTimelockSigningJobSchema, P as xOnlyPublicKey, Pt as SigningJobSchema, Q as ChallengeSchema, R as getTimelockFromSequence, Rt as StartTransferRequestSchema, S as createInitialTimelockNodeTx, St as HashVariant, T as createZeroTimelockNodeTx, Tt as InvoiceStatus, U as CommitStatus, Ut as TreeNodeStatus, V as taprootKeySpendSighash, Vt as TransferStatus, W as InvoiceAttachmentSchema, Wt as UserSignedTxSigningJobSchema, X as TokenTransactionMetadataSchema, Y as TokenOutputStatus, Z as TokenTransactionStatus, _ as addressToScript, _t as AdaptorPublicKeyPackageSchema, a as proofOfPossessionDigest, at as uuidToBytes, b as createDecrementedTimelockNodeTx, bt as ClaimPackageSchema, d as LIGHTNING_HTLC_SEQUENCE, dt as assertU32, et as hashSparkInvoice, f as constructHtlcSenderSpend, ft as requireLength, g as lightningHtlcOutputScript, gt as sparkNetworkProto, h as finalizeHtlcSpend, ht as sparkNetworkFromProto, it as uuidFromBytes, j as btcNetwork, k as verifyFinalizedTaprootSignature, kt as RenewRefundTimelockSigningJobSchema, lt as assertCompressedKey, mt as sparkNetworkConfig, nt as protoInvoiceToPlain, o as sendLeafSigningDigest, ot as uuidv7, p as createRefundTxsForLightning, pt as u64ToSats, q as SignatureWithIndexSchema, rt as validateInvoiceFields, st as compareBytes, t as hashFinalTokenTransaction, tt as encodeInvoiceFields, ut as assertSats, v as createConnectorRefundTxs, w as createMultiInputRootTx, wt as InputSigningDataSchema, x as createDecrementedTimelockRefundTxs, xt as Direction, y as createCurrentTimelockRefundTxs, z as isZeroTimelock, zt as TransferPackageSchema } from "./token-DmojVTWi.mjs";
+import { $ as SparkAuthnService, A as EPHEMERAL_ANCHOR_SCRIPT, B as parseTransaction, Bt as TransferReceiverStatus, C as createInitialTimelockRefundTxs, Ct as InitiatePreimageSwapRequest_Reason, D as txId, Dt as RenewNodeTimelockSigningJobSchema, E as estimateVbytes, Et as Order, Ft as SparkAddressSchema, G as PartialTokenOutputSchema, Gt as SignatureScheme, Ht as TransferType, I as doesTxnNeedRenewed, It as SparkInvoiceFieldsSchema, J as SparkTokenService, K as PartialTokenTransactionSchema, L as getNextHTLCTransactionSequence, Lt as SparkService, M as computeTaprootKeyNoScript, N as p2trScriptFromPublicKey, Nt as SenderTransferPackageSchema, O as txIdInputBytes, Ot as RenewNodeZeroTimelockSigningJobSchema, P as xOnlyPublicKey, Pt as SigningJobSchema, Q as ChallengeSchema, R as getTimelockFromSequence, Rt as StartTransferRequestSchema, S as createInitialTimelockNodeTx, St as HashVariant, T as createZeroTimelockNodeTx, Tt as InvoiceStatus, U as CommitStatus, Ut as TreeNodeStatus, V as taprootKeySpendSighash, Vt as TransferStatus, W as InvoiceAttachmentSchema, Wt as UserSignedTxSigningJobSchema, X as TokenTransactionMetadataSchema, Y as TokenOutputStatus, Z as TokenTransactionStatus, _ as bitcoinAddressScript, _t as AdaptorPublicKeyPackageSchema, a as proofOfPossessionDigest, at as uuidToBytes, b as createDecrementedTimelockNodeTx, bt as ClaimPackageSchema, d as LIGHTNING_HTLC_SEQUENCE, dt as assertU32, et as hashSparkInvoice, f as constructHtlcSenderSpend, ft as requireLength, g as lightningHtlcOutputScript, gt as sparkNetworkProto, h as finalizeHtlcSpend, ht as sparkNetworkFromProto, it as uuidFromBytes, j as btcNetwork, k as verifyFinalizedTaprootSignature, kt as RenewRefundTimelockSigningJobSchema, lt as assertCompressedKey, mt as sparkNetworkConfig, nt as protoInvoiceToPlain, o as sendLeafSigningDigest, ot as uuidv7, p as createRefundTxsForLightning, pt as u64ToSats, q as SignatureWithIndexSchema, rt as validateInvoiceFields, st as compareBytes, t as hashFinalTokenTransaction, tt as encodeInvoiceFields, ut as assertSats, v as createConnectorRefundTxs, w as createMultiInputRootTx, wt as InputSigningDataSchema, x as createDecrementedTimelockRefundTxs, xt as Direction, y as createCurrentTimelockRefundTxs, z as isZeroTimelock, zt as TransferPackageSchema } from "./token-C3vqRH-k.mjs";
 import { n as isExpired, t as decodeBolt11 } from "./bolt11-rfxnyLcb.mjs";
 import { t as serverErrorText } from "./text-CDhN7qo4.mjs";
 import { bytesToHex, hexToBytes, utf8ToBytes } from "@noble/hashes/utils.js";
@@ -11,7 +11,7 @@ import { base64, bech32m } from "@scure/base";
 import { sha256 } from "@noble/hashes/sha2.js";
 import { Code, ConnectError, createClient } from "@connectrpc/connect";
 import { createGrpcWebTransport } from "@connectrpc/connect-web";
-import { bytesToNumberBE, equalBytes, hexToBytes as hexToBytes$1, numberToBytesBE, numberToVarBytesBE } from "@noble/curves/utils.js";
+import { bytesToHex as bytesToHex$1, bytesToNumberBE, equalBytes, hexToBytes as hexToBytes$1, numberToBytesBE, numberToVarBytesBE } from "@noble/curves/utils.js";
 import { Address, OutScript, Transaction } from "@scure/btc-signer";
 //#region src/core/address.ts
 const BECH32M_LIMIT$1 = 1024;
@@ -1229,6 +1229,94 @@ fragment UserRequestFragment on UserRequest {
         lightning_send_request_payment_preimage: payment_preimage
     }
 }`;
+const TRANSFERS = `
+query Transfers($transfer_spark_ids: [UUID!]!) {
+  transfers(transfer_spark_ids: $transfer_spark_ids) {
+    ...TransferFragment
+    transfer_user_request: user_request {
+      ...UserRequestFragment
+    }
+  }
+}
+
+fragment TransferFragment on Transfer {
+  __typename
+  transfer_spark_id: spark_id
+}
+
+fragment CurrencyAmountFragment on CurrencyAmount {
+  __typename
+  currency_amount_original_value: original_value
+  currency_amount_original_unit: original_unit
+}
+
+fragment TransferSparkIdFragment on Transfer {
+  __typename
+  transfer_spark_id: spark_id
+}
+
+fragment UserRequestFragment on UserRequest {
+  __typename
+  ... on ClaimStaticDeposit {
+    claim_static_deposit_id: id
+    claim_static_deposit_deposit_amount: deposit_amount {
+      ...CurrencyAmountFragment
+    }
+    claim_static_deposit_credit_amount: credit_amount {
+      ...CurrencyAmountFragment
+    }
+    claim_static_deposit_max_fee: max_fee {
+      ...CurrencyAmountFragment
+    }
+    claim_static_deposit_status: status
+    claim_static_deposit_transaction_id: transaction_id
+    claim_static_deposit_output_index: output_index
+    claim_static_deposit_transfer_spark_id: transfer_spark_id
+  }
+  ... on CoopExitRequest {
+    coop_exit_request_id: id
+    coop_exit_request_fee: fee {
+      ...CurrencyAmountFragment
+    }
+    coop_exit_request_l1_broadcast_fee: l1_broadcast_fee {
+      ...CurrencyAmountFragment
+    }
+    coop_exit_request_status: status
+    coop_exit_request_coop_exit_txid: coop_exit_txid
+    coop_exit_request_transfer: transfer {
+      ...TransferSparkIdFragment
+    }
+  }
+  ... on LeavesSwapRequest {
+    leaves_swap_request_id: id
+    leaves_swap_request_status: status
+  }
+  ... on LightningReceiveRequest {
+    lightning_receive_request_id: id
+    lightning_receive_request_invoice: invoice {
+      __typename
+      invoice_encoded_invoice: encoded_invoice
+      invoice_payment_hash: payment_hash
+    }
+    lightning_receive_request_status: status
+    lightning_receive_request_transfer: transfer {
+      ...TransferSparkIdFragment
+    }
+    lightning_receive_request_payment_preimage: payment_preimage
+  }
+  ... on LightningSendRequest {
+    lightning_send_request_id: id
+    lightning_send_request_encoded_invoice: encoded_invoice
+    lightning_send_request_fee: fee {
+      ...CurrencyAmountFragment
+    }
+    lightning_send_request_status: status
+    lightning_send_request_transfer: transfer {
+      ...TransferSparkIdFragment
+    }
+    lightning_send_request_payment_preimage: payment_preimage
+  }
+}`;
 //#endregion
 //#region src/ssp/parse.ts
 /** A malformed SSP response is a server fault, not caller input. */
@@ -1251,6 +1339,11 @@ function asSats(value, field) {
 	if (n === void 0 || !Number.isSafeInteger(n) || n < 0) throw unexpectedResponse(field, "is not a non-negative integer");
 	return n;
 }
+/** A GraphQL Int field used as an array/output index — a number, not a decimal string. */
+function asIndex(value, field) {
+	if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw unexpectedResponse(field, "is not a non-negative integer");
+	return value;
+}
 /** CurrencyAmount in SATOSHI → sats; any other unit is an unexpected response. */
 function currencyAmountSats(value, field) {
 	const amount = asObject(value, field);
@@ -1371,6 +1464,75 @@ function parseCoopExitResult(request, field) {
 		rawConnectorTransaction: asHexBytes(request["coop_exit_request_raw_connector_transaction"], `${field}.coop_exit_request_raw_connector_transaction`)
 	};
 }
+function optionalTxidHex(value, field) {
+	if (value === void 0 || value === null) return;
+	return asTxidHex(value, field);
+}
+/** The `transfers` query's per-item parse: id plus its user_request union member (or none). */
+function parseTransfersResponse(data) {
+	const items = data["transfers"];
+	if (!Array.isArray(items)) throw unexpectedResponse("transfers", "is not an array");
+	return items.map((item, index) => {
+		const field = `transfers[${index}]`;
+		const entry = asObject(item, field);
+		const request = entry["transfer_user_request"];
+		return {
+			transferId: asString(entry["transfer_spark_id"], `${field}.transfer_spark_id`),
+			request: request === void 0 || request === null ? void 0 : parseUserRequest(asObject(request, `${field}.transfer_user_request`), `${field}.transfer_user_request`)
+		};
+	});
+}
+/**
+* Discriminated `user_request` parse. An unknown `__typename` is a variant we do not model, not a
+* malformed response.
+*/
+function parseUserRequest(request, field) {
+	switch (request["__typename"]) {
+		case "LightningSendRequest": {
+			const send = parseLightningSend(request, field);
+			return {
+				kind: "lightning-send",
+				status: send.status,
+				invoice: send.encodedInvoice,
+				feeSats: send.feeSats,
+				...send.paymentPreimage === void 0 ? {} : { preimage: send.paymentPreimage }
+			};
+		}
+		case "LightningReceiveRequest": {
+			const receive = parseLightningReceive(request, field);
+			return {
+				kind: "lightning-receive",
+				status: receive.status,
+				invoice: receive.invoice,
+				...receive.paymentPreimage === void 0 ? {} : { preimage: receive.paymentPreimage }
+			};
+		}
+		case "CoopExitRequest": return parseCoopExitRequest(request, field);
+		case "ClaimStaticDeposit": return parseStaticDepositRequest(request, field);
+		case "LeavesSwapRequest": return { kind: "leaves-swap" };
+		default: return;
+	}
+}
+/** `coop_exit` for history: fee = `fee` + `l1_broadcast_fee`, status and payout txid. */
+function parseCoopExitRequest(request, field) {
+	const txid = optionalTxidHex(request["coop_exit_request_coop_exit_txid"], `${field}.coop_exit_request_coop_exit_txid`);
+	return {
+		kind: "coop-exit",
+		status: asString(request["coop_exit_request_status"], `${field}.coop_exit_request_status`),
+		feeSats: currencyAmountSats(request["coop_exit_request_fee"], `${field}.coop_exit_request_fee`) + currencyAmountSats(request["coop_exit_request_l1_broadcast_fee"], `${field}.coop_exit_request_l1_broadcast_fee`),
+		...txid === void 0 ? {} : { txid }
+	};
+}
+/** `claim_static_deposit` for history: the claim's txid, vout and credited amount. */
+function parseStaticDepositRequest(request, field) {
+	return {
+		kind: "static-deposit",
+		txid: asTxidHex(request["claim_static_deposit_transaction_id"], `${field}.claim_static_deposit_transaction_id`),
+		vout: asIndex(request["claim_static_deposit_output_index"], `${field}.claim_static_deposit_output_index`),
+		depositAmountSats: currencyAmountSats(request["claim_static_deposit_deposit_amount"], `${field}.claim_static_deposit_deposit_amount`),
+		creditAmountSats: currencyAmountSats(request["claim_static_deposit_credit_amount"], `${field}.claim_static_deposit_credit_amount`)
+	};
+}
 //#endregion
 //#region src/ssp/index.ts
 /**
@@ -1501,6 +1663,11 @@ function createSspClient(options) {
 		}
 	}
 	return {
+		async transfers(transferIds) {
+			if (transferIds.length === 0) return [];
+			if (transferIds.length > 100) throw new SparkInputError("transfers: at most 100 ids per call");
+			return parseTransfersResponse(asObject(await readPost("Transfers", TRANSFERS, { transfer_spark_ids: [...transferIds] }), "transfers"));
+		},
 		async swapFeeEstimate(amountSats) {
 			if (!Number.isSafeInteger(amountSats) || amountSats <= 0) throw new SparkInputError("amount sats must be a positive integer");
 			return currencyAmountSats(asObject((await readPost("LeavesSwapFeeEstimate", LEAVES_SWAP_FEE_ESTIMATE, { total_amount_sats: amountSats }))["leaves_swap_fee_estimate"], "leaves_swap_fee_estimate")["leaves_swap_fee_estimate_output_fee_estimate"], "leaves_swap_fee_estimate_output_fee_estimate");
@@ -2209,7 +2376,7 @@ function validateCoopExitPayoutTransaction(params) {
 }
 function p2trAddressScript(address, network) {
 	try {
-		return OutScript.encode(Address(btcNetwork(network)).decode(address));
+		return bitcoinAddressScript(address, network);
 	} catch (error) {
 		throw new SparkInputError("expectedPayoutAddress: could not decode the withdrawal address", { cause: error });
 	}
@@ -3025,7 +3192,7 @@ function depositScript(verifyingKey, network) {
 /** Output script of a coordinator-supplied address, decoded under our network only. */
 function depositAddressScript(address, network) {
 	try {
-		return OutScript.encode(Address(btcNetwork(network)).decode(address));
+		return bitcoinAddressScript(address, network);
 	} catch (error) {
 		throw new SparkError("deposit: address does not decode under our network", { cause: error });
 	}
@@ -3706,17 +3873,27 @@ async function queryTransfersByIds(options) {
 		network: sparkNetworkProto(options.network)
 	}, options.call)).transfers;
 }
-/** `query_all_transfers` — transfers where the identity is sender or receiver. */
+/**
+* `query_all_transfers` — transfers where the identity is sender or receiver. `types` filters on
+* the server side (empty means all). `nextOffset` is the offset of the following page — `undefined`
+* when the SO reports `-1` (a short page ends the listing).
+*/
 async function queryAllTransfers(options) {
-	return (await options.spark.query_all_transfers({
+	const response = await options.spark.query_all_transfers({
 		participant: {
 			case: "senderOrReceiverIdentityPublicKey",
 			value: options.identityPublicKey
 		},
 		network: sparkNetworkProto(options.network),
 		limit: BigInt(options.limit ?? 100),
-		offset: BigInt(options.offset ?? 0)
-	}, options.call)).transfers.map(mapTransfer);
+		offset: BigInt(options.offset ?? 0),
+		types: [...options.types ?? []]
+	}, options.call);
+	const nextOffset = Number(response.offset);
+	return {
+		transfers: response.transfers.map(mapTransfer),
+		nextOffset: nextOffset < 0 ? void 0 : nextOffset
+	};
 }
 /**
 * Whether `transfer` is exactly the one we signed for: our id, same type, our sender key, and the
@@ -4262,6 +4439,111 @@ async function claimByTransferId(options) {
 	}
 }
 //#endregion
+//#region src/transfer/payment.ts
+/**
+* CoopExitRequest statuses, bucketed per Breez's `SparkCoopExitRequestStatus::acceptance`: accepted
+* means the SSP took the exit over — the SO-side transfer status keeps telling completion; terminal
+* failures are failed; anything else (incl. unknown values) is pending.
+*/
+const COOP_EXIT_ACCEPTED$1 = /* @__PURE__ */ new Set([
+	"INBOUND_TRANSFER_CHECKED",
+	"TX_SIGNED",
+	"TX_BROADCASTED",
+	"WAITING_ON_TX_CONFIRMATIONS",
+	"COMPLETE_REQUEST_RECEIVED",
+	"ON_CHAIN_TX_CONFIRMED",
+	"SUCCEEDED"
+]);
+const COOP_EXIT_FAILED$1 = /* @__PURE__ */ new Set([
+	"EXPIRED",
+	"FAILED",
+	"INBOUND_TRANSFER_CLAIMING_FAILED",
+	"EXPIRING_FAILED",
+	"FAILING_FAILED"
+]);
+/**
+* Whether the transfer's counterparty is the SSP: the receiver on sends (any edge of a
+* multi-receiver), the sender on receives. Shared by the history batch-fetch and the mapper.
+*/
+function sspCounterparty(transfer, identityPublicKey, sspIdentityPublicKey) {
+	return equalBytes(transfer.senderIdentityPublicKey, identityPublicKey) ? equalBytes(transfer.receiverIdentityPublicKey, sspIdentityPublicKey) || transfer.receivers.some((receiver) => equalBytes(receiver.identityPublicKey, sspIdentityPublicKey)) : equalBytes(transfer.senderIdentityPublicKey, sspIdentityPublicKey);
+}
+function toSparkPayment(options) {
+	const { transfer, request } = options;
+	const direction = equalBytes(transfer.senderIdentityPublicKey, options.identityPublicKey) ? "send" : "receive";
+	const isSsp = sspCounterparty(transfer, options.identityPublicKey, options.sspIdentityPublicKey);
+	const method = transfer.type === "COOPERATIVE_EXIT" ? "withdraw" : transfer.type === "UTXO_SWAP" ? "deposit" : transfer.type === "PREIMAGE_SWAP" ? isSsp ? "lightning" : "spark" : "spark";
+	let status;
+	if (transfer.status === "COMPLETED") status = "completed";
+	else if (direction === "send" && transfer.status === "SENDER_KEY_TWEAKED") status = "completed";
+	else if (transfer.status === "EXPIRED" || transfer.status === "RETURNED") status = "failed";
+	else status = "pending";
+	let feeSats = 0;
+	let amountSats = transfer.totalValueSats;
+	let details;
+	switch (method) {
+		case "lightning":
+			if (request?.kind === "lightning-send") {
+				if (request.preimage !== void 0) status = "completed";
+				({feeSats} = request);
+				amountSats = Math.max(0, transfer.totalValueSats - feeSats);
+				details = lightningDetails(request.invoice, request.preimage);
+			} else if (request?.kind === "lightning-receive") details = lightningDetails(request.invoice, request.preimage);
+			break;
+		case "withdraw":
+			if (request?.kind === "coop-exit") {
+				({feeSats} = request);
+				amountSats = Math.max(0, transfer.totalValueSats - feeSats);
+				if (COOP_EXIT_FAILED$1.has(request.status)) status = "failed";
+				else if (!COOP_EXIT_ACCEPTED$1.has(request.status)) status = "pending";
+				details = {
+					kind: "withdraw",
+					...request.txid === void 0 ? {} : { txid: request.txid }
+				};
+			}
+			break;
+		case "deposit":
+			if (request?.kind === "static-deposit") {
+				feeSats = Math.max(0, request.depositAmountSats - request.creditAmountSats);
+				details = {
+					kind: "deposit",
+					txid: request.txid,
+					vout: request.vout
+				};
+			}
+			break;
+		case "spark": details = {
+			kind: "spark",
+			...transfer.sparkInvoice === void 0 ? {} : { invoice: transfer.sparkInvoice }
+		};
+	}
+	if (method !== "spark" && details === void 0) status = "pending";
+	return {
+		id: transfer.id,
+		direction,
+		status,
+		method,
+		amountSats,
+		feeSats,
+		createdAt: transfer.createdTimeMs,
+		details
+	};
+}
+function lightningDetails(invoice, preimage) {
+	try {
+		const decoded = decodeBolt11(invoice);
+		return {
+			kind: "lightning",
+			invoice,
+			paymentHash: bytesToHex$1(decoded.paymentHash),
+			...decoded.description === void 0 ? {} : { description: decoded.description },
+			...preimage === void 0 ? {} : { preimage: bytesToHex$1(preimage) }
+		};
+	} catch {
+		return;
+	}
+}
+//#endregion
 //#region src/transfer/send.ts
 /**
 * The signed `TransferPackage` for a send-style transfer: every leaf gets a fresh recipient key
@@ -5892,13 +6174,49 @@ function createTransfers(context) {
 				network
 			})).transfers;
 		},
-		list: async (listOptions) => queryAllTransfers({
-			spark,
-			identityPublicKey: await signer.identityPublicKey(),
-			network,
-			...listOptions?.limit === void 0 ? {} : { limit: listOptions.limit },
-			...listOptions?.offset === void 0 ? {} : { offset: listOptions.offset }
-		}),
+		history: async (historyOptions) => {
+			const limit = historyOptions?.limit ?? 20;
+			if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100) throw new SparkInputError("history: limit must be an integer in 1–100");
+			const offset = historyOptions?.offset ?? 0;
+			if (!Number.isSafeInteger(offset) || offset < 0) throw new SparkInputError("history: offset must be a non-negative integer");
+			const identityPublicKey = await signer.identityPublicKey();
+			const sspIdentityPublicKey = context.config.ssp.identityPublicKey;
+			const { transfers, nextOffset } = await queryAllTransfers({
+				spark,
+				identityPublicKey,
+				network,
+				limit,
+				offset,
+				types: [
+					TransferType.TRANSFER,
+					TransferType.PREIMAGE_SWAP,
+					TransferType.COOPERATIVE_EXIT,
+					TransferType.UTXO_SWAP
+				]
+			});
+			const sspIds = transfers.filter((transfer) => sspCounterparty(transfer, identityPublicKey, sspIdentityPublicKey)).map((transfer) => transfer.id);
+			const requests = /* @__PURE__ */ new Map();
+			for (const result of await context.sspClient.transfers(sspIds)) if (result.request !== void 0) requests.set(result.transferId, result.request);
+			return {
+				payments: transfers.map((transfer) => toSparkPayment({
+					transfer,
+					request: requests.get(transfer.id),
+					identityPublicKey,
+					sspIdentityPublicKey
+				})),
+				nextOffset
+			};
+		},
+		list: async (listOptions) => {
+			const { transfers } = await queryAllTransfers({
+				spark,
+				identityPublicKey: await signer.identityPublicKey(),
+				network,
+				...listOptions?.limit === void 0 ? {} : { limit: listOptions.limit },
+				...listOptions?.offset === void 0 ? {} : { offset: listOptions.offset }
+			});
+			return transfers;
+		},
 		send: async (sendOptions) => sendSats(context, {
 			receivers: [{
 				receiverIdentityPublicKey: context.receiverIdentityKey(sendOptions.receiver),
@@ -6348,7 +6666,7 @@ async function payLightningInvoice(deps, options) {
 */
 async function sweepHtlcTimeout(deps, options) {
 	if (!Number.isFinite(options.feeRateSatPerVbyte) || options.feeRateSatPerVbyte <= 0) throw new SparkInputError("feeRateSatPerVbyte: must be a positive finite number");
-	const destinationScript = addressToScript(options.destinationAddress);
+	const destinationScript = bitcoinAddressScript(options.destinationAddress, deps.network);
 	const htlc = parseTransaction(options.htlcTx);
 	if (!Number.isSafeInteger(options.vout) || options.vout < 0 || options.vout >= htlc.outputsLength) throw new SparkInputError("vout: out of range for the HTLC transaction's outputs");
 	const output = htlc.getOutput(options.vout);
@@ -6459,7 +6777,8 @@ function createLightning(context) {
 		receiveStatus: async (request) => lightningReceiveStatus(context.sspClient, request),
 		sweepHtlcTimeout: async (options) => sweepHtlcTimeout({
 			signer: context.signer,
-			sspIdentityPublicKey: context.config.ssp.identityPublicKey
+			sspIdentityPublicKey: context.config.ssp.identityPublicKey,
+			network: context.network
 		}, options)
 	};
 }
@@ -6628,7 +6947,7 @@ const COMPLETE_RETRY_DELAY_MS = 2e3;
 /** `address` must decode under this client's network before any signer or SSP work runs. */
 function checkWithdrawalAddress(address, network) {
 	try {
-		Address(btcNetwork(network)).decode(address);
+		bitcoinAddressScript(address, network);
 	} catch (error) {
 		throw new SparkInputError(`coop exit: invalid withdrawal address for ${network}`, { cause: error });
 	}
@@ -6647,7 +6966,7 @@ function prevout0(txBytes, context) {
 }
 /** The sats `rawCoopExitTransaction` pays to `address` — an exit not paying it is an error. */
 function payoutSatsForAddress(rawCoopExitTransaction, address, network) {
-	const expectedScript = OutScript.encode(Address(btcNetwork(network)).decode(address));
+	const expectedScript = bitcoinAddressScript(address, network);
 	const tx = parseTransaction(rawCoopExitTransaction);
 	for (let i = 0; i < tx.outputsLength; i++) {
 		const output = tx.getOutput(i);
@@ -7405,4 +7724,4 @@ function createMemorySparkStore() {
 	};
 }
 //#endregion
-export { EPHEMERAL_ANCHOR_SCRIPT, MIN_STATIC_REFUND_FEE_SATS, SparkCryptoError, SparkError, SparkInputError, SparkRequestError, SparkTokenBroadcastError, addressToScript, buildCpfpChild, createMemorySparkStore, createSatsInvoice, createSparkClient, createTokensInvoice, decodeBolt11, decodeSparkAddress, decodeTokenIdentifier, encodeSparkAddress, encodeTokenIdentifier, exitTransactions, isExpired, parseSparkInvoice, sparkNetworkConfig, uuidv7, verifySparkAddressSignature };
+export { EPHEMERAL_ANCHOR_SCRIPT, MIN_STATIC_REFUND_FEE_SATS, SparkCryptoError, SparkError, SparkInputError, SparkRequestError, SparkTokenBroadcastError, bitcoinAddressScript, buildCpfpChild, createMemorySparkStore, createSatsInvoice, createSparkClient, createTokensInvoice, decodeBolt11, decodeSparkAddress, decodeTokenIdentifier, encodeSparkAddress, encodeTokenIdentifier, exitTransactions, isExpired, parseSparkInvoice, sparkNetworkConfig, uuidv7, verifySparkAddressSignature };

package/dist/server.d.mts

@@ -1,4 +1,4 @@
-import { n as SparkClient } from "./index-rHuqmVV3.mjs";
+import { n as SparkClient } from "./index-CsGON46O.mjs";
 //#region src/server/store.d.ts
 type LightningAddressUser = {
   /** Lowercase LUD-16 local-part. */

package/dist/signer.d.mts

@@ -1,7 +1,7 @@
 import { n as SparkCrypto } from "./index-DUSx3L3J.mjs";
 import { a as sparkNetworkConfig, n as SparkNetwork } from "./lightning-address-CRULmi9v.mjs";
 import { r as decodeBolt11 } from "./bolt11-DsNTTS_O.mjs";
-import { _ as SparkOperator, a as HtlcTimeoutSignRequest, b as SigningTarget, c as PrepareClaimRequest, d as PreparedLightningReceive, f as PreparedTransfer, g as SparkLeafKey, h as SparkKey, i as FrostSignJob, l as PrepareTransferRequest, m as SigningCommitment, n as EPHEMERAL_ANCHOR_SCRIPT, o as IdentityStatement, p as PreparedTransferLeaf, r as FrostAggregateJob, s as OperatorCommitment, t as addressToScript, u as PreparedClaim, v as SparkSigner, y as StaticDepositClaimRequest } from "./transactions-DjTZU8ev.mjs";
+import { _ as SparkOperator, a as HtlcTimeoutSignRequest, b as SigningTarget, c as PrepareClaimRequest, d as PreparedLightningReceive, f as PreparedTransfer, g as SparkLeafKey, h as SparkKey, i as FrostSignJob, l as PrepareTransferRequest, m as SigningCommitment, n as EPHEMERAL_ANCHOR_SCRIPT, o as IdentityStatement, p as PreparedTransferLeaf, r as FrostAggregateJob, s as OperatorCommitment, t as bitcoinAddressScript, u as PreparedClaim, v as SparkSigner, y as StaticDepositClaimRequest } from "./transactions-p89sj_IQ.mjs";
 import { secp256k1 } from "@noble/curves/secp256k1.js";
 //#region src/signer/outflow.d.ts
 /** What an authorized signature sends out, derived inside the signer (never caller-supplied). */
@@ -139,4 +139,4 @@ export declare function createLnurlAuthSigner(options: {
   readonly rootKey: Uint8Array;
 }): LnurlAuthSigner;
 //#endregion
-export { type AuthorizeOutflow, EPHEMERAL_ANCHOR_SCRIPT, type FrostAggregateJob, type FrostSignJob, type HtlcTimeoutSignRequest, type IdentityStatement, type LnurlAuthSigner, type OperatorCommitment, type PrepareClaimRequest, type PrepareTransferRequest, type PreparedClaim, type PreparedLightningReceive, type PreparedTransfer, type PreparedTransferLeaf, type SigningCommitment, type SigningTarget, type SparkKey, type SparkLeafKey, type SparkNetwork, type SparkOperator, type SparkOutflow, type SparkSigner, type StaticDepositClaimRequest, addressToScript, decodeBolt11, sparkNetworkConfig };
+export { type AuthorizeOutflow, EPHEMERAL_ANCHOR_SCRIPT, type FrostAggregateJob, type FrostSignJob, type HtlcTimeoutSignRequest, type IdentityStatement, type LnurlAuthSigner, type OperatorCommitment, type PrepareClaimRequest, type PrepareTransferRequest, type PreparedClaim, type PreparedLightningReceive, type PreparedTransfer, type PreparedTransferLeaf, type SigningCommitment, type SigningTarget, type SparkKey, type SparkLeafKey, type SparkNetwork, type SparkOperator, type SparkOutflow, type SparkSigner, type StaticDepositClaimRequest, bitcoinAddressScript, decodeBolt11, sparkNetworkConfig };

package/dist/signer.mjs

@@ -1,5 +1,5 @@
 import { n as SparkError, r as SparkInputError, t as SparkCryptoError } from "./errors-5xLkExNL.mjs";
-import { A as EPHEMERAL_ANCHOR_SCRIPT, At as SecretShareSchema, B as parseTransaction, F as checkIfValidSequence, H as taprootScriptSpendSighash, It as SparkInvoiceFieldsSchema, K as PartialTokenTransactionSchema, Mt as SendLeafKeyTweaksSchema, N as p2trScriptFromPublicKey, O as txIdInputBytes, Q as ChallengeSchema, R as getTimelockFromSequence, V as taprootKeySpendSighash, _ as addressToScript, bt as ClaimPackageSchema, c as staticDepositStatementDigest, ct as uint64be, d as LIGHTNING_HTLC_SEQUENCE, et as hashSparkInvoice, ft as requireLength, g as lightningHtlcOutputScript, i as claimPackageDigest, jt as SendLeafKeyTweakSchema, l as transferPackageDigest, m as createSequenceLockScript, mt as sparkNetworkConfig, n as hashPartialTokenTransaction, nt as protoInvoiceToPlain, o as sendLeafSigningDigest, r as authnChallengeDigest, s as sspChallengeDigest, u as watchtowerRecoveryStatementDigest, vt as ClaimLeafKeyTweakSchema, yt as ClaimLeafKeyTweaksSchema, zt as TransferPackageSchema } from "./token-DmojVTWi.mjs";
+import { A as EPHEMERAL_ANCHOR_SCRIPT, At as SecretShareSchema, B as parseTransaction, F as checkIfValidSequence, H as taprootScriptSpendSighash, It as SparkInvoiceFieldsSchema, K as PartialTokenTransactionSchema, Mt as SendLeafKeyTweaksSchema, N as p2trScriptFromPublicKey, O as txIdInputBytes, Q as ChallengeSchema, R as getTimelockFromSequence, V as taprootKeySpendSighash, _ as bitcoinAddressScript, bt as ClaimPackageSchema, c as staticDepositStatementDigest, ct as uint64be, d as LIGHTNING_HTLC_SEQUENCE, et as hashSparkInvoice, ft as requireLength, g as lightningHtlcOutputScript, i as claimPackageDigest, jt as SendLeafKeyTweakSchema, l as transferPackageDigest, m as createSequenceLockScript, mt as sparkNetworkConfig, n as hashPartialTokenTransaction, nt as protoInvoiceToPlain, o as sendLeafSigningDigest, r as authnChallengeDigest, s as sspChallengeDigest, u as watchtowerRecoveryStatementDigest, vt as ClaimLeafKeyTweakSchema, yt as ClaimLeafKeyTweaksSchema, zt as TransferPackageSchema } from "./token-C3vqRH-k.mjs";
 import { t as decodeBolt11 } from "./bolt11-rfxnyLcb.mjs";
 import { i as lightningAddressMessageDigest, r as lightningAddressMessage } from "./lightning-address-CZrb8x4p.mjs";
 import "./crypto.mjs";
@@ -1424,4 +1424,4 @@ function createLnurlAuthSigner(options) {
 	};
 }
 //#endregion
-export { EPHEMERAL_ANCHOR_SCRIPT, addressToScript, createLnurlAuthSigner, createSparkSigner, decodeBolt11, lightningSendHtlcScript, lnurlAuthRootKey, sparkAccountKey, sparkNetworkConfig };
+export { EPHEMERAL_ANCHOR_SCRIPT, bitcoinAddressScript, createLnurlAuthSigner, createSparkSigner, decodeBolt11, lightningSendHtlcScript, lnurlAuthRootKey, sparkAccountKey, sparkNetworkConfig };

package/dist/{token-DmojVTWi.mjs → token-C3vqRH-k.mjs}

@@ -1208,15 +1208,16 @@ function prevOutAt(tx, vout) {
 	};
 }
 /**
-* Decodes a Bitcoin address to its output script under any network — matching upstream
-* `Address::from_str(..).assume_checked()`, which never checks that the address's network matches
-* the operating network.
+* Decodes a Bitcoin address to its output script under `network` — bech32 HRP and base58 version
+* bytes must match. An address that only decodes under the other network is an input error, not a
+* silent retry: a coop-exit or sweep to a foreign-network address would burn sats.
 */
-function addressToScript(address) {
-	for (const net of [btcNetwork("mainnet"), btcNetwork("regtest")]) try {
-		return OutScript.encode(Address(net).decode(address));
-	} catch {}
-	throw new SparkInputError("address: not a decodable Bitcoin address");
+function bitcoinAddressScript(address, network) {
+	try {
+		return OutScript.encode(Address(btcNetwork(network)).decode(address));
+	} catch (error) {
+		throw new SparkInputError(`address: not a ${network} Bitcoin address`, { cause: error });
+	}
 }
 /**
 * Shared builder for node/refund transactions: one input spending `parentTxBytes`'s `vout`, one
@@ -1255,10 +1256,10 @@ function buildSingleOutputTx(parentTxBytes, vout, outputScript, sequence, applyF
 * anchor output at `sequence`; the direct variant deducts the fee, has no anchor, and uses
 * `directSequence`.
 */
-function constructNodeTxPair(parentTx, vout, address, sequence, directSequence, feeSats) {
+function constructNodeTxPair(parentTx, vout, address, network, sequence, directSequence, feeSats) {
 	checkIfValidSequence(sequence);
 	checkIfValidSequence(directSequence);
-	const outputScript = addressToScript(address);
+	const outputScript = bitcoinAddressScript(address, network);
 	return {
 		cpfp: buildSingleOutputTx(parentTx, vout, outputScript, sequence, false, feeSats, true),
 		direct: buildSingleOutputTx(parentTx, vout, outputScript, directSequence, true, feeSats, false)
@@ -1284,7 +1285,7 @@ function constructRefundTxTrio(cpfpNodeTx, directNodeTx, vout, receivingPublicKe
 function createNodeTxs(params) {
 	const address = p2trAddressFromScript(prevOutAt(parseTransaction(params.parentTx), params.vout).script, params.network);
 	const directSequence = params.directSequence ?? params.sequence + 50;
-	return constructNodeTxPair(params.parentTx, params.vout, address, params.sequence, directSequence, 955);
+	return constructNodeTxPair(params.parentTx, params.vout, address, params.network, params.sequence, directSequence, 955);
 }
 /** Zero-timelock node transactions over output 0 (root variant of `createNodeTxs`). */
 function createZeroTimelockNodeTx(parentTx, network) {
@@ -2119,4 +2120,4 @@ function hashFinalTokenTransaction(finalTokenTransaction) {
 	return hashProto(FinalTokenTransactionSchema, finalTokenTransaction);
 }
 //#endregion
-export { SparkAuthnService as $, EPHEMERAL_ANCHOR_SCRIPT as A, SecretShareSchema as At, parseTransaction as B, TransferReceiverStatus as Bt, createInitialTimelockRefundTxs as C, InitiatePreimageSwapRequest_Reason as Ct, txId as D, RenewNodeTimelockSigningJobSchema as Dt, estimateVbytes as E, Order as Et, checkIfValidSequence as F, SparkAddressSchema as Ft, PartialTokenOutputSchema as G, SignatureScheme as Gt, taprootScriptSpendSighash as H, TransferType as Ht, doesTxnNeedRenewed as I, SparkInvoiceFieldsSchema as It, SparkTokenService as J, PartialTokenTransactionSchema as K, getNextHTLCTransactionSequence as L, SparkService as Lt, computeTaprootKeyNoScript as M, SendLeafKeyTweaksSchema as Mt, p2trScriptFromPublicKey as N, SenderTransferPackageSchema as Nt, txIdInputBytes as O, RenewNodeZeroTimelockSigningJobSchema as Ot, xOnlyPublicKey as P, SigningJobSchema as Pt, ChallengeSchema as Q, getTimelockFromSequence as R, StartTransferRequestSchema as Rt, createInitialTimelockNodeTx as S, HashVariant as St, createZeroTimelockNodeTx as T, InvoiceStatus as Tt, CommitStatus as U, TreeNodeStatus as Ut, taprootKeySpendSighash as V, TransferStatus as Vt, InvoiceAttachmentSchema as W, UserSignedTxSigningJobSchema as Wt, TokenTransactionMetadataSchema as X, TokenOutputStatus as Y, TokenTransactionStatus as Z, addressToScript as _, AdaptorPublicKeyPackageSchema as _t, proofOfPossessionDigest as a, uuidToBytes as at, createDecrementedTimelockNodeTx as b, ClaimPackageSchema as bt, staticDepositStatementDigest as c, uint64be as ct, LIGHTNING_HTLC_SEQUENCE as d, assertU32 as dt, hashSparkInvoice as et, constructHtlcSenderSpend as f, requireLength as ft, lightningHtlcOutputScript as g, sparkNetworkProto as gt, finalizeHtlcSpend as h, sparkNetworkFromProto as ht, claimPackageDigest as i, uuidFromBytes as it, btcNetwork as j, SendLeafKeyTweakSchema as jt, verifyFinalizedTaprootSignature as k, RenewRefundTimelockSigningJobSchema as kt, transferPackageDigest as l, assertCompressedKey as lt, createSequenceLockScript as m, sparkNetworkConfig as mt, hashPartialTokenTransaction as n, protoInvoiceToPlain as nt, sendLeafSigningDigest as o, uuidv7 as ot, createRefundTxsForLightning as p, u64ToSats as pt, SignatureWithIndexSchema as q, authnChallengeDigest as r, validateInvoiceFields as rt, sspChallengeDigest as s, compareBytes as st, hashFinalTokenTransaction as t, encodeInvoiceFields as tt, watchtowerRecoveryStatementDigest as u, assertSats as ut, createConnectorRefundTxs as v, ClaimLeafKeyTweakSchema as vt, createMultiInputRootTx as w, InputSigningDataSchema as wt, createDecrementedTimelockRefundTxs as x, Direction as xt, createCurrentTimelockRefundTxs as y, ClaimLeafKeyTweaksSchema as yt, isZeroTimelock as z, TransferPackageSchema as zt };
+export { SparkAuthnService as $, EPHEMERAL_ANCHOR_SCRIPT as A, SecretShareSchema as At, parseTransaction as B, TransferReceiverStatus as Bt, createInitialTimelockRefundTxs as C, InitiatePreimageSwapRequest_Reason as Ct, txId as D, RenewNodeTimelockSigningJobSchema as Dt, estimateVbytes as E, Order as Et, checkIfValidSequence as F, SparkAddressSchema as Ft, PartialTokenOutputSchema as G, SignatureScheme as Gt, taprootScriptSpendSighash as H, TransferType as Ht, doesTxnNeedRenewed as I, SparkInvoiceFieldsSchema as It, SparkTokenService as J, PartialTokenTransactionSchema as K, getNextHTLCTransactionSequence as L, SparkService as Lt, computeTaprootKeyNoScript as M, SendLeafKeyTweaksSchema as Mt, p2trScriptFromPublicKey as N, SenderTransferPackageSchema as Nt, txIdInputBytes as O, RenewNodeZeroTimelockSigningJobSchema as Ot, xOnlyPublicKey as P, SigningJobSchema as Pt, ChallengeSchema as Q, getTimelockFromSequence as R, StartTransferRequestSchema as Rt, createInitialTimelockNodeTx as S, HashVariant as St, createZeroTimelockNodeTx as T, InvoiceStatus as Tt, CommitStatus as U, TreeNodeStatus as Ut, taprootKeySpendSighash as V, TransferStatus as Vt, InvoiceAttachmentSchema as W, UserSignedTxSigningJobSchema as Wt, TokenTransactionMetadataSchema as X, TokenOutputStatus as Y, TokenTransactionStatus as Z, bitcoinAddressScript as _, AdaptorPublicKeyPackageSchema as _t, proofOfPossessionDigest as a, uuidToBytes as at, createDecrementedTimelockNodeTx as b, ClaimPackageSchema as bt, staticDepositStatementDigest as c, uint64be as ct, LIGHTNING_HTLC_SEQUENCE as d, assertU32 as dt, hashSparkInvoice as et, constructHtlcSenderSpend as f, requireLength as ft, lightningHtlcOutputScript as g, sparkNetworkProto as gt, finalizeHtlcSpend as h, sparkNetworkFromProto as ht, claimPackageDigest as i, uuidFromBytes as it, btcNetwork as j, SendLeafKeyTweakSchema as jt, verifyFinalizedTaprootSignature as k, RenewRefundTimelockSigningJobSchema as kt, transferPackageDigest as l, assertCompressedKey as lt, createSequenceLockScript as m, sparkNetworkConfig as mt, hashPartialTokenTransaction as n, protoInvoiceToPlain as nt, sendLeafSigningDigest as o, uuidv7 as ot, createRefundTxsForLightning as p, u64ToSats as pt, SignatureWithIndexSchema as q, authnChallengeDigest as r, validateInvoiceFields as rt, sspChallengeDigest as s, compareBytes as st, hashFinalTokenTransaction as t, encodeInvoiceFields as tt, watchtowerRecoveryStatementDigest as u, assertSats as ut, createConnectorRefundTxs as v, ClaimLeafKeyTweakSchema as vt, createMultiInputRootTx as w, InputSigningDataSchema as wt, createDecrementedTimelockRefundTxs as x, Direction as xt, createCurrentTimelockRefundTxs as y, ClaimLeafKeyTweaksSchema as yt, isZeroTimelock as z, TransferPackageSchema as zt };

package/dist/{transactions-DjTZU8ev.d.mts → transactions-p89sj_IQ.d.mts}

@@ -336,10 +336,10 @@ declare const EPHEMERAL_ANCHOR_SCRIPT: Uint8Array;
 //#endregion
 //#region src/core/bitcoin/transactions.d.ts
 /**
- * Decodes a Bitcoin address to its output script under any network — matching upstream
- * `Address::from_str(..).assume_checked()`, which never checks that the address's network matches
- * the operating network.
+ * Decodes a Bitcoin address to its output script under `network` — bech32 HRP and base58 version
+ * bytes must match. An address that only decodes under the other network is an input error, not a
+ * silent retry: a coop-exit or sweep to a foreign-network address would burn sats.
  */
-declare function addressToScript(address: string): Uint8Array;
+declare function bitcoinAddressScript(address: string, network: SparkNetwork): Uint8Array;
 //#endregion
-export { SparkOperator as _, HtlcTimeoutSignRequest as a, SigningTarget as b, PrepareClaimRequest as c, PreparedLightningReceive as d, PreparedTransfer as f, SparkLeafKey as g, SparkKey as h, FrostSignJob as i, PrepareTransferRequest as l, SigningCommitment as m, EPHEMERAL_ANCHOR_SCRIPT as n, IdentityStatement as o, PreparedTransferLeaf as p, FrostAggregateJob as r, OperatorCommitment as s, addressToScript as t, PreparedClaim as u, SparkSigner as v, StaticDepositClaimRequest as y };
+export { SparkOperator as _, HtlcTimeoutSignRequest as a, SigningTarget as b, PrepareClaimRequest as c, PreparedLightningReceive as d, PreparedTransfer as f, SparkLeafKey as g, SparkKey as h, FrostSignJob as i, PrepareTransferRequest as l, SigningCommitment as m, EPHEMERAL_ANCHOR_SCRIPT as n, IdentityStatement as o, PreparedTransferLeaf as p, FrostAggregateJob as r, OperatorCommitment as s, bitcoinAddressScript as t, PreparedClaim as u, SparkSigner as v, StaticDepositClaimRequest as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qntx/spark",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Spark Bitcoin L2 protocol for TypeScript: platform-neutral client, signer and crypto-backend interfaces.",
   "keywords": [
     "bitcoin",