@atomicfinance/types 3.6.1 → 4.0.0

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

@@ -0,0 +1,342 @@
+/* eslint-disable no-console */
+import { expect } from 'chai';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import JSONbig from 'json-bigint';
+import * as path from 'path';
+
+import { DlcAccept, DlcOffer, DlcSign } from '../../lib';
+
+// Configure json-bigint to handle large integers as BigInt but preserve floating point numbers
+const JSONBigInt = JSONbig({
+  storeAsString: false, // Store as BigInt, not string
+  useNativeBigInt: true, // Use native BigInt support
+  alwaysParseAsBig: false, // Don't convert all numbers to BigInt - preserve smaller numbers and floats
+  // This will automatically use BigInt for integers that exceed MAX_SAFE_INTEGER
+  // and keep regular numbers for smaller integers and floats
+});
+
+interface RustDlcCliResult {
+  status: 'success' | 'error';
+  data?: any;
+  messageType?: string;
+  message: string;
+}
+
+describe('Rust-DLC Cross-Language Compatibility Tests', () => {
+  const rustCliPath = path.join(__dirname, '../../../../rust-dlc-cli');
+
+  // Helper function to call rust-dlc CLI
+  function callRustCli(command: string, input?: string): RustDlcCliResult {
+    const cliCmd = `cd ${rustCliPath} && cargo run --bin dlc-compat -- ${command}`;
+
+    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}`,
+        };
+      }
+    }
+  }
+
+  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,
+            );
+          }
+        });
+      }
+    });
+
+    it('should discover and load test vector files for cross-language testing', () => {
+      expect(testVectorFiles.length).to.be.greaterThan(
+        0,
+        'Should find test vector files',
+      );
+      expect(Object.keys(allTestData).length).to.be.greaterThan(
+        0,
+        'Should load test data',
+      );
+
+      console.error(`\n📋 Cross-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 ? '✅' : '❌';
+        console.error(
+          `  ${index + 1}. ${file} (O:${hasOffer} A:${hasAccept} S:${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}`,
+          );
+        }
+      });
+
+      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}`);
+
+      // Document current status
+      expect(testedOffers).to.be.greaterThan(0, 'Should test some offers');
+    });
+
+    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}`,
+          );
+        }
+      });
+
+      console.error(
+        `\n📊 Cross-Language Accept Test Results: Tested ${testedAccepts} accepts`,
+      );
+      expect(testedAccepts).to.be.greaterThan(
+        -1,
+        'Documents accept testing status',
+      );
+    });
+
+    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}`,
+          );
+        }
+      });
+
+      console.error(
+        `\n📊 Cross-Language Sign Test Results: Tested ${testedSigns} signs`,
+      );
+      expect(testedSigns).to.be.greaterThan(
+        -1,
+        'Documents sign testing status',
+      );
+    });
+  });
+
+  describe('CLI Tool Integration', () => {
+    it('should have working rust-dlc CLI tool', () => {
+      const validation = callRustCli('validate -t offer', '{}');
+
+      expect(validation.status).to.equal('error'); // Empty object should fail validation
+      expect(validation.message).to.include('Invalid offer structure');
+    });
+
+    it('should validate complete rust-dlc test vectors', () => {
+      const rustOfferPath = path.join(
+        __dirname,
+        '../../../../../rust-dlc/dlc-messages/src/test_inputs/offer_msg.json',
+      );
+
+      if (fs.existsSync(rustOfferPath)) {
+        const rustOffer = fs.readFileSync(rustOfferPath, 'utf8');
+        const validation = callRustCli('validate -t offer', rustOffer);
+
+        expect(validation.status).to.equal(
+          'success',
+          'Should validate complete rust-dlc offer test vector',
+        );
+      }
+    });
+  });
+});