@cogcoin/client 0.5.14 → 0.5.15

package/README.md

@@ -1,6 +1,6 @@
 # `@cogcoin/client`
 
-`@cogcoin/client@0.5.14` is the store-backed Cogcoin client package for applications that want a local wallet, durable SQLite-backed state, and a managed Bitcoin Core integration around `@cogcoin/indexer`. It publishes the reusable client APIs, the SQLite adapter, the managed `bitcoind` integration, and the first-party `cogcoin` CLI in one package.
+`@cogcoin/client@0.5.15` is the store-backed Cogcoin client package for applications that want a local wallet, durable SQLite-backed state, and a managed Bitcoin Core integration around `@cogcoin/indexer`. It publishes the reusable client APIs, the SQLite adapter, the managed `bitcoind` integration, and the first-party `cogcoin` CLI in one package.
 
 Use Node 22 or newer.
 

package/dist/bitcoind/types.d.ts

@@ -275,6 +275,7 @@ export interface RpcPrevout {
 }
 export interface RpcVin {
     txid?: string;
+    vout?: number;
     coinbase?: string;
     prevout?: RpcPrevout;
 }
@@ -310,6 +311,11 @@ export interface RpcWalletTransaction {
     blockheight?: number;
     time?: number;
     timereceived?: number;
+    details?: Array<{
+        address?: string;
+        vout?: number;
+    }>;
+    decoded?: RpcTransaction;
 }
 export interface RpcBlock {
     hash: string;
@@ -409,6 +415,10 @@ export interface RpcListUnspentEntry {
 }
 export interface RpcDecodedPsbt {
     tx: RpcTransaction;
+    inputs?: Array<{
+        witness_utxo?: RpcVout;
+        non_witness_utxo?: RpcTransaction;
+    }>;
 }
 export interface RpcFinalizePsbtResult {
     psbt?: string;

package/dist/wallet/coin-control.d.ts

@@ -1,4 +1,4 @@
-import type { RpcListUnspentEntry, RpcLockedUnspent } from "../bitcoind/types.js";
+import type { RpcListUnspentEntry, RpcLockedUnspent, RpcWalletTransaction } from "../bitcoind/types.js";
 import { persistWalletStateUpdate } from "./descriptor-normalization.js";
 import type { WalletRuntimePaths } from "./runtime.js";
 import type { OutpointRecord, PortableWalletArchivePayloadV1, UnlockSessionStateV1, WalletStateV1 } from "./types.js";
@@ -7,6 +7,7 @@ export interface WalletCoinControlRpc {
     listUnspent(walletName: string, minConf?: number): Promise<RpcListUnspentEntry[]>;
     listLockUnspent(walletName: string): Promise<RpcLockedUnspent[]>;
     lockUnspent(walletName: string, unlock: boolean, outputs: RpcLockedUnspent[]): Promise<boolean>;
+    getTransaction?(walletName: string, txid: string): Promise<RpcWalletTransaction>;
 }
 export declare function outpointKey(outpoint: OutpointRecord): string;
 export declare function normalizeWalletStateRecord(state: WalletStateV1): WalletStateV1;

package/dist/wallet/coin-control.js

@@ -289,6 +289,64 @@ function collectPersistentPolicyLockedOutpoints(state, spendableUtxos) {
     }
     return outpoints;
 }
+function collectManagedScriptPubKeyHexes(state) {
+    const scripts = new Set();
+    const add = (scriptPubKeyHex) => {
+        if (typeof scriptPubKeyHex === "string" && scriptPubKeyHex.length > 0) {
+            scripts.add(scriptPubKeyHex);
+        }
+    };
+    add(state.funding.scriptPubKeyHex);
+    for (const identity of state.identities) {
+        add(identity.scriptPubKeyHex);
+    }
+    for (const domain of state.domains) {
+        add(domain.currentOwnerScriptPubKeyHex);
+    }
+    for (const family of state.proactiveFamilies) {
+        add(family.sourceSenderScriptPubKeyHex);
+        add(family.reservedScriptPubKeyHex);
+    }
+    add(state.miningState.currentSenderScriptPubKeyHex);
+    return scripts;
+}
+function findWalletTransactionOutputScriptPubKeyHex(transaction, vout) {
+    const decodedScriptPubKeyHex = transaction?.decoded?.vout.find((output) => output.n === vout)?.scriptPubKey?.hex;
+    return typeof decodedScriptPubKeyHex === "string" && decodedScriptPubKeyHex.length > 0
+        ? decodedScriptPubKeyHex
+        : null;
+}
+async function collectManagedInspectionUnlocks(options) {
+    if (options.rpc.getTransaction === undefined) {
+        return [];
+    }
+    const managedScripts = collectManagedScriptPubKeyHexes(options.state);
+    if (managedScripts.size === 0 || options.lockedOutpoints.length === 0) {
+        return [];
+    }
+    const transactionCache = new Map();
+    const inspectionUnlocks = [];
+    const loadTransaction = (txid) => {
+        let cached = transactionCache.get(txid);
+        if (cached === undefined) {
+            cached = options.rpc.getTransaction?.(options.walletName, txid).catch(() => null) ?? Promise.resolve(null);
+            transactionCache.set(txid, cached);
+        }
+        return cached;
+    };
+    for (const outpoint of options.lockedOutpoints) {
+        const key = outpointKey(outpoint);
+        if (options.fixedInputKeys.has(key) || options.temporarilyUnlockedKeys.has(key)) {
+            continue;
+        }
+        const transaction = await loadTransaction(outpoint.txid);
+        const scriptPubKeyHex = findWalletTransactionOutputScriptPubKeyHex(transaction, outpoint.vout);
+        if (scriptPubKeyHex !== null && managedScripts.has(scriptPubKeyHex)) {
+            inspectionUnlocks.push({ txid: outpoint.txid, vout: outpoint.vout });
+        }
+    }
+    return inspectionUnlocks;
+}
 export async function reconcilePersistentPolicyLocks(options) {
     const rawReserveOutpoints = normalizeOutpointRecordList(options.state.proactiveReserveOutpoints);
     let state = normalizeWalletStateRecord(options.state);
@@ -309,10 +367,23 @@ export async function reconcilePersistentPolicyLocks(options) {
         const key = outpointKey(outpoint);
         return lockedBeforeReserveInspectionKeys.has(key) && !fixedInputKeys.has(key);
     });
-    if (reserveInspectionUnlocks.length > 0) {
-        await options.rpc.lockUnspent(options.walletName, true, reserveInspectionUnlocks).catch(() => undefined);
+    const managedInspectionUnlocks = await collectManagedInspectionUnlocks({
+        rpc: options.rpc,
+        walletName: options.walletName,
+        state,
+        lockedOutpoints: lockedBeforeReserveInspection,
+        fixedInputKeys,
+        temporarilyUnlockedKeys,
+    });
+    const inspectionUnlockMap = new Map();
+    for (const outpoint of [...reserveInspectionUnlocks, ...managedInspectionUnlocks]) {
+        inspectionUnlockMap.set(outpointKey(outpoint), outpoint);
+    }
+    const inspectionUnlocks = [...inspectionUnlockMap.values()];
+    if (inspectionUnlocks.length > 0) {
+        await options.rpc.lockUnspent(options.walletName, true, inspectionUnlocks).catch(() => undefined);
     }
-    const spendableUtxos = reserveInspectionUnlocks.length > 0 || options.spendableUtxos === undefined
+    const spendableUtxos = inspectionUnlocks.length > 0 || options.spendableUtxos === undefined
         ? await options.rpc.listUnspent(options.walletName, 0).catch(() => [])
         : options.spendableUtxos;
     const previouslyProtectedUniverse = collectPersistentPolicyLockedOutpoints(state, spendableUtxos);

package/dist/wallet/mining/runner.d.ts

@@ -1,12 +1,12 @@
 import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import { createRpcClient } from "../../bitcoind/node.js";
 import type { ProgressOutputMode } from "../../bitcoind/types.js";
-import { type MutationSender, type WalletMutationRpcClient } from "../tx/common.js";
+import { type FixedWalletInput, type MutationSender, type WalletMutationRpcClient } from "../tx/common.js";
 import { type WalletPrompter } from "../lifecycle.js";
 import { openWalletReadContext } from "../read/index.js";
 import { type WalletRuntimePaths } from "../runtime.js";
 import { type WalletSecretProvider } from "../state/provider.js";
-import type { MiningStateRecord } from "../types.js";
+import type { MiningStateRecord, OutpointRecord, WalletStateV1 } from "../types.js";
 import type { MiningRuntimeStatusV1 } from "./types.js";
 type MiningRpcClient = WalletMutationRpcClient & {
     getBlockchainInfo(): Promise<{
@@ -64,6 +64,21 @@ type MiningRpcClient = WalletMutationRpcClient & {
     sendRawTransaction(hex: string): Promise<string>;
     saveMempool?(): Promise<null>;
 };
+interface MiningCandidate {
+    domainId: number;
+    domainName: string;
+    localIndex: number;
+    sender: MutationSender;
+    anchorOutpoint: OutpointRecord;
+    sentence: string;
+    encodedSentenceBytes: Uint8Array;
+    bip39WordIndices: number[];
+    bip39Words: readonly string[];
+    canonicalBlend: bigint;
+    referencedBlockHashDisplay: string;
+    referencedBlockHashInternal: Uint8Array;
+    targetBlockHeight: number;
+}
 interface RunnerDependencies {
     openReadContext?: typeof openWalletReadContext;
     attachService?: typeof attachOrStartManagedBitcoindService;
@@ -104,6 +119,61 @@ export interface MiningStartResult {
     started: boolean;
     snapshot: MiningRuntimeStatusV1 | null;
 }
+declare function createMiningPlan(options: {
+    state: WalletStateV1;
+    candidate: MiningCandidate;
+    conflictOutpoint: OutpointRecord;
+    allUtxos: Awaited<ReturnType<MiningRpcClient["listUnspent"]>>;
+    feeRateSatVb: number;
+}): {
+    sender: MutationSender;
+    fixedInputs: FixedWalletInput[];
+    outputs: unknown[];
+    changeAddress: string;
+    changePosition: number;
+    expectedOpReturnScriptHex: string;
+    expectedAnchorScriptHex: string;
+    expectedAnchorValueSats: bigint;
+    allowedFundingScriptPubKeyHex: string;
+    eligibleFundingOutpointKeys: Set<string>;
+    expectedConflictOutpoint: OutpointRecord;
+    feeRateSatVb: number;
+};
+export declare function createMiningPlanForTesting(options: {
+    state: WalletStateV1;
+    candidate: {
+        domainId: number;
+        domainName: string;
+        localIndex: number;
+        sender: MutationSender;
+        anchorOutpoint: OutpointRecord;
+        sentence: string;
+        encodedSentenceBytes: Uint8Array;
+        bip39WordIndices: number[];
+        bip39Words: readonly string[];
+        canonicalBlend: bigint;
+        referencedBlockHashDisplay: string;
+        referencedBlockHashInternal: Uint8Array;
+        targetBlockHeight: number;
+    };
+    conflictOutpoint: OutpointRecord;
+    allUtxos: Awaited<ReturnType<MiningRpcClient["listUnspent"]>>;
+    feeRateSatVb: number;
+}): {
+    sender: MutationSender;
+    fixedInputs: FixedWalletInput[];
+    outputs: unknown[];
+    changeAddress: string;
+    changePosition: number;
+    expectedOpReturnScriptHex: string;
+    expectedAnchorScriptHex: string;
+    expectedAnchorValueSats: bigint;
+    allowedFundingScriptPubKeyHex: string;
+    eligibleFundingOutpointKeys: Set<string>;
+    expectedConflictOutpoint: OutpointRecord;
+    feeRateSatVb: number;
+};
+export declare function validateMiningDraftForTesting(decoded: Awaited<ReturnType<MiningRpcClient["decodePsbt"]>>, funded: Awaited<ReturnType<MiningRpcClient["walletCreateFundedPsbt"]>>, plan: ReturnType<typeof createMiningPlan>): void;
 export declare function runForegroundMining(options: RunForegroundMiningOptions): Promise<void>;
 export declare function startBackgroundMining(options: StartBackgroundMiningOptions): Promise<MiningStartResult>;
 export declare function stopBackgroundMining(options: StopBackgroundMiningOptions): Promise<MiningRuntimeStatusV1 | null>;

package/dist/wallet/mining/runner.js

@@ -8,7 +8,7 @@ import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
 import { createRpcClient } from "../../bitcoind/node.js";
 import { COG_OPCODES, COG_PREFIX } from "../cogop/constants.js";
 import { extractOpReturnPayloadFromScriptHex } from "../tx/register.js";
-import { DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB, assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, buildWalletMutationTransaction, outpointKey as walletMutationOutpointKey, isAlreadyAcceptedError, isBroadcastUnknownError, reconcilePersistentPolicyLocks, saveWalletStatePreservingUnlock, } from "../tx/common.js";
+import { DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB, assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, buildWalletMutationTransaction, getDecodedInputScriptPubKeyHex, outpointKey as walletMutationOutpointKey, isAlreadyAcceptedError, isBroadcastUnknownError, reconcilePersistentPolicyLocks, saveWalletStatePreservingUnlock, } from "../tx/common.js";
 import { acquireFileLock } from "../fs/lock.js";
 import { loadOrAutoUnlockWalletState } from "../lifecycle.js";
 import { isMineableWalletDomain, openWalletReadContext, } from "../read/index.js";
@@ -610,16 +610,16 @@ function validateMiningDraft(decoded, funded, plan) {
         throw new Error("wallet_mining_missing_inputs");
     }
     assertFixedInputPrefixMatches(inputs, plan.fixedInputs, "wallet_mining_missing_inputs");
-    if (inputs[0]?.prevout?.scriptPubKey?.hex !== plan.sender.scriptPubKeyHex) {
+    if (getDecodedInputScriptPubKeyHex(decoded, 0) !== plan.sender.scriptPubKeyHex) {
         throw new Error("wallet_mining_sender_input_mismatch");
     }
-    if (inputs[1]?.prevout?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex
+    if (getDecodedInputScriptPubKeyHex(decoded, 1) !== plan.allowedFundingScriptPubKeyHex
         || inputs[1]?.txid !== plan.expectedConflictOutpoint.txid
-        || inputs[1].vout !== plan.expectedConflictOutpoint.vout) {
+        || inputs[1]?.vout !== plan.expectedConflictOutpoint.vout) {
         throw new Error("wallet_mining_conflict_input_mismatch");
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
@@ -650,6 +650,12 @@ async function buildMiningTransaction(options) {
         feeRate: options.plan.feeRateSatVb,
     });
 }
+export function createMiningPlanForTesting(options) {
+    return createMiningPlan(options);
+}
+export function validateMiningDraftForTesting(decoded, funded, plan) {
+    validateMiningDraft(decoded, funded, plan);
+}
 function resolveEligibleAnchoredRoots(context) {
     const state = context.localState.state;
     const model = context.model;

package/dist/wallet/tx/anchor.js

@@ -9,7 +9,7 @@ import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { serializeDomainAnchor, serializeDomainTransfer, validateDomainName, } from "../cogop/index.js";
 import { openWalletReadContext } from "../read/index.js";
-import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, getDecodedInputScriptPubKeyHex, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, inputMatchesOutpoint, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, findSpendableFundingInputsFromTransaction, getDecodedInputScriptPubKeyHex, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, inputMatchesOutpoint, } from "./common.js";
 import { confirmYesNo } from "./confirm.js";
 const ACTIVE_FAMILY_STATUSES = new Set([
     "draft",
@@ -551,6 +551,12 @@ function buildTx2Plan(options) {
     }
     const fundingUtxos = sortUtxos(options.allUtxos.filter((entry) => entry.scriptPubKey === options.state.funding.scriptPubKeyHex
         && isSpendableConfirmedUtxo(entry)));
+    const tx1FundingChangeInputs = findSpendableFundingInputsFromTransaction({
+        allUtxos: options.allUtxos,
+        txid: tx1Txid,
+        fundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+        minConf: 0,
+    });
     const foundingPayload = options.operation.foundingMessagePayloadHex === null
         ? undefined
         : Buffer.from(options.operation.foundingMessagePayloadHex, "hex");
@@ -562,7 +568,10 @@ function buildTx2Plan(options) {
             address: options.operation.targetIdentity.address,
         },
         changeAddress: options.state.funding.address,
-        fixedInputs: [{ txid: provisional.txid, vout: provisional.vout }],
+        fixedInputs: [
+            { txid: provisional.txid, vout: provisional.vout },
+            ...tx1FundingChangeInputs,
+        ],
         outputs: [
             { data: Buffer.from(opReturnData).toString("hex") },
             { [options.operation.targetIdentity.address]: satsToBtcNumber(BigInt(options.state.anchorValueSats)) },
@@ -590,7 +599,7 @@ function validateTx1Draft(decoded, funded, plan) {
         throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
     }
     assertFixedInputPrefixMatches(inputs, plan.fixedInputs, `${plan.errorPrefix}_sender_input_mismatch`);
-    const firstInputScriptPubKeyHex = getDecodedInputScriptPubKeyHex(inputs[0]);
+    const firstInputScriptPubKeyHex = getDecodedInputScriptPubKeyHex(decoded, 0);
     if (firstInputScriptPubKeyHex !== plan.sender.scriptPubKeyHex) {
         throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
     }
@@ -600,7 +609,7 @@ function validateTx1Draft(decoded, funded, plan) {
         }
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
@@ -644,13 +653,13 @@ function validateTx2Draft(decoded, funded, plan) {
         throw new Error(`${plan.errorPrefix}_provisional_input_mismatch`);
     }
     assertFixedInputPrefixMatches(inputs, plan.fixedInputs, `${plan.errorPrefix}_provisional_input_mismatch`);
-    const firstInputScriptPubKeyHex = getDecodedInputScriptPubKeyHex(inputs[0]);
+    const firstInputScriptPubKeyHex = getDecodedInputScriptPubKeyHex(decoded, 0);
     if (firstInputScriptPubKeyHex !== plan.sender.scriptPubKeyHex
         || !inputMatchesOutpoint(inputs[0], plan.requiredProvisionalOutpoint)) {
         throw new Error(`${plan.errorPrefix}_provisional_input_mismatch`);
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
@@ -700,6 +709,7 @@ async function buildTx2(options) {
         validateFundedDraft: validateTx2Draft,
         finalizeErrorCode: "wallet_anchor_tx2_finalize_failed",
         mempoolRejectPrefix: "wallet_anchor_tx2_mempool_rejected",
+        availableFundingMinConf: 0,
         reserveCandidates: options.state.proactiveReserveOutpoints,
     });
 }

package/dist/wallet/tx/cog.js

@@ -7,7 +7,7 @@ import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { serializeCogClaim, serializeCogLock, serializeCogTransfer, } from "../cogop/index.js";
 import { openWalletReadContext } from "../read/index.js";
-import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, formatCogAmount, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, formatCogAmount, getDecodedInputScriptPubKeyHex, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
 import { confirmTypedAcknowledgement, confirmYesNo } from "./confirm.js";
 import { getCanonicalIdentitySelector, resolveIdentityBySelector, } from "./identity-selector.js";
 import { findPendingMutationByIntent, upsertPendingMutation } from "./journal.js";
@@ -297,11 +297,11 @@ function validateFundedDraft(decoded, funded, plan) {
         throw new Error(`${plan.errorPrefix}_missing_sender_input`);
     }
     assertFixedInputPrefixMatches(inputs, plan.fixedInputs, `${plan.errorPrefix}_sender_input_mismatch`);
-    if (inputs[0]?.prevout?.scriptPubKey?.hex !== plan.sender.scriptPubKeyHex) {
+    if (getDecodedInputScriptPubKeyHex(decoded, 0) !== plan.sender.scriptPubKeyHex) {
         throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,

package/dist/wallet/tx/common.d.ts

@@ -1,4 +1,4 @@
-import type { RpcDecodedPsbt, RpcFinalizePsbtResult, RpcListUnspentEntry, RpcLockedUnspent, RpcTestMempoolAcceptResult, RpcTransaction, RpcVin, RpcWalletCreateFundedPsbtResult, RpcWalletProcessPsbtResult } from "../../bitcoind/types.js";
+import type { RpcDecodedPsbt, RpcFinalizePsbtResult, RpcListUnspentEntry, RpcLockedUnspent, RpcTestMempoolAcceptResult, RpcTransaction, RpcVin, RpcWalletCreateFundedPsbtResult, RpcWalletTransaction, RpcWalletProcessPsbtResult } from "../../bitcoind/types.js";
 import { type WalletSecretProvider } from "../state/provider.js";
 import type { OutpointRecord, PendingMutationRecord, PendingMutationStatus, WalletStateV1 } from "../types.js";
 import type { WalletReadContext } from "../read/index.js";
@@ -14,12 +14,15 @@ export interface WalletMutationRpcClient {
     listUnspent(walletName: string, minConf?: number): Promise<RpcListUnspentEntry[]>;
     listLockUnspent(walletName: string): Promise<RpcLockedUnspent[]>;
     lockUnspent(walletName: string, unlock: boolean, outputs: RpcLockedUnspent[]): Promise<boolean>;
+    getTransaction?(walletName: string, txid: string): Promise<RpcWalletTransaction>;
     walletCreateFundedPsbt(walletName: string, inputs: Array<{
         txid: string;
         vout: number;
     }>, outputs: unknown[], locktime: number, options: Record<string, unknown>, bip32Derivs?: boolean): Promise<RpcWalletCreateFundedPsbtResult>;
     decodePsbt(psbt: string): Promise<RpcDecodedPsbt>;
+    walletPassphrase(walletName: string, passphrase: string, timeoutSeconds: number): Promise<null>;
     walletProcessPsbt(walletName: string, psbt: string, sign?: boolean, sighashType?: string): Promise<RpcWalletProcessPsbtResult>;
+    walletLock(walletName: string): Promise<null>;
     finalizePsbt(psbt: string, extract?: boolean): Promise<RpcFinalizePsbtResult>;
     decodeRawTransaction(hex: string): Promise<RpcTransaction>;
     testMempoolAccept(rawTransactions: string[]): Promise<RpcTestMempoolAcceptResult[]>;
@@ -44,6 +47,12 @@ export declare function saveWalletStatePreservingUnlock(options: {
 }): Promise<void>;
 export declare function formatCogAmount(value: bigint): string;
 export declare function outpointKey(outpoint: OutpointRecord): string;
+export declare function findSpendableFundingInputsFromTransaction(options: {
+    allUtxos: RpcListUnspentEntry[];
+    txid: string;
+    fundingScriptPubKeyHex: string;
+    minConf?: number;
+}): FixedWalletInput[];
 export declare function updateMutationRecord(mutation: PendingMutationRecord, status: PendingMutationStatus, nowUnixMs: number, options?: {
     attemptedTxid?: string | null;
     attemptedWtxid?: string | null;
@@ -51,12 +60,12 @@ export declare function updateMutationRecord(mutation: PendingMutationRecord, st
 }): PendingMutationRecord;
 export declare function unlockTemporaryBuilderLocks(rpc: Pick<WalletMutationRpcClient, "lockUnspent">, walletName: string, outpoints: OutpointRecord[]): Promise<void>;
 export declare function diffTemporaryLockedOutpoints(before: RpcLockedUnspent[], after: RpcLockedUnspent[]): OutpointRecord[];
-export declare function getDecodedInputScriptPubKeyHex(input: RpcVin): string | null;
 export declare function getDecodedInputVout(input: RpcVin): number | null;
+export declare function getDecodedInputScriptPubKeyHex(decoded: RpcDecodedPsbt, inputIndex: number): string | null;
 export declare function inputMatchesOutpoint(input: RpcVin, outpoint: OutpointRecord): boolean;
 export declare function assertFixedInputPrefixMatches(inputs: RpcVin[], fixedInputs: FixedWalletInput[], errorCode: string): void;
 export declare function assertFundingInputsAfterFixedPrefix(options: {
-    inputs: RpcVin[];
+    decoded: RpcDecodedPsbt;
     fixedInputs: FixedWalletInput[];
     allowedFundingScriptPubKeyHex: string;
     eligibleFundingOutpointKeys: Set<string>;
@@ -102,6 +111,7 @@ export declare function buildWalletMutationTransaction<TPlan>(options: {
     finalizeErrorCode: string;
     mempoolRejectPrefix: string;
     feeRate?: number;
+    availableFundingMinConf?: number;
     temporarilyUnlockedPolicyOutpoints?: readonly OutpointRecord[];
 }): Promise<BuiltWalletMutationTransaction>;
 export declare function buildWalletMutationTransactionWithReserveFallback<TPlan>(options: {
@@ -120,5 +130,6 @@ export declare function buildWalletMutationTransactionWithReserveFallback<TPlan>
     finalizeErrorCode: string;
     mempoolRejectPrefix: string;
     feeRate?: number;
+    availableFundingMinConf?: number;
     reserveCandidates: readonly OutpointRecord[];
 }): Promise<BuiltWalletMutationTransaction>;

package/dist/wallet/tx/common.js

@@ -5,6 +5,7 @@ import { createWalletSecretReference, } from "../state/provider.js";
 import { reconcilePersistentPolicyLocks as reconcileWalletCoinControlLocks } from "../coin-control.js";
 import { requestMiningGenerationPreemption } from "../mining/coordination.js";
 export const DEFAULT_WALLET_MUTATION_FEE_RATE_SAT_VB = 10;
+const MANAGED_CORE_WALLET_SIGNING_UNLOCK_TIMEOUT_SECONDS = 10;
 function btcNumberToSats(value) {
     return BigInt(Math.round(value * 100_000_000));
 }
@@ -48,12 +49,24 @@ export function formatCogAmount(value) {
 export function outpointKey(outpoint) {
     return `${outpoint.txid}:${outpoint.vout}`;
 }
-function isSpendableConfirmedFundingUtxo(entry, fundingScriptPubKeyHex) {
+function isSpendableFundingUtxo(entry, fundingScriptPubKeyHex, minConf) {
     return entry.scriptPubKey === fundingScriptPubKeyHex
-        && entry.confirmations >= 1
+        && entry.confirmations >= minConf
         && entry.spendable !== false
         && entry.safe !== false;
 }
+export function findSpendableFundingInputsFromTransaction(options) {
+    const minConf = options.minConf ?? 0;
+    return options.allUtxos
+        .filter((entry) => entry.txid === options.txid
+        && isSpendableFundingUtxo(entry, options.fundingScriptPubKeyHex, minConf))
+        .sort((left, right) => left.vout - right.vout
+        || left.txid.localeCompare(right.txid))
+        .map((entry) => ({
+        txid: entry.txid,
+        vout: entry.vout,
+    }));
+}
 export function updateMutationRecord(mutation, status, nowUnixMs, options = {}) {
     return {
         ...mutation,
@@ -79,12 +92,33 @@ export function diffTemporaryLockedOutpoints(before, after) {
         vout: entry.vout,
     }));
 }
-export function getDecodedInputScriptPubKeyHex(input) {
-    return input.prevout?.scriptPubKey?.hex ?? null;
-}
 export function getDecodedInputVout(input) {
-    const vout = input.vout;
-    return typeof vout === "number" ? vout : null;
+    return typeof input.vout === "number" ? input.vout : null;
+}
+export function getDecodedInputScriptPubKeyHex(decoded, inputIndex) {
+    const input = decoded.tx.vin[inputIndex];
+    if (input === undefined) {
+        return null;
+    }
+    const prevoutScriptPubKeyHex = input.prevout?.scriptPubKey?.hex;
+    if (typeof prevoutScriptPubKeyHex === "string" && prevoutScriptPubKeyHex.length > 0) {
+        return prevoutScriptPubKeyHex;
+    }
+    const psbtInput = decoded.inputs?.[inputIndex];
+    const witnessScriptPubKeyHex = psbtInput?.witness_utxo?.scriptPubKey?.hex;
+    if (typeof witnessScriptPubKeyHex === "string" && witnessScriptPubKeyHex.length > 0) {
+        return witnessScriptPubKeyHex;
+    }
+    const vout = getDecodedInputVout(input);
+    if (vout === null) {
+        return null;
+    }
+    const nonWitnessScriptPubKeyHex = psbtInput?.non_witness_utxo?.vout
+        .find((output) => output.n === vout)
+        ?.scriptPubKey?.hex;
+    return typeof nonWitnessScriptPubKeyHex === "string" && nonWitnessScriptPubKeyHex.length > 0
+        ? nonWitnessScriptPubKeyHex
+        : null;
 }
 export function inputMatchesOutpoint(input, outpoint) {
     return input.txid === outpoint.txid && getDecodedInputVout(input) === outpoint.vout;
@@ -100,9 +134,9 @@ export function assertFixedInputPrefixMatches(inputs, fixedInputs, errorCode) {
     }
 }
 export function assertFundingInputsAfterFixedPrefix(options) {
-    for (let index = options.fixedInputs.length; index < options.inputs.length; index += 1) {
-        const input = options.inputs[index];
-        const scriptPubKeyHex = getDecodedInputScriptPubKeyHex(input);
+    for (let index = options.fixedInputs.length; index < options.decoded.tx.vin.length; index += 1) {
+        const input = options.decoded.tx.vin[index];
+        const scriptPubKeyHex = getDecodedInputScriptPubKeyHex(options.decoded, index);
         const vout = getDecodedInputVout(input);
         if (scriptPubKeyHex !== options.allowedFundingScriptPubKeyHex || vout === null || typeof input.txid !== "string") {
             throw new Error(options.errorCode);
@@ -155,8 +189,8 @@ function computeRemainingFundingValueSats(options) {
     for (const value of options.availableFundingValueByKey.values()) {
         remaining += value;
     }
-    for (const input of options.transaction.vin) {
-        const scriptPubKeyHex = getDecodedInputScriptPubKeyHex(input);
+    for (const [index, input] of options.decoded.tx.vin.entries()) {
+        const scriptPubKeyHex = getDecodedInputScriptPubKeyHex(options.decoded, index);
         const vout = getDecodedInputVout(input);
         if (scriptPubKeyHex !== options.fundingScriptPubKeyHex || vout === null || typeof input.txid !== "string") {
             continue;
@@ -166,7 +200,7 @@ function computeRemainingFundingValueSats(options) {
             vout,
         })) ?? 0n;
     }
-    for (const output of options.transaction.vout) {
+    for (const output of options.decoded.tx.vout) {
         if (output.scriptPubKey?.hex !== options.fundingScriptPubKeyHex) {
             continue;
         }
@@ -211,8 +245,9 @@ export async function buildWalletMutationTransaction(options) {
         fixedInputs: options.plan.fixedInputs,
         temporarilyUnlockedOutpoints: options.temporarilyUnlockedPolicyOutpoints,
     });
-    const availableFundingUtxos = (await options.rpc.listUnspent(options.walletName, 1))
-        .filter((entry) => isSpendableConfirmedFundingUtxo(entry, options.plan.allowedFundingScriptPubKeyHex));
+    const availableFundingMinConf = options.availableFundingMinConf ?? 1;
+    const availableFundingUtxos = (await options.rpc.listUnspent(options.walletName, availableFundingMinConf))
+        .filter((entry) => isSpendableFundingUtxo(entry, options.plan.allowedFundingScriptPubKeyHex, availableFundingMinConf));
     const availableFundingValueByKey = new Map(availableFundingUtxos.map((entry) => [
         outpointKey({ txid: entry.txid, vout: entry.vout }),
         btcNumberToSats(entry.amount),
@@ -244,7 +279,7 @@ export async function buildWalletMutationTransaction(options) {
         options.validateFundedDraft(decoded, funded, validationPlan);
         if (options.state.proactiveReserveSats > 0) {
             const remainingFundingValueSats = computeRemainingFundingValueSats({
-                transaction: decoded.tx,
+                decoded,
                 fundingScriptPubKeyHex: options.plan.allowedFundingScriptPubKeyHex,
                 availableFundingValueByKey,
             });
@@ -252,16 +287,25 @@ export async function buildWalletMutationTransaction(options) {
                 throw new Error("wallet_mutation_insufficient_funding_after_reserve");
             }
         }
-        const signed = await options.rpc.walletProcessPsbt(options.walletName, funded.psbt, true, "DEFAULT");
-        const finalized = await options.rpc.finalizePsbt(signed.psbt, true);
-        if (!finalized.complete || finalized.hex == null) {
-            throw new Error(options.finalizeErrorCode);
+        await options.rpc.walletPassphrase(options.walletName, options.state.managedCoreWallet.internalPassphrase, MANAGED_CORE_WALLET_SIGNING_UNLOCK_TIMEOUT_SECONDS);
+        let signed;
+        let finalized;
+        let decodedRaw;
+        try {
+            signed = await options.rpc.walletProcessPsbt(options.walletName, funded.psbt, true, "DEFAULT");
+            finalized = await options.rpc.finalizePsbt(signed.psbt, true);
+            if (!finalized.complete || finalized.hex == null) {
+                throw new Error(options.finalizeErrorCode);
+            }
+            decodedRaw = await options.rpc.decodeRawTransaction(finalized.hex);
+            const mempoolResult = await options.rpc.testMempoolAccept([finalized.hex]);
+            const accepted = mempoolResult[0];
+            if (accepted == null || !accepted.allowed) {
+                throw new Error(`${options.mempoolRejectPrefix}_${accepted?.["reject-reason"] ?? "unknown"}`);
+            }
         }
-        const decodedRaw = await options.rpc.decodeRawTransaction(finalized.hex);
-        const mempoolResult = await options.rpc.testMempoolAccept([finalized.hex]);
-        const accepted = mempoolResult[0];
-        if (accepted == null || !accepted.allowed) {
-            throw new Error(`${options.mempoolRejectPrefix}_${accepted?.["reject-reason"] ?? "unknown"}`);
+        finally {
+            await options.rpc.walletLock(options.walletName).catch(() => undefined);
         }
         if ((options.temporarilyUnlockedPolicyOutpoints?.length ?? 0) > 0) {
             await reconcilePersistentPolicyLocks({
@@ -295,31 +339,44 @@ export async function buildWalletMutationTransaction(options) {
     }
 }
 export async function buildWalletMutationTransactionWithReserveFallback(options) {
+    const preflightReconciled = options.reserveCandidates.length > 0
+        ? null
+        : await reconcileWalletCoinControlLocks({
+            rpc: options.rpc,
+            walletName: options.walletName,
+            state: options.state,
+            fixedInputs: options.plan.fixedInputs,
+        });
+    const effectiveState = preflightReconciled?.state ?? options.state;
+    const reserveCandidates = options.reserveCandidates.length > 0
+        ? [...options.reserveCandidates]
+        : [...effectiveState.proactiveReserveOutpoints];
     let unlockedReserveOutpoints = [];
     let lastError = null;
-    for (let attempt = 0; attempt <= options.reserveCandidates.length; attempt += 1) {
+    for (let attempt = 0; attempt <= reserveCandidates.length; attempt += 1) {
         if (attempt > 0) {
             unlockedReserveOutpoints = [
                 ...unlockedReserveOutpoints,
-                options.reserveCandidates[attempt - 1],
+                reserveCandidates[attempt - 1],
             ];
         }
         try {
             return await buildWalletMutationTransaction({
                 rpc: options.rpc,
                 walletName: options.walletName,
-                state: options.state,
+                state: effectiveState,
                 plan: options.plan,
                 validateFundedDraft: options.validateFundedDraft,
                 finalizeErrorCode: options.finalizeErrorCode,
                 mempoolRejectPrefix: options.mempoolRejectPrefix,
                 feeRate: options.feeRate,
+                availableFundingMinConf: options.availableFundingMinConf,
                 temporarilyUnlockedPolicyOutpoints: unlockedReserveOutpoints,
             });
         }
         catch (error) {
             lastError = error;
-            if ((!isInsufficientFundsError(error) && !isReserveFloorFundingError(error)) || attempt === options.reserveCandidates.length) {
+            if ((!isInsufficientFundsError(error) && !isReserveFloorFundingError(error)) || attempt === reserveCandidates.length) {
                 throw error;
             }
         }

package/dist/wallet/tx/domain-admin.js

@@ -9,7 +9,7 @@ import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { serializeSetCanonical, serializeSetDelegate, serializeSetEndpoint, serializeSetMiner, validateDomainName, } from "../cogop/index.js";
 import { openWalletReadContext } from "../read/index.js";
-import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, getDecodedInputScriptPubKeyHex, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
 import { confirmYesNo } from "./confirm.js";
 import { getCanonicalIdentitySelector } from "./identity-selector.js";
 import { findPendingMutationByIntent, upsertPendingMutation } from "./journal.js";
@@ -156,11 +156,11 @@ function validateFundedDraft(decoded, funded, plan) {
         throw new Error(`${plan.errorPrefix}_missing_sender_input`);
     }
     assertFixedInputPrefixMatches(inputs, plan.fixedInputs, `${plan.errorPrefix}_sender_input_mismatch`);
-    if (inputs[0]?.prevout?.scriptPubKey?.hex !== plan.sender.scriptPubKeyHex) {
+    if (getDecodedInputScriptPubKeyHex(decoded, 0) !== plan.sender.scriptPubKeyHex) {
         throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,

package/dist/wallet/tx/domain-market.js

@@ -7,7 +7,7 @@ import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { serializeDomainBuy, serializeDomainSell, serializeDomainTransfer, validateDomainName, } from "../cogop/index.js";
 import { openWalletReadContext } from "../read/index.js";
-import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, getDecodedInputScriptPubKeyHex, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
 import { confirmTypedAcknowledgement, confirmYesNo } from "./confirm.js";
 import { getCanonicalIdentitySelector, resolveIdentityBySelector, } from "./identity-selector.js";
 import { findPendingMutationByIntent, upsertPendingMutation } from "./journal.js";
@@ -297,11 +297,11 @@ function validateFundedDraft(decoded, funded, plan) {
         throw new Error(`${plan.errorPrefix}_missing_sender_input`);
     }
     assertFixedInputPrefixMatches(inputs, plan.fixedInputs, `${plan.errorPrefix}_sender_input_mismatch`);
-    if (inputs[0]?.prevout?.scriptPubKey?.hex !== plan.sender.scriptPubKeyHex) {
+    if (getDecodedInputScriptPubKeyHex(decoded, 0) !== plan.sender.scriptPubKeyHex) {
         throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,

package/dist/wallet/tx/field.js

@@ -10,7 +10,7 @@ import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { FIELD_FORMAT_BYTES, serializeDataUpdate, serializeFieldReg, } from "../cogop/index.js";
 import { validateFieldName } from "../cogop/validate-name.js";
 import { findDomainField, openWalletReadContext, } from "../read/index.js";
-import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, findSpendableFundingInputsFromTransaction, getDecodedInputScriptPubKeyHex, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
 import { confirmTypedAcknowledgement as confirmSharedTypedAcknowledgement, confirmYesNo as confirmSharedYesNo, } from "./confirm.js";
 import { getCanonicalIdentitySelector } from "./identity-selector.js";
 import { findPendingMutationByIntent, upsertPendingMutation } from "./journal.js";
@@ -274,10 +274,19 @@ function buildFieldFamilyTx2Plan(options) {
         && entry.confirmations >= 1
         && entry.spendable !== false
         && entry.safe !== false);
+    const tx1FundingChangeInputs = findSpendableFundingInputsFromTransaction({
+        allUtxos: options.allUtxos,
+        txid: options.tx1Txid,
+        fundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+        minConf: 0,
+    });
     return {
         sender: options.sender,
         changeAddress: options.state.funding.address,
-        fixedInputs: [{ txid: options.tx1Txid, vout: 1 }],
+        fixedInputs: [
+            { txid: options.tx1Txid, vout: 1 },
+            ...tx1FundingChangeInputs,
+        ],
         outputs: [
             { data: Buffer.from(options.opReturnData).toString("hex") },
             { [options.sender.address]: satsToBtcNumber(BigInt(options.state.anchorValueSats)) },
@@ -298,11 +307,11 @@ function validateFieldDraft(decoded, funded, plan) {
         throw new Error(`${plan.errorPrefix}_missing_sender_input`);
     }
     assertFixedInputPrefixMatches(inputs, plan.fixedInputs, `${plan.errorPrefix}_sender_input_mismatch`);
-    if (inputs[0]?.prevout?.scriptPubKey?.hex !== plan.sender.scriptPubKeyHex) {
+    if (getDecodedInputScriptPubKeyHex(decoded, 0) !== plan.sender.scriptPubKeyHex) {
         throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,
@@ -339,6 +348,7 @@ async function buildFieldTransaction(options) {
         validateFundedDraft: validateFieldDraft,
         finalizeErrorCode: `${options.plan.errorPrefix}_finalize_failed`,
         mempoolRejectPrefix: `${options.plan.errorPrefix}_mempool_rejected`,
+        availableFundingMinConf: options.availableFundingMinConf,
         reserveCandidates: options.state.proactiveReserveOutpoints,
     });
 }
@@ -1581,9 +1591,10 @@ async function submitFieldCreateFamily(options) {
                 rpc,
                 walletName,
                 state: workingState,
+                availableFundingMinConf: 0,
                 plan: buildFieldFamilyTx2Plan({
                     state: workingState,
-                    allUtxos: await rpc.listUnspent(walletName, 1),
+                    allUtxos: await rpc.listUnspent(walletName, 0),
                     sender: operation.sender,
                     tx1Txid,
                     opReturnData: serializeDataUpdate(operation.chainDomain.domainId, resumedFamily.expectedFieldId ?? operation.chainDomain.nextFieldId, options.value.format, options.value.value).opReturnData,

package/dist/wallet/tx/register.js

@@ -8,7 +8,7 @@ import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { computeRootRegistrationPriceSats, serializeDomainReg } from "../cogop/index.js";
 import { openWalletReadContext } from "../read/index.js";
-import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, formatCogAmount, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, formatCogAmount, getDecodedInputScriptPubKeyHex, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
 import { confirmTypedAcknowledgement, confirmYesNo } from "./confirm.js";
 import { getCanonicalIdentitySelector, resolveIdentityBySelector, } from "./identity-selector.js";
 import { findPendingMutationByIntent, upsertPendingMutation } from "./journal.js";
@@ -402,11 +402,11 @@ function validateFundedDraft(decoded, funded, plan) {
         throw new Error("wallet_register_missing_sender_input");
     }
     assertFixedInputPrefixMatches(inputs, plan.fixedInputs, "wallet_register_sender_input_mismatch");
-    if (inputs[0]?.prevout?.scriptPubKey?.hex !== plan.sender.scriptPubKeyHex) {
+    if (getDecodedInputScriptPubKeyHex(decoded, 0) !== plan.sender.scriptPubKeyHex) {
         throw new Error("wallet_register_sender_input_mismatch");
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,

package/dist/wallet/tx/reputation.js

@@ -8,7 +8,7 @@ import { resolveWalletRuntimePathsForTesting } from "../runtime.js";
 import { createDefaultWalletSecretProvider, } from "../state/provider.js";
 import { serializeRepCommit, serializeRepRevoke, validateDomainName, } from "../cogop/index.js";
 import { openWalletReadContext } from "../read/index.js";
-import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, formatCogAmount, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
+import { assertFixedInputPrefixMatches, assertFundingInputsAfterFixedPrefix, assertWalletMutationContextReady, buildWalletMutationTransactionWithReserveFallback, formatCogAmount, getDecodedInputScriptPubKeyHex, isAlreadyAcceptedError, isBroadcastUnknownError, outpointKey, pauseMiningForWalletMutation, saveWalletStatePreservingUnlock, unlockTemporaryBuilderLocks, updateMutationRecord, } from "./common.js";
 import { confirmTypedAcknowledgement as confirmSharedTypedAcknowledgement, confirmYesNo as confirmSharedYesNo, } from "./confirm.js";
 import { getCanonicalIdentitySelector } from "./identity-selector.js";
 import { findPendingMutationByIntent, upsertPendingMutation } from "./journal.js";
@@ -185,11 +185,11 @@ function validateFundedDraft(decoded, funded, plan) {
         throw new Error(`${plan.errorPrefix}_missing_sender_input`);
     }
     assertFixedInputPrefixMatches(inputs, plan.fixedInputs, `${plan.errorPrefix}_sender_input_mismatch`);
-    if (inputs[0]?.prevout?.scriptPubKey?.hex !== plan.sender.scriptPubKeyHex) {
+    if (getDecodedInputScriptPubKeyHex(decoded, 0) !== plan.sender.scriptPubKeyHex) {
         throw new Error(`${plan.errorPrefix}_sender_input_mismatch`);
     }
     assertFundingInputsAfterFixedPrefix({
-        inputs,
+        decoded,
         fixedInputs: plan.fixedInputs,
         allowedFundingScriptPubKeyHex: plan.allowedFundingScriptPubKeyHex,
         eligibleFundingOutpointKeys: plan.eligibleFundingOutpointKeys,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogcoin/client",
-  "version": "0.5.14",
+  "version": "0.5.15",
   "description": "Store-backed Cogcoin client with wallet flows, SQLite persistence, and managed Bitcoin Core integration.",
   "license": "MIT",
   "type": "module",