@originals/sdk 1.4.2 → 1.4.3

package/tests/manual/test-commit-creation.ts

@@ -1,323 +0,0 @@
-/**
- * Manual Test: Commit Transaction Creation
- *
- * This script demonstrates and verifies commit transaction creation without broadcasting.
- * It uses test data (NOT real keys) to ensure the commit transaction logic works correctly.
- *
- * Expected Output:
- * - Valid P2TR commit address
- * - Valid PSBT with correct inputs and outputs
- * - Reveal keypair for subsequent reveal transaction
- * - Inscription script data (script, control block, leaf version)
- * - Fee calculation matching expected values
- *
- * Usage:
- * ```bash
- * bun run tests/manual/test-commit-creation.ts
- * ```
- *
- * IMPORTANT: This script does NOT broadcast transactions. It only creates and verifies
- * the PSBT structure for commit transactions.
- */
-
-import { createCommitTransaction } from '../../src/bitcoin/transactions/commit.js';
-import type { Utxo } from '../../src/types/bitcoin.js';
-import * as btc from '@scure/btc-signer';
-
-// ANSI color codes for output
-const colors = {
-  reset: '\x1b[0m',
-  bright: '\x1b[1m',
-  green: '\x1b[32m',
-  blue: '\x1b[34m',
-  yellow: '\x1b[33m',
-  red: '\x1b[31m'
-};
-
-function log(message: string, color = colors.reset) {
-  console.log(`${color}${message}${colors.reset}`);
-}
-
-function logSection(title: string) {
-  console.log('\n' + '='.repeat(80));
-  log(title, colors.bright + colors.blue);
-  console.log('='.repeat(80));
-}
-
-function logSuccess(message: string) {
-  log(`✓ ${message}`, colors.green);
-}
-
-function logInfo(message: string) {
-  log(`ℹ ${message}`, colors.blue);
-}
-
-function logWarning(message: string) {
-  log(`⚠ ${message}`, colors.yellow);
-}
-
-function logError(message: string) {
-  log(`✗ ${message}`, colors.red);
-}
-
-/**
- * Create mock UTXOs for testing (NOT real UTXOs)
- */
-function createMockUtxos(): Utxo[] {
-  return [
-    {
-      txid: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-      vout: 0,
-      value: 50000,
-      scriptPubKey: '0014' + 'b'.repeat(40), // Mock P2WPKH scriptPubKey
-      address: 'bc1qtest1234567890'
-    },
-    {
-      txid: 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
-      vout: 1,
-      value: 30000,
-      scriptPubKey: '0014' + 'c'.repeat(40),
-      address: 'bc1qtest0987654321'
-    }
-  ];
-}
-
-/**
- * Verify PSBT structure without decoding (basic checks)
- */
-function verifyPsbtStructure(psbt: btc.Transaction, expectedInputCount: number): boolean {
-  try {
-    logInfo(`PSBT Input Count: ${psbt.inputsLength}`);
-    logInfo(`PSBT Output Count: ${psbt.outputsLength}`);
-
-    if (psbt.inputsLength !== expectedInputCount) {
-      logError(`Expected ${expectedInputCount} inputs, got ${psbt.inputsLength}`);
-      return false;
-    }
-
-    if (psbt.outputsLength < 1) {
-      logError(`Expected at least 1 output, got ${psbt.outputsLength}`);
-      return false;
-    }
-
-    logSuccess('PSBT structure is valid');
-    return true;
-  } catch (error) {
-    logError(`Failed to verify PSBT: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    return false;
-  }
-}
-
-/**
- * Main test function
- */
-async function main() {
-  logSection('Commit Transaction Creation Test');
-
-  try {
-    // Test 1: Create simple text inscription
-    logSection('Test 1: Simple Text Inscription');
-
-    const inscription1Content = Buffer.from('Hello, Ordinals!');
-    const mockUtxos1 = createMockUtxos();
-
-    logInfo('Creating commit transaction...');
-    logInfo(`Content: "${inscription1Content.toString()}"`);
-    logInfo(`Content Type: text/plain`);
-    logInfo(`Available UTXOs: ${mockUtxos1.length}`);
-    logInfo(`Total Value: ${mockUtxos1.reduce((sum, u) => sum + u.value, 0)} sats`);
-
-    const result1 = await createCommitTransaction({
-      content: inscription1Content,
-      contentType: 'text/plain',
-      utxos: mockUtxos1,
-      changeAddress: 'bc1qtest_change_address_12345',
-      feeRate: 10,
-      network: 'mainnet'
-    });
-
-    logSuccess('Commit transaction created successfully');
-
-    // Verify commit address
-    logInfo(`Commit Address: ${result1.commitAddress}`);
-    if (result1.commitAddress.startsWith('bc1p')) {
-      logSuccess('Commit address is valid P2TR (bc1p...)');
-    } else {
-      logWarning(`Unexpected address format: ${result1.commitAddress}`);
-    }
-
-    // Verify PSBT
-    logInfo(`PSBT Base64 Length: ${result1.commitPsbtBase64.length} chars`);
-    logInfo(`PSBT Base64 (first 50 chars): ${result1.commitPsbtBase64.substring(0, 50)}...`);
-
-    // Verify PSBT structure
-    const psbtValid = verifyPsbtStructure(result1.commitPsbt, 1);
-    if (!psbtValid) {
-      throw new Error('PSBT structure validation failed');
-    }
-
-    // Verify commit amount and fees
-    logInfo(`Commit Amount: ${result1.commitAmount} sats`);
-    logInfo(`Commit Fee: ${result1.fees.commit} sats`);
-
-    if (result1.commitAmount < 546) {
-      logError('Commit amount is below dust limit!');
-    } else {
-      logSuccess('Commit amount meets dust limit');
-    }
-
-    if (result1.fees.commit <= 0) {
-      logError('Invalid fee amount!');
-    } else {
-      logSuccess(`Fee calculation: ${result1.fees.commit} sats at 10 sat/vB`);
-    }
-
-    // Verify reveal keypair
-    logInfo(`Reveal Private Key Length: ${result1.revealPrivateKey.length} chars`);
-    logInfo(`Reveal Public Key Length: ${result1.revealPublicKey.length} chars`);
-
-    if (result1.revealPrivateKey.length === 64 && result1.revealPublicKey.length === 64) {
-      logSuccess('Reveal keypair has correct format (32 bytes each in hex)');
-    } else {
-      logWarning('Unexpected reveal keypair format');
-    }
-
-    // Verify inscription script
-    logInfo(`Inscription Script Length: ${result1.inscriptionScript.script.length} bytes`);
-    logInfo(`Control Block Length: ${result1.inscriptionScript.controlBlock.length} bytes`);
-    logInfo(`Leaf Version: 0x${result1.inscriptionScript.leafVersion.toString(16)}`);
-
-    if (result1.inscriptionScript.leafVersion === 0xc0) {
-      logSuccess('Leaf version is correct (0xc0)');
-    } else {
-      logWarning(`Unexpected leaf version: 0x${result1.inscriptionScript.leafVersion.toString(16)}`);
-    }
-
-    // Verify selected UTXOs
-    logInfo(`Selected UTXOs: ${result1.selectedUtxos.length}`);
-    const totalSelectedValue = result1.selectedUtxos.reduce((sum, u) => sum + u.value, 0);
-    logInfo(`Total Selected Value: ${totalSelectedValue} sats`);
-
-    const expectedMinimum = result1.commitAmount + result1.fees.commit;
-    if (totalSelectedValue >= expectedMinimum) {
-      logSuccess(`Selected UTXOs cover commit + fees (${totalSelectedValue} >= ${expectedMinimum})`);
-    } else {
-      logError(`Insufficient selected value (${totalSelectedValue} < ${expectedMinimum})`);
-    }
-
-    // Test 2: JSON content with metadata
-    logSection('Test 2: JSON Content with Metadata');
-
-    const inscription2Content = Buffer.from(JSON.stringify({
-      message: 'Test inscription',
-      timestamp: Date.now()
-    }));
-
-    const result2 = await createCommitTransaction({
-      content: inscription2Content,
-      contentType: 'application/json',
-      utxos: createMockUtxos(),
-      changeAddress: 'bc1qtest_change_address_12345',
-      feeRate: 20,
-      network: 'mainnet',
-      metadata: {
-        title: 'Test JSON Inscription',
-        author: 'Manual Test Script'
-      }
-    });
-
-    logSuccess('JSON inscription commit transaction created');
-    logInfo(`Commit Address: ${result2.commitAddress}`);
-    logInfo(`Fee Rate: 20 sat/vB`);
-    logInfo(`Commit Fee: ${result2.fees.commit} sats`);
-
-    // Verify fee scales with fee rate (should be ~2x the first test)
-    const feeRatio = result2.fees.commit / result1.fees.commit;
-    logInfo(`Fee Ratio (20 sat/vB vs 10 sat/vB): ${feeRatio.toFixed(2)}x`);
-
-    if (feeRatio >= 1.8 && feeRatio <= 2.2) {
-      logSuccess('Fee scales correctly with fee rate');
-    } else {
-      logWarning(`Fee ratio outside expected range: ${feeRatio.toFixed(2)}x`);
-    }
-
-    // Test 3: Large content (1KB)
-    logSection('Test 3: Large Content (1KB)');
-
-    const largeContent = Buffer.alloc(1024, 'a');
-
-    const result3 = await createCommitTransaction({
-      content: largeContent,
-      contentType: 'text/plain',
-      utxos: [
-        {
-          txid: 'c'.repeat(64),
-          vout: 0,
-          value: 500000, // Larger UTXO for larger content
-          scriptPubKey: '0014' + 'd'.repeat(40),
-          address: 'bc1qtest_large_utxo'
-        }
-      ],
-      changeAddress: 'bc1qtest_change_address_12345',
-      feeRate: 10,
-      network: 'mainnet'
-    });
-
-    logSuccess('Large content inscription commit transaction created');
-    logInfo(`Content Size: ${largeContent.length} bytes`);
-    logInfo(`Inscription Script Size: ${result3.inscriptionScript.script.length} bytes`);
-    logInfo(`Commit Fee: ${result3.fees.commit} sats`);
-
-    // Test 4: Testnet address
-    logSection('Test 4: Testnet Address Generation');
-
-    const result4 = await createCommitTransaction({
-      content: Buffer.from('Testnet inscription'),
-      contentType: 'text/plain',
-      utxos: createMockUtxos(),
-      changeAddress: 'tb1qtest_testnet_change',
-      feeRate: 5,
-      network: 'testnet'
-    });
-
-    logInfo(`Testnet Commit Address: ${result4.commitAddress}`);
-
-    if (result4.commitAddress.startsWith('tb1p')) {
-      logSuccess('Testnet address is valid (tb1p...)');
-    } else {
-      logWarning(`Unexpected testnet address format: ${result4.commitAddress}`);
-    }
-
-    // Final summary
-    logSection('Test Summary');
-    logSuccess('All tests completed successfully!');
-    logInfo('Commit transaction creation is working correctly');
-    logInfo('PSBT structure is valid');
-    logInfo('Fee calculation is accurate');
-    logInfo('P2TR address generation is correct');
-    logInfo('Inscription script data is properly formatted');
-
-    console.log('\n' + '='.repeat(80));
-    logSuccess('✓ Manual verification complete - commit.ts is ready for use');
-    console.log('='.repeat(80) + '\n');
-
-    // IMPORTANT REMINDER
-    logWarning('REMINDER: This script does NOT broadcast transactions');
-    logWarning('         It only creates and verifies PSBT structure');
-    logWarning('         DO NOT use these test keys or addresses for real Bitcoin');
-
-  } catch (error) {
-    logSection('Test Failed');
-    logError(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    if (error instanceof Error && error.stack) {
-      console.error(error.stack);
-    }
-    process.exit(1);
-  }
-}
-
-// Run the tests
-main().catch(error => {
-  console.error('Unhandled error:', error);
-  process.exit(1);
-});

package/tests/mocks/MockKeyStore.ts

@@ -1,38 +0,0 @@
-import { KeyStore } from '../../src/types';
-
-/**
- * MockKeyStore is a simple in-memory implementation of the KeyStore interface
- * for testing purposes.
- */
-export class MockKeyStore implements KeyStore {
-  private keys: Map<string, string> = new Map();
-
-  async getPrivateKey(verificationMethodId: string): Promise<string | null> {
-    return this.keys.get(verificationMethodId) || null;
-  }
-
-  async setPrivateKey(verificationMethodId: string, privateKey: string): Promise<void> {
-    this.keys.set(verificationMethodId, privateKey);
-  }
-
-  /**
-   * Helper method for testing: clear all stored keys
-   */
-  clear(): void {
-    this.keys.clear();
-  }
-
-  /**
-   * Helper method for testing: get all stored keys
-   */
-  getAllKeys(): Map<string, string> {
-    return new Map(this.keys);
-  }
-
-  /**
-   * Helper method: get all verification method IDs
-   */
-  getAllVerificationMethodIds(): string[] {
-    return Array.from(this.keys.keys());
-  }
-}

package/tests/mocks/adapters/MemoryStorageAdapter.ts

@@ -1,24 +0,0 @@
-import type { StorageAdapter, StorageGetResult, StoragePutOptions } from '../../../src/adapters/types';
-
-export class MemoryStorageAdapter implements StorageAdapter {
-  private readonly keyToObject: Map<string, { content: Buffer; contentType: string }> = new Map();
-
-  async put(objectKey: string, data: Buffer | string, options: StoragePutOptions = {}): Promise<string> {
-    const content = Buffer.isBuffer(data) ? data : Buffer.from(data);
-    const contentType = options.contentType || 'application/octet-stream';
-    this.keyToObject.set(objectKey, { content, contentType });
-    return `memory://${objectKey}`;
-  }
-
-  async get(objectKey: string): Promise<StorageGetResult | null> {
-    const entry = this.keyToObject.get(objectKey);
-    if (!entry) return null;
-    return { content: Buffer.from(entry.content), contentType: entry.contentType };
-  }
-
-  async delete(objectKey: string): Promise<boolean> {
-    return this.keyToObject.delete(objectKey);
-  }
-}
-
-

package/tests/mocks/adapters/MockFeeOracle.ts

@@ -1,11 +0,0 @@
-import type { FeeOracleAdapter } from '../../../src/adapters/types';
-
-export class MockFeeOracle implements FeeOracleAdapter {
-  constructor(private readonly defaultRate: number = 10) {}
-  async estimateFeeRate(targetBlocks: number = 1): Promise<number> {
-    const multiplier = Math.max(1, Math.min(6, targetBlocks));
-    return this.defaultRate * multiplier;
-  }
-}
-
-

package/tests/mocks/adapters/MockOrdinalsProvider.ts

@@ -1,76 +0,0 @@
-import type { OrdinalsProvider } from '../../../src/adapters/types';
-
-export class MockOrdinalsProvider implements OrdinalsProvider {
-  async createInscription(params: { data: Buffer; contentType: string; feeRate?: number }) {
-    return {
-      inscriptionId: 'insc-mock',
-      revealTxId: 'tx-reveal-mock',
-      commitTxId: 'tx-commit-mock',
-      satoshi: '123',
-      txid: 'tx-mock',
-      vout: 0,
-      blockHeight: 1,
-      content: params.data,
-      contentType: params.contentType,
-      feeRate: params.feeRate
-    };
-  }
-
-  async getInscriptionById(id: string) {
-    if (!id) return null;
-    return {
-      inscriptionId: id,
-      content: Buffer.from(''),
-      contentType: 'text/plain',
-      txid: 'tx-mock',
-      vout: 0,
-      satoshi: '123'
-    };
-  }
-
-  async transferInscription(
-    inscriptionId: string,
-    toAddress: string,
-    options?: { feeRate?: number }
-  ): Promise<{
-    txid: string;
-    vin: Array<{ txid: string; vout: number }>;
-    vout: Array<{ value: number; scriptPubKey: string; address?: string }>;
-    fee: number;
-    blockHeight?: number;
-    confirmations?: number;
-    satoshi?: string;
-  }> {
-    if (!inscriptionId) {
-      throw new Error('inscriptionId required');
-    }
-    return {
-      txid: 'tx-transfer-mock',
-      vin: [{ txid: 'tx-prev', vout: 0 }],
-      vout: [{ value: 10_000, scriptPubKey: 'script', address: toAddress }],
-      fee: options?.feeRate ? Math.round(options.feeRate) : 100,
-      blockHeight: 2,
-      confirmations: 0,
-      satoshi: '123'
-    };
-  }
-
-  async getInscriptionsBySatoshi(satoshi: string) {
-    if (!satoshi) return [];
-    return [{ inscriptionId: 'insc-mock' }];
-  }
-
-  async broadcastTransaction(_txHexOrObj: unknown): Promise<string> {
-    return 'txid-mock';
-  }
-
-  async getTransactionStatus(_txid: string): Promise<{ confirmed: boolean; blockHeight?: number; confirmations?: number }> {
-    return { confirmed: false };
-  }
-
-  async estimateFee(blocks: number = 1): Promise<number> {
-    return 10 * Math.max(1, blocks);
-  }
-}
-
-

package/tests/mocks/adapters/OrdMockProvider.test.ts

@@ -1,176 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { OrdMockProvider } from '../../../src/adapters/providers/OrdMockProvider';
-
-describe('OrdMockProvider', () => {
-  test('createInscription and retrieval works', async () => {
-    const prov = new OrdMockProvider();
-    const data = Buffer.from('hello');
-    const res = await prov.createInscription({ data, contentType: 'text/plain' });
-    expect(typeof res.inscriptionId).toBe('string');
-    const fetched = await prov.getInscriptionById(res.inscriptionId);
-    expect(fetched?.txid).toBe(res.txid);
-  });
-
-  test('broadcastTransaction returns mock txid', async () => {
-    const prov = new OrdMockProvider();
-    const txid = await prov.broadcastTransaction('mock-tx-hex');
-    expect(txid).toBe('mock-broadcast-txid');
-  });
-
-  test('getTransactionStatus returns confirmed status', async () => {
-    const prov = new OrdMockProvider();
-    const status = await prov.getTransactionStatus('any-txid');
-    expect(status.confirmed).toBe(true);
-    expect(status.blockHeight).toBe(1);
-    expect(status.confirmations).toBe(1);
-  });
-
-  test('estimateFee with default blocks', async () => {
-    const prov = new OrdMockProvider();
-    const fee = await prov.estimateFee();
-    expect(fee).toBeGreaterThanOrEqual(1);
-  });
-
-  test('estimateFee with multiple blocks reduces fee', async () => {
-    const prov = new OrdMockProvider({ feeRate: 10 });
-    const fee1 = await prov.estimateFee(1);
-    const fee3 = await prov.estimateFee(3);
-    expect(fee1).toBe(10);
-    expect(fee3).toBe(8); // 10 - (3-1) = 8
-  });
-
-  test('transferInscription throws error for non-existent inscription', async () => {
-    const prov = new OrdMockProvider();
-    await expect(prov.transferInscription('non-existent', 'bc1qaddress'))
-      .rejects.toThrow('inscription not found');
-  });
-
-  test('constructor accepts custom state', async () => {
-    const customState = new Map();
-    customState.set('test-id', {
-      inscriptionId: 'test-id',
-      content: Buffer.from('test'),
-      contentType: 'text/plain',
-      txid: 'test-txid',
-      vout: 0,
-      satoshi: 'test-sat'
-    });
-
-    const prov = new OrdMockProvider({
-      inscriptionsById: customState,
-      feeRate: 10
-    });
-
-    const inscription = await prov.getInscriptionById('test-id');
-    expect(inscription).toBeDefined();
-    expect(inscription?.inscriptionId).toBe('test-id');
-  });
-
-  test('getInscriptionById returns null for non-existent id', async () => {
-    const prov = new OrdMockProvider();
-    const inscription = await prov.getInscriptionById('non-existent');
-    expect(inscription).toBeNull();
-  });
-
-  test('getInscriptionsBySatoshi returns empty array for non-existent satoshi', async () => {
-    const prov = new OrdMockProvider();
-    const inscriptions = await prov.getInscriptionsBySatoshi('999999');
-    expect(inscriptions).toEqual([]);
-  });
-
-  test('getInscriptionsBySatoshi returns list of inscriptions for satoshi', async () => {
-    const prov = new OrdMockProvider();
-    const data = Buffer.from('test data');
-    const res = await prov.createInscription({ data, contentType: 'text/plain' });
-    
-    // Get the satoshi from the created inscription
-    const inscriptions = await prov.getInscriptionsBySatoshi(res.satoshi!);
-    expect(inscriptions.length).toBeGreaterThan(0);
-    expect(inscriptions[0].inscriptionId).toBe(res.inscriptionId);
-  });
-
-  test('createInscription with custom feeRate', async () => {
-    const prov = new OrdMockProvider();
-    const data = Buffer.from('test data');
-    const res = await prov.createInscription({ 
-      data, 
-      contentType: 'text/plain',
-      feeRate: 15 
-    });
-    expect(res.feeRate).toBe(15);
-  });
-
-  test('createInscription returns all expected fields', async () => {
-    const prov = new OrdMockProvider();
-    const data = Buffer.from('test data');
-    const res = await prov.createInscription({ data, contentType: 'text/plain' });
-    
-    expect(res.inscriptionId).toBeDefined();
-    expect(res.revealTxId).toBeDefined();
-    expect(res.commitTxId).toBeUndefined();
-    expect(res.satoshi).toBeDefined();
-    expect(res.txid).toBeDefined();
-    expect(res.vout).toBe(0);
-    expect(res.blockHeight).toBe(1);
-    expect(res.content).toEqual(data);
-    expect(res.contentType).toBe('text/plain');
-  });
-
-  test('transferInscription returns proper transaction details', async () => {
-    const prov = new OrdMockProvider();
-    const data = Buffer.from('test data');
-    const res = await prov.createInscription({ data, contentType: 'text/plain' });
-    
-    const transfer = await prov.transferInscription(res.inscriptionId, 'bc1qaddress', { feeRate: 10 });
-    
-    expect(transfer.txid).toBeDefined();
-    expect(transfer.vin).toBeDefined();
-    expect(transfer.vin.length).toBeGreaterThan(0);
-    expect(transfer.vin[0].txid).toBe(res.txid);
-    expect(transfer.vin[0].vout).toBe(res.vout);
-    expect(transfer.vout).toBeDefined();
-    expect(transfer.vout[0].value).toBe(546);
-    expect(transfer.vout[0].scriptPubKey).toBe('script');
-    expect(transfer.fee).toBe(100);
-    expect(transfer.blockHeight).toBe(1);
-    expect(transfer.confirmations).toBe(0);
-    expect(transfer.satoshi).toBe(res.satoshi);
-  });
-
-  test('transferInscription without options', async () => {
-    const prov = new OrdMockProvider();
-    const data = Buffer.from('test data');
-    const res = await prov.createInscription({ data, contentType: 'text/plain' });
-    
-    const transfer = await prov.transferInscription(res.inscriptionId, 'bc1qaddress');
-    
-    expect(transfer.txid).toBeDefined();
-  });
-
-  test('constructor with partial state including inscriptionsBySatoshi', async () => {
-    const inscriptionsBySatoshi = new Map();
-    inscriptionsBySatoshi.set('12345', ['insc-1', 'insc-2']);
-    
-    const prov = new OrdMockProvider({
-      inscriptionsBySatoshi,
-      feeRate: 8
-    });
-
-    const inscriptions = await prov.getInscriptionsBySatoshi('12345');
-    expect(inscriptions.length).toBe(2);
-    expect(inscriptions[0].inscriptionId).toBe('insc-1');
-    expect(inscriptions[1].inscriptionId).toBe('insc-2');
-  });
-
-  test('createInscription generates numeric satoshi identifier', async () => {
-    const prov = new OrdMockProvider();
-    const data = Buffer.from('test');
-    const res = await prov.createInscription({ data, contentType: 'text/plain' });
-    
-    // Verify satoshi is numeric
-    expect(res.satoshi).toBeDefined();
-    expect(Number.isNaN(Number(res.satoshi))).toBe(false);
-    expect(Number(res.satoshi!)).toBeGreaterThan(0);
-  });
-});
-

package/tests/mocks/adapters/index.ts

@@ -1,6 +0,0 @@
-export * from './MemoryStorageAdapter';
-export * from './MockFeeOracle';
-export * from './MockOrdinalsProvider';
-export * from '../MockKeyStore';
-
-