@sidhujag/sysweb3-keyring 1.0.547 → 1.0.549

package/src/transactions/index.ts

@@ -1,2 +0,0 @@
-export * from './ethereum';
-export * from './syscoin';

package/src/transactions/syscoin.ts

@@ -1,542 +0,0 @@
-import { INetwork, getNetworkConfig } from '@sidhujag/sysweb3-network';
-import { ITxid, txUtils } from '@sidhujag/sysweb3-utils';
-import * as syscoinjs from 'syscoinjs-lib';
-// import { BIP_84, ONE_HUNDRED_MILLION, SYSCOIN_BASIC_FEE } from 'utils';
-
-import { LedgerKeyring } from '../ledger';
-import { DefaultWalletPolicy } from '../ledger/bitcoin_client';
-import { SyscoinHDSigner } from '../signers';
-import { TrezorKeyring } from '../trezor';
-import {
-  ISyscoinTransactions,
-  KeyringAccountType,
-  accountType,
-} from '../types';
-import {
-  getAccountDerivationPath,
-  convertExtendedKeyVersion,
-} from '../utils/derivation-paths';
-import { PsbtUtils } from '../utils/psbt';
-
-type EstimateFeeParams = {
-  changeAddress: string;
-  feeRateBN: any;
-  outputs: { address: string; value: any; subtractFeeFrom?: boolean }[];
-  txOptions: any;
-  xpub: string;
-};
-
-export class SyscoinTransactions implements ISyscoinTransactions {
-  // New separated transaction flow for better UX:
-  // 1. Call getEstimateSysTransactionFee() - creates UNSIGNED PSBT and calculates fee
-  // 2. Call signPSBT() - signs the PSBT with appropriate wallet (HD/Trezor/Ledger)
-  // 3. Call sendTransaction() - broadcasts the signed PSBT
-  //
-  // This separation allows:
-  // - Independent error handling for each step
-  // - Better UX feedback (fee estimation, signing, broadcasting)
-  // - Hardware wallet compatibility with proper PSBT enhancement
-
-  private getSigner: () => {
-    hd: SyscoinHDSigner;
-    main: any;
-  };
-  private getReadOnlySigner: () => {
-    main: any;
-  };
-  private trezor: TrezorKeyring;
-  private ledger: LedgerKeyring;
-  private getState: () => {
-    accounts: {
-      HDAccount: accountType;
-      Imported: accountType;
-      Ledger: accountType;
-      Trezor: accountType;
-    };
-    activeAccountId: number;
-    activeAccountType: KeyringAccountType;
-    activeNetwork: INetwork;
-  };
-  private getAddress: (
-    xpub: string,
-    isChangeAddress: boolean
-  ) => Promise<string>;
-
-  constructor(
-    getSyscoinSigner: () => {
-      hd: SyscoinHDSigner;
-      main: any;
-    },
-    getReadOnlySigner: () => {
-      main: any;
-    },
-    getState: () => {
-      accounts: {
-        HDAccount: accountType;
-        Imported: accountType;
-        Ledger: accountType;
-        Trezor: accountType;
-      };
-      activeAccountId: number;
-      activeAccountType: KeyringAccountType;
-      activeNetwork: INetwork;
-    },
-    getAddress: (xpub: string, isChangeAddress: boolean) => Promise<string>,
-    ledgerSigner: LedgerKeyring,
-    trezorSigner: TrezorKeyring
-  ) {
-    this.getSigner = getSyscoinSigner;
-    this.getReadOnlySigner = getReadOnlySigner;
-    this.getState = getState;
-    this.getAddress = getAddress;
-    this.trezor = trezorSigner;
-    this.ledger = ledgerSigner;
-  }
-
-  private getTransactionPSBT = async (
-    { txOptions, outputs, changeAddress, feeRateBN, xpub }: EstimateFeeParams,
-    main: any
-  ) => {
-    try {
-      // Use syscoinjs-lib directly for transaction creation
-      const result = await main.createTransaction(
-        txOptions,
-        changeAddress,
-        outputs,
-        feeRateBN,
-        xpub // sysFromXpubOrAddress
-      );
-
-      if (result && result.psbt) {
-        return { psbt: result.psbt, fee: result.fee };
-      }
-      throw new Error('psbt not found');
-    } catch (error) {
-      // Propagate structured error from syscoinjs-lib
-      if (error.error && error.code) {
-        throw error;
-      }
-      // Wrap non-structured errors
-      throw {
-        error: true,
-        code: 'TRANSACTION_CREATION_FAILED',
-        message: error.message || 'Failed to create transaction',
-        details: error,
-      };
-    }
-  };
-
-  public decodeRawTransaction = (psbtOrHex: any, isRawHex = false) => {
-    const { main } = this.getReadOnlySigner();
-
-    if (isRawHex) {
-      // Handle raw transaction hex
-      const bitcoinTx =
-        syscoinjs.utils.bitcoinjs.Transaction.fromHex(psbtOrHex);
-      return main.decodeRawTransaction(bitcoinTx);
-    } else {
-      // Handle PSBT format (existing behavior)
-      const psbtObj = PsbtUtils.fromPali(psbtOrHex);
-      return main.decodeRawTransaction(psbtObj);
-    }
-  };
-
-  public getRecommendedFee = async (explorerUrl: string): Promise<number> =>
-    (await syscoinjs.utils.fetchEstimateFee(explorerUrl, 1)) / 1024;
-
-  public txUtilsFunctions = () => {
-    const { getRawTransaction } = txUtils();
-    return {
-      getRawTransaction,
-    };
-  };
-
-  // Internal method for signing with the HD signer
-  private signPSBTWithSigner = async ({
-    psbt,
-    signer,
-  }: {
-    psbt: any;
-    signer: any;
-  }): Promise<any> => await signer.sign(psbt);
-
-  // Create unsigned PSBT for any transaction type
-  private createUnsignedPSBT = async ({
-    txOptions = {},
-    isMax = false,
-    amount,
-    receivingAddress,
-    feeRateBN,
-    token = null,
-  }: {
-    amount: number | string; // Accept both for safer precision handling
-    feeRateBN: any; // BigNumber in satoshis/byte
-    receivingAddress: string;
-    token?: { guid: string; symbol?: string } | null;
-    txOptions?: any;
-    isMax?: boolean | false;
-  }): Promise<{ psbt: any; fee: number }> => {
-    // Ensure RBF is enabled by default if not explicitly set
-    const finalTxOptions = { rbf: true, ...txOptions };
-    const { activeAccountId, accounts, activeAccountType } = this.getState();
-    // Use read-only signer since we're just creating an unsigned PSBT
-    const { main } = this.getReadOnlySigner();
-    const account = accounts[activeAccountType]?.[activeAccountId];
-    if (!account) {
-      throw new Error('Active account not found');
-    }
-    const xpub = account.xpub;
-    const isSingleAddressImported =
-      activeAccountType === KeyringAccountType.Imported &&
-      xpub === account.address;
-    // Convert amount to satoshis (1 SYS = 1e8 satoshis)
-    // Using BigNumber to prevent precision loss
-    const amountStr = amount.toString();
-
-    // Safe conversion without parseFloat to avoid precision loss
-    // Split the string to handle decimal values properly
-    const parts = amountStr.split('.');
-    const integerPart = parts[0] || '0';
-    const decimalPart = parts[1] || '';
-
-    // Pad or truncate decimal part to 8 places (satoshi precision)
-    const paddedDecimal = decimalPart.padEnd(8, '0').substring(0, 8);
-
-    // Combine to get satoshis (integer + decimal as one number)
-    const satoshiStr = integerPart + paddedDecimal;
-
-    // Remove leading zeros but keep at least one digit
-    const trimmedSatoshis = satoshiStr.replace(/^0+/, '') || '0';
-
-    const value = new syscoinjs.utils.BN(trimmedSatoshis);
-    // If this is a single-address imported account (WIF import), use the account.address for both from and change
-    const changeAddress = isSingleAddressImported
-      ? account.address
-      : await this.getAddress(xpub, true);
-
-    try {
-      if (token && token.guid) {
-        // Token transaction: use assetAllocationSend
-        // Create a Map for the asset allocation
-        const assetMap = new Map();
-        assetMap.set(token.guid, {
-          changeAddress,
-          outputs: [
-            {
-              value: value as any,
-              address: receivingAddress,
-            },
-          ],
-        });
-
-        // Pass xpub to get back just the PSBT without signing and sending
-        // syscoinjs-lib will validate asset existence and sufficient balance
-        const result = await main.assetAllocationSend(
-          finalTxOptions,
-          assetMap,
-          changeAddress,
-          feeRateBN,
-          isSingleAddressImported ? account.address : xpub // Pass source
-        );
-
-        // Return PSBT and fee
-        return { psbt: result.psbt, fee: result.fee };
-      } else {
-        // Native transaction: use getTransactionPSBT to create unsigned PSBT
-        const outputs = [
-          {
-            address: receivingAddress,
-            value: value, // Pass BN object directly
-            ...(isMax && { subtractFeeFrom: true }), // Only add subtractFeeFrom if isMax is true
-          },
-        ];
-
-        const result = await this.getTransactionPSBT(
-          {
-            txOptions: finalTxOptions,
-            outputs,
-            changeAddress,
-            feeRateBN,
-            xpub: isSingleAddressImported ? account.address : xpub,
-          },
-          main
-        );
-
-        return result;
-      }
-    } catch (error) {
-      // Re-throw structured errors from syscoinjs-lib
-      if (error.error && error.code) {
-        throw error;
-      }
-      // Wrap other errors in structured format
-      throw {
-        error: true,
-        code: 'TRANSACTION_CREATION_FAILED',
-        message: error.message || 'Failed to create unsigned PSBT',
-        details: error,
-      };
-    }
-  };
-
-  // Sign PSBT with appropriate method - separated for better error handling
-  private signPSBTWithMethod = async (
-    psbt: any,
-    isTrezor: boolean,
-    isLedger = false
-  ): Promise<any> => {
-    const { activeNetwork, activeAccountId, activeAccountType, accounts } =
-      this.getState();
-
-    if (isLedger) {
-      // CRITICAL: Enhance PSBT with required Ledger fields
-      const account = accounts[activeAccountType]?.[activeAccountId];
-      if (!account) {
-        throw new Error('Active account not found');
-      }
-      const accountXpub = account.xpub;
-      const accountId = account.id;
-      const enhancedPsbt = await this.ledger.convertToLedgerFormat(
-        psbt,
-        accountXpub,
-        accountId,
-        activeNetwork.currency,
-        activeNetwork.slip44
-      );
-
-      // Get wallet policy for Ledger
-      const fingerprint =
-        await this.ledger.ledgerUtxoClient.getMasterFingerprint();
-
-      const hdPath = getAccountDerivationPath(
-        activeNetwork.currency,
-        activeNetwork.slip44,
-        accountId
-      );
-
-      // Convert stored/display zpub/vpub to device-friendly xpub/tpub for policy descriptor using network macros
-      const { types: deviceTypes } = getNetworkConfig(
-        activeNetwork.slip44,
-        activeNetwork.currency
-      );
-      const devicePubMagicDec =
-        activeNetwork.slip44 === 1
-          ? (deviceTypes.xPubType as any).testnet.vpub
-          : deviceTypes.xPubType.mainnet.zpub;
-      const devicePubMagicHex = Number(devicePubMagicDec)
-        .toString(16)
-        .padStart(8, '0');
-      const deviceXpub = convertExtendedKeyVersion(
-        accountXpub,
-        devicePubMagicHex
-      );
-      const xpubWithDescriptor = `[${hdPath}]${deviceXpub}`.replace(
-        'm',
-        fingerprint
-      );
-      const walletPolicy = new DefaultWalletPolicy(
-        'wpkh(@0/**)',
-        xpubWithDescriptor
-      );
-
-      // Register lazily and retrieve HMAC for silent operations thereafter
-      let hmac: Buffer | null = null;
-      if (typeof (this.ledger as any).getOrRegisterHmac === 'function') {
-        hmac = await (this.ledger as any).getOrRegisterHmac(
-          walletPolicy,
-          fingerprint
-        );
-      }
-
-      // Sign the enhanced PSBT with Ledger using the HMAC (silent after first approval)
-      const signatureEntries = await this.ledger.ledgerUtxoClient.signPsbt(
-        enhancedPsbt.toBase64(),
-        walletPolicy,
-        hmac
-      );
-
-      signatureEntries.forEach(([inputIndex, partialSig]) => {
-        enhancedPsbt.updateInput(inputIndex, {
-          partialSig: [partialSig],
-        });
-      });
-
-      // Finalize all inputs
-      enhancedPsbt.finalizeAllInputs();
-
-      return enhancedPsbt;
-    } else if (isTrezor) {
-      // Handle Trezor signing for UTXO
-      // Get network configuration for Trezor
-      const networkConfig = getNetworkConfig(
-        activeNetwork.slip44,
-        activeNetwork.currency
-      );
-      const isTestnet = activeNetwork.slip44 === 1;
-      const bitcoinjsNetwork = isTestnet
-        ? networkConfig?.networks?.testnet
-        : networkConfig?.networks?.mainnet;
-
-      const trezorTx = this.trezor.convertToTrezorFormat({
-        psbt,
-        coin: activeNetwork.currency.toLowerCase(),
-        network: bitcoinjsNetwork || undefined, // Pass network config for isScriptHash check
-      });
-      const signedPsbt = await this.trezor.signUtxoTransaction(trezorTx, psbt);
-      return signedPsbt;
-    } else {
-      const { hd } = this.getSigner();
-      const signedPsbt = await this.signPSBTWithSigner({
-        psbt,
-        signer: hd,
-      });
-      return signedPsbt;
-    }
-  };
-
-  // Create unsigned PSBT and estimate fee - NO SIGNING
-  public getEstimateSysTransactionFee = async ({
-    txOptions = {},
-    isMax = false,
-    amount,
-    receivingAddress,
-    feeRate,
-    token = null,
-  }: {
-    amount: number | string; // Accept both for safer precision handling
-    feeRate?: number;
-    receivingAddress: string;
-    // Optional fee rate in SYS/byte
-    token?: { guid: string; symbol?: string } | null;
-    txOptions?: any;
-    isMax?: boolean | false;
-  }) => {
-    try {
-      // Ensure RBF is enabled by default if not explicitly set
-      const finalTxOptions = { rbf: true, ...txOptions };
-      // Use read-only signer since we're just estimating fees and creating unsigned PSBT
-      const { main } = this.getReadOnlySigner();
-      // Step 1: Determine fee rate
-      let actualFeeRate;
-      if (feeRate !== undefined) {
-        actualFeeRate = feeRate;
-      } else {
-        actualFeeRate = await this.getRecommendedFee(main.blockbookURL);
-      }
-
-      // Convert fee rate to satoshis/byte and ensure minimum relay of 1 sat/vB
-      // Blockbook returns coins per kB; after division by 1024, some testnets
-      // can yield < 1 sat/vB (e.g., 0.9765625). Round up and clamp to 1 to
-      // avoid zero-fee transactions due to truncation when converting to BN.
-      const satPerByte = Math.max(1, Math.ceil(actualFeeRate * 1e8));
-      const feeRateBN = new syscoinjs.utils.BN(satPerByte);
-
-      // Step 2: Create unsigned PSBT
-      const result = await this.createUnsignedPSBT({
-        txOptions: finalTxOptions,
-        isMax,
-        amount,
-        receivingAddress,
-        feeRateBN,
-        token,
-      });
-
-      return {
-        fee: result.fee / 1e8,
-        psbt: PsbtUtils.toPali(result.psbt), // Return UNSIGNED PSBT as JSON
-      };
-    } catch (error) {
-      // Pass through structured errors from syscoinjs-lib
-      if (error.error && error.code) {
-        // Convert fee from satoshis to SYS if available
-        if (error.fee !== undefined) {
-          // If fee is a BN object, convert to number first
-          if (typeof error.fee === 'object' && error.fee.toNumber) {
-            error.fee = error.fee.toNumber() / 1e8;
-          } else {
-            error.fee = error.fee / 1e8;
-          }
-        }
-        if (error.remainingFee !== undefined) {
-          // If remainingFee is a BN object, convert to number first
-          if (
-            typeof error.remainingFee === 'object' &&
-            error.remainingFee.toNumber
-          ) {
-            error.remainingFee = error.remainingFee.toNumber() / 1e8;
-          } else {
-            error.remainingFee = error.remainingFee / 1e8;
-          }
-        }
-        if (error.shortfall !== undefined) {
-          // If shortfall is a BN object, convert to number first
-          if (typeof error.shortfall === 'object' && error.shortfall.toNumber) {
-            error.shortfall = error.shortfall.toNumber() / 1e8;
-          } else {
-            error.shortfall = error.shortfall / 1e8;
-          }
-        }
-        throw error;
-      }
-      // Wrap other errors
-      throw {
-        error: true,
-        code: 'TRANSACTION_CREATION_FAILED',
-        message: error.message || 'Failed to estimate transaction fee',
-        details: error,
-      };
-    }
-  };
-
-  // Removed createAndSignSysTransaction - functionality merged into getEstimateSysTransactionFee
-
-  private sendSignedTransaction = async (psbt): Promise<ITxid> => {
-    try {
-      // Use read-only signer since we're just broadcasting an already-signed transaction
-      const { main } = this.getReadOnlySigner();
-      // Send the transaction
-      const result = await main.send(psbt);
-
-      // Extract the transaction ID
-      const txid = result.extractTransaction().getId();
-      return { txid };
-    } catch (error) {
-      // Pass through structured errors
-      if (error.error && error.code) {
-        throw error;
-      }
-      // Wrap other errors
-      throw {
-        error: true,
-        code: 'TRANSACTION_SEND_FAILED',
-        message: error.message || 'Failed to send transaction',
-        details: error,
-      };
-    }
-  };
-
-  public signPSBT = async ({
-    psbt,
-    isTrezor = false,
-    isLedger = false,
-  }: {
-    psbt: any;
-    isTrezor?: boolean;
-    isLedger?: boolean;
-  }): Promise<any> => {
-    const psbtObj = PsbtUtils.fromPali(psbt);
-    const signedPsbt = await this.signPSBTWithMethod(
-      psbtObj,
-      isTrezor,
-      isLedger
-    );
-    return PsbtUtils.toPali(signedPsbt);
-  };
-
-  public sendTransaction = async (psbt: any): Promise<ITxid> => {
-    if (!psbt) {
-      throw new Error('Signed PSBT is required for broadcasting.');
-    }
-    return await this.sendSignedTransaction(PsbtUtils.fromPali(psbt));
-  };
-}