@atomicfinance/bitcoin-dlc-provider 4.2.6 → 4.2.8

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

@@ -1,439 +0,0 @@
-/* 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

@@ -1,255 +0,0 @@
-/* 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',
-        );
-      }
-    });
-  });
-});