@originals/sdk 1.1.0

package/src/bitcoin/providers/OrdNodeProvider.ts

@@ -0,0 +1,92 @@
+import type { ResourceProvider, LinkedResource, ResourceInfo, Inscription, ResourceCrawlOptions } from './types';
+
+export interface OrdNodeProviderOptions {
+  nodeUrl: string;
+  timeout?: number;
+  network?: 'mainnet' | 'testnet' | 'signet';
+}
+
+export class OrdNodeProvider implements ResourceProvider {
+  private readonly nodeUrl: string;
+  private readonly timeout: number;
+  private readonly network: 'mainnet' | 'testnet' | 'signet';
+
+  constructor(options: OrdNodeProviderOptions) {
+    this.nodeUrl = options.nodeUrl;
+    this.timeout = options.timeout || 5000;
+    this.network = options.network || 'mainnet';
+  }
+
+  async resolve(resourceId: string): Promise<LinkedResource> {
+    return {
+      id: resourceId,
+      type: 'Unknown',
+      contentType: 'application/octet-stream',
+      content_url: `${this.nodeUrl}/content/${resourceId}`
+    };
+  }
+
+  async resolveInscription(inscriptionId: string): Promise<Inscription> {
+    return {
+      id: inscriptionId,
+      sat: 0,
+      content_type: 'text/plain',
+      content_url: `${this.nodeUrl}/content/${inscriptionId}`
+    };
+  }
+
+  async resolveInfo(resourceId: string): Promise<ResourceInfo> {
+    return {
+      id: resourceId,
+      type: 'Unknown',
+      contentType: 'application/octet-stream',
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+      content_url: `${this.nodeUrl}/content/${resourceId}`
+    };
+  }
+
+  async resolveCollection(did: string, _options: { type?: string; limit?: number; offset?: number } = {}): Promise<LinkedResource[]> {
+    return [];
+  }
+
+  async getSatInfo(_satNumber: string): Promise<{ inscription_ids: string[] }> {
+    return { inscription_ids: [] };
+  }
+
+  async getMetadata(_inscriptionId: string): Promise<any> {
+    return null;
+  }
+
+  async *getAllResources(_options: ResourceCrawlOptions = {}): AsyncGenerator<LinkedResource[]> {
+    // no-op generator yields nothing
+    return;
+  }
+
+  async *getAllResourcesChronological(_options: ResourceCrawlOptions = {}): AsyncGenerator<LinkedResource[]> {
+    // no-op generator yields nothing
+    return;
+  }
+
+  async getInscriptionLocationsByAddress(_address: string): Promise<{ id: string; location: string }[]> {
+    return [];
+  }
+
+  async getInscriptionByNumber(_inscriptionNumber: number): Promise<Inscription> {
+    return {
+      id: '0',
+      sat: 0,
+      content_type: 'text/plain',
+      content_url: `${this.nodeUrl}/content/0`
+    };
+  }
+
+  async getAddressOutputs(_address: string): Promise<string[]> {
+    return [];
+  }
+
+  async getOutputDetails(_outpoint: string): Promise<{ value: number; script_pubkey: string; spent: boolean; inscriptions: string[] }> {
+    return { value: 0, script_pubkey: '', spent: false, inscriptions: [] };
+  }
+}
+

package/src/bitcoin/providers/OrdinalsProvider.ts

@@ -0,0 +1,56 @@
+import { OrdinalsClient } from '../OrdinalsClient';
+import { withRetry } from '../../utils/retry';
+
+export interface OrdinalsProvider {
+  getSatInfo(satNumber: string): Promise<{ inscription_ids: string[] }>;
+  resolveInscription(inscriptionId: string): Promise<{ id: string; sat: number; content_type: string; content_url: string }>;
+  getMetadata(inscriptionId: string): Promise<any>;
+  estimateFee(blocks?: number): Promise<number>;
+}
+
+export class OrdinalsClientProvider implements OrdinalsProvider {
+  constructor(private client: OrdinalsClient, private options?: { retries?: number; baseUrl?: string }) {}
+
+  async getSatInfo(satNumber: string): Promise<{ inscription_ids: string[] }> {
+    return withRetry(() => this.client.getSatInfo(satNumber), {
+      maxRetries: this.options?.retries ?? 2,
+      isRetriable: () => true
+    });
+  }
+
+  async resolveInscription(inscriptionId: string): Promise<{ id: string; sat: number; content_type: string; content_url: string }> {
+    return withRetry(async () => {
+      const res = await this.client.getInscriptionById(inscriptionId);
+      if (!res) throw new Error('Inscription not found');
+      if (!res.satoshi) throw new Error('Inscription missing satoshi');
+      const sat = Number(String(res.satoshi));
+      if (Number.isNaN(sat)) throw new Error('Invalid satoshi value');
+      if (!res.contentType) throw new Error('Inscription missing contentType');
+      const base = (this.options?.baseUrl || '').replace(/\/$/, '');
+      if (!base) throw new Error('baseUrl is required to construct content_url');
+      const id = res.inscriptionId;
+      const content_url = `${base}/content/${id}`;
+      return {
+        id,
+        sat,
+        content_type: res.contentType,
+        content_url
+      };
+    }, { maxRetries: this.options?.retries ?? 2, isRetriable: () => true });
+  }
+
+  async getMetadata(inscriptionId: string): Promise<any> {
+    return withRetry(() => this.client.getMetadata(inscriptionId), {
+      maxRetries: this.options?.retries ?? 2,
+      isRetriable: () => true
+    });
+  }
+
+  async estimateFee(blocks?: number): Promise<number> {
+    return withRetry(() => this.client.estimateFee(blocks), {
+      maxRetries: this.options?.retries ?? 2,
+      isRetriable: () => true
+    });
+  }
+}
+

package/src/bitcoin/providers/types.ts

@@ -0,0 +1,59 @@
+export interface LinkedResource {
+  id: string;
+  type: string;
+  contentType: string;
+  content_url: string;
+}
+
+export interface Inscription {
+  id: string;
+  sat: number;
+  content_type: string;
+  content_url: string;
+  number?: number;
+  height?: number;
+  timestamp?: number;
+}
+
+export interface ResourceInfo {
+  id: string;
+  type: string;
+  contentType: string;
+  createdAt?: string;
+  updatedAt?: string;
+  content_url: string;
+}
+
+export interface ResourceProvider {
+  resolve(resourceId: string): Promise<LinkedResource>;
+  resolveInscription(inscriptionId: string): Promise<Inscription>;
+  resolveInfo(resourceId: string): Promise<ResourceInfo>;
+  resolveCollection(did: string, options: { type?: string; limit?: number; offset?: number }): Promise<LinkedResource[]>;
+  getSatInfo(satNumber: string): Promise<{ inscription_ids: string[] }>;
+  getMetadata(inscriptionId: string): Promise<any>;
+  getAllResources(options?: ResourceCrawlOptions): AsyncGenerator<LinkedResource[]>;
+  getAllResourcesChronological(options?: ResourceCrawlOptions): AsyncGenerator<LinkedResource[]>;
+  getInscriptionLocationsByAddress(address: string): Promise<InscriptionRefWithLocation[]>;
+  getInscriptionByNumber(inscriptionNumber: number): Promise<Inscription>;
+  getAddressOutputs(address: string): Promise<string[]>;
+  getOutputDetails(outpoint: string): Promise<{ value: number; script_pubkey: string; spent: boolean; inscriptions: string[] }>;
+}
+
+export interface ResourceCrawlOptions {
+  batchSize?: number;
+  startFrom?: number;
+  maxResources?: number;
+  filter?: (resource: LinkedResource) => boolean;
+}
+
+export interface ResourceBatch {
+  resources: LinkedResource[];
+  nextCursor?: number;
+  hasMore: boolean;
+}
+
+export interface InscriptionRefWithLocation {
+  id: string;
+  location: string;
+}
+

package/src/bitcoin/transactions/commit.ts

@@ -0,0 +1,465 @@
+/**
+ * Commit Transaction Processing for Ordinals
+ *
+ * This module implements the commit transaction process for ordinals inscriptions.
+ * It handles the generation of the commit address and preparation of the commit transaction.
+ *
+ * Ported from legacy ordinalsplus transaction infrastructure.
+ */
+
+import * as btc from '@scure/btc-signer';
+import * as ordinals from 'micro-ordinals';
+import { schnorr } from '@noble/curves/secp256k1';
+import { Utxo } from '../../types/bitcoin.js';
+import { calculateFee } from '../fee-calculation.js';
+import { selectUtxos, SimpleUtxoSelectionOptions } from '../utxo-selection.js';
+
+// Define minimum dust limit (satoshis)
+const MIN_DUST_LIMIT = 546;
+
+// Maximum iterations for UTXO reselection to prevent infinite loops
+const MAX_SELECTION_ITERATIONS = 5;
+
+/**
+ * Bitcoin network type for @scure/btc-signer
+ */
+type BitcoinNetwork = 'mainnet' | 'testnet' | 'regtest' | 'signet';
+
+/**
+ * Get @scure/btc-signer network configuration
+ */
+function getScureNetwork(network: BitcoinNetwork): typeof btc.NETWORK {
+  switch (network) {
+    case 'mainnet':
+      return btc.NETWORK;
+    case 'testnet':
+    case 'signet':
+    case 'regtest':
+      return btc.TEST_NETWORK;
+    default:
+      return btc.NETWORK;
+  }
+}
+
+/**
+ * Validates that a UTXO has all required fields for spending
+ *
+ * @param utxo - The UTXO to validate
+ * @returns true if the UTXO is valid and spendable, false otherwise
+ */
+function isValidSpendableUtxo(utxo: Utxo): boolean {
+  return !!(
+    utxo.txid &&
+    typeof utxo.vout === 'number' &&
+    utxo.value > 0 &&
+    utxo.scriptPubKey &&
+    utxo.scriptPubKey.length > 0
+  );
+}
+
+/**
+ * Parameters for creating a commit transaction
+ */
+export interface CommitTransactionParams {
+  /** Inscription content as Buffer */
+  content: Buffer;
+  /** MIME type of the content (e.g., 'text/plain', 'image/png') */
+  contentType: string;
+  /** Available UTXOs to fund the transaction */
+  utxos: Utxo[];
+  /** Address to send change back to */
+  changeAddress: string;
+  /** Fee rate in sats/vB */
+  feeRate: number;
+  /** Bitcoin network configuration */
+  network: BitcoinNetwork;
+  /** Optional minimum amount for the commit output */
+  minimumCommitAmount?: number;
+  /** Optional metadata for the inscription */
+  metadata?: Record<string, unknown>;
+  /** Optional pointer to target specific satoshi */
+  pointer?: number;
+}
+
+/**
+ * Result of the commit transaction creation
+ */
+export interface CommitTransactionResult {
+  /** P2TR address for the commit output */
+  commitAddress: string;
+  /** Base64-encoded PSBT for the commit transaction */
+  commitPsbtBase64: string;
+  /** Raw PSBT object for commit transaction (for direct manipulation) */
+  commitPsbt: btc.Transaction;
+  /** The exact amount sent to the commit output */
+  commitAmount: number;
+  /** Selected UTXOs for the transaction */
+  selectedUtxos: Utxo[];
+  /** Fee information */
+  fees: {
+    /** Fee for the commit transaction in satoshis */
+    commit: number;
+  };
+  /** Reveal private key (hex string) - needed for reveal transaction */
+  revealPrivateKey: string;
+  /** Reveal public key (hex string) */
+  revealPublicKey: string;
+  /** Inscription script for reveal transaction */
+  inscriptionScript: {
+    script: Uint8Array;
+    controlBlock: Uint8Array;
+    leafVersion: number;
+  };
+}
+
+/**
+ * Estimates the size of a commit transaction
+ *
+ * @param inputCount - Number of transaction inputs
+ * @param outputCount - Number of transaction outputs (including commit and change)
+ * @returns Estimated transaction size in virtual bytes
+ */
+function estimateCommitTxSize(inputCount: number, outputCount: number): number {
+  // Transaction overhead
+  const overhead = 10.5;
+
+  // P2WPKH inputs (assuming most common case)
+  const inputSize = 68 * inputCount;
+
+  // P2TR output for commit and P2WPKH for change
+  const commitOutputSize = 43; // P2TR output
+  const changeOutputSize = outputCount > 1 ? 31 * (outputCount - 1) : 0; // P2WPKH outputs for change
+
+  return Math.ceil(overhead + inputSize + commitOutputSize + changeOutputSize);
+}
+
+/**
+ * Creates a commit transaction for an ordinals inscription
+ *
+ * This function:
+ * 1. Validates and filters UTXOs to ensure they are spendable
+ * 2. Creates an inscription with the provided content
+ * 3. Generates a reveal keypair and script
+ * 4. Creates a P2TR commit address
+ * 5. Selects UTXOs to fund the transaction (with iterative reselection if needed)
+ * 6. Builds a PSBT with commit output and change
+ *
+ * The function ensures that:
+ * - All selected UTXOs have valid scriptPubKey fields
+ * - Total input value always covers output value + fees
+ * - UTXO selection is re-run if fee increases after accurate calculation
+ *
+ * @param params - Parameters for the commit transaction
+ * @returns Complete information for the prepared commit transaction
+ * @throws Error if no valid UTXOs are available or insufficient funds
+ */
+export async function createCommitTransaction(
+  params: CommitTransactionParams
+): Promise<CommitTransactionResult> {
+  const {
+    content,
+    contentType,
+    utxos,
+    changeAddress,
+    feeRate,
+    network,
+    minimumCommitAmount = MIN_DUST_LIMIT,
+    metadata,
+    pointer
+  } = params;
+
+  // Validate inputs
+  if (!utxos || utxos.length === 0) {
+    throw new Error('No UTXOs provided to fund the transaction.');
+  }
+
+  if (!content || content.length === 0) {
+    throw new Error('Invalid inscription: missing content.');
+  }
+
+  if (!contentType) {
+    throw new Error('Invalid inscription: missing content type.');
+  }
+
+  if (!changeAddress) {
+    throw new Error('Change address is required.');
+  }
+
+  if (feeRate <= 0) {
+    throw new Error(`Invalid fee rate: ${feeRate}`);
+  }
+
+  // CRITICAL: Pre-filter UTXOs to ensure all have valid scriptPubKey
+  // This prevents silent failures where UTXOs are selected but can't be spent
+  const validUtxos = utxos.filter(isValidSpendableUtxo);
+
+  if (validUtxos.length === 0) {
+    const invalidCount = utxos.length;
+    const invalidReasons: string[] = [];
+
+    utxos.forEach((utxo, idx) => {
+      if (!utxo.scriptPubKey || utxo.scriptPubKey.length === 0) {
+        invalidReasons.push(`UTXO ${idx} (${utxo.txid}:${utxo.vout}): missing scriptPubKey`);
+      } else if (!utxo.txid) {
+        invalidReasons.push(`UTXO ${idx}: missing txid`);
+      } else if (typeof utxo.vout !== 'number') {
+        invalidReasons.push(`UTXO ${idx} (${utxo.txid}): missing or invalid vout`);
+      } else if (utxo.value <= 0) {
+        invalidReasons.push(`UTXO ${idx} (${utxo.txid}:${utxo.vout}): invalid value (${utxo.value})`);
+      }
+    });
+
+    throw new Error(
+      `No valid spendable UTXOs available. ${invalidCount} UTXO(s) provided but all are invalid:\n` +
+      invalidReasons.slice(0, 5).join('\n') +
+      (invalidReasons.length > 5 ? `\n... and ${invalidReasons.length - 5} more` : '')
+    );
+  }
+
+  // Log filtered UTXOs for debugging
+  if (validUtxos.length < utxos.length) {
+    const filteredCount = utxos.length - validUtxos.length;
+    console.warn(`Filtered out ${filteredCount} invalid UTXO(s). ${validUtxos.length} valid UTXO(s) remain.`);
+  }
+
+  // Step 1: Create the inscription object
+  const tags: ordinals.Tags = {
+    contentType
+  };
+
+  // Add metadata if provided
+  if (metadata && Object.keys(metadata).length > 0) {
+    tags.metadata = metadata;
+  }
+
+  // Add pointer if provided
+  if (typeof pointer !== 'undefined') {
+    (tags as any).pointer = pointer;
+  }
+
+  const inscription: ordinals.Inscription = {
+    tags,
+    body: new Uint8Array(content)
+  };
+
+  // Step 2: Generate a reveal keypair
+  // Use random private key for reveal transaction
+  const revealPrivateKey = schnorr.utils.randomPrivateKey();
+  const revealPublicKey = schnorr.getPublicKey(revealPrivateKey);
+
+  // Step 3: Create the inscription script tree using micro-ordinals
+  const scriptTree = ordinals.p2tr_ord_reveal(revealPublicKey, [inscription]);
+
+  // Step 4: Create P2TR address for the commit output
+  const scureNetwork = getScureNetwork(network);
+
+  // Create taproot output using the inscription script tree
+  // Use the reveal public key as the internal key
+  const taprootPayment = btc.p2tr(
+    revealPublicKey, // internal key
+    scriptTree, // script tree
+    scureNetwork,
+    false, // allowUnknownOutputs
+    [ordinals.OutOrdinalReveal] // customScripts
+  );
+
+  if (!taprootPayment.address) {
+    throw new Error('Failed to generate P2TR commit address');
+  }
+
+  const commitAddress = taprootPayment.address;
+
+  // Extract script information from the taproot payment
+  if (!taprootPayment.leaves || taprootPayment.leaves.length === 0) {
+    throw new Error('Failed to extract taproot leaves from P2TR payment');
+  }
+
+  const leaf = taprootPayment.leaves[0];
+  const leafVersion = leaf.version ?? 0xc0;
+
+  // Compute control block from leaf data
+  // The control block is: version byte | internal key (32 bytes) | merkle path
+  const controlBlock = btc.TaprootControlBlock.encode({
+    version: leafVersion,
+    internalKey: revealPublicKey,
+    merklePath: leaf.path
+  });
+
+  // Step 5: Calculate minimum amount needed for the commit output
+  const commitOutputValue = Math.max(minimumCommitAmount, MIN_DUST_LIMIT);
+
+  // Step 6: Iterative UTXO selection with fee recalculation
+  // This ensures that after we know the actual input count, we have enough funds
+  let selectedUtxos: Utxo[] = [];
+  let totalInputValue = 0;
+  let estimatedFee = 0;
+  let iteration = 0;
+
+  // Start with initial estimate (1 input, 2 outputs)
+  let targetAmount = commitOutputValue + Number(calculateFee(estimateCommitTxSize(1, 2), feeRate));
+
+  while (iteration < MAX_SELECTION_ITERATIONS) {
+    iteration++;
+
+    // Select UTXOs based on current target amount
+    const options: SimpleUtxoSelectionOptions = {
+      targetAmount
+    };
+
+    try {
+      const selectionResult = selectUtxos(validUtxos, options);
+      selectedUtxos = selectionResult.selectedUtxos;
+      totalInputValue = selectionResult.totalInputValue;
+    } catch (error) {
+      throw new Error(
+        `Insufficient funds. Need ${targetAmount} sats for commit output (${commitOutputValue} sats) and estimated fees. ` +
+        `Available: ${validUtxos.reduce((sum, u) => sum + u.value, 0)} sats from ${validUtxos.length} valid UTXO(s). ` +
+        `${error instanceof Error ? error.message : 'Unknown error'}`
+      );
+    }
+
+    // Calculate accurate fee based on actual selected input count
+    // Assume 2 outputs (commit + change) for now - we'll adjust later if no change
+    const actualInputCount = selectedUtxos.length;
+    const estimatedVBytes = estimateCommitTxSize(actualInputCount, 2);
+    estimatedFee = Number(calculateFee(estimatedVBytes, feeRate));
+
+    // Check if we need to account for no change output
+    const potentialChange = totalInputValue - commitOutputValue - estimatedFee;
+    let finalOutputCount = 2;
+
+    if (potentialChange < MIN_DUST_LIMIT) {
+      // No change output, recalculate fee with 1 output
+      finalOutputCount = 1;
+      const adjustedVBytes = estimateCommitTxSize(actualInputCount, finalOutputCount);
+      estimatedFee = Number(calculateFee(adjustedVBytes, feeRate));
+    }
+
+    // Check if we have enough funds with the accurate fee calculation
+    const requiredTotal = commitOutputValue + estimatedFee;
+
+    if (totalInputValue >= requiredTotal) {
+      // We have enough funds, break out of loop
+      break;
+    }
+
+    // Not enough funds, need to reselect with higher target
+    // Add a small buffer (5%) to account for potential fee variations
+    targetAmount = Math.ceil(requiredTotal * 1.05);
+
+    if (iteration >= MAX_SELECTION_ITERATIONS) {
+      throw new Error(
+        `Unable to select sufficient UTXOs after ${MAX_SELECTION_ITERATIONS} iterations. ` +
+        `Required: ${requiredTotal} sats (commit: ${commitOutputValue}, fee: ${estimatedFee}), ` +
+        `Selected: ${totalInputValue} sats from ${selectedUtxos.length} UTXO(s). ` +
+        `Total available: ${validUtxos.reduce((sum, u) => sum + u.value, 0)} sats from ${validUtxos.length} valid UTXO(s).`
+      );
+    }
+  }
+
+  // Final validation: ensure we have selected UTXOs
+  if (!selectedUtxos || selectedUtxos.length === 0) {
+    throw new Error('No UTXOs selected for the transaction after selection process.');
+  }
+
+  // Step 7: Create transaction using @scure/btc-signer
+  const tx = new btc.Transaction();
+
+  // Add inputs - all selected UTXOs are already validated to have scriptPubKey
+  for (const utxo of selectedUtxos) {
+    // This check is now redundant due to pre-filtering, but kept as defense-in-depth
+    if (!utxo.scriptPubKey) {
+      throw new Error(
+        `CRITICAL ERROR: Selected UTXO ${utxo.txid}:${utxo.vout} is missing scriptPubKey. ` +
+        `This should never happen due to pre-filtering. Please report this bug.`
+      );
+    }
+
+    tx.addInput({
+      txid: utxo.txid,
+      index: utxo.vout,
+      witnessUtxo: {
+        script: Buffer.from(utxo.scriptPubKey, 'hex'),
+        amount: BigInt(utxo.value)
+      }
+    });
+  }
+
+  // Verify input count matches selected UTXOs
+  if (tx.inputsLength !== selectedUtxos.length) {
+    throw new Error(
+      `Input count mismatch: expected ${selectedUtxos.length} inputs but transaction has ${tx.inputsLength}. ` +
+      `This indicates a critical error in transaction construction.`
+    );
+  }
+
+  // Step 8: Calculate final fee based on actual transaction structure
+  const actualInputCount = tx.inputsLength;
+
+  // Determine if we'll have a change output
+  const preliminaryChange = totalInputValue - commitOutputValue - estimatedFee;
+  const willHaveChange = preliminaryChange >= MIN_DUST_LIMIT;
+  const finalOutputCount = willHaveChange ? 2 : 1;
+
+  // Calculate final fee with correct output count
+  const finalVBytes = estimateCommitTxSize(actualInputCount, finalOutputCount);
+  const finalFee = Number(calculateFee(finalVBytes, feeRate));
+
+  // CRITICAL: Final validation that inputs cover outputs + fees
+  const finalChange = totalInputValue - commitOutputValue - finalFee;
+
+  if (finalChange < 0) {
+    throw new Error(
+      `CRITICAL ERROR: Outputs exceed inputs! ` +
+      `Inputs: ${totalInputValue} sats, ` +
+      `Outputs: ${commitOutputValue} sats (commit) + ${finalFee} sats (fee) = ${commitOutputValue + finalFee} sats. ` +
+      `Deficit: ${Math.abs(finalChange)} sats. ` +
+      `This should never happen due to iterative selection. Please report this bug.`
+    );
+  }
+
+  // Step 9: Add the commit output using the P2TR address
+  tx.addOutputAddress(
+    commitAddress,
+    BigInt(commitOutputValue),
+    scureNetwork
+  );
+
+  // Step 10: Add change output if above dust limit
+  if (finalChange >= MIN_DUST_LIMIT) {
+    tx.addOutputAddress(
+      changeAddress,
+      BigInt(finalChange),
+      scureNetwork
+    );
+  } else if (finalChange > 0) {
+    // If change is below dust limit, it's effectively added to the fee
+    console.log(
+      `Change amount ${finalChange} sats is below dust limit (${MIN_DUST_LIMIT} sats), adding to fee. ` +
+      `Final fee: ${finalFee + finalChange} sats.`
+    );
+  }
+
+  // Step 11: Get the PSBT as base64
+  const txPsbt = tx.toPSBT();
+  const commitPsbtBase64 = typeof txPsbt === 'string' ? txPsbt : Buffer.from(txPsbt).toString('base64');
+
+  return {
+    commitAddress,
+    commitPsbtBase64,
+    commitPsbt: tx,
+    commitAmount: commitOutputValue,
+    selectedUtxos,
+    fees: {
+      // Include dust in final fee if no change output
+      commit: finalChange >= MIN_DUST_LIMIT ? finalFee : finalFee + finalChange
+    },
+    revealPrivateKey: Buffer.from(revealPrivateKey).toString('hex'),
+    revealPublicKey: Buffer.from(revealPublicKey).toString('hex'),
+    inscriptionScript: {
+      script: leaf.script,
+      controlBlock,
+      leafVersion
+    }
+  };
+}

package/src/bitcoin/transactions/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Bitcoin Transactions
+ *
+ * This directory contains modules for creating and managing Bitcoin transactions,
+ * particularly for Ordinals inscriptions.
+ */
+
+// Export commit transaction functionality
+export {
+  createCommitTransaction,
+  type CommitTransactionParams,
+  type CommitTransactionResult
+} from './commit.js';