@bopen-io/wallet-toolbox 2.1.21-parity-fix.2 → 2.6.2-brc153.2

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

@@ -0,0 +1,872 @@
+"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 hashWasm_1 = require("../../utility/hashWasm");
+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, hashWasm_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