@bsv/wallet-toolbox 2.1.25 → 3.0.0-alpha.0

package/out/src/storage/schema/__tests/processingFsmLegacyMapping.test.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const processingFsm_1 = require("../processingFsm");
+const legacyMappingCases = [
+    // §4 trigger: processAction / isNoSend && !isSendWith → "nosend → nosend"
+    // queued (pre-send) → nosend
+    { legacy: 'processAction nosend mark', from: 'queued', to: 'nosend' },
+    // §4 trigger: processAction delayed broadcast (collapses to queued → queued
+    // via `nextActionAt`); covered by identity rule but listed for completeness.
+    { legacy: 'processAction delayed (identity)', from: 'queued', to: 'queued' },
+    // §4 trigger: processAction pre-broadcast → "queued → broadcasting"
+    // queued → sending (sending = "in flight" per ProcessingStatus jsdoc)
+    { legacy: 'processAction pre-broadcast', from: 'queued', to: 'sending' },
+    // §4 trigger: processAction post-broadcast → "broadcasting → broadcasted"
+    // sending → sent (handoff acknowledged)
+    { legacy: 'processAction post-broadcast (handoff)', from: 'sending', to: 'sent' },
+    // §4 trigger: same post-broadcast path may land at `seen` when the provider
+    // ack arrives with a first observation, not just a queue receipt.
+    { legacy: 'processAction post-broadcast (seen)', from: 'sending', to: 'seen' },
+    // §4 trigger: internalizeAction bump-absent → "unsent → unproven"
+    // queued → sent (rawTx exists, handoff implied by bump-absent path)
+    { legacy: 'internalizeAction bump-absent', from: 'queued', to: 'sent' },
+    // §4 trigger: attemptToPostReqsToNetwork / `invalid` → "* → invalid"
+    // each non-terminal state that may host a tx during the attempt loop.
+    { legacy: 'attemptToPost invalid (from queued)', from: 'queued', to: 'invalid' },
+    { legacy: 'attemptToPost invalid (from sending)', from: 'sending', to: 'invalid' },
+    { legacy: 'attemptToPost invalid (from sent)', from: 'sent', to: 'invalid' },
+    { legacy: 'attemptToPost invalid (from seen)', from: 'seen', to: 'invalid' },
+    { legacy: 'attemptToPost invalid (from seen_multi)', from: 'seen_multi', to: 'invalid' },
+    { legacy: 'attemptToPost invalid (from unconfirmed)', from: 'unconfirmed', to: 'invalid' },
+    // NOTE: `reorging → invalid` is intentionally NOT a legal direct edge per
+    // bsv_wallet_transaction_requirements v1.0 §5: "A reorg SHALL never cause
+    // a transaction to be marked Invalid or DoubleSpend." Callers must first
+    // transition reorging → unconfirmed (or another recovery state) before
+    // marking invalid.
+    { legacy: 'attemptToPost invalid (from nosend)', from: 'nosend', to: 'invalid' },
+    { legacy: 'attemptToPost invalid (from nonfinal)', from: 'nonfinal', to: 'invalid' },
+    // §4 trigger: attemptToPost success → "broadcasting → broadcasted" with
+    // wasBroadcast=true. new-schema: sending → sent. Also covers queued → sent on the
+    // bump-absent path executed inside the attempt loop.
+    { legacy: 'attemptToPost success (queued)', from: 'queued', to: 'sent' },
+    { legacy: 'attemptToPost success (sending)', from: 'sending', to: 'sent' },
+    // §4 trigger: attemptToPost doubleSpend → "* → doubleSpend" (terminal).
+    // every non-terminal state that may host a tx when a doubleSpend
+    // notification arrives.
+    { legacy: 'attemptToPost doubleSpend (from queued)', from: 'queued', to: 'doubleSpend' },
+    { legacy: 'attemptToPost doubleSpend (from sending)', from: 'sending', to: 'doubleSpend' },
+    { legacy: 'attemptToPost doubleSpend (from sent)', from: 'sent', to: 'doubleSpend' },
+    { legacy: 'attemptToPost doubleSpend (from seen)', from: 'seen', to: 'doubleSpend' },
+    { legacy: 'attemptToPost doubleSpend (from seen_multi)', from: 'seen_multi', to: 'doubleSpend' },
+    { legacy: 'attemptToPost doubleSpend (from unconfirmed)', from: 'unconfirmed', to: 'doubleSpend' },
+    // NOTE: `reorging → doubleSpend` is intentionally NOT a legal direct edge.
+    // See note above for reorging → invalid; same spec rationale applies.
+    { legacy: 'attemptToPost doubleSpend (from nosend)', from: 'nosend', to: 'doubleSpend' },
+    { legacy: 'attemptToPost doubleSpend (from nonfinal)', from: 'nonfinal', to: 'doubleSpend' },
+    // §4 trigger: attemptToPost serviceError → "* → sending + attempts++".
+    // retry path from any state where a live re-broadcast makes sense.
+    // Excludes terminal states (invalid/doubleSpend/proven enter via unfail or
+    // reorging, not directly) and excludes `frozen` (operator-paused).
+    { legacy: 'attemptToPost serviceError retry (from queued)', from: 'queued', to: 'sending' },
+    { legacy: 'attemptToPost serviceError retry (self-retry)', from: 'sending', to: 'sending' },
+    { legacy: 'attemptToPost serviceError retry (from sent)', from: 'sent', to: 'sending' },
+    { legacy: 'attemptToPost serviceError retry (from seen)', from: 'seen', to: 'sending' },
+    { legacy: 'attemptToPost serviceError retry (from seen_multi)', from: 'seen_multi', to: 'sending' },
+    { legacy: 'attemptToPost serviceError retry (from unconfirmed)', from: 'unconfirmed', to: 'sending' },
+    { legacy: 'attemptToPost serviceError retry (from nosend)', from: 'nosend', to: 'sending' },
+    { legacy: 'attemptToPost serviceError retry (from nonfinal)', from: 'nonfinal', to: 'sending' },
+    // §4 trigger: Monitor proof → "* → confirmed". new-schema: only states that have
+    // observed the tx on-chain may transition to confirmed directly (terminal
+    // proof). Pre-observation states must pass through `seen`/`unconfirmed`
+    // first — enforced by the FSM, not asserted here.
+    { legacy: 'Monitor proof (from seen)', from: 'seen', to: 'confirmed' },
+    { legacy: 'Monitor proof (from seen_multi)', from: 'seen_multi', to: 'confirmed' },
+    { legacy: 'Monitor proof (from unconfirmed)', from: 'unconfirmed', to: 'confirmed' },
+    { legacy: 'Monitor proof (from reorging)', from: 'reorging', to: 'confirmed' }
+];
+describe('Processing FSM legacy mapping coverage (STORAGE_METHOD_WIRING §4)', () => {
+    it.each(legacyMappingCases)('$legacy: $from -> $to is permitted', ({ from, to }) => {
+        expect((0, processingFsm_1.isValidProcessingTransition)(from, to)).toBe(true);
+    });
+});
+//# sourceMappingURL=processingFsmLegacyMapping.test.js.map

package/out/src/storage/schema/__tests/processingFsmLegacyMapping.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"processingFsmLegacyMapping.test.js","sourceRoot":"","sources":["../../../../../src/storage/schema/__tests/processingFsmLegacyMapping.test.ts"],"names":[],"mappings":"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"}

package/out/src/storage/schema/__tests/spendabilityRule.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=spendabilityRule.test.d.ts.map

package/out/src/storage/schema/__tests/spendabilityRule.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spendabilityRule.test.d.ts","sourceRoot":"","sources":["../../../../../src/storage/schema/__tests/spendabilityRule.test.ts"],"names":[],"mappings":""}

package/out/src/storage/schema/__tests/spendabilityRule.test.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const spendabilityRule_1 = require("../spendabilityRule");
+describe('Spendability rules', () => {
+    const tip = { height: 1000 };
+    test('non-spendable processing state rejects', () => {
+        expect((0, spendabilityRule_1.isOutputSpendable)({ spentBy: null, lockingScript: [0x76] }, { processing: 'queued' }, tip)).toBe(false);
+        expect((0, spendabilityRule_1.isOutputSpendable)({ spentBy: null, lockingScript: [0x76] }, { processing: 'invalid' }, tip)).toBe(false);
+    });
+    test('spent output rejects', () => {
+        expect((0, spendabilityRule_1.isOutputSpendable)({ spentBy: 7, lockingScript: [0x76] }, { processing: 'confirmed' }, tip)).toBe(false);
+    });
+    test('missing locking script rejects', () => {
+        expect((0, spendabilityRule_1.isOutputSpendable)({ spentBy: null, lockingScript: null }, { processing: 'confirmed' }, tip)).toBe(false);
+    });
+    test('immature coinbase rejects', () => {
+        expect((0, spendabilityRule_1.isOutputSpendable)({ spentBy: null, lockingScript: [0x76], isCoinbase: true, maturesAtHeight: 1001 }, { processing: 'confirmed' }, tip)).toBe(false);
+    });
+    test('mature coinbase passes', () => {
+        expect((0, spendabilityRule_1.isOutputSpendable)({ spentBy: null, lockingScript: [0x76], isCoinbase: true, maturesAtHeight: 1000 }, { processing: 'confirmed' }, tip)).toBe(true);
+    });
+    test('non-coinbase spendable in sent state', () => {
+        expect((0, spendabilityRule_1.isOutputSpendable)({ spentBy: null, lockingScript: [0x76], isCoinbase: false }, { processing: 'sent' }, tip)).toBe(true);
+    });
+    test('coinbase without chain tip cannot mature', () => {
+        expect((0, spendabilityRule_1.isOutputSpendable)({ spentBy: null, lockingScript: [0x76], isCoinbase: true, maturesAtHeight: 100 }, { processing: 'confirmed' }, undefined)).toBe(false);
+    });
+});
+//# sourceMappingURL=spendabilityRule.test.js.map

package/out/src/storage/schema/__tests/spendabilityRule.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spendabilityRule.test.js","sourceRoot":"","sources":["../../../../../src/storage/schema/__tests/spendabilityRule.test.ts"],"names":[],"mappings":"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"}

package/out/src/storage/schema/__tests/v7FsmLegacyMapping.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=v7FsmLegacyMapping.test.d.ts.map

package/out/src/storage/schema/__tests/v7FsmLegacyMapping.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v7FsmLegacyMapping.test.d.ts","sourceRoot":"","sources":["../../../../../src/storage/schema/__tests/v7FsmLegacyMapping.test.ts"],"names":[],"mappings":""}

package/out/src/storage/schema/__tests/v7FsmLegacyMapping.test.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const v7Fsm_1 = require("../v7Fsm");
+const legacyMappingCases = [
+    // §4 trigger: processAction / isNoSend && !isSendWith → "nosend → nosend"
+    // V7: queued (pre-send) → nosend
+    { legacy: 'processAction nosend mark', from: 'queued', to: 'nosend' },
+    // §4 trigger: processAction delayed broadcast (collapses to queued → queued
+    // via `nextActionAt`); covered by identity rule but listed for completeness.
+    { legacy: 'processAction delayed (identity)', from: 'queued', to: 'queued' },
+    // §4 trigger: processAction pre-broadcast → "queued → broadcasting"
+    // V7: queued → sending (sending = "in flight" per ProcessingStatus jsdoc)
+    { legacy: 'processAction pre-broadcast', from: 'queued', to: 'sending' },
+    // §4 trigger: processAction post-broadcast → "broadcasting → broadcasted"
+    // V7: sending → sent (handoff acknowledged)
+    { legacy: 'processAction post-broadcast (handoff)', from: 'sending', to: 'sent' },
+    // §4 trigger: same post-broadcast path may land at `seen` when the provider
+    // ack arrives with a first observation, not just a queue receipt.
+    { legacy: 'processAction post-broadcast (seen)', from: 'sending', to: 'seen' },
+    // §4 trigger: internalizeAction bump-absent → "unsent → unproven"
+    // V7: queued → sent (rawTx exists, handoff implied by bump-absent path)
+    { legacy: 'internalizeAction bump-absent', from: 'queued', to: 'sent' },
+    // §4 trigger: attemptToPostReqsToNetwork / `invalid` → "* → invalid"
+    // V7: each non-terminal state that may host a tx during the attempt loop.
+    { legacy: 'attemptToPost invalid (from queued)', from: 'queued', to: 'invalid' },
+    { legacy: 'attemptToPost invalid (from sending)', from: 'sending', to: 'invalid' },
+    { legacy: 'attemptToPost invalid (from sent)', from: 'sent', to: 'invalid' },
+    { legacy: 'attemptToPost invalid (from seen)', from: 'seen', to: 'invalid' },
+    { legacy: 'attemptToPost invalid (from seen_multi)', from: 'seen_multi', to: 'invalid' },
+    { legacy: 'attemptToPost invalid (from unconfirmed)', from: 'unconfirmed', to: 'invalid' },
+    { legacy: 'attemptToPost invalid (from reorging)', from: 'reorging', to: 'invalid' },
+    { legacy: 'attemptToPost invalid (from nosend)', from: 'nosend', to: 'invalid' },
+    { legacy: 'attemptToPost invalid (from nonfinal)', from: 'nonfinal', to: 'invalid' },
+    // §4 trigger: attemptToPost success → "broadcasting → broadcasted" with
+    // wasBroadcast=true. V7: sending → sent. Also covers queued → sent on the
+    // bump-absent path executed inside the attempt loop.
+    { legacy: 'attemptToPost success (queued)', from: 'queued', to: 'sent' },
+    { legacy: 'attemptToPost success (sending)', from: 'sending', to: 'sent' },
+    // §4 trigger: attemptToPost doubleSpend → "* → doubleSpend" (terminal).
+    // V7: every non-terminal state that may host a tx when a doubleSpend
+    // notification arrives.
+    { legacy: 'attemptToPost doubleSpend (from queued)', from: 'queued', to: 'doubleSpend' },
+    { legacy: 'attemptToPost doubleSpend (from sending)', from: 'sending', to: 'doubleSpend' },
+    { legacy: 'attemptToPost doubleSpend (from sent)', from: 'sent', to: 'doubleSpend' },
+    { legacy: 'attemptToPost doubleSpend (from seen)', from: 'seen', to: 'doubleSpend' },
+    { legacy: 'attemptToPost doubleSpend (from seen_multi)', from: 'seen_multi', to: 'doubleSpend' },
+    { legacy: 'attemptToPost doubleSpend (from unconfirmed)', from: 'unconfirmed', to: 'doubleSpend' },
+    { legacy: 'attemptToPost doubleSpend (from reorging)', from: 'reorging', to: 'doubleSpend' },
+    { legacy: 'attemptToPost doubleSpend (from nosend)', from: 'nosend', to: 'doubleSpend' },
+    { legacy: 'attemptToPost doubleSpend (from nonfinal)', from: 'nonfinal', to: 'doubleSpend' },
+    // §4 trigger: attemptToPost serviceError → "* → sending + attempts++".
+    // V7: retry path from any state where a live re-broadcast makes sense.
+    // Excludes terminal states (invalid/doubleSpend/proven enter via unfail or
+    // reorging, not directly) and excludes `frozen` (operator-paused).
+    { legacy: 'attemptToPost serviceError retry (from queued)', from: 'queued', to: 'sending' },
+    { legacy: 'attemptToPost serviceError retry (self-retry)', from: 'sending', to: 'sending' },
+    { legacy: 'attemptToPost serviceError retry (from sent)', from: 'sent', to: 'sending' },
+    { legacy: 'attemptToPost serviceError retry (from seen)', from: 'seen', to: 'sending' },
+    { legacy: 'attemptToPost serviceError retry (from seen_multi)', from: 'seen_multi', to: 'sending' },
+    { legacy: 'attemptToPost serviceError retry (from unconfirmed)', from: 'unconfirmed', to: 'sending' },
+    { legacy: 'attemptToPost serviceError retry (from nosend)', from: 'nosend', to: 'sending' },
+    { legacy: 'attemptToPost serviceError retry (from nonfinal)', from: 'nonfinal', to: 'sending' },
+    // §4 trigger: Monitor proof → "* → proven". V7: only states that have
+    // observed the tx on-chain may transition to proven directly (terminal
+    // proof). Pre-observation states must pass through `seen`/`unconfirmed`
+    // first — enforced by the FSM, not asserted here.
+    { legacy: 'Monitor proof (from seen)', from: 'seen', to: 'proven' },
+    { legacy: 'Monitor proof (from seen_multi)', from: 'seen_multi', to: 'proven' },
+    { legacy: 'Monitor proof (from unconfirmed)', from: 'unconfirmed', to: 'proven' },
+    { legacy: 'Monitor proof (from reorging)', from: 'reorging', to: 'proven' }
+];
+describe('v7Fsm legacy mapping coverage (V7_STORAGE_METHOD_WIRING §4)', () => {
+    it.each(legacyMappingCases)('$legacy: $from -> $to is permitted', ({ from, to }) => {
+        expect((0, v7Fsm_1.isValidProcessingTransition)(from, to)).toBe(true);
+    });
+});
+//# sourceMappingURL=v7FsmLegacyMapping.test.js.map

package/out/src/storage/schema/__tests/v7FsmLegacyMapping.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"v7FsmLegacyMapping.test.js","sourceRoot":"","sources":["../../../../../src/storage/schema/__tests/v7FsmLegacyMapping.test.ts"],"names":[],"mappings":"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"}

package/out/src/storage/schema/backfill.d.ts

@@ -0,0 +1,35 @@
+import { TableAction, TableProvenTx, TableProvenTxReq, TableTransaction, TableTransactionNew } from './tables';
+/**
+ * Pure transformation helpers for the the new schema backfill.
+ *
+ * These functions are deliberately storage-agnostic — they accept the legacy
+ * rows and return the new shapes. A storage driver (Knex or IDB) is responsible
+ * for reading the source rows and inserting the returned objects.
+ *
+ * No row in this module ever talks to the database; this keeps the
+ * transformation under unit-test control and lets us run dry-run migrations.
+ */
+/**
+ * Merge a legacy `proven_tx_reqs` row together with an optional `proven_txs`
+ * row into a single new `transactions` (transactions_new) row.
+ *
+ * The proof fields come from `proven_txs` when present; otherwise they are
+ * left undefined. Processing state is derived from the request's legacy status.
+ */
+export declare function buildTransactionNewRow(req: TableProvenTxReq, proven: TableProvenTx | undefined, now?: Date): Omit<TableTransactionNew, 'transactionId'>;
+/**
+ * Build a new `transactions` row from a legacy per-user `transactions` row when
+ * no `proven_tx_reqs` entry exists (e.g. locally-created actions that never
+ * reached the broadcast queue).
+ *
+ * Returns `undefined` when the legacy row has no txid — such rows belong to
+ * incomplete actions and have no canonical new-schema representation yet.
+ */
+export declare function buildTransactionNewRowFromLegacyTx(tx: TableTransaction, now?: Date): Omit<TableTransactionNew, 'transactionId'> | undefined;
+/**
+ * Build a new `actions` row from a legacy per-user `transactions` row.
+ * The caller is responsible for resolving `transactionId` to the
+ * newly-inserted `transactions_new.transactionId`.
+ */
+export declare function buildActionRow(legacy: TableTransaction, newTransactionId: number, now?: Date): Omit<TableAction, 'actionId'>;
+//# sourceMappingURL=backfill.d.ts.map

package/out/src/storage/schema/backfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backfill.d.ts","sourceRoot":"","sources":["../../../../src/storage/schema/backfill.ts"],"names":[],"mappings":"AACA,OAAO,EACL,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,UAAU,CAAA;AAEjB;;;;;;;;;GASG;AAEH;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,gBAAgB,EACrB,MAAM,EAAE,aAAa,GAAG,SAAS,EACjC,GAAG,GAAE,IAAiB,GACrB,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC,CA2B5C;AAED;;;;;;;GAOG;AACH,wBAAgB,kCAAkC,CAChD,EAAE,EAAE,gBAAgB,EACpB,GAAG,GAAE,IAAiB,GACrB,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC,GAAG,SAAS,CA8BxD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,gBAAgB,EACxB,gBAAgB,EAAE,MAAM,EACxB,GAAG,GAAE,IAAiB,GACrB,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,CAgB/B"}

package/out/src/storage/schema/backfill.idb.d.ts

@@ -0,0 +1,32 @@
+import { IDBPDatabase, IDBPTransaction } from 'idb';
+import { StorageIdbSchema } from './StorageIdbSchema';
+import { TableAction, TableProvenTx, TableProvenTxReq, TableTransaction, TableTransactionNew } from './tables';
+import { BackfillDriver, BackfillStats } from './backfill.runner';
+type IdbStoreName = keyof StorageIdbSchema;
+/**
+ * IndexedDB driver for the the backfill.
+ *
+ * The orchestrator is driven entirely from this driver inside a single
+ * `readwrite` transaction across the legacy + new-schema stores. The streams cache
+ * the keys up-front (`getAllKeys`) and then walk them one at a time so the
+ * idb cursor lifetime does not span an external `await`.
+ */
+export declare class IdbBackfillDriver implements BackfillDriver {
+    private readonly trx;
+    constructor(trx: IDBPTransaction<StorageIdbSchema, IdbStoreName[], 'readwrite'>);
+    streamLegacyReqs(): AsyncIterable<{
+        req: TableProvenTxReq;
+        proven?: TableProvenTx;
+    }>;
+    streamLegacyTransactions(): AsyncIterable<TableTransaction>;
+    upsertTransactionNew(row: Omit<TableTransactionNew, 'transactionId'>): Promise<number>;
+    upsertAction(row: Omit<TableAction, 'actionId'>): Promise<number>;
+    repointTxLabelMap(legacyTransactionId: number, actionId: number): Promise<void>;
+}
+/**
+ * Convenience entry point that opens the required readwrite transaction and
+ * runs the orchestrator against it.
+ */
+export declare function runIdbBackfill(db: IDBPDatabase<StorageIdbSchema>, now?: Date): Promise<BackfillStats>;
+export {};
+//# sourceMappingURL=backfill.idb.d.ts.map

package/out/src/storage/schema/backfill.idb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backfill.idb.d.ts","sourceRoot":"","sources":["../../../../src/storage/schema/backfill.idb.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,KAAK,CAAA;AACnD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AACrD,OAAO,EACL,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,UAAU,CAAA;AACjB,OAAO,EAAe,cAAc,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAE9E,KAAK,YAAY,GAAG,MAAM,gBAAgB,CAAA;AAW1C;;;;;;;GAOG;AACH,qBAAa,iBAAkB,YAAW,cAAc;IAEpD,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAAH,GAAG,EAAE,eAAe,CAAC,gBAAgB,EAAE,YAAY,EAAE,EAAE,WAAW,CAAC;IAG9E,gBAAgB,IAAK,aAAa,CAAC;QAAE,GAAG,EAAE,gBAAgB,CAAC;QAAC,MAAM,CAAC,EAAE,aAAa,CAAA;KAAE,CAAC;IAYrF,wBAAwB,IAAK,aAAa,CAAC,gBAAgB,CAAC;IAS9D,oBAAoB,CAAE,GAAG,EAAE,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAavF,YAAY,CAAE,GAAG,EAAE,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAalE,iBAAiB,CAAE,mBAAmB,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAWvF;AAED;;;GAGG;AACH,wBAAsB,cAAc,CAClC,EAAE,EAAE,YAAY,CAAC,gBAAgB,CAAC,EAClC,GAAG,GAAE,IAAiB,GACrB,OAAO,CAAC,aAAa,CAAC,CAMxB"}

package/out/src/storage/schema/backfill.idb.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdbBackfillDriver = void 0;
+exports.runIdbBackfill = runIdbBackfill;
+const backfill_runner_1 = require("./backfill.runner");
+const BACKFILL_STORES = [
+    'proven_tx_reqs',
+    'proven_txs',
+    'transactions',
+    'transactions_new',
+    'actions',
+    'tx_labels_map'
+];
+/**
+ * IndexedDB driver for the the backfill.
+ *
+ * The orchestrator is driven entirely from this driver inside a single
+ * `readwrite` transaction across the legacy + new-schema stores. The streams cache
+ * the keys up-front (`getAllKeys`) and then walk them one at a time so the
+ * idb cursor lifetime does not span an external `await`.
+ */
+class IdbBackfillDriver {
+    constructor(trx) {
+        this.trx = trx;
+    }
+    async *streamLegacyReqs() {
+        const reqStore = this.trx.objectStore('proven_tx_reqs');
+        const provenStore = this.trx.objectStore('proven_txs');
+        const reqKeys = await reqStore.getAllKeys();
+        for (const key of reqKeys) {
+            const req = await reqStore.get(key);
+            let proven;
+            if (req.provenTxId != null)
+                proven = await provenStore.get(req.provenTxId);
+            yield { req, proven };
+        }
+    }
+    async *streamLegacyTransactions() {
+        const store = this.trx.objectStore('transactions');
+        const keys = await store.getAllKeys();
+        for (const key of keys) {
+            const row = await store.get(key);
+            yield row;
+        }
+    }
+    async upsertTransactionNew(row) {
+        const store = this.trx.objectStore('transactions_new');
+        const txidIndex = store.index('txid');
+        const existing = await txidIndex.get(row.txid);
+        if (existing != null) {
+            const merged = { ...existing, ...row, transactionId: existing.transactionId };
+            await store.put(merged);
+            return existing.transactionId;
+        }
+        const newId = await store.add(row);
+        return newId;
+    }
+    async upsertAction(row) {
+        const store = this.trx.objectStore('actions');
+        const idx = store.index('userId_transactionId');
+        const existing = await idx.get([row.userId, row.transactionId]);
+        if (existing != null) {
+            const merged = { ...existing, ...row, actionId: existing.actionId };
+            await store.put(merged);
+            return existing.actionId;
+        }
+        const newId = await store.add(row);
+        return newId;
+    }
+    async repointTxLabelMap(legacyTransactionId, actionId) {
+        if (legacyTransactionId === actionId)
+            return;
+        const store = this.trx.objectStore('tx_labels_map');
+        const idx = store.index('transactionId');
+        const matches = await idx.getAll(legacyTransactionId);
+        for (const m of matches) {
+            const updated = { ...m, transactionId: actionId };
+            await store.delete([m.txLabelId, legacyTransactionId]);
+            await store.add(updated);
+        }
+    }
+}
+exports.IdbBackfillDriver = IdbBackfillDriver;
+/**
+ * Convenience entry point that opens the required readwrite transaction and
+ * runs the orchestrator against it.
+ */
+async function runIdbBackfill(db, now = new Date()) {
+    const trx = db.transaction(BACKFILL_STORES, 'readwrite');
+    const driver = new IdbBackfillDriver(trx);
+    const stats = await (0, backfill_runner_1.runBackfill)(driver, now);
+    await trx.done;
+    return stats;
+}
+//# sourceMappingURL=backfill.idb.js.map

package/out/src/storage/schema/backfill.idb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backfill.idb.js","sourceRoot":"","sources":["../../../../src/storage/schema/backfill.idb.ts"],"names":[],"mappings":"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"}

package/out/src/storage/schema/backfill.js

@@ -0,0 +1,150 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTransactionNewRow = buildTransactionNewRow;
+exports.buildTransactionNewRowFromLegacyTx = buildTransactionNewRowFromLegacyTx;
+exports.buildActionRow = buildActionRow;
+const sdk = __importStar(require("../../sdk"));
+/**
+ * Pure transformation helpers for the the new schema backfill.
+ *
+ * These functions are deliberately storage-agnostic — they accept the legacy
+ * rows and return the new shapes. A storage driver (Knex or IDB) is responsible
+ * for reading the source rows and inserting the returned objects.
+ *
+ * No row in this module ever talks to the database; this keeps the
+ * transformation under unit-test control and lets us run dry-run migrations.
+ */
+/**
+ * Merge a legacy `proven_tx_reqs` row together with an optional `proven_txs`
+ * row into a single new `transactions` (transactions_new) row.
+ *
+ * The proof fields come from `proven_txs` when present; otherwise they are
+ * left undefined. Processing state is derived from the request's legacy status.
+ */
+function buildTransactionNewRow(req, proven, now = new Date()) {
+    var _a, _b, _c;
+    const processing = sdk.provenTxReqStatusToProcessing(req.status);
+    return {
+        created_at: req.created_at,
+        updated_at: now,
+        txid: req.txid,
+        processing,
+        processingChangedAt: (_a = req.updated_at) !== null && _a !== void 0 ? _a : now,
+        nextActionAt: undefined,
+        attempts: (_b = req.attempts) !== null && _b !== void 0 ? _b : 0,
+        rebroadcastCycles: (_c = req.rebroadcastAttempts) !== null && _c !== void 0 ? _c : 0,
+        wasBroadcast: req.wasBroadcast === true,
+        idempotencyKey: undefined,
+        batch: req.batch,
+        rawTx: req.rawTx,
+        inputBeef: req.inputBEEF,
+        height: proven === null || proven === void 0 ? void 0 : proven.height,
+        merkleIndex: proven === null || proven === void 0 ? void 0 : proven.index,
+        merklePath: proven === null || proven === void 0 ? void 0 : proven.merklePath,
+        merkleRoot: proven === null || proven === void 0 ? void 0 : proven.merkleRoot,
+        blockHash: proven === null || proven === void 0 ? void 0 : proven.blockHash,
+        isCoinbase: false,
+        lastProvider: undefined,
+        lastProviderStatus: undefined,
+        frozenReason: undefined,
+        rowVersion: 0
+    };
+}
+/**
+ * Build a new `transactions` row from a legacy per-user `transactions` row when
+ * no `proven_tx_reqs` entry exists (e.g. locally-created actions that never
+ * reached the broadcast queue).
+ *
+ * Returns `undefined` when the legacy row has no txid — such rows belong to
+ * incomplete actions and have no canonical new-schema representation yet.
+ */
+function buildTransactionNewRowFromLegacyTx(tx, now = new Date()) {
+    var _a;
+    if (tx.txid == null)
+        return undefined;
+    // Unsigned/unprocessed transactions may have an empty-string txid.
+    // Give them a stable placeholder so each gets its own new schema row and actions entry.
+    const txid = tx.txid === '' ? `pending:legacy:${tx.transactionId}` : tx.txid;
+    return {
+        created_at: tx.created_at,
+        updated_at: now,
+        txid,
+        processing: sdk.transactionStatusToProcessing(tx.status),
+        processingChangedAt: (_a = tx.updated_at) !== null && _a !== void 0 ? _a : now,
+        nextActionAt: undefined,
+        attempts: 0,
+        rebroadcastCycles: 0,
+        wasBroadcast: false,
+        idempotencyKey: undefined,
+        batch: undefined,
+        rawTx: tx.rawTx,
+        inputBeef: tx.inputBEEF,
+        height: undefined,
+        merkleIndex: undefined,
+        merklePath: undefined,
+        merkleRoot: undefined,
+        blockHash: undefined,
+        isCoinbase: false,
+        lastProvider: undefined,
+        lastProviderStatus: undefined,
+        frozenReason: undefined,
+        rowVersion: 0
+    };
+}
+/**
+ * Build a new `actions` row from a legacy per-user `transactions` row.
+ * The caller is responsible for resolving `transactionId` to the
+ * newly-inserted `transactions_new.transactionId`.
+ */
+function buildActionRow(legacy, newTransactionId, now = new Date()) {
+    var _a;
+    return {
+        created_at: legacy.created_at,
+        updated_at: now,
+        userId: legacy.userId,
+        transactionId: newTransactionId,
+        reference: legacy.reference,
+        description: legacy.description,
+        isOutgoing: legacy.isOutgoing,
+        satoshisDelta: (_a = legacy.satoshis) !== null && _a !== void 0 ? _a : 0,
+        userNosend: legacy.status === 'nosend',
+        hidden: false,
+        userAborted: legacy.status === 'failed',
+        notifyJson: undefined,
+        rowVersion: 0
+    };
+}
+//# sourceMappingURL=backfill.js.map

package/out/src/storage/schema/backfill.js.map

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

package/out/src/storage/schema/backfill.knex.d.ts

@@ -0,0 +1,32 @@
+import { Knex } from 'knex';
+import { TableAction, TableProvenTx, TableProvenTxReq, TableTransaction, TableTransactionNew } from './tables';
+import { BackfillDriver, BackfillStats } from './backfill.runner';
+/**
+ * Knex driver for the the backfill.
+ *
+ * Reads from the legacy `proven_tx_reqs`, `proven_txs`, and `transactions`
+ * tables, writes into the new `transactions_new` and `actions` tables, and
+ * re-points `tx_labels_map` rows to the new `actionId`.
+ *
+ * All work is performed against the `knex` (or transaction) handle passed in.
+ * The caller is responsible for opening a transaction around the orchestrator
+ * call when atomicity is desired.
+ */
+export declare class KnexBackfillDriver implements BackfillDriver {
+    private readonly knex;
+    constructor(knex: Knex);
+    streamLegacyReqs(): AsyncIterable<{
+        req: TableProvenTxReq;
+        proven?: TableProvenTx;
+    }>;
+    streamLegacyTransactions(): AsyncIterable<TableTransaction>;
+    upsertTransactionNew(row: Omit<TableTransactionNew, 'transactionId'>): Promise<number>;
+    upsertAction(row: Omit<TableAction, 'actionId'>): Promise<number>;
+    repointTxLabelMap(legacyTransactionId: number, actionId: number): Promise<void>;
+}
+/**
+ * Convenience entry point. Opens a Knex transaction and runs the orchestrator
+ * inside it so that the entire backfill either succeeds or rolls back.
+ */
+export declare function runKnexBackfill(knex: Knex, now?: Date): Promise<BackfillStats>;
+//# sourceMappingURL=backfill.knex.d.ts.map

package/out/src/storage/schema/backfill.knex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backfill.knex.d.ts","sourceRoot":"","sources":["../../../../src/storage/schema/backfill.knex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAA;AAC3B,OAAO,EACL,WAAW,EACX,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,mBAAmB,EACpB,MAAM,UAAU,CAAA;AACjB,OAAO,EAAe,cAAc,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AAI9E;;;;;;;;;;GAUG;AACH,qBAAa,kBAAmB,YAAW,cAAc;IAC1C,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE,IAAI;IAEhC,gBAAgB,IAAK,aAAa,CAAC;QAAE,GAAG,EAAE,gBAAgB,CAAC;QAAC,MAAM,CAAC,EAAE,aAAa,CAAA;KAAE,CAAC;IA6DrF,wBAAwB,IAAK,aAAa,CAAC,gBAAgB,CAAC;IAiC9D,oBAAoB,CAAE,GAAG,EAAE,IAAI,CAAC,mBAAmB,EAAE,eAAe,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAuDvF,YAAY,CAAE,GAAG,EAAE,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IA0ClE,iBAAiB,CAAE,mBAAmB,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAMvF;AAED;;;GAGG;AACH,wBAAsB,eAAe,CAAE,IAAI,EAAE,IAAI,EAAE,GAAG,GAAE,IAAiB,GAAG,OAAO,CAAC,aAAa,CAAC,CAKjG"}