@sidhujag/sysweb3-keyring 1.0.491

package/types/ledger/bitcoin_client/lib/psbtv2.d.ts

@@ -0,0 +1,167 @@
+import * as bjs from 'bitcoinjs-lib';
+export declare enum psbtGlobal {
+    UNSIGNED_TX = 0,
+    XPUB = 1,
+    TX_VERSION = 2,
+    FALLBACK_LOCKTIME = 3,
+    INPUT_COUNT = 4,
+    OUTPUT_COUNT = 5,
+    TX_MODIFIABLE = 6,
+    VERSION = 251
+}
+export declare enum psbtIn {
+    NON_WITNESS_UTXO = 0,
+    WITNESS_UTXO = 1,
+    PARTIAL_SIG = 2,
+    SIGHASH_TYPE = 3,
+    REDEEM_SCRIPT = 4,
+    WITNESS_SCRIPT = 5,
+    BIP32_DERIVATION = 6,
+    FINAL_SCRIPTSIG = 7,
+    FINAL_SCRIPTWITNESS = 8,
+    PREVIOUS_TXID = 14,
+    OUTPUT_INDEX = 15,
+    SEQUENCE = 16,
+    TAP_KEY_SIG = 19,
+    TAP_BIP32_DERIVATION = 22
+}
+export declare enum psbtOut {
+    REDEEM_SCRIPT = 0,
+    WITNESS_SCRIPT = 1,
+    BIP_32_DERIVATION = 2,
+    AMOUNT = 3,
+    SCRIPT = 4,
+    TAP_BIP32_DERIVATION = 7
+}
+export declare class NoSuchEntry extends Error {
+}
+/**
+ * Implements Partially Signed Bitcoin Transaction version 2, BIP370, as
+ * documented at https://github.com/bitcoin/bips/blob/master/bip-0370.mediawiki
+ * and https://github.com/bitcoin/bips/blob/master/bip-0174.mediawiki
+ *
+ * A psbt is a data structure that can carry all relevant information about a
+ * transaction through all stages of the signing process. From constructing an
+ * unsigned transaction to extracting the final serialized transaction ready for
+ * broadcast.
+ *
+ * This implementation is limited to what's needed in ledgerjs to carry out its
+ * duties, which means that support for features like multisig or taproot script
+ * path spending are not implemented. Specifically, it supports p2pkh,
+ * p2wpkhWrappedInP2sh, p2wpkh and p2tr key path spending.
+ *
+ * This class is made purposefully dumb, so it's easy to add support for
+ * complemantary fields as needed in the future.
+ */
+export declare class PsbtV2 {
+    protected globalMap: Map<string, Buffer>;
+    protected inputMaps: Map<string, Buffer>[];
+    protected outputMaps: Map<string, Buffer>[];
+    setGlobalTxVersion(version: number): void;
+    getGlobalTxVersion(): number;
+    setGlobalFallbackLocktime(locktime: number): void;
+    getGlobalFallbackLocktime(): number | undefined;
+    setGlobalInputCount(inputCount: number): void;
+    getGlobalInputCount(): number;
+    setGlobalOutputCount(outputCount: number): void;
+    getGlobalOutputCount(): number;
+    setGlobalTxModifiable(byte: Buffer): void;
+    getGlobalTxModifiable(): Buffer | undefined;
+    setGlobalPsbtVersion(psbtVersion: number): void;
+    getGlobalPsbtVersion(): number;
+    setInputNonWitnessUtxo(inputIndex: number, transaction: Buffer): void;
+    getInputNonWitnessUtxo(inputIndex: number): Buffer | undefined;
+    setInputWitnessUtxo(inputIndex: number, amount: number, scriptPubKey: Buffer): void;
+    getInputWitnessUtxo(inputIndex: number): {
+        readonly amount: number;
+        readonly scriptPubKey: Buffer;
+    } | undefined;
+    setInputPartialSig(inputIndex: number, pubkey: Buffer, signature: Buffer): void;
+    getInputPartialSig(inputIndex: number, pubkey: Buffer): Buffer | undefined;
+    setInputSighashType(inputIndex: number, sigHashtype: number): void;
+    getInputSighashType(inputIndex: number): number | undefined;
+    setInputRedeemScript(inputIndex: number, redeemScript: Buffer): void;
+    getInputRedeemScript(inputIndex: number): Buffer | undefined;
+    setInputWitnessScript(inputIndex: number, witnessScript: Buffer): void;
+    getInputWitnessScript(inputIndex: number): Buffer | undefined;
+    setInputBip32Derivation(inputIndex: number, pubkey: Buffer, masterFingerprint: Buffer, path: readonly number[]): void;
+    getInputBip32Derivation(inputIndex: number, pubkey: Buffer): {
+        readonly masterFingerprint: Buffer;
+        readonly path: readonly number[];
+    } | undefined;
+    setInputFinalScriptsig(inputIndex: number, scriptSig: Buffer): void;
+    getInputFinalScriptsig(inputIndex: number): Buffer | undefined;
+    setInputFinalScriptwitness(inputIndex: number, scriptWitness: Buffer): void;
+    getInputFinalScriptwitness(inputIndex: number): Buffer;
+    setInputPreviousTxId(inputIndex: number, txid: Buffer): void;
+    getInputPreviousTxid(inputIndex: number): Buffer;
+    setInputOutputIndex(inputIndex: number, outputIndex: number): void;
+    getInputOutputIndex(inputIndex: number): number;
+    setInputSequence(inputIndex: number, sequence: number): void;
+    getInputSequence(inputIndex: number): number;
+    setInputTapKeySig(inputIndex: number, sig: Buffer): void;
+    getInputTapKeySig(inputIndex: number): Buffer | undefined;
+    setInputTapBip32Derivation(inputIndex: number, pubkey: Buffer, hashes: readonly Buffer[], masterFingerprint: Buffer, path: readonly number[]): void;
+    getInputTapBip32Derivation(inputIndex: number, pubkey: Buffer): {
+        readonly hashes: readonly Buffer[];
+        readonly masterFingerprint: Buffer;
+        readonly path: readonly number[];
+    };
+    getInputKeyDatas(inputIndex: number, keyType: KeyType): readonly Buffer[];
+    setOutputRedeemScript(outputIndex: number, redeemScript: Buffer): void;
+    getOutputRedeemScript(outputIndex: number): Buffer;
+    setOutputBip32Derivation(outputIndex: number, pubkey: Buffer, masterFingerprint: Buffer, path: readonly number[]): void;
+    getOutputBip32Derivation(outputIndex: number, pubkey: Buffer): {
+        readonly masterFingerprint: Buffer;
+        readonly path: readonly number[];
+    };
+    setOutputAmount(outputIndex: number, amount: number): void;
+    getOutputAmount(outputIndex: number): number;
+    setOutputScript(outputIndex: number, scriptPubKey: Buffer): void;
+    getOutputScript(outputIndex: number): Buffer;
+    setOutputTapBip32Derivation(outputIndex: number, pubkey: Buffer, hashes: readonly Buffer[], fingerprint: Buffer, path: readonly number[]): void;
+    getOutputTapBip32Derivation(outputIndex: number, pubkey: Buffer): {
+        readonly hashes: readonly Buffer[];
+        readonly masterFingerprint: Buffer;
+        readonly path: readonly number[];
+    };
+    deleteInputEntries(inputIndex: number, keyTypes: readonly psbtIn[]): void;
+    copy(to: PsbtV2): void;
+    copyMaps(from: readonly ReadonlyMap<string, Buffer>[], to: Map<string, Buffer>[]): void;
+    copyMap(from: ReadonlyMap<string, Buffer>, to: Map<string, Buffer>): void;
+    serialize(): Buffer;
+    deserialize(psbt: Buffer): void;
+    normalizeToV2(): void;
+    /**
+     * Imports a BitcoinJS (bitcoinjs-lib) Psbt object.
+     * https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/psbt.ts
+     *
+     * Prepares the fields required for signing a Psbt on a Ledger
+     * device. It should be used exclusively before calling
+     * `appClient.signPsbt()` and not as a general Psbt conversion method.
+     *
+     * Note: This method supports all the policies that the Ledger is able to
+     * sign, with the exception of taproot: tr(@0).
+     */
+    fromBitcoinJS(psbtBJS: bjs.Psbt): PsbtV2;
+    private readKeyPair;
+    private getKeyDatas;
+    private isKeyType;
+    private setGlobal;
+    private getGlobal;
+    private getGlobalOptional;
+    private setInput;
+    private getInput;
+    private getInputOptional;
+    private setOutput;
+    private getOutput;
+    private getMap;
+    private encodeBip32Derivation;
+    private decodeBip32Derivation;
+    private writeBip32Derivation;
+    private readBip32Derivation;
+    private encodeTapBip32Derivation;
+    private decodeTapBip32Derivation;
+}
+type KeyType = number;
+export {};

package/types/ledger/bitcoin_client/lib/varint.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Converts a `bigint` to a `number` if it non-negative and at most MAX_SAFE_INTEGER; throws `RangeError` otherwise.
+ * Used when converting a Bitcoin-style varint to a `number`, since varints could be larger than what the `Number`
+ * class can represent without loss of precision.
+ *
+ * @param n the number to convert
+ * @returns `n` as a `number`
+ */
+export declare function sanitizeBigintToNumber(n: number | bigint): number;
+/**
+ * Parses a Bitcoin-style variable length integer from a buffer, starting at the given `offset`. Returns a pair
+ * containing the parsed `BigInt`, and its length in bytes from the buffer.
+ *
+ * @param data the `Buffer` from which the variable-length integer is read
+ * @param offset a non-negative offset to read from
+ * @returns a pair where the first element is the parsed BigInt, and the second element is the length in bytes parsed
+ * from the buffer.
+ *
+ * @throws `RangeError` if offset is negative.
+ * @throws `Error` if the buffer's end is reached withut parsing being completed.
+ */
+export declare function parseVarint(data: Buffer, offset: number): readonly [bigint, number];
+export declare function createVarint(value: number | bigint): Buffer;

package/types/ledger/consts.d.ts

@@ -0,0 +1,3 @@
+export declare const DESCRIPTOR = "wpkh(@0/**)";
+export declare const RECEIVING_ADDRESS_INDEX = 0;
+export declare const WILL_NOT_DISPLAY = false;

package/types/ledger/index.d.ts

@@ -0,0 +1,51 @@
+import Transport from '@ledgerhq/hw-transport';
+import SysUtxoClient from './bitcoin_client';
+import { IEvmMethods, IUTXOMethods } from './types';
+import LedgerEthClient from '@ledgerhq/hw-app-eth';
+export declare class LedgerKeyring {
+    ledgerEVMClient: LedgerEthClient;
+    ledgerUtxoClient: SysUtxoClient;
+    private hdPath;
+    evm: IEvmMethods;
+    utxo: IUTXOMethods;
+    transport: Transport | null;
+    private hardwareWalletManager;
+    constructor();
+    /**
+     * Ensure Ledger is connected with automatic retry
+     * Note: This is automatically called by all operations through executeWithRetry
+     * External callers don't need to call this directly
+     */
+    ensureConnection(): Promise<void>;
+    private getUtxoAddress;
+    verifyUtxoAddress: (accountIndex: number, currency: string, slip44: number) => Promise<string>;
+    private getXpub;
+    /**
+     * Sign a UTXO message - public method used by transaction classes
+     */
+    signUtxoMessage: (path: string, message: string) => Promise<string>;
+    private signEVMTransaction;
+    private signPersonalMessage;
+    private sanitizeData;
+    private transformTypedData;
+    private getEvmAddressAndPubKey;
+    private signTypedData;
+    private getMasterFingerprint;
+    private setHdPath;
+    /**
+     * Convert PSBT to Ledger format with retry logic
+     */
+    convertToLedgerFormat(psbt: any, accountXpub: string, accountId: number, currency: string, slip44: number): Promise<any>;
+    /**
+     * Execute operation with automatic retry
+     */
+    private executeWithRetry;
+    /**
+     * Get hardware wallet status
+     */
+    getStatus(): import("../hardware-wallet-manager").HardwareWalletStatus | undefined;
+    /**
+     * Clean up resources
+     */
+    destroy(): Promise<void>;
+}

package/types/ledger/types.d.ts

@@ -0,0 +1,48 @@
+import { Version } from '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: Version;
+    }) => Promise<string>;
+}
+export {};

package/types/network-utils.d.ts

@@ -0,0 +1,14 @@
+import { INetwork } from '@sidhujag/sysweb3-network';
+/**
+ * Generate default UTXO networks from coins.ts data
+ * This ensures consistency and avoids hardcoded duplicates
+ */
+export declare function getDefaultUTXONetworks(): {
+    [chainId: number]: INetwork;
+};
+/**
+ * Get specific default UTXO networks for backwards compatibility
+ */
+export declare function getSyscoinUTXOMainnetNetwork(): INetwork;
+export declare function getSyscoinUTXOTestnetNetwork(): INetwork;
+export declare function getBitcoinMainnetNetwork(): INetwork;

package/types/providers.d.ts

@@ -0,0 +1,47 @@
+import { Networkish } from '@ethersproject/networks';
+import { ethers } from 'ethers';
+import { ConnectionInfo } from 'ethers/lib/utils';
+import { Provider } from 'zksync-ethers';
+declare class BaseProvider extends ethers.providers.JsonRpcProvider {
+    private isPossibleGetChainId;
+    private cooldownTime;
+    private rateLimit;
+    private requestCount;
+    private lastRequestTime;
+    private currentChainId;
+    private currentId;
+    isInCooldown: boolean;
+    errorMessage: any;
+    serverHasAnError: boolean;
+    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?: ConnectionInfo | string, network?: Networkish);
+    private bindMethods;
+    private throttledRequest;
+    private canMakeRequest;
+    private cooldown;
+    perform(method: string, params: any): Promise<any>;
+    send: (method: string, params: any[]) => Promise<any>;
+    sendBatch(method: string, params: Array<any[]>): Promise<any[]>;
+}
+export declare class CustomJsonRpcProvider extends BaseProvider {
+    constructor(signal: AbortSignal, url?: ConnectionInfo | string, network?: Networkish);
+}
+export declare class CustomL2JsonRpcProvider extends Provider {
+    private baseProvider;
+    constructor(signal: AbortSignal, url?: ConnectionInfo | string, network?: ethers.providers.Networkish);
+    perform(method: string, params: any): Promise<any>;
+    send(method: string, params: any[]): Promise<any>;
+    sendBatch(method: string, params: Array<any[]>): Promise<any[]>;
+}
+export {};

package/types/signers.d.ts

@@ -0,0 +1,95 @@
+import { BitcoinNetwork, IPubTypes, INetwork } from '@sidhujag/sysweb3-network';
+import { BIP32Interface } from 'bip32';
+import { Psbt } from 'bitcoinjs-lib';
+export declare const getSyscoinSigners: ({ mnemonic, rpc, }: ISyscoinSignerParams) => {
+    hd: SyscoinHDSigner;
+    main: any;
+};
+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;
+    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;
+    getAccountXpub: () => string;
+    getAddressFromKeypair: (keypair: BIP32Interface) => string;
+    getAddressFromPubKey: (pubkey: string) => string;
+    getHDPath: (addressIndex: number, isChange: boolean, bipNum?: number) => string;
+    getNewReceivingAddress: (skipIncrement?: boolean, bipNum?: number) => Promise<string>;
+    node: {
+        seed: Buffer;
+        coinType: number;
+        pubTypes: IPubTypes;
+        network: BitcoinNetwork;
+    };
+    setAccountIndex: (accountIndex: number) => void;
+    getRootNode: () => BIP32Interface;
+    importMethod: string;
+    signPSBT: ({ psbt, isTrezor, isLedger, pathIn, }: {
+        psbt: any;
+        isTrezor?: boolean;
+        isLedger?: boolean;
+        pathIn?: string;
+    }) => Promise<any>;
+    getNewChangeAddress: (skipIncrement?: boolean, bipNum?: number) => Promise<string>;
+    restore: (password: string, bipNum?: number) => boolean;
+    mnemonicOrZprv: string;
+    setLatestIndexesFromXPubTokens: (tokens: any) => void;
+    sign: (psbt: Psbt, pathIn?: string) => Promise<Psbt>;
+    getMasterFingerprint: () => Buffer;
+}
+export type SyscoinMainSigner = {
+    Signer: SyscoinHDSigner;
+    blockbookURL: string;
+    network: BitcoinNetwork;
+};

package/types/storage.d.ts

@@ -0,0 +1,2 @@
+export declare const setEncryptedVault: (decryptedVault: any, pwd: string) => Promise<void>;
+export declare const getDecryptedVault: (pwd: string) => Promise<any>;

package/types/transactions/__tests__/integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/transactions/__tests__/syscoin.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/transactions/ethereum.d.ts

@@ -0,0 +1,80 @@
+import { TransactionResponse } from '@ethersproject/abstract-provider';
+import { INetwork } from '@sidhujag/sysweb3-network';
+import { TypedMessage, Version, TypedData } from 'eth-sig-util';
+import { BigNumber, ethers } from 'ethers';
+import { LedgerKeyring } from '../ledger';
+import { CustomJsonRpcProvider, CustomL2JsonRpcProvider } from '../providers';
+import { TrezorKeyring } from '../trezor';
+import { IResponseFromSendErcSignedTransaction, ISendSignedErcTransactionProps, ISendTransaction, IEthereumTransactions, SimpleTransactionRequest, KeyringAccountType, accountType, IGasParams } from '../types';
+export declare class EthereumTransactions implements IEthereumTransactions {
+    private _web3Provider;
+    trezorSigner: TrezorKeyring;
+    ledgerSigner: LedgerKeyring;
+    private getNetwork;
+    private abortController;
+    private getDecryptedPrivateKey;
+    private getState;
+    constructor(getNetwork: () => INetwork, getDecryptedPrivateKey: () => {
+        address: string;
+        decryptedPrivateKey: string;
+    }, getState: () => {
+        accounts: {
+            HDAccount: accountType;
+            Imported: accountType;
+            Ledger: accountType;
+            Trezor: accountType;
+        };
+        activeAccountId: number;
+        activeAccountType: KeyringAccountType;
+        activeNetwork: INetwork;
+    }, ledgerSigner: LedgerKeyring, trezorSigner: TrezorKeyring);
+    get web3Provider(): CustomJsonRpcProvider | CustomL2JsonRpcProvider;
+    private ensureProvidersInitialized;
+    private isUtxoNetwork;
+    signTypedData: (addr: string, typedData: TypedData | TypedMessage<any>, version: Version) => Promise<any>;
+    verifyTypedSignature: (data: TypedData | TypedMessage<any>, signature: string, version: Version) => string;
+    ethSign: (params: string[]) => Promise<string>;
+    signPersonalMessage: (params: string[]) => Promise<string>;
+    parsePersonalMessage: (hexMsg: string) => string;
+    verifyPersonalMessage: (message: string, sign: string) => string;
+    getEncryptedPubKey: () => string;
+    decryptMessage: (msgParams: string[]) => string;
+    toBigNumber: (aBigNumberish: string | number) => BigNumber;
+    getData: ({ contractAddress, receivingAddress, value, }: {
+        contractAddress: string;
+        receivingAddress: string;
+        value: any;
+    }) => any;
+    getFeeDataWithDynamicMaxPriorityFeePerGas: () => Promise<{
+        maxFeePerGas: BigNumber;
+        maxPriorityFeePerGas: BigNumber;
+    }>;
+    calculateNewGasValues: (oldTxsParams: IGasParams, isForCancel: boolean, isLegacy: boolean) => IGasParams;
+    cancelSentTransaction: (txHash: string, isLegacy?: boolean) => Promise<{
+        error?: boolean;
+        isCanceled: boolean;
+        transaction?: TransactionResponse;
+    }>;
+    sendFormattedTransaction: (params: SimpleTransactionRequest, isLegacy?: boolean) => Promise<TransactionResponse>;
+    sendTransactionWithEditedFee: (txHash: string, isLegacy?: boolean) => Promise<{
+        error?: boolean;
+        isSpeedUp: boolean;
+        transaction?: TransactionResponse;
+    }>;
+    sendTransaction: ({ sender, receivingAddress, amount, gasLimit, token, }: ISendTransaction) => Promise<TransactionResponse>;
+    sendSignedErc20Transaction: ({ receiver, tokenAddress, tokenAmount, isLegacy, maxPriorityFeePerGas, maxFeePerGas, gasPrice, decimals, gasLimit, saveTrezorTx, }: ISendSignedErcTransactionProps) => Promise<IResponseFromSendErcSignedTransaction>;
+    sendSignedErc721Transaction: ({ receiver, tokenAddress, tokenId, isLegacy, maxPriorityFeePerGas, maxFeePerGas, gasPrice, gasLimit, }: ISendSignedErcTransactionProps) => Promise<IResponseFromSendErcSignedTransaction>;
+    sendSignedErc1155Transaction: ({ receiver, tokenAddress, tokenId, tokenAmount, isLegacy, maxPriorityFeePerGas, maxFeePerGas, gasPrice, gasLimit, }: ISendSignedErcTransactionProps) => Promise<IResponseFromSendErcSignedTransaction>;
+    getRecommendedNonce: (address: string) => Promise<number>;
+    getFeeByType: (type: string) => Promise<string>;
+    getGasLimit: (toAddress: string) => Promise<number>;
+    getTxGasLimit: (tx: SimpleTransactionRequest) => Promise<BigNumber>;
+    getRecommendedGasPrice: (formatted?: boolean) => Promise<string | {
+        gwei: string;
+        ethers: string;
+    }>;
+    getBalance: (address: string) => Promise<number>;
+    private getTransactionTimestamp;
+    setWeb3Provider(network: INetwork): void;
+    importAccount: (mnemonicOrPrivKey: string) => ethers.Wallet;
+}

package/types/transactions/index.d.ts

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

package/types/transactions/syscoin.d.ts

@@ -0,0 +1,61 @@
+import { INetwork } from '@sidhujag/sysweb3-network';
+import { ITxid } from '@sidhujag/sysweb3-utils';
+import { LedgerKeyring } from '../ledger';
+import { SyscoinHDSigner } from '../signers';
+import { TrezorKeyring } from '../trezor';
+import { ISyscoinTransactions, KeyringAccountType, accountType } from '../types';
+export declare class SyscoinTransactions implements ISyscoinTransactions {
+    private getSigner;
+    private getReadOnlySigner;
+    private trezor;
+    private ledger;
+    private getState;
+    private getAddress;
+    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);
+    private getTransactionPSBT;
+    decodeRawTransaction: (psbtOrHex: any, isRawHex?: boolean) => any;
+    getRecommendedFee: (explorerUrl: string) => Promise<number>;
+    txUtilsFunctions: () => {
+        getRawTransaction: (explorerUrl: string, txid: string) => any;
+    };
+    private signPSBTWithSigner;
+    private createUnsignedPSBT;
+    private signPSBTWithMethod;
+    getEstimateSysTransactionFee: ({ txOptions, isMax, amount, receivingAddress, feeRate, token, }: {
+        amount: number;
+        feeRate?: number;
+        receivingAddress: string;
+        token?: {
+            guid: string;
+            symbol?: string;
+        } | null;
+        txOptions?: any;
+        isMax?: boolean | false;
+    }) => Promise<{
+        fee: number;
+        psbt: any;
+    }>;
+    private sendSignedTransaction;
+    signPSBT: ({ psbt, isTrezor, isLedger, pathIn, }: {
+        psbt: any;
+        isTrezor?: boolean;
+        isLedger?: boolean;
+        pathIn?: string;
+    }) => Promise<any>;
+    sendTransaction: (psbt: any) => Promise<ITxid>;
+}