@bsv/wallet-toolbox 2.4.3 → 2.4.20

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

@@ -0,0 +1,869 @@
+"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 actionBatchBootstrap_1 = require("./actionBatchBootstrap");
+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");
+const actionBatchPack_1 = require("../../utility/actionBatchPack");
+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;
+    eagerEnabled = false;
+    eagerLogicalBytes = 0;
+    eagerPending = new Map();
+    eagerUploadLanes;
+    eagerUploadCursor = 0;
+    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);
+        this.eagerUploadLanes = Array.from({
+            length: capabilities.packedUploads == null
+                ? 1
+                : Math.max(1, capabilities.maxConcurrentUploads)
+        }, async () => { });
+    }
+    get usesCompactManifest() {
+        return this.capabilities.manifestVersion === 2;
+    }
+    get packedUploads() {
+        return this.capabilities.packedUploads?.version === 1
+            ? this.capabilities.packedUploads
+            : undefined;
+    }
+    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
+                            ? (0, utilityHelpers_noBuffer_1.asString)((0, ActionBatchPlanner_1.plannerInputLockingScript)(this.state, input))
+                            : 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 rawTx = prior.tx.toUint8Array();
+        const rawTxDigest = (0, actionBatchDigest_1.actionBatchBlobDigest)(rawTx);
+        const lockingScriptDigests = prior.dcr.outputs.map(output => {
+            const lockingScript = prior.tx.outputs[output.vout]?.lockingScript.toHex();
+            if (lockingScript == null) {
+                throw new WERR_errors_1.WERR_INVALID_OPERATION(`missing staged output script for ${txid}.${String(output.vout)}`);
+            }
+            if (lockingScript.length === 0 && !this.usesCompactManifest)
+                return undefined;
+            const digest = (0, actionBatchDigest_1.actionBatchBlobDigest)((0, utilityHelpers_noBuffer_1.asUint8Array)(lockingScript));
+            if (!this.usesCompactManifest)
+                this.lockingScripts.set(digest, lockingScript);
+            return digest;
+        });
+        const compactPlan = {
+            ...prior.dcr,
+            inputBeef: undefined,
+            inputs: prior.dcr.inputs.map(input => ({
+                ...input,
+                sourceLockingScript: this.usesCompactManifest ? undefined : input.sourceLockingScript,
+                sourceTransaction: undefined
+            })),
+            outputs: prior.dcr.outputs.map(output => ({ ...output, lockingScript: '' }))
+        };
+        const action = {
+            reference: prior.reference,
+            txid,
+            rawTxDigest,
+            lockingScriptDigests,
+            deriveLockingScripts: this.usesCompactManifest || undefined,
+            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.queueEagerLogicalBlob(rawTxDigest, rawTx);
+        this.planned.delete(prior.reference);
+        this.scheduleExtensionIfNeeded();
+    }
+    physicalBlobs(logicalDigest, bytes) {
+        const packed = this.packedUploads;
+        const maxPhysicalBytes = packed == null
+            ? this.capabilities.maxBlobBytes
+            : Math.min(this.capabilities.maxBlobBytes, Math.max(1, packed.maxPackBytes - (0, actionBatchPack_1.actionBatchPackLength)([{
+                    digest: logicalDigest,
+                    bytes: new Uint8Array()
+                }])));
+        if (bytes.length <= maxPhysicalBytes) {
+            return { blobs: [{ digest: logicalDigest, bytes }] };
+        }
+        const chunks = [];
+        const blobs = [];
+        for (let offset = 0; offset < bytes.length; offset += maxPhysicalBytes) {
+            const chunk = bytes.subarray(offset, Math.min(bytes.length, offset + maxPhysicalBytes));
+            const digest = (0, actionBatchDigest_1.actionBatchBlobDigest)(chunk);
+            chunks.push(digest);
+            blobs.push({ digest, bytes: chunk });
+        }
+        return { chunks, blobs };
+    }
+    queueEagerLogicalBlob(digest, bytes) {
+        const packed = this.packedUploads;
+        if (packed?.eager !== true || !this.usesCompactManifest)
+            return;
+        const physical = this.physicalBlobs(digest, bytes);
+        for (const blob of physical.blobs) {
+            if (this.eagerPending.has(blob.digest))
+                continue;
+            this.eagerPending.set(blob.digest, blob.bytes);
+            this.eagerLogicalBytes += blob.bytes.length;
+        }
+        if (this.eagerLogicalBytes > this.capabilities.maxInlineBytes) {
+            this.eagerEnabled = true;
+            this.flushEagerPacks(false);
+        }
+    }
+    takePack(final) {
+        const packed = this.packedUploads;
+        if (packed == null || this.eagerPending.size === 0)
+            return [];
+        const items = [];
+        for (const [digest, bytes] of this.eagerPending) {
+            const candidate = [...items, { digest, bytes }];
+            if (candidate.length > packed.maxItems ||
+                (0, actionBatchPack_1.actionBatchPackLength)(candidate) > packed.maxPackBytes)
+                break;
+            items.push({ digest, bytes });
+        }
+        if (items.length === 0)
+            throw new WERR_errors_1.WERR_INVALID_OPERATION('action batch blob cannot fit provider pack');
+        const length = (0, actionBatchPack_1.actionBatchPackLength)(items);
+        if (!final && items.length === this.eagerPending.size &&
+            length < Math.floor(packed.maxPackBytes * 0.9))
+            return [];
+        for (const item of items)
+            this.eagerPending.delete(item.digest);
+        return items;
+    }
+    schedulePackUpload(items) {
+        const packed = this.packedUploads;
+        if (packed == null || items.length === 0)
+            return;
+        const lane = this.eagerUploadCursor++ % this.eagerUploadLanes.length;
+        this.eagerUploadLanes[lane] = this.eagerUploadLanes[lane]
+            .then(async () => {
+            await this.wallet.storage.putActionBatchPack({
+                batchId: this.batchId,
+                items,
+                maxPackBytes: packed.maxPackBytes,
+                maxItems: packed.maxItems,
+                preferredEncodings: packed.encodings
+            });
+        })
+            .catch(() => {
+            // Eager upload is speculative. Prepare remains the source of truth:
+            // anything this attempt did not persist is reported missing and
+            // retried through the ordinary final upload path.
+        });
+    }
+    async awaitEagerUploads() {
+        await Promise.all(this.eagerUploadLanes);
+    }
+    flushEagerPacks(final) {
+        if (!this.eagerEnabled)
+            return;
+        for (;;) {
+            const items = this.takePack(final);
+            if (items.length === 0)
+                return;
+            this.schedulePackUpload(items);
+        }
+    }
+    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; });
+    }
+    addLockingScriptBlobs(blobs) {
+        if (this.usesCompactManifest)
+            return;
+        for (const [digest, script] of this.lockingScripts) {
+            if (!blobs.has(digest))
+                blobs.set(digest, (0, utilityHelpers_noBuffer_1.asUint8Array)(script));
+        }
+    }
+    preparePhysicalUploads(blobs) {
+        const uploadBlobs = new Map();
+        const blobChunks = {};
+        for (const [digest, bytes] of blobs) {
+            const physical = this.physicalBlobs(digest, bytes);
+            for (const blob of physical.blobs) {
+                if (!uploadBlobs.has(blob.digest))
+                    uploadBlobs.set(blob.digest, blob.bytes);
+            }
+            if (physical.chunks != null)
+                blobChunks[digest] = physical.chunks;
+        }
+        return { uploadBlobs, blobChunks };
+    }
+    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, 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 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) => ({
+            ...action,
+            rawTx: undefined,
+            rawTxDigest: addBlob(rawBytes[index])
+        }));
+        const dependencyBeefDigest = addBlob(dependencyBytes);
+        this.addLockingScriptBlobs(blobs);
+        const totalBytes = [...blobs.values()].reduce((sum, bytes) => sum + bytes.length, 0);
+        const useUploads = totalBytes > this.capabilities.maxInlineBytes;
+        if (useUploads)
+            this.queueEagerLogicalBlob(dependencyBeefDigest, dependencyBytes);
+        const { uploadBlobs, blobChunks } = useUploads
+            ? this.preparePhysicalUploads(blobs)
+            : { uploadBlobs: new Map(), blobChunks: {} };
+        const withoutDigest = {
+            format: this.usesCompactManifest ? 2 : undefined,
+            batchId: this.batchId,
+            actions,
+            dependencyBeefDigest,
+            inlineBlobs: useUploads
+                ? undefined
+                : Object.fromEntries(blobs),
+            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) {
+        this.flushEagerPacks(true);
+        await this.awaitEagerUploads();
+        const prepared = await this.wallet.storage.prepareActionBatchCommit(manifest);
+        const missing = new Set(prepared.missingDigests);
+        const pending = uploads.filter(upload => missing.has(upload.digest));
+        const packed = this.packedUploads;
+        if (packed != null && manifest.format === 2) {
+            const packs = [];
+            let current = [];
+            for (const upload of pending) {
+                const candidate = [...current, upload];
+                if (current.length > 0 && (candidate.length > packed.maxItems ||
+                    (0, actionBatchPack_1.actionBatchPackLength)(candidate) > packed.maxPackBytes)) {
+                    packs.push(current);
+                    current = [];
+                }
+                current.push(upload);
+            }
+            if (current.length > 0)
+                packs.push(current);
+            const concurrency = Math.max(1, Math.min(prepared.maxConcurrentUploads, this.capabilities.maxConcurrentUploads, packs.length));
+            let packCursor = 0;
+            await Promise.all(Array.from({ length: concurrency }, async () => {
+                for (;;) {
+                    const pack = packs[packCursor++];
+                    if (pack == null)
+                        return;
+                    await this.wallet.storage.putActionBatchPack({
+                        batchId: this.batchId,
+                        items: pack,
+                        maxPackBytes: packed.maxPackBytes,
+                        maxItems: packed.maxItems,
+                        preferredEncodings: packed.encodings
+                    });
+                }
+            }));
+            return;
+        }
+        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 = uploads.length > 0 && manifest.format === 2 && this.capabilities.commitByDigest === true
+            ? await this.wallet.storage.commitActionBatchByDigest({
+                batchId: manifest.batchId,
+                digest: manifest.digest
+            })
+            : 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}`);
+                if (!this.usesCompactManifest)
+                    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.awaitEagerUploads();
+        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 bootstrap = (0, actionBatchBootstrap_1.actionBatchBootstrap)(args, capabilities);
+        const begin = await this.wallet.storage.beginActionBatch({ ...bootstrap, batchId });
+        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