crypto-aio 0.0.3 → 0.2.0

package/dist/adapters/utxo/preview.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coinSelectionPreview = coinSelectionPreview;
+/**
+ * `ext.utxo.coinSelection`: a dry run of the configured coin selection. Signs nothing. The
+ * change output is sized for the sending address (the wallet's `changeAddress` is not known
+ * here), so the fee may differ from a build's by a change output's size difference.
+ */
+const error_1 = require("../../core/errors/error");
+const coinselect_1 = require("./coinselect");
+const spend_1 = require("./spend");
+/**
+ * A caller's request reaches this method unchecked by the core (ext methods are the
+ * family's), so its shape is checked here: a malformed one is a fixed-text validation
+ * error, never a foreign `TypeError`. Addresses are checked where they are decoded.
+ */
+function assertRequest(request) {
+    const invalid = (reason) => new error_1.ValidationError('INVALID_INTENT', reason);
+    if (request === null || typeof request !== 'object') {
+        throw invalid('a coin selection request is { from, outputs, fee?, exclude? }');
+    }
+    if (!Array.isArray(request.outputs)) {
+        throw invalid('outputs must be an array of { to, amount }');
+    }
+    for (const output of request.outputs) {
+        if (output === null || typeof output !== 'object') {
+            throw invalid('outputs must be an array of { to, amount }');
+        }
+        const { amount } = output;
+        if (typeof amount !== 'bigint' || amount <= 0n) {
+            throw new error_1.ValidationError('INVALID_AMOUNT', 'an output amount must be a positive bigint (satoshis)');
+        }
+    }
+    const exclude = request.exclude;
+    if (exclude !== undefined &&
+        (!Array.isArray(exclude) || !exclude.every((o) => typeof o === 'string'))) {
+        throw invalid('exclude must be an array of outpoints (txid:vout)');
+    }
+}
+async function coinSelectionPreview(ctx, request) {
+    assertRequest(request);
+    const sender = (0, spend_1.senderOf)(ctx, request.from);
+    const outputs = (0, spend_1.plannedOutputs)(ctx, request.outputs);
+    const rate = await (0, spend_1.rateOf)(ctx, request.fee ?? 'normal');
+    const candidates = await (0, spend_1.spendable)(ctx, sender.from.canonical, request.exclude, ctx.config.minInputConfirmations);
+    const selection = (0, coinselect_1.selectCoins)({
+        candidates,
+        outputs,
+        changeScript: sender.from.script,
+        inputType: sender.type,
+        rate,
+        dustRelayFee: ctx.config.dustRelayFee,
+        strategy: ctx.config.coinSelection,
+    });
+    const inputs = selection.ok ? selection.inputs : candidates;
+    return {
+        inputs: inputs.map((i) => ({ outpoint: i.outpoint, value: i.value })),
+        fee: selection.fee,
+        satPerKvB: rate,
+        vsize: selection.vsize,
+        change: selection.ok ? selection.change : 0n,
+        sufficient: selection.ok,
+    };
+}
+//# sourceMappingURL=preview.js.map

package/dist/adapters/utxo/preview.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.js","sourceRoot":"","sources":["../../../src/adapters/utxo/preview.ts"],"names":[],"mappings":";;AA6CA,oDAgCC;AA7ED;;;;GAIG;AACH,mDAA0D;AAC1D,6CAA2C;AAE3C,mCAAsE;AAGtE;;;;GAIG;AACH,SAAS,aAAa,CAAC,OAA6B;IAClD,MAAM,OAAO,GAAG,CAAC,MAAc,EAAE,EAAE,CAAC,IAAI,uBAAe,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAC;IAClF,IAAI,OAAO,KAAK,IAAI,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;QACpD,MAAM,OAAO,CAAC,+DAA+D,CAAC,CAAC;IACjF,CAAC;IACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QACpC,MAAM,OAAO,CAAC,4CAA4C,CAAC,CAAC;IAC9D,CAAC;IACD,KAAK,MAAM,MAAM,IAAI,OAAO,CAAC,OAA6B,EAAE,CAAC;QAC3D,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;YAClD,MAAM,OAAO,CAAC,4CAA4C,CAAC,CAAC;QAC9D,CAAC;QACD,MAAM,EAAE,MAAM,EAAE,GAAG,MAAuC,CAAC;QAC3D,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,IAAI,EAAE,EAAE,CAAC;YAC/C,MAAM,IAAI,uBAAe,CACvB,gBAAgB,EAChB,uDAAuD,CACxD,CAAC;QACJ,CAAC;IACH,CAAC;IACD,MAAM,OAAO,GAAY,OAAO,CAAC,OAAO,CAAC;IACzC,IACE,OAAO,KAAK,SAAS;QACrB,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,CAAC,EACzE,CAAC;QACD,MAAM,OAAO,CAAC,mDAAmD,CAAC,CAAC;IACrE,CAAC;AACH,CAAC;AAEM,KAAK,UAAU,oBAAoB,CACxC,GAAgB,EAChB,OAA6B;IAE7B,aAAa,CAAC,OAAO,CAAC,CAAC;IACvB,MAAM,MAAM,GAAG,IAAA,gBAAQ,EAAC,GAAG,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,MAAM,OAAO,GAAG,IAAA,sBAAc,EAAC,GAAG,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACrD,MAAM,IAAI,GAAG,MAAM,IAAA,cAAM,EAAC,GAAG,EAAE,OAAO,CAAC,GAAG,IAAI,QAAQ,CAAC,CAAC;IACxD,MAAM,UAAU,GAAG,MAAM,IAAA,iBAAS,EAChC,GAAG,EACH,MAAM,CAAC,IAAI,CAAC,SAAS,EACrB,OAAO,CAAC,OAAO,EACf,GAAG,CAAC,MAAM,CAAC,qBAAqB,CACjC,CAAC;IACF,MAAM,SAAS,GAAG,IAAA,wBAAW,EAAC;QAC5B,UAAU;QACV,OAAO;QACP,YAAY,EAAE,MAAM,CAAC,IAAI,CAAC,MAAM;QAChC,SAAS,EAAE,MAAM,CAAC,IAAI;QACtB,IAAI;QACJ,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,YAAY;QACrC,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,aAAa;KACnC,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC;IAC5D,OAAO;QACL,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC;QACrE,GAAG,EAAE,SAAS,CAAC,GAAG;QAClB,SAAS,EAAE,IAAI;QACf,KAAK,EAAE,SAAS,CAAC,KAAK;QACtB,MAAM,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE;QAC5C,UAAU,EAAE,SAAS,CAAC,EAAE;KACzB,CAAC;AACJ,CAAC","sourcesContent":["/**\n * `ext.utxo.coinSelection`: a dry run of the configured coin selection. Signs nothing. The\n * change output is sized for the sending address (the wallet's `changeAddress` is not known\n * here), so the fee may differ from a build's by a change output's size difference.\n */\nimport { ValidationError } from '../../core/errors/error';\nimport { selectCoins } from './coinselect';\nimport type { UtxoContext } from './context';\nimport { plannedOutputs, rateOf, senderOf, spendable } from './spend';\nimport type { UtxoSelectionPreview, UtxoSelectionRequest } from './types';\n\n/**\n * A caller's request reaches this method unchecked by the core (ext methods are the\n * family's), so its shape is checked here: a malformed one is a fixed-text validation\n * error, never a foreign `TypeError`. Addresses are checked where they are decoded.\n */\nfunction assertRequest(request: UtxoSelectionRequest): void {\n  const invalid = (reason: string) => new ValidationError('INVALID_INTENT', reason);\n  if (request === null || typeof request !== 'object') {\n    throw invalid('a coin selection request is { from, outputs, fee?, exclude? }');\n  }\n  if (!Array.isArray(request.outputs)) {\n    throw invalid('outputs must be an array of { to, amount }');\n  }\n  for (const output of request.outputs as readonly unknown[]) {\n    if (output === null || typeof output !== 'object') {\n      throw invalid('outputs must be an array of { to, amount }');\n    }\n    const { amount } = output as { readonly amount?: unknown };\n    if (typeof amount !== 'bigint' || amount <= 0n) {\n      throw new ValidationError(\n        'INVALID_AMOUNT',\n        'an output amount must be a positive bigint (satoshis)',\n      );\n    }\n  }\n  const exclude: unknown = request.exclude;\n  if (\n    exclude !== undefined &&\n    (!Array.isArray(exclude) || !exclude.every((o) => typeof o === 'string'))\n  ) {\n    throw invalid('exclude must be an array of outpoints (txid:vout)');\n  }\n}\n\nexport async function coinSelectionPreview(\n  ctx: UtxoContext,\n  request: UtxoSelectionRequest,\n): Promise<UtxoSelectionPreview> {\n  assertRequest(request);\n  const sender = senderOf(ctx, request.from);\n  const outputs = plannedOutputs(ctx, request.outputs);\n  const rate = await rateOf(ctx, request.fee ?? 'normal');\n  const candidates = await spendable(\n    ctx,\n    sender.from.canonical,\n    request.exclude,\n    ctx.config.minInputConfirmations,\n  );\n  const selection = selectCoins({\n    candidates,\n    outputs,\n    changeScript: sender.from.script,\n    inputType: sender.type,\n    rate,\n    dustRelayFee: ctx.config.dustRelayFee,\n    strategy: ctx.config.coinSelection,\n  });\n  const inputs = selection.ok ? selection.inputs : candidates;\n  return {\n    inputs: inputs.map((i) => ({ outpoint: i.outpoint, value: i.value })),\n    fee: selection.fee,\n    satPerKvB: rate,\n    vsize: selection.vsize,\n    change: selection.ok ? selection.change : 0n,\n    sufficient: selection.ok,\n  };\n}\n"]}

package/dist/adapters/utxo/proofs.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Proofs (finalized-state checks behind `proven` verdicts) and the block source.
+ *
+ * Finality is N confirmations. Every fact is attested at its own height with a monotone
+ * predicate quorum key, and no endpoint proposes a height. "Block h is final" is "every
+ * proof endpoint holds a block at h + N − 1": the quorum reads the head with the key
+ * `head >= h + N − 1`, so endpoints further ahead agree, and one that trails decides
+ * nothing. Only `finalizedHead` (no anchor of its own) takes one endpoint's head, trails
+ * it by `PEER_SKEW`, then attests it. One endpoint's head never decides finality.
+ *
+ * `includedFinal` answers "not included" only when an input of our Attempt has a
+ * quorum-attested final spender that is neither our txid nor a malleated copy of it.
+ * Every other case decides nothing (a retryable `ProviderError`): our transaction in a
+ * mempool or in a block not yet final, an unknown spender, a lagging or load-balanced
+ * backend. A stale inclusion (its block is no longer the block at its height) is a
+ * retryable `PROVIDER_INCONSISTENT`, and so is a transaction view that puts ours in a
+ * block while another transaction's spend of its input is final: both cannot hold. So
+ * `includedFinal` never answers "not included" without its own attestation of a different
+ * final spend, and an endpoint-set change between the monitor's `slotConsumed` and
+ * `includedFinal` calls cannot produce a false proven `replaced`.
+ *
+ * The block source delivers only what authenticated bytes say. A block's transactions are
+ * decoded from its own bytes (`rawBlock`), which must hash to the block the scan asked for
+ * and commit to every transaction and witness, and the header read at its height must be
+ * those bytes' own (parent and time). The outputs a delivered transaction's inputs spend,
+ * which give its `from`, input values and fee, are read from the block itself or from each
+ * previous transaction's bytes, bound to the txid the input names. So no endpoint can add,
+ * drop or alter a transaction, an output or a sender of what is delivered. A filtered scan
+ * picks transactions by their outputs (the bytes) and by the inputs the index's pages say
+ * spend from a watched address; each page must be the bytes' own, confirmed in that block,
+ * and its claims must hold for every transaction delivered, so a lying index can at most
+ * hide a watched address's spend that pays no watched address. Which block is at a height
+ * stays the endpoint's word, as in every family (the proof quorum confirms rollbacks). A
+ * reorg while reading, or a block, page or previous transaction the endpoint does not have,
+ * decides nothing (retryable). Address filters match output and prevout scripts, so a
+ * watched address's spend is kept even when no output of it has an address.
+ */
+import type { BlockSource, ProofSource } from '../../core/driver/types';
+import { type UtxoContext } from './context';
+import type { EsploraTx } from './types';
+/** Blocks `finalizedHead` trails one endpoint's head by, so peers can attest it. */
+export declare const PEER_SKEW = 2n;
+/**
+ * The reads a proof attests under the proof quorum, each fact at its own height. The
+ * proof source and the builder share them: the builder's proof-tagged reads are this
+ * module's, never a copy.
+ */
+export declare function attestedReads(ctx: UtxoContext, signal?: AbortSignal): {
+    holds: (height: bigint) => Promise<boolean>;
+    hashAt: (height: bigint) => Promise<string | null>;
+    assertCanonical: (height: bigint, hash: string) => Promise<void>;
+    txView: (txid: string) => Promise<EsploraTx | null>;
+};
+/**
+ * Each of `txids` (the previous transactions of the inputs a build adds) is in a
+ * block, attested under the proof quorum at its own height: the proof endpoints agree on the
+ * transaction and its block, all hold a block `confirmations − 1` above it, and have that
+ * block at that height. Its bytes authenticate themselves, but only this proves a
+ * chain holds it: an indexer's invented transaction, or one a reorg took out, would stall an
+ * Attempt for good, since nothing would ever spend its outpoint. Anything short of that is a
+ * retryable `PROVIDER_UNAVAILABLE` (a stale view `PROVIDER_INCONSISTENT`), and every read
+ * decides nothing on failure. A parent found final is not read again.
+ */
+export declare function assertConfirmed(ctx: UtxoContext, txids: readonly string[], confirmations: number, signal?: AbortSignal): Promise<void>;
+export declare function proofSource(ctx: UtxoContext): ProofSource;
+export declare function blockSource(ctx: UtxoContext): BlockSource;

package/dist/adapters/utxo/proofs.js

@@ -0,0 +1,469 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PEER_SKEW = void 0;
+exports.attestedReads = attestedReads;
+exports.assertConfirmed = assertConfirmed;
+exports.proofSource = proofSource;
+exports.blockSource = blockSource;
+const error_1 = require("../../core/errors/error");
+const bytes_1 = require("../../core/util/bytes");
+const address_1 = require("./address");
+const context_1 = require("./context");
+const decode_1 = require("./decode");
+const esplora_1 = require("./esplora");
+const rawblock_1 = require("./rawblock");
+const reader_1 = require("./reader");
+/** Blocks `finalizedHead` trails one endpoint's head by, so peers can attest it. */
+exports.PEER_SKEW = 2n;
+/** Esplora's page of block transactions (electrs' `CHAIN_TXS_PER_PAGE`). */
+const PAGE = 25;
+/**
+ * How many previous transactions a block scan reads at once: a full block's delivered
+ * transactions spend outputs of thousands. The transport's rate limit still paces them.
+ */
+const PREVIOUS_READS = 8;
+/** No height is below 0 or beyond what a server parses: such a height is never sent. */
+const MAX_HEIGHT = BigInt(Number.MAX_SAFE_INTEGER);
+const outOfRange = (height) => height < 0n || height > MAX_HEIGHT;
+const undecided = (reason) => new error_1.ProviderError('PROVIDER_UNAVAILABLE', reason);
+/** Two quorum reads that cannot both hold decide nothing (retryable). */
+const contradiction = (reason) => new error_1.ProviderError('PROVIDER_INCONSISTENT', reason, { retryable: true });
+const stale = () => contradiction('the including block is no longer the block at its height');
+/** The block a scan reads is gone from the endpoint's chain, or was never on it. */
+const changed = (block) => contradiction(`block ${block.height} changed while scanning`);
+/**
+ * An output of a block's or a previous transaction's bytes as an Esplora page shows it.
+ * Its value is in range (consensus), so out of range the bytes are not chain data.
+ */
+function outputView(output) {
+    if (output.value < 0n || output.value > esplora_1.MAX_MONEY)
+        throw (0, esplora_1.malformed)('output value');
+    return {
+        script: (0, bytes_1.toHex)(output.script),
+        type: (0, decode_1.scriptType)(output.script),
+        value: output.value,
+    };
+}
+/**
+ * Whether a page's transaction is `own`, the one the block's bytes hold at its place: the
+ * same txid, and the same inputs (outpoints, sequences, coinbase) and outputs.
+ */
+function samePageTx(page, own) {
+    return (page.txid === own.txid &&
+        page.version === own.version &&
+        page.locktime === own.locktime &&
+        page.vin.length === own.inputs.length &&
+        page.vout.length === own.outputs.length &&
+        page.vin.every((input, n) => {
+            const mine = own.inputs[n];
+            return (mine !== undefined &&
+                input.txid === mine.txid &&
+                input.vout === mine.vout &&
+                input.sequence === mine.sequence &&
+                input.coinbase === (0, rawblock_1.isNullOutpoint)(mine));
+        }) &&
+        page.vout.every((output, n) => {
+            const mine = own.outputs[n];
+            return (mine !== undefined &&
+                output.value === mine.value &&
+                output.script === (0, bytes_1.toHex)(mine.script));
+        }));
+}
+/**
+ * A block hash read under the proof quorum is compared as `parseHash` reads it, so two
+ * honest endpoints that differ only by whitespace agree, and the key is exactly the value
+ * the verdict uses. Compared as raw text, one endpoint's trailing newline would split the
+ * quorum forever.
+ */
+const HASH_PROOF = { ...context_1.PROOF, quorumKey: esplora_1.parseHash };
+/** A transaction view as the proof quorum compares it: its txid, and its block and height. */
+const txViewKey = (answer) => {
+    const t = (0, esplora_1.parseTx)(answer);
+    return t.status.confirmed
+        ? `${t.txid}@${t.status.blockHash}:${t.status.blockHeight}`
+        : `${t.txid}:unconfirmed`;
+};
+/**
+ * The reads a proof attests under the proof quorum, each fact at its own height. The
+ * proof source and the builder share them: the builder's proof-tagged reads are this
+ * module's, never a copy.
+ */
+function attestedReads(ctx, signal) {
+    const { esplora } = ctx;
+    /** "I hold a block at `height`" (monotone in the head, so endpoints further ahead agree). */
+    const holds = async (height) => {
+        const head = await esplora.tipHeight({
+            ...(0, context_1.withSignal)(context_1.PROOF, signal),
+            quorumKey: (answer) => (0, esplora_1.parseHeight)(answer) >= height,
+        });
+        return head >= height;
+    };
+    /** The hash of the block at `height` on the proof endpoints' chain. */
+    const hashAt = (height) => esplora.blockHashAt(height, (0, context_1.withSignal)(HASH_PROOF, signal));
+    /** The quorum's hash at `height` must be `hash`; otherwise the answer was stale. */
+    const assertCanonical = async (height, hash) => {
+        if ((await hashAt(height)) !== hash)
+            throw stale();
+    };
+    /** A transaction and the block it is in, as the proof endpoints agree on it. */
+    const txView = (txid) => esplora.tx(txid, { ...(0, context_1.withSignal)(context_1.PROOF, signal), quorumKey: txViewKey });
+    return { holds, hashAt, assertCanonical, txView };
+}
+/** How many parents `assertConfirmed` reads at once, and keeps once final. */
+const PARENT_READS = 4;
+const FINAL_PARENTS = 10_000;
+const finalParents = new WeakMap();
+const notConfirmed = () => new error_1.ProviderError('PROVIDER_UNAVAILABLE', "an input's previous transaction is not in a block the proof endpoints hold yet");
+/**
+ * Each of `txids` (the previous transactions of the inputs a build adds) is in a
+ * block, attested under the proof quorum at its own height: the proof endpoints agree on the
+ * transaction and its block, all hold a block `confirmations − 1` above it, and have that
+ * block at that height. Its bytes authenticate themselves, but only this proves a
+ * chain holds it: an indexer's invented transaction, or one a reorg took out, would stall an
+ * Attempt for good, since nothing would ever spend its outpoint. Anything short of that is a
+ * retryable `PROVIDER_UNAVAILABLE` (a stale view `PROVIDER_INCONSISTENT`), and every read
+ * decides nothing on failure. A parent found final is not read again.
+ */
+async function assertConfirmed(ctx, txids, confirmations, signal) {
+    let final = finalParents.get(ctx.esplora);
+    if (!final) {
+        final = new Map();
+        finalParents.set(ctx.esplora, final);
+    }
+    const known = final;
+    const pending = [...new Set(txids)].filter((txid) => !known.has(txid));
+    if (pending.length === 0)
+        return;
+    await (0, context_1.proofRead)(async () => {
+        const reads = attestedReads(ctx, signal);
+        const blocks = new Map();
+        let top = 0n;
+        await (0, context_1.forEachBounded)(pending, PARENT_READS, async (txid) => {
+            const tx = await reads.txView(txid);
+            if (!tx?.status.confirmed)
+                throw notConfirmed();
+            const height = tx.status.blockHeight;
+            blocks.set(tx.status.blockHash, height);
+            if (height > top)
+                top = height;
+        });
+        // Monotone: the proof endpoints hold `top + confirmations − 1` only if they hold every
+        // lower height, so one read attests every parent's depth.
+        if (!(await reads.holds(top + BigInt(Math.max(1, confirmations)) - 1n))) {
+            throw notConfirmed();
+        }
+        for (const [hash, height] of blocks)
+            await reads.assertCanonical(height, hash);
+        if (await reads.holds(top + BigInt(ctx.config.confirmations) - 1n)) {
+            for (const txid of pending) {
+                known.set(txid, true);
+                if (known.size > FINAL_PARENTS)
+                    known.delete(known.keys().next().value);
+            }
+        }
+    });
+}
+function proofSource(ctx) {
+    const { esplora, config } = ctx;
+    const depth = BigInt(config.confirmations) - 1n;
+    const { holds, hashAt, assertCanonical, txView } = attestedReads(ctx);
+    /** The transaction that spent `input` in a final, canonical block (quorum-attested). */
+    const finalSpender = async (input) => {
+        const spend = await esplora.outspend(input.txid, input.vout, {
+            ...context_1.PROOF,
+            quorumKey: (answer) => {
+                const s = (0, esplora_1.parseOutspend)(answer);
+                return s.spent && s.status?.confirmed
+                    ? `${s.txid}@${s.status.blockHash}:${s.status.blockHeight}`
+                    : 'not-in-a-block';
+            },
+        });
+        const status = spend.status;
+        if (!spend.spent || spend.txid === undefined || !status?.confirmed)
+            return undefined;
+        const height = status.blockHeight;
+        const hash = status.blockHash;
+        if (!(await holds(height + depth)))
+            return undefined;
+        await assertCanonical(height, hash);
+        return { txid: spend.txid, height, hash };
+    };
+    const inputsOf = (ordering) => ordering.kind === 'inputs' ? ordering.inputs.map(context_1.parseOutpoint) : [];
+    const source = {
+        async finalizedHead() {
+            const anchor = (await esplora.tipHeight(context_1.MONITOR)) - exports.PEER_SKEW;
+            if (anchor < 0n || !(await holds(anchor))) {
+                throw undecided('the proof endpoints have not reached the head');
+            }
+            const final = anchor - depth;
+            const height = final < 0n ? 0n : final;
+            const hash = await hashAt(height);
+            if (hash === null)
+                throw undecided('the final block is not visible to the proof endpoints');
+            return { height, hash };
+        },
+        async includedFinal(ref, ordering, from) {
+            if (!(0, esplora_1.isHash)(ref.id))
+                throw undecided('malformed transaction id');
+            const tx = await txView(ref.id);
+            if (tx?.status.confirmed) {
+                const height = tx.status.blockHeight;
+                const hash = tx.status.blockHash;
+                if (await holds(height + depth)) {
+                    await assertCanonical(height, hash);
+                    // A transaction in a block has executed; its txid commits to its outputs.
+                    return {
+                        included: true,
+                        success: true,
+                        blockHeight: height,
+                        blockHash: hash,
+                        txHash: tx.txid,
+                    };
+                }
+            }
+            // Unknown, in a mempool, or not yet final: only a final spender of one of our inputs
+            // decides. Our own txid there means the views are inconsistent (decide nothing); a
+            // malleated copy of ours is our payment; any other transaction proves ours dead,
+            // unless the quorum also puts ours in a block (the views contradict each other).
+            for (const input of inputsOf(ordering)) {
+                const spender = await finalSpender(input);
+                if (spender === undefined)
+                    continue;
+                if (spender.txid === ref.id) {
+                    throw undecided('the spend and the transaction views disagree');
+                }
+                if (await (0, reader_1.isOwnCopy)(ctx, ref.id, from, spender.txid, context_1.PROOF)) {
+                    return {
+                        included: true,
+                        success: true,
+                        blockHeight: spender.height,
+                        blockHash: spender.hash,
+                        txHash: spender.txid,
+                    };
+                }
+                if (tx?.status.confirmed) {
+                    throw contradiction('the transaction is in a block while another spend of its input is final');
+                }
+                return { included: false };
+            }
+            throw undecided(tx
+                ? 'the transaction is not final yet'
+                : 'the indexer does not know this transaction yet');
+        },
+        async slotConsumed(ordering, _from, level) {
+            for (const input of inputsOf(ordering)) {
+                if (level === 'latest') {
+                    if ((await esplora.outspend(input.txid, input.vout, context_1.MONITOR)).spent)
+                        return true;
+                }
+                else if ((await finalSpender(input)) !== undefined) {
+                    return true;
+                }
+            }
+            return false;
+        },
+        expired: async () => false,
+        async blockHash(height, level) {
+            if (outOfRange(height))
+                return null;
+            if (level === 'finalized' && !(await holds(height + depth)))
+                return null;
+            return hashAt(height);
+        },
+    };
+    // Every read of every proof decides nothing on "not available here".
+    return {
+        finalizedHead: () => (0, context_1.proofRead)(() => source.finalizedHead()),
+        includedFinal: (ref, ordering, from) => (0, context_1.proofRead)(() => source.includedFinal(ref, ordering, from)),
+        slotConsumed: (ordering, from, level) => (0, context_1.proofRead)(() => source.slotConsumed(ordering, from, level)),
+        expired: (ordering) => source.expired(ordering),
+        blockHash: (height, level) => (0, context_1.proofRead)(() => source.blockHash(height, level)),
+    };
+}
+function blockSource(ctx) {
+    const { esplora, config } = ctx;
+    /** The output scripts of the watched addresses; `undefined` means no filter. */
+    const scriptsOf = (addresses) => {
+        if (addresses === undefined || addresses.length === 0)
+            return undefined;
+        const scripts = new Set();
+        for (const address of addresses) {
+            try {
+                scripts.add((0, bytes_1.toHex)((0, address_1.decodeAddress)(address, config.address).script));
+            }
+            catch {
+                // Not an address of this network: it matches nothing.
+            }
+        }
+        return scripts;
+    };
+    /**
+     * The places of `raw`'s transactions that touch `wanted`, with each one's page: an output
+     * to it, read from the block's own bytes, or an input that, by the index's pages, spends
+     * from it. Every page is bound to the bytes: exactly the transactions they hold at its
+     * places, with the same inputs and outputs, confirmed in this block. So a page only claims
+     * which outputs the block's inputs spend, and `viewOf` checks the claims of every
+     * transaction delivered against the previous transactions' own bytes: all a lying index
+     * can do is hide a spend from a watched address that pays no watched address.
+     */
+    const touching = async (block, raw, wanted) => {
+        const picked = new Map();
+        for (let start = 0; start < raw.txs.length; start += PAGE) {
+            let page;
+            try {
+                page = await esplora.blockTxs(block.hash, start, context_1.MONITOR);
+            }
+            catch (error) {
+                // A backend that does not have the block (lagging, load-balanced) decides nothing.
+                if ((0, esplora_1.isNotFound)(error))
+                    throw changed(block);
+                throw error;
+            }
+            // Each page holds exactly what the block leaves for it.
+            if (page.length !== Math.min(PAGE, raw.txs.length - start)) {
+                throw (0, esplora_1.malformed)('block txs page');
+            }
+            page.forEach((tx, offset) => {
+                const own = raw.txs[start + offset];
+                if (!samePageTx(tx, own)) {
+                    throw contradiction("a block page differs from the block's own bytes");
+                }
+                const { status } = tx;
+                if (!status.confirmed ||
+                    status.blockHash !== block.hash ||
+                    status.blockHeight !== block.height) {
+                    throw changed(block);
+                }
+                if (own.outputs.some((output) => wanted.has((0, bytes_1.toHex)(output.script))) ||
+                    tx.vin.some((input) => input.prevout && wanted.has(input.prevout.script))) {
+                    picked.set(start + offset, tx);
+                }
+            });
+        }
+        return picked;
+    };
+    /**
+     * The outputs the inputs of `txs` spend, by previous txid: a transaction of the block
+     * itself, or the previous transaction's own bytes, bound to its txid (`outputsOf`). One
+     * endpoint answers, so one that does not have a previous transaction decides nothing.
+     */
+    const spentOutputs = async (raw, txs) => {
+        const known = new Map(raw.txs.map((tx) => [tx.txid, tx.outputs]));
+        const missing = new Set();
+        for (const tx of txs) {
+            for (const input of tx.inputs) {
+                if (!(0, rawblock_1.isNullOutpoint)(input) && !known.has(input.txid))
+                    missing.add(input.txid);
+            }
+        }
+        await (0, context_1.forEachBounded)([...missing], PREVIOUS_READS, async (txid) => {
+            const outputs = await esplora.outputsOf(txid, context_1.MONITOR);
+            if (!outputs)
+                throw undecided("an input's previous transaction is not available");
+            known.set(txid, outputs);
+        });
+        return known;
+    };
+    /**
+     * A transaction of the block as Esplora shows it, from its own bytes and the outputs its
+     * inputs spend, so it decodes as a page of it would. A page's claims about those outputs
+     * (`page`) must be what the previous transactions hold.
+     */
+    const viewOf = (tx, spent, status, page) => {
+        const vout = tx.outputs.map(outputView);
+        let coinbase = false;
+        let fee = -vout.reduce((sum, output) => sum + output.value, 0n);
+        const vin = tx.inputs.map((input, n) => {
+            const outpoint = { txid: input.txid, vout: input.vout, sequence: input.sequence };
+            if ((0, rawblock_1.isNullOutpoint)(input)) {
+                coinbase = true;
+                return { ...outpoint, coinbase: true };
+            }
+            const output = spent.get(input.txid)?.[input.vout];
+            if (!output)
+                throw contradiction('a block input spends an output that does not exist');
+            const prevout = outputView(output);
+            const claim = page?.vin[n]?.prevout;
+            if (claim && (claim.script !== prevout.script || claim.value !== prevout.value)) {
+                throw contradiction('the index names another output than the one an input spends');
+            }
+            fee += prevout.value;
+            return { ...outpoint, coinbase: false, prevout };
+        });
+        // Esplora's convention: a coinbase's fee is 0.
+        if (coinbase)
+            fee = 0n;
+        if (fee < 0n || fee > esplora_1.MAX_MONEY)
+            throw (0, esplora_1.malformed)('tx fee');
+        return {
+            txid: tx.txid,
+            version: tx.version,
+            locktime: tx.locktime,
+            weight: tx.strippedSize * 3 + tx.bytes.length,
+            fee,
+            vin,
+            vout,
+            status,
+        };
+    };
+    return {
+        async header(height) {
+            if (outOfRange(height))
+                return null;
+            const hash = await esplora.blockHashAt(height, context_1.MONITOR);
+            if (!hash)
+                return null;
+            const block = await esplora.block(hash, context_1.MONITOR);
+            if (!block)
+                return null;
+            // The block at `height` must say it is at `height`.
+            if (block.height !== height) {
+                throw contradiction(`block ${height} changed while reading`);
+            }
+            return {
+                height: block.height,
+                hash: block.hash,
+                parentHash: block.parentHash,
+                timestamp: block.timestamp,
+            };
+        },
+        async transactions(block, filter) {
+            // `filter.assets` is a hint: a list without the native asset wants tokens only, and a
+            // Bitcoin block has none, so nothing is read.
+            if (filter?.assets?.length && !filter.assets.includes('native'))
+                return [];
+            // The block's own bytes, bound to its hash (`rawBlock`): every transaction delivered
+            // is the block's, byte for byte, whatever the index's pages say.
+            const raw = await esplora.rawBlock(block.hash, context_1.MONITOR);
+            // A backend that does not have the block (lagging, load-balanced, or a full-mode
+            // electrs, which serves its best chain's only) decides nothing.
+            if (!raw)
+                throw changed(block);
+            // The header read at this height must be the bytes' own, so the block delivered (its
+            // parent link and time) is the one its hash names.
+            if (raw.parentHash !== block.parentHash || raw.time !== block.timestamp) {
+                throw contradiction(`the header of block ${block.height} is not its own`);
+            }
+            const wanted = scriptsOf(filter?.addresses);
+            const picked = wanted && (await touching(block, raw, wanted));
+            const txs = picked ? raw.txs.filter((_, i) => picked.has(i)) : raw.txs;
+            const spent = await spentOutputs(raw, txs);
+            // Checked after the reads, so a reorg while reading is caught.
+            if ((await esplora.blockHashAt(block.height, context_1.MONITOR)) !== block.hash) {
+                throw changed(block);
+            }
+            const status = {
+                confirmed: true,
+                blockHeight: block.height,
+                blockHash: block.hash,
+                blockTime: raw.time,
+            };
+            return raw.txs.flatMap((tx, i) => picked && !picked.has(i)
+                ? []
+                : [
+                    (0, decode_1.decodeTransaction)(viewOf(tx, spent, status, picked?.get(i)), config.address),
+                ]);
+        },
+    };
+}
+//# sourceMappingURL=proofs.js.map