crypto-aio 0.0.3 → 0.1.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":"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","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,57 @@
+/**
+ * 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 reads chain data leniently (the Esplora client's parsers) and binds
+ * every page to its block: each page has exactly the transactions the block's count
+ * leaves for it, no txid twice, each confirmed in that block. A reorg while paging, or a
+ * page 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,331 @@
+"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 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;
+/** Consensus: a block's transaction count × 4 is at most `MAX_BLOCK_WEIGHT` (4,000,000). */
+const MAX_BLOCK_TXS = 1_000_000;
+/** 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');
+/**
+ * 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;
+    };
+    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) {
+            const inconsistent = () => contradiction(`block ${block.height} changed while scanning`);
+            const meta = await esplora.block(block.hash, context_1.MONITOR);
+            if (!meta || meta.height !== block.height)
+                throw inconsistent();
+            // Every block has a coinbase; none holds more than consensus allows. Bounded work.
+            if (meta.txCount < 1 || meta.txCount > MAX_BLOCK_TXS) {
+                throw (0, esplora_1.malformed)('block.tx_count');
+            }
+            // `filter.assets` is a hint: a list without the native asset wants tokens only, and a
+            // Bitcoin block has none, so nothing is paged.
+            if (filter?.assets?.length && !filter.assets.includes('native'))
+                return [];
+            const txs = [];
+            const seen = new Set();
+            for (let start = 0; start < meta.txCount; 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 inconsistent();
+                    throw error;
+                }
+                // Each page holds exactly what the count leaves for it, and no txid twice.
+                if (page.length !== Math.min(PAGE, meta.txCount - start)) {
+                    throw (0, esplora_1.malformed)('block txs page');
+                }
+                for (const tx of page) {
+                    if (seen.has(tx.txid))
+                        throw (0, esplora_1.malformed)('block txs page');
+                    seen.add(tx.txid);
+                    const { status } = tx;
+                    if (!status.confirmed ||
+                        status.blockHash !== block.hash ||
+                        status.blockHeight !== block.height) {
+                        throw inconsistent();
+                    }
+                    txs.push(tx);
+                }
+            }
+            // Checked after the pages, so a reorg while paging is caught.
+            if ((await esplora.blockHashAt(block.height, context_1.MONITOR)) !== block.hash)
+                throw inconsistent();
+            const wanted = scriptsOf(filter?.addresses);
+            const touches = (tx) => wanted === undefined ||
+                tx.vout.some((output) => wanted.has(output.script)) ||
+                tx.vin.some((input) => input.prevout && wanted.has(input.prevout.script));
+            return txs.filter(touches).map((tx) => (0, decode_1.decodeTransaction)(tx, config.address));
+        },
+    };
+}
+//# sourceMappingURL=proofs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proofs.js","sourceRoot":"","sources":["../../../src/adapters/utxo/proofs.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Proofs (finalized-state checks behind `proven` verdicts) and the block source.\n *\n * Finality is N confirmations. Every fact is attested at its own height with a monotone\n * predicate quorum key, and no endpoint proposes a height. \"Block h is final\" is \"every\n * proof endpoint holds a block at h + N − 1\": the quorum reads the head with the key\n * `head >= h + N − 1`, so endpoints further ahead agree, and one that trails decides\n * nothing. Only `finalizedHead` (no anchor of its own) takes one endpoint's head, trails\n * it by `PEER_SKEW`, then attests it. One endpoint's head never decides finality.\n *\n * `includedFinal` answers \"not included\" only when an input of our Attempt has a\n * quorum-attested final spender that is neither our txid nor a malleated copy of it.\n * Every other case decides nothing (a retryable `ProviderError`): our transaction in a\n * mempool or in a block not yet final, an unknown spender, a lagging or load-balanced\n * backend. A stale inclusion (its block is no longer the block at its height) is a\n * retryable `PROVIDER_INCONSISTENT`, and so is a transaction view that puts ours in a\n * block while another transaction's spend of its input is final: both cannot hold. So\n * `includedFinal` never answers \"not included\" without its own attestation of a different\n * final spend, and an endpoint-set change between the monitor's `slotConsumed` and\n * `includedFinal` calls cannot produce a false proven `replaced`.\n *\n * The block source reads chain data leniently (the Esplora client's parsers) and binds\n * every page to its block: each page has exactly the transactions the block's count\n * leaves for it, no txid twice, each confirmed in that block. A reorg while paging, or a\n * page the endpoint does not have, decides nothing (retryable). Address filters match\n * output and prevout scripts, so a watched address's spend is kept even when no output of\n * it has an address.\n */\nimport type {\n  BlockSource,\n  DriverBlock,\n  FinalityLevel,\n  ProofSource,\n} from '../../core/driver/types';\nimport { ProviderError } from '../../core/errors/error';\nimport type { OrderingData } from '../../core/model/ordering';\nimport type { AttemptRef } from '../../core/model/transaction';\nimport { toHex } from '../../core/util/bytes';\nimport { decodeAddress } from './address';\nimport {\n  MONITOR,\n  PROOF,\n  forEachBounded,\n  parseOutpoint,\n  proofRead,\n  withSignal,\n  type UtxoContext,\n} from './context';\nimport { decodeTransaction } from './decode';\nimport {\n  isHash,\n  isNotFound,\n  type EsploraClient,\n  malformed,\n  parseHash,\n  parseHeight,\n  parseOutspend,\n  parseTx,\n} from './esplora';\nimport { isOwnCopy } from './reader';\nimport type { EsploraTx } from './types';\n\n/** Blocks `finalizedHead` trails one endpoint's head by, so peers can attest it. */\nexport const PEER_SKEW = 2n;\n\n/** Esplora's page of block transactions (electrs' `CHAIN_TXS_PER_PAGE`). */\nconst PAGE = 25;\n/** Consensus: a block's transaction count × 4 is at most `MAX_BLOCK_WEIGHT` (4,000,000). */\nconst MAX_BLOCK_TXS = 1_000_000;\n/** No height is below 0 or beyond what a server parses: such a height is never sent. */\nconst MAX_HEIGHT = BigInt(Number.MAX_SAFE_INTEGER);\nconst outOfRange = (height: bigint): boolean => height < 0n || height > MAX_HEIGHT;\n\nconst undecided = (reason: string): ProviderError =>\n  new ProviderError('PROVIDER_UNAVAILABLE', reason);\n\n/** Two quorum reads that cannot both hold decide nothing (retryable). */\nconst contradiction = (reason: string): ProviderError =>\n  new ProviderError('PROVIDER_INCONSISTENT', reason, { retryable: true });\n\nconst stale = (): ProviderError =>\n  contradiction('the including block is no longer the block at its height');\n\n/**\n * A block hash read under the proof quorum is compared as `parseHash` reads it, so two\n * honest endpoints that differ only by whitespace agree, and the key is exactly the value\n * the verdict uses. Compared as raw text, one endpoint's trailing newline would split the\n * quorum forever.\n */\nconst HASH_PROOF = { ...PROOF, quorumKey: parseHash };\n\n/** A transaction view as the proof quorum compares it: its txid, and its block and height. */\nconst txViewKey = (answer: unknown): string => {\n  const t = parseTx(answer);\n  return t.status.confirmed\n    ? `${t.txid}@${t.status.blockHash}:${t.status.blockHeight}`\n    : `${t.txid}:unconfirmed`;\n};\n\n/**\n * The reads a proof attests under the proof quorum, each fact at its own height. The\n * proof source and the builder share them: the builder's proof-tagged reads are this\n * module's, never a copy.\n */\nexport function attestedReads(ctx: UtxoContext, signal?: AbortSignal) {\n  const { esplora } = ctx;\n  /** \"I hold a block at `height`\" (monotone in the head, so endpoints further ahead agree). */\n  const holds = async (height: bigint): Promise<boolean> => {\n    const head = await esplora.tipHeight({\n      ...withSignal(PROOF, signal),\n      quorumKey: (answer) => parseHeight(answer) >= height,\n    });\n    return head >= height;\n  };\n  /** The hash of the block at `height` on the proof endpoints' chain. */\n  const hashAt = (height: bigint): Promise<string | null> =>\n    esplora.blockHashAt(height, withSignal(HASH_PROOF, signal));\n  /** The quorum's hash at `height` must be `hash`; otherwise the answer was stale. */\n  const assertCanonical = async (height: bigint, hash: string): Promise<void> => {\n    if ((await hashAt(height)) !== hash) throw stale();\n  };\n  /** A transaction and the block it is in, as the proof endpoints agree on it. */\n  const txView = (txid: string): Promise<EsploraTx | null> =>\n    esplora.tx(txid, { ...withSignal(PROOF, signal), quorumKey: txViewKey });\n  return { holds, hashAt, assertCanonical, txView };\n}\n\n/** How many parents `assertConfirmed` reads at once, and keeps once final. */\nconst PARENT_READS = 4;\nconst FINAL_PARENTS = 10_000;\nconst finalParents = new WeakMap<EsploraClient, Map<string, true>>();\n\nconst notConfirmed = (): ProviderError =>\n  new ProviderError(\n    'PROVIDER_UNAVAILABLE',\n    \"an input's previous transaction is not in a block the proof endpoints hold yet\",\n  );\n\n/**\n * Each of `txids` (the previous transactions of the inputs a build adds) is in a\n * block, attested under the proof quorum at its own height: the proof endpoints agree on the\n * transaction and its block, all hold a block `confirmations − 1` above it, and have that\n * block at that height. Its bytes authenticate themselves, but only this proves a\n * chain holds it: an indexer's invented transaction, or one a reorg took out, would stall an\n * Attempt for good, since nothing would ever spend its outpoint. Anything short of that is a\n * retryable `PROVIDER_UNAVAILABLE` (a stale view `PROVIDER_INCONSISTENT`), and every read\n * decides nothing on failure. A parent found final is not read again.\n */\nexport async function assertConfirmed(\n  ctx: UtxoContext,\n  txids: readonly string[],\n  confirmations: number,\n  signal?: AbortSignal,\n): Promise<void> {\n  let final = finalParents.get(ctx.esplora);\n  if (!final) {\n    final = new Map();\n    finalParents.set(ctx.esplora, final);\n  }\n  const known = final;\n  const pending = [...new Set(txids)].filter((txid) => !known.has(txid));\n  if (pending.length === 0) return;\n  await proofRead(async () => {\n    const reads = attestedReads(ctx, signal);\n    const blocks = new Map<string, bigint>();\n    let top = 0n;\n    await forEachBounded(pending, PARENT_READS, async (txid) => {\n      const tx = await reads.txView(txid);\n      if (!tx?.status.confirmed) throw notConfirmed();\n      const height = tx.status.blockHeight as bigint;\n      blocks.set(tx.status.blockHash as string, height);\n      if (height > top) top = height;\n    });\n    // Monotone: the proof endpoints hold `top + confirmations − 1` only if they hold every\n    // lower height, so one read attests every parent's depth.\n    if (!(await reads.holds(top + BigInt(Math.max(1, confirmations)) - 1n))) {\n      throw notConfirmed();\n    }\n    for (const [hash, height] of blocks) await reads.assertCanonical(height, hash);\n    if (await reads.holds(top + BigInt(ctx.config.confirmations) - 1n)) {\n      for (const txid of pending) {\n        known.set(txid, true);\n        if (known.size > FINAL_PARENTS) known.delete(known.keys().next().value as string);\n      }\n    }\n  });\n}\n\nexport function proofSource(ctx: UtxoContext): ProofSource {\n  const { esplora, config } = ctx;\n  const depth = BigInt(config.confirmations) - 1n;\n  const { holds, hashAt, assertCanonical, txView } = attestedReads(ctx);\n\n  /** The transaction that spent `input` in a final, canonical block (quorum-attested). */\n  const finalSpender = async (input: {\n    txid: string;\n    vout: number;\n  }): Promise<{ txid: string; height: bigint; hash: string } | undefined> => {\n    const spend = await esplora.outspend(input.txid, input.vout, {\n      ...PROOF,\n      quorumKey: (answer) => {\n        const s = parseOutspend(answer);\n        return s.spent && s.status?.confirmed\n          ? `${s.txid}@${s.status.blockHash}:${s.status.blockHeight}`\n          : 'not-in-a-block';\n      },\n    });\n    const status = spend.status;\n    if (!spend.spent || spend.txid === undefined || !status?.confirmed) return undefined;\n    const height = status.blockHeight as bigint;\n    const hash = status.blockHash as string;\n    if (!(await holds(height + depth))) return undefined;\n    await assertCanonical(height, hash);\n    return { txid: spend.txid, height, hash };\n  };\n\n  const inputsOf = (ordering: OrderingData): { txid: string; vout: number }[] =>\n    ordering.kind === 'inputs' ? ordering.inputs.map(parseOutpoint) : [];\n\n  const source: ProofSource = {\n    async finalizedHead() {\n      const anchor = (await esplora.tipHeight(MONITOR)) - PEER_SKEW;\n      if (anchor < 0n || !(await holds(anchor))) {\n        throw undecided('the proof endpoints have not reached the head');\n      }\n      const final = anchor - depth;\n      const height = final < 0n ? 0n : final;\n      const hash = await hashAt(height);\n      if (hash === null)\n        throw undecided('the final block is not visible to the proof endpoints');\n      return { height, hash };\n    },\n\n    async includedFinal(ref: AttemptRef, ordering: OrderingData, from: string) {\n      if (!isHash(ref.id)) throw undecided('malformed transaction id');\n      const tx = await txView(ref.id);\n      if (tx?.status.confirmed) {\n        const height = tx.status.blockHeight as bigint;\n        const hash = tx.status.blockHash as string;\n        if (await holds(height + depth)) {\n          await assertCanonical(height, hash);\n          // A transaction in a block has executed; its txid commits to its outputs.\n          return {\n            included: true,\n            success: true,\n            blockHeight: height,\n            blockHash: hash,\n            txHash: tx.txid,\n          };\n        }\n      }\n      // Unknown, in a mempool, or not yet final: only a final spender of one of our inputs\n      // decides. Our own txid there means the views are inconsistent (decide nothing); a\n      // malleated copy of ours is our payment; any other transaction proves ours dead,\n      // unless the quorum also puts ours in a block (the views contradict each other).\n      for (const input of inputsOf(ordering)) {\n        const spender = await finalSpender(input);\n        if (spender === undefined) continue;\n        if (spender.txid === ref.id) {\n          throw undecided('the spend and the transaction views disagree');\n        }\n        if (await isOwnCopy(ctx, ref.id, from, spender.txid, PROOF)) {\n          return {\n            included: true,\n            success: true,\n            blockHeight: spender.height,\n            blockHash: spender.hash,\n            txHash: spender.txid,\n          };\n        }\n        if (tx?.status.confirmed) {\n          throw contradiction(\n            'the transaction is in a block while another spend of its input is final',\n          );\n        }\n        return { included: false };\n      }\n      throw undecided(\n        tx\n          ? 'the transaction is not final yet'\n          : 'the indexer does not know this transaction yet',\n      );\n    },\n\n    async slotConsumed(ordering, _from, level: FinalityLevel) {\n      for (const input of inputsOf(ordering)) {\n        if (level === 'latest') {\n          if ((await esplora.outspend(input.txid, input.vout, MONITOR)).spent)\n            return true;\n        } else if ((await finalSpender(input)) !== undefined) {\n          return true;\n        }\n      }\n      return false;\n    },\n\n    expired: async () => false,\n\n    async blockHash(height, level) {\n      if (outOfRange(height)) return null;\n      if (level === 'finalized' && !(await holds(height + depth))) return null;\n      return hashAt(height);\n    },\n  };\n\n  // Every read of every proof decides nothing on \"not available here\".\n  return {\n    finalizedHead: () => proofRead(() => source.finalizedHead()),\n    includedFinal: (ref, ordering, from) =>\n      proofRead(() => source.includedFinal(ref, ordering, from)),\n    slotConsumed: (ordering, from, level) =>\n      proofRead(() => source.slotConsumed(ordering, from, level)),\n    expired: (ordering) => source.expired(ordering),\n    blockHash: (height, level) => proofRead(() => source.blockHash(height, level)),\n  };\n}\n\nexport function blockSource(ctx: UtxoContext): BlockSource {\n  const { esplora, config } = ctx;\n\n  /** The output scripts of the watched addresses; `undefined` means no filter. */\n  const scriptsOf = (addresses: readonly string[] | undefined) => {\n    if (addresses === undefined || addresses.length === 0) return undefined;\n    const scripts = new Set<string>();\n    for (const address of addresses) {\n      try {\n        scripts.add(toHex(decodeAddress(address, config.address).script));\n      } catch {\n        // Not an address of this network: it matches nothing.\n      }\n    }\n    return scripts;\n  };\n\n  return {\n    async header(height): Promise<DriverBlock | null> {\n      if (outOfRange(height)) return null;\n      const hash = await esplora.blockHashAt(height, MONITOR);\n      if (!hash) return null;\n      const block = await esplora.block(hash, MONITOR);\n      if (!block) return null;\n      // The block at `height` must say it is at `height`.\n      if (block.height !== height) {\n        throw contradiction(`block ${height} changed while reading`);\n      }\n      return {\n        height: block.height,\n        hash: block.hash,\n        parentHash: block.parentHash,\n        timestamp: block.timestamp,\n      };\n    },\n\n    async transactions(block, filter) {\n      const inconsistent = () =>\n        contradiction(`block ${block.height} changed while scanning`);\n      const meta = await esplora.block(block.hash, MONITOR);\n      if (!meta || meta.height !== block.height) throw inconsistent();\n      // Every block has a coinbase; none holds more than consensus allows. Bounded work.\n      if (meta.txCount < 1 || meta.txCount > MAX_BLOCK_TXS) {\n        throw malformed('block.tx_count');\n      }\n      // `filter.assets` is a hint: a list without the native asset wants tokens only, and a\n      // Bitcoin block has none, so nothing is paged.\n      if (filter?.assets?.length && !filter.assets.includes('native')) return [];\n      const txs: EsploraTx[] = [];\n      const seen = new Set<string>();\n      for (let start = 0; start < meta.txCount; start += PAGE) {\n        let page: EsploraTx[];\n        try {\n          page = await esplora.blockTxs(block.hash, start, MONITOR);\n        } catch (error) {\n          // A backend that does not have the block (lagging, load-balanced) decides nothing.\n          if (isNotFound(error)) throw inconsistent();\n          throw error;\n        }\n        // Each page holds exactly what the count leaves for it, and no txid twice.\n        if (page.length !== Math.min(PAGE, meta.txCount - start)) {\n          throw malformed('block txs page');\n        }\n        for (const tx of page) {\n          if (seen.has(tx.txid)) throw malformed('block txs page');\n          seen.add(tx.txid);\n          const { status } = tx;\n          if (\n            !status.confirmed ||\n            status.blockHash !== block.hash ||\n            status.blockHeight !== block.height\n          ) {\n            throw inconsistent();\n          }\n          txs.push(tx);\n        }\n      }\n      // Checked after the pages, so a reorg while paging is caught.\n      if ((await esplora.blockHashAt(block.height, MONITOR)) !== block.hash)\n        throw inconsistent();\n      const wanted = scriptsOf(filter?.addresses);\n      const touches = (tx: EsploraTx) =>\n        wanted === undefined ||\n        tx.vout.some((output) => wanted.has(output.script)) ||\n        tx.vin.some((input) => input.prevout && wanted.has(input.prevout.script));\n      return txs.filter(touches).map((tx) => decodeTransaction(tx, config.address));\n    },\n  };\n}\n"]}

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

@@ -0,0 +1,59 @@
+/** Bitcoin Core's `MAX_BLOCK_SERIALIZED_SIZE`: no transaction's bytes are more. */
+export declare const MAX_TX_BYTES = 4000000;
+/**
+ * Consensus: a transaction's weight (4 × its size without witness data, at least) is at most
+ * `MAX_BLOCK_WEIGHT` (4,000,000), so a transaction a chain holds has at most 1,000,000 bytes
+ * without its witness.
+ */
+export declare const MAX_STRIPPED_BYTES = 1000000;
+export interface ParsedInput {
+    /** The previous txid, in display order (the reverse of the serialized hash). */
+    readonly txid: string;
+    /** The previous transaction's hash as serialized (internal byte order): a view. */
+    readonly hash: Uint8Array;
+    readonly vout: number;
+    readonly script: Uint8Array;
+    readonly sequence: number;
+    readonly witness: readonly Uint8Array[];
+}
+export interface ParsedOutput {
+    /** As bitcoind reads it: a signed 64-bit integer. */
+    readonly value: bigint;
+    readonly script: Uint8Array;
+}
+export interface ParsedTx {
+    readonly txid: string;
+    readonly version: number;
+    readonly locktime: number;
+    readonly inputs: readonly ParsedInput[];
+    readonly outputs: readonly ParsedOutput[];
+    readonly hasWitness: boolean;
+    /** The size without witness data (bitcoind's `TX_NO_WITNESS` serialization). */
+    readonly strippedSize: number;
+    /** The output list as serialized (its count, then each output): a view. */
+    readonly outputBytes: Uint8Array;
+    /** The serialization without witness data (BIP174 `non_witness_utxo`). */
+    stripped(): Uint8Array;
+}
+export interface ReadOptions {
+    /**
+     * The most bytes without witness data: `MAX_STRIPPED_BYTES` (the default) for data a chain
+     * holds; the broadcaster reads what it sent with `MAX_TX_BYTES`, so every size bitcoind
+     * decodes is read (bitcoind refuses a larger one later, as `bad-txns-oversize`).
+     */
+    readonly maxStripped?: number;
+}
+/** The txid of a serialization without witness data, given as consecutive stretches. */
+export declare const txidOfParts: (parts: readonly Uint8Array[]) => string;
+/** A little-endian 32-bit field, as bitcoind writes it. */
+export declare function writeU32(n: number): Uint8Array;
+/** A CompactSize, as bitcoind writes it (at most `MAX_SIZE` here). */
+export declare function writeSize(n: number): Uint8Array;
+/** Transaction bytes, read in one pass; `undefined` when bitcoind would not decode them. */
+export declare function readTx(bytes: Uint8Array, options?: ReadOptions): ParsedTx | undefined;
+/**
+ * Transaction hex (either case, no prefix), capped at `MAX_TX_BYTES` before it is
+ * decoded, then read by `readTx`. Node's hex decoder is native and linear, and stops at
+ * the first pair that is not hex, so a short result means the text was not plain hex.
+ */
+export declare function readTxHex(hex: string, options?: ReadOptions): ParsedTx | undefined;