@did-btcr2/method 0.37.0 → 0.39.0

package/src/core/beacon/beacon.ts

@@ -7,13 +7,10 @@ import { Address, OutScript, p2pkh, p2tr, p2wpkh, Script, SigHash, Transaction }
 import type { BeaconProcessResult } from '../resolver.js';
 import type { SidecarData } from '../types.js';
 import { BeaconError } from './error.js';
-import { StaticFeeEstimator } from './fee-estimator.js';
+import { DEFAULT_FEE_ESTIMATOR } from './fee-estimator.js';
 import type { FeeEstimator } from './fee-estimator.js';
 import type { BeaconService, BeaconSignal } from './interfaces.js';
 
-/** Default fee estimator used when none is supplied. ~5 sat/vB static rate. */
-const DEFAULT_FEE_ESTIMATOR: FeeEstimator = new StaticFeeEstimator(5);
-
 /**
  * Singleton beacon script kinds. Per the did:btcr2 spec, deterministic DID documents
  * include three beacon services: P2PKH, P2WPKH, and P2TR (taproot key-path), all
@@ -51,6 +48,54 @@ export const SINGLETON_BEACON_TX_VSIZE: Readonly<Record<SingletonScriptKind, num
   p2tr   : P2TR_BEACON_TX_VSIZE,
 };
 
+/**
+ * Serialized size (vbytes) of a single change output, by script kind:
+ * 8 (value) + 1 (scriptPubKey length) + scriptPubKey bytes. P2PKH 25, P2WPKH 22,
+ * P2TR 34. These are non-witness bytes, so each contributes its full byte count to
+ * the transaction vsize. The {@link SINGLETON_BEACON_TX_VSIZE} constants bake in a
+ * same-kind change output; {@link beaconTxVsize} uses these deltas to re-size the
+ * fee when a caller routes change to an address of a different kind (ADR 044).
+ */
+export const CHANGE_OUTPUT_VBYTES: Readonly<Record<SingletonScriptKind, number>> = {
+  p2pkh  : 34,
+  p2wpkh : 31,
+  p2tr   : 43,
+};
+
+/**
+ * Dust threshold (sats) below which a change output is not worth creating, by script
+ * kind (the standard Bitcoin Core dust relay thresholds at the default 3 sat/vB dust
+ * rate). When the change after fees falls below this, the builders omit the change
+ * output and let the remainder fall into the fee rather than emit an unspendable,
+ * relay-rejected dust output (ADR 044).
+ */
+export const DUST_LIMIT_SATS: Readonly<Record<SingletonScriptKind, number>> = {
+  p2pkh  : 546,
+  p2wpkh : 294,
+  p2tr   : 330,
+};
+
+/**
+ * vsize (vbytes) for a beacon transaction that spends one input of `beaconKind`
+ * and returns change to an output of `changeKind`, plus the OP_RETURN(32) signal.
+ *
+ * When `changeKind === beaconKind` (the default, change to the beacon address) this
+ * returns the per-kind {@link SINGLETON_BEACON_TX_VSIZE} constant unchanged, so the
+ * default path and the constants' lock-in tests are byte-identical. A differing
+ * `changeKind` swaps the assumed same-kind change output for the actual one, keeping
+ * the result a valid upper bound. The aggregation key-path spend is the
+ * `beaconKind: 'p2tr'` case (its input is always the cohort's P2TR key path; only the
+ * change output varies), the analytical sizing ADR 045 calls for, computed without a
+ * secret.
+ */
+export function beaconTxVsize(
+  beaconKind: SingletonScriptKind,
+  changeKind: SingletonScriptKind,
+): number {
+  const base = SINGLETON_BEACON_TX_VSIZE[beaconKind] - CHANGE_OUTPUT_VBYTES[beaconKind];
+  return base + CHANGE_OUTPUT_VBYTES[changeKind];
+}
+
 /**
  * Detect the singleton script kind of a Bitcoin address (P2PKH / P2WPKH / P2TR).
  * The deterministic-DID document emits all three kinds; the broadcast path needs
@@ -88,12 +133,56 @@ export function deriveSingletonAddress(
   return p2tr(pubkey.slice(1, 33), undefined, network).address!;
 }
 
+/**
+ * Resolve the change-output recipient for a beacon transaction. Returns the beacon
+ * address when no change address is supplied (preserving the prior behavior of
+ * returning change to the spent address), otherwise validates the caller-supplied
+ * address against the network and returns it. Validating here fails fast rather than
+ * burning a real UTXO on a transaction that breaks at broadcast (ADR 044).
+ */
+export function resolveChangeAddress(
+  beaconAddress: string,
+  network: BTCNetwork,
+  changeAddress?: string,
+): string {
+  if(!changeAddress || changeAddress === beaconAddress) return beaconAddress;
+  try {
+    Address(network).decode(changeAddress);
+  } catch {
+    throw new BeaconError(
+      `Invalid change address "${changeAddress}" for network "${network}".`,
+      'INVALID_CHANGE_ADDRESS',
+      { changeAddress, network }
+    );
+  }
+  return changeAddress;
+}
+
+/**
+ * Detect the change output's script kind for fee sizing. A change address that is not
+ * one of the three singleton kinds (for example P2SH or P2WSH) is sized as P2TR, the
+ * largest standard change output, so the estimated fee stays a valid upper bound.
+ */
+function changeOutputKind(changeAddress: string, network: BTCNetwork): SingletonScriptKind {
+  try {
+    return detectSingletonScriptKind(changeAddress, network);
+  } catch {
+    return 'p2tr';
+  }
+}
+
 /**
  * Options accepted by {@link SinglePartyBeacon.buildSignAndBroadcast} and related helpers.
  */
 export interface BroadcastOptions {
   /** Fee estimator for computing the transaction fee. Defaults to {@link DEFAULT_FEE_ESTIMATOR}. */
   feeEstimator?: FeeEstimator;
+  /**
+   * Address to send change to. Defaults to the beacon address (reuses the spent
+   * address, the prior behavior). Supply a fresh address the controller owns to
+   * stop linking the beacon's announcements into one on-chain chain (ADR 044).
+   */
+  changeAddress?: string;
 }
 
 /**
@@ -107,8 +196,10 @@ export interface BeaconTxPlan {
   prevOutScripts: Uint8Array[];
   /** Amounts (sats) of the consumed previous outputs. */
   prevOutValues: bigint[];
-  /** Address change was sent back to (same as the beacon address). */
+  /** The beacon address this tx spends from. */
   beaconAddress: string;
+  /** Address the change output was sent to (the beacon address unless a change address was supplied). */
+  changeAddress: string;
   /** The UTXO this tx consumes. */
   utxo: AddressUtxo;
   /** The fee (sats) already deducted from the change output. */
@@ -188,9 +279,17 @@ export async function buildAggregationBeaconTx(opts: {
   network: BTCNetwork;
   /** Optional fee estimator (defaults to 5 sat/vB). */
   feeEstimator?: FeeEstimator;
+  /**
+   * Address to send change to. Defaults to the beacon (cohort) address. Supply the
+   * funder's address (an operator-funded cohort's funding wallet) to stop reusing the
+   * cohort address for change (ADR 044). Change ownership is the funder's call, which
+   * the cohort-condition model leaves to the caller (ADR 039).
+   */
+  changeAddress?: string;
 }): Promise<BeaconTxPlan> {
   const feeEstimator = opts.feeEstimator ?? DEFAULT_FEE_ESTIMATOR;
   const { utxo, prevTxBytes } = await fetchSpendableUtxo(opts.beaconAddress, opts.bitcoin);
+  const changeAddress = resolveChangeAddress(opts.beaconAddress, opts.network, opts.changeAddress);
 
   // The funded beacon output is a Taproot script-tree output: key path is the
   // MuSig2 aggregate, script path is the k-of-n fallback + CSV recovery leaves
@@ -200,8 +299,11 @@ export async function buildAggregationBeaconTx(opts: {
   // key-path sighash and the fallback script-path sighash.
   const witnessScript = OutScript.encode(Address(opts.network).decode(opts.beaconAddress));
 
-  // Fee cannot be probe-measured (no secret key for MuSig2 round). Use fixed P2TR vsize.
-  const feeSats = await feeEstimator.estimateFee(P2TR_BEACON_TX_VSIZE);
+  // The fee cannot be probe-measured (no secret key until the downstream MuSig2
+  // round), so size it analytically. The input is the cohort's P2TR key path; only
+  // the change output's kind varies, so the vsize follows the change address (ADR 045).
+  const changeKind = changeOutputKind(changeAddress, opts.network);
+  const feeSats = await feeEstimator.estimateFee(beaconTxVsize('p2tr', changeKind));
   if(BigInt(utxo.value) <= feeSats) {
     throw new BeaconError(
       `UTXO value (${utxo.value}) insufficient to cover fee (${feeSats}).`,
@@ -221,7 +323,12 @@ export async function buildAggregationBeaconTx(opts: {
     witnessUtxo    : { amount: BigInt(utxo.value), script: witnessScript },
     tapInternalKey : opts.internalPubkey,
   });
-  tx.addOutputAddress(opts.beaconAddress, BigInt(utxo.value) - feeSats, opts.network);
+  // Change first (omitted when it would be dust, sweeping the remainder into the
+  // fee), then the OP_RETURN signal, which the spec requires to be the last output.
+  const changeValue = BigInt(utxo.value) - feeSats;
+  if(changeValue >= BigInt(DUST_LIMIT_SATS[changeKind])) {
+    tx.addOutputAddress(changeAddress, changeValue, opts.network);
+  }
   tx.addOutput({ script: opReturnScript(opts.signalBytes), amount: 0n });
 
   return {
@@ -229,6 +336,7 @@ export async function buildAggregationBeaconTx(opts: {
     prevOutScripts : [witnessScript],
     prevOutValues  : [BigInt(utxo.value)],
     beaconAddress  : opts.beaconAddress,
+    changeAddress,
     utxo,
     feeSats,
     scriptKind     : 'p2tr',
@@ -404,6 +512,7 @@ export abstract class SinglePartyBeacon {
     const { utxo, prevTxBytes } = await fetchSpendableUtxo(beaconAddress, bitcoin);
     const plan = await this.buildSinglePartyTx({
       signalBytes, beaconAddress, utxo, prevTxBytes, signer, bitcoin, feeEstimator,
+      changeAddress : options?.changeAddress,
     });
     const signedHex = await this.signSinglePartyTx(plan, signer);
     return this.broadcastRawTx(bitcoin, signedHex);
@@ -416,8 +525,9 @@ export abstract class SinglePartyBeacon {
    * the input accordingly. Validates that the signer's pubkey produces the beacon
    * address under that script kind: without this check, a misconfigured caller
    * would burn a real UTXO on a tx that fails at broadcast. Fees are computed from
-   * the per-kind {@link SINGLETON_BEACON_TX_VSIZE} constant, avoiding any probe-sign
-   * round-trip.
+   * the per-kind {@link SINGLETON_BEACON_TX_VSIZE} constant (via {@link beaconTxVsize}),
+   * avoiding any probe-sign round-trip; a change address of a different kind re-sizes
+   * the fee by the change output's size delta so it stays a valid upper bound.
    */
   protected async buildSinglePartyTx(opts: {
     signalBytes: Uint8Array;
@@ -427,10 +537,12 @@ export abstract class SinglePartyBeacon {
     signer: Signer;
     bitcoin: BitcoinConnection;
     feeEstimator: FeeEstimator;
+    changeAddress?: string;
   }): Promise<BeaconTxPlan> {
     const network = opts.bitcoin.data;
     const pubkey = opts.signer.publicKey;
     const kind = detectSingletonScriptKind(opts.beaconAddress, network);
+    const changeAddress = resolveChangeAddress(opts.beaconAddress, network, opts.changeAddress);
 
     const derivedAddress = deriveSingletonAddress(kind, pubkey, network);
     if(derivedAddress !== opts.beaconAddress) {
@@ -441,7 +553,8 @@ export abstract class SinglePartyBeacon {
       );
     }
 
-    const feeSats = await opts.feeEstimator.estimateFee(SINGLETON_BEACON_TX_VSIZE[kind]);
+    const changeKind = changeOutputKind(changeAddress, network);
+    const feeSats = await opts.feeEstimator.estimateFee(beaconTxVsize(kind, changeKind));
     const amount = BigInt(opts.utxo.value);
     if(amount <= feeSats) {
       throw new BeaconError(
@@ -487,7 +600,12 @@ export abstract class SinglePartyBeacon {
       });
     }
 
-    tx.addOutputAddress(opts.beaconAddress, amount - feeSats, network);
+    // Change first (omitted when it would be dust, sweeping the remainder into the
+    // fee), then the OP_RETURN signal, which the spec requires to be the last output.
+    const changeValue = amount - feeSats;
+    if(changeValue >= BigInt(DUST_LIMIT_SATS[changeKind])) {
+      tx.addOutputAddress(changeAddress, changeValue, network);
+    }
     tx.addOutput({ script: opReturnScript(opts.signalBytes), amount: 0n });
 
     return {
@@ -495,6 +613,7 @@ export abstract class SinglePartyBeacon {
       prevOutScripts : [prevOutScript],
       prevOutValues  : [amount],
       beaconAddress  : opts.beaconAddress,
+      changeAddress,
       utxo           : opts.utxo,
       feeSats,
       scriptKind     : kind,

package/src/core/beacon/fee-estimator.ts

@@ -1,52 +1,18 @@
-/**
- * Estimates the fee (in satoshis) for a transaction of a given virtual size.
- *
- * Beacons delegate fee calculation to a `FeeEstimator` so that callers can
- * plug in different strategies: static fee rates for tests/regtest, mempool
- * APIs for mainnet, Bitcoin Core `estimatesmartfee` RPC for full-node setups,
- * etc.
- *
- * Implementations return the **total fee in satoshis** for a transaction of
- * the given virtual size (`vsize`). Callers pass the vsize; the estimator
- * decides the fee rate and computes the total.
- */
-export interface FeeEstimator {
-  /**
-   * Estimate the total fee in satoshis for a transaction of the given vsize.
-   * @param vsize Transaction virtual size in vbytes.
-   * @returns Total fee in satoshis.
-   */
-  estimateFee(vsize: number): Promise<bigint>;
-}
+// The FeeEstimator contract and the StaticFeeEstimator implementation live in
+// @did-btcr2/bitcoin, the natural home for a sat/vB fee primitive shared by the
+// single-party and aggregated beacon broadcast paths. They are re-exported here so
+// the @did-btcr2/method public surface is unchanged.
+import { StaticFeeEstimator } from '@did-btcr2/bitcoin';
+import type { FeeEstimator } from '@did-btcr2/bitcoin';
+
+export { StaticFeeEstimator };
+export type { FeeEstimator };
 
 /**
- * Fee estimator that returns a fixed fee rate regardless of network conditions.
- *
- * Suitable for:
- * - Tests (deterministic outputs)
- * - Regtest (no real fee market)
- * - Environments where a fee rate is supplied out-of-band
- *
- * For mainnet production use, prefer a dynamic estimator that queries current
- * network conditions (mempool APIs, Bitcoin Core RPC).
+ * Default fee estimator used when a caller supplies none: a static 5 sat/vB rate.
+ * Suitable for tests and regtest. Production callers should inject a dynamic
+ * estimator (a mempool API, or Bitcoin Core `estimatesmartfee`) at the point the
+ * beacon transaction is built (single-party broadcast options, or the aggregation
+ * service runner's fee estimator).
  */
-export class StaticFeeEstimator implements FeeEstimator {
-  readonly satsPerVbyte: number;
-
-  /**
-   * @param satsPerVbyte Fee rate in satoshis per virtual byte. Default: 5 sat/vB.
-   */
-  constructor(satsPerVbyte: number = 5) {
-    if(satsPerVbyte < 0 || !Number.isFinite(satsPerVbyte)) {
-      throw new Error(`Invalid satsPerVbyte: ${satsPerVbyte}`);
-    }
-    this.satsPerVbyte = satsPerVbyte;
-  }
-
-  async estimateFee(vsize: number): Promise<bigint> {
-    if(vsize < 0 || !Number.isFinite(vsize)) {
-      throw new Error(`Invalid vsize: ${vsize}`);
-    }
-    return BigInt(Math.ceil(vsize * this.satsPerVbyte));
-  }
-}
+export const DEFAULT_FEE_ESTIMATOR: FeeEstimator = new StaticFeeEstimator(5);

package/src/core/did-sender-resolver.ts

@@ -0,0 +1,25 @@
+import { CompressedSecp256k1PublicKey } from '@did-btcr2/keypair';
+import { Identifier } from './identifier.js';
+
+/**
+ * Resolve a did:btcr2 sender's communication public key from its DID, for the
+ * aggregation HTTP transport's `resolveSenderPk` option: a KEY identifier decodes to
+ * its genesis public key. The aggregation transport is DID-method-agnostic and does
+ * not name `Identifier`; method supplies this resolver when it wires the transport so
+ * a sender that is not a pre-registered peer can still be authenticated from its DID.
+ *
+ * @param did The sender's DID.
+ * @returns The sender's compressed public key, or `undefined` when the DID is not a
+ *   decodable did:btcr2 KEY identifier (resolution then falls back to registered peers).
+ */
+export function resolveBtcr2SenderPk(did: string): CompressedSecp256k1PublicKey | undefined {
+  try {
+    const components = Identifier.decode(did);
+    if(components.idType === 'KEY') {
+      return new CompressedSecp256k1PublicKey(components.genesisBytes);
+    }
+  } catch {
+    // Not a decodable did:btcr2 KEY identifier.
+  }
+  return undefined;
+}

package/src/index.ts

@@ -1,20 +1,5 @@
-// Aggregation
-export * from './core/aggregation/service.js';
-export * from './core/aggregation/participant.js';
-export * from './core/aggregation/signer.js';
-export * from './core/aggregation/conditions.js';
-export * from './core/aggregation/recovery-policy.js';
-export * from './core/aggregation/recovery-spend.js';
-export * from './core/aggregation/fallback-spend.js';
-export * from './core/aggregation/cohort.js';
-export * from './core/aggregation/signing-session.js';
-export * from './core/aggregation/phases.js';
-export * from './core/aggregation/errors.js';
-export * from './core/aggregation/beacon-strategy.js';
-export * from './core/aggregation/logger.js';
-export * from './core/aggregation/messages/index.js';
-export * from './core/aggregation/transport/index.js';
-export * from './core/aggregation/runner/index.js';
+// Aggregation (extracted to @did-btcr2/aggregation; re-exported here for backward compatibility)
+export * from '@did-btcr2/aggregation';
 
 // Beacons
 export * from './core/beacon/beacon.js';
@@ -29,6 +14,7 @@ export * from './core/beacon/smt-beacon.js';
 export * from './core/beacon/utils.js';
 
 // Core
+export * from './core/did-sender-resolver.js';
 export * from './core/identifier.js';
 export * from './core/interfaces.js';
 export * from './core/resolver.js';

package/dist/esm/core/aggregation/beacon-strategy.js

@@ -1,76 +0,0 @@
-import { canonicalize } from '@did-btcr2/common';
-import { base64UrlToHash, blockHash, didToIndex, hashToBase64Url, verifySerializedProof } from '@did-btcr2/smt';
-const CAS_STRATEGY = {
-    type: 'CASBeacon',
-    buildAggregatedData(cohort) {
-        cohort.buildCASAnnouncement();
-    },
-    getDistributePayload(cohort) {
-        return { casAnnouncement: cohort.casAnnouncement };
-    },
-    validateParticipantView({ participantDid, included, expectedHash, body }) {
-        const casAnnouncement = body.casAnnouncement;
-        if (!casAnnouncement)
-            return { matches: false };
-        if (!included) {
-            // Cooperative non-inclusion: the decliner must be ABSENT from the map.
-            return { matches: !(participantDid in casAnnouncement), casAnnouncement };
-        }
-        return {
-            matches: casAnnouncement[participantDid] === expectedHash,
-            casAnnouncement,
-        };
-    },
-};
-const SMT_STRATEGY = {
-    type: 'SMTBeacon',
-    buildAggregatedData(cohort) {
-        cohort.buildSMTTree();
-    },
-    getDistributePayload(cohort, participantDid) {
-        const proof = cohort.smtProofs?.get(participantDid);
-        return { smtProof: proof };
-    },
-    validateParticipantView({ participantDid, included, submittedUpdate, body }) {
-        const smtProof = body.smtProof;
-        const index = didToIndex(participantDid);
-        if (!included) {
-            // Cooperative non-inclusion: the proof has a nonce but no updateId by
-            // construction. The leaf is SHA-256(SHA-256(nonce)); do NOT run the
-            // inclusion-only updateId guard (a missing updateId is correct here).
-            if (!smtProof?.nonce || smtProof?.updateId)
-                return { matches: false, smtProof };
-            const candidateHash = blockHash(blockHash(base64UrlToHash(smtProof.nonce)));
-            return { matches: verifySerializedProof(smtProof, index, candidateHash), smtProof };
-        }
-        if (!smtProof?.updateId || !smtProof?.nonce || !submittedUpdate)
-            return { matches: false, smtProof };
-        // Verify updateId matches the canonicalized update hash. Proof hash fields
-        // are base64url (no padding) per the SMT Proof spec.
-        const canonicalBytes = new TextEncoder().encode(canonicalize(submittedUpdate));
-        const expectedUpdateId = hashToBase64Url(blockHash(canonicalBytes));
-        if (smtProof.updateId !== expectedUpdateId) {
-            return { matches: false, smtProof };
-        }
-        // Verify Merkle inclusion. The leaf is SHA-256(SHA-256(nonce) || SHA-256(update)).
-        const candidateHash = blockHash(blockHash(base64UrlToHash(smtProof.nonce)), base64UrlToHash(smtProof.updateId));
-        return {
-            matches: verifySerializedProof(smtProof, index, candidateHash),
-            smtProof,
-        };
-    },
-};
-/** Registered strategies keyed by `beaconType` string. */
-const STRATEGIES = new Map([
-    [CAS_STRATEGY.type, CAS_STRATEGY],
-    [SMT_STRATEGY.type, SMT_STRATEGY],
-]);
-/** Register a custom beacon strategy. Overwrites any existing entry with the same type. */
-export function registerBeaconStrategy(strategy) {
-    STRATEGIES.set(strategy.type, strategy);
-}
-/** Look up a registered beacon strategy by type, or undefined if not registered. */
-export function getBeaconStrategy(type) {
-    return STRATEGIES.get(type);
-}
-//# sourceMappingURL=beacon-strategy.js.map

package/dist/esm/core/aggregation/beacon-strategy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"beacon-strategy.js","sourceRoot":"","sources":["../../../../src/core/aggregation/beacon-strategy.ts"],"names":[],"mappings":"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"}