@bsv/wallet-toolbox-client 2.4.4 → 2.4.20

package/out/src/signer/actionBatch/ActionBatchWorkspace.js

@@ -1,693 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActionBatchController = void 0;
-exports.additionalFundingTarget = additionalFundingTarget;
-exports.fundingRunwayExtension = fundingRunwayExtension;
-const sdk_1 = require("@bsv/sdk");
-const WERR_errors_1 = require("../../sdk/WERR_errors");
-const utilityHelpers_1 = require("../../utility/utilityHelpers");
-const utilityHelpers_noBuffer_1 = require("../../utility/utilityHelpers.noBuffer");
-const types_1 = require("../../sdk/types");
-const actionBatchDigest_1 = require("../../utility/actionBatchDigest");
-const ActionBatchPlanner_1 = require("./ActionBatchPlanner");
-const beefForTxids_1 = require("../../utility/beefForTxids");
-function mergeUnique(values) {
-    return [...new Set(values)];
-}
-function nextGeometricTarget(value) {
-    return Math.min(Number.MAX_SAFE_INTEGER, value * 2);
-}
-function additionalFundingTarget(error) {
-    return error.moreSatoshisNeeded;
-}
-function fundingRunwayExtension(runwayTarget, ewmaConfirmedInputs, ewmaConfirmedSatoshis, availableConfirmed) {
-    const availableConfirmedCount = availableConfirmed.length;
-    const availableConfirmedSatoshis = availableConfirmed
-        .reduce((sum, output) => sum + output.satoshis, 0);
-    const predictedByInputs = availableConfirmedCount / Math.max(1, ewmaConfirmedInputs);
-    const predictedBySatoshis = ewmaConfirmedSatoshis > 0
-        ? availableConfirmedSatoshis / ewmaConfirmedSatoshis
-        : Number.POSITIVE_INFINITY;
-    if (Math.min(predictedByInputs, predictedBySatoshis) >= 2)
-        return undefined;
-    const nextRunwayTarget = nextGeometricTarget(runwayTarget);
-    return {
-        nextRunwayTarget,
-        requestedOutputs: Math.max(1, Math.ceil(nextRunwayTarget * ewmaConfirmedInputs) - availableConfirmedCount),
-        targetSatoshis: Math.max(1, nextRunwayTarget * ewmaConfirmedSatoshis - availableConfirmedSatoshis)
-    };
-}
-function makePlannerState(begin, firstAction) {
-    const sharedBeef = new sdk_1.Beef();
-    if (begin.inputBeef != null)
-        sharedBeef.mergeBeef(begin.inputBeef);
-    if (firstAction.inputBEEF != null)
-        sharedBeef.mergeBeef(firstAction.inputBEEF);
-    for (const output of [...begin.reservedOutputs, ...begin.explicitOutputs]) {
-        if (output.sourceTransaction != null)
-            sharedBeef.mergeRawTx(output.sourceTransaction);
-    }
-    const state = {
-        begin,
-        sharedBeef,
-        reserved: new Map(),
-        explicit: new Map(),
-        staged: new Map(),
-        discardedStagedTxids: new Set(),
-        consumed: new Set(),
-        estimatedChangeCount: begin.availableChangeCount
-    };
-    (0, ActionBatchPlanner_1.addPlannerOutputs)(state.reserved, begin.reservedOutputs, begin.changeBasket.name);
-    (0, ActionBatchPlanner_1.addPlannerOutputs)(state.explicit, begin.explicitOutputs);
-    return state;
-}
-class ActionBatchWorkspace {
-    wallet;
-    capabilities;
-    batchId;
-    state;
-    planned = new Map();
-    actions = [];
-    lockingScripts = new Map();
-    ewmaConfirmedInputs = 1;
-    ewmaConfirmedSatoshis = 0;
-    hasConfirmedSample = false;
-    runwayTarget = 4;
-    extension;
-    renewal;
-    expiresAt;
-    committed = false;
-    constructor(wallet, begin, firstAction, capabilities) {
-        this.wallet = wallet;
-        this.capabilities = capabilities;
-        this.batchId = begin.batchId;
-        this.state = makePlannerState(begin, firstAction);
-        this.expiresAt = Date.parse(begin.expiresAt);
-    }
-    ownsReference(reference) {
-        if (this.planned.has(reference))
-            return true;
-        if (this.actions.some(action => action.reference === reference || action.txid === reference))
-            return true;
-        return Object.entries(this.wallet.pendingSignActions)
-            .some(([pendingReference, pending]) => this.planned.has(pendingReference) && pending.tx.id('hex') === reference);
-    }
-    get isEmpty() {
-        return this.planned.size === 0 && this.actions.length === 0;
-    }
-    overlayListActions(persisted, args) {
-        if (args.labels.includes(types_1.specOpFailedActions))
-            return persisted;
-        const controlLabels = new Set(args.labels.includes(types_1.specOpNoSendActions) ? ['abort'] : []);
-        const ordinaryLabels = args.labels.filter(label => !(0, types_1.isListActionsSpecOp)(label) && !controlLabels.has(label));
-        const staged = this.actions
-            .filter(action => {
-            if (ordinaryLabels.length === 0)
-                return true;
-            const matches = ordinaryLabels.filter(label => action.metadata.labels.includes(label)).length;
-            return args.labelQueryMode === 'all' ? matches === ordinaryLabels.length : matches > 0;
-        })
-            .map(action => {
-            const tx = this.state.sharedBeef.findTxid(action.txid)?.tx;
-            if (tx == null)
-                throw new WERR_errors_1.WERR_INVALID_OPERATION(`missing staged transaction ${action.txid}`);
-            const managedInputSatoshis = action.plan.inputs
-                .filter(input => input.vin >= action.metadata.inputs.length)
-                .reduce((sum, input) => sum + input.sourceSatoshis, 0);
-            const changeOutputSatoshis = action.plan.outputs
-                .filter(output => output.purpose === 'change')
-                .reduce((sum, output) => sum + output.satoshis, 0);
-            return {
-                txid: action.txid,
-                satoshis: changeOutputSatoshis - managedInputSatoshis,
-                status: 'nosend',
-                isOutgoing: true,
-                description: action.metadata.description,
-                labels: args.includeLabels ? action.metadata.labels : undefined,
-                version: tx.version,
-                lockTime: tx.lockTime,
-                inputs: args.includeInputs
-                    ? action.plan.inputs.map(input => ({
-                        sourceOutpoint: `${input.sourceTxid}.${input.sourceVout}`,
-                        sourceSatoshis: input.sourceSatoshis,
-                        sourceLockingScript: args.includeInputSourceLockingScripts ? input.sourceLockingScript : undefined,
-                        unlockingScript: args.includeInputUnlockingScripts
-                            ? tx.inputs[input.vin]?.unlockingScript?.toHex()
-                            : undefined,
-                        inputDescription: input.spendingDescription ?? '',
-                        sequenceNumber: tx.inputs[input.vin]?.sequence ?? 0
-                    }))
-                    : undefined,
-                outputs: args.includeOutputs
-                    ? action.plan.outputs.map(output => ({
-                        satoshis: output.satoshis,
-                        lockingScript: args.includeOutputLockingScripts
-                            ? tx.outputs[output.vout]?.lockingScript.toHex()
-                            : undefined,
-                        spendable: output.purpose !== 'storage-commission',
-                        customInstructions: undefined,
-                        tags: output.tags,
-                        outputIndex: output.vout,
-                        outputDescription: output.outputDescription,
-                        basket: output.basket ?? ''
-                    }))
-                    : undefined
-            };
-        });
-        const actions = [...persisted.actions, ...staged];
-        return {
-            totalActions: persisted.totalActions + staged.length,
-            actions: actions.slice(args.offset, args.offset + args.limit)
-        };
-    }
-    overlayListOutputs(persisted, args) {
-        const isBalance = args.basket === types_1.specOpWalletBalance || args.tags.includes(types_1.specOpWalletBalance);
-        const managedOnly = args.basket === types_1.specOpWalletManagedUtxos || isBalance;
-        const consumed = this.state.consumed;
-        const stagedLabels = new Map(this.actions.map(action => [action.txid, action.metadata.labels]));
-        const staged = [...this.state.staged.entries()]
-            .filter(([outpoint, output]) => {
-            if (consumed.has(outpoint))
-                return false;
-            if (managedOnly)
-                return output.change;
-            if (output.basketName !== args.basket)
-                return false;
-            const tags = output.tags ?? [];
-            if (args.tags.length === 0)
-                return true;
-            const matches = args.tags.filter(tag => tags.includes(tag)).length;
-            return args.tagQueryMode === 'all' ? matches === args.tags.length : matches > 0;
-        })
-            .map(([outpoint, output]) => ({
-            satoshis: output.satoshis,
-            lockingScript: args.includeLockingScripts
-                ? (0, utilityHelpers_noBuffer_1.asString)((0, ActionBatchPlanner_1.plannerOutputLockingScript)(this.state, output))
-                : undefined,
-            spendable: true,
-            customInstructions: args.includeCustomInstructions ? output.customInstructions : undefined,
-            tags: args.includeTags ? output.tags ?? [] : undefined,
-            outpoint,
-            labels: args.includeLabels && output.txid != null ? stagedLabels.get(output.txid) ?? [] : undefined
-        }));
-        if (isBalance) {
-            const consumedConfirmed = [...this.state.reserved.entries()]
-                .filter(([outpoint]) => consumed.has(outpoint))
-                .reduce((sum, [, output]) => sum + output.satoshis, 0);
-            return {
-                totalOutputs: persisted.totalOutputs - consumedConfirmed + staged.reduce((sum, output) => sum + output.satoshis, 0),
-                outputs: []
-            };
-        }
-        const persistedUnconsumed = persisted.outputs.filter(output => !consumed.has(output.outpoint));
-        const outputs = [
-            ...persistedUnconsumed,
-            ...staged
-        ];
-        const ordered = args.offset < 0 ? [...outputs].reverse() : outputs;
-        const offset = args.offset < 0 ? Math.max(0, -args.offset - 1) : args.offset;
-        const result = {
-            totalOutputs: persisted.totalOutputs - (persisted.outputs.length - persistedUnconsumed.length) + staged.length,
-            outputs: ordered.slice(offset, offset + args.limit)
-        };
-        if (args.includeTransactions) {
-            const beef = new sdk_1.Beef();
-            if (persisted.BEEF != null)
-                beef.mergeBeef(persisted.BEEF);
-            beef.mergeBeef(this.state.sharedBeef);
-            for (const txid of args.knownTxids)
-                if (beef.findTxid(txid) != null)
-                    beef.makeTxidOnly(txid);
-            result.BEEF = beef.toUint8Array();
-        }
-        return result;
-    }
-    mergeExtension(extension) {
-        for (const output of [...extension.reservedOutputs, ...extension.explicitOutputs]) {
-            if (output.sourceTransaction != null) {
-                this.state.sharedBeef.mergeRawTx(output.sourceTransaction);
-            }
-        }
-        (0, ActionBatchPlanner_1.addPlannerOutputs)(this.state.reserved, extension.reservedOutputs, this.state.begin.changeBasket.name);
-        (0, ActionBatchPlanner_1.addPlannerOutputs)(this.state.explicit, extension.explicitOutputs);
-        if (extension.inputBeef != null) {
-            this.state.sharedBeef.mergeBeef(extension.inputBeef);
-        }
-    }
-    missingExplicitOutpoints(args) {
-        return [...args.inputs.map(input => input.outpoint), ...args.options.noSendChange]
-            .filter(outpoint => {
-            const key = `${outpoint.txid}.${outpoint.vout}`;
-            return !this.state.staged.has(key) && !this.state.explicit.has(key) &&
-                !this.state.reserved.has(key) && (this.state.discardedStagedTxids.has(outpoint.txid) ||
-                this.state.sharedBeef.findTxid(outpoint.txid)?.tx == null);
-        });
-    }
-    async extend(targetSatoshis, requestedOutputs, explicitOutpoints, includeSourceTransactions) {
-        const extension = await this.wallet.storage.extendActionBatch({
-            batchId: this.batchId,
-            targetSatoshis: Math.max(1, Math.ceil(targetSatoshis)),
-            requestedOutputs: Math.max(1, Math.ceil(requestedOutputs)),
-            explicitOutpoints,
-            includeSourceTransactions
-        });
-        this.mergeExtension(extension);
-        this.expiresAt = Date.parse(extension.expiresAt);
-        return {
-            outputCount: extension.reservedOutputs.length,
-            satoshis: extension.reservedOutputs.reduce((sum, output) => sum + output.satoshis, 0)
-        };
-    }
-    async renewIfNeeded() {
-        if (Date.now() >= this.expiresAt)
-            return;
-        const renewAt = this.expiresAt - this.capabilities.leaseMs * 0.2;
-        if (Date.now() < renewAt)
-            return;
-        this.renewal ??= this.wallet.storage.renewActionBatch(this.batchId)
-            .then(result => { this.expiresAt = Date.parse(result.expiresAt); })
-            .finally(() => { this.renewal = undefined; });
-        await this.renewal;
-    }
-    async plan(args) {
-        if (this.committed)
-            throw new WERR_errors_1.WERR_INVALID_OPERATION('action batch is already committed');
-        await this.renewIfNeeded();
-        if (this.extension != null)
-            await this.extension;
-        if (args.inputBEEF != null) {
-            this.state.sharedBeef.mergeBeef(args.inputBEEF);
-        }
-        const missing = this.missingExplicitOutpoints(args);
-        if (missing.length > 0)
-            await this.extend(1, 1, missing, args.isSignAction);
-        let planned;
-        let requestedOutputs = 8;
-        for (;;) {
-            try {
-                planned = await (0, ActionBatchPlanner_1.planAction)(this.state, args);
-                break;
-            }
-            catch (error) {
-                if (!(error instanceof WERR_errors_1.WERR_INSUFFICIENT_FUNDS))
-                    throw error;
-                // generateChangeSdk has already credited every unconsumed reservation
-                // supplied by planFunding. Only the reported shortfall is additional;
-                // requesting totalSatoshisNeeded here double-counts the held pool.
-                const target = additionalFundingTarget(error);
-                const added = await this.extend(target, requestedOutputs, [], args.isSignAction);
-                if (added.outputCount === 0 || added.satoshis === 0)
-                    throw error;
-                requestedOutputs = nextGeometricTarget(requestedOutputs);
-            }
-        }
-        if (planned == null)
-            throw new WERR_errors_1.WERR_INVALID_OPERATION('unable to plan action batch transaction');
-        this.planned.set(planned.dcr.reference, { args, planned });
-        return planned.dcr;
-    }
-    updateEwma(plan) {
-        const confirmed = plan.planned.consumedOutpoints
-            .map(outpoint => this.state.reserved.get(outpoint))
-            .filter((output) => output != null);
-        if (confirmed.length === 0)
-            return;
-        const satoshis = confirmed.reduce((sum, output) => sum + output.satoshis, 0);
-        if (!this.hasConfirmedSample) {
-            this.ewmaConfirmedInputs = confirmed.length;
-            this.ewmaConfirmedSatoshis = satoshis;
-            this.hasConfirmedSample = true;
-            return;
-        }
-        this.ewmaConfirmedInputs = 0.5 * confirmed.length + 0.5 * this.ewmaConfirmedInputs;
-        this.ewmaConfirmedSatoshis = 0.5 * satoshis + 0.5 * this.ewmaConfirmedSatoshis;
-    }
-    stage(prior, processArgs) {
-        if (this.actions.some(action => action.reference === prior.reference))
-            return;
-        const pending = this.planned.get(prior.reference);
-        if (pending == null)
-            throw new WERR_errors_1.WERR_INVALID_OPERATION('signed action does not belong to active action batch');
-        const txid = prior.tx.id('hex');
-        const lockingScriptDigests = prior.dcr.outputs.map(output => {
-            if (output.lockingScript.length === 0)
-                return undefined;
-            const digest = (0, actionBatchDigest_1.actionBatchBlobDigest)((0, utilityHelpers_noBuffer_1.asArray)(output.lockingScript));
-            this.lockingScripts.set(digest, output.lockingScript);
-            return digest;
-        });
-        const compactPlan = {
-            ...prior.dcr,
-            inputBeef: undefined,
-            inputs: prior.dcr.inputs.map(input => ({ ...input, sourceTransaction: undefined })),
-            outputs: prior.dcr.outputs.map(output => ({ ...output, lockingScript: '' }))
-        };
-        const action = {
-            reference: prior.reference,
-            txid,
-            lockingScriptDigests,
-            plan: compactPlan,
-            metadata: {
-                description: pending.args.description,
-                labels: pending.args.labels,
-                isNoSend: processArgs.isNoSend,
-                isDelayed: processArgs.isDelayed,
-                inputs: pending.args.inputs,
-                outputs: pending.args.outputs.map(output => ({ ...output, lockingScript: '' }))
-            },
-            commissionKeyOffset: pending.planned.commissionKeyOffset
-        };
-        this.actions.push(action);
-        this.updateEwma(pending);
-        (0, ActionBatchPlanner_1.stageTransactionOutputs)(this.state, prior.tx, prior.dcr);
-        (0, ActionBatchPlanner_1.mergePlannerBeef)(this.state, prior.tx);
-        this.planned.delete(prior.reference);
-        this.scheduleExtensionIfNeeded();
-    }
-    scheduleExtensionIfNeeded() {
-        if (this.extension != null)
-            return;
-        const availableConfirmed = [...this.state.reserved.entries()]
-            .filter(([outpoint]) => !this.state.consumed.has(outpoint));
-        const request = fundingRunwayExtension(this.runwayTarget, this.ewmaConfirmedInputs, this.ewmaConfirmedSatoshis, availableConfirmed.map(([, output]) => output));
-        if (request == null)
-            return;
-        this.extension = this.extend(request.targetSatoshis, request.requestedOutputs, [], false)
-            .then(added => {
-            // A failed or partial extension must not geometrically inflate the
-            // next request against a runway that the wallet never acquired.
-            if (added.outputCount >= request.requestedOutputs &&
-                added.satoshis >= request.targetSatoshis) {
-                this.runwayTarget = request.nextRunwayTarget;
-            }
-        })
-            .catch(() => { })
-            .finally(() => { this.extension = undefined; });
-    }
-    buildManifest(sendWith, isDelayed) {
-        const stagedTxids = new Set(this.actions.map(action => action.txid));
-        const externalTxids = this.actions.flatMap(action => action.plan.inputs)
-            .map(input => input.sourceTxid)
-            .filter(txid => !stagedTxids.has(txid));
-        const dependencyBytes = (0, utilityHelpers_noBuffer_1.asArray)((0, beefForTxids_1.beefForTxids)(this.state.sharedBeef, externalTxids).toUint8Array());
-        const rawBytes = this.actions.map(action => {
-            const tx = this.state.sharedBeef.findTxid(action.txid)?.tx;
-            if (tx == null)
-                throw new WERR_errors_1.WERR_INVALID_OPERATION(`missing staged transaction ${action.txid}`);
-            return (0, utilityHelpers_noBuffer_1.asArray)(tx.toUint8Array());
-        });
-        const blobs = new Map();
-        const addBlob = (bytes) => {
-            const digest = (0, actionBatchDigest_1.actionBatchBlobDigest)(bytes);
-            if (!blobs.has(digest))
-                blobs.set(digest, bytes);
-            return digest;
-        };
-        const actions = this.actions.map((action, index) => {
-            return { ...action, rawTx: undefined, rawTxDigest: addBlob(rawBytes[index]) };
-        });
-        const dependencyBeefDigest = addBlob(dependencyBytes);
-        for (const [digest, script] of this.lockingScripts) {
-            if (!blobs.has(digest))
-                blobs.set(digest, (0, utilityHelpers_noBuffer_1.asArray)(script));
-        }
-        const totalBytes = [...blobs.values()].reduce((sum, bytes) => sum + bytes.length, 0);
-        const useUploads = totalBytes > this.capabilities.maxInlineBytes;
-        const uploadBlobs = new Map();
-        const blobChunks = {};
-        if (useUploads) {
-            const chunkBytes = Math.max(1, this.capabilities.maxBlobBytes);
-            for (const [digest, bytes] of blobs) {
-                if (bytes.length <= chunkBytes) {
-                    uploadBlobs.set(digest, bytes);
-                    continue;
-                }
-                const chunks = [];
-                for (let offset = 0; offset < bytes.length; offset += chunkBytes) {
-                    const chunk = bytes.slice(offset, Math.min(bytes.length, offset + chunkBytes));
-                    const chunkDigest = (0, actionBatchDigest_1.actionBatchBlobDigest)(chunk);
-                    chunks.push(chunkDigest);
-                    if (!uploadBlobs.has(chunkDigest))
-                        uploadBlobs.set(chunkDigest, chunk);
-                }
-                blobChunks[digest] = chunks;
-            }
-        }
-        const withoutDigest = {
-            batchId: this.batchId,
-            actions,
-            dependencyBeefDigest,
-            inlineBlobs: useUploads
-                ? undefined
-                : Object.fromEntries([...blobs].map(([digest, bytes]) => [digest, Uint8Array.from(bytes)])),
-            blobChunks: Object.keys(blobChunks).length === 0 ? undefined : blobChunks,
-            sendWith: mergeUnique(sendWith),
-            isDelayed
-        };
-        return {
-            manifest: { ...withoutDigest, digest: (0, actionBatchDigest_1.actionBatchManifestDigest)(withoutDigest) },
-            uploads: [...uploadBlobs].map(([digest, bytes]) => ({ digest, bytes }))
-        };
-    }
-    async uploadMissing(manifest, uploads) {
-        const prepared = await this.wallet.storage.prepareActionBatchCommit(manifest);
-        const missing = new Set(prepared.missingDigests);
-        const pending = uploads.filter(upload => missing.has(upload.digest));
-        const concurrency = Math.max(1, Math.min(prepared.maxConcurrentUploads, this.capabilities.maxConcurrentUploads, pending.length));
-        let cursor = 0;
-        await Promise.all(Array.from({ length: concurrency }, async () => {
-            for (;;) {
-                const index = cursor++;
-                if (index >= pending.length)
-                    return;
-                const upload = pending[index];
-                if (upload.bytes.length > prepared.maxBlobBytes) {
-                    throw new WERR_errors_1.WERR_INVALID_OPERATION(`action batch blob ${upload.digest} exceeds provider limit`);
-                }
-                await this.wallet.storage.putActionBatchBlob({
-                    batchId: this.batchId,
-                    digest: upload.digest,
-                    bytes: upload.bytes
-                });
-            }
-        }));
-    }
-    async commit(sendWith, isDelayed) {
-        if (this.extension != null)
-            await this.extension;
-        await this.renewIfNeeded();
-        if (this.planned.size > 0)
-            throw new WERR_errors_1.WERR_INVALID_OPERATION('all two-step actions must be signed before batch commit');
-        const { manifest, uploads } = this.buildManifest(sendWith, isDelayed);
-        if (uploads.length > 0)
-            await this.uploadMissing(manifest, uploads);
-        const result = await this.wallet.storage.commitActionBatch(manifest);
-        this.committed = true;
-        return result;
-    }
-    abortAction(referenceOrTxid) {
-        let pendingReference;
-        if (this.planned.has(referenceOrTxid)) {
-            pendingReference = referenceOrTxid;
-        }
-        else {
-            pendingReference = Object.entries(this.wallet.pendingSignActions)
-                .find(([reference, pending]) => this.planned.has(reference) && pending.tx.id('hex') === referenceOrTxid)?.[0];
-        }
-        const actionIndex = this.actions.findIndex(action => action.reference === referenceOrTxid || action.txid === referenceOrTxid);
-        const action = actionIndex < 0 ? undefined : this.actions[actionIndex];
-        const targetTxid = action?.txid ??
-            (pendingReference == null ? undefined : this.wallet.pendingSignActions[pendingReference]?.tx.id('hex'));
-        if (targetTxid != null && this.hasDependentAction(targetTxid, action?.reference ?? pendingReference)) {
-            throw new WERR_errors_1.WERR_INVALID_OPERATION(`cannot abort action ${referenceOrTxid} while another staged action depends on it`);
-        }
-        if (action != null) {
-            this.actions.splice(actionIndex, 1);
-        }
-        else if (pendingReference != null) {
-            this.planned.delete(pendingReference);
-            Reflect.deleteProperty(this.wallet.pendingSignActions, pendingReference);
-        }
-        else {
-            return false;
-        }
-        if (targetTxid != null)
-            this.state.discardedStagedTxids.add(targetTxid);
-        this.rebuildStagedState();
-        return true;
-    }
-    hasDependentAction(txid, excludedReference) {
-        if (this.actions.some(action => action.reference !== excludedReference &&
-            action.plan.inputs.some(input => input.sourceTxid === txid)))
-            return true;
-        return [...this.planned.entries()].some(([reference, pending]) => reference !== excludedReference &&
-            pending.planned.dcr.inputs.some(input => input.sourceTxid === txid));
-    }
-    rebuildStagedState() {
-        this.state.consumed.clear();
-        this.state.staged.clear();
-        this.state.estimatedChangeCount = this.state.begin.availableChangeCount;
-        this.lockingScripts.clear();
-        for (const action of this.actions) {
-            const tx = this.state.sharedBeef.findTxid(action.txid)?.tx;
-            if (tx == null)
-                throw new WERR_errors_1.WERR_INVALID_OPERATION(`missing staged transaction ${action.txid}`);
-            for (const input of action.plan.inputs) {
-                this.state.consumed.add(`${input.sourceTxid}.${input.sourceVout}`);
-            }
-            const managedInputCount = action.plan.inputs.length - action.metadata.inputs.length;
-            const changeOutputCount = action.plan.outputs.filter(output => output.purpose === 'change').length;
-            this.state.estimatedChangeCount += changeOutputCount - managedInputCount;
-            (0, ActionBatchPlanner_1.stageTransactionOutputs)(this.state, tx, action.plan);
-            const lockingScriptDigests = action.lockingScriptDigests ?? [];
-            lockingScriptDigests.forEach((digest, outputIndex) => {
-                if (digest == null)
-                    return;
-                const vout = action.plan.outputs[outputIndex]?.vout;
-                const script = vout == null ? undefined : tx.outputs[vout]?.lockingScript;
-                if (script == null)
-                    throw new WERR_errors_1.WERR_INVALID_OPERATION(`missing staged output script for ${action.txid}.${vout}`);
-                this.lockingScripts.set(digest, script.toHex());
-            });
-        }
-        for (const pending of this.planned.values()) {
-            for (const outpoint of pending.planned.consumedOutpoints)
-                this.state.consumed.add(outpoint);
-            const managedInputCount = pending.planned.dcr.inputs.length - pending.args.inputs.length;
-            const changeOutputCount = pending.planned.dcr.outputs.filter(output => output.purpose === 'change').length;
-            this.state.estimatedChangeCount += changeOutputCount - managedInputCount;
-        }
-    }
-    async abort() {
-        if (this.committed)
-            return;
-        await this.wallet.storage.abortActionBatch(this.batchId);
-        for (const reference of this.planned.keys())
-            delete this.wallet.pendingSignActions[reference];
-    }
-}
-class ActionBatchController {
-    wallet;
-    mode;
-    workspace;
-    capabilities = new Map();
-    serial = Promise.resolve();
-    constructor(wallet, mode) {
-        this.wallet = wallet;
-        this.mode = mode;
-    }
-    get hasWorkspace() { return this.workspace != null; }
-    overlayListActions(persisted, args) {
-        return this.workspace?.overlayListActions(persisted, args) ?? persisted;
-    }
-    overlayListOutputs(persisted, args) {
-        return this.workspace?.overlayListOutputs(persisted, args) ?? persisted;
-    }
-    async runExclusive(operation) {
-        const run = this.serial.then(operation);
-        this.serial = run.then(() => { }, () => { });
-        return await run;
-    }
-    async negotiate() {
-        if (this.mode === 'legacy')
-            return undefined;
-        const activeStore = this.wallet.storage.getActiveStore();
-        let capabilities = this.capabilities.get(activeStore);
-        if (capabilities == null) {
-            capabilities = this.wallet.storage.getCapabilities()
-                .then(result => result.actionBatch?.version === 1 ? result.actionBatch : undefined)
-                .catch(() => undefined);
-            this.capabilities.set(activeStore, capabilities);
-        }
-        return await capabilities;
-    }
-    async begin(args) {
-        if (args.inputs.length > 8)
-            return undefined;
-        const capabilities = await this.negotiate();
-        if (capabilities == null)
-            return undefined;
-        const batchId = (0, utilityHelpers_1.randomBytesBase64)(24);
-        const begin = await this.wallet.storage.beginActionBatch({
-            batchId,
-            firstAction: { ...args, logger: undefined }
-        });
-        this.workspace = new ActionBatchWorkspace(this.wallet, begin, args, capabilities);
-        return this.workspace;
-    }
-    async plan(args) {
-        return await this.runExclusive(async () => {
-            if (!args.isNewTx)
-                return undefined;
-            let workspace = this.workspace;
-            let beganWorkspace = false;
-            if (workspace == null) {
-                if (!args.isNoSend)
-                    return undefined;
-                workspace = await this.begin(args);
-                if (workspace == null)
-                    return undefined;
-                beganWorkspace = true;
-            }
-            try {
-                return await workspace.plan(args);
-            }
-            catch (error) {
-                if (beganWorkspace) {
-                    await workspace.abort();
-                    this.workspace = undefined;
-                }
-                throw error;
-            }
-        });
-    }
-    async process(prior, args) {
-        return await this.runExclusive(async () => {
-            const workspace = this.workspace;
-            if (workspace == null)
-                return undefined;
-            if (prior != null && !workspace.ownsReference(prior.reference))
-                return undefined;
-            if (prior != null)
-                workspace.stage(prior, args);
-            const shouldCommit = args.isSendWith || (prior != null && !args.isNoSend);
-            if (!shouldCommit)
-                return { sendWithResults: [] };
-            const sendWith = [...args.options.sendWith];
-            if (prior != null && !args.isNoSend && !sendWith.includes(prior.tx.id('hex')))
-                sendWith.push(prior.tx.id('hex'));
-            const result = await workspace.commit(sendWith, args.isDelayed);
-            this.workspace = undefined;
-            return result;
-        });
-    }
-    ownsReference(reference) {
-        return this.workspace?.ownsReference(reference) ?? false;
-    }
-    async abort() {
-        return await this.runExclusive(async () => {
-            if (this.workspace == null)
-                return false;
-            await this.workspace.abort();
-            this.workspace = undefined;
-            return true;
-        });
-    }
-    async abortAction(referenceOrTxid) {
-        return await this.runExclusive(async () => {
-            const workspace = this.workspace;
-            if (workspace == null)
-                return false;
-            const aborted = workspace.abortAction(referenceOrTxid);
-            if (!aborted)
-                return false;
-            if (workspace.isEmpty) {
-                await workspace.abort();
-                this.workspace = undefined;
-            }
-            return true;
-        });
-    }
-}
-exports.ActionBatchController = ActionBatchController;
-//# sourceMappingURL=ActionBatchWorkspace.js.map