@sidhujag/sysweb3-keyring 1.0.491

package/types/trezor/index.d.ts

@@ -0,0 +1,170 @@
+import { AccountInfo, EthereumTransaction, EthereumTransactionEIP1559 } from '@trezor/connect-webextension';
+import { Buffer } from 'buffer';
+import { Version } from 'eth-sig-util';
+import { SyscoinHDSigner } from '../signers';
+export interface TrezorControllerState {
+    hdPath: string;
+    paths: Record<string, number>;
+}
+declare global {
+    interface Window {
+        TrezorConnect: any;
+    }
+}
+export declare class TrezorKeyring {
+    hdPath: string;
+    publicKey: Buffer;
+    chainCode: Buffer;
+    paths: Record<string, number>;
+    model?: string;
+    private getSigner;
+    private hardwareWalletManager;
+    private initialized;
+    constructor(getSyscoinSigner: () => {
+        hd: SyscoinHDSigner;
+        main: any;
+    });
+    /**
+     * Initialize Trezor script.
+     */
+    init(): Promise<boolean>;
+    /**
+     * Execute operation with automatic retry
+     */
+    private executeWithRetry;
+    /**
+     * This return account info based in params provided.
+     *
+     * @param coin - network symbol. Example: eth, sys, btc
+     * @param slip44 - network slip44 number
+     * @param hdPath - path derivation. Example: m/84'/57'/0'
+     * @param index - index of account for path derivation
+     * @returns derivated account info or error
+     */
+    getAccountInfo({ coin, slip44, hdPath, index, }: {
+        coin: string;
+        hdPath?: string;
+        index?: number;
+        slip44: number;
+    }): Promise<AccountInfo>;
+    /**
+     * Gets the model, if known.
+     * This may be `undefined` if the model hasn't been loaded yet.
+     *
+     * @returns
+     */
+    getModel(): string | undefined;
+    /**
+     * This removes the Trezor Connect iframe from the DOM
+     *
+     * @returns void
+     */
+    dispose(): void;
+    /**
+     * This verify if message is valid or not.
+     *
+     * @param coin - network symbol. Example: eth, sys, btc
+     * @param address - account address that signed message
+     * @param message - message to be verified. Example: 'Test message'
+     * @param signature - signature received in sign method. Example: I6BrpivjCwZmScZ6BMAHWGQPo+JjX2kzKXU5LcGVfEgvFb2VfJuKo3g6eSQcykQZiILoWNUDn5rDHkwJg3EcvuY=
+     * @returns derivated account info or error
+     */
+    verifyMessage({ coin, address, message, signature, }: {
+        address: string;
+        coin: string;
+        message: string;
+        signature: string;
+    }): Promise<{
+        success: any;
+        payload: any;
+    }>;
+    /**
+     * This return account public key.
+     *
+     * @param coin - network symbol. Example: eth, sys, btc
+     * @param slip44 - network slip44 number
+     * @param hdPath - path derivation. Example: m/44'/57'/0'/0/0
+     * @returns publicKey and chainCode
+     */
+    getPublicKey({ coin, slip44, hdPath, index, }: {
+        coin: string;
+        hdPath?: string;
+        index?: number;
+        slip44: number;
+    }): Promise<any>;
+    range(n: number): number[];
+    /**
+     * This sign UTXO tx.
+     *
+     * @param coin - network symbol. Example: eth, sys, btc
+     * @param inputs - utxo transaction inputs
+     * @param outputs - utxo transaction outputs
+     * @returns signature object
+     */
+    signUtxoTransaction(utxoTransaction: any, psbt: any): Promise<any>;
+    private setHdPath;
+    convertToAddressNFormat(path: string): any[];
+    isScriptHash(address: string, networkInfo: any): boolean;
+    isPaymentFactory(payment: any): (script: any) => boolean;
+    isBech32(address: string): boolean;
+    isP2WSHScript(script: any): boolean;
+    convertToTrezorFormat({ psbt, pathIn, coin }: any): any;
+    /**
+     * This sign EVM tx.
+     *
+     * @param index - index of account for path derivation
+     * @param tx - ethereum tx object
+     * @returns signature object
+     */
+    signEthTransaction({ tx, index, coin, slip44, }: {
+        index: string;
+        tx: EthereumTransaction | EthereumTransactionEIP1559;
+        coin: string;
+        slip44: number;
+    }): Promise<any>;
+    /**
+     * This sign message.
+     *
+     * @param coin - network symbol. Example: eth, sys, btc
+     * @param slip44 - network slip44 number
+     * @param message - message to be signed. Example: 'Test message'
+     * @param index - index of account for path derivation
+     * @returns signature object
+     */
+    signMessage({ index, message, coin, slip44, address, }: {
+        address: string;
+        coin: string;
+        index?: number;
+        message?: string;
+        slip44: number;
+    }): Promise<unknown>;
+    private _signUtxoPersonalMessage;
+    private _signEthPersonalMessage;
+    private _sanitizeData;
+    private _transformTypedData;
+    /**
+     * EIP-712 Sign Typed Data
+     */
+    signTypedData({ version, address, data, index, }: {
+        address: string;
+        data: any;
+        index: number;
+        version: Version;
+    }): Promise<any>;
+    /**
+     * Verify UTXO address by displaying it on the Trezor device
+     * @param accountIndex - The account index
+     * @param currency - The currency (coin type)
+     * @param slip44 - The slip44 value for the network
+     * @returns The verified address
+     */
+    verifyUtxoAddress(accountIndex: number, currency: string, slip44: number): Promise<string | undefined>;
+    /**
+     * Check Trezor status
+     */
+    getStatus(): import("../hardware-wallet-manager").HardwareWalletStatus | undefined;
+    /**
+     * Clean up resources
+     */
+    destroy(): Promise<void>;
+}

package/types/types.d.ts

@@ -0,0 +1,294 @@
+import { TransactionResponse } from '@ethersproject/abstract-provider';
+import { INetwork, INetworkType } from '@sidhujag/sysweb3-network';
+import { ITxid } from '@sidhujag/sysweb3-utils';
+import { TypedData, TypedMessage } from 'eth-sig-util';
+import { ethers, BigNumber, BigNumberish } from 'ethers';
+import { CustomJsonRpcProvider, CustomL2JsonRpcProvider } from 'providers';
+import { LedgerKeyring } from './ledger';
+import { SyscoinHDSigner } from './signers';
+import { TrezorKeyring } from './trezor';
+export interface ISendTransaction {
+    amount: number;
+    gasLimit?: number;
+    gasPrice?: number;
+    receivingAddress: string;
+    sender: string;
+    token?: any;
+}
+export type SimpleTransactionRequest = {
+    accessList?: ethers.utils.AccessListish;
+    ccipReadEnabled?: boolean;
+    chainId: number;
+    customData?: Record<string, any>;
+    data?: ethers.BytesLike;
+    from: string;
+    gasLimit?: ethers.BigNumberish;
+    gasPrice?: ethers.BigNumberish;
+    maxFeePerGas: ethers.BigNumberish;
+    maxPriorityFeePerGas: ethers.BigNumberish;
+    nonce?: ethers.BigNumberish;
+    r?: string;
+    s?: string;
+    to: string;
+    type?: number;
+    v?: string;
+    value?: ethers.BigNumberish;
+};
+export declare type Version = 'V1' | 'V2' | 'V3' | 'V4';
+export interface IEthereumTransactions {
+    cancelSentTransaction: (txHash: string, isLegacy?: boolean) => 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: TypedData | TypedMessage<any>, version: Version) => Promise<string>;
+    sendTransaction: (data: ISendTransaction) => Promise<TransactionResponse>;
+    importAccount: (mnemonicOrPrivKey: string) => ethers.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) => ethers.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: TypedData | TypedMessage<any>, signature: string, version: Version) => string;
+    setWeb3Provider: (network: INetwork) => void;
+    getRecommendedGasPrice: (formatted?: boolean) => Promise<string | {
+        ethers: string;
+        gwei: string;
+    }>;
+    web3Provider: CustomJsonRpcProvider | CustomL2JsonRpcProvider;
+    getTxGasLimit: (tx: SimpleTransactionRequest) => Promise<ethers.BigNumber>;
+}
+/**
+ * Error structure for Syscoin transaction operations.
+ * This interface documents the error format that consumers (like Pali) should expect
+ * when catching errors from ISyscoinTransactions methods.
+ *
+ * @example
+ * try {
+ *   const result = await syscoinTransaction.getEstimateSysTransactionFee({...});
+ * } catch (error: unknown) {
+ *   const sysError = error as ISyscoinTransactionError;
+ *   if (sysError.code === 'INSUFFICIENT_FUNDS') {
+ *     console.log(`Short by ${sysError.shortfall} SYS`);
+ *   }
+ * }
+ */
+export interface ISyscoinTransactionError {
+    error: boolean;
+    code: 'INSUFFICIENT_FUNDS' | 'INVALID_FEE_RATE' | 'INVALID_AMOUNT' | 'INVALID_MEMO' | 'INVALID_BLOB' | 'INVALID_OUTPUT_COUNT' | 'INVALID_ASSET_ALLOCATION' | 'INVALID_PARENT_NODES' | 'INVALID_TX_VALUE' | 'INVALID_RECEIPT_VALUE' | 'SUBTRACT_FEE_FAILED' | 'TRANSACTION_CREATION_FAILED' | 'TRANSACTION_SEND_FAILED';
+    message: string;
+    fee?: number;
+    remainingFee?: number;
+    shortfall?: number;
+    details?: {
+        inputTotal?: any;
+        outputTotal?: any;
+        requiredFee?: any;
+        message?: string;
+        markedOutputs?: number;
+        removedOutputs?: number;
+        guid?: string;
+    };
+}
+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;
+    }>;
+    getRecommendedFee: (explorerUrl: string) => Promise<number>;
+    decodeRawTransaction: (psbtOrHex: any, isRawHex?: boolean) => any;
+    sendTransaction: (psbt: any) => Promise<ITxid>;
+    signPSBT: ({ psbt, isTrezor, isLedger, pathIn, }: {
+        isLedger?: boolean;
+        isTrezor?: boolean;
+        pathIn?: string;
+        psbt: any;
+    }) => Promise<any>;
+}
+export interface IKeyringManager {
+    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;
+    importAccount: (privKey: string, label?: string) => 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: () => string;
+    getUTXOState: () => any;
+    importLedgerAccount: (label?: string) => Promise<IKeyringAccountState | undefined>;
+    getActiveUTXOAccountState: () => any;
+    createEthAccount: (privateKey: string) => any;
+    getAddress: (xpub: string, isChangeAddress: boolean) => Promise<string>;
+    initializeWalletSecurely: (seedPhrase: string, password: string, prvPassword?: string) => Promise<IKeyringAccountState>;
+    initializeSession: (seedPhrase: string, password: string) => Promise<void>;
+    createFirstAccount: (label?: string) => Promise<IKeyringAccountState>;
+    transferSessionTo: (targetKeyring: IKeyringManager) => void;
+    receiveSessionOwnership: (sessionPassword: any, sessionMnemonic: any) => void;
+    lockWallet: () => void;
+    setVaultStateGetter: (getter: () => any) => void;
+}
+export declare 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;
+}
+export {};

package/types/utils/derivation-paths.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 declare function getCoinInfo(coinShortcut: string, slip44: number): {
+    slip44: any;
+    segwit: any;
+    isEvm: boolean;
+};
+/**
+ * Determine if a coin is EVM-based (Ethereum-like)
+ */
+export declare function isEvmCoin(coinShortcut: string, slip44: number): boolean;
+/**
+ * Determine if a coin uses SegWit (BIP84 - m/84')
+ */
+export declare function isSegwitCoin(coinShortcut: string, slip44: number): boolean;
+/**
+ * Determine if a coin uses legacy derivation (BIP44 - m/44')
+ */
+export declare function isLegacyCoin(coinShortcut: string, slip44: number): boolean;
+/**
+ * Get the appropriate BIP standard for a coin
+ */
+export declare function getBipStandard(coinShortcut: string, slip44: number): number;
+/**
+ * Generate derivation path for account level (ending with account index)
+ * Example: m/84'/57'/0' for Syscoin account derivation
+ */
+export declare function getAccountDerivationPath(coinShortcut: string, slip44: number, accountIndex?: number): string;
+/**
+ * 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 declare function getAddressDerivationPath(coinShortcut: string, slip44: number, accountIndex?: number, isChangeAddress?: boolean, addressIndex?: number): string;

package/types/utils/psbt.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Utility functions for PSBT conversion between Pali and syscoinjs formats
+ */
+export declare 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;
+    /**
+     * 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;
+}

package/types/utils.d.ts

@@ -0,0 +1,4 @@
+export declare function checkError(method: string, error: any, params: any): any;
+export declare const SYSCOIN_BASIC_FEE = 0.00001;
+export declare const ONE_HUNDRED_MILLION = 100000000;
+export declare const BIP_84 = 84;