nostr-bray 2.4.0 → 3.0.0

package/dist/zap/handlers.js

@@ -1,50 +1,101 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { getConversationKey, encrypt, decrypt } from 'nostr-tools/nip44';
-import { finalizeEvent } from 'nostr-tools/pure';
+import { chmodSync, renameSync, unlinkSync, writeFileSync, mkdirSync, existsSync, } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { basename, dirname, isAbsolute, join } from 'node:path';
+import { NwcClient, NwcError, inspectNwcConnection } from '@forgesworn/nwc-kit';
+import { NwcTransactionHistoryClient } from '@forgesworn/nwc-kit/extensions/05';
+import { tryDecodeBolt11, verifyPreimage } from 'farrier-kit';
+import { readPrivateRegularFile, readNwcUriFile, } from './nwc-file.js';
+const PUBKEY_HEX = /^[0-9a-f]{64}$/i;
+const MAX_WALLETS_FILE_BYTES = 1_048_576;
+const MAX_WALLETS = 128;
+const MAX_PATH_CHARS = 4096;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function validateWalletFiles(value) {
+    if (!isRecord(value) || Object.keys(value).length > MAX_WALLETS) {
+        throw new Error(`Wallet registry must contain at most ${MAX_WALLETS} entries`);
+    }
+    const walletFiles = {};
+    for (const [pubkey, filePath] of Object.entries(value)) {
+        if (!PUBKEY_HEX.test(pubkey) ||
+            typeof filePath !== 'string' ||
+            filePath.length === 0 ||
+            filePath.length > MAX_PATH_CHARS ||
+            !isAbsolute(filePath)) {
+            throw new Error('Wallet registry contains an invalid public key or secret-file path');
+        }
+        walletFiles[pubkey.toLowerCase()] = filePath;
+    }
+    return walletFiles;
+}
 /**
  * Load the wallets map from the JSON file. Returns empty map if file missing.
  *
  * @param walletsFile - Absolute path to the JSON wallets store.
- * @returns A map of public key hex strings to NWC URIs.
+ * @returns A map of public key hex strings to absolute NWC secret-file paths.
  *
  * @example
  * const wallets = loadWallets('/home/user/.bray/wallets.json')
- * // { 'abc123...': 'nostr+walletconnect://...' }
+ * // { 'abc123...': '/run/secrets/alice-nwc' }
  */
 export function loadWallets(walletsFile) {
     if (!walletsFile || !existsSync(walletsFile))
         return {};
+    const bytes = readPrivateRegularFile(walletsFile, MAX_WALLETS_FILE_BYTES, 'Wallet registry');
+    let parsed;
     try {
-        const data = JSON.parse(readFileSync(walletsFile, 'utf-8'));
-        return data.wallets ?? {};
+        parsed = JSON.parse(bytes.toString('utf-8'));
     }
     catch {
-        return {};
+        throw new Error('Wallet registry is not valid JSON');
     }
+    finally {
+        bytes.fill(0);
+    }
+    if (!isRecord(parsed) ||
+        parsed.version !== 1 ||
+        !('walletFiles' in parsed) ||
+        Object.keys(parsed).some((key) => key !== 'version' && key !== 'walletFiles')) {
+        throw new Error('Wallet registry has an unsupported or unsafe format');
+    }
+    return validateWalletFiles(parsed.walletFiles);
 }
 /**
  * Save the wallets map to the JSON file. Creates parent dirs and sets 0600.
  *
  * @param walletsFile - Absolute path to the JSON wallets store.
- * @param wallets - Map of public key hex strings to NWC URIs to persist.
+ * @param wallets - Map of public key hex strings to absolute NWC secret-file paths.
  * @returns void
  *
  * @example
  * saveWallets('/home/user/.bray/wallets.json', {
- *   'abc123...': 'nostr+walletconnect://pubkey?relay=wss://relay.example&secret=deadbeef',
+ *   'abc123...': '/run/secrets/alice-nwc',
  * })
  */
 export function saveWallets(walletsFile, wallets) {
+    if (!walletsFile)
+        throw new Error('Wallet registry path is not configured');
+    const validated = validateWalletFiles(wallets);
     const dir = dirname(walletsFile);
     if (!existsSync(dir))
         mkdirSync(dir, { recursive: true, mode: 0o700 });
-    const data = { wallets };
-    writeFileSync(walletsFile, JSON.stringify(data, null, 2) + '\n', { mode: 0o600 });
+    const data = { version: 1, walletFiles: validated };
+    const temporary = join(dir, `.${basename(walletsFile)}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        writeFileSync(temporary, JSON.stringify(data, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+        chmodSync(temporary, 0o600);
+        renameSync(temporary, walletsFile);
+        chmodSync(walletsFile, 0o600);
+    }
+    finally {
+        if (existsSync(temporary))
+            unlinkSync(temporary);
+    }
 }
 /**
  * Resolve the NWC URI for the active identity.
- * 1. Per-identity wallet from wallets file
+ * 1. Per-identity NWC secret file referenced by the wallet registry
  * 2. Global NWC URI (fallback)
  * 3. undefined (no wallet configured)
  *
@@ -53,71 +104,36 @@ export function saveWallets(walletsFile, wallets) {
  * @returns The resolved NWC URI, or `undefined` if no wallet is configured.
  *
  * @example
- * const uri = resolveNwcUri(ctx, '/home/user/.bray/wallets.json', process.env.NWC_URI)
+ * const uri = resolveNwcUri(ctx, '/home/user/.bray/wallets.json', configuredNwcUri)
  * if (!uri) throw new Error('No wallet configured')
  */
 export function resolveNwcUri(ctx, walletsFile, globalNwcUri) {
     const pubkey = ctx.activePublicKeyHex;
     const wallets = loadWallets(walletsFile);
-    return wallets[pubkey] ?? globalNwcUri;
+    const walletFile = wallets[pubkey.toLowerCase()];
+    return walletFile ? readNwcUriFile(walletFile) : globalNwcUri;
 }
 /**
  * Parse a nostr+walletconnect:// URI.
  *
  * @param uri - A `nostr+walletconnect://` URI as specified in NIP-47.
- * @returns A parsed {@link NwcConnection} containing the wallet pubkey, relay URL, and connection secret.
- * @throws {Error} If `pubkey`, `relay`, or `secret` are missing from the URI.
+ * @returns Public connection metadata. The connection secret is never returned.
+ * @throws {Error} If the URI is malformed or insecure.
  *
  * @example
  * const conn = parseNwcUri(
  *   'nostr+walletconnect://abc123?relay=wss%3A%2F%2Frelay.example&secret=deadbeef',
  * )
- * // { pubkey: 'abc123', relay: 'wss://relay.example', secret: 'deadbeef' }
+ * // { pubkey: 'abc123', relay: 'wss://relay.example/', relays: ['wss://relay.example/'] }
  */
 export function parseNwcUri(uri) {
-    const url = new URL(uri);
-    const pubkey = url.hostname || url.pathname.replace('//', '');
-    const relay = url.searchParams.get('relay');
-    const secret = url.searchParams.get('secret');
-    if (!pubkey || !relay || !secret) {
-        throw new Error('Invalid NWC URI: missing pubkey, relay, or secret');
-    }
-    return { pubkey, relay, secret };
-}
-/** Build an encrypted NIP-47 request event (kind 23194) */
-function buildNwcRequest(conn, method, params) {
-    const secretBytes = Buffer.from(conn.secret, 'hex');
-    try {
-        const conversationKey = getConversationKey(secretBytes, conn.pubkey);
-        const content = encrypt(JSON.stringify({ method, params }), conversationKey);
-        const event = finalizeEvent({
-            kind: 23194,
-            created_at: Math.floor(Date.now() / 1000),
-            tags: [['p', conn.pubkey]],
-            content,
-        }, secretBytes);
-        return event;
-    }
-    finally {
-        secretBytes.fill(0);
-    }
-}
-/** Decrypt a NIP-47 response event (kind 23195) */
-function decryptNwcResponse(conn, event) {
-    const secretBytes = Buffer.from(conn.secret, 'hex');
-    try {
-        const conversationKey = getConversationKey(secretBytes, conn.pubkey);
-        const plaintext = decrypt(event.content, conversationKey);
-        try {
-            return JSON.parse(plaintext);
-        }
-        catch {
-            throw new Error('NWC response is not valid JSON');
-        }
-    }
-    finally {
-        secretBytes.fill(0);
-    }
+    const connection = inspectNwcConnection(uri);
+    return {
+        pubkey: connection.walletPubkey,
+        relay: connection.relays[0],
+        relays: connection.relays,
+        ...(connection.lud16 ? { lud16: connection.lud16 } : {}),
+    };
 }
 /**
  * Parse zap receipts (kind 9735) for the active identity.
@@ -167,184 +183,122 @@ function parseZapReceipt(event) {
  * Decode basic bolt11 invoice fields.
  *
  * @param bolt11 - A BOLT-11 Lightning invoice string (e.g. `lnbc...`).
- * @returns An object with the decoded fields. `amountMsats` is present when the
- *   amount is encoded in the invoice prefix; `description` and `expiry` are not
- *   yet decoded and will be absent in the current implementation.
+ * @returns The bounded amount, description and expiry fields committed by the
+ *   invoice. `amountMsats` is absent for an amountless invoice.
  *
  * @example
  * const { amountMsats } = handleZapDecode('lnbc1000n1...')
  * console.log(`Invoice is for ${amountMsats} msats`)
  */
 export function handleZapDecode(bolt11) {
-    const result = {};
-    const match = bolt11.match(/^ln(?:bc|tb|tbs)(\d+)([munp])?/);
-    if (match) {
-        const num = parseInt(match[1], 10);
-        const multiplier = match[2];
-        const multipliers = {
-            'm': 100_000_000,
-            'u': 100_000,
-            'n': 100,
-            'p': 0.1,
-        };
-        if (multiplier && multipliers[multiplier]) {
-            result.amountMsats = Math.round(num * multipliers[multiplier]);
-        }
+    const decoded = tryDecodeBolt11(bolt11);
+    if (!decoded)
+        return {};
+    if (decoded.amountMsats !== null && decoded.amountMsats > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error('BOLT-11 amount exceeds JavaScript safe integer range');
     }
-    return result;
+    return {
+        ...(decoded.amountMsats !== null ? { amountMsats: Number(decoded.amountMsats) } : {}),
+        ...(decoded.description !== null ? { description: decoded.description } : {}),
+        expiry: decoded.expirySeconds,
+    };
 }
-// --- NWC Operations ---
 /**
- * Pay a Lightning invoice via NWC.
- *
- * @param args - Payment arguments.
- * @param args.invoice - BOLT-11 Lightning invoice to pay.
- * @param args.nwcUri - NWC URI identifying the wallet to use.
- * @returns The signed NIP-47 request event and relay publish result.
- * @throws {Error} If `nwcUri` is not provided.
- *
- * @example
- * const { event, publish } = await handleZapSend(ctx, pool, {
- *   invoice: 'lnbc500n1...',
- *   nwcUri: 'nostr+walletconnect://abc123?relay=wss%3A%2F%2Frelay.example&secret=deadbeef',
- * })
+ * The wallet may have submitted a payment but Bray cannot prove settlement.
+ * Callers must reconcile `paymentHash` before attempting the invoice again.
  */
-export async function handleZapSend(ctx, pool, args) {
-    if (!args.nwcUri) {
-        throw new Error('Wallet not configured. Set NWC_URI or NWC_URI_FILE to enable zap sending.');
+export class ZapPaymentOutcomeUnknownError extends Error {
+    paymentHash;
+    code = 'PAYMENT_OUTCOME_UNKNOWN';
+    constructor(paymentHash) {
+        super(`Payment outcome is unknown for ${paymentHash}. Reconcile the original invoice before retrying.`);
+        this.paymentHash = paymentHash;
+        this.name = 'ZapPaymentOutcomeUnknownError';
     }
-    const conn = parseNwcUri(args.nwcUri);
-    const event = buildNwcRequest(conn, 'pay_invoice', { invoice: args.invoice });
-    const publish = await pool.publish(ctx.activeNpub, event);
-    return { event, publish };
 }
-/**
- * Request wallet balance via NWC.
- *
- * @param args - Balance request arguments.
- * @param args.nwcUri - NWC URI identifying the wallet to query.
- * @returns The signed NIP-47 `get_balance` request event and relay publish result.
- * @throws {Error} If `nwcUri` is not provided.
- *
- * @example
- * const { event, publish } = await handleZapBalance(ctx, pool, {
- *   nwcUri: 'nostr+walletconnect://abc123?relay=wss%3A%2F%2Frelay.example&secret=deadbeef',
- * })
- */
-export async function handleZapBalance(ctx, pool, args) {
-    if (!args.nwcUri) {
-        throw new Error('Wallet not configured. Set NWC_URI or NWC_URI_FILE to check balance.');
+function requireWallet(nwcUri, action) {
+    if (!nwcUri) {
+        throw new Error(`Wallet not configured. Set NWC_URI_FILE or connect a persona wallet file to ${action}.`);
     }
-    const conn = parseNwcUri(args.nwcUri);
-    const event = buildNwcRequest(conn, 'get_balance', {});
-    const publish = await pool.publish(ctx.activeNpub, event);
-    return { event, publish };
+    return nwcUri;
 }
-/**
- * Generate a Lightning invoice via NWC.
- *
- * @param args - Invoice creation arguments.
- * @param args.amountMsats - Invoice amount in millisatoshis.
- * @param args.description - Optional human-readable memo attached to the invoice.
- * @param args.nwcUri - NWC URI identifying the wallet to use.
- * @returns The signed NIP-47 `make_invoice` request event and relay publish result.
- * @throws {Error} If `nwcUri` is not provided.
- *
- * @example
- * const { event, publish } = await handleZapMakeInvoice(ctx, pool, {
- *   amountMsats: 21_000,
- *   description: 'Coffee ☕',
- *   nwcUri: 'nostr+walletconnect://abc123?relay=wss%3A%2F%2Frelay.example&secret=deadbeef',
- * })
- */
-export async function handleZapMakeInvoice(ctx, pool, args) {
-    if (!args.nwcUri) {
-        throw new Error('Wallet not configured. Set NWC_URI or NWC_URI_FILE to create invoices.');
-    }
-    const conn = parseNwcUri(args.nwcUri);
-    const event = buildNwcRequest(conn, 'make_invoice', {
-        amount: args.amountMsats,
-        description: args.description,
-    });
-    const publish = await pool.publish(ctx.activeNpub, event);
-    return { event, publish };
+function requestOptions(args) {
+    return {
+        ...(args.signal ? { signal: args.signal } : {}),
+        ...(args.timeoutMs !== undefined ? { timeoutMs: args.timeoutMs } : {}),
+    };
 }
-/**
- * Look up an invoice via NWC.
- *
- * @param args - Lookup arguments. Provide at least one of `paymentHash` or `invoice`.
- * @param args.paymentHash - Hex-encoded payment hash of the invoice to look up.
- * @param args.invoice - BOLT-11 invoice string to look up.
- * @param args.nwcUri - NWC URI identifying the wallet to query.
- * @returns The signed NIP-47 `lookup_invoice` request event and relay publish result.
- * @throws {Error} If `nwcUri` is not provided.
- *
- * @example
- * const { event, publish } = await handleZapLookupInvoice(ctx, pool, {
- *   paymentHash: 'a1b2c3...',
- *   nwcUri: 'nostr+walletconnect://abc123?relay=wss%3A%2F%2Frelay.example&secret=deadbeef',
- * })
- */
-export async function handleZapLookupInvoice(ctx, pool, args) {
-    if (!args.nwcUri) {
-        throw new Error('Wallet not configured.');
+async function withClient(nwcUri, transport, operation) {
+    const client = new NwcClient(nwcUri, { ...(transport ? { transport } : {}) });
+    try {
+        return await operation(client);
+    }
+    finally {
+        client.close();
     }
-    const conn = parseNwcUri(args.nwcUri);
-    const params = {};
-    if (args.paymentHash)
-        params.payment_hash = args.paymentHash;
-    if (args.invoice)
-        params.invoice = args.invoice;
-    const event = buildNwcRequest(conn, 'lookup_invoice', params);
-    const publish = await pool.publish(ctx.activeNpub, event);
-    return { event, publish };
 }
-/**
- * List recent transactions via NWC.
- *
- * @param args - Pagination arguments.
- * @param args.limit - Maximum number of transactions to return (default 10).
- * @param args.offset - Number of transactions to skip for pagination (default 0).
- * @param args.nwcUri - NWC URI identifying the wallet to query.
- * @returns The signed NIP-47 `list_transactions` request event and relay publish result.
- * @throws {Error} If `nwcUri` is not provided.
- *
- * @example
- * const { event, publish } = await handleZapListTransactions(ctx, pool, {
- *   limit: 5,
- *   offset: 0,
- *   nwcUri: 'nostr+walletconnect://abc123?relay=wss%3A%2F%2Frelay.example&secret=deadbeef',
- * })
- */
-export async function handleZapListTransactions(ctx, pool, args) {
-    if (!args.nwcUri) {
-        throw new Error('Wallet not configured.');
+/** Pay a BOLT-11 invoice and return only after the wallet proves settlement. */
+export async function handleZapSend(_ctx, _pool, args) {
+    const uri = requireWallet(args.nwcUri, 'enable payments');
+    const decoded = tryDecodeBolt11(args.invoice);
+    if (!decoded)
+        throw new Error('Invalid BOLT-11 invoice');
+    if (decoded.amountMsats === null) {
+        throw new Error('Amountless BOLT-11 invoices are refused because no explicit payment amount was supplied');
     }
-    const conn = parseNwcUri(args.nwcUri);
-    const event = buildNwcRequest(conn, 'list_transactions', {
-        limit: args.limit ?? 10,
-        offset: args.offset ?? 0,
-    });
-    const publish = await pool.publish(ctx.activeNpub, event);
-    return { event, publish };
+    if (decoded.amountMsats > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error('BOLT-11 amount exceeds JavaScript safe integer range');
+    }
+    let paid;
+    try {
+        paid = await withClient(uri, args.transport, (client) => client.payInvoice({ invoice: args.invoice }, requestOptions(args)));
+    }
+    catch (error) {
+        // An authenticated wallet rejection is definitive. Transport, timeout,
+        // abort, and malformed-response failures can happen after submission.
+        if (error instanceof NwcError && error.code === 'WALLET_ERROR')
+            throw error;
+        throw new ZapPaymentOutcomeUnknownError(decoded.paymentHashHex);
+    }
+    if (!verifyPreimage(paid.preimage, decoded.paymentHashHex)) {
+        throw new ZapPaymentOutcomeUnknownError(decoded.paymentHashHex);
+    }
+    return { ...paid, paymentHash: decoded.paymentHashHex, verified: true };
 }
-/**
- * Parse a NWC wallet response event.
- *
- * @param nwcUri - The NWC URI whose secret is used to decrypt the response.
- * @param event - A kind 23195 NIP-47 response event from the wallet service.
- * @returns The decrypted response payload containing `result_type`, an optional
- *   `result` object, and an optional `error` with `code` and `message`.
- *
- * @example
- * const response = handleZapParseResponse(
- *   'nostr+walletconnect://abc123?relay=wss%3A%2F%2Frelay.example&secret=deadbeef',
- *   walletResponseEvent,
- * )
- * if (response.error) console.error(response.error.message)
- * else console.log(response.result)
- */
-export function handleZapParseResponse(nwcUri, event) {
-    const conn = parseNwcUri(nwcUri);
-    return decryptNwcResponse(conn, event);
+/** Return the wallet's confirmed balance in millisatoshis. */
+export async function handleZapBalance(_ctx, _pool, args) {
+    const uri = requireWallet(args.nwcUri, 'check the balance');
+    return withClient(uri, args.transport, (client) => client.getBalance(requestOptions(args)));
+}
+/** Generate a Lightning invoice through the configured wallet. */
+export async function handleZapMakeInvoice(_ctx, _pool, args) {
+    const uri = requireWallet(args.nwcUri, 'create invoices');
+    return withClient(uri, args.transport, (client) => client.makeInvoice({
+        amount: args.amountMsats,
+        ...(args.description !== undefined ? { description: args.description } : {}),
+    }, requestOptions(args)));
+}
+/** Look up an invoice and return the wallet's authenticated result. */
+export async function handleZapLookupInvoice(_ctx, _pool, args) {
+    const uri = requireWallet(args.nwcUri, 'look up invoices');
+    return withClient(uri, args.transport, (client) => client.lookupInvoice({
+        ...(args.paymentHash !== undefined ? { payment_hash: args.paymentHash } : {}),
+        ...(args.invoice !== undefined ? { invoice: args.invoice } : {}),
+    }, requestOptions(args)));
+}
+/** List recent transactions through the isolated NIP-47 extension 05 client. */
+export async function handleZapListTransactions(_ctx, _pool, args) {
+    const uri = requireWallet(args.nwcUri, 'list transactions');
+    const client = new NwcTransactionHistoryClient(uri, {
+        ...(args.transport ? { transport: args.transport } : {}),
+    });
+    try {
+        return await client.listTransactions({
+            limit: args.limit ?? 10,
+            offset: args.offset ?? 0,
+        }, requestOptions(args));
+    }
+    finally {
+        client.close();
+    }
 }

package/dist/zap/index.d.ts

@@ -1 +1,2 @@
 export * from './handlers.js';
+export * from './nwc-file.js';

package/dist/zap/index.js

@@ -1 +1,2 @@
 export * from './handlers.js';
+export * from './nwc-file.js';

package/dist/zap/nwc-file.d.ts

@@ -0,0 +1,5 @@
+export declare function readPrivateRegularFile(filePath: string, maximumBytes: number, label: string): Buffer;
+/** Read and validate an NWC connection from a private local secret file. */
+export declare function readNwcUriFile(filePath: string): string;
+/** Resolve and validate a secret-file path before adding it to the registry. */
+export declare function normaliseNwcUriFile(filePath: string): string;

package/dist/zap/nwc-file.js

@@ -0,0 +1,65 @@
+import { closeSync, fstatSync, openSync, readSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { inspectNwcConnection } from '@forgesworn/nwc-kit';
+const MAX_NWC_URI_BYTES = 8192;
+const MAX_PATH_CHARS = 4096;
+export function readPrivateRegularFile(filePath, maximumBytes, label) {
+    const descriptor = openSync(filePath, 'r');
+    let bytes;
+    try {
+        const stats = fstatSync(descriptor);
+        if (!stats.isFile() || stats.size === 0 || stats.size > maximumBytes) {
+            throw new Error(`${label} must be a non-empty regular file no larger than ${maximumBytes} bytes`);
+        }
+        if (process.platform !== 'win32' && (stats.mode & 0o077) !== 0) {
+            throw new Error(`${label} permissions are too broad; run chmod 600 on the file`);
+        }
+        bytes = Buffer.allocUnsafe(stats.size);
+        let offset = 0;
+        while (offset < bytes.length) {
+            const count = readSync(descriptor, bytes, offset, bytes.length - offset, null);
+            if (count === 0)
+                throw new Error(`${label} changed while it was being read`);
+            offset += count;
+        }
+        const extra = Buffer.allocUnsafe(1);
+        try {
+            if (readSync(descriptor, extra, 0, 1, null) !== 0) {
+                throw new Error(`${label} changed while it was being read`);
+            }
+        }
+        finally {
+            extra.fill(0);
+        }
+        return bytes;
+    }
+    catch (error) {
+        bytes?.fill(0);
+        throw error;
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}
+/** Read and validate an NWC connection from a private local secret file. */
+export function readNwcUriFile(filePath) {
+    if (typeof filePath !== 'string' || filePath.length === 0 || filePath.length > MAX_PATH_CHARS) {
+        throw new Error('NWC URI file path is missing or too long');
+    }
+    const absolutePath = resolve(filePath);
+    const bytes = readPrivateRegularFile(absolutePath, MAX_NWC_URI_BYTES, 'NWC URI file');
+    try {
+        const uri = bytes.toString('utf-8').trim();
+        inspectNwcConnection(uri);
+        return uri;
+    }
+    finally {
+        bytes.fill(0);
+    }
+}
+/** Resolve and validate a secret-file path before adding it to the registry. */
+export function normaliseNwcUriFile(filePath) {
+    const absolutePath = resolve(filePath);
+    readNwcUriFile(absolutePath);
+    return absolutePath;
+}