@nullpay/mcp 1.0.3 → 1.0.5

package/dist/aleo.js

@@ -24,7 +24,8 @@ const crypto_1 = __importDefault(require("crypto"));
 const esm_1 = require("./esm");
 const env_1 = require("./env");
 exports.PROGRAM_ID = 'zk_pay_proofs_privacy_v22.aleo';
-const FREEZELIST_PROGRAM_ID = 'test_usdcx_freezelist.aleo';
+const USDCX_FREEZELIST_PROGRAM_ID = 'test_usdcx_freezelist.aleo';
+const USAD_FREEZELIST_PROGRAM_ID = 'test_usad_freezelist.aleo';
 const EXPLORER_BASE = 'https://api.explorer.provable.com/v1';
 const MAPPING_BASE = 'https://api.provable.com/v2/testnet/program';
 const SCANNER_BASE = 'https://api.provable.com/scanner/testnet';
@@ -548,39 +549,54 @@ async function findSpendableRecord(session, programFilter, recordName, amountReq
     }
     return null;
 }
-async function getFreezeListIndex(index) {
+function getFreezeListProgramId(tokenProgram) {
+    if (tokenProgram === 'test_usdcx_stablecoin.aleo') {
+        return USDCX_FREEZELIST_PROGRAM_ID;
+    }
+    if (tokenProgram === 'test_usad_stablecoin.aleo') {
+        return USAD_FREEZELIST_PROGRAM_ID;
+    }
+    return null;
+}
+async function getFreezeListIndex(programId, index) {
     const { AleoNetworkClient } = await (0, esm_1.dynamicImport)('@provablehq/sdk');
     const client = new AleoNetworkClient(EXPLORER_BASE);
-    const value = await client.getProgramMappingValue(FREEZELIST_PROGRAM_ID, 'freeze_list_index', `${index}u32`);
+    const value = await client.getProgramMappingValue(programId, 'freeze_list_index', `${index}u32`);
     return value ? value.replace(/"/g, '') : null;
 }
-async function generateFreezeListProof(targetIndex = 1, occupiedLeafValue) {
-    const { Field, Poseidon4 } = await (0, esm_1.dynamicImport)('@provablehq/wasm');
-    const hasher = new Poseidon4();
-    const emptyHashes = [];
-    let currentEmpty = '0field';
-    for (let level = 0; level < 16; level += 1) {
-        emptyHashes.push(currentEmpty);
-        const field = Field.fromString(currentEmpty);
-        currentEmpty = hasher.hash([field, field]).toString();
-    }
-    let currentHash = '0field';
-    let currentIndex = targetIndex;
-    const proofSiblings = [];
-    for (let level = 0; level < 16; level += 1) {
-        const isLeft = currentIndex % 2 === 0;
-        const siblingIndex = isLeft ? currentIndex + 1 : currentIndex - 1;
-        let siblingHash = emptyHashes[level];
-        if (level === 0 && siblingIndex === 0 && occupiedLeafValue) {
-            siblingHash = occupiedLeafValue;
+async function getFreezeListCount(programId) {
+    const response = await fetch(`${MAPPING_BASE}/${programId}/mapping/freeze_list_last_index/true`);
+    if (!response.ok) {
+        return 0;
+    }
+    const value = await response.json();
+    if (!value) {
+        return 0;
+    }
+    const parsed = Number.parseInt(String(value).replace(/u32|["']/g, ''), 10);
+    return Number.isFinite(parsed) ? parsed + 1 : 0;
+}
+async function generateFreezeListProof(ownerAddress, tokenProgram) {
+    const freezeListProgramId = getFreezeListProgramId(tokenProgram);
+    if (!freezeListProgramId) {
+        throw new Error(`Unsupported freeze list program for ${tokenProgram}`);
+    }
+    const { SealanceMerkleTree } = await (0, esm_1.dynamicImport)('@provablehq/sdk');
+    const count = Math.max(1, await getFreezeListCount(freezeListProgramId));
+    const addresses = [];
+    for (let index = 0; index < count; index += 1) {
+        const address = await getFreezeListIndex(freezeListProgramId, index);
+        if (address) {
+            addresses.push(address);
         }
-        proofSiblings.push(siblingHash);
-        const left = Field.fromString(isLeft ? currentHash : siblingHash);
-        const right = Field.fromString(isLeft ? siblingHash : currentHash);
-        currentHash = hasher.hash([left, right]).toString();
-        currentIndex = Math.floor(currentIndex / 2);
     }
-    return `[${proofSiblings.join(', ')}]`;
+    const sealance = new SealanceMerkleTree();
+    const leaves = sealance.generateLeaves(addresses, 16);
+    const tree = sealance.buildTree(leaves);
+    const [leftIdx, rightIdx] = sealance.getLeafIndices(tree, ownerAddress);
+    const proofLeft = sealance.getSiblingPath(tree, leftIdx, 16);
+    const proofRight = sealance.getSiblingPath(tree, rightIdx, 16);
+    return sealance.formatMerkleProof([proofLeft, proofRight]);
 }
 async function createSponsoredPaymentAuthorization(args) {
     const session = await getScannerSession(args.walletPrivateKey);
@@ -598,14 +614,12 @@ async function createSponsoredPaymentAuthorization(args) {
     }
     let proofsInput;
     if (paymentMode.tokenProgram !== 'credits.aleo') {
-        const firstIndex = await getFreezeListIndex(0);
-        let index0Field;
-        if (firstIndex) {
-            const { Address } = await (0, esm_1.dynamicImport)('@provablehq/wasm');
-            index0Field = Address.from_string(firstIndex).toGroup().toXCoordinate().toString();
+        const ownerMatch = record.match(/owner\s*:\s*([a-z0-9]+)/i);
+        const ownerAddress = ownerMatch?.[1];
+        if (!ownerAddress || !ownerAddress.startsWith('aleo')) {
+            throw new Error(`Failed to read token record owner for ${paymentMode.tokenProgram}.`);
         }
-        const proof = await generateFreezeListProof(1, index0Field);
-        proofsInput = `[${proof}, ${proof}]`;
+        proofsInput = await generateFreezeListProof(ownerAddress, paymentMode.tokenProgram);
     }
     const { AleoKeyProvider, AleoNetworkClient, NetworkRecordProvider, ProgramManager } = await (0, esm_1.dynamicImport)('@provablehq/sdk');
     const keyProvider = new AleoKeyProvider();

package/dist/service.js

@@ -235,18 +235,27 @@ class NullPayMcpService {
         let recoveredEncryptedBurnerKey = null;
         let usedRecoveredPassword = false;
         let restoredBurnerFromChain = false;
-        const attemptRecovery = async () => {
-            if (!mainPrivateKey) {
-                return false;
+        let chainBackupLoaded = false;
+        const loadChainBackup = async () => {
+            if (chainBackupLoaded || !mainPrivateKey) {
+                return null;
             }
+            chainBackupLoaded = true;
             const recovered = await (0, aleo_1.recoverOnChainWalletBackup)(mainPrivateKey, address);
-            if (!recovered?.password) {
-                return false;
+            if (!recovered) {
+                return null;
             }
-            password = recovered.password;
             recoveredBackupSource = recovered.source;
             recoveredBurnerAddress = recovered.burnerAddress || null;
             recoveredEncryptedBurnerKey = recovered.encryptedBurnerKey || null;
+            return recovered;
+        };
+        const attemptRecovery = async () => {
+            const recovered = await loadChainBackup();
+            if (!recovered?.password) {
+                return false;
+            }
+            password = recovered.password;
             usedRecoveredPassword = true;
             return true;
         };
@@ -302,6 +311,9 @@ class NullPayMcpService {
                 burnerAddress = null;
             }
         }
+        if (!encryptedBurnerKey || !burnerAddress || !encryptedBurnerAddress) {
+            await loadChainBackup();
+        }
         if ((!encryptedBurnerAddress || !encryptedBurnerKey || !burnerAddress) && recoveredBurnerAddress && recoveredEncryptedBurnerKey) {
             burnerAddress = recoveredBurnerAddress;
             encryptedBurnerAddress = await (0, crypto_1.encryptWithPassword)(recoveredBurnerAddress, password);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@nullpay/mcp",
-    "version": "1.0.3",
+    "version": "1.0.5",
     "description": "NullPay MCP server and Claude setup wizard for conversational payment flows",
     "type": "commonjs",
     "main": "dist/server.js",