@atomicfinance/bitcoin-dlc-provider 4.1.3 → 4.1.4

package/.yalc/@node-dlc/messaging/__tests__/compatibility/dlcspecs-compatibility.spec.ts

@@ -0,0 +1,439 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { expect } from 'chai';
+import * as fs from 'fs';
+import * as path from 'path';
+
+import { DlcAccept, DlcOffer, DlcSign, MessageType } from '../../lib';
+
+interface DlcSpecsTestData {
+  offer_message?: {
+    message: any;
+    serialized: string;
+  };
+  accept_message?: {
+    message: any;
+    serialized: string;
+  };
+  sign_message?: {
+    message: any;
+    serialized: string;
+  };
+}
+
+interface TestResult {
+  filename: string;
+  messageType: string;
+  success: boolean;
+  error?: string;
+  details?: any;
+}
+
+describe('DLC Ecosystem Compatibility Tests', () => {
+  const dlcSpecsDir = path.join(__dirname, '../../test_vectors/dlcspecs');
+  const rustDlcDir = path.join(__dirname, '../../test_vectors/rust-dlc');
+
+  let dlcSpecsFiles: string[] = [];
+  let rustDlcFiles: string[] = [];
+
+  before(() => {
+    // Discover all test vector files
+    if (fs.existsSync(dlcSpecsDir)) {
+      dlcSpecsFiles = fs
+        .readdirSync(dlcSpecsDir)
+        .filter((f) => f.endsWith('.json'));
+    }
+
+    if (fs.existsSync(rustDlcDir)) {
+      rustDlcFiles = fs
+        .readdirSync(rustDlcDir)
+        .filter((f) => f.endsWith('.json'));
+    }
+  });
+
+  describe('DLCSpecs Test Vector Compatibility', () => {
+    it('should test all dlcspecs test vectors with version compatibility', () => {
+      const allResults: TestResult[] = [];
+      let oldFormatCount = 0;
+      let newFormatCount = 0;
+
+      dlcSpecsFiles.forEach((filename) => {
+        const filePath = path.join(dlcSpecsDir, filename);
+        let testData: DlcSpecsTestData;
+
+        try {
+          testData = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        } catch (error) {
+          testData = {};
+        }
+
+        // Test offer message if present
+        if (testData.offer_message) {
+          const result: TestResult = {
+            filename,
+            messageType: 'offer',
+            success: false,
+          };
+
+          try {
+            const inputBuffer = Buffer.from(
+              testData.offer_message.serialized,
+              'hex',
+            );
+            const expectedMessage = testData.offer_message.message;
+
+            // Check format version based on serialization
+            const messageType = inputBuffer.readUInt16BE(0);
+            expect(messageType).to.equal(MessageType.DlcOffer);
+
+            // Detect old vs new format
+            const nextBytes = inputBuffer.slice(2, 7);
+            const possibleProtocolVersion = nextBytes.readUInt32BE(0);
+            const possibleContractFlags = nextBytes.readUInt8(4);
+            const isNewFormat =
+              possibleProtocolVersion >= 1 &&
+              possibleProtocolVersion <= 10 &&
+              possibleContractFlags === 0;
+
+            if (isNewFormat) {
+              newFormatCount++;
+            } else {
+              oldFormatCount++;
+            }
+
+            const offer = DlcOffer.deserialize(inputBuffer);
+
+            expect(offer.type).to.equal(MessageType.DlcOffer);
+
+            if (expectedMessage.protocolVersion) {
+              expect(offer.protocolVersion).to.equal(
+                expectedMessage.protocolVersion,
+              );
+            }
+
+            if (expectedMessage.chainHash) {
+              expect(offer.chainHash.toString('hex')).to.equal(
+                expectedMessage.chainHash,
+              );
+            }
+
+            if (expectedMessage.temporaryContractId) {
+              expect(offer.temporaryContractId.toString('hex')).to.equal(
+                expectedMessage.temporaryContractId,
+              );
+            }
+
+            // Test round-trip serialization
+            const serialized = offer.serialize();
+            const deserialized = DlcOffer.deserialize(serialized);
+            expect(deserialized.protocolVersion).to.equal(
+              offer.protocolVersion,
+            );
+
+            result.success = true;
+            result.details = {
+              protocolVersion: offer.protocolVersion,
+              formatVersion: isNewFormat ? 'new' : 'old',
+              contractInfoType: offer.contractInfo.constructor.name,
+              fundingInputsCount: offer.fundingInputs.length,
+              offerCollateral: Number(offer.offerCollateral),
+            };
+          } catch (error) {
+            result.error = error.message;
+          }
+
+          allResults.push(result);
+        }
+
+        // Test accept message if present
+        if (testData.accept_message) {
+          const result: TestResult = {
+            filename,
+            messageType: 'accept',
+            success: false,
+          };
+
+          try {
+            const inputBuffer = Buffer.from(
+              testData.accept_message.serialized,
+              'hex',
+            );
+            const expectedMessage = testData.accept_message.message;
+
+            const accept = DlcAccept.deserialize(inputBuffer);
+
+            expect(accept.type).to.equal(MessageType.DlcAccept);
+
+            if (expectedMessage.protocolVersion) {
+              expect(accept.protocolVersion).to.equal(
+                expectedMessage.protocolVersion,
+              );
+            }
+
+            if (expectedMessage.temporaryContractId) {
+              expect(accept.temporaryContractId.toString('hex')).to.equal(
+                expectedMessage.temporaryContractId,
+              );
+            }
+
+            // Test round-trip
+            const serialized = accept.serialize();
+            const deserialized = DlcAccept.deserialize(serialized);
+            expect(deserialized.protocolVersion).to.equal(
+              accept.protocolVersion,
+            );
+
+            result.success = true;
+            result.details = {
+              protocolVersion: accept.protocolVersion,
+              fundingInputsCount: accept.fundingInputs.length,
+              acceptCollateral: Number(accept.acceptCollateral),
+              hasNegotiationFields: !!accept.negotiationFields,
+            };
+          } catch (error) {
+            result.error = error.message;
+          }
+
+          allResults.push(result);
+        }
+
+        // Test sign message if present
+        if (testData.sign_message) {
+          const result: TestResult = {
+            filename,
+            messageType: 'sign',
+            success: false,
+          };
+
+          try {
+            const inputBuffer = Buffer.from(
+              testData.sign_message.serialized,
+              'hex',
+            );
+            const expectedMessage = testData.sign_message.message;
+
+            const sign = DlcSign.deserialize(inputBuffer);
+
+            expect(sign.type).to.equal(MessageType.DlcSign);
+
+            if (expectedMessage.protocolVersion) {
+              expect(sign.protocolVersion).to.equal(
+                expectedMessage.protocolVersion,
+              );
+            }
+
+            if (expectedMessage.contractId) {
+              expect(sign.contractId.toString('hex')).to.equal(
+                expectedMessage.contractId,
+              );
+            }
+
+            // Test round-trip
+            const serialized = sign.serialize();
+            const deserialized = DlcSign.deserialize(serialized);
+            expect(deserialized.protocolVersion).to.equal(sign.protocolVersion);
+
+            result.success = true;
+            result.details = {
+              protocolVersion: sign.protocolVersion,
+              cetSignatureCount: sign.cetAdaptorSignatures.sigs.length,
+              hasBatchFunding: !!sign.batchFundingGroups,
+            };
+          } catch (error) {
+            result.error = error.message;
+          }
+
+          allResults.push(result);
+        }
+      });
+
+      // Generate comprehensive report with version analysis
+      const dlcSpecsSuccessRate =
+        allResults.length > 0
+          ? allResults.filter((r) => r.success).length / allResults.length
+          : 0;
+
+      const byMessageType = {
+        offer: allResults.filter((r) => r.messageType === 'offer'),
+        accept: allResults.filter((r) => r.messageType === 'accept'),
+        sign: allResults.filter((r) => r.messageType === 'sign'),
+      };
+
+      const failures = allResults.filter((r) => !r.success);
+
+      const reportLines = [
+        `DLCSpecs Test Vector Results (With Version Compatibility):`,
+        `Files Processed: ${dlcSpecsFiles.length}`,
+        `Tests Run: ${allResults.length}`,
+        `Success Rate: ${Math.round(dlcSpecsSuccessRate * 100)}% (${
+          allResults.filter((r) => r.success).length
+        }/${allResults.length})`,
+        '',
+        'Version Analysis:',
+        `  • Old format (pre-protocol_version): ${oldFormatCount}`,
+        `  • New format (with protocol_version): ${newFormatCount}`,
+        '',
+        'By Message Type:',
+        ...Object.entries(byMessageType).map(([type, results]) => {
+          const successCount = results.filter((r) => r.success).length;
+          const rate =
+            results.length > 0
+              ? Math.round((successCount / results.length) * 100)
+              : 0;
+          return `  • ${type}: ${rate}% (${successCount}/${results.length})`;
+        }),
+      ];
+
+      if (failures.length > 0) {
+        reportLines.push('', 'Failures:');
+        failures.forEach((f) => {
+          reportLines.push(`  • ${f.filename} (${f.messageType}): ${f.error}`);
+        });
+      }
+
+      // Enhanced expectation with version context
+      const expectedMinRate = 0.5; // Expect reasonable compatibility with version detection
+      expect(dlcSpecsSuccessRate).to.be.at.least(
+        expectedMinRate,
+        `DLCSpecs compatibility: ${Math.round(
+          dlcSpecsSuccessRate * 100,
+        )}%. Version Analysis: ${oldFormatCount} old format, ${newFormatCount} new format test vectors. \n\n${reportLines.join(
+          '\n',
+        )}`,
+      );
+    });
+  });
+
+  describe('Rust-DLC Test Vector Compatibility', () => {
+    it('should test all rust-dlc test vectors comprehensively', () => {
+      const allResults: TestResult[] = [];
+
+      rustDlcFiles.forEach((filename) => {
+        const filePath = path.join(rustDlcDir, filename);
+        let testData: any;
+
+        try {
+          testData = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        } catch (error) {
+          testData = {};
+        }
+
+        const result: TestResult = {
+          filename,
+          messageType: 'rust-dlc-validation',
+          success: false,
+        };
+
+        try {
+          // Detect message type from filename or structure
+          let messageType = 'unknown';
+          if (filename.includes('offer')) messageType = 'offer';
+          else if (filename.includes('accept')) messageType = 'accept';
+          else if (filename.includes('sign')) messageType = 'sign';
+
+          result.messageType = `rust-dlc-${messageType}`;
+
+          // Universal rust-dlc validations
+          if (testData.protocolVersion !== undefined) {
+            expect(testData.protocolVersion).to.be.a('number');
+            expect(testData.protocolVersion).to.equal(1);
+          }
+
+          // Message-specific validations
+          if (messageType === 'offer' || testData.contractInfo) {
+            expect(testData.chainHash).to.be.a('string');
+            expect(testData.temporaryContractId).to.be.a('string');
+            expect(testData.contractInfo).to.be.an('object');
+            expect(testData.fundingPubkey).to.be.a('string');
+            expect(testData.payoutSpk).to.be.a('string');
+
+            if (testData.contractInfo.singleContractInfo) {
+              expect(
+                testData.contractInfo.singleContractInfo.totalCollateral,
+              ).to.be.a('number');
+            }
+          }
+
+          if (
+            messageType === 'accept' ||
+            testData.acceptCollateral !== undefined
+          ) {
+            expect(testData.temporaryContractId).to.be.a('string');
+            expect(testData.acceptCollateral).to.be.a('number');
+            expect(testData.fundingPubkey).to.be.a('string');
+            expect(testData.cetAdaptorSignatures).to.be.an('object');
+            expect(
+              testData.cetAdaptorSignatures.ecdsaAdaptorSignatures,
+            ).to.be.an('array');
+          }
+
+          if (messageType === 'sign' || testData.contractId) {
+            expect(testData.contractId).to.be.a('string');
+            expect(testData.cetAdaptorSignatures).to.be.an('object');
+            expect(testData.refundSignature).to.be.a('string');
+            expect(testData.fundingSignatures).to.be.an('object');
+          }
+
+          result.success = true;
+          result.details = {
+            detectedType: messageType,
+            protocolVersion: testData.protocolVersion,
+            hasContractInfo: !!testData.contractInfo,
+            hasCetSignatures: !!testData.cetAdaptorSignatures,
+          };
+        } catch (error) {
+          result.error = error.message;
+        }
+
+        allResults.push(result);
+      });
+
+      // Generate comprehensive report
+      const rustDlcSuccessRate =
+        allResults.length > 0
+          ? allResults.filter((r) => r.success).length / allResults.length
+          : 0;
+
+      const failures = allResults.filter((r) => !r.success);
+
+      const reportLines = [
+        `Rust-DLC Test Vector Results:`,
+        `Files Processed: ${rustDlcFiles.length}`,
+        `Tests Run: ${allResults.length}`,
+        `Success Rate: ${Math.round(rustDlcSuccessRate * 100)}% (${
+          allResults.filter((r) => r.success).length
+        }/${allResults.length})`,
+      ];
+
+      if (failures.length > 0) {
+        reportLines.push('', 'Failures:');
+        failures.forEach((f) => {
+          reportLines.push(`  • ${f.filename}: ${f.error}`);
+        });
+      }
+
+      // We expect high compatibility with rust-dlc
+      expect(rustDlcSuccessRate).to.be.greaterThan(
+        0.8,
+        `Rust-DLC compatibility too low: ${Math.round(
+          rustDlcSuccessRate * 100,
+        )}%. \n\n${reportLines.join('\n')}`,
+      );
+    });
+  });
+
+  describe('Overall Ecosystem Compatibility Summary', () => {
+    it('should provide comprehensive ecosystem compatibility metrics with version analysis', () => {
+      expect(dlcSpecsFiles.length).to.be.greaterThan(
+        0,
+        'Should have dlcspecs test vectors',
+      );
+      expect(rustDlcFiles.length).to.be.greaterThan(
+        0,
+        'Should have rust-dlc test vectors',
+      );
+
+      // Report will be shown in console during test run through assertion messages
+      expect(true).to.be.true; // Always pass, this is just for reporting
+    });
+  });
+});

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

@@ -0,0 +1,255 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* 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;
+}
+
+// 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,
+    });
+
+    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}`,
+      };
+    }
+  }
+}
+
+// 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,
+        'Should find test vector files',
+      );
+      expect(Object.keys(allTestData).length).to.be.greaterThan(
+        0,
+        'Should load test data',
+      );
+
+      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
+          ? '[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} (${hasOffer} ${hasAccept} ${hasSign})`,
+        );
+      });
+    });
+  });
+
+  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),
+        );
+
+        expect(rustValidation.status).to.equal(
+          'success',
+          `Rust validation failed for ${filename}: ${rustValidation.message}`,
+        );
+
+        // Step 3: Test Rust serialization of Node.js JSON
+        const rustSerialization = callRustCli(
+          'serialize -t offer',
+          JSONBigInt.stringify(nodeJson),
+        );
+
+        expect(rustSerialization.status).to.equal(
+          'success',
+          `Rust serialization failed for ${filename}: ${rustSerialization.message}`,
+        );
+
+        const rustHex = rustSerialization.data;
+        expect(nodeHex).to.equal(
+          rustHex,
+          `Hex serialization mismatch for ${filename}. Node.js length: ${nodeHex.length}, Rust length: ${rustHex.length}`,
+        );
+      });
+    });
+  });
+
+  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}`,
+        );
+      });
+    });
+  });
+
+  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}`,
+        );
+      });
+    });
+  });
+
+  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',
+        );
+      }
+    });
+  });
+});