@sidhujag/sysweb3-keyring 1.0.547 → 1.0.548

package/src/ledger/types.ts

@@ -1,74 +0,0 @@
-import { SignTypedDataVersion } from '@metamask/eth-sig-util';
-
-export interface IUTXOMethods {
-  getUtxoAddress: ({
-    coin,
-    index,
-    slip44,
-  }: {
-    coin: string;
-    index: number;
-    slip44: number;
-  }) => Promise<string>;
-  getXpub: ({
-    index,
-    coin,
-    slip44,
-  }: {
-    coin: string;
-    index: number;
-    slip44: number;
-  }) => Promise<string>;
-  verifyUtxoAddress: (
-    accountIndex: number,
-    currency: string,
-    slip44: number
-  ) => Promise<string>;
-}
-
-interface MessageTypeProperty {
-  name: string;
-  type: string;
-}
-export interface MessageTypes {
-  [additionalProperties: string]: MessageTypeProperty[];
-  EIP712Domain: MessageTypeProperty[];
-}
-
-export interface IEvmMethods {
-  getEvmAddressAndPubKey: ({
-    accountIndex,
-  }: {
-    accountIndex: number;
-  }) => Promise<{
-    address: string;
-    publicKey: string;
-  }>;
-  signEVMTransaction: ({
-    rawTx,
-    accountIndex,
-  }: {
-    accountIndex: number;
-    rawTx: string;
-  }) => Promise<{
-    r: string;
-    s: string;
-    v: string;
-  }>;
-  signPersonalMessage: ({
-    message,
-    accountIndex,
-  }: {
-    accountIndex: number;
-    message: string;
-  }) => Promise<string>;
-  signTypedData: ({
-    version,
-    data,
-    accountIndex,
-  }: {
-    accountIndex: number;
-    data: any;
-    version: SignTypedDataVersion;
-  }) => Promise<string>;
-}

package/src/network-utils.ts

@@ -1,99 +0,0 @@
-import {
-  INetwork,
-  INetworkType,
-  coins as utxoCoins,
-} from '@sidhujag/sysweb3-network';
-
-/**
- * Generate default UTXO networks from coins.ts data
- * This ensures consistency and avoids hardcoded duplicates
- */
-export function getDefaultUTXONetworks(): { [chainId: number]: INetwork } {
-  const defaultNetworks: { [chainId: number]: INetwork } = {};
-
-  // Filter coins that should be default networks
-  const defaultCoins = utxoCoins.filter((coin) => {
-    // Include Syscoin mainnet and testnet as defaults
-    return (
-      (coin.coinShortcut === 'SYS' && coin.slip44 === 57) || // Syscoin Mainnet
-      (coin.coinShortcut === 'tSYS' && coin.slip44 === 1) || // Syscoin Testnet
-      (coin.coinShortcut === 'BTC' && coin.slip44 === 0) // Bitcoin Mainnet only
-    );
-  });
-
-  defaultCoins.forEach((coin) => {
-    if (
-      !coin.blockchainLink ||
-      !coin.blockchainLink.url ||
-      coin.blockchainLink.url.length === 0
-    ) {
-      return; // Skip coins without valid blockbook URLs
-    }
-
-    // Use primary blockbook URL
-    const primaryUrl = Array.isArray(coin.blockchainLink.url)
-      ? coin.blockchainLink.url[0]
-      : coin.blockchainLink.url;
-
-    const chainId = (coin as any).chainId || coin.slip44;
-
-    const network: INetwork = {
-      chainId,
-      url: primaryUrl,
-      label: coin.name || coin.coinLabel || `${coin.coinShortcut} Network`,
-      default: coin.coinShortcut === 'SYS',
-      currency: coin.coinShortcut?.toLowerCase() || 'unknown',
-      slip44: coin.slip44,
-      kind: INetworkType.Syscoin,
-    };
-
-    defaultNetworks[chainId] = network;
-  });
-
-  return defaultNetworks;
-}
-
-/**
- * Get specific default UTXO networks for backwards compatibility
- */
-export function getSyscoinUTXOMainnetNetwork(): INetwork {
-  const networks = getDefaultUTXONetworks();
-  // Find Syscoin mainnet (slip44: 57)
-  const syscoinMainnet = Object.values(networks).find(
-    (network) => network.slip44 === 57 && network.currency === 'sys'
-  );
-
-  if (!syscoinMainnet) {
-    throw new Error('Syscoin UTXO Mainnet network not found in coins.ts');
-  }
-
-  return syscoinMainnet;
-}
-
-export function getSyscoinUTXOTestnetNetwork(): INetwork {
-  const networks = getDefaultUTXONetworks();
-  // Find Syscoin testnet (slip44: 1, currency: tsys)
-  const syscoinTestnet = Object.values(networks).find(
-    (network) => network.slip44 === 1 && network.currency === 'tsys'
-  );
-
-  if (!syscoinTestnet) {
-    throw new Error('Syscoin UTXO Testnet network not found in coins.ts');
-  }
-
-  return syscoinTestnet;
-}
-
-export function getBitcoinMainnetNetwork(): INetwork {
-  const networks = getDefaultUTXONetworks();
-  // Find Bitcoin mainnet (slip44: 0, currency: btc)
-  const bitcoinMainnet = Object.values(networks).find(
-    (network) => network.slip44 === 0 && network.currency === 'btc'
-  );
-
-  if (!bitcoinMainnet) {
-    throw new Error('Bitcoin Mainnet network not found in coins.ts');
-  }
-
-  return bitcoinMainnet;
-}

package/src/providers.ts

@@ -1,345 +0,0 @@
-import { BigNumber } from '@ethersproject/bignumber';
-import { Logger } from '@ethersproject/logger';
-import { Networkish } from '@ethersproject/networks';
-import { shallowCopy } from '@ethersproject/properties';
-import { JsonRpcProvider } from '@ethersproject/providers';
-
-import { handleStatusCodeError } from './errorUtils';
-import { checkError } from './utils';
-
-const logger = new Logger('sysweb3-keyring/providers');
-
-// Type definition for zksync-ethers Provider to avoid direct import
-type ZkSyncProvider = any;
-
-class BaseProvider extends JsonRpcProvider {
-  private isPossibleGetChainId = true;
-  private cooldownTime = 120 * 1000;
-  private rateLimit = 30;
-  private requestCount = 0;
-  private lastRequestTime = 0;
-  private currentChainId = '';
-  private currentId = 1;
-  public isInCooldown = false;
-  public errorMessage: any = '';
-  public serverHasAnError = false;
-  signal: AbortSignal;
-  _pendingBatchAggregator: NodeJS.Timer | null;
-  _pendingBatch: Array<{
-    reject: (error: Error) => void;
-    request: { id: number; jsonrpc: '2.0'; method: string; params: Array<any> };
-    resolve: (result: any) => void;
-  }> | null;
-
-  constructor(
-    signal: AbortSignal,
-    url?: string | { url: string },
-    network?: Networkish
-  ) {
-    super(url, network);
-    this.signal = signal;
-    this._pendingBatchAggregator = null;
-    this._pendingBatch = null;
-
-    this.bindMethods();
-  }
-
-  private bindMethods() {
-    const proto = Object.getPrototypeOf(this);
-    for (const key of Object.getOwnPropertyNames(proto)) {
-      if (typeof this[key] === 'function' && key !== 'constructor') {
-        this[key] = this[key].bind(this);
-      }
-    }
-  }
-
-  private throttledRequest = <T>(requestFn: () => Promise<T>): Promise<T> => {
-    if (!this.canMakeRequest()) {
-      return this.cooldown();
-    }
-    // Execute request immediately without timeout delay
-    return requestFn().catch((error) => {
-      if (error.name === 'AbortError') {
-        console.log('Aborted request', error);
-        return Promise.reject(error);
-      }
-      throw error;
-    });
-  };
-  private canMakeRequest = () => {
-    const now = Date.now();
-    let elapsedTime = 0;
-    if (this.lastRequestTime > 0) {
-      elapsedTime = now - this.lastRequestTime;
-    }
-    if (elapsedTime <= this.cooldownTime && this.serverHasAnError) {
-      this.isInCooldown = true;
-      return false;
-    }
-
-    if (elapsedTime >= this.cooldownTime && this.serverHasAnError) {
-      this.requestCount = 0;
-      this.serverHasAnError = false;
-      this.isInCooldown = true;
-      return false; //One last blocked request before cooldown ends
-    }
-
-    if (this.requestCount < this.rateLimit || !this.serverHasAnError) {
-      this.requestCount++;
-      if (elapsedTime > 1000) {
-        //Uncomment the console.log to see the request per second
-        // console.log(
-        //   `Request/sec to Provider(${this.connection.url}): ${this.requestCount}`
-        // );
-        this.requestCount = 1;
-        this.lastRequestTime = now;
-      } else if (this.lastRequestTime === 0) {
-        this.lastRequestTime = now;
-      }
-      this.isInCooldown = false;
-      return true;
-    }
-  };
-
-  private cooldown = async () => {
-    const now = Date.now();
-    const elapsedTime = now - this.lastRequestTime;
-    console.error(
-      'Cant make request, rpc cooldown is active for the next: ',
-      (this.cooldownTime - elapsedTime) / 1000,
-      ' seconds'
-    );
-    throw {
-      message: `Cant make request, rpc cooldown is active for the next: ${
-        (this.cooldownTime - elapsedTime) / 1000
-      } seconds`,
-    };
-  };
-
-  async perform(method: string, params: any): Promise<any> {
-    // Legacy networks do not like the type field being passed along (which
-    // is fair), so we delete type if it is 0 and a non-EIP-1559 network
-    if (method === 'call' || method === 'estimateGas') {
-      const tx = params.transaction;
-      if (tx && tx.type != null && BigNumber.from(tx.type).isZero()) {
-        // If there are no EIP-1559 properties, it might be non-EIP-1559
-        if (tx.maxFeePerGas == null && tx.maxPriorityFeePerGas == null) {
-          const feeData = await this.getFeeData();
-          if (
-            feeData.maxFeePerGas == null &&
-            feeData.maxPriorityFeePerGas == null
-          ) {
-            // Network doesn't know about EIP-1559 (and hence type)
-            params = shallowCopy(params);
-            params.transaction = shallowCopy(tx);
-            delete params.transaction.type;
-          }
-        }
-      }
-    }
-
-    const args = this.prepareRequest(method, params);
-
-    if (args == null) {
-      logger.throwError(
-        method + ' not implemented',
-        Logger.errors.NOT_IMPLEMENTED,
-        { operation: method }
-      );
-    }
-    try {
-      return await this.send(args[0], args[1]);
-    } catch (error) {
-      return checkError(method, error, params);
-    }
-  }
-
-  override send = async (method: string, params: any[]) => {
-    if (!this.isPossibleGetChainId && method === 'eth_chainId') {
-      return this.currentChainId;
-    }
-
-    const headers = {
-      'Content-Type': 'application/json',
-    };
-
-    const options: RequestInit = {
-      method: 'POST',
-      headers,
-      body: JSON.stringify({
-        jsonrpc: '2.0',
-        method,
-        params,
-        id: this.currentId,
-      }),
-      signal: this.signal,
-    };
-
-    const result = await this.throttledRequest(() =>
-      fetch(this.connection.url, options)
-        .then(async (response) => {
-          if (!response.ok) {
-            let errorBody = {
-              error: undefined,
-              message: undefined,
-            };
-            try {
-              errorBody = await response.json();
-            } catch (error) {
-              console.warn('No body in request', error);
-            }
-            this.errorMessage =
-              errorBody.error ||
-              errorBody.message ||
-              'No message from Provider';
-            handleStatusCodeError(response.status, this.errorMessage);
-          }
-          switch (response.status) {
-            case 200:
-              return response.json();
-            default:
-              throw {
-                message: `Unexpected HTTP status code: ${response.status}`,
-              };
-          }
-        })
-        .then((json) => {
-          if (json.error) {
-            if (json.error.message.includes('insufficient funds')) {
-              console.error({
-                errorMessage: json.error.message,
-              });
-              this.errorMessage = json.error.message;
-              throw new Error(json.error.message);
-            }
-            this.errorMessage = json.error.message;
-            console.log({ requestData: { method, params }, error: json.error });
-            console.error({
-              errorMessage: json.error.message,
-            });
-            throw new Error(json.error.message);
-          }
-          if (method === 'eth_chainId') {
-            this.currentChainId = json.result;
-            this.isPossibleGetChainId = false;
-          }
-          this.currentId++;
-          this.serverHasAnError = false;
-          return json.result;
-        })
-    );
-    return result;
-  };
-
-  async sendBatch(method: string, params: Array<any[]>): Promise<any[]> {
-    // Create batch request array
-    const requests = params.map((param, index) => ({
-      jsonrpc: '2.0',
-      id: this.currentId + index,
-      method,
-      params: param,
-    }));
-
-    this.currentId += requests.length;
-
-    const headers = {
-      'Content-Type': 'application/json',
-    };
-
-    const options: RequestInit = {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(requests),
-      signal: this.signal,
-    };
-
-    const results = await this.throttledRequest(() =>
-      fetch(this.connection.url, options)
-        .then(async (response) => {
-          if (!response.ok) {
-            let errorBody = {
-              error: undefined,
-              message: undefined,
-            };
-            try {
-              errorBody = await response.json();
-            } catch (error) {
-              console.warn('No body in request', error);
-            }
-            this.errorMessage =
-              errorBody.error ||
-              errorBody.message ||
-              'No message from Provider';
-            handleStatusCodeError(response.status, this.errorMessage);
-          }
-          return response.json();
-        })
-        .then((jsonArray) => {
-          // Sort results by ID to ensure correct order
-          const sortedResults = jsonArray.sort((a: any, b: any) => a.id - b.id);
-
-          // Extract results or throw errors
-          return sortedResults.map((json: any) => {
-            if (json.error) {
-              this.errorMessage = json.error.message;
-              console.error({
-                errorMessage: json.error.message,
-              });
-              throw new Error(json.error.message);
-            }
-            return json.result;
-          });
-        })
-    );
-
-    return results;
-  }
-}
-
-export class CustomJsonRpcProvider extends BaseProvider {
-  constructor(
-    signal: AbortSignal,
-    url?: string | { url: string },
-    network?: Networkish
-  ) {
-    super(signal, url, network);
-  }
-}
-
-// CustomL2JsonRpcProvider extends BaseProvider to provide all standard provider methods
-export class CustomL2JsonRpcProvider extends BaseProvider {
-  private zkSyncProvider: ZkSyncProvider | null = null;
-
-  constructor(
-    signal: AbortSignal,
-    url?: string | { url: string },
-    network?: Networkish
-  ) {
-    super(signal, url, network);
-  }
-
-  // Lazy initialization of zkSync provider
-  private async initializeZkSyncProvider(): Promise<void> {
-    if (!this.zkSyncProvider) {
-      // Dynamic import creates a separate chunk for zksync-ethers
-      // webpack magic comment for chunk naming
-      const { Provider } = await import(
-        /* webpackChunkName: "zksync-provider" */ 'zksync-ethers'
-      );
-      this.zkSyncProvider = new Provider(this.connection.url, this.network);
-    }
-  }
-
-  // Override perform to handle zkSync-specific methods
-  async perform(method: string, params: any): Promise<any> {
-    // For zkSync-specific methods, ensure zkSync provider is initialized
-    if (method.startsWith('zks_') || method === 'eth_estimateGas') {
-      await this.initializeZkSyncProvider();
-      if (this.zkSyncProvider && this.zkSyncProvider.perform) {
-        return this.zkSyncProvider.perform(method, params);
-      }
-    }
-    // For all other methods, use the base provider
-    return super.perform(method, params);
-  }
-}

package/src/signers.ts

@@ -1,158 +0,0 @@
-import { BitcoinNetwork, IPubTypes, INetwork } from '@sidhujag/sysweb3-network';
-import { BIP32Interface } from 'bip32';
-import { Psbt } from 'bitcoinjs-lib';
-import * as syscoinjs from 'syscoinjs-lib';
-
-export const getSyscoinSigners = ({
-  mnemonic,
-  rpc,
-}: ISyscoinSignerParams): { hd: SyscoinHDSigner; main: any } => {
-  const { url, slip44, currency } = rpc.formattedNetwork;
-  let config: BitcoinNetwork | null = null;
-  let pubTypes: IPubTypes | null = null;
-  let networks: { mainnet: BitcoinNetwork; testnet: BitcoinNetwork } | null =
-    null;
-  let isTestnet = false;
-
-  // Determine if this is a testnet based on slip44 and currency
-  isTestnet =
-    slip44 === 1 || Boolean(currency && currency.toLowerCase().startsWith('t'));
-
-  if (rpc.networkConfig) {
-    const { networkConfig } = rpc;
-    const { networks: _networkConfig, types } = networkConfig;
-
-    config = isTestnet ? _networkConfig.testnet : _networkConfig.mainnet;
-    networks = _networkConfig;
-    pubTypes = types.zPubType;
-  }
-
-  // @ts-ignore
-  const hd: SyscoinHDSigner = new syscoinjs.utils.HDSigner(
-    mnemonic,
-    null,
-    isTestnet, // Use proper testnet flag
-    networks,
-    slip44,
-    pubTypes,
-    84
-  );
-
-  const main: any = new syscoinjs.SyscoinJSLib(hd, url, config);
-
-  return {
-    hd,
-    main,
-  };
-};
-
-export type SyscoinHdAccount = {
-  network: BitcoinNetwork;
-  networks: {
-    mainnet: BitcoinNetwork;
-    testnet: BitcoinNetwork;
-  };
-  pubTypes: IPubTypes;
-  zprv: string;
-};
-
-export type ISyscoinSignerParams = {
-  mnemonic: string;
-  rpc: {
-    formattedNetwork: INetwork;
-    networkConfig?: {
-      networks: { mainnet: BitcoinNetwork; testnet: BitcoinNetwork };
-      types: { xPubType: IPubTypes; zPubType: IPubTypes };
-    };
-  };
-};
-
-export type IMainSignerParams = {
-  hd: SyscoinHDSigner;
-  network?: BitcoinNetwork;
-  url: string;
-};
-
-export interface SyscoinHDSigner {
-  Signer: {
-    SLIP44: number;
-    accountIndex: number;
-    accounts: any;
-    blockbookURL: string;
-    changeIndex: number;
-    network: BitcoinNetwork;
-    networks: { mainnet: BitcoinNetwork; testnet: BitcoinNetwork };
-    password: string | null;
-    pubTypes: IPubTypes;
-    receivingIndex: number;
-    setIndexFlag: number;
-  };
-  backup: () => void;
-  blockbookURL: string;
-  // Already async
-  createAccount: (bipNum?: number, zprv?: string) => number;
-  createAccountAtIndex: (
-    index: number,
-    bipNum?: number,
-    zprv?: string
-  ) => number;
-  createAddress: (
-    addressIndex: number,
-    isChange: boolean,
-    bipNum?: number
-  ) => string;
-  createKeypair: (addressIndex: number, isChange: boolean) => BIP32Interface;
-  deriveAccount: (index: number, bipNum?: number) => string;
-  deriveKeypair: (keypath: string) => BIP32Interface;
-  derivePubKey: (keypath: string) => string;
-  // Updated signature
-  getAccountXpub: () => string;
-  getAddressFromKeypair: (keypair: BIP32Interface) => string;
-  getAddressFromPubKey: (pubkey: string) => string;
-  getHDPath: (
-    addressIndex: number,
-    isChange: boolean,
-    bipNum?: number
-  ) => string; // Already async
-  getNewReceivingAddress: (
-    skipIncrement?: boolean,
-    bipNum?: number
-  ) => Promise<string>;
-  // Added new property for import method tracking
-  node: {
-    seed: Buffer;
-    coinType: number;
-    pubTypes: IPubTypes;
-    network: BitcoinNetwork;
-  };
-  setAccountIndex: (accountIndex: number) => void;
-  getRootNode: () => BIP32Interface;
-  // Updated to reflect the enhanced property name
-  importMethod: string;
-  signPSBT: ({
-    psbt,
-    isTrezor,
-    isLedger,
-  }: {
-    psbt: any;
-    isTrezor?: boolean;
-    isLedger?: boolean;
-  }) => Promise<any>;
-  getNewChangeAddress: (
-    skipIncrement?: boolean,
-    bipNum?: number
-  ) => Promise<string>;
-  restore: (password: string, bipNum?: number) => boolean;
-  mnemonicOrZprv: string;
-  setLatestIndexesFromXPubTokens: (tokens: any) => void;
-  // Made async
-  sign: (psbt: Psbt) => Promise<Psbt>;
-  // Made async
-  getMasterFingerprint: () => Buffer;
-}
-
-export type SyscoinMainSigner = {
-  Signer: SyscoinHDSigner;
-  blockbookURL: string;
-  network: BitcoinNetwork;
-};