@sidhujag/sysweb3-keyring 1.0.545 → 1.0.547

package/src/ledger/types.ts

@@ -0,0 +1,74 @@
+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

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,345 @@
+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

@@ -0,0 +1,158 @@
+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;
+};