@nullpay/mcp 1.0.0 → 1.0.3

package/dist/server.js

@@ -1,59 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
+exports.startServer = startServer;
 const backend_client_1 = require("./backend-client");
+const env_1 = require("./env");
 const protocol_1 = require("./protocol");
 const session_store_1 = require("./session-store");
 const service_1 = require("./service");
-function parseDotEnv(content) {
-    const parsed = {};
-    for (const rawLine of content.split(/\r?\n/)) {
-        const line = rawLine.trim();
-        if (!line || line.startsWith('#')) {
-            continue;
-        }
-        const normalized = line.startsWith('export ') ? line.slice(7).trim() : line;
-        const separatorIndex = normalized.indexOf('=');
-        if (separatorIndex <= 0) {
-            continue;
-        }
-        const key = normalized.slice(0, separatorIndex).trim();
-        let value = normalized.slice(separatorIndex + 1).trim();
-        if (!key) {
-            continue;
-        }
-        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
-            value = value.slice(1, -1);
-        }
-        parsed[key] = value;
-    }
-    return parsed;
-}
-function loadEnvFiles() {
-    const packageRoot = path_1.default.resolve(__dirname, '..');
-    const repoRoot = path_1.default.resolve(packageRoot, '..', '..');
-    const candidates = [
-        path_1.default.resolve(process.cwd(), '.env'),
-        path_1.default.resolve(packageRoot, '.env'),
-        path_1.default.resolve(repoRoot, '.env'),
-        path_1.default.resolve(repoRoot, 'backend', '.env'),
-    ];
-    for (const filePath of candidates) {
-        if (!fs_1.default.existsSync(filePath)) {
-            continue;
-        }
-        const values = parseDotEnv(fs_1.default.readFileSync(filePath, 'utf8'));
-        for (const [key, value] of Object.entries(values)) {
-            if (!process.env[key]) {
-                process.env[key] = value;
-            }
-        }
-    }
-}
 function shieldStdoutForMcp() {
     const protocolWrite = process.stdout.write.bind(process.stdout);
     globalThis.__nullpayMcpStdoutWrite = (chunk) => protocolWrite(chunk);
@@ -73,39 +25,38 @@ function shieldStdoutForMcp() {
         return true;
     });
 }
-loadEnvFiles();
-shieldStdoutForMcp();
-const backendBaseUrl = process.env.NULLPAY_BACKEND_URL || 'http://localhost:3000/api';
-const publicBaseUrl = process.env.NULLPAY_PUBLIC_BASE_URL || 'https://nullpay.app';
-const mcpSecret = process.env.NULLPAY_MCP_SHARED_SECRET;
-const backend = new backend_client_1.NullPayBackendClient(backendBaseUrl, mcpSecret);
-const sessions = new session_store_1.SessionStore();
-const service = new service_1.NullPayMcpService(backend, sessions, publicBaseUrl);
-const server = new protocol_1.StdioJsonRpcServer(async (request) => {
-    if (request.method === 'initialize') {
-        return {
-            protocolVersion: String(request.params?.protocolVersion || '2025-11-25'),
-            capabilities: {
-                tools: {}
-            },
-            serverInfo: {
-                name: 'nullpay-mcp',
-                version: '0.1.0'
-            }
-        };
-    }
-    if (request.method === 'notifications/initialized') {
+function startServer() {
+    shieldStdoutForMcp();
+    const { backendBaseUrl, publicBaseUrl } = (0, env_1.getRuntimeConfig)();
+    const backend = new backend_client_1.NullPayBackendClient(backendBaseUrl);
+    const sessions = new session_store_1.SessionStore();
+    const service = new service_1.NullPayMcpService(backend, sessions, publicBaseUrl);
+    const server = new protocol_1.StdioJsonRpcServer(async (request) => {
+        if (request.method === 'initialize') {
+            return {
+                protocolVersion: String(request.params?.protocolVersion || '2025-11-25'),
+                capabilities: {
+                    tools: {}
+                },
+                serverInfo: {
+                    name: 'nullpay-mcp',
+                    version: '0.2.0'
+                }
+            };
+        }
+        if (request.method === 'notifications/initialized') {
+            return {};
+        }
+        if (request.method === 'tools/list') {
+            return { tools: service.listTools() };
+        }
+        if (request.method === 'tools/call') {
+            const name = String(request.params?.name || '');
+            const args = (request.params?.arguments || {});
+            return await service.callTool(name, args);
+        }
         return {};
-    }
-    if (request.method === 'tools/list') {
-        return { tools: service.listTools() };
-    }
-    if (request.method === 'tools/call') {
-        const name = String(request.params?.name || '');
-        const args = (request.params?.arguments || {});
-        return await service.callTool(name, args);
-    }
-    return {};
-});
-console.error('nullpay mcp starting');
-server.start();
+    });
+    console.error(`nullpay mcp starting against ${backendBaseUrl}`);
+    server.start();
+}

package/dist/service.js

@@ -142,7 +142,7 @@ class NullPayMcpService {
         return [
             {
                 name: 'login',
-                description: 'Login to NullPay, validate password, create burner wallet, or switch active wallet. If NULLPAY_MAIN_ADDRESS and NULLPAY_MAIN_PASSWORD are configured, call this tool with empty arguments and do not ask the user to share secrets in chat. The MCP server can also read NULLPAY_MAIN_PRIVATE_KEY from env without exposing it to the model.',
+                description: 'Login to NullPay, validate password, create burner wallet, recover a backed-up password or burner wallet from on-chain records, or switch active wallet. If NULLPAY_MAIN_ADDRESS and NULLPAY_MAIN_PASSWORD are configured, call this tool with empty arguments and do not ask the user to share secrets in chat. The MCP server can also read NULLPAY_MAIN_PRIVATE_KEY from env without exposing it to the model.',
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -222,21 +222,70 @@ class NullPayMcpService {
     async login(args) {
         const envMain = getMainWalletEnv();
         const address = (args.address || envMain.address || '').trim();
-        const password = args.password || envMain.password || '';
+        let password = args.password || envMain.password || '';
         const mainPrivateKey = args.main_private_key || envMain.privateKey || null;
-        if (!address || !password) {
-            throw new Error('Address and password are required. You can pass them directly or set NULLPAY_MAIN_ADDRESS and NULLPAY_MAIN_PASSWORD in env.');
+        if (!address) {
+            throw new Error('Address is required. You can pass it directly or set NULLPAY_MAIN_ADDRESS in env.');
         }
         const addressHash = (0, crypto_1.hashAddress)(address);
         const existingProfile = await this.backend.getUserProfile(addressHash);
         let encryptedMainAddress = existingProfile?.main_address || null;
+        let recoveredBackupSource = null;
+        let recoveredBurnerAddress = null;
+        let recoveredEncryptedBurnerKey = null;
+        let usedRecoveredPassword = false;
+        let restoredBurnerFromChain = false;
+        const attemptRecovery = async () => {
+            if (!mainPrivateKey) {
+                return false;
+            }
+            const recovered = await (0, aleo_1.recoverOnChainWalletBackup)(mainPrivateKey, address);
+            if (!recovered?.password) {
+                return false;
+            }
+            password = recovered.password;
+            recoveredBackupSource = recovered.source;
+            recoveredBurnerAddress = recovered.burnerAddress || null;
+            recoveredEncryptedBurnerKey = recovered.encryptedBurnerKey || null;
+            usedRecoveredPassword = true;
+            return true;
+        };
         if (encryptedMainAddress) {
-            const decrypted = await (0, crypto_1.decryptWithPassword)(encryptedMainAddress, password);
+            if (!password) {
+                const recovered = await attemptRecovery();
+                if (!recovered) {
+                    throw new Error('Password is required for this NullPay account. Set NULLPAY_MAIN_PASSWORD, pass password directly, or provide NULLPAY_MAIN_PRIVATE_KEY so the MCP can recover a backed-up password from on-chain records.');
+                }
+            }
+            let decrypted;
+            try {
+                decrypted = await (0, crypto_1.decryptWithPassword)(encryptedMainAddress, password);
+            }
+            catch {
+                const recovered = await attemptRecovery();
+                if (!recovered) {
+                    throw new Error('Password is incorrect for this NullPay account, and no recoverable on-chain password backup was found for the provided main private key.');
+                }
+                decrypted = await (0, crypto_1.decryptWithPassword)(encryptedMainAddress, password);
+            }
             if (decrypted !== address) {
-                throw new Error('Password is incorrect for this NullPay account.');
+                const recovered = await attemptRecovery();
+                if (!recovered) {
+                    throw new Error('Password is incorrect for this NullPay account.');
+                }
+                const recoveredAddress = await (0, crypto_1.decryptWithPassword)(encryptedMainAddress, password);
+                if (recoveredAddress !== address) {
+                    throw new Error('Recovered password does not match the provided address.');
+                }
             }
         }
         else {
+            if (!password) {
+                const recovered = await attemptRecovery();
+                if (!recovered) {
+                    throw new Error('Password is required to create a new NullPay account unless the MCP can recover it from on-chain backup records using NULLPAY_MAIN_PRIVATE_KEY.');
+                }
+            }
             encryptedMainAddress = await (0, crypto_1.encryptWithPassword)(address, password);
         }
         if (!encryptedMainAddress) {
@@ -246,7 +295,18 @@ class NullPayMcpService {
         let encryptedBurnerKey = existingProfile?.encrypted_burner_key || null;
         let burnerAddress = null;
         if (encryptedBurnerAddress) {
-            burnerAddress = await (0, crypto_1.decryptWithPassword)(encryptedBurnerAddress, password);
+            try {
+                burnerAddress = await (0, crypto_1.decryptWithPassword)(encryptedBurnerAddress, password);
+            }
+            catch {
+                burnerAddress = null;
+            }
+        }
+        if ((!encryptedBurnerAddress || !encryptedBurnerKey || !burnerAddress) && recoveredBurnerAddress && recoveredEncryptedBurnerKey) {
+            burnerAddress = recoveredBurnerAddress;
+            encryptedBurnerAddress = await (0, crypto_1.encryptWithPassword)(recoveredBurnerAddress, password);
+            encryptedBurnerKey = recoveredEncryptedBurnerKey;
+            restoredBurnerFromChain = true;
         }
         if (args.create_burner_wallet && !encryptedBurnerKey) {
             const { PrivateKey } = await (0, esm_1.dynamicImport)('@provablehq/sdk');
@@ -282,11 +342,17 @@ class NullPayMcpService {
         });
         const usedEnvCredentials = Boolean(envMain.address && envMain.password && !args.address && !args.password);
         const lines = [
-            usedEnvCredentials ? 'Used main-wallet address and password from MCP env.' : `Logged in as ${address}.`,
+            usedEnvCredentials ? 'Used main-wallet address and password from MCP env.' : 'Logged in as ' + address + '.',
             encryptedBurnerKey
-                ? `Active wallet: ${preferredWallet}. Burner wallet is available${burnerAddress ? ` at ${burnerAddress}` : ''}.`
+                ? 'Active wallet: ' + preferredWallet + '. Burner wallet is available' + (burnerAddress ? ' at ' + burnerAddress : '') + '.'
                 : 'Active wallet: main. No burner wallet is stored yet.',
         ];
+        if (usedRecoveredPassword) {
+            lines.push('Recovered your NullPay password from on-chain backup records using the main wallet private key (' + (recoveredBackupSource === 'full_burner' ? 'full burner backup' : 'password backup') + ').');
+        }
+        if (restoredBurnerFromChain) {
+            lines.push('Recovered your backed-up burner wallet from on-chain records and restored it into the MCP session.');
+        }
         if (mainPrivateKey) {
             lines.push('Main wallet private key is available for record-backed amount lookup and main-wallet payments. Active wallet is set to main by default, and you can switch to burner anytime by logging in again with wallet_preference set to burner. Invoice lookup will prefer the main wallet records even when you pay from burner.');
         }
@@ -306,6 +372,9 @@ class NullPayMcpService {
                 has_main_private_key: Boolean(mainPrivateKey),
                 main_private_key_from_env: Boolean(envMain.privateKey),
                 used_env_credentials: usedEnvCredentials,
+                used_recovered_password: usedRecoveredPassword,
+                recovery_source: recoveredBackupSource,
+                restored_burner_from_chain: restoredBurnerFromChain,
             },
         };
     }

package/dist/setup.d.ts

@@ -0,0 +1 @@
+export declare function runSetupWizard(): Promise<void>;

package/dist/setup.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSetupWizard = runSetupWizard;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("readline/promises"));
+const process_1 = require("process");
+function getClaudeCodeConfigPath() {
+    return path_1.default.join(os_1.default.homedir(), '.claude.json');
+}
+function getClaudeDesktopConfigPath() {
+    if (process.platform === 'win32') {
+        const localAppData = process.env.LOCALAPPDATA || path_1.default.join(os_1.default.homedir(), 'AppData', 'Local');
+        const packagedClaudePath = path_1.default.join(localAppData, 'Packages', 'Claude_pzs8sxrjxfjjc', 'LocalCache', 'Roaming', 'Claude', 'claude_desktop_config.json');
+        if (fs_1.default.existsSync(packagedClaudePath) || fs_1.default.existsSync(path_1.default.dirname(packagedClaudePath))) {
+            return packagedClaudePath;
+        }
+    }
+    if (process.platform === 'win32') {
+        const appData = process.env.APPDATA || path_1.default.join(os_1.default.homedir(), 'AppData', 'Roaming');
+        return path_1.default.join(appData, 'Claude', 'claude_desktop_config.json');
+    }
+    if (process.platform === 'darwin') {
+        return path_1.default.join(os_1.default.homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    }
+    return path_1.default.join(os_1.default.homedir(), '.config', 'Claude', 'claude_desktop_config.json');
+}
+function buildServerEntry(answers) {
+    const env = {
+        NULLPAY_MAIN_ADDRESS: answers.address,
+        NULLPAY_MAIN_PRIVATE_KEY: answers.privateKey,
+        NULLPAY_MAIN_PASSWORD: answers.password,
+    };
+    if (process.platform === 'win32') {
+        return {
+            command: 'cmd',
+            args: ['/c', 'npx', '-y', '@nullpay/mcp', 'server'],
+            env,
+        };
+    }
+    return {
+        command: 'npx',
+        args: ['-y', '@nullpay/mcp', 'server'],
+        env,
+    };
+}
+function readJsonConfig(configPath) {
+    if (!fs_1.default.existsSync(configPath)) {
+        return {};
+    }
+    const raw = fs_1.default.readFileSync(configPath, 'utf8').trim();
+    if (!raw) {
+        return {};
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed || Array.isArray(parsed) || typeof parsed !== 'object') {
+        throw new Error(`Config at ${configPath} is not a JSON object.`);
+    }
+    return parsed;
+}
+function writeMcpConfig(configPath, serverName, entry) {
+    const current = readJsonConfig(configPath);
+    const currentMcpServers = current.mcpServers && typeof current.mcpServers === 'object' && !Array.isArray(current.mcpServers)
+        ? current.mcpServers
+        : {};
+    const next = {
+        ...current,
+        mcpServers: {
+            ...currentMcpServers,
+            [serverName]: entry,
+        },
+    };
+    fs_1.default.mkdirSync(path_1.default.dirname(configPath), { recursive: true });
+    fs_1.default.writeFileSync(configPath, `${JSON.stringify(next, null, 2)}\n`, 'utf8');
+}
+async function askChoice(rl) {
+    process_1.stdout.write('Where do you want to install NullPay MCP?\n');
+    process_1.stdout.write('1. Claude Code\n');
+    process_1.stdout.write('2. Claude Desktop\n');
+    process_1.stdout.write('3. Cancel\n');
+    while (true) {
+        const answer = (await rl.question('Choose 1, 2, or 3: ')).trim();
+        if (answer === '1')
+            return 'claude-code';
+        if (answer === '2')
+            return 'claude-desktop';
+        if (answer === '3')
+            return null;
+        process_1.stdout.write('Please enter 1, 2, or 3.\n');
+    }
+}
+async function askRequired(rl, label) {
+    while (true) {
+        const answer = (await rl.question(`${label}: `)).trim();
+        if (answer) {
+            return answer;
+        }
+        process_1.stdout.write(`${label} is required.\n`);
+    }
+}
+async function collectAnswers(rl) {
+    process_1.stdout.write('\nNullPay will configure Claude automatically. You only need to provide your wallet credentials here.\n\n');
+    const address = await askRequired(rl, 'Main wallet address');
+    const privateKey = await askRequired(rl, 'Main wallet private key');
+    const password = await askRequired(rl, 'NullPay password');
+    return {
+        address,
+        privateKey,
+        password,
+    };
+}
+async function runSetupWizard() {
+    const rl = promises_1.default.createInterface({ input: process_1.stdin, output: process_1.stdout });
+    try {
+        process_1.stdout.write('NullPay MCP setup\n\n');
+        const choice = await askChoice(rl);
+        if (!choice) {
+            process_1.stdout.write('Setup cancelled.\n');
+            return;
+        }
+        const answers = await collectAnswers(rl);
+        const entry = buildServerEntry(answers);
+        const configPath = choice === 'claude-code' ? getClaudeCodeConfigPath() : getClaudeDesktopConfigPath();
+        writeMcpConfig(configPath, 'nullpay', entry);
+        process_1.stdout.write(`\nNullPay MCP was added to ${configPath}\n`);
+        if (choice === 'claude-code') {
+            process_1.stdout.write('Next step: restart Claude Code or run `claude mcp list` to confirm the server is registered.\n');
+        }
+        else {
+            process_1.stdout.write('Next step: fully restart Claude Desktop so it reloads the new MCP config.\n');
+        }
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/utils/crypto.d.ts

@@ -1,3 +1,3 @@
-export declare function hashAddress(address: string): string;
-export declare function encryptWithPassword(text: string, password: string): Promise<string>;
-export declare function decryptWithPassword(payload: string, password: string): Promise<string>;
+export declare function hashAddress(address: string): string;
+export declare function encryptWithPassword(text: string, password: string): Promise<string>;
+export declare function decryptWithPassword(payload: string, password: string): Promise<string>;

package/dist/utils/crypto.js

@@ -1,66 +1,66 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hashAddress = hashAddress;
-exports.encryptWithPassword = encryptWithPassword;
-exports.decryptWithPassword = decryptWithPassword;
-const crypto_1 = __importDefault(require("crypto"));
-const ITERATIONS = 100000;
-const KEY_LENGTH = 32;
-const DIGEST = 'sha256';
-function toBase64(buffer) {
-    return Buffer.from(buffer).toString('base64');
-}
-function fromBase64(value) {
-    return Buffer.from(value, 'base64');
-}
-function hashAddress(address) {
-    return crypto_1.default.createHash('sha256').update(address).digest('hex');
-}
-async function encryptWithPassword(text, password) {
-    const salt = crypto_1.default.randomBytes(16);
-    const iv = crypto_1.default.randomBytes(12);
-    const key = await new Promise((resolve, reject) => {
-        crypto_1.default.pbkdf2(password, salt, ITERATIONS, KEY_LENGTH, DIGEST, (error, derivedKey) => {
-            if (error)
-                reject(error);
-            else
-                resolve(derivedKey);
-        });
-    });
-    const cipher = crypto_1.default.createCipheriv('aes-256-gcm', key, iv);
-    const ciphertext = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()]);
-    const tag = cipher.getAuthTag();
-    return `${toBase64(salt)}:${toBase64(iv)}:${toBase64(Buffer.concat([ciphertext, tag]))}`;
-}
-async function decryptWithPassword(payload, password) {
-    const parts = payload.split(':');
-    if (parts.length !== 3) {
-        throw new Error('Invalid encrypted payload format');
-    }
-    const [saltPart, ivPart, cipherPart] = parts;
-    const salt = fromBase64(saltPart);
-    const iv = fromBase64(ivPart);
-    const cipherWithTag = fromBase64(cipherPart);
-    const ciphertext = cipherWithTag.subarray(0, cipherWithTag.length - 16);
-    const tag = cipherWithTag.subarray(cipherWithTag.length - 16);
-    const key = await new Promise((resolve, reject) => {
-        crypto_1.default.pbkdf2(password, salt, ITERATIONS, KEY_LENGTH, DIGEST, (error, derivedKey) => {
-            if (error)
-                reject(error);
-            else
-                resolve(derivedKey);
-        });
-    });
-    try {
-        const decipher = crypto_1.default.createDecipheriv('aes-256-gcm', key, iv);
-        decipher.setAuthTag(tag);
-        const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-        return plaintext.toString('utf8');
-    }
-    catch {
-        throw new Error('Incorrect password or corrupted data');
-    }
-}
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashAddress = hashAddress;
+exports.encryptWithPassword = encryptWithPassword;
+exports.decryptWithPassword = decryptWithPassword;
+const crypto_1 = __importDefault(require("crypto"));
+const ITERATIONS = 100000;
+const KEY_LENGTH = 32;
+const DIGEST = 'sha256';
+function toBase64(buffer) {
+    return Buffer.from(buffer).toString('base64');
+}
+function fromBase64(value) {
+    return Buffer.from(value, 'base64');
+}
+function hashAddress(address) {
+    return crypto_1.default.createHash('sha256').update(address).digest('hex');
+}
+async function encryptWithPassword(text, password) {
+    const salt = crypto_1.default.randomBytes(16);
+    const iv = crypto_1.default.randomBytes(12);
+    const key = await new Promise((resolve, reject) => {
+        crypto_1.default.pbkdf2(password, salt, ITERATIONS, KEY_LENGTH, DIGEST, (error, derivedKey) => {
+            if (error)
+                reject(error);
+            else
+                resolve(derivedKey);
+        });
+    });
+    const cipher = crypto_1.default.createCipheriv('aes-256-gcm', key, iv);
+    const ciphertext = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return `${toBase64(salt)}:${toBase64(iv)}:${toBase64(Buffer.concat([ciphertext, tag]))}`;
+}
+async function decryptWithPassword(payload, password) {
+    const parts = payload.split(':');
+    if (parts.length !== 3) {
+        throw new Error('Invalid encrypted payload format');
+    }
+    const [saltPart, ivPart, cipherPart] = parts;
+    const salt = fromBase64(saltPart);
+    const iv = fromBase64(ivPart);
+    const cipherWithTag = fromBase64(cipherPart);
+    const ciphertext = cipherWithTag.subarray(0, cipherWithTag.length - 16);
+    const tag = cipherWithTag.subarray(cipherWithTag.length - 16);
+    const key = await new Promise((resolve, reject) => {
+        crypto_1.default.pbkdf2(password, salt, ITERATIONS, KEY_LENGTH, DIGEST, (error, derivedKey) => {
+            if (error)
+                reject(error);
+            else
+                resolve(derivedKey);
+        });
+    });
+    try {
+        const decipher = crypto_1.default.createDecipheriv('aes-256-gcm', key, iv);
+        decipher.setAuthTag(tag);
+        const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+        return plaintext.toString('utf8');
+    }
+    catch {
+        throw new Error('Incorrect password or corrupted data');
+    }
+}

package/dist/utils/env.d.ts

@@ -1,6 +1,6 @@
-export declare function readEnvTrimmed(name: string): string | undefined;
-export declare function getMainWalletEnv(): {
-    address: string | undefined;
-    password: string | undefined;
-    privateKey: string | undefined;
-};
+export declare function readEnvTrimmed(name: string): string | undefined;
+export declare function getMainWalletEnv(): {
+    address: string | undefined;
+    password: string | undefined;
+    privateKey: string | undefined;
+};

package/dist/utils/env.js

@@ -1,15 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readEnvTrimmed = readEnvTrimmed;
-exports.getMainWalletEnv = getMainWalletEnv;
-function readEnvTrimmed(name) {
-    const value = process.env[name]?.trim();
-    return value ? value : undefined;
-}
-function getMainWalletEnv() {
-    return {
-        address: readEnvTrimmed('NULLPAY_MAIN_ADDRESS'),
-        password: readEnvTrimmed('NULLPAY_MAIN_PASSWORD'),
-        privateKey: readEnvTrimmed('NULLPAY_MAIN_PRIVATE_KEY') || readEnvTrimmed('NULLPAY_MAIN_PVT_KEY')
-    };
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readEnvTrimmed = readEnvTrimmed;
+exports.getMainWalletEnv = getMainWalletEnv;
+function readEnvTrimmed(name) {
+    const value = process.env[name]?.trim();
+    return value ? value : undefined;
+}
+function getMainWalletEnv() {
+    return {
+        address: readEnvTrimmed('NULLPAY_MAIN_ADDRESS'),
+        password: readEnvTrimmed('NULLPAY_MAIN_PASSWORD'),
+        privateKey: readEnvTrimmed('NULLPAY_MAIN_PRIVATE_KEY') || readEnvTrimmed('NULLPAY_MAIN_PVT_KEY')
+    };
+}

package/dist/utils/esm.d.ts

@@ -1 +1 @@
-export declare function dynamicImport<T = any>(specifier: string): Promise<T>;
+export declare function dynamicImport<T = any>(specifier: string): Promise<T>;

package/dist/utils/esm.js

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dynamicImport = dynamicImport;
-async function dynamicImport(specifier) {
-    const importer = new Function('s', 'return import(s);');
-    return await importer(specifier);
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dynamicImport = dynamicImport;
+async function dynamicImport(specifier) {
+    const importer = new Function('s', 'return import(s);');
+    return await importer(specifier);
+}

package/dist/utils/formatters.d.ts

@@ -1,14 +1,14 @@
-import { Currency, InvoiceRecord, InvoiceType } from '../types';
-export declare function normalizeCurrency(value?: string): Currency;
-export declare function normalizePaymentCurrency(value?: string): Exclude<Currency, 'ANY'> | undefined;
-export declare function normalizeInvoiceType(value?: string): InvoiceType;
-export declare function tokenTypeLabel(tokenType?: number | null): string;
-export declare function invoiceTypeLabel(invoiceType?: number | null): string;
-export declare function currencyToTokenType(currency?: Currency | null): number;
-export declare function linkTokenToCurrency(token?: string | null): Currency | undefined;
-export declare function linkTypeToInvoiceType(type?: string | null): InvoiceType;
-export declare function parseAmount(value?: string | number | null): number | undefined;
-export declare function shouldMarkInvoiceSettled(invoiceType?: number | null): boolean;
-export declare function formatInvoiceSummary(invoice: InvoiceRecord): string;
-export declare function getAmountSource(invoice: InvoiceRecord): 'record' | 'database' | 'missing';
-export declare function buildAmountLookupHint(invoice: InvoiceRecord, hasInvoiceLookupKey: boolean): string;
+import { Currency, InvoiceRecord, InvoiceType } from '../types';
+export declare function normalizeCurrency(value?: string): Currency;
+export declare function normalizePaymentCurrency(value?: string): Exclude<Currency, 'ANY'> | undefined;
+export declare function normalizeInvoiceType(value?: string): InvoiceType;
+export declare function tokenTypeLabel(tokenType?: number | null): string;
+export declare function invoiceTypeLabel(invoiceType?: number | null): string;
+export declare function currencyToTokenType(currency?: Currency | null): number;
+export declare function linkTokenToCurrency(token?: string | null): Currency | undefined;
+export declare function linkTypeToInvoiceType(type?: string | null): InvoiceType;
+export declare function parseAmount(value?: string | number | null): number | undefined;
+export declare function shouldMarkInvoiceSettled(invoiceType?: number | null): boolean;
+export declare function formatInvoiceSummary(invoice: InvoiceRecord): string;
+export declare function getAmountSource(invoice: InvoiceRecord): 'record' | 'database' | 'missing';
+export declare function buildAmountLookupHint(invoice: InvoiceRecord, hasInvoiceLookupKey: boolean): string;