@atomicfinance/bitcoin-dlc-provider 4.0.0 → 4.0.2

package/.yalc/@node-dlc/messaging/__tests__/compatibility/rust-dlc-cross-language.spec.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable no-console */
 import { expect } from 'chai';
 import { execSync } from 'child_process';
@@ -23,73 +24,75 @@ interface RustDlcCliResult {
   message: string;
 }
 
-describe('Rust-DLC Cross-Language Compatibility Tests', () => {
+// Helper function to call rust-dlc CLI
+function callRustCli(command: string, input?: string): RustDlcCliResult {
   const rustCliPath = path.join(__dirname, '../../../../rust-dlc-cli');
+  const cliCmd = `cd ${rustCliPath} && cargo run --bin dlc-compat -- ${command}`;
+
+  try {
+    // Use shorter timeout in CI environments to avoid test timeouts
+    const isCI = process.env.CI === 'true';
+    const cliTimeout = isCI ? 60000 : 300000; // 1 minute in CI, 5 minutes locally
+
+    const result = execSync(cliCmd, {
+      input: input || '',
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: cliTimeout,
+    });
 
-  // Helper function to call rust-dlc CLI
-  function callRustCli(command: string, input?: string): RustDlcCliResult {
-    const cliCmd = `cd ${rustCliPath} && cargo run --bin dlc-compat -- ${command}`;
-
+    return JSON.parse(result.trim());
+  } catch (error: any) {
+    // If the command failed, try to parse stderr or stdout as JSON
     try {
-      const result = execSync(cliCmd, {
-        input: input || '',
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-        timeout: 300000, // 5 minutes to handle Rust compilation and execution
-      });
-
-      return JSON.parse(result.trim());
-    } catch (error: any) {
-      // If the command failed, try to parse stderr or stdout as JSON
-      try {
-        const errorOutput = error.stdout || error.stderr || '';
-        if (errorOutput.trim().startsWith('{')) {
-          return JSON.parse(errorOutput.trim());
-        }
-
-        // If not JSON, create error response
-        return {
-          status: 'error',
-          message: `CLI execution failed: ${error.message}. Output: ${errorOutput}`,
-        };
-      } catch {
-        return {
-          status: 'error',
-          message: `CLI execution failed: ${error.message}`,
-        };
+      const errorOutput = error.stdout || error.stderr || '';
+      if (errorOutput.trim().startsWith('{')) {
+        return JSON.parse(errorOutput.trim());
       }
+
+      // If not JSON, create error response
+      return {
+        status: 'error',
+        message: `CLI execution failed: ${error.message}. Output: ${errorOutput}`,
+      };
+    } catch {
+      return {
+        status: 'error',
+        message: `CLI execution failed: ${error.message}`,
+      };
     }
   }
+}
 
-  describe('DlcOffer Cross-Language Compatibility', () => {
-    // Use the correct path and load test vectors like the working test does
-    const testVectorsDir = path.join(__dirname, '../../test_vectors/dlcspecs');
-    let testVectorFiles: string[] = [];
-    const allTestData: { [filename: string]: any } = {};
-
-    before(() => {
-      if (fs.existsSync(testVectorsDir)) {
-        testVectorFiles = fs
-          .readdirSync(testVectorsDir)
-          .filter((f) => f.endsWith('.json'))
-          .sort(); // Sort for consistent test order
-
-        // Load test vector files using json-bigint to preserve large integers
-        testVectorFiles.forEach((filename) => {
-          const filePath = path.join(testVectorsDir, filename);
-          try {
-            const fileContent = fs.readFileSync(filePath, 'utf8');
-            allTestData[filename] = JSONBigInt.parse(fileContent);
-          } catch (error) {
-            console.warn(
-              `Failed to load test vector ${filename}:`,
-              error.message,
-            );
-          }
-        });
-      }
-    });
+// Load test vectors at module level so they're available for test generation
+const testVectorsDir = path.join(__dirname, '../../test_vectors/dlcspecs');
+const testVectorFiles: string[] = [];
+const allTestData: { [filename: string]: any } = {};
+
+// Load test data synchronously at module level
+if (fs.existsSync(testVectorsDir)) {
+  const files = fs
+    .readdirSync(testVectorsDir)
+    .filter((f) => f.endsWith('.json'))
+    .sort(); // Sort for consistent test order
+
+  files.forEach((filename) => {
+    const filePath = path.join(testVectorsDir, filename);
+    try {
+      const fileContent = fs.readFileSync(filePath, 'utf8');
+      allTestData[filename] = JSONBigInt.parse(fileContent);
+      testVectorFiles.push(filename);
+    } catch (error) {
+      console.warn(
+        `Failed to load test vector ${filename}:`,
+        (error as Error).message,
+      );
+    }
+  });
+}
 
+describe('Rust-DLC Cross-Language Compatibility Tests', () => {
+  describe('Test Vector Discovery', () => {
     it('should discover and load test vector files for cross-language testing', () => {
       expect(testVectorFiles.length).to.be.greaterThan(
         0,
@@ -100,217 +103,127 @@ describe('Rust-DLC Cross-Language Compatibility Tests', () => {
         'Should load test data',
       );
 
-      console.error(`\n📋 Cross-Language Test Vector Discovery:`);
+      console.error(`\nCross-Language Test Vector Discovery:`);
       console.error(
         `  Found ${testVectorFiles.length} test vector files for cross-language testing:`,
       );
       testVectorFiles.forEach((file, index) => {
-        const hasOffer = allTestData[file]?.offer_message ? '✅' : '❌';
-        const hasAccept = allTestData[file]?.accept_message ? '✅' : '❌';
-        const hasSign = allTestData[file]?.sign_message ? '✅' : '❌';
+        const hasOffer = allTestData[file]?.offer_message
+          ? '[OFFER]'
+          : '[NO_OFFER]';
+        const hasAccept = allTestData[file]?.accept_message
+          ? '[ACCEPT]'
+          : '[NO_ACCEPT]';
+        const hasSign = allTestData[file]?.sign_message
+          ? '[SIGN]'
+          : '[NO_SIGN]';
         console.error(
-          `  ${index + 1}. ${file} (O:${hasOffer} A:${hasAccept} S:${hasSign})`,
+          `  ${index + 1}. ${file} (${hasOffer} ${hasAccept} ${hasSign})`,
         );
       });
     });
+  });
 
-    it('should test cross-language compatibility for offers', function () {
-      this.timeout(60000); // Increase timeout to 60 seconds for testing all vectors
-      let testedOffers = 0;
-      let rustValidationPassed = 0;
-      let rustValidationFailed = 0;
-
-      testVectorFiles.forEach((filename) => {
-        const testData = allTestData[filename];
-        if (!testData?.offer_message) return;
-
-        testedOffers++;
-
-        try {
-          // Step 1: Create Node.js DLC message from JSON
-          const nodeOffer = DlcOffer.fromJSON(testData.offer_message.message);
-          const nodeJson = nodeOffer.toJSON(); // Now defaults to canonical rust-dlc format
-          const nodeHex = nodeOffer.serialize().toString('hex');
-
-          // Step 2: Test Rust validation of Node.js JSON (mock for now)
-          const rustValidation = callRustCli(
-            'validate -t offer',
-            JSONBigInt.stringify(nodeJson),
-          );
-
-          if (rustValidation.status === 'success') {
-            rustValidationPassed++;
-            console.error(`✅ Rust validated Node.js offer from ${filename}`);
-
-            // Step 3: Test Rust serialization of Node.js JSON
-            const rustSerialization = callRustCli(
-              'serialize -t offer',
-              JSONBigInt.stringify(nodeJson),
-            );
-            if (rustSerialization.status === 'success') {
-              const rustHex = rustSerialization.data;
-              if (nodeHex === rustHex) {
-                console.error(`🎉 Perfect hex compatibility for ${filename}!`);
-              } else {
-                console.error('nodeHex', nodeHex);
-                console.error('rustHex', rustHex);
-                console.error(
-                  `⚠️  Hex differences for ${filename} (length: Node ${nodeHex.length}, Rust ${rustHex.length})`,
-                );
-              }
-            }
-          } else {
-            rustValidationFailed++;
-            console.error('rustValidation', rustValidation);
-            console.error('nodeJson', nodeJson);
-            console.error('nodeHex', nodeHex);
-            console.log(
-              'testData.offer_message.message',
-              testData.offer_message.message,
-            );
-            console.error(
-              `❌ Rust validation failed for ${filename}: ${rustValidation.message}`,
-            );
-
-            // Add debugging for JSON structure issues
-            if (
-              rustValidation.message.includes('expected map with a single key')
-            ) {
-              console.error(
-                `🔍 Debugging ${filename} JSON structure for contract descriptor:`,
-              );
-              // eslint-disable-next-line @typescript-eslint/no-explicit-any
-              const jsonObj = nodeJson as any;
-
-              // Check for different contract info structures
-              if (jsonObj.contractInfo?.singleContractInfo) {
-                console.error('Single contract info structure:');
-                console.error(
-                  JSONBigInt.stringify(
-                    jsonObj.contractInfo.singleContractInfo.contractInfo
-                      ?.contractDescriptor,
-                    null,
-                    2,
-                  ),
-                );
-              } else if (jsonObj.contractInfo?.disjointContractInfo) {
-                console.error('Disjoint contract info structure:');
-                console.error('Contract infos array:');
-                jsonObj.contractInfo.disjointContractInfo.contractInfos?.forEach(
-                  (contractInfo: any, index: number) => {
-                    console.error(
-                      `  Contract Info ${index}:`,
-                      JSONBigInt.stringify(
-                        contractInfo.contractDescriptor,
-                        null,
-                        2,
-                      ),
-                    );
-                  },
-                );
-              } else {
-                console.error('Unknown contract info structure:');
-                console.error(
-                  JSONBigInt.stringify(jsonObj.contractInfo, null, 2),
-                );
-              }
-            }
-          }
-        } catch (error) {
-          rustValidationFailed++;
-          console.error(
-            `❌ Node.js processing failed for ${filename}: ${error.message}`,
-          );
-        }
-      });
+  describe('DlcOffer Cross-Language Compatibility', () => {
+    // Generate individual test cases for offers
+    testVectorFiles.forEach((filename) => {
+      const testData = allTestData[filename];
+      if (!testData?.offer_message) return;
+
+      it(`should have Rust-compatible offer for ${filename}`, function () {
+        // Use longer timeout in CI to account for slower build times
+        const isCI = process.env.CI === 'true';
+        this.timeout(isCI ? 90000 : 15000); // 90s in CI, 15s locally
+
+        // Step 1: Create Node.js DLC message from JSON
+        const nodeOffer = DlcOffer.fromJSON(testData.offer_message.message);
+        const nodeJson = nodeOffer.toJSON(); // Now defaults to canonical rust-dlc format
+        const nodeHex = nodeOffer.serialize().toString('hex');
+
+        // Step 2: Test Rust validation of Node.js JSON
+        const rustValidation = callRustCli(
+          'validate -t offer',
+          JSONBigInt.stringify(nodeJson),
+        );
 
-      console.error(`\n📊 Cross-Language Offer Test Results:`);
-      console.error(`  Tested offers: ${testedOffers}`);
-      console.error(`  Rust validation passed: ${rustValidationPassed}`);
-      console.error(`  Rust validation failed: ${rustValidationFailed}`);
+        expect(rustValidation.status).to.equal(
+          'success',
+          `Rust validation failed for ${filename}: ${rustValidation.message}`,
+        );
 
-      // Document current status
-      expect(testedOffers).to.be.greaterThan(0, 'Should test some offers');
-    });
+        // Step 3: Test Rust serialization of Node.js JSON
+        const rustSerialization = callRustCli(
+          'serialize -t offer',
+          JSONBigInt.stringify(nodeJson),
+        );
 
-    it('should test cross-language compatibility for accepts', function () {
-      this.timeout(60000); // Increase timeout to 60 seconds for testing all vectors
-      let testedAccepts = 0;
-
-      testVectorFiles.forEach((filename) => {
-        const testData = allTestData[filename];
-        if (!testData?.accept_message) return;
-
-        testedAccepts++;
-
-        try {
-          const nodeAccept = DlcAccept.fromJSON(
-            testData.accept_message.message,
-          );
-
-          const nodeJson = nodeAccept.toJSON();
-
-          // Test Rust validation
-          const rustValidation = callRustCli(
-            'validate -t accept',
-            JSONBigInt.stringify(nodeJson),
-          );
-
-          console.error(
-            `Cross-language accept test for ${filename}: ${rustValidation.status}`,
-          );
-        } catch (error) {
-          console.error(
-            `❌ Accept processing failed for ${filename}: ${error.message}`,
-          );
-        }
-      });
+        expect(rustSerialization.status).to.equal(
+          'success',
+          `Rust serialization failed for ${filename}: ${rustSerialization.message}`,
+        );
 
-      console.error(
-        `\n📊 Cross-Language Accept Test Results: Tested ${testedAccepts} accepts`,
-      );
-      expect(testedAccepts).to.be.greaterThan(
-        -1,
-        'Documents accept testing status',
-      );
+        const rustHex = rustSerialization.data;
+        expect(nodeHex).to.equal(
+          rustHex,
+          `Hex serialization mismatch for ${filename}. Node.js length: ${nodeHex.length}, Rust length: ${rustHex.length}`,
+        );
+      });
     });
+  });
 
-    it('should test cross-language compatibility for signs', function () {
-      this.timeout(60000); // Increase timeout to 60 seconds for testing all vectors
-      let testedSigns = 0;
-
-      testVectorFiles.forEach((filename) => {
-        const testData = allTestData[filename];
-        if (!testData?.sign_message) return;
-
-        testedSigns++;
-
-        try {
-          const nodeSign = DlcSign.fromJSON(testData.sign_message.message);
-          const nodeJson = nodeSign.toJSON();
-
-          // Test Rust validation
-          const rustValidation = callRustCli(
-            'validate -t sign',
-            JSONBigInt.stringify(nodeJson),
-          );
-          console.error(
-            `Cross-language sign test for ${filename}: ${rustValidation.status}`,
-          );
-        } catch (error) {
-          console.error(
-            `❌ Sign processing failed for ${filename}: ${error.message}`,
-          );
-        }
+  describe('DlcAccept Cross-Language Compatibility', () => {
+    // Generate individual test cases for accepts
+    testVectorFiles.forEach((filename) => {
+      const testData = allTestData[filename];
+      if (!testData?.accept_message) return;
+
+      it(`should have Rust-compatible accept for ${filename}`, function () {
+        // Use longer timeout in CI to account for slower build times
+        const isCI = process.env.CI === 'true';
+        this.timeout(isCI ? 90000 : 15000); // 90s in CI, 15s locally
+
+        const nodeAccept = DlcAccept.fromJSON(testData.accept_message.message);
+        const nodeJson = nodeAccept.toJSON();
+
+        // Test Rust validation
+        const rustValidation = callRustCli(
+          'validate -t accept',
+          JSONBigInt.stringify(nodeJson),
+        );
+
+        expect(rustValidation.status).to.equal(
+          'success',
+          `Rust validation failed for ${filename}: ${rustValidation.message}`,
+        );
       });
+    });
+  });
 
-      console.error(
-        `\n📊 Cross-Language Sign Test Results: Tested ${testedSigns} signs`,
-      );
-      expect(testedSigns).to.be.greaterThan(
-        -1,
-        'Documents sign testing status',
-      );
+  describe('DlcSign Cross-Language Compatibility', () => {
+    // Generate individual test cases for signs
+    testVectorFiles.forEach((filename) => {
+      const testData = allTestData[filename];
+      if (!testData?.sign_message) return;
+
+      it(`should have Rust-compatible sign for ${filename}`, function () {
+        // Use longer timeout in CI to account for slower build times
+        const isCI = process.env.CI === 'true';
+        this.timeout(isCI ? 90000 : 15000); // 90s in CI, 15s locally
+
+        const nodeSign = DlcSign.fromJSON(testData.sign_message.message);
+        const nodeJson = nodeSign.toJSON();
+
+        // Test Rust validation
+        const rustValidation = callRustCli(
+          'validate -t sign',
+          JSONBigInt.stringify(nodeJson),
+        );
+
+        expect(rustValidation.status).to.equal(
+          'success',
+          `Rust validation failed for ${filename}: ${rustValidation.message}`,
+        );
+      });
     });
   });