@sidhujag/sysweb3-keyring 1.0.545 → 1.0.547

package/src/types.ts

@@ -0,0 +1,366 @@
+import { TransactionResponse } from '@ethersproject/abstract-provider';
+import { BigNumber, BigNumberish } from '@ethersproject/bignumber';
+import { BytesLike } from '@ethersproject/bytes';
+import { AccessListish } from '@ethersproject/transactions';
+import { Wallet } from '@ethersproject/wallet';
+import {
+  TypedDataV1,
+  TypedMessage,
+  SignTypedDataVersion,
+} from '@metamask/eth-sig-util';
+import { INetwork, INetworkType } from '@sidhujag/sysweb3-network';
+import { ITxid } from '@sidhujag/sysweb3-utils';
+import { CustomJsonRpcProvider, CustomL2JsonRpcProvider } from 'providers';
+
+import { LedgerKeyring } from './ledger';
+import { SyscoinHDSigner } from './signers';
+import { TrezorKeyring } from './trezor';
+
+export type SimpleTransactionRequest = {
+  accessList?: AccessListish;
+  ccipReadEnabled?: boolean;
+  chainId: number;
+  customData?: Record<string, any>;
+  data?: BytesLike;
+
+  from: string;
+  gasLimit?: BigNumberish;
+  gasPrice?: BigNumberish;
+
+  maxFeePerGas: BigNumberish;
+  maxPriorityFeePerGas: BigNumberish;
+
+  nonce?: BigNumberish;
+  r?: string;
+
+  s?: string;
+  to: string;
+  type?: number;
+  v?: string;
+  value?: BigNumberish;
+};
+
+// Version type is now replaced by SignTypedDataVersion from @metamask/eth-sig-util
+
+export interface IEthereumTransactions {
+  cancelSentTransaction: (
+    txHash: string,
+    isLegacy?: boolean,
+    fallbackNonce?: number
+  ) => Promise<{
+    error?: boolean;
+    isCanceled: boolean;
+    transaction?: TransactionResponse;
+  }>;
+  decryptMessage: (msgParams: string[]) => string;
+  ethSign: (params: string[]) => Promise<string>;
+  getBalance: (address: string) => Promise<number>;
+  getEncryptedPubKey: () => string;
+  getErc20TokensByAddress?: (
+    address: string,
+    isSupported: boolean,
+    apiUrl: string
+  ) => Promise<any[]>;
+  getFeeByType: (type: string) => Promise<string>;
+  getFeeDataWithDynamicMaxPriorityFeePerGas: () => Promise<any>;
+  getGasLimit: (toAddress: string) => Promise<number>;
+  getGasOracle?: () => Promise<any>;
+  getRecommendedNonce: (address: string) => Promise<number>;
+  signTypedData: (
+    addr: string,
+    typedData: TypedDataV1 | TypedMessage<any>,
+    version: SignTypedDataVersion
+  ) => Promise<string>;
+
+  importAccount: (mnemonicOrPrivKey: string) => Wallet;
+  parsePersonalMessage: (hexMsg: string) => string;
+  sendFormattedTransaction: (
+    params: SimpleTransactionRequest,
+    isLegacy?: boolean
+  ) => Promise<TransactionResponse>;
+  sendSignedErc1155Transaction: ({
+    receiver,
+    tokenAddress,
+    tokenId,
+    isLegacy,
+    gasPrice,
+    gasLimit,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+  }: ISendSignedErcTransactionProps) => Promise<IResponseFromSendErcSignedTransaction>;
+  verifyPersonalMessage: (msg: string, sign: string) => string;
+  toBigNumber: (aBigNumberish: string | number) => BigNumber;
+  sendSignedErc20Transaction: ({
+    networkUrl,
+    receiver,
+    tokenAddress,
+    tokenAmount,
+  }: ISendSignedErcTransactionProps) => Promise<IResponseFromSendErcSignedTransaction>;
+
+  sendSignedErc721Transaction: ({
+    networkUrl,
+    receiver,
+    tokenAddress,
+    tokenId,
+  }: ISendSignedErcTransactionProps) => Promise<IResponseFromSendErcSignedTransaction>;
+
+  sendTransactionWithEditedFee: (
+    txHash: string,
+    isLegacy?: boolean
+  ) => Promise<{
+    isSpeedUp: boolean;
+    transaction?: TransactionResponse;
+    error?: boolean;
+  }>;
+
+  signPersonalMessage: (params: string[]) => Promise<string>;
+  verifyTypedSignature: (
+    data: TypedDataV1 | TypedMessage<any>,
+    signature: string,
+    version: SignTypedDataVersion
+  ) => string;
+  setWeb3Provider: (network: INetwork) => void;
+  getRecommendedGasPrice: (formatted?: boolean) => Promise<
+    | string
+    | {
+        ethers: string;
+        gwei: string;
+      }
+  >;
+  web3Provider: CustomJsonRpcProvider | CustomL2JsonRpcProvider;
+  getTxGasLimit: (tx: SimpleTransactionRequest) => Promise<BigNumber>;
+}
+
+export interface ISyscoinTransactions {
+  getEstimateSysTransactionFee: ({
+    txOptions,
+    amount,
+    receivingAddress,
+    feeRate,
+    token,
+    isMax,
+  }: {
+    amount: number;
+    feeRate?: number;
+    receivingAddress: string;
+    token?: { guid: string; symbol?: string } | null;
+    txOptions?: any;
+    isMax?: boolean | false;
+  }) => Promise<{ fee: number; psbt: any }>; // Returns UNSIGNED psbt - may throw ISyscoinTransactionError
+  getRecommendedFee: (explorerUrl: string) => Promise<number>;
+  decodeRawTransaction: (psbtOrHex: any, isRawHex?: boolean) => any;
+  // Sign PSBT separately
+  sendTransaction: (psbt: any) => Promise<ITxid>;
+  signPSBT: ({
+    psbt,
+    isTrezor,
+    isLedger,
+  }: {
+    isLedger?: boolean;
+    isTrezor?: boolean;
+    psbt: any;
+  }) => Promise<any>;
+}
+
+export interface IKeyringManager {
+  // Core keyring functionality
+  addNewAccount: (label?: string) => Promise<IKeyringAccountState>;
+  ethereumTransaction: IEthereumTransactions;
+  forgetMainWallet: (pwd: string) => void;
+  getAccountById: (
+    id: number,
+    accountType: KeyringAccountType
+  ) => Omit<IKeyringAccountState, 'xprv'>;
+  getAccountXpub: () => string;
+  getEncryptedXprv: (hd: SyscoinHDSigner) => string;
+  unlock: (
+    password: string,
+    isForPvtKey?: boolean
+  ) => Promise<{
+    canLogin: boolean;
+    needsAccountCreation?: boolean;
+  }>;
+  isUnlocked: () => boolean;
+  logout: () => void;
+  ledgerSigner: LedgerKeyring;
+  trezorSigner: TrezorKeyring;
+  setSignerNetwork: (network: INetwork) => Promise<{
+    success: boolean;
+  }>;
+  getPrivateKeyByAccountId: (
+    id: number,
+    accountType: KeyringAccountType,
+    pwd: string
+  ) => Promise<string>;
+  setStorage: (client: any) => void;
+  syscoinTransaction: ISyscoinTransactions;
+  isSeedValid: (seedPhrase: string) => boolean;
+  getSeed: (pwd: string) => Promise<string>;
+  importTrezorAccount: (label?: string) => Promise<IKeyringAccountState>;
+  utf8Error: boolean;
+  validateZprv: (
+    zprv: string,
+    targetNetwork?: INetwork
+  ) => IValidateZprvResponse;
+  validateWif: (
+    wif: string,
+    targetNetwork?: INetwork
+  ) => { isValid: boolean; message?: string };
+  // Account management
+  importAccount: (
+    privKey: string,
+    label?: string,
+    options?: { utxoAddressType?: 'p2wpkh' | 'p2pkh' }
+  ) => Promise<IKeyringAccountState>;
+  getNewChangeAddress: () => Promise<string>;
+  getChangeAddress: (id: number) => Promise<string>;
+  getPubkey: (id: number, isChangeAddress: boolean) => Promise<string>;
+  getBip32Path: (id: number, isChangeAddress: boolean) => Promise<string>;
+  updateReceivingAddress: () => Promise<string>;
+  getActiveAccount: () => {
+    activeAccount: Omit<IKeyringAccountState, 'xprv'>;
+    activeAccountType: KeyringAccountType;
+  };
+  importWeb3Account: (mnemonicOrPrivKey: string) => any;
+  createNewSeed: (wordCount?: number) => string;
+  getUTXOState: () => any;
+  importLedgerAccount: (
+    label?: string
+  ) => Promise<IKeyringAccountState | undefined>;
+  getActiveUTXOAccountState: () => any;
+  createEthAccount: (privateKey: string) => any;
+  getAddress: (xpub: string, isChangeAddress: boolean) => Promise<string>;
+  // Secure initialization and password management
+  initializeWalletSecurely: (
+    seedPhrase: string,
+    password: string,
+    prvPassword?: string
+  ) => Promise<IKeyringAccountState>;
+  // NEW: Separated initialization methods
+  initializeSession: (seedPhrase: string, password: string) => Promise<void>;
+  createFirstAccount: (label?: string) => Promise<IKeyringAccountState>;
+  transferSessionTo: (targetKeyring: IKeyringManager) => void;
+  receiveSessionOwnership: (sessionPassword: any, sessionMnemonic: any) => void;
+  lockWallet: () => void;
+  // NEW: Store access for stateless keyring
+  setVaultStateGetter: (getter: () => any) => void;
+}
+
+export enum KeyringAccountType {
+  HDAccount = 'HDAccount',
+  Imported = 'Imported',
+  Ledger = 'Ledger',
+  Trezor = 'Trezor',
+}
+
+export type IKeyringDApp = {
+  active: boolean;
+  id: number;
+  url: string;
+};
+
+export type accountType = {
+  [id: number]: IKeyringAccountState;
+};
+
+export type IKeyringBalances = {
+  [INetworkType.Syscoin]: number;
+  [INetworkType.Ethereum]: number;
+};
+
+interface INetworkParams {
+  bech32: string;
+  bip32: {
+    private: number;
+    public: number;
+  };
+  messagePrefix: string;
+  pubKeyHash: number;
+  scriptHash: number;
+  slip44: number;
+  wif: number;
+}
+
+interface IValidateZprvResponse {
+  isValid: boolean;
+  message: string;
+  network?: INetworkParams | null;
+  node?: any;
+}
+
+export interface IKeyringAccountState {
+  address: string;
+  balances: IKeyringBalances;
+  id: number;
+  isImported: boolean;
+  isLedgerWallet: boolean;
+  isTrezorWallet: boolean;
+  label: string;
+  xprv: string;
+  xpub: string;
+}
+
+export interface ISyscoinBackendAccount {
+  address: string;
+  balance: string;
+  itemsOnPage: number;
+  page: number;
+  totalPages: number;
+  totalReceived: string;
+  totalSent: string;
+  txs: number;
+  unconfirmedBalance: string;
+  unconfirmedTxs: number;
+}
+
+export interface ILatestUpdateForSysAccount {
+  balances: {
+    ethereum: number;
+    syscoin: number;
+  };
+  receivingAddress: any;
+  xpub: any;
+}
+
+export interface ISendSignedErcTransactionProps {
+  decimals?: number;
+  gasLimit?: BigNumberish;
+  gasPrice?: BigNumberish;
+  isLegacy?: boolean;
+  maxFeePerGas?: BigNumberish;
+  maxPriorityFeePerGas?: BigNumberish;
+  networkUrl: string;
+  receiver: string;
+  saveTrezorTx?: (tx: any) => void;
+  tokenAddress: string;
+  tokenAmount?: string;
+  tokenId?: number;
+}
+
+export interface IResponseFromSendErcSignedTransaction {
+  accessList: any[];
+  chainId: number;
+  confirmations: number | null;
+  data: string;
+  from: string;
+  gasLimit: BigNumber;
+  gasPrice: BigNumber | null;
+  hash: string;
+  maxFeePerGas: BigNumber;
+  maxPriorityFeePerGas: BigNumber;
+  nonce: number;
+  r: string;
+  s: string;
+  to: string;
+  type: number;
+  v: number | null;
+  value: BigNumber;
+  wait: any;
+}
+
+export interface IGasParams {
+  gasLimit?: BigNumber;
+  gasPrice?: BigNumber;
+  maxFeePerGas?: BigNumber;
+  maxPriorityFeePerGas?: BigNumber;
+}

package/src/utils/derivation-paths.ts

@@ -0,0 +1,133 @@
+// Import coins data from the relative package in the monorepo
+import { findCoin } from '@sidhujag/sysweb3-network';
+
+/**
+ * Get coin information by coin shortcut or slip44
+ * Priority: 1) Check if slip44=60 (EVM), 2) Check coins.ts (UTXO), 3) Default to unknown
+ */
+export function getCoinInfo(coinShortcut: string, slip44: number) {
+  // slip44=60: Ethereum and most EVM-compatible networks (BSC, Polygon, Arbitrum, etc.)
+  // This must be checked FIRST to prevent any UTXO coin conflicts
+  if (slip44 === 60) {
+    return {
+      slip44,
+      segwit: false,
+      isEvm: true,
+    };
+  }
+
+  // Use the shared findCoin utility to search for UTXO coins
+  const coin = findCoin({ slip44, name: coinShortcut });
+
+  if (coin) {
+    return {
+      slip44: coin.slip44,
+      segwit: coin.segwit || false,
+      isEvm: false, // UTXO coins from coins.ts are not EVM
+    };
+  }
+
+  // For unknown slip44 values, we cannot safely assume EVM
+  // Return as unknown/unsupported rather than defaulting to EVM
+  return {
+    slip44,
+    segwit: false,
+    isEvm: false, // Changed from true to false - unknown slip44 should not default to EVM
+  };
+}
+
+/**
+ * Determine if a coin is EVM-based (Ethereum-like)
+ */
+export function isEvmCoin(coinShortcut: string, slip44: number): boolean {
+  const coinInfo = getCoinInfo(coinShortcut, slip44);
+  return coinInfo.isEvm;
+}
+
+/**
+ * Determine if a coin uses SegWit (BIP84 - m/84')
+ */
+export function isSegwitCoin(coinShortcut: string, slip44: number): boolean {
+  const coinInfo = getCoinInfo(coinShortcut, slip44);
+  return coinInfo.segwit === true;
+}
+
+/**
+ * Determine if a coin uses legacy derivation (BIP44 - m/44')
+ */
+export function isLegacyCoin(coinShortcut: string, slip44: number): boolean {
+  return !isSegwitCoin(coinShortcut, slip44);
+}
+
+/**
+ * Get the appropriate BIP standard for a coin
+ */
+export function getBipStandard(coinShortcut: string, slip44: number): number {
+  if (isEvmCoin(coinShortcut, slip44)) {
+    return 44; // EVM coins use BIP44
+  }
+
+  if (isSegwitCoin(coinShortcut, slip44)) {
+    return 84; // SegWit coins use BIP84
+  }
+
+  return 44; // Default to BIP44 for legacy coins
+}
+
+/**
+ * Generate derivation path for account level (ending with account index)
+ * Example: m/84'/57'/0' for Syscoin account derivation
+ */
+export function getAccountDerivationPath(
+  coinShortcut: string,
+  slip44: number,
+  accountIndex = 0
+): string {
+  const bip = getBipStandard(coinShortcut, slip44);
+  return `m/${bip}'/${slip44}'/${accountIndex}'`;
+}
+
+/**
+ * Generate derivation path for address level (full path to specific address)
+ * Example: m/84'/57'/0'/0/0 for first address of first Syscoin account
+ */
+export function getAddressDerivationPath(
+  coinShortcut: string,
+  slip44: number,
+  accountIndex = 0,
+  isChangeAddress = false,
+  addressIndex = 0
+): string {
+  const bip = getBipStandard(coinShortcut, slip44);
+
+  if (isEvmCoin(coinShortcut, slip44)) {
+    // EVM coins typically use: m/44'/60'/0'/0/addressIndex
+    return `m/${bip}'/${slip44}'/0'/0/${addressIndex}`;
+  } else {
+    // UTXO coins use: m/84'/slip44'/account'/change/addressIndex
+    const changeValue = isChangeAddress ? 1 : 0;
+    return `m/${bip}'/${slip44}'/${accountIndex}'/${changeValue}/${addressIndex}`;
+  }
+}
+
+/**
+ * Convert an extended key's version bytes to a target version (e.g., xpub->zpub or tpub->vpub)
+ * - Pass targetVersionHex as a 4-byte hex string (e.g., '04b24746' for zpub, '045f1cf6' for vpub)
+ */
+export function convertExtendedKeyVersion(
+  extendedKey: string,
+  targetVersionHex: string
+): string {
+  try {
+    // Lazy import to avoid bundling when unused
+    /* eslint-disable @typescript-eslint/no-var-requires */
+    const bs58check = require('bs58check');
+    const decoded: Buffer = Buffer.from(bs58check.decode(extendedKey));
+    const target = Buffer.from(targetVersionHex, 'hex');
+    target.copy(decoded, 0, 0, 4);
+    return bs58check.encode(decoded);
+  } catch (e) {
+    // If conversion fails, return original key
+    return extendedKey;
+  }
+}

package/src/utils/psbt.ts

@@ -0,0 +1,24 @@
+import * as syscoinjs from 'syscoinjs-lib';
+
+/**
+ * Utility functions for PSBT conversion between Pali and syscoinjs formats
+ */
+export class PsbtUtils {
+  /**
+   * Import PSBT from Pali's exported format to syscoinjs PSBT object
+   * @param psbtFromPali - PSBT data exported from Pali
+   * @returns syscoinjs PSBT object
+   */
+  static fromPali(psbtFromPali: any): any {
+    return syscoinjs.utils.importPsbtFromJson(psbtFromPali).psbt;
+  }
+
+  /**
+   * Export syscoinjs PSBT object to Pali's expected format
+   * @param psbt - syscoinjs PSBT object
+   * @returns PSBT data in Pali's expected format
+   */
+  static toPali(psbt: any): any {
+    return syscoinjs.utils.exportPsbtToJson(psbt, undefined);
+  }
+}

package/src/utils.ts

@@ -0,0 +1,191 @@
+import { isHexString } from '@ethersproject/bytes';
+import { Logger } from '@ethersproject/logger';
+
+const logger = new Logger('utils');
+
+const errorGas = ['call', 'estimateGas'];
+
+function spelunk(
+  value: any,
+  requireData: boolean
+): null | { data: null | string; message: string } {
+  if (value == null) {
+    return null;
+  }
+
+  // These *are* the droids we're looking for.
+  if (typeof value.message === 'string' && value.message.match('reverted')) {
+    const data = isHexString(value.data) ? value.data : null;
+    if (!requireData || data) {
+      return { message: value.message, data };
+    }
+  }
+
+  // Spelunk further...
+  if (typeof value === 'object') {
+    for (const key in value) {
+      const result = spelunk(value[key], requireData);
+      if (result) {
+        return result;
+      }
+    }
+    return null;
+  }
+
+  // Might be a JSON string we can further descend...
+  if (typeof value === 'string') {
+    try {
+      return spelunk(JSON.parse(value), requireData);
+      // eslint-disable-next-line
+    } catch (error) {}
+  }
+
+  return null;
+}
+
+export function checkError(method: string, error: any, params: any): any {
+  const transaction = params.transaction || params.signedTransaction;
+
+  // Undo the "convenience" some nodes are attempting to prevent backwards
+  // incompatibility; maybe for v6 consider forwarding reverts as errors
+  if (method === 'call') {
+    const result = spelunk(error, true);
+    if (result) {
+      return result.data;
+    }
+
+    // Nothing descriptive..
+    logger.throwError(
+      'missing revert data in call exception; Transaction reverted without a reason string',
+      Logger.errors.CALL_EXCEPTION,
+      {
+        data: '0x',
+        transaction,
+        error,
+      }
+    );
+  }
+
+  if (method === 'estimateGas') {
+    // Try to find something, with a preference on SERVER_ERROR body
+    let result = spelunk(error.body, false);
+    if (result == null) {
+      result = spelunk(error, false);
+    }
+
+    // Found "reverted", this is a CALL_EXCEPTION
+    if (result) {
+      logger.throwError(
+        'cannot estimate gas; transaction may fail or may require manual gas limit',
+        Logger.errors.UNPREDICTABLE_GAS_LIMIT,
+        {
+          reason: result.message,
+          method,
+          transaction,
+          error,
+        }
+      );
+    }
+  }
+
+  // @TODO: Should we spelunk for message too?
+
+  let message = error.message;
+  if (
+    error.code === Logger.errors.SERVER_ERROR &&
+    error.error &&
+    typeof error.error.message === 'string'
+  ) {
+    message = error.error.message;
+  } else if (typeof error.body === 'string') {
+    message = error.body;
+  } else if (typeof error.responseText === 'string') {
+    message = error.responseText;
+  }
+  message = (message || '').toLowerCase();
+
+  // "insufficient funds for gas * price + value + cost(data)"
+  if (
+    message.match(
+      /insufficient funds|base fee exceeds gas limit|InsufficientFunds/i
+    )
+  ) {
+    logger.throwError(
+      'insufficient funds for intrinsic transaction cost',
+      Logger.errors.INSUFFICIENT_FUNDS,
+      {
+        error,
+        method,
+        transaction,
+      }
+    );
+  }
+
+  // "nonce too low"
+  if (message.match(/nonce (is )?too low/i)) {
+    logger.throwError(
+      'nonce has already been used',
+      Logger.errors.NONCE_EXPIRED,
+      {
+        error,
+        method,
+        transaction,
+      }
+    );
+  }
+
+  // "replacement transaction underpriced"
+  if (
+    message.match(
+      /replacement transaction underpriced|transaction gas price.*too low/i
+    )
+  ) {
+    logger.throwError(
+      'replacement fee too low',
+      Logger.errors.REPLACEMENT_UNDERPRICED,
+      {
+        error,
+        method,
+        transaction,
+      }
+    );
+  }
+
+  // "replacement transaction underpriced"
+  if (message.match(/only replay-protected/i)) {
+    logger.throwError(
+      'legacy pre-eip-155 transactions not supported',
+      Logger.errors.UNSUPPORTED_OPERATION,
+      {
+        error,
+        method,
+        transaction,
+      }
+    );
+  }
+
+  if (
+    errorGas.indexOf(method) >= 0 &&
+    message.match(
+      /gas required exceeds allowance|always failing transaction|execution reverted|revert/
+    )
+  ) {
+    logger.throwError(
+      'cannot estimate gas; transaction may fail or may require manual gas limit',
+      Logger.errors.UNPREDICTABLE_GAS_LIMIT,
+      {
+        error,
+        method,
+        transaction,
+      }
+    );
+  }
+
+  throw error;
+}
+
+export const SYSCOIN_BASIC_FEE = 0.00001;
+
+export const ONE_HUNDRED_MILLION = 1e8;
+
+export const BIP_84 = 84;