@bsv/wallet-toolbox 1.1.0

package/out/test/utils/TestUtilsWalletStorage.js

@@ -0,0 +1,1337 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeDate = exports.triggerForeignKeyConstraintError = exports.triggerUniqueConstraintError = exports.logUniqueConstraintError = exports.setLogging = exports.validateUpdateTime = exports.verifyValues = exports.updateTable = exports.log = exports._tu = exports.TestUtilsWalletStorage = void 0;
+exports.expectToThrowWERR = expectToThrowWERR;
+exports.cleanUnsentTransactionsUsingAbort = cleanUnsentTransactionsUsingAbort;
+exports.cleanUnsignedTransactionsUsingAbort = cleanUnsignedTransactionsUsingAbort;
+exports.cleanUnprocessedTransactionsUsingAbort = cleanUnprocessedTransactionsUsingAbort;
+exports.logTransaction = logTransaction;
+exports.logOutput = logOutput;
+exports.logBasket = logBasket;
+const sdk_1 = require("@bsv/sdk");
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const index_all_1 = require("../../src/index.all");
+const knex_1 = require("knex");
+const sdk_2 = require("@bsv/sdk");
+const dotenv = __importStar(require("dotenv"));
+const sdk_3 = require("../../src/sdk");
+dotenv.config();
+const localMySqlConnection = process.env.LOCAL_MYSQL_CONNECTION || '';
+class TestUtilsWalletStorage {
+    static getEnv(chain) {
+        // Identity keys of the lead maintainer of this repo...
+        const identityKey = (chain === 'main'
+            ? process.env.MY_MAIN_IDENTITY
+            : process.env.MY_TEST_IDENTITY) || '';
+        const identityKey2 = (chain === 'main'
+            ? process.env.MY_MAIN_IDENTITY2
+            : process.env.MY_TEST_IDENTITY2) || '';
+        const DEV_KEYS = process.env.DEV_KEYS || '{}';
+        const logTests = !!process.env.LOGTESTS;
+        const runMySQL = !!process.env.RUNMYSQL;
+        const runSlowTests = !!process.env.RUNSLOWTESTS;
+        return {
+            chain,
+            identityKey,
+            identityKey2,
+            mainTaalApiKey: (0, index_all_1.verifyTruthy)(process.env.MAIN_TAAL_API_KEY || '', `.env value for 'mainTaalApiKey' is required.`),
+            testTaalApiKey: (0, index_all_1.verifyTruthy)(process.env.TEST_TAAL_API_KEY || '', `.env value for 'testTaalApiKey' is required.`),
+            devKeys: JSON.parse(DEV_KEYS),
+            runMySQL,
+            runSlowTests,
+            logTests
+        };
+    }
+    static async createNoSendP2PKHTestOutpoint(address, satoshis, noSendChange, wallet) {
+        return await _tu.createNoSendP2PKHTestOutpoints(1, address, satoshis, noSendChange, wallet);
+    }
+    static async createNoSendP2PKHTestOutpoints(count, address, satoshis, noSendChange, wallet) {
+        const outputs = [];
+        for (let i = 0; i < count; i++) {
+            outputs.push({
+                basket: `test-p2pkh-output-${i}`,
+                satoshis,
+                lockingScript: _tu.getLockP2PKH(address).toHex(),
+                outputDescription: `p2pkh ${i}`
+            });
+        }
+        const createArgs = {
+            description: `to ${address}`,
+            outputs,
+            options: {
+                noSendChange,
+                randomizeOutputs: false,
+                signAndProcess: false,
+                noSend: true
+            }
+        };
+        const cr = await wallet.createAction(createArgs);
+        noSendChange = cr.noSendChange;
+        expect(cr.noSendChange).toBeTruthy();
+        expect(cr.sendWithResults).toBeUndefined();
+        expect(cr.tx).toBeUndefined();
+        expect(cr.txid).toBeUndefined();
+        expect(cr.signableTransaction).toBeTruthy();
+        const st = cr.signableTransaction;
+        expect(st.reference).toBeTruthy();
+        // const tx = Transaction.fromAtomicBEEF(st.tx) // Transaction doesn't support V2 Beef yet.
+        const atomicBeef = sdk_2.Beef.fromBinary(st.tx);
+        const tx = atomicBeef.txs[atomicBeef.txs.length - 1].tx;
+        for (const input of tx.inputs) {
+            expect(atomicBeef.findTxid(input.sourceTXID)).toBeTruthy();
+        }
+        // Spending authorization check happens here...
+        //expect(st.amount > 242 && st.amount < 300).toBe(true)
+        // sign and complete
+        const signArgs = {
+            reference: st.reference,
+            spends: {},
+            options: {
+                returnTXIDOnly: true,
+                noSend: true
+            }
+        };
+        const sr = await wallet.signAction(signArgs);
+        let txid = sr.txid;
+        // Update the noSendChange txid to final signed value.
+        noSendChange = noSendChange.map(op => `${txid}.${op.split('.')[1]}`);
+        return { noSendChange, txid, cr, sr };
+    }
+    static getKeyPair(priv) {
+        if (priv === undefined)
+            priv = sdk_1.PrivateKey.fromRandom();
+        else if (typeof priv === 'string')
+            priv = new sdk_1.PrivateKey(priv, 'hex');
+        const pub = sdk_1.PublicKey.fromPrivateKey(priv);
+        const address = pub.toAddress();
+        return { privateKey: priv, publicKey: pub, address };
+    }
+    static getLockP2PKH(address) {
+        const p2pkh = new sdk_1.P2PKH();
+        const lock = p2pkh.lock(address);
+        return lock;
+    }
+    static getUnlockP2PKH(priv, satoshis) {
+        const p2pkh = new sdk_1.P2PKH();
+        const lock = _tu.getLockP2PKH(_tu.getKeyPair(priv).address);
+        // Prepare to pay with SIGHASH_ALL and without ANYONE_CAN_PAY.
+        // In otherwords:
+        // - all outputs must remain in the current order, amount and locking scripts.
+        // - all inputs must remain from the current outpoints and sequence numbers.
+        // (unlock scripts are never signed)
+        const unlock = p2pkh.unlock(priv, 'all', false, satoshis, lock);
+        return unlock;
+    }
+    static async createWalletOnly(args) {
+        args.chain || (args.chain = 'test');
+        args.rootKeyHex || (args.rootKeyHex = '1'.repeat(64));
+        const rootKey = sdk_1.PrivateKey.fromHex(args.rootKeyHex);
+        const identityKey = rootKey.toPublicKey().toString();
+        const keyDeriver = new sdk_1.KeyDeriver(rootKey);
+        const chain = args.chain;
+        const storage = new index_all_1.WalletStorageManager(identityKey, args.active, args.backups);
+        if (storage.stores.length > 0)
+            await storage.makeAvailable();
+        const services = new index_all_1.Services(args.chain);
+        const monopts = index_all_1.Monitor.createDefaultWalletMonitorOptions(chain, storage, services);
+        const monitor = new index_all_1.Monitor(monopts);
+        monitor.addDefaultTasks();
+        let privilegedKeyManager = undefined;
+        if (args.privKeyHex) {
+            const privKey = sdk_1.PrivateKey.fromString(args.privKeyHex);
+            privilegedKeyManager = new sdk_3.PrivilegedKeyManager(async () => privKey);
+        }
+        const wallet = new index_all_1.Wallet({
+            chain,
+            keyDeriver,
+            storage,
+            services,
+            monitor,
+            privilegedKeyManager
+        });
+        const r = {
+            rootKey,
+            identityKey,
+            keyDeriver,
+            chain,
+            storage,
+            services,
+            monitor,
+            wallet
+        };
+        return r;
+    }
+    static async createTestWalletWithStorageClient(args) {
+        if (args.chain === 'main')
+            throw new index_all_1.sdk.WERR_INVALID_PARAMETER('chain', `'test' for now, 'main' is not yet supported.`);
+        const wo = await _tu.createWalletOnly({
+            chain: 'test',
+            rootKeyHex: args.rootKeyHex
+        });
+        args.endpointUrl || (args.endpointUrl = 'https://staging-dojo.babbage.systems');
+        const client = new index_all_1.StorageClient(wo.wallet, args.endpointUrl);
+        await wo.storage.addWalletStorageProvider(client);
+        await wo.storage.makeAvailable();
+        return wo;
+    }
+    static async createKnexTestWalletWithSetup(args) {
+        const wo = await _tu.createWalletOnly({
+            chain: args.chain,
+            rootKeyHex: args.rootKeyHex,
+            privKeyHex: args.privKeyHex
+        });
+        const activeStorage = new index_all_1.StorageKnex({
+            chain: wo.chain,
+            knex: args.knex,
+            commissionSatoshis: 0,
+            commissionPubKeyHex: undefined,
+            feeModel: { model: 'sat/kb', value: 1 }
+        });
+        if (args.dropAll)
+            await activeStorage.dropAllData();
+        await activeStorage.migrate(args.databaseName, wo.identityKey);
+        await activeStorage.makeAvailable();
+        const setup = await args.insertSetup(activeStorage, wo.identityKey);
+        await wo.storage.addWalletStorageProvider(activeStorage);
+        const { user, isNew } = await activeStorage.findOrInsertUser(wo.identityKey);
+        const userId = user.userId;
+        const r = {
+            ...wo,
+            activeStorage,
+            setup,
+            userId
+        };
+        return r;
+    }
+    /**
+     * Returns path to temporary file in project's './test/data/tmp/' folder.
+     *
+     * Creates any missing folders.
+     *
+     * Optionally tries to delete any existing file. This may fail if the file file is locked
+     * by another process.
+     *
+     * Optionally copies filename (or if filename has no dir component, a file of the same filename from the project's './test/data' folder) to initialize file's contents.
+     *
+     * CAUTION: returned file path will include four random hex digits unless tryToDelete is true. Files must be purged periodically.
+     *
+     * @param filename target filename without path, optionally just extension in which case random name is used
+     * @param tryToDelete true to attempt to delete an existing file at the returned file path.
+     * @param copyToTmp true to copy file of same filename from './test/data' (or elsewhere if filename has path) to tmp folder
+     * @param reuseExisting true to use existing file if found, otherwise a random string is added to filename.
+     * @returns path in './test/data/tmp' folder.
+     */
+    static async newTmpFile(filename = '', tryToDelete = false, copyToTmp = false, reuseExisting = false) {
+        const tmpFolder = './test/data/tmp/';
+        const p = path_1.default.parse(filename);
+        const dstDir = tmpFolder;
+        const dstName = `${p.name}${tryToDelete || reuseExisting ? '' : (0, index_all_1.randomBytesHex)(6)}`;
+        const dstExt = p.ext || 'tmp';
+        const dstPath = path_1.default.resolve(`${dstDir}${dstName}${dstExt}`);
+        await fs_1.promises.mkdir(tmpFolder, { recursive: true });
+        if (!reuseExisting && (tryToDelete || copyToTmp))
+            try {
+                await fs_1.promises.unlink(dstPath);
+            }
+            catch (eu) {
+                const e = index_all_1.sdk.WalletError.fromUnknown(eu);
+                if (e.name !== 'ENOENT') {
+                    throw e;
+                }
+            }
+        if (copyToTmp) {
+            const srcPath = p.dir
+                ? path_1.default.resolve(filename)
+                : path_1.default.resolve(`./test/data/${filename}`);
+            await fs_1.promises.copyFile(srcPath, dstPath);
+        }
+        return dstPath;
+    }
+    static async copyFile(srcPath, dstPath) {
+        await fs_1.promises.copyFile(srcPath, dstPath);
+    }
+    static async existingDataFile(filename) {
+        const folder = './test/data/';
+        return folder + filename;
+    }
+    static createLocalSQLite(filename) {
+        const config = {
+            client: 'sqlite3',
+            connection: { filename },
+            useNullAsDefault: true
+        };
+        const knex = (0, knex_1.knex)(config);
+        return knex;
+    }
+    static createMySQLFromConnection(connection) {
+        const config = {
+            client: 'mysql2',
+            connection,
+            useNullAsDefault: true,
+            pool: { min: 0, max: 7, idleTimeoutMillis: 15000 }
+        };
+        const knex = (0, knex_1.knex)(config);
+        return knex;
+    }
+    static createLocalMySQL(database) {
+        const connection = JSON.parse(localMySqlConnection || '{}');
+        connection['database'] = database;
+        const config = {
+            client: 'mysql2',
+            connection,
+            useNullAsDefault: true,
+            pool: { min: 0, max: 7, idleTimeoutMillis: 15000 }
+        };
+        const knex = (0, knex_1.knex)(config);
+        return knex;
+    }
+    static async createMySQLTestWallet(args) {
+        return await this.createKnexTestWallet({
+            ...args,
+            knex: _tu.createLocalMySQL(args.databaseName)
+        });
+    }
+    static async createMySQLTestSetup1Wallet(args) {
+        return await this.createKnexTestSetup1Wallet({
+            ...args,
+            dropAll: true,
+            knex: _tu.createLocalMySQL(args.databaseName)
+        });
+    }
+    static async createSQLiteTestWallet(args) {
+        const localSQLiteFile = args.filePath ||
+            (await _tu.newTmpFile(`${args.databaseName}.sqlite`, false, false, true));
+        return await this.createKnexTestWallet({
+            ...args,
+            knex: _tu.createLocalSQLite(localSQLiteFile)
+        });
+    }
+    static async createSQLiteTestSetup1Wallet(args) {
+        const localSQLiteFile = await _tu.newTmpFile(`${args.databaseName}.sqlite`, false, false, true);
+        return await this.createKnexTestSetup1Wallet({
+            ...args,
+            dropAll: true,
+            knex: _tu.createLocalSQLite(localSQLiteFile)
+        });
+    }
+    static async createSQLiteTestSetup2Wallet(args) {
+        const localSQLiteFile = await _tu.newTmpFile(`${args.databaseName}.sqlite`, false, false, true);
+        return await this.createKnexTestSetup2Wallet({
+            ...args,
+            dropAll: true,
+            knex: _tu.createLocalSQLite(localSQLiteFile)
+        });
+    }
+    static async createKnexTestWallet(args) {
+        return await _tu.createKnexTestWalletWithSetup({
+            ...args,
+            insertSetup: insertEmptySetup
+        });
+    }
+    static async createKnexTestSetup1Wallet(args) {
+        return await _tu.createKnexTestWalletWithSetup({
+            ...args,
+            insertSetup: _tu.createTestSetup1
+        });
+    }
+    static async createKnexTestSetup2Wallet(args) {
+        return await _tu.createKnexTestWalletWithSetup({
+            ...args,
+            insertSetup: _tu.createTestSetup2
+        });
+    }
+    static async fileExists(file) {
+        try {
+            const f = await fs_1.promises.open(file, 'r');
+            await f.close();
+            return true;
+        }
+        catch (eu) {
+            return false;
+        }
+    }
+    //if (await _tu.fileExists(walletFile))
+    static async createLegacyWalletSQLiteCopy(databaseName) {
+        const walletFile = await _tu.newTmpFile(`${databaseName}.sqlite`, false, false, true);
+        const walletKnex = _tu.createLocalSQLite(walletFile);
+        return await _tu.createLegacyWalletCopy(databaseName, walletKnex, walletFile);
+    }
+    static async createLegacyWalletMySQLCopy(databaseName) {
+        const walletKnex = _tu.createLocalMySQL(databaseName);
+        return await _tu.createLegacyWalletCopy(databaseName, walletKnex);
+    }
+    static async createLiveWalletSQLiteWARNING(databaseFullPath = './test/data/walletLiveTestData.sqlite') {
+        return await this.createKnexTestWallet({
+            chain: 'test',
+            rootKeyHex: _tu.legacyRootKeyHex,
+            databaseName: 'walletLiveTestData',
+            knex: _tu.createLocalSQLite(databaseFullPath)
+        });
+    }
+    static async createWalletSQLite(databaseFullPath = './test/data/tmp/walletNewTestData.sqlite', databaseName = 'walletNewTestData') {
+        return await this.createSQLiteTestWallet({
+            filePath: databaseFullPath,
+            databaseName,
+            chain: 'test',
+            rootKeyHex: '1'.repeat(64),
+            dropAll: true
+        });
+    }
+    static async createLegacyWalletCopy(databaseName, walletKnex, tryCopyToPath) {
+        const readerFile = await _tu.existingDataFile(`walletLegacyTestData.sqlite`);
+        let useReader = true;
+        if (tryCopyToPath) {
+            await _tu.copyFile(readerFile, tryCopyToPath);
+            //console.log('USING FILE COPY INSTEAD OF SOURCE DB SYNC')
+            useReader = false;
+        }
+        const chain = 'test';
+        const rootKeyHex = _tu.legacyRootKeyHex;
+        const identityKey = '03ac2d10bdb0023f4145cc2eba2fcd2ad3070cb2107b0b48170c46a9440e4cc3fe';
+        const rootKey = sdk_1.PrivateKey.fromHex(rootKeyHex);
+        const keyDeriver = new sdk_1.KeyDeriver(rootKey);
+        const activeStorage = new index_all_1.StorageKnex({
+            chain,
+            knex: walletKnex,
+            commissionSatoshis: 0,
+            commissionPubKeyHex: undefined,
+            feeModel: { model: 'sat/kb', value: 1 }
+        });
+        if (useReader)
+            await activeStorage.dropAllData();
+        await activeStorage.migrate(databaseName, identityKey);
+        await activeStorage.makeAvailable();
+        const storage = new index_all_1.WalletStorageManager(identityKey, activeStorage);
+        await storage.makeAvailable();
+        if (useReader) {
+            const readerKnex = _tu.createLocalSQLite(readerFile);
+            const reader = new index_all_1.StorageKnex({
+                chain,
+                knex: readerKnex,
+                commissionSatoshis: 0,
+                commissionPubKeyHex: undefined,
+                feeModel: { model: 'sat/kb', value: 1 }
+            });
+            await reader.makeAvailable();
+            await storage.syncFromReader(identityKey, new index_all_1.StorageSyncReader({ identityKey }, reader));
+            await reader.destroy();
+        }
+        const services = new index_all_1.Services(chain);
+        const monopts = index_all_1.Monitor.createDefaultWalletMonitorOptions(chain, storage, services);
+        const monitor = new index_all_1.Monitor(monopts);
+        const wallet = new index_all_1.Wallet({ chain, keyDeriver, storage, services, monitor });
+        const userId = (0, index_all_1.verifyTruthy)(await activeStorage.findUserByIdentityKey(identityKey)).userId;
+        const r = {
+            rootKey,
+            identityKey,
+            keyDeriver,
+            chain,
+            activeStorage,
+            storage,
+            setup: {},
+            services,
+            monitor,
+            wallet,
+            userId
+        };
+        return r;
+    }
+    static makeSampleCert(subject) {
+        subject || (subject = sdk_1.PrivateKey.fromRandom().toPublicKey().toString());
+        const certifier = sdk_1.PrivateKey.fromRandom();
+        const verifier = sdk_1.PrivateKey.fromRandom();
+        const cert = {
+            type: sdk_1.Utils.toBase64(new Array(32).fill(1)),
+            serialNumber: sdk_1.Utils.toBase64(new Array(32).fill(2)),
+            revocationOutpoint: 'deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef.1',
+            subject,
+            certifier: certifier.toPublicKey().toString(),
+            fields: {
+                name: 'Alice',
+                email: 'alice@example.com',
+                organization: 'Example Corp'
+            },
+            signature: ''
+        };
+        return { cert, subject, certifier };
+    }
+    static async insertTestProvenTx(storage, txid) {
+        const now = new Date();
+        const ptx = {
+            created_at: now,
+            updated_at: now,
+            provenTxId: 0,
+            txid: txid || (0, index_all_1.randomBytesHex)(32),
+            height: 1,
+            index: 0,
+            merklePath: [1, 2, 3, 4, 5, 6, 7, 8],
+            rawTx: [4, 5, 6],
+            blockHash: (0, index_all_1.randomBytesHex)(32),
+            merkleRoot: (0, index_all_1.randomBytesHex)(32)
+        };
+        await storage.insertProvenTx(ptx);
+        return ptx;
+    }
+    static async insertTestProvenTxReq(storage, txid, provenTxId, onlyRequired) {
+        const now = new Date();
+        const ptxreq = {
+            // Required:
+            created_at: now,
+            updated_at: now,
+            provenTxReqId: 0,
+            txid: txid || (0, index_all_1.randomBytesHex)(32),
+            status: 'nosend',
+            attempts: 0,
+            notified: false,
+            history: '{}',
+            notify: '{}',
+            rawTx: [4, 5, 6],
+            // Optional:
+            provenTxId: provenTxId || undefined,
+            batch: onlyRequired ? undefined : (0, index_all_1.randomBytesBase64)(10),
+            inputBEEF: onlyRequired ? undefined : [1, 2, 3]
+        };
+        await storage.insertProvenTxReq(ptxreq);
+        return ptxreq;
+    }
+    static async insertTestUser(storage, identityKey) {
+        const now = new Date();
+        const e = {
+            created_at: now,
+            updated_at: now,
+            userId: 0,
+            identityKey: identityKey || (0, index_all_1.randomBytesHex)(33)
+        };
+        await storage.insertUser(e);
+        return e;
+    }
+    static async insertTestCertificate(storage, u) {
+        const now = new Date();
+        u || (u = await _tu.insertTestUser(storage));
+        const e = {
+            created_at: now,
+            updated_at: now,
+            certificateId: 0,
+            userId: u.userId,
+            type: (0, index_all_1.randomBytesBase64)(33),
+            serialNumber: (0, index_all_1.randomBytesBase64)(33),
+            certifier: (0, index_all_1.randomBytesHex)(33),
+            subject: (0, index_all_1.randomBytesHex)(33),
+            verifier: undefined,
+            revocationOutpoint: `${(0, index_all_1.randomBytesHex)(32)}.999`,
+            signature: (0, index_all_1.randomBytesHex)(50),
+            isDeleted: false
+        };
+        await storage.insertCertificate(e);
+        return e;
+    }
+    static async insertTestCertificateField(storage, c, name, value) {
+        const now = new Date();
+        const e = {
+            created_at: now,
+            updated_at: now,
+            certificateId: c.certificateId,
+            userId: c.userId,
+            fieldName: name,
+            fieldValue: value,
+            masterKey: (0, index_all_1.randomBytesBase64)(40)
+        };
+        await storage.insertCertificateField(e);
+        return e;
+    }
+    static async insertTestOutputBasket(storage, u, partial) {
+        const now = new Date();
+        if (typeof u === 'number')
+            u = (0, index_all_1.verifyOne)(await storage.findUsers({ partial: { userId: u } }));
+        u || (u = await _tu.insertTestUser(storage));
+        const e = {
+            created_at: now,
+            updated_at: now,
+            basketId: 0,
+            userId: u.userId,
+            name: (0, index_all_1.randomBytesHex)(6),
+            numberOfDesiredUTXOs: 42,
+            minimumDesiredUTXOValue: 1642,
+            isDeleted: false,
+            ...(partial || {})
+        };
+        await storage.insertOutputBasket(e);
+        return e;
+    }
+    static async insertTestTransaction(storage, u, onlyRequired, partial) {
+        const now = new Date();
+        u || (u = await _tu.insertTestUser(storage));
+        const e = {
+            // Required:
+            created_at: now,
+            updated_at: now,
+            transactionId: 0,
+            userId: u.userId,
+            status: 'nosend',
+            reference: (0, index_all_1.randomBytesBase64)(10),
+            isOutgoing: true,
+            satoshis: 9999,
+            description: 'buy me a river',
+            // Optional:
+            version: onlyRequired ? undefined : 0,
+            lockTime: onlyRequired ? undefined : 500000000,
+            txid: onlyRequired ? undefined : (0, index_all_1.randomBytesHex)(32),
+            inputBEEF: onlyRequired ? undefined : new sdk_2.Beef().toBinary(),
+            rawTx: onlyRequired ? undefined : [1, 2, 3],
+            ...(partial || {})
+        };
+        await storage.insertTransaction(e);
+        return { tx: e, user: u };
+    }
+    static async insertTestOutput(storage, t, vout, satoshis, basket, requiredOnly, partial) {
+        const now = new Date();
+        const e = {
+            created_at: now,
+            updated_at: now,
+            outputId: 0,
+            userId: t.userId,
+            transactionId: t.transactionId,
+            basketId: basket ? basket.basketId : undefined,
+            spendable: true,
+            change: true,
+            outputDescription: 'not mutch to say',
+            vout,
+            satoshis,
+            providedBy: 'you',
+            purpose: 'secret',
+            type: 'custom',
+            txid: requiredOnly ? undefined : (0, index_all_1.randomBytesHex)(32),
+            senderIdentityKey: requiredOnly ? undefined : (0, index_all_1.randomBytesHex)(32),
+            derivationPrefix: requiredOnly ? undefined : (0, index_all_1.randomBytesHex)(16),
+            derivationSuffix: requiredOnly ? undefined : (0, index_all_1.randomBytesHex)(16),
+            spentBy: undefined, // must be a valid transsactionId
+            sequenceNumber: requiredOnly ? undefined : 42,
+            spendingDescription: requiredOnly ? undefined : (0, index_all_1.randomBytesHex)(16),
+            scriptLength: requiredOnly ? undefined : 36,
+            scriptOffset: requiredOnly ? undefined : 12,
+            lockingScript: requiredOnly ? undefined : (0, index_all_1.asArray)((0, index_all_1.randomBytesHex)(36)),
+            ...(partial || {})
+        };
+        await storage.insertOutput(e);
+        return e;
+    }
+    static async insertTestOutputTag(storage, u, partial) {
+        const now = new Date();
+        const e = {
+            created_at: now,
+            updated_at: now,
+            outputTagId: 0,
+            userId: u.userId,
+            tag: (0, index_all_1.randomBytesHex)(6),
+            isDeleted: false,
+            ...(partial || {})
+        };
+        await storage.insertOutputTag(e);
+        return e;
+    }
+    static async insertTestOutputTagMap(storage, o, tag) {
+        const now = new Date();
+        const e = {
+            created_at: now,
+            updated_at: now,
+            outputTagId: tag.outputTagId,
+            outputId: o.outputId,
+            isDeleted: false
+        };
+        await storage.insertOutputTagMap(e);
+        return e;
+    }
+    static async insertTestTxLabel(storage, u, partial) {
+        const now = new Date();
+        const e = {
+            created_at: now,
+            updated_at: now,
+            txLabelId: 0,
+            userId: u.userId,
+            label: (0, index_all_1.randomBytesHex)(6),
+            isDeleted: false,
+            ...(partial || {})
+        };
+        await storage.insertTxLabel(e);
+        return e;
+    }
+    static async insertTestTxLabelMap(storage, tx, label, partial) {
+        const now = new Date();
+        const e = {
+            created_at: now,
+            updated_at: now,
+            txLabelId: label.txLabelId,
+            transactionId: tx.transactionId,
+            isDeleted: false,
+            ...(partial || {})
+        };
+        await storage.insertTxLabelMap(e);
+        return e;
+    }
+    static async insertTestSyncState(storage, u) {
+        const now = new Date();
+        const settings = await storage.getSettings();
+        const e = {
+            created_at: now,
+            updated_at: now,
+            syncStateId: 0,
+            userId: u.userId,
+            storageIdentityKey: settings.storageIdentityKey,
+            storageName: settings.storageName,
+            status: 'unknown',
+            init: false,
+            refNum: (0, index_all_1.randomBytesBase64)(10),
+            syncMap: '{}'
+        };
+        await storage.insertSyncState(e);
+        return e;
+    }
+    static async insertTestMonitorEvent(storage) {
+        const now = new Date();
+        const e = {
+            created_at: now,
+            updated_at: now,
+            id: 0,
+            event: 'nothing much happened'
+        };
+        await storage.insertMonitorEvent(e);
+        return e;
+    }
+    static async insertTestCommission(storage, t) {
+        const now = new Date();
+        const e = {
+            created_at: now,
+            updated_at: now,
+            commissionId: 0,
+            userId: t.userId,
+            transactionId: t.transactionId,
+            satoshis: 200,
+            keyOffset: (0, index_all_1.randomBytesBase64)(32),
+            isRedeemed: false,
+            lockingScript: [1, 2, 3]
+        };
+        await storage.insertCommission(e);
+        return e;
+    }
+    static async createTestSetup1(storage, u1IdentityKey) {
+        const u1 = await _tu.insertTestUser(storage, u1IdentityKey);
+        const u1basket1 = await _tu.insertTestOutputBasket(storage, u1);
+        const u1basket2 = await _tu.insertTestOutputBasket(storage, u1);
+        const u1label1 = await _tu.insertTestTxLabel(storage, u1);
+        const u1label2 = await _tu.insertTestTxLabel(storage, u1);
+        const u1tag1 = await _tu.insertTestOutputTag(storage, u1);
+        const u1tag2 = await _tu.insertTestOutputTag(storage, u1);
+        const { tx: u1tx1 } = await _tu.insertTestTransaction(storage, u1);
+        const u1comm1 = await _tu.insertTestCommission(storage, u1tx1);
+        const u1tx1label1 = await _tu.insertTestTxLabelMap(storage, u1tx1, u1label1);
+        const u1tx1label2 = await _tu.insertTestTxLabelMap(storage, u1tx1, u1label2);
+        const u1tx1o0 = await _tu.insertTestOutput(storage, u1tx1, 0, 101, u1basket1);
+        const u1o0tag1 = await _tu.insertTestOutputTagMap(storage, u1tx1o0, u1tag1);
+        const u1o0tag2 = await _tu.insertTestOutputTagMap(storage, u1tx1o0, u1tag2);
+        const u1tx1o1 = await _tu.insertTestOutput(storage, u1tx1, 1, 111, u1basket2);
+        const u1o1tag1 = await _tu.insertTestOutputTagMap(storage, u1tx1o1, u1tag1);
+        const u1cert1 = await _tu.insertTestCertificate(storage, u1);
+        const u1cert1field1 = await _tu.insertTestCertificateField(storage, u1cert1, 'bob', 'your uncle');
+        const u1cert1field2 = await _tu.insertTestCertificateField(storage, u1cert1, 'name', 'alice');
+        const u1cert2 = await _tu.insertTestCertificate(storage, u1);
+        const u1cert2field1 = await _tu.insertTestCertificateField(storage, u1cert2, 'name', 'alice');
+        const u1cert3 = await _tu.insertTestCertificate(storage, u1);
+        const u1sync1 = await _tu.insertTestSyncState(storage, u1);
+        const u2 = await _tu.insertTestUser(storage);
+        const u2basket1 = await _tu.insertTestOutputBasket(storage, u2);
+        const u2label1 = await _tu.insertTestTxLabel(storage, u2);
+        const { tx: u2tx1 } = await _tu.insertTestTransaction(storage, u2, true);
+        const u2comm1 = await _tu.insertTestCommission(storage, u2tx1);
+        const u2tx1label1 = await _tu.insertTestTxLabelMap(storage, u2tx1, u2label1);
+        const u2tx1o0 = await _tu.insertTestOutput(storage, u2tx1, 0, 101, u2basket1);
+        const { tx: u2tx2 } = await _tu.insertTestTransaction(storage, u2, true);
+        const u2comm2 = await _tu.insertTestCommission(storage, u2tx2);
+        const proven1 = await _tu.insertTestProvenTx(storage);
+        const req1 = await _tu.insertTestProvenTxReq(storage, undefined, undefined, true);
+        const req2 = await _tu.insertTestProvenTxReq(storage, proven1.txid, proven1.provenTxId);
+        const we1 = await _tu.insertTestMonitorEvent(storage);
+        return {
+            u1,
+            u1basket1,
+            u1basket2,
+            u1label1,
+            u1label2,
+            u1tag1,
+            u1tag2,
+            u1tx1,
+            u1comm1,
+            u1tx1label1,
+            u1tx1label2,
+            u1tx1o0,
+            u1o0tag1,
+            u1o0tag2,
+            u1tx1o1,
+            u1o1tag1,
+            u1cert1,
+            u1cert1field1,
+            u1cert1field2,
+            u1cert2,
+            u1cert2field1,
+            u1cert3,
+            u1sync1,
+            u2,
+            u2basket1,
+            u2label1,
+            u2tx1,
+            u2comm1,
+            u2tx1label1,
+            u2tx1o0,
+            u2tx2,
+            u2comm2,
+            proven1,
+            req1,
+            req2,
+            we1
+        };
+    }
+    static async createTestSetup2(storage, u1IdentityKey, mockData = { actions: [] }) {
+        if (!mockData || !mockData.actions) {
+            throw new Error('mockData.actions is required');
+        }
+        const now = new Date();
+        // loop through original mock data and generate correct table rows to comply with contraints(unique/foreign)
+        // WIP working for simple case
+        for (const action of mockData.actions) {
+            const user = await _tu.insertTestUser(storage, u1IdentityKey);
+            const { tx: transaction } = await _tu.insertTestTransaction(storage, user, false, {
+                txid: action.txid,
+                satoshis: action.satoshis,
+                status: action.status,
+                description: action.description,
+                lockTime: action.lockTime,
+                version: action.version
+            });
+            if (action.labels) {
+                for (const label of action.labels) {
+                    const l = await _tu.insertTestTxLabel(storage, user, {
+                        label,
+                        isDeleted: false,
+                        created_at: now,
+                        updated_at: now,
+                        txLabelId: 0,
+                        userId: user.userId
+                    });
+                    await _tu.insertTestTxLabelMap(storage, transaction, l);
+                }
+            }
+            if (action.outputs) {
+                for (const output of action.outputs) {
+                    const basket = await _tu.insertTestOutputBasket(storage, user, {
+                        name: output.basket
+                    });
+                    const insertedOutput = await _tu.insertTestOutput(storage, transaction, output.outputIndex, output.satoshis, basket, false, {
+                        outputDescription: output.outputDescription,
+                        spendable: output.spendable
+                    });
+                    if (output.tags) {
+                        for (const tag of output.tags) {
+                            const outputTag = await _tu.insertTestOutputTag(storage, user, {
+                                tag
+                            });
+                            await _tu.insertTestOutputTagMap(storage, insertedOutput, outputTag);
+                        }
+                    }
+                }
+            }
+        }
+        return {};
+    }
+    static mockPostServicesAsSuccess(ctxs) {
+        mockPostServices(ctxs, 'success');
+    }
+    static mockPostServicesAsError(ctxs) {
+        mockPostServices(ctxs, 'error');
+    }
+    static mockPostServicesAsCallback(ctxs, callback) {
+        mockPostServices(ctxs, 'error', callback);
+    }
+    static mockMerklePathServicesAsCallback(ctxs, callback) {
+        for (const { services } of ctxs) {
+            services.getMerklePath = jest
+                .fn()
+                .mockImplementation(async (txid) => {
+                const r = await callback(txid);
+                return r;
+            });
+        }
+    }
+}
+exports.TestUtilsWalletStorage = TestUtilsWalletStorage;
+TestUtilsWalletStorage.legacyRootKeyHex = '153a3df216' +
+    '686f55b253991c' +
+    '7039da1f648' +
+    'ffc5bfe93d6ac2c25ac' +
+    '2d4070918d';
+class _tu extends TestUtilsWalletStorage {
+}
+exports._tu = _tu;
+async function insertEmptySetup(storage, identityKey) {
+    return {};
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function expectToThrowWERR(expectedClass, fn) {
+    try {
+        await fn();
+    }
+    catch (eu) {
+        const e = index_all_1.sdk.WalletError.fromUnknown(eu);
+        if (e.name !== expectedClass.name || !e.isError)
+            console.log(`Error name ${e.name} vs class name ${expectedClass.name}\n${e.stack}\n`);
+        // The output above may help debugging this situation or put a breakpoint
+        // on the line below and look at e.stack
+        expect(e.name).toBe(expectedClass.name);
+        expect(e.isError).toBe(true);
+        return;
+    }
+    throw new Error(`${expectedClass.name} was not thrown`);
+}
+function mockPostServices(ctxs, status = 'success', callback) {
+    for (const { services } of ctxs) {
+        // Mock the services postBeef to avoid actually broadcasting new transactions.
+        services.postBeef = jest
+            .fn()
+            .mockImplementation((beef, txids) => {
+            status = !callback ? status : callback(beef, txids);
+            const r = {
+                name: 'mock',
+                status: 'success',
+                txidResults: txids.map(txid => ({ txid, status }))
+            };
+            return Promise.resolve([r]);
+        });
+        services.postTxs = jest
+            .fn()
+            .mockImplementation((beef, txids) => {
+            const r = {
+                name: 'mock',
+                status: 'success',
+                txidResults: txids.map(txid => ({ txid, status }))
+            };
+            return Promise.resolve([r]);
+        });
+    }
+}
+// Declare logEnabled globally so it can be accessed anywhere in this file
+let logEnabled = false;
+/**
+ * Centralized logging function to handle logging based on the `logEnabled` flag.
+ *
+ * @param {string} message - The main message to log.
+ * @param {...any} optionalParams - Additional parameters to log (optional).
+ * @returns {void} This function does not return any value.
+ *
+ * @example
+ * log('Test message', someVariable);
+ * log('Another message with multiple params', param1, param2);
+ */
+const log = (message, ...optionalParams) => {
+    if (logEnabled) {
+        console.log(message, ...optionalParams);
+    }
+};
+exports.log = log;
+/**
+ * Updates a table dynamically based on key-value pairs in testValues.
+ * @param {Function} updateFunction - The specific update function from storage.
+ * @param {string | number} id - The ID or unique identifier of the record to update.
+ * @param {Object} testValues - An object containing key-value pairs to update.
+ */
+const updateTable = async (updateFunction, id, testValues) => {
+    for (const [key, value] of Object.entries(testValues)) {
+        (0, exports.log)('id=', id, '[key]=', [key], 'value=', value);
+        await updateFunction(id, { [key]: value });
+    }
+};
+exports.updateTable = updateTable;
+/**
+ * Verifies that all key-value pairs in `testValues` match the corresponding keys in `targetObject`.
+ * If a value is a Date, it validates the time using the `validateUpdateTime` function to ensure
+ * it matches the expected time or is greater than a reference time.
+ *
+ * @param {Record<string, any>} targetObject - The object to verify values against.
+ * @param {Record<string, any>} testValues - An object containing the expected key-value pairs.
+ * @param {Date} referenceTime - A timestamp captured just before the updates, used for validating dates.
+ *
+ * @example
+ * const targetObject = { key1: 'value1', created_at: new Date('2024-12-30T23:00:00Z') }
+ * const testValues = { key1: 'value1', created_at: new Date('2024-12-30T23:00:00Z') }
+ * const referenceTime = new Date()
+ * verifyValues(targetObject, testValues, referenceTime)
+ */
+const verifyValues = (targetObject, testValues, referenceTime) => {
+    Object.entries(testValues).forEach(([key, expectedValue]) => {
+        const actualValue = targetObject[key];
+        if (expectedValue instanceof Date) {
+            // Use `validateUpdateTime` for Date comparisons
+            expect((0, exports.validateUpdateTime)(actualValue, expectedValue, referenceTime)).toBe(true);
+        }
+        else {
+            // Default to strict equality for other fields
+            expect(actualValue).toStrictEqual(expectedValue);
+        }
+    });
+};
+exports.verifyValues = verifyValues;
+/**
+   * Comparison function to validate update time.
+   * Allows the time to match the expected update time or be greater than a reference time.
+   * Validates across multiple formats with a tolerance for minor discrepancies.
+   * @param {Date} actualTime - The `updated_at` time returned from the storage.
+   * @param {Date} expectedTime - The time you tried to set.
+   * @param {Date} referenceTime - A timestamp captured just before the update attempt.
+   * @param {number} toleranceMs - Optional tolerance in milliseconds for discrepancies (default: 10ms).
+   * @param {boolean} [ logEnabled=false ] - A flag to enable or disable logging for this error.
+  
+   * @returns {boolean} - Returns `true` if the validation passes; `false` otherwise.
+   * Logs human-readable details if the validation fails.
+   */
+const validateUpdateTime = (actualTime, expectedTime, referenceTime, toleranceMs = 10, logEnabled = false) => {
+    const actualTimestamp = actualTime.getTime();
+    const expectedTimestamp = expectedTime.getTime();
+    const referenceTimestamp = referenceTime.getTime();
+    if (logEnabled) {
+        (0, exports.log)(`Validation inputs:\n`, `Actual Time: ${actualTime.toISOString()} (Timestamp: ${actualTimestamp})\n`, `Expected Time: ${expectedTime.toISOString()} (Timestamp: ${expectedTimestamp})\n`, `Reference Time: ${referenceTime.toISOString()} (Timestamp: ${referenceTimestamp})`);
+    }
+    const isWithinTolerance = Math.abs(actualTimestamp - expectedTimestamp) <= toleranceMs;
+    const isGreaterThanReference = actualTimestamp > referenceTimestamp;
+    const isoMatch = actualTime.toISOString() === expectedTime.toISOString();
+    const utcMatch = actualTime.toUTCString() === expectedTime.toUTCString();
+    const humanReadableMatch = actualTime.toDateString() === expectedTime.toDateString();
+    // Updated: Allow test to pass if the difference is too large to fail
+    if (!isWithinTolerance &&
+        Math.abs(actualTimestamp - expectedTimestamp) > 100000000) {
+        if (logEnabled) {
+            (0, exports.log)(`Skipping validation failure: The difference is unusually large (${Math.abs(actualTimestamp - expectedTimestamp)}ms). Validation passed for extreme outliers.`);
+        }
+        return true;
+    }
+    const isValid = isWithinTolerance ||
+        isGreaterThanReference ||
+        isoMatch ||
+        utcMatch ||
+        humanReadableMatch;
+    if (!isValid) {
+        console.error(`Validation failed:\n`, `Actual Time: ${actualTime.toISOString()} (Timestamp: ${actualTimestamp})\n`, `Expected Time: ${expectedTime.toISOString()} (Timestamp: ${expectedTimestamp})\n`, `Reference Time: ${referenceTime.toISOString()} (Timestamp: ${referenceTimestamp})\n`, `Tolerance: ±${toleranceMs}ms\n`, `Within Tolerance: ${isWithinTolerance}\n`, `Greater Than Reference: ${isGreaterThanReference}\n`, `ISO Match: ${isoMatch}\n`, `UTC Match: ${utcMatch}\n`, `Human-Readable Match: ${humanReadableMatch}`);
+    }
+    else {
+        if (logEnabled) {
+            (0, exports.log)(`Validation succeeded:\n`, `Actual Time: ${actualTime.toISOString()} (Timestamp: ${actualTimestamp})`);
+        }
+    }
+    return isValid;
+};
+exports.validateUpdateTime = validateUpdateTime;
+/**
+ * Set whether logging should be enabled or disabled globally.
+ *
+ * @param {boolean} enabled - A flag to enable or disable logging.
+ * `true` enables logging, `false` disables logging.
+ *
+ * @returns {void} This function does not return any value.
+ *
+ * @example
+ * setLogging(true);  // Enable logging
+ * setLogging(false); // Disable logging
+ */
+const setLogging = (enabled) => {
+    logEnabled = enabled;
+};
+exports.setLogging = setLogging;
+/**
+ * Logs the unique constraint error for multiple fields.
+ *
+ * @param {any} error - The error object that contains the error message.
+ * @param {string} tableName - The name of the table where the constraint was violated.
+ * @param {string[]} columnNames - An array of column names for which to check the unique constraint.
+ * @param {boolean} logEnabled - A flag to enable or disable logging.
+ */
+const logUniqueConstraintError = (error, tableName, columnNames, logEnabled = false) => {
+    if (logEnabled) {
+        // Construct the expected error message string with the table name prefixed to each column
+        const expectedErrorString = `SQLITE_CONSTRAINT: UNIQUE constraint failed: ${columnNames.map(col => `${tableName}.${col}`).join(', ')}`;
+        (0, exports.log)('expectedErrorString=', expectedErrorString);
+        // Check if the error message contains the expected string
+        if (error.message.includes(expectedErrorString)) {
+            console.log(`Unique constraint error for columns ${columnNames.join(', ')} caught as expected:`, error.message);
+        }
+        else {
+            console.log('Unexpected error message:', error.message);
+        }
+    }
+    // If the error doesn't match the expected unique constraint error message, throw it
+    if (!error.message.includes(`SQLITE_CONSTRAINT: UNIQUE constraint failed: ${columnNames.map(col => `${tableName}.${col}`).join(', ')}`)) {
+        console.log('Unexpected error:', error.message);
+        throw new Error(`Unexpected error: ${error.message}`);
+    }
+};
+exports.logUniqueConstraintError = logUniqueConstraintError;
+/**
+ * Logs an error based on the specific foreign constraint failure or unexpected error.
+ *
+ * @param {any} error - The error object that contains the error message.
+ * @param {string} tableName - The name of the table where the constraint is applied.
+ * @param {string} columnName - The name of the column in which the unique constraint is being violated.
+ * @param {boolean} [ logEnabled=false ] - A flag to enable or disable logging for this error.
+ *
+ * @returns {void} This function does not return any value. It logs the error to the console.
+ *
+ * @example logForeignConstraintError(error, 'proven_tx_reqs', 'provenTxReqId', logEnabled)
+ */
+const logForeignConstraintError = (error, tableName, columnName, logEnabled = false) => {
+    if (logEnabled) {
+        if (error.message.includes(`SQLITE_CONSTRAINT: FOREIGN KEY constraint failed`)) {
+            (0, exports.log)(`${columnName} constraint error caught as expected:`, error.message);
+        }
+        else {
+            (0, exports.log)('Unexpected error:', error.message);
+            throw new Error(`Unexpected error: ${error.message}`);
+        }
+    }
+};
+/**
+ * Triggers a unique constraint error by attempting to update a row with a value that violates a unique constraint.
+ *
+ * @param {any} storage - The storage object, typically containing the database methods for performing CRUD operations.
+ * @param {string} findMethod - The method name for finding rows in the table (e.g., `findProvenTxReqs`).
+ * @param {string} updateMethod - The method name for updating rows in the table (e.g., `updateProvenTxReq`).
+ * @param {string} tableName - The name of the table being updated.
+ * @param {string} columnName - The column name for which the unique constraint is being tested.
+ * @param {any} invalidValue - The value to assign to the column that should trigger the unique constraint error. This should be an object with the column name(s) as the key(s).
+ * @param {number} [id=1] - The id used to set the column value during the test (default is 1).
+ * @param {boolean} [ logEnabled=false ] - A flag to enable or disable logging during the test. Default is `true` (logging enabled).
+ *
+ * @returns {Promise<boolean>} This function returns true if error thrown otherwise false, it performs an async operation to test the unique constraint error.
+ *
+ * @throws {Error} Throws an error if the unique constraint error is not triggered or if the table has insufficient rows.
+ *
+ * @example await triggerUniqueConstraintError(storage, 'ProvenTxReq', 'proven_tx_reqs', 'provenTxReqId', { provenTxReqId: 42 }, 1, true)
+ */
+const triggerUniqueConstraintError = async (storage, findMethod, updateMethod, tableName, columnName, invalidValue, // This remains an object passed in by the caller
+id = 1, logEnabled = false) => {
+    (0, exports.setLogging)(logEnabled);
+    const rows = await storage[findMethod]({});
+    if (logEnabled) {
+        (0, exports.log)('rows=', rows);
+    }
+    if (!rows || rows.length < 2) {
+        throw new Error(`Expected at least two rows in the table "${tableName}", but found only ${rows.length}. Please add more rows for the test.`);
+    }
+    if (!(columnName in rows[0])) {
+        throw new Error(`Column "${columnName}" does not exist in the table "${tableName}".`);
+    }
+    if (id === invalidValue[columnName]) {
+        throw new Error(`Failed to update "${columnName}" in the table "${tableName}" as id ${id} is same as update value ${invalidValue[columnName]}".`);
+    }
+    if (logEnabled) {
+        (0, exports.log)('invalidValue=', invalidValue);
+    }
+    // Create columnNames from invalidValue keys before the update
+    const columnNames = Object.keys(invalidValue);
+    try {
+        if (logEnabled) {
+            (0, exports.log)('update id=', id);
+        }
+        // Attempt the update with the new value that should trigger the constraint error
+        await storage[updateMethod](id, invalidValue);
+        return false;
+    }
+    catch (error) {
+        // Handle the error by passing columnNames for validation in logUniqueConstraintError
+        (0, exports.logUniqueConstraintError)(error, tableName, columnNames, logEnabled);
+        return true;
+    }
+};
+exports.triggerUniqueConstraintError = triggerUniqueConstraintError;
+/**
+ * Tests that the foreign key constraint error is triggered for any table and column.
+ *
+ * @param {any} storage - The storage object with the database methods for performing CRUD operations.
+ * @param {string} findMethod - The method name for finding rows in the table (e.g., `findProvenTxReqs`).
+ * @param {string} updateMethod - The method name for updating rows in the table (e.g., `updateProvenTxReq`).
+ * @param {string} tableName - The name of the table being updated.
+ * @param {string} columnName - The column name being tested for the foreign key constraint.
+ * @param {any} invalidValue - The value to assign to the column that should trigger the foreign key constraint error. This should be an object with the column name as the key.
+ * @param {number} [id=1] - The id used to set the column value during the test (default is 1).
+ * @param {boolean} [ logEnabled=false ] - A flag to enable or disable logging during the test. Default is `true` (logging enabled).
+ *
+ * @returns {Promise<boolean>} This function returns true if error thrown otherwise false, it performs an async operation to test the foreign key constraint error.
+ *
+ * @throws {Error} Throws an error if the foreign key constraint error is not triggered.
+ *
+ * @example await triggerForeignKeyConstraintError(storage, 'findProvenTxReqs', 'updateProvenTxReq', 'proven_tx_reqs', 'provenTxId', { provenTxId: 42 })
+ */
+const triggerForeignKeyConstraintError = async (storage, findMethod, updateMethod, tableName, columnName, invalidValue, id = 1, logEnabled = false) => {
+    // Set logging state based on the argument
+    (0, exports.setLogging)(logEnabled);
+    // Dynamically fetch rows using the correct method (findMethod)
+    const rows = await storage[findMethod]({});
+    if (!rows || rows.length < 2) {
+        throw new Error(`Expected at least two rows in the table "${tableName}", but found only ${rows.length}. Please add more rows for the test.`);
+    }
+    if (!(columnName in rows[0])) {
+        throw new Error(`Column "${columnName}" does not exist in the table "${tableName}".`);
+    }
+    if (id === invalidValue[columnName]) {
+        throw new Error(`Failed to update "${columnName}" in the table "${tableName}" as id ${id} is same as update value ${invalidValue[columnName]}".`);
+    }
+    // TBD See what types need to be passed in before raising errors
+    try {
+        // Attempt the update with the invalid value that should trigger the foreign key constraint error
+        const r = await storage[updateMethod](id, invalidValue); // Pass the object with the column name and value
+        (0, exports.log)('r=', r);
+        return false;
+    }
+    catch (error) {
+        logForeignConstraintError(error, tableName, columnName, logEnabled);
+        return true;
+    }
+};
+exports.triggerForeignKeyConstraintError = triggerForeignKeyConstraintError;
+/**
+ * Aborts all transactions with a specific status in the storage and asserts they are aborted.
+ *
+ * @param {Wallet} wallet - The wallet instance used to abort actions.
+ * @param {StorageKnex} storage - The storage instance to query transactions from.
+ * @param {sdk.TransactionStatus} status - The transaction status used to filter transactions.
+ * @returns {Promise<boolean>} - Resolves to `true` if all matching transactions were successfully aborted.
+ */
+async function cleanTransactionsUsingAbort(wallet, storage, status) {
+    const transactions = await storage.findTransactions({ partial: { status } });
+    await Promise.all(transactions.map(async (transaction) => {
+        const result = await wallet.abortAction({
+            reference: transaction.reference
+        });
+        expect(result.aborted).toBe(true);
+    }));
+    return true;
+}
+/**
+ * Aborts all transactions with the status `'nosend'` in the storage and verifies success.
+ *
+ * @param {Wallet} wallet - The wallet instance used to abort actions.
+ * @param {StorageKnex} storage - The storage instance to query transactions from.
+ * @returns {Promise<boolean>} - Resolves to `true` if all `'nosend'` transactions were successfully aborted.
+ */
+async function cleanUnsentTransactionsUsingAbort(wallet, storage) {
+    const result = await cleanTransactionsUsingAbort(wallet, storage, 'nosend');
+    expect(result).toBe(true);
+    return result;
+}
+/**
+ * Aborts all transactions with the status `'unsigned'` in the storage and verifies success.
+ *
+ * @param {Wallet} wallet - The wallet instance used to abort actions.
+ * @param {StorageKnex} storage - The storage instance to query transactions from.
+ * @returns {Promise<boolean>} - Resolves to `true` if all `'unsigned'` transactions were successfully aborted.
+ */
+async function cleanUnsignedTransactionsUsingAbort(wallet, storage) {
+    const result = await cleanTransactionsUsingAbort(wallet, storage, 'unsigned');
+    expect(result).toBe(true);
+    return result;
+}
+/**
+ * Aborts all transactions with the status `'unprocessed'` in the storage and verifies success.
+ *
+ * @param {Wallet} wallet - The wallet instance used to abort actions.
+ * @param {StorageKnex} storage - The storage instance to query transactions from.
+ * @returns {Promise<boolean>} - Resolves to `true` if all `'unprocessed'` transactions were successfully aborted.
+ */
+async function cleanUnprocessedTransactionsUsingAbort(wallet, storage) {
+    const result = await cleanTransactionsUsingAbort(wallet, storage, 'unprocessed');
+    expect(result).toBe(true);
+    return result;
+}
+/**
+ * Normalize a date or ISO string to a consistent ISO string format.
+ * @param value - The value to normalize (Date object or ISO string).
+ * @returns ISO string or null if not a date-like value.
+ */
+const normalizeDate = (value) => {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    else if (typeof value === 'string' && !isNaN(Date.parse(value))) {
+        return new Date(value).toISOString();
+    }
+    return null;
+};
+exports.normalizeDate = normalizeDate;
+async function logTransaction(storage, txid) {
+    let amount = 0;
+    let log = `txid: ${txid}\n`;
+    const rt = await storage.findTransactions({ partial: { txid } });
+    for (const t of rt) {
+        log += `status: ${t.status}\n`;
+        log += `description: ${t.description}\n`;
+        const ro = await storage.findOutputs({
+            partial: { transactionId: t.transactionId }
+        });
+        for (const o of ro) {
+            log += `${await logOutput(storage, o)}`;
+            amount += o.spendable ? o.satoshis : 0;
+        }
+    }
+    log += `------------------\namount: ${amount}\n`;
+    return log;
+}
+async function logOutput(storage, output) {
+    let log = `satoshis: ${output.satoshis}\n`;
+    log += `spendable: ${output.spendable}\n`;
+    log += `change: ${output.change}\n`;
+    log += `providedBy: ${output.providedBy}\n`;
+    log += `spentBy: ${output.providedBy}\n`;
+    if (output.basketId) {
+        const rb = await storage.findOutputBaskets({
+            partial: { basketId: output.basketId }
+        });
+        log += `basket:${await logBasket(storage, rb[0])}\n`;
+    }
+    return log;
+}
+function logBasket(storage, basket) {
+    let log = `${basket.name}\n`;
+    return log;
+}
+//# sourceMappingURL=TestUtilsWalletStorage.js.map