otx-btc-wallet-core 0.1.0

package/src/utils/psbt.ts

@@ -0,0 +1,185 @@
+/**
+ * PSBT (Partially Signed Bitcoin Transaction) utilities
+ */
+
+/**
+ * Convert PSBT hex to base64
+ */
+export function psbtHexToBase64(hex: string): string {
+  // Remove any whitespace
+  const cleanHex = hex.replace(/\s/g, '');
+
+  // Validate hex string
+  if (!/^[0-9a-fA-F]*$/.test(cleanHex)) {
+    throw new Error('Invalid hex string');
+  }
+
+  if (cleanHex.length % 2 !== 0) {
+    throw new Error('Hex string must have even length');
+  }
+
+  // Convert hex to bytes then to base64
+  const bytes = new Uint8Array(cleanHex.length / 2);
+  for (let i = 0; i < cleanHex.length; i += 2) {
+    bytes[i / 2] = parseInt(cleanHex.substring(i, i + 2), 16);
+  }
+
+  // Use Buffer in Node.js or btoa in browser
+  if (typeof Buffer !== 'undefined') {
+    return Buffer.from(bytes).toString('base64');
+  }
+
+  // Browser fallback
+  let binary = '';
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]!);
+  }
+  return btoa(binary);
+}
+
+/**
+ * Convert PSBT base64 to hex
+ */
+export function psbtBase64ToHex(base64: string): string {
+  // Decode base64 to bytes
+  let bytes: Uint8Array;
+
+  if (typeof Buffer !== 'undefined') {
+    bytes = Buffer.from(base64, 'base64');
+  } else {
+    // Browser fallback
+    const binary = atob(base64);
+    bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+  }
+
+  // Convert bytes to hex
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('');
+}
+
+/**
+ * Validate PSBT hex format
+ * PSBT magic bytes: 0x70736274ff (psbt\xff)
+ */
+export function isValidPsbtHex(hex: string): boolean {
+  const cleanHex = hex.replace(/\s/g, '').toLowerCase();
+
+  // Check minimum length (magic bytes = 5 bytes = 10 hex chars)
+  if (cleanHex.length < 10) {
+    return false;
+  }
+
+  // Check magic bytes
+  return cleanHex.startsWith('70736274ff');
+}
+
+/**
+ * Validate PSBT base64 format
+ */
+export function isValidPsbtBase64(base64: string): boolean {
+  try {
+    const hex = psbtBase64ToHex(base64);
+    return isValidPsbtHex(hex);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Extract basic info from PSBT hex (without full parsing)
+ * This is a lightweight check - for full parsing use a library like bitcoinjs-lib
+ */
+export function getPsbtInfo(psbtHex: string): {
+  isValid: boolean;
+  version: number | null;
+  inputCount: number | null;
+  outputCount: number | null;
+} {
+  if (!isValidPsbtHex(psbtHex)) {
+    return {
+      isValid: false,
+      version: null,
+      inputCount: null,
+      outputCount: null,
+    };
+  }
+
+  // PSBT structure is complex, return basic validation only
+  // For full parsing, use bitcoinjs-lib or similar
+  return {
+    isValid: true,
+    version: null, // Would need full parsing
+    inputCount: null, // Would need full parsing
+    outputCount: null, // Would need full parsing
+  };
+}
+
+/**
+ * Combine multiple signed PSBTs into one
+ * Note: This is a basic implementation. For complex cases, use bitcoinjs-lib.
+ *
+ * @param psbts - Array of PSBT hex strings to combine
+ * @returns Combined PSBT hex
+ */
+export function combinePsbts(psbts: string[]): string {
+  if (psbts.length === 0) {
+    throw new Error('No PSBTs provided');
+  }
+
+  if (psbts.length === 1) {
+    return psbts[0]!;
+  }
+
+  // For proper PSBT combination, you need bitcoinjs-lib
+  // This is just a placeholder that returns the first PSBT
+  // In production, use: bitcoin.Psbt.combine([psbt1, psbt2, ...])
+  console.warn(
+    'combinePsbts: For proper PSBT combination, use bitcoinjs-lib. ' +
+    'This function returns the first PSBT as a fallback.'
+  );
+
+  return psbts[0]!;
+}
+
+/**
+ * Sighash types for Bitcoin transactions
+ */
+export const SighashType = {
+  ALL: 0x01,
+  NONE: 0x02,
+  SINGLE: 0x03,
+  ANYONECANPAY: 0x80,
+  ALL_ANYONECANPAY: 0x81,
+  NONE_ANYONECANPAY: 0x82,
+  SINGLE_ANYONECANPAY: 0x83,
+} as const;
+
+export type SighashType = (typeof SighashType)[keyof typeof SighashType];
+
+/**
+ * Get human-readable name for sighash type
+ */
+export function getSighashTypeName(sighash: number): string {
+  switch (sighash) {
+    case SighashType.ALL:
+      return 'SIGHASH_ALL';
+    case SighashType.NONE:
+      return 'SIGHASH_NONE';
+    case SighashType.SINGLE:
+      return 'SIGHASH_SINGLE';
+    case SighashType.ANYONECANPAY:
+      return 'SIGHASH_ANYONECANPAY';
+    case SighashType.ALL_ANYONECANPAY:
+      return 'SIGHASH_ALL|ANYONECANPAY';
+    case SighashType.NONE_ANYONECANPAY:
+      return 'SIGHASH_NONE|ANYONECANPAY';
+    case SighashType.SINGLE_ANYONECANPAY:
+      return 'SIGHASH_SINGLE|ANYONECANPAY';
+    default:
+      return `UNKNOWN(${sighash})`;
+  }
+}