@bopen-io/wallet-toolbox 2.6.2-brc153.3 → 2.14.5

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActionBatchController = void 0;
 exports.additionalFundingTarget = additionalFundingTarget;
 exports.fundingRunwayExtension = fundingRunwayExtension;
+const validationHelpers_1 = require("@bsv/sdk/wallet/validationHelpers");
 const sdk_1 = require("@bsv/sdk");
 const actionBatchBootstrap_1 = require("./actionBatchBootstrap");
 const WERR_errors_1 = require("../../sdk/WERR_errors");
@@ -16,6 +17,27 @@ const actionBatchPack_1 = require("../../utility/actionBatchPack");
 function mergeUnique(values) {
     return [...new Set(values)];
 }
+function isActionBatchStateError(error) {
+    if (error instanceof WERR_errors_1.WERR_ACTION_BATCH_STATE)
+        return true;
+    if (error == null || typeof error !== 'object')
+        return false;
+    const candidate = error;
+    return ((candidate.name === 'WERR_ACTION_BATCH_STATE' || candidate.code === 'WERR_ACTION_BATCH_STATE') &&
+        typeof candidate.state === 'string');
+}
+function isActionBatchCapacityError(error) {
+    if (error == null || typeof error !== 'object')
+        return false;
+    const candidate = error;
+    const code = candidate.name === 'Error' ? candidate.code : (candidate.name ?? candidate.code);
+    if (code === 'WERR_INVALID_PARAMETER' && candidate.parameter === 'firstAction')
+        return true;
+    return (code === 'WERR_INVALID_OPERATION' &&
+        typeof candidate.message === 'string' &&
+        candidate.message.includes('action batch') &&
+        (candidate.message.includes('maximum') || candidate.message.includes('reserve')));
+}
 function nextGeometricTarget(value) {
     return Math.min(Number.MAX_SAFE_INTEGER, value * 2);
 }
@@ -24,12 +46,9 @@ function additionalFundingTarget(error) {
 }
 function fundingRunwayExtension(runwayTarget, ewmaConfirmedInputs, ewmaConfirmedSatoshis, availableConfirmed) {
     const availableConfirmedCount = availableConfirmed.length;
-    const availableConfirmedSatoshis = availableConfirmed
-        .reduce((sum, output) => sum + output.satoshis, 0);
+    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;
+    const predictedBySatoshis = ewmaConfirmedSatoshis > 0 ? availableConfirmedSatoshis / ewmaConfirmedSatoshis : Number.POSITIVE_INFINITY;
     if (Math.min(predictedByInputs, predictedBySatoshis) >= 2)
         return undefined;
     const nextRunwayTarget = nextGeometricTarget(runwayTarget);
@@ -71,6 +90,7 @@ class ActionBatchWorkspace {
     planned = new Map();
     actions = [];
     lockingScripts = new Map();
+    canResume;
     ewmaConfirmedInputs = 1;
     ewmaConfirmedSatoshis = 0;
     hasConfirmedSample = false;
@@ -90,27 +110,34 @@ class ActionBatchWorkspace {
         this.batchId = begin.batchId;
         this.state = makePlannerState(begin, firstAction);
         this.expiresAt = Date.parse(begin.expiresAt);
+        this.canResume = capabilities.resume === true && wallet.storage.resumeActionBatch != null;
         this.eagerUploadLanes = Array.from({
-            length: capabilities.packedUploads == null
-                ? 1
-                : Math.max(1, capabilities.maxConcurrentUploads)
+            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;
+        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);
+        return Object.entries(this.wallet.pendingSignActions).some(([pendingReference, pending]) => this.planned.has(pendingReference) && pending.tx.id('hex') === reference);
+    }
+    ownsTransaction(txid) {
+        return (this.actions.some(action => action.txid === txid) ||
+            Object.entries(this.wallet.pendingSignActions).some(([reference, pending]) => this.planned.has(reference) && pending.tx.id('hex') === txid));
+    }
+    references(args) {
+        const referencesStagedOutput = [...args.inputs.map(input => input.outpoint), ...args.options.noSendChange].some(outpoint => this.state.staged.has(`${outpoint.txid}.${outpoint.vout}`));
+        return referencesStagedOutput || args.options.sendWith.some(txid => this.ownsTransaction(txid));
+    }
+    referencesSendWith(txids) {
+        return txids.some(txid => this.ownsTransaction(txid));
     }
     get isEmpty() {
         return this.planned.size === 0 && this.actions.length === 0;
@@ -208,9 +235,9 @@ class ActionBatchWorkspace {
                 : undefined,
             spendable: true,
             customInstructions: args.includeCustomInstructions ? output.customInstructions : undefined,
-            tags: args.includeTags ? output.tags ?? [] : undefined,
+            tags: args.includeTags ? (output.tags ?? []) : undefined,
             outpoint,
-            labels: args.includeLabels && output.txid != null ? stagedLabels.get(output.txid) ?? [] : undefined
+            labels: args.includeLabels && output.txid != null ? (stagedLabels.get(output.txid) ?? []) : undefined
         }));
         if (isBalance) {
             const consumedConfirmed = [...this.state.reserved.entries()]
@@ -222,10 +249,7 @@ class ActionBatchWorkspace {
             };
         }
         const persistedUnconsumed = persisted.outputs.filter(output => !consumed.has(output.outpoint));
-        const outputs = [
-            ...persistedUnconsumed,
-            ...staged
-        ];
+        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 = {
@@ -257,12 +281,13 @@ class ActionBatchWorkspace {
         }
     }
     missingExplicitOutpoints(args) {
-        return [...args.inputs.map(input => input.outpoint), ...args.options.noSendChange]
-            .filter(outpoint => {
+        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);
+            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) {
@@ -280,15 +305,46 @@ class ActionBatchWorkspace {
             satoshis: extension.reservedOutputs.reduce((sum, output) => sum + output.satoshis, 0)
         };
     }
+    async resume() {
+        const outpoints = [
+            ...new Map([...this.state.reserved.values(), ...this.state.explicit.values()]
+                .filter(output => output.txid != null)
+                .map(output => [`${output.txid}.${output.vout}`, { txid: output.txid, vout: output.vout }])).values()
+        ];
+        const result = await this.wallet.storage.resumeActionBatch({
+            batchId: this.batchId,
+            outpoints
+        });
+        this.expiresAt = Date.parse(result.expiresAt);
+    }
     async renewIfNeeded() {
-        if (Date.now() >= this.expiresAt)
+        if (Date.now() >= this.expiresAt) {
+            if (this.canResume)
+                await this.resume();
             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; });
+        this.renewal ??= this.wallet.storage
+            .renewActionBatch(this.batchId)
+            .then(result => {
+            this.expiresAt = Date.parse(result.expiresAt);
+        })
+            .catch(async (error) => {
+            if (isActionBatchStateError(error) && error.state === 'expired') {
+                // Providers without the optional resume extension retain the v1
+                // commit-time reacquisition path. Let commit reach it instead of
+                // converting a renewal race into a permanent client-side wedge.
+                if (this.canResume)
+                    await this.resume();
+                return;
+            }
+            throw error;
+        })
+            .finally(() => {
+            this.renewal = undefined;
+        });
         await this.renewal;
     }
     async plan(args) {
@@ -404,10 +460,13 @@ class ActionBatchWorkspace {
         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()
-                }])));
+            : 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 }] };
         }
@@ -444,16 +503,14 @@ class ActionBatchWorkspace {
         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)
+            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))
+        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);
@@ -496,8 +553,7 @@ class ActionBatchWorkspace {
     scheduleExtensionIfNeeded() {
         if (this.extension != null)
             return;
-        const availableConfirmed = [...this.state.reserved.entries()]
-            .filter(([outpoint]) => !this.state.consumed.has(outpoint));
+        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;
@@ -505,13 +561,14 @@ class ActionBatchWorkspace {
             .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) {
+            if (added.outputCount >= request.requestedOutputs && added.satoshis >= request.targetSatoshis) {
                 this.runwayTarget = request.nextRunwayTarget;
             }
         })
             .catch(() => { })
-            .finally(() => { this.extension = undefined; });
+            .finally(() => {
+            this.extension = undefined;
+        });
     }
     addLockingScriptBlobs(blobs) {
         if (this.usesCompactManifest)
@@ -536,8 +593,10 @@ class ActionBatchWorkspace {
         return { uploadBlobs, blobChunks };
     }
     buildManifest(sendWith, isDelayed) {
+        const normalizedSendWith = (0, validationHelpers_1.validateCreateActionOptions)({ sendWith: mergeUnique(sendWith) }).sendWith;
         const stagedTxids = new Set(this.actions.map(action => action.txid));
-        const externalTxids = this.actions.flatMap(action => action.plan.inputs)
+        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();
@@ -573,11 +632,9 @@ class ActionBatchWorkspace {
             batchId: this.batchId,
             actions,
             dependencyBeefDigest,
-            inlineBlobs: useUploads
-                ? undefined
-                : Object.fromEntries(blobs),
+            inlineBlobs: useUploads ? undefined : Object.fromEntries(blobs),
             blobChunks: Object.keys(blobChunks).length === 0 ? undefined : blobChunks,
-            sendWith: mergeUnique(sendWith),
+            sendWith: normalizedSendWith,
             isDelayed
         };
         return {
@@ -597,8 +654,8 @@ class ActionBatchWorkspace {
             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)) {
+                if (current.length > 0 &&
+                    (candidate.length > packed.maxItems || (0, actionBatchPack_1.actionBatchPackLength)(candidate) > packed.maxPackBytes)) {
                     packs.push(current);
                     current = [];
                 }
@@ -647,8 +704,9 @@ class ActionBatchWorkspace {
         if (this.extension != null)
             await this.extension;
         await this.renewIfNeeded();
-        if (this.planned.size > 0)
+        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);
@@ -667,8 +725,7 @@ class ActionBatchWorkspace {
             pendingReference = referenceOrTxid;
         }
         else {
-            pendingReference = Object.entries(this.wallet.pendingSignActions)
-                .find(([reference, pending]) => this.planned.has(reference) && pending.tx.id('hex') === referenceOrTxid)?.[0];
+            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];
@@ -693,11 +750,10 @@ class ActionBatchWorkspace {
         return true;
     }
     hasDependentAction(txid, excludedReference) {
-        if (this.actions.some(action => action.reference !== excludedReference &&
-            action.plan.inputs.some(input => input.sourceTxid === txid)))
+        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));
+        }
+        return [...this.planned.entries()].some(([reference, pending]) => reference !== excludedReference && pending.planned.dcr.inputs.some(input => input.sourceTxid === txid));
     }
     rebuildStagedState() {
         this.state.consumed.clear();
@@ -754,7 +810,9 @@ class ActionBatchController {
         this.wallet = wallet;
         this.mode = mode;
     }
-    get hasWorkspace() { return this.workspace != null; }
+    get hasWorkspace() {
+        return this.workspace != null;
+    }
     overlayListActions(persisted, args) {
         return this.workspace?.overlayListActions(persisted, args) ?? persisted;
     }
@@ -772,8 +830,9 @@ class ActionBatchController {
         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)
+            capabilities = this.wallet.storage
+                .getCapabilities()
+                .then(result => (result.actionBatch?.version === 1 ? result.actionBatch : undefined))
                 .catch(() => undefined);
             this.capabilities.set(activeStore, capabilities);
         }
@@ -791,28 +850,64 @@ class ActionBatchController {
         this.workspace = new ActionBatchWorkspace(this.wallet, begin, args, capabilities);
         return this.workspace;
     }
+    async retire(workspace) {
+        await workspace.abort().catch(() => undefined);
+        if (this.workspace === workspace)
+            this.workspace = undefined;
+    }
+    async recover(workspace, input, isDelayed = false, resume = false) {
+        try {
+            if (resume)
+                await workspace.resume();
+            return Array.isArray(input) ? await workspace.commit(input, isDelayed) : await workspace.plan(input);
+        }
+        catch (error) {
+            if (!resume && isActionBatchStateError(error) && error.state === 'expired' && workspace.canResume) {
+                return await this.recover(workspace, input, isDelayed, true);
+            }
+            // A soft-expired version-1 batch still has a compatible commit-time
+            // reacquisition path. Only terminal lifecycle errors retire it here.
+            if (isActionBatchStateError(error) && error.state !== 'expired')
+                await this.retire(workspace);
+            throw error;
+        }
+    }
     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)
+            const workspace = this.workspace;
+            if (workspace != null) {
+                // Workspace membership is an explicit transaction-graph relationship.
+                // Time adjacency, a shared Wallet instance, or a shared originator are
+                // not sufficient: unrelated work must remain on the legacy path.
+                if (!workspace.references(args))
                     return undefined;
-                workspace = await this.begin(args);
-                if (workspace == null)
+                return await this.recover(workspace, args);
+            }
+            if (!args.isNoSend)
+                return undefined;
+            let begun;
+            try {
+                begun = await this.begin(args);
+            }
+            catch (error) {
+                // The reservation ceiling bounds the optimization, not the public
+                // createAction contract. A first action that cannot fit must retain
+                // the pre-batch persistence path.
+                if (isActionBatchCapacityError(error))
                     return undefined;
-                beganWorkspace = true;
+                throw error;
             }
+            if (begun == null)
+                return undefined;
             try {
-                return await workspace.plan(args);
+                return await begun.plan(args);
             }
             catch (error) {
-                if (beganWorkspace) {
-                    await workspace.abort();
-                    this.workspace = undefined;
-                }
+                await this.retire(begun);
+                if (isActionBatchCapacityError(error))
+                    return undefined;
                 throw error;
             }
         });
@@ -824,15 +919,33 @@ class ActionBatchController {
                 return undefined;
             if (prior != null && !workspace.ownsReference(prior.reference))
                 return undefined;
+            if (prior == null && !workspace.referencesSendWith(args.options.sendWith))
+                return undefined;
             if (prior != null)
                 workspace.stage(prior, args);
-            const shouldCommit = args.isSendWith || (prior != null && !args.isNoSend);
+            const referencesWorkspace = workspace.referencesSendWith(args.options.sendWith);
+            if (prior != null && args.isNoSend && args.isSendWith && !referencesWorkspace) {
+                // The new action belongs to the workspace, but its explicit sendWith
+                // list does not. Preserve the staged action and fulfill the unrelated
+                // broadcast through the ordinary path; returning an empty result here
+                // would silently drop an explicit caller request.
+                return await this.wallet.storage.processAction({
+                    isNewTx: false,
+                    isSendWith: true,
+                    isNoSend: false,
+                    isDelayed: args.isDelayed,
+                    sendWith: [...args.options.sendWith],
+                    logger: args.logger
+                });
+            }
+            const shouldCommit = referencesWorkspace || (prior != null && !args.isNoSend);
             if (!shouldCommit)
                 return { sendWithResults: [] };
             const sendWith = [...args.options.sendWith];
-            if (prior != null && !args.isNoSend && !sendWith.includes(prior.tx.id('hex')))
+            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);
+            }
+            const result = await this.recover(workspace, sendWith, args.isDelayed);
             this.workspace = undefined;
             return result;
         });