@bsv/wallet-toolbox-client 2.4.4 → 2.4.20

package/out/src/storage/portable/index.js

@@ -1,872 +0,0 @@
-"use strict";
-/* eslint-disable @typescript-eslint/triple-slash-reference */
-/// <reference path="../../types/bsv-sdk-aesgcm.d.ts" />
-/* eslint-enable @typescript-eslint/triple-slash-reference */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exportBRC38 = exportBRC38;
-exports.exportBRC38Json = exportBRC38Json;
-exports.parseBRC38Json = parseBRC38Json;
-exports.importBRC38 = importBRC38;
-exports.exportBRC39 = exportBRC39;
-exports.importBRC39 = importBRC39;
-exports.encryptBRC39 = encryptBRC39;
-exports.decryptBRC39 = decryptBRC39;
-const sdk_1 = require("@bsv/sdk");
-const AESGCM_1 = require("@bsv/sdk/primitives/AESGCM");
-const hash_wasm_1 = require("hash-wasm");
-const EntityBase_1 = require("../schema/entities/EntityBase");
-const utilityHelpers_1 = require("../../utility/utilityHelpers");
-const BRC38_TITLE = 'User Wallet Data Format';
-const BRC39_MAGIC = [0x57, 0x44, 0x41, 0x54]; // WDAT
-const BRC39_HEADER_LENGTH = 33;
-const BRC39_TAG_LENGTH = 16;
-const BRC39_DEFAULT_ITERATIONS = 7;
-const BRC39_DEFAULT_MEMORY_KIB = 131072;
-const BRC39_DEFAULT_PARALLELISM = 1;
-const BRC39_HASH_LENGTH = 32;
-const BRC39_SALT_LENGTH = 32;
-const BRC39_NONCE_LENGTH = 32;
-const tableNames = [
-    'provenTxs',
-    'provenTxReqs',
-    'outputBaskets',
-    'transactions',
-    'commissions',
-    'outputs',
-    'outputTags',
-    'outputTagMaps',
-    'txLabels',
-    'txLabelMaps',
-    'certificates',
-    'certificateFields',
-    'syncStates'
-];
-const SYNC_CHUNK_ENTITY_ORDER = [
-    'provenTx',
-    'outputBasket',
-    'outputTag',
-    'txLabel',
-    'transaction',
-    'output',
-    'txLabelMap',
-    'outputTagMap',
-    'certificate',
-    'certificateField',
-    'commission',
-    'provenTxReq'
-];
-const binaryFieldsByKind = {
-    commission: ['lockingScript'],
-    output: ['lockingScript'],
-    provenTx: ['merklePath', 'rawTx'],
-    provenTxReq: ['rawTx', 'inputBEEF'],
-    transaction: ['inputBEEF', 'rawTx']
-};
-const jsonFieldsByKind = {
-    provenTxReq: ['history', 'notify'],
-    syncState: ['syncMap', 'errorLocal', 'errorOther']
-};
-const dateFieldsByKind = {
-    settings: ['created_at', 'updated_at'],
-    user: ['created_at', 'updated_at'],
-    provenTx: ['created_at', 'updated_at'],
-    provenTxReq: ['created_at', 'updated_at'],
-    outputBasket: ['created_at', 'updated_at'],
-    transaction: ['created_at', 'updated_at'],
-    commission: ['created_at', 'updated_at'],
-    output: ['created_at', 'updated_at'],
-    outputTag: ['created_at', 'updated_at'],
-    outputTagMap: ['created_at', 'updated_at'],
-    txLabel: ['created_at', 'updated_at'],
-    txLabelMap: ['created_at', 'updated_at'],
-    certificate: ['created_at', 'updated_at'],
-    certificateField: ['created_at', 'updated_at'],
-    syncState: ['created_at', 'updated_at', 'when']
-};
-async function exportBRC38(storage, identityKey) {
-    const sourceStorage = await storage.makeAvailable();
-    const user = (0, utilityHelpers_1.verifyTruthy)(await storage.findUserByIdentityKey(identityKey));
-    const userId = user.userId;
-    const transactions = await storage.findTransactions({ partial: { userId } });
-    const transactionIds = new Set(transactions.map(t => t.transactionId));
-    const transactionTxids = new Set(transactions.map(t => t.txid).filter((txid) => txid != null));
-    const provenTxReqs = (await storage.getProvenTxReqsForUser({ userId })).filter(r => transactionTxids.has(r.txid));
-    const provenTxIds = new Set();
-    for (const tx of transactions)
-        if (tx.provenTxId != null)
-            provenTxIds.add(tx.provenTxId);
-    for (const req of provenTxReqs)
-        if (req.provenTxId != null)
-            provenTxIds.add(req.provenTxId);
-    const provenTxs = [];
-    for (const provenTxId of Array.from(provenTxIds).sort(compareNumber)) {
-        const proven = (0, utilityHelpers_1.verifyOneOrNone)(await storage.findProvenTxs({ partial: { provenTxId } }));
-        if (proven != null)
-            provenTxs.push(proven);
-    }
-    const outputBaskets = await storage.findOutputBaskets({ partial: { userId } });
-    const commissions = await storage.findCommissions({ partial: { userId } });
-    const outputs = await storage.findOutputs({ partial: { userId } });
-    const outputTags = await storage.findOutputTags({ partial: { userId } });
-    const outputTagMaps = (await storage.getOutputTagMapsForUser({ userId }))
-        .filter(m => outputs.some(o => o.outputId === m.outputId));
-    const txLabels = await storage.findTxLabels({ partial: { userId } });
-    const txLabelMaps = (await storage.getTxLabelMapsForUser({ userId }))
-        .filter(m => transactionIds.has(m.transactionId));
-    const certificates = await storage.findCertificates({ partial: { userId } });
-    const certificateFields = await storage.findCertificateFields({ partial: { userId } });
-    const syncStates = await storage.findSyncStates({ partial: { userId } });
-    const data = {
-        brc: 38,
-        title: BRC38_TITLE,
-        formatVersion: 1,
-        exportedAt: isoDate(new Date()),
-        sourceStorage: portableRow('settings', sourceStorage),
-        user: portableRow('user', user),
-        tables: {
-            provenTxs: provenTxs.map(r => portableRow('provenTx', r)),
-            provenTxReqs: provenTxReqs.map(r => portableRow('provenTxReq', r)),
-            outputBaskets: outputBaskets.map(r => portableRow('outputBasket', r)),
-            transactions: transactions.map(r => portableRow('transaction', r)),
-            commissions: commissions.map(r => portableRow('commission', r)),
-            outputs: outputs.map(r => portableRow('output', r)),
-            outputTags: outputTags.map(r => portableRow('outputTag', r)),
-            outputTagMaps: outputTagMaps.map(r => portableRow('outputTagMap', r)),
-            txLabels: txLabels.map(r => portableRow('txLabel', r)),
-            txLabelMaps: txLabelMaps.map(r => portableRow('txLabelMap', r)),
-            certificates: certificates.map(r => {
-                const row = portableRow('certificate', r);
-                delete row.fields;
-                return row;
-            }),
-            certificateFields: certificateFields.map(r => portableRow('certificateField', r)),
-            syncStates: syncStates.map(r => portableRow('syncState', r))
-        }
-    };
-    sortBRC38Tables(data.tables);
-    validateBRC38(data);
-    return data;
-}
-async function exportBRC38Json(storage, identityKey) {
-    return canonicalize(await exportBRC38(storage, identityKey));
-}
-function parseBRC38Json(json) {
-    let data;
-    try {
-        data = JSON.parse(json);
-    }
-    catch (e) {
-        throw new Error(`Invalid BRC-38 JSON: ${e.message}`);
-    }
-    return validateBRC38(data);
-}
-async function importBRC38(storage, documentOrJson, options) {
-    const data = typeof documentOrJson === 'string' ? parseBRC38Json(documentOrJson) : validateBRC38(documentOrJson);
-    const targetSettings = await storage.makeAvailable();
-    const decoded = decodeBRC38(data);
-    if (decoded.sourceStorage.chain !== targetSettings.chain) {
-        throw new Error(`BRC-38 chain mismatch: payload is ${decoded.sourceStorage.chain}, target is ${targetSettings.chain}`);
-    }
-    if (options.mode === 'restore')
-        return await restoreBRC38(storage, decoded);
-    if (options.mode === 'merge')
-        return await mergeBRC38(storage, decoded, targetSettings);
-    throw new Error(`Unsupported BRC-38 import mode: ${String(options.mode)}`);
-}
-async function exportBRC39(storage, identityKey, password, options) {
-    return await encryptBRC39(await exportBRC38(storage, identityKey), password, options);
-}
-async function importBRC39(storage, bytes, password, options) {
-    return await importBRC38(storage, await decryptBRC39(bytes, password), options);
-}
-async function encryptBRC39(documentOrJson, password, options) {
-    const data = typeof documentOrJson === 'string' ? parseBRC38Json(documentOrJson) : validateBRC38(documentOrJson);
-    const plaintext = new Uint8Array(sdk_1.Utils.toArray(canonicalize(data), 'utf8'));
-    const salt = new Uint8Array((0, sdk_1.Random)(BRC39_SALT_LENGTH));
-    const nonce = new Uint8Array((0, sdk_1.Random)(BRC39_NONCE_LENGTH));
-    const iterations = options?.iterations ?? BRC39_DEFAULT_ITERATIONS;
-    const memoryKiB = options?.memoryKiB ?? BRC39_DEFAULT_MEMORY_KIB;
-    const parallelism = options?.parallelism ?? BRC39_DEFAULT_PARALLELISM;
-    validateKdfParams(iterations, memoryKiB, parallelism, BRC39_HASH_LENGTH);
-    validateExportKdfParams(iterations, memoryKiB);
-    const key = await deriveBRC39Key(password, salt, iterations, memoryKiB, parallelism);
-    const { result, authenticationTag } = (0, AESGCM_1.AESGCM)(plaintext, nonce, key);
-    const header = new Uint8Array(BRC39_HEADER_LENGTH + salt.length + nonce.length);
-    header.set(BRC39_MAGIC, 0);
-    header[4] = 1;
-    header[5] = 1;
-    header[6] = 38;
-    header[7] = 1;
-    header[8] = 0;
-    header[9] = salt.length;
-    header[10] = nonce.length;
-    writeUInt32BE(header, 11, iterations);
-    writeUInt32BE(header, 15, memoryKiB);
-    header[19] = parallelism;
-    header[20] = BRC39_HASH_LENGTH;
-    header.set(salt, BRC39_HEADER_LENGTH);
-    header.set(nonce, BRC39_HEADER_LENGTH + salt.length);
-    return Array.from(concatBytes(header, result, authenticationTag));
-}
-function parseBRC39Header(file) {
-    if (file.length < BRC39_HEADER_LENGTH + BRC39_TAG_LENGTH + 2)
-        throw new Error('Invalid BRC-39 file: too short');
-    for (let i = 0; i < BRC39_MAGIC.length; i++) {
-        if (file[i] !== BRC39_MAGIC[i])
-            throw new Error('Invalid BRC-39 file: bad magic');
-    }
-    assertHeaderConstants(file);
-    for (let i = 21; i < BRC39_HEADER_LENGTH; i++) {
-        if (file[i] !== 0)
-            throw new Error('Invalid BRC-39 reserved bytes');
-    }
-    const saltLength = file[9];
-    const nonceLength = file[10];
-    if (saltLength === 0)
-        throw new Error('Invalid BRC-39 salt length');
-    if (nonceLength === 0)
-        throw new Error('Invalid BRC-39 nonce length');
-    const iterations = readUInt32BE(file, 11);
-    const memoryKiB = readUInt32BE(file, 15);
-    const parallelism = file[19];
-    const hashLength = file[20];
-    validateKdfParams(iterations, memoryKiB, parallelism, hashLength);
-    return { saltLength, nonceLength, iterations, memoryKiB, parallelism, hashLength };
-}
-function assertHeaderConstants(file) {
-    if (file[4] !== 1)
-        throw new Error('Unsupported BRC-39 format version');
-    if (file[5] !== 1)
-        throw new Error('Unsupported BRC-39 protector type');
-    if (file[6] !== 38)
-        throw new Error('Unsupported BRC-39 inner format');
-    if (file[7] !== 1)
-        throw new Error('Unsupported BRC-39 KDF type');
-    if (file[8] !== 0)
-        throw new Error('Invalid BRC-39 flags');
-}
-async function decryptBRC39(bytes, password) {
-    const file = new Uint8Array(bytes);
-    const header = parseBRC39Header(file);
-    const payloadStart = BRC39_HEADER_LENGTH + header.saltLength + header.nonceLength;
-    if (file.length <= payloadStart + BRC39_TAG_LENGTH)
-        throw new Error('Invalid BRC-39 ciphertext');
-    const salt = file.slice(BRC39_HEADER_LENGTH, BRC39_HEADER_LENGTH + header.saltLength);
-    const nonce = file.slice(BRC39_HEADER_LENGTH + header.saltLength, payloadStart);
-    const ciphertext = file.slice(payloadStart, file.length - BRC39_TAG_LENGTH);
-    const tag = file.slice(file.length - BRC39_TAG_LENGTH);
-    const key = await deriveBRC39Key(password, salt, header.iterations, header.memoryKiB, header.parallelism);
-    const plaintext = (0, AESGCM_1.AESGCMDecrypt)(ciphertext, nonce, tag, key);
-    if (plaintext == null)
-        throw new Error('BRC-39 authentication failed');
-    return parseBRC38Json(sdk_1.Utils.toUTF8(Array.from(plaintext)));
-}
-function validateBRC38(value) {
-    rejectNulls(value, 'document');
-    if (!isObject(value))
-        throw new Error('BRC-38 document must be an object');
-    const data = value;
-    if (data.brc !== 38)
-        throw new Error('BRC-38 document brc must equal 38');
-    if (data.title !== BRC38_TITLE)
-        throw new Error('BRC-38 title must equal User Wallet Data Format');
-    if (data.formatVersion !== 1)
-        throw new Error('BRC-38 formatVersion must equal 1');
-    assertIsoDate(data.exportedAt, 'exportedAt');
-    if (!isObject(data.sourceStorage))
-        throw new Error('BRC-38 sourceStorage must be an object');
-    if (!isObject(data.user))
-        throw new Error('BRC-38 user must be an object');
-    if (!isObject(data.tables))
-        throw new Error('BRC-38 tables must be an object');
-    for (const name of tableNames) {
-        if (!Array.isArray(data.tables[name]))
-            throw new Error(`BRC-38 tables.${name} must be an array`);
-    }
-    validatePortableRows('settings', [data.sourceStorage], 'sourceStorage');
-    validatePortableRows('user', [data.user], 'user');
-    validatePortableRows('provenTx', data.tables.provenTxs, 'provenTxs');
-    validatePortableRows('provenTxReq', data.tables.provenTxReqs, 'provenTxReqs');
-    validatePortableRows('outputBasket', data.tables.outputBaskets, 'outputBaskets');
-    validatePortableRows('transaction', data.tables.transactions, 'transactions');
-    validatePortableRows('commission', data.tables.commissions, 'commissions');
-    validatePortableRows('output', data.tables.outputs, 'outputs');
-    validatePortableRows('outputTag', data.tables.outputTags, 'outputTags');
-    validatePortableRows('outputTagMap', data.tables.outputTagMaps, 'outputTagMaps');
-    validatePortableRows('txLabel', data.tables.txLabels, 'txLabels');
-    validatePortableRows('txLabelMap', data.tables.txLabelMaps, 'txLabelMaps');
-    validatePortableRows('certificate', data.tables.certificates, 'certificates');
-    validatePortableRows('certificateField', data.tables.certificateFields, 'certificateFields');
-    validatePortableRows('syncState', data.tables.syncStates, 'syncStates');
-    validateRelationships(data);
-    return data;
-}
-function decodeBRC38(data) {
-    return {
-        sourceStorage: fromPortableRow('settings', data.sourceStorage),
-        user: fromPortableRow('user', data.user),
-        provenTxs: data.tables.provenTxs.map(r => fromPortableRow('provenTx', r)),
-        provenTxReqs: data.tables.provenTxReqs.map(r => fromPortableRow('provenTxReq', r)),
-        outputBaskets: data.tables.outputBaskets.map(r => fromPortableRow('outputBasket', r)),
-        transactions: data.tables.transactions.map(r => fromPortableRow('transaction', r)),
-        commissions: data.tables.commissions.map(r => fromPortableRow('commission', r)),
-        outputs: data.tables.outputs.map(r => fromPortableRow('output', r)),
-        outputTags: data.tables.outputTags.map(r => fromPortableRow('outputTag', r)),
-        outputTagMaps: data.tables.outputTagMaps.map(r => fromPortableRow('outputTagMap', r)),
-        txLabels: data.tables.txLabels.map(r => fromPortableRow('txLabel', r)),
-        txLabelMaps: data.tables.txLabelMaps.map(r => fromPortableRow('txLabelMap', r)),
-        certificates: data.tables.certificates.map(r => fromPortableRow('certificate', r)),
-        certificateFields: data.tables.certificateFields.map(r => fromPortableRow('certificateField', r)),
-        syncStates: data.tables.syncStates.map(r => fromPortableRow('syncState', r))
-    };
-}
-async function restoreBRC38(storage, data) {
-    await assertRestoreTargetEmpty(storage);
-    await storage.transaction(async (trx) => {
-        await storage.insertUser({ ...data.user }, trx);
-        for (const row of data.provenTxs)
-            await storage.insertProvenTx({ ...row }, trx);
-        for (const row of data.outputBaskets)
-            await storage.insertOutputBasket({ ...row }, trx);
-        for (const row of data.outputTags)
-            await storage.insertOutputTag({ ...row }, trx);
-        for (const row of data.txLabels)
-            await storage.insertTxLabel({ ...row }, trx);
-        for (const row of data.transactions)
-            await storage.insertTransaction({ ...row }, trx);
-        for (const row of data.outputs)
-            await storage.insertOutput({ ...row }, trx);
-        for (const row of data.txLabelMaps)
-            await storage.insertTxLabelMap({ ...row }, trx);
-        for (const row of data.outputTagMaps)
-            await storage.insertOutputTagMap({ ...row }, trx);
-        for (const row of data.certificates)
-            await storage.insertCertificate({ ...row }, trx);
-        for (const row of data.certificateFields)
-            await storage.insertCertificateField({ ...row }, trx);
-        for (const row of data.commissions)
-            await storage.insertCommission({ ...row }, trx);
-        for (const row of data.provenTxReqs)
-            await storage.insertProvenTxReq({ ...row }, trx);
-        for (const row of data.syncStates)
-            await storage.insertSyncState({ ...row }, trx);
-    });
-    return {
-        mode: 'restore',
-        identityKey: data.user.identityKey,
-        userId: data.user.userId,
-        inserts: 1 + countDecodedRows(data),
-        updates: 0
-    };
-}
-async function mergeBRC38(storage, data, targetSettings) {
-    const { user: targetUser } = await storage.findOrInsertUser(data.user.identityKey);
-    await storage.findOrInsertSyncStateAuth({ identityKey: data.user.identityKey, userId: targetUser.userId }, data.sourceStorage.storageIdentityKey, data.sourceStorage.storageName);
-    const chunk = {
-        fromStorageIdentityKey: data.sourceStorage.storageIdentityKey,
-        toStorageIdentityKey: targetSettings.storageIdentityKey,
-        userIdentityKey: data.user.identityKey,
-        user: { ...data.user, activeStorage: targetUser.activeStorage },
-        provenTxs: data.provenTxs.map(r => ({ ...r })),
-        outputBaskets: data.outputBaskets.map(r => ({ ...r })),
-        outputTags: data.outputTags.map(r => ({ ...r })),
-        txLabels: data.txLabels.map(r => ({ ...r })),
-        transactions: data.transactions.map(r => ({ ...r })),
-        outputs: data.outputs.map(r => ({ ...r })),
-        txLabelMaps: data.txLabelMaps.map(r => ({ ...r })),
-        outputTagMaps: data.outputTagMaps.map(r => ({ ...r })),
-        certificates: data.certificates.map(r => ({ ...r })),
-        certificateFields: data.certificateFields.map(r => ({ ...r })),
-        commissions: data.commissions.map(r => ({ ...r })),
-        provenTxReqs: data.provenTxReqs.map(r => ({ ...r }))
-    };
-    const args = {
-        fromStorageIdentityKey: chunk.fromStorageIdentityKey,
-        toStorageIdentityKey: chunk.toStorageIdentityKey,
-        identityKey: data.user.identityKey,
-        maxRoughSize: Number.MAX_SAFE_INTEGER,
-        maxItems: Number.MAX_SAFE_INTEGER,
-        offsets: SYNC_CHUNK_ENTITY_ORDER.map(name => ({ name, offset: 0 }))
-    };
-    const first = await storage.processSyncChunk(args, chunk);
-    const done = await storage.processSyncChunk(args, {
-        fromStorageIdentityKey: chunk.fromStorageIdentityKey,
-        toStorageIdentityKey: chunk.toStorageIdentityKey,
-        userIdentityKey: data.user.identityKey,
-        provenTxs: [],
-        outputBaskets: [],
-        outputTags: [],
-        txLabels: [],
-        transactions: [],
-        outputs: [],
-        txLabelMaps: [],
-        outputTagMaps: [],
-        certificates: [],
-        certificateFields: [],
-        commissions: [],
-        provenTxReqs: []
-    });
-    const currentSyncState = (0, utilityHelpers_1.verifyOne)(await storage.findSyncStates({
-        partial: {
-            userId: targetUser.userId,
-            storageIdentityKey: data.sourceStorage.storageIdentityKey,
-            storageName: data.sourceStorage.storageName
-        }
-    }));
-    const importMap = normalizeSyncMap(JSON.parse(currentSyncState.syncMap));
-    const syncStateResult = await mergeImportedSyncStates(storage, data.syncStates, targetUser.userId, importMap, data.sourceStorage);
-    return {
-        mode: 'merge',
-        identityKey: data.user.identityKey,
-        userId: targetUser.userId,
-        inserts: first.inserts + done.inserts + syncStateResult.inserts,
-        updates: first.updates + done.updates + syncStateResult.updates
-    };
-}
-async function mergeImportedSyncStates(storage, syncStates, userId, importMap, sourceStorage) {
-    let inserts = 0;
-    let updates = 0;
-    for (const source of syncStates) {
-        const row = {
-            ...source,
-            userId,
-            syncMap: JSON.stringify(remapSyncMap(JSON.parse(source.syncMap), importMap))
-        };
-        const existing = (0, utilityHelpers_1.verifyOneOrNone)(await storage.findSyncStates({
-            partial: {
-                userId,
-                storageIdentityKey: row.storageIdentityKey,
-                storageName: row.storageName
-            }
-        }));
-        if (existing == null) {
-            row.syncStateId = 0;
-            await storage.insertSyncState(row);
-            inserts++;
-        }
-        else {
-            row.syncStateId = existing.syncStateId;
-            if (row.storageIdentityKey === sourceStorage.storageIdentityKey &&
-                row.storageName === sourceStorage.storageName) {
-                row.syncMap = existing.syncMap;
-            }
-            await storage.updateSyncState(existing.syncStateId, row);
-            updates++;
-        }
-    }
-    return { inserts, updates };
-}
-function remapSyncMap(source, importMap) {
-    const copy = normalizeSyncMap(source);
-    remapEntityIdMap(copy.provenTx.idMap, importMap.provenTx.idMap);
-    remapEntityIdMap(copy.outputBasket.idMap, importMap.outputBasket.idMap);
-    remapEntityIdMap(copy.transaction.idMap, importMap.transaction.idMap);
-    remapEntityIdMap(copy.provenTxReq.idMap, importMap.provenTxReq.idMap);
-    remapEntityIdMap(copy.txLabel.idMap, importMap.txLabel.idMap);
-    remapEntityIdMap(copy.output.idMap, importMap.output.idMap);
-    remapEntityIdMap(copy.outputTag.idMap, importMap.outputTag.idMap);
-    remapEntityIdMap(copy.certificate.idMap, importMap.certificate.idMap);
-    remapEntityIdMap(copy.commission.idMap, importMap.commission.idMap);
-    return copy;
-}
-function normalizeSyncMap(source) {
-    const normalized = (0, EntityBase_1.createSyncMap)();
-    if (!isObject(source))
-        return normalized;
-    for (const key of Object.keys(normalized)) {
-        const incoming = source[key];
-        if (isObject(incoming))
-            mergeSyncMapEntry(normalized[key], incoming);
-    }
-    return normalized;
-}
-function mergeSyncMapEntry(target, incoming) {
-    if (typeof incoming.entityName === 'string')
-        target.entityName = incoming.entityName;
-    if (Number.isInteger(incoming.count))
-        target.count = incoming.count;
-    if (isObject(incoming.idMap))
-        target.idMap = parseIdMap(incoming.idMap);
-    applyMaxUpdatedAt(target, incoming.maxUpdated_at);
-}
-function parseIdMap(incoming) {
-    const idMap = {};
-    for (const [remoteId, localId] of Object.entries(incoming)) {
-        const parsedRemoteId = Number(remoteId);
-        if (Number.isInteger(parsedRemoteId) && Number.isInteger(localId)) {
-            idMap[parsedRemoteId] = localId;
-        }
-    }
-    return idMap;
-}
-function applyMaxUpdatedAt(target, value) {
-    if (typeof value === 'string') {
-        const maxUpdatedAt = new Date(value);
-        if (!Number.isNaN(maxUpdatedAt.getTime()))
-            target.maxUpdated_at = maxUpdatedAt;
-    }
-    else if (value instanceof Date) {
-        target.maxUpdated_at = value;
-    }
-}
-function remapEntityIdMap(idMap, importIdMap) {
-    for (const key of Object.keys(idMap)) {
-        const targetId = importIdMap[idMap[Number(key)]];
-        if (targetId != null)
-            idMap[Number(key)] = targetId;
-    }
-}
-async function assertRestoreTargetEmpty(storage) {
-    const counts = await Promise.all([
-        storage.countUsers({ partial: {} }),
-        storage.countProvenTxs({ partial: {} }),
-        storage.countProvenTxReqs({ partial: {} }),
-        storage.countOutputBaskets({ partial: {} }),
-        storage.countTransactions({ partial: {} }),
-        storage.countCommissions({ partial: {} }),
-        storage.countOutputs({ partial: {} }),
-        storage.countOutputTags({ partial: {} }),
-        storage.countOutputTagMaps({ partial: {} }),
-        storage.countTxLabels({ partial: {} }),
-        storage.countTxLabelMaps({ partial: {} }),
-        storage.countCertificates({ partial: {} }),
-        storage.countCertificateFields({ partial: {} }),
-        storage.countSyncStates({ partial: {} }),
-        storage.countMonitorEvents({ partial: {} })
-    ]);
-    if (counts.some(c => c > 0))
-        throw new Error('BRC-38 restore requires an empty target storage except settings');
-}
-function countDecodedRows(data) {
-    return data.provenTxs.length + data.provenTxReqs.length + data.outputBaskets.length + data.transactions.length +
-        data.commissions.length + data.outputs.length + data.outputTags.length + data.outputTagMaps.length +
-        data.txLabels.length + data.txLabelMaps.length + data.certificates.length + data.certificateFields.length +
-        data.syncStates.length;
-}
-function buildRelationshipIndex(data) {
-    return {
-        userId: requireNumber(data.user.userId, 'user.userId'),
-        txIds: ids(data.tables.transactions, 'transactionId', 'transactions'),
-        txidValues: new Set(data.tables.transactions.map(t => t.txid).filter((v) => typeof v === 'string')),
-        provenTxIds: ids(data.tables.provenTxs, 'provenTxId', 'provenTxs'),
-        basketIds: ids(data.tables.outputBaskets, 'basketId', 'outputBaskets'),
-        outputIds: ids(data.tables.outputs, 'outputId', 'outputs'),
-        outputTagIds: ids(data.tables.outputTags, 'outputTagId', 'outputTags'),
-        txLabelIds: ids(data.tables.txLabels, 'txLabelId', 'txLabels'),
-        certificateIds: ids(data.tables.certificates, 'certificateId', 'certificates')
-    };
-}
-function requireRef(set, value, path, message) {
-    if (!set.has(requireNumber(value, path)))
-        throw new Error(message);
-}
-function validateTransactions(data, idx) {
-    for (const row of data.tables.transactions) {
-        requireUserId(row, idx.userId, 'transactions');
-        if (row.provenTxId != null) {
-            requireRef(idx.provenTxIds, row.provenTxId, 'transaction.provenTxId', 'BRC-38 transaction.provenTxId does not reference an exported provenTx');
-        }
-    }
-}
-function validateOutputs(data, idx) {
-    for (const row of data.tables.outputs) {
-        requireUserId(row, idx.userId, 'outputs');
-        requireRef(idx.txIds, row.transactionId, 'output.transactionId', 'BRC-38 output.transactionId does not reference an exported transaction');
-        if (row.basketId != null) {
-            requireRef(idx.basketIds, row.basketId, 'output.basketId', 'BRC-38 output.basketId does not reference an exported output basket');
-        }
-        if (row.spentBy != null) {
-            requireRef(idx.txIds, row.spentBy, 'output.spentBy', 'BRC-38 output.spentBy does not reference an exported transaction');
-        }
-    }
-}
-function validateCommissions(data, idx) {
-    for (const row of data.tables.commissions) {
-        requireUserId(row, idx.userId, 'commissions');
-        requireRef(idx.txIds, row.transactionId, 'commission.transactionId', 'BRC-38 commission.transactionId does not reference an exported transaction');
-    }
-}
-function validateTxLabelMaps(data, idx) {
-    for (const row of data.tables.txLabelMaps) {
-        requireRef(idx.txIds, row.transactionId, 'txLabelMap.transactionId', 'BRC-38 txLabelMap.transactionId does not reference an exported transaction');
-        requireRef(idx.txLabelIds, row.txLabelId, 'txLabelMap.txLabelId', 'BRC-38 txLabelMap.txLabelId does not reference an exported transaction label');
-    }
-}
-function validateOutputTagMaps(data, idx) {
-    for (const row of data.tables.outputTagMaps) {
-        requireRef(idx.outputIds, row.outputId, 'outputTagMap.outputId', 'BRC-38 outputTagMap.outputId does not reference an exported output');
-        requireRef(idx.outputTagIds, row.outputTagId, 'outputTagMap.outputTagId', 'BRC-38 outputTagMap.outputTagId does not reference an exported output tag');
-    }
-}
-function validateCertificateFields(data, idx) {
-    for (const row of data.tables.certificateFields) {
-        requireUserId(row, idx.userId, 'certificateFields');
-        requireRef(idx.certificateIds, row.certificateId, 'certificateField.certificateId', 'BRC-38 certificateField.certificateId does not reference an exported certificate');
-    }
-}
-function validateProvenTxReqs(data, idx) {
-    for (const row of data.tables.provenTxReqs) {
-        if (!idx.txidValues.has(requireString(row.txid, 'provenTxReq.txid'))) {
-            throw new Error('BRC-38 provenTxReq.txid does not match an exported transaction');
-        }
-        if (row.provenTxId != null) {
-            requireRef(idx.provenTxIds, row.provenTxId, 'provenTxReq.provenTxId', 'BRC-38 provenTxReq.provenTxId does not reference an exported provenTx');
-        }
-    }
-}
-function validateRelationships(data) {
-    const idx = buildRelationshipIndex(data);
-    validateTransactions(data, idx);
-    for (const row of data.tables.outputBaskets)
-        requireUserId(row, idx.userId, 'outputBaskets');
-    for (const row of data.tables.outputTags)
-        requireUserId(row, idx.userId, 'outputTags');
-    for (const row of data.tables.txLabels)
-        requireUserId(row, idx.userId, 'txLabels');
-    for (const row of data.tables.certificates)
-        requireUserId(row, idx.userId, 'certificates');
-    for (const row of data.tables.syncStates)
-        requireUserId(row, idx.userId, 'syncStates');
-    validateOutputs(data, idx);
-    validateCommissions(data, idx);
-    validateTxLabelMaps(data, idx);
-    validateOutputTagMaps(data, idx);
-    validateCertificateFields(data, idx);
-    validateProvenTxReqs(data, idx);
-}
-function validatePortableRows(kind, rows, path) {
-    const dateFields = new Set(dateFieldsByKind[kind] ?? []);
-    const binaryFields = new Set(binaryFieldsByKind[kind] ?? []);
-    const jsonFields = new Set(jsonFieldsByKind[kind] ?? []);
-    for (const [index, row] of rows.entries()) {
-        validatePortableRow(row, `${path}[${index}]`, dateFields, binaryFields, jsonFields);
-    }
-}
-function validatePortableRow(row, rowPath, dateFields, binaryFields, jsonFields) {
-    if (!isObject(row))
-        throw new Error(`BRC-38 ${rowPath} must be an object`);
-    for (const field of dateFields) {
-        if (field in row)
-            assertIsoDate(row[field], `${rowPath}.${field}`);
-    }
-    for (const field of binaryFields) {
-        if (field in row)
-            assertBase64(row[field], `${rowPath}.${field}`);
-    }
-    for (const field of jsonFields) {
-        if (field in row && !isObject(row[field]))
-            throw new Error(`BRC-38 ${rowPath}.${field} must be an object`);
-    }
-}
-function portableRow(kind, row) {
-    const out = {};
-    const binaryFields = new Set(binaryFieldsByKind[kind] ?? []);
-    const jsonFields = new Set(jsonFieldsByKind[kind] ?? []);
-    for (const [key, value] of Object.entries(row)) {
-        if (value == null)
-            continue;
-        if (key === 'logger')
-            continue;
-        if (binaryFields.has(key)) {
-            out[key] = sdk_1.Utils.toBase64(value);
-        }
-        else if (jsonFields.has(key)) {
-            out[key] = typeof value === 'string' ? JSON.parse(value) : value;
-        }
-        else if (value instanceof Date) {
-            out[key] = isoDate(value);
-        }
-        else {
-            out[key] = value;
-        }
-    }
-    return out;
-}
-function fromPortableRow(kind, row) {
-    const out = {};
-    const dateFields = new Set(dateFieldsByKind[kind] ?? []);
-    const binaryFields = new Set(binaryFieldsByKind[kind] ?? []);
-    const jsonFields = new Set(jsonFieldsByKind[kind] ?? []);
-    for (const [key, value] of Object.entries(row)) {
-        if (dateFields.has(key))
-            out[key] = new Date(value);
-        else if (binaryFields.has(key))
-            out[key] = sdk_1.Utils.toArray(value, 'base64');
-        else if (jsonFields.has(key))
-            out[key] = JSON.stringify(value);
-        else
-            out[key] = value;
-    }
-    return out;
-}
-function sortBRC38Tables(tables) {
-    tables.provenTxs.sort(byNumber('provenTxId'));
-    tables.provenTxReqs.sort(byNumber('provenTxReqId'));
-    tables.outputBaskets.sort(byNumber('basketId'));
-    tables.transactions.sort(byNumber('transactionId'));
-    tables.commissions.sort(byNumber('commissionId'));
-    tables.outputs.sort(byNumber('outputId'));
-    tables.outputTags.sort(byNumber('outputTagId'));
-    tables.outputTagMaps.sort(byNumber('outputId', 'outputTagId'));
-    tables.txLabels.sort(byNumber('txLabelId'));
-    tables.txLabelMaps.sort(byNumber('transactionId', 'txLabelId'));
-    tables.certificates.sort(byNumber('certificateId'));
-    tables.certificateFields.sort((a, b) => {
-        const certificateIdOrder = requireNumber(a.certificateId, 'certificateId') - requireNumber(b.certificateId, 'certificateId');
-        if (certificateIdOrder !== 0)
-            return certificateIdOrder;
-        return requireString(a.fieldName, 'fieldName').localeCompare(requireString(b.fieldName, 'fieldName'));
-    });
-    tables.syncStates.sort(byNumber('syncStateId'));
-}
-function byNumber(field, secondField) {
-    return (a, b) => {
-        const first = requireNumber(a[field], field) - requireNumber(b[field], field);
-        if (first !== 0 || secondField == null)
-            return first;
-        return requireNumber(a[secondField], secondField) - requireNumber(b[secondField], secondField);
-    };
-}
-function ids(rows, field, label) {
-    const set = new Set();
-    for (const row of rows) {
-        const id = requireNumber(row[field], `${label}.${field}`);
-        if (set.has(id))
-            throw new Error(`BRC-38 duplicate ${label}.${field}: ${id}`);
-        set.add(id);
-    }
-    return set;
-}
-function requireUserId(row, userId, label) {
-    if (requireNumber(row.userId, `${label}.userId`) !== userId)
-        throw new Error(`BRC-38 ${label}.userId does not match user.userId`);
-}
-function requireNumber(value, path) {
-    if (!Number.isInteger(value))
-        throw new Error(`BRC-38 ${path} must be an integer`);
-    return value;
-}
-function requireString(value, path) {
-    if (typeof value !== 'string')
-        throw new Error(`BRC-38 ${path} must be a string`);
-    return value;
-}
-function assertIsoDate(value, path) {
-    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value)) {
-        throw new Error(`BRC-38 ${path} must be a UTC ISO timestamp`);
-    }
-    const date = new Date(value);
-    if (Number.isNaN(date.getTime()) || date.toISOString() !== value)
-        throw new Error(`BRC-38 ${path} is invalid`);
-}
-function assertBase64(value, path) {
-    if (typeof value !== 'string' || value.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(value)) {
-        throw new Error(`BRC-38 ${path} must be padded base64`);
-    }
-}
-function rejectNulls(value, path) {
-    if (value === null)
-        throw new Error(`BRC-38 ${path} must omit null values`);
-    if (Array.isArray(value)) {
-        for (let i = 0; i < value.length; i++)
-            rejectNulls(value[i], `${path}[${i}]`);
-    }
-    else if (isObject(value)) {
-        for (const [key, child] of Object.entries(value))
-            rejectNulls(child, `${path}.${key}`);
-    }
-}
-function canonicalize(value) {
-    if (value === null || value === undefined)
-        throw new Error('Cannot canonicalize null or undefined');
-    if (typeof value === 'string')
-        return JSON.stringify(value);
-    if (typeof value === 'number') {
-        if (!Number.isFinite(value))
-            throw new Error('Cannot canonicalize non-finite number');
-        return JSON.stringify(value);
-    }
-    if (typeof value === 'boolean')
-        return value ? 'true' : 'false';
-    if (Array.isArray(value))
-        return `[${value.map(canonicalize).join(',')}]`;
-    if (isObject(value)) {
-        const entries = Object.keys(value)
-            .sort(compareCodepoints)
-            .map(key => canonicalizeEntry(key, value[key]));
-        return `{${entries.join(',')}}`;
-    }
-    throw new Error(`Unsupported JSON value type: ${typeof value}`);
-}
-function canonicalizeEntry(key, value) {
-    return `${JSON.stringify(key)}:${canonicalize(value)}`;
-}
-function compareCodepoints(a, b) {
-    if (a < b)
-        return -1;
-    if (a > b)
-        return 1;
-    return 0;
-}
-function isoDate(date) {
-    return date.toISOString();
-}
-function isObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function compareNumber(a, b) {
-    return a - b;
-}
-function concatBytes(...arrays) {
-    const total = arrays.reduce((sum, a) => sum + a.length, 0);
-    const out = new Uint8Array(total);
-    let offset = 0;
-    for (const array of arrays) {
-        out.set(array, offset);
-        offset += array.length;
-    }
-    return out;
-}
-async function deriveBRC39Key(password, salt, iterations, memoryKiB, parallelism) {
-    const normalized = password.normalize('NFC');
-    const hash = await (0, hash_wasm_1.argon2id)({
-        password: new Uint8Array(sdk_1.Utils.toArray(normalized, 'utf8')),
-        salt,
-        iterations,
-        memorySize: memoryKiB,
-        parallelism,
-        hashLength: BRC39_HASH_LENGTH,
-        outputType: 'binary'
-    });
-    return new Uint8Array(hash);
-}
-function validateKdfParams(iterations, memoryKiB, parallelism, hashLength) {
-    if (!Number.isInteger(iterations) || iterations <= 0)
-        throw new Error('Invalid BRC-39 Argon2id iterations');
-    if (!Number.isInteger(memoryKiB) || memoryKiB <= 0)
-        throw new Error('Invalid BRC-39 Argon2id memoryKiB');
-    if (!Number.isInteger(parallelism) || parallelism <= 0 || parallelism > 255)
-        throw new Error('Invalid BRC-39 Argon2id parallelism');
-    if (hashLength !== BRC39_HASH_LENGTH)
-        throw new Error('Invalid BRC-39 Argon2id hashLength');
-}
-function validateExportKdfParams(iterations, memoryKiB) {
-    if (iterations < BRC39_DEFAULT_ITERATIONS) {
-        throw new Error('BRC-39 export iterations must not be weaker than the canonical default');
-    }
-    if (memoryKiB < BRC39_DEFAULT_MEMORY_KIB) {
-        throw new Error('BRC-39 export memoryKiB must not be weaker than the canonical default');
-    }
-}
-function writeUInt32BE(target, offset, value) {
-    if (!Number.isInteger(value) || value < 0 || value > 0xffffffff)
-        throw new Error('BRC-39 integer out of range');
-    target[offset] = (value >>> 24) & 0xff;
-    target[offset + 1] = (value >>> 16) & 0xff;
-    target[offset + 2] = (value >>> 8) & 0xff;
-    target[offset + 3] = value & 0xff;
-}
-function readUInt32BE(source, offset) {
-    return ((source[offset] << 24) >>> 0) + (source[offset + 1] << 16) + (source[offset + 2] << 8) + source[offset + 3];
-}
-//# sourceMappingURL=index.js.map