@sidhujag/sysweb3-keyring 1.0.627 → 2.0.0

package/types/ledger/host-types.d.ts

@@ -0,0 +1,131 @@
+/** Serializable Ledger requests. This module must remain free of device SDK imports. */
+export interface LedgerProgress {
+    status: 'not-started' | 'pending' | 'stopped' | 'completed' | 'error';
+    requiredUserInteraction?: string;
+    step?: string;
+}
+export interface LedgerOperationOptions {
+    signal?: AbortSignal;
+    onProgress?: (progress: LedgerProgress) => void;
+}
+export interface LedgerUtxoAccount {
+    currency: string;
+    slip44: number;
+    accountIndex: number;
+}
+export interface LedgerPartialSignature {
+    inputIndex: number;
+    pubkeyHex: string;
+    signatureHex: string;
+    tapleafHashHex?: string;
+}
+export interface LedgerTypedData {
+    domain: Record<string, unknown>;
+    types: Record<string, {
+        name: string;
+        type: string;
+    }[]>;
+    primaryType: string;
+    message: Record<string, unknown>;
+}
+export type LedgerBlindSigningIntent = Readonly<{
+    kind: 'transaction';
+    accountIndex: number;
+    derivationPath: string;
+    expectedAddress: string;
+    unsignedTxHex: string;
+    chainId: string;
+    digest: string;
+} | {
+    kind: 'typed-data';
+    accountIndex: number;
+    derivationPath: string;
+    expectedAddress: string;
+    version: 'V3' | 'V4';
+    data: LedgerTypedData;
+    digest: string;
+}>;
+/** Trusted host policy, never a field accepted from a dapp request. */
+export interface LedgerEvmConfig {
+    /**
+     * The public DSK may fall back to blind signing. The host must disclose that
+     * limitation and approve this exact intent each time. No callback means deny.
+     */
+    confirmBlindSigning?: (intent: LedgerBlindSigningIntent, signal: AbortSignal) => boolean | Promise<boolean>;
+}
+export interface LedgerEvmHost {
+    getAddress(request: {
+        accountIndex: number;
+        checkOnDevice?: boolean;
+        chainId?: number;
+    }, options?: LedgerOperationOptions): Promise<{
+        address: string;
+        publicKey: string;
+    }>;
+    signTransaction(request: {
+        accountIndex: number;
+        unsignedTxHex: string;
+        expectedAddress: string;
+    }, options?: LedgerOperationOptions): Promise<{
+        r: string;
+        s: string;
+        v: string;
+    }>;
+    signPersonalMessage(request: {
+        accountIndex: number;
+        messageHex: string;
+        expectedAddress: string;
+    }, options?: LedgerOperationOptions): Promise<string>;
+    signTypedData(request: {
+        accountIndex: number;
+        version: 'V3' | 'V4';
+        data: LedgerTypedData;
+        expectedAddress: string;
+    }, options?: LedgerOperationOptions): Promise<string>;
+}
+export interface LedgerUtxoHost {
+    getXpub(request: LedgerUtxoAccount & {
+        checkOnDevice?: boolean;
+    }, options?: LedgerOperationOptions): Promise<string>;
+    getAddress(request: LedgerUtxoAccount & {
+        checkOnDevice?: boolean;
+    }, options?: LedgerOperationOptions): Promise<string>;
+    getAccount(request: LedgerUtxoAccount & {
+        checkOnDevice?: boolean;
+    }, options?: LedgerOperationOptions): Promise<{
+        xpub: string;
+        fingerprint: string;
+        address: string;
+    }>;
+    signMessage(request: LedgerUtxoAccount & {
+        message: string;
+        addressIndex?: number;
+        change?: boolean;
+        accountXpub: string;
+    }, options?: LedgerOperationOptions): Promise<string>;
+    signPsbt(request: LedgerUtxoAccount & {
+        psbtBase64: string;
+        accountXpub: string;
+    }, options?: LedgerOperationOptions): Promise<{
+        fingerprint: string;
+        signatures: LedgerPartialSignature[];
+    }>;
+}
+/** The wallet authority injects this port; an absent host never opens a device. */
+export interface LedgerHost {
+    connect(request?: {
+        useGrantedDevices?: boolean;
+    }, options?: LedgerOperationOptions): Promise<void>;
+    disconnect(): Promise<void>;
+    getStatus(): {
+        connected: boolean;
+    };
+    readonly evm: LedgerEvmHost;
+    readonly utxo: LedgerUtxoHost;
+}
+export declare function ledgerHostError(code: string, message: string): Error & {
+    code: string;
+};
+export declare const ledgerCancelledError: () => Error & {
+    code: string;
+};

package/types/ledger/index.d.ts

@@ -1,62 +1,25 @@
-import Transport from '@ledgerhq/hw-transport';
-import SysUtxoClient from './bitcoin_client';
-import type { Psbt } from 'bitcoinjs-lib';
-import { IEvmMethods, IUTXOMethods } from './types';
-import LedgerEthClient from '@ledgerhq/hw-app-eth';
-import { HardwareWalletManager } from '../hardware-wallet-manager';
+import { ConnectionStatus, HardwareWalletType } from '../hardware-wallet-manager';
+import type { HardwareWalletManager } from '../hardware-wallet-manager';
+import type { LedgerHost, LedgerUtxoHost } from './host-types';
+import type { IEvmMethods, IUTXOMethods } from './types';
+/** Small authority-side facade. Device SDKs belong exclusively in ledger-host. */
 export declare class LedgerKeyring {
-    ledgerEVMClient: LedgerEthClient;
-    ledgerUtxoClient: SysUtxoClient;
-    private hdPath;
-    evm: IEvmMethods;
-    utxo: IUTXOMethods;
-    transport: Transport | null;
-    private hardwareWalletManager;
-    private walletHmacCache;
-    /**
-     * @param sharedHardwareWalletManager Optional shared HardwareWalletManager instance.
-     *                                     If provided, this will be used instead of creating
-     *                                     a new instance. This allows multiple KeyringManagers
-     *                                     to share the same Ledger connection.
-     */
-    constructor(sharedHardwareWalletManager?: HardwareWalletManager);
-    /**
-     * 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;
+    private readonly sharedHardwareWalletManager?;
+    private readonly host?;
+    readonly evm: IEvmMethods;
+    readonly utxo: IUTXOMethods;
+    private generation;
+    constructor(sharedHardwareWalletManager?: HardwareWalletManager | undefined, host?: LedgerHost | undefined);
+    private requireHost;
+    private run;
+    ensureConnection: () => Promise<void>;
     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 buildWalletCacheKey;
-    private getOrRegisterHmac;
-    private setHdPath;
-    /**
-     * Convert PSBT to Ledger format with retry logic
-     */
-    convertToLedgerFormat(psbt: Psbt, accountXpub: string, accountId: number, currency: string, slip44: number): Promise<Psbt>;
-    /**
-     * Execute operation with automatic retry
-     */
-    private executeWithRetry;
-    /**
-     * Get hardware wallet status
-     */
-    getStatus(): import("../hardware-wallet-manager").HardwareWalletStatus | undefined;
-    /**
-     * Clean up resources
-     */
+    signUtxoMessage: (request: Parameters<LedgerUtxoHost["signMessage"]>[0]) => Promise<string>;
+    signPsbt: (request: Parameters<LedgerUtxoHost["signPsbt"]>[0]) => ReturnType<LedgerUtxoHost["signPsbt"]>;
+    getStatus(): {
+        type: HardwareWalletType;
+        connected: boolean;
+        status: ConnectionStatus;
+    };
     destroy(): Promise<void>;
 }

package/types/ledger/prepare-psbt.d.ts

@@ -0,0 +1,3 @@
+import type { Psbt } from 'bitcoinjs-lib';
+/** Enrich public PSBT metadata only. Callers must also enforce account scope. */
+export declare function prepareLedgerPsbt(psbt: Psbt, accountXpub: string, accountId: number, currency: string, slip44: number, fingerprint: string): Psbt;

package/types/ledger/types.d.ts

@@ -30,6 +30,7 @@ export interface IEvmMethods {
     signEVMTransaction: ({ rawTx, accountIndex, }: {
         accountIndex: number;
         rawTx: string;
+        expectedAddress: string;
     }) => Promise<{
         r: string;
         s: string;
@@ -38,10 +39,12 @@ export interface IEvmMethods {
     signPersonalMessage: ({ message, accountIndex, }: {
         accountIndex: number;
         message: string;
+        expectedAddress: string;
     }) => Promise<string>;
     signTypedData: ({ version, data, accountIndex, }: {
         accountIndex: number;
         data: any;
+        expectedAddress: string;
         version: SignTypedDataVersion;
     }) => Promise<string>;
 }

package/types/ledger-host.d.ts

@@ -0,0 +1,7 @@
+import type { LedgerHost, LedgerEvmConfig } from './ledger/host-types';
+export interface LedgerDmkHostConfig extends LedgerEvmConfig {
+    /** Platform-owned DMK, allowing a future host to register its own transports. */
+    dmk?: object;
+}
+export declare function createLedgerDmkHost(config?: LedgerDmkHostConfig): LedgerHost;
+export type { LedgerEvmConfig, LedgerBlindSigningIntent, LedgerHost, LedgerEvmHost, LedgerUtxoHost, LedgerUtxoAccount, LedgerPartialSignature, LedgerTypedData, LedgerOperationOptions, LedgerProgress, } from './ledger/host-types';

package/types/software-hd-account.d.ts

@@ -0,0 +1,16 @@
+import type { IKeyringAccountState } from './types';
+/** Fixed Ethereum BIP44 address index; not an arbitrary derivation path. */
+export interface EvmHdRuntimeAccountRequest {
+    readonly index: number;
+}
+/** Trusted host guard must return undefined synchronously. */
+export interface EvmHdRuntimeAccountOptions {
+    assertCurrent: () => void;
+}
+/**
+ * Internal runtime record, matching createFirstAccount/addNewAccount. Contains a
+ * password-encrypted xprv; never publish it or persist it as a public catalogue.
+ * No plaintext private key, mnemonic, or password is returned.
+ */
+export type EncryptedEvmHdRuntimeAccount = IKeyringAccountState;
+export declare function snapshotEvmHdIndex(value: EvmHdRuntimeAccountRequest): number;

package/types/software.d.ts

@@ -0,0 +1,39 @@
+/** Software-only entry: explicit host storage, no browser/device initialization. */
+import { KeyringCore } from './keyring-core';
+import type { KeyringStoragePort } from './keyring-core';
+import type { EncryptedEvmHdRuntimeAccount, EvmHdRuntimeAccountOptions, EvmHdRuntimeAccountRequest } from './software-hd-account';
+import type { PreparedEvmSigningOptions, PreparedSoftwareEvmSigningRequest, SignedPreparedEvmTransaction } from './transactions/prepared-evm';
+declare const softwareHostBrand: unique symbol;
+/** Opaque handle minted by createSoftwareKeyringHost; no injectable persistence. */
+export interface SoftwareKeyringHost {
+    readonly [softwareHostBrand]: true;
+}
+/** Create once per wallet authority, then share with its per-network keyrings. */
+export declare const createSoftwareKeyringHost: (storage: KeyringStoragePort) => SoftwareKeyringHost;
+export declare class SoftwareKeyring extends KeyringCore<undefined, undefined> {
+    constructor(host: SoftwareKeyringHost);
+    /**
+     * Derive a fixed-path Ethereum HD runtime account without network or storage
+     * writes. The returned password-encrypted xprv is internal runtime state,
+     * never a public account/catalogue DTO. The host owns index allocation.
+     */
+    deriveEvmHdRuntimeAccount(request: EvmHdRuntimeAccountRequest, options: EvmHdRuntimeAccountOptions): Promise<EncryptedEvmHdRuntimeAccount>;
+    /**
+     * Sign exactly the prepared envelope without RPC, fee/nonce discovery or
+     * broadcasting. The host must journal the result before submitting it.
+     * A later lock cannot revoke already returned signed bytes.
+     */
+    signPreparedEvmTransaction(request: PreparedSoftwareEvmSigningRequest, options: PreparedEvmSigningOptions): SignedPreparedEvmTransaction;
+    /** Software authorities cannot rebind their backing store after creation. */
+    setStorage: (client: any) => never;
+    /** Sessions may move only through the core's same-authority transfer path. */
+    receiveSessionOwnership: (...session: Parameters<KeyringCore["receiveSessionOwnership"]>) => never;
+    static createInitialized(host: SoftwareKeyringHost, seed: string, password: string, vaultStateGetter: () => any): Promise<SoftwareKeyring>;
+}
+export { KeyringAccountType } from './types';
+export { INetworkType } from '@sidhujag/sysweb3-network';
+export type { INetwork } from '@sidhujag/sysweb3-network';
+export type { KeyringStoragePort } from './keyring-core';
+export type { IKeyringAccountState } from './types';
+export type { PreparedEvmTransaction, PreparedEvmSigningOptions, PreparedSoftwareEvmSigningRequest, SignedPreparedEvmTransaction, } from './transactions/prepared-evm';
+export type { EncryptedEvmHdRuntimeAccount, EvmHdRuntimeAccountOptions, EvmHdRuntimeAccountRequest, } from './software-hd-account';

package/types/storage-core.d.ts

@@ -0,0 +1,22 @@
+/** A host-owned namespace containing one wallet authority's logical records. */
+export interface VaultStoragePort {
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown): Promise<void>;
+    /** Atomically creates the entire batch only when every key is absent. */
+    createManyIfAbsent(items: Record<string, unknown>): Promise<boolean>;
+}
+export interface VaultPersistence {
+    setEncryptedVault(decryptedVault: any, pwd: string, freshVaultKeys?: {
+        salt: string;
+    }): Promise<void>;
+    getDecryptedVault(pwd: string, legacyPassword?: string): Promise<any>;
+}
+export declare class VaultAuthenticationError extends Error {
+    readonly code = "INVALID_PASSWORD";
+    constructor();
+}
+/**
+ * Create once per wallet authority and share across its network keyrings.
+ * The host owns storage durability and cross-context atomic creation.
+ */
+export declare const createVaultPersistence: (storage: VaultStoragePort) => VaultPersistence;

package/types/storage.d.ts

@@ -1,8 +1,5 @@
-export declare class VaultAuthenticationError extends Error {
-    readonly code = "INVALID_PASSWORD";
-    constructor();
-}
 export declare const setEncryptedVault: (decryptedVault: any, pwd: string, freshVaultKeys?: {
     salt: string;
 }) => Promise<void>;
 export declare const getDecryptedVault: (pwd: string, legacyPassword?: string) => Promise<any>;
+export { VaultAuthenticationError } from './storage-core';

package/types/transactions/ethereum.d.ts

@@ -1,15 +1,21 @@
 import { TypedMessage, SignTypedDataVersion, TypedDataV1 } from '@metamask/eth-sig-util';
 import { INetwork } from '@sidhujag/sysweb3-network';
 import { BigNumber, TransactionResponse } from '../ethers-v6';
-import { LedgerKeyring } from '../ledger';
 import { CustomJsonRpcProvider } from '../providers';
-import { TrezorKeyring } from '../trezor';
 import { IResponseFromSendErcSignedTransaction, ISendSignedErcTransactionProps, IEthereumTransactions, IEvmCancellationOptions, IEvmReplacementOptions, IEvmSendOptions, SimpleTransactionRequest, KeyringAccountType, accountType, IGasParams } from '../types';
-export declare class EthereumTransactions implements IEthereumTransactions {
+import type { LedgerKeyring } from '../ledger';
+import type { TrezorKeyring } from '../trezor';
+/** Minimal trusted device capabilities used by EVM transaction routing. */
+export interface EthereumLedgerSigner {
+    evm: Pick<LedgerKeyring['evm'], 'signTypedData' | 'signPersonalMessage' | 'signEVMTransaction'>;
+    verifyUtxoAddress: LedgerKeyring['verifyUtxoAddress'];
+}
+export type EthereumTrezorSigner = Pick<TrezorKeyring, 'signTypedData' | 'signMessage' | 'signEthTransaction' | 'verifyUtxoAddress'>;
+export declare class EthereumTransactions<TLedger extends EthereumLedgerSigner | undefined = LedgerKeyring, TTrezor extends EthereumTrezorSigner | undefined = TrezorKeyring> implements IEthereumTransactions {
     private _web3Provider;
     private _web3ProviderKey?;
-    trezorSigner: TrezorKeyring;
-    ledgerSigner: LedgerKeyring;
+    trezorSigner: TTrezor;
+    ledgerSigner: TLedger;
     private getNetwork;
     private captureSigningContext?;
     private abortController;
@@ -29,12 +35,15 @@ export declare class EthereumTransactions implements IEthereumTransactions {
         activeAccountId: number;
         activeAccountType: KeyringAccountType;
         activeNetwork: INetwork;
-    }, ledgerSigner: LedgerKeyring, trezorSigner: TrezorKeyring, captureSigningContext?: () => () => void);
+    }, ledgerSigner: TLedger, trezorSigner: TTrezor, captureSigningContext?: () => () => void);
+    private requireLedgerSigner;
+    private requireTrezorSigner;
+    private assertHardwareSignerAvailable;
     private captureEvmSigningContext;
     get web3Provider(): CustomJsonRpcProvider;
     private ensureProvidersInitialized;
     private isUtxoNetwork;
-    signTypedData: (addr: string, typedData: TypedDataV1 | TypedMessage<any>, version: SignTypedDataVersion) => Promise<any>;
+    signTypedData: (addr: string, typedData: TypedDataV1 | TypedMessage<any>, version: SignTypedDataVersion) => Promise<string>;
     verifyUtxoAddress: (accountIndex: number, currency: string, slip44: number) => Promise<string | undefined>;
     verifyTypedSignature: (data: TypedDataV1 | TypedMessage<any>, signature: string, version: SignTypedDataVersion) => string;
     ethSign: (params: string[]) => Promise<string>;
@@ -66,6 +75,7 @@ export declare class EthereumTransactions implements IEthereumTransactions {
     cancelSentTransaction: (txHash: string, isLegacy: boolean | undefined, fallbackNonce: number | undefined, options: IEvmCancellationOptions) => Promise<{
         error?: boolean;
         isCanceled: boolean;
+        maximumFee?: string;
         transaction?: TransactionResponse;
     }>;
     sendFormattedTransaction: (params: SimpleTransactionRequest, isLegacy?: boolean, options?: IEvmSendOptions) => Promise<any>;

package/types/transactions/evm-local-signer.d.ts

@@ -20,5 +20,7 @@ export declare const hashPersonalMessage: (message: Uint8Array) => string;
 export declare const signPersonalMessage: (message: string | Uint8Array, privateKey: string | Uint8Array) => string;
 export declare const parsePersonalMessage: (hexMessage: string) => string;
 export declare const signTransaction: (transaction: TransactionRequest, privateKey: string | Uint8Array) => string;
-export declare const sendLocalEvmTransaction: (provider: CustomJsonRpcProvider, privateKey: string, transaction: Deferrable<Record<string, any>>, beforeBroadcast?: () => void, beforeSign?: () => void) => Promise<any>;
+export declare const sendLocalEvmTransaction: (provider: CustomJsonRpcProvider, privateKey: string, transaction: Deferrable<Record<string, any>>, beforeBroadcast?: () => void, beforeSign?: () => void, 
+/** Synchronous final-envelope check; throw to reject. Promise results are rejected. */
+validateBeforeSign?: (transaction: TransactionRequest) => void) => Promise<any>;
 export declare const sameAddress: (left: string, right: string) => boolean;

package/types/transactions/hardware-psbt.d.ts

@@ -0,0 +1,7 @@
+import { type ISyscoinHardwareSigner } from './syscoin-core';
+import type { LedgerKeyring } from '../ledger';
+import type { TrezorKeyring } from '../trezor';
+/** Legacy device adapter. The software transaction engine never imports it. */
+export declare function createLedgerPsbtSigner(ledger: LedgerKeyring): ISyscoinHardwareSigner;
+/** Keep Trezor conversion and signing outside the software-only import graph. */
+export declare function createTrezorPsbtSigner(trezor: TrezorKeyring): ISyscoinHardwareSigner;

package/types/transactions/prepared-evm.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Fully specified type-0/type-2 transaction. Quantities are canonical decimal
+ * integer strings, nonce is at most MAX_SAFE_INTEGER, and gasLimit is uint64.
+ * Addresses must be nonzero hex addresses; valid casing is normalized. Data is
+ * even-length 0x hex, at most 16 KiB. Contract creation/access lists are omitted.
+ */
+export type PreparedEvmTransaction = Readonly<{
+    from: string;
+    to: string;
+    chainId: string;
+    nonce: string;
+    value: string;
+    gasLimit: string;
+    data: string;
+} & ({
+    type: 0;
+    gasPrice: string;
+} | {
+    type: 2;
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+})>;
+export type PreparedSoftwareEvmSigningRequest = Readonly<{
+    account: Readonly<{
+        id: number;
+        type: 'HDAccount' | 'Imported';
+        expectedAddress: string;
+    }>;
+    network: Readonly<{
+        kind: 'ethereum';
+        chainId: string;
+        slip44: 60;
+        /** Exact configured endpoint binding; signing does not contact or authenticate it. */
+        url: string;
+    }>;
+    transaction: PreparedEvmTransaction;
+}>;
+export type PreparedEvmSigningOptions = Readonly<{
+    /** Host-owned consent/session/review expiry check. Must return undefined. */
+    assertCurrent(): void;
+}>;
+export type SignedPreparedEvmTransaction = Readonly<{
+    rawTransaction: string;
+    hash: string;
+    unsignedHash: string;
+    from: string;
+    /** Canonical signed fields, checked against the requested envelope. */
+    transaction: PreparedEvmTransaction;
+}>;
+export declare function snapshotPreparedEvmRequest(input: unknown): PreparedSoftwareEvmSigningRequest;
+export declare function preparedEvmGuard(input: unknown): () => void;
+/** Internal, network-free signing. The key never becomes part of the result. */
+export declare function signPreparedEvmEnvelope(transaction: PreparedEvmTransaction, privateKey: string): SignedPreparedEvmTransaction;

package/types/transactions/syscoin-core.d.ts

@@ -0,0 +1,92 @@
+import { ITxid, txUtils } from '@sidhujag/sysweb3-utils';
+import { Psbt } from 'bitcoinjs-lib';
+import { ISyscoinTransactions, KeyringAccountType, accountType } from '../types';
+import { ExcludedOutpoint } from '../utils/excluded-utxos';
+import { type PsbtAccountScope } from '../utils/psbt-account-scope';
+import type { SyscoinHDSigner } from '../signers';
+import type { INetwork } from '@sidhujag/sysweb3-network';
+/** A hardware operation receives only its selected public account/context. */
+export interface ISyscoinHardwareSigningRequest {
+    readonly account: Readonly<{
+        id: number;
+        xpub: string;
+    }>;
+    assertCurrent: () => void;
+    getRawTransaction?: ReturnType<typeof txUtils>['getRawTransaction'];
+    readonly network: Readonly<INetwork>;
+    psbt: Psbt;
+    scope: PsbtAccountScope;
+}
+/**
+ * Trusted wallet-authority adapter, not an untrusted plugin entry point.
+ * Implementations must preserve the reviewed unsigned transaction and enforce
+ * device signature/account-scope validation before returning the signed PSBT.
+ */
+export type ISyscoinHardwareSigner = (request: ISyscoinHardwareSigningRequest) => Promise<Psbt>;
+export interface ISyscoinHardwareSigners {
+    ledger?: ISyscoinHardwareSigner;
+    trezor?: ISyscoinHardwareSigner;
+}
+export declare const createHardwareSignerUnavailableError: (hardware: string) => Error & {
+    code: string;
+};
+export declare class SyscoinTransactionsCore implements ISyscoinTransactions {
+    private getSigner;
+    private getReadOnlySigner;
+    private hardwareSigners;
+    private getState;
+    private getAddress;
+    private captureSigningContext?;
+    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>, hardwareSigners?: ISyscoinHardwareSigners, captureSigningContext?: () => () => void);
+    private getTransactionPSBT;
+    decodeRawTransaction: (psbtOrHex: any, isRawHex?: boolean) => any;
+    private feeCache;
+    getRecommendedFee: (explorerUrl: string) => Promise<number>;
+    txUtilsFunctions: () => {
+        getRawTransaction: (explorerUrl: string, txid: string) => Promise<any>;
+    };
+    private signPSBTWithSigner;
+    private createNativeSweepPSBT;
+    private createUnsignedPSBT;
+    private signPSBTWithMethod;
+    getEstimateSysTransactionFee: ({ txOptions, isMax, nativeSweep, amount, receivingAddress, feeRate, token, excludedOutpoints, }: {
+        amount: number | string;
+        feeRate?: number;
+        receivingAddress: string;
+        token?: {
+            guid: string;
+            symbol?: string;
+        } | null;
+        txOptions?: any;
+        isMax?: boolean | false;
+        nativeSweep?: boolean;
+        excludedOutpoints?: readonly ExcludedOutpoint[];
+    }) => Promise<{
+        grossAmount?: string | undefined;
+        recipientAmount?: string | undefined;
+        fee: number;
+        psbt: any;
+    }>;
+    private sendSignedTransaction;
+    signPSBT: ({ psbt, isTrezor, isLedger, }: {
+        psbt: any;
+        isTrezor?: boolean;
+        isLedger?: boolean;
+    }) => Promise<any>;
+    sendTransaction: (psbt: any) => Promise<ITxid>;
+}

package/types/transactions/syscoin.d.ts

@@ -1,68 +1,9 @@
-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';
-import { ExcludedOutpoint } from '../utils/excluded-utxos';
-export declare class SyscoinTransactions implements ISyscoinTransactions {
-    private getSigner;
-    private getReadOnlySigner;
-    private trezor;
-    private ledger;
-    private getState;
-    private getAddress;
-    private captureSigningContext?;
-    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, captureSigningContext?: () => () => void);
-    private getTransactionPSBT;
-    decodeRawTransaction: (psbtOrHex: any, isRawHex?: boolean) => any;
-    private feeCache;
-    getRecommendedFee: (explorerUrl: string) => Promise<number>;
-    txUtilsFunctions: () => {
-        getRawTransaction: (explorerUrl: string, txid: string) => Promise<any>;
-    };
-    private signPSBTWithSigner;
-    private createNativeSweepPSBT;
-    private createUnsignedPSBT;
-    private signPSBTWithMethod;
-    getEstimateSysTransactionFee: ({ txOptions, isMax, nativeSweep, amount, receivingAddress, feeRate, token, excludedOutpoints, }: {
-        amount: number | string;
-        feeRate?: number;
-        receivingAddress: string;
-        token?: {
-            guid: string;
-            symbol?: string;
-        } | null;
-        txOptions?: any;
-        isMax?: boolean | false;
-        nativeSweep?: boolean;
-        excludedOutpoints?: readonly ExcludedOutpoint[];
-    }) => Promise<{
-        grossAmount?: string | undefined;
-        recipientAmount?: string | undefined;
-        fee: number;
-        psbt: any;
-    }>;
-    private sendSignedTransaction;
-    signPSBT: ({ psbt, isTrezor, isLedger, }: {
-        psbt: any;
-        isTrezor?: boolean;
-        isLedger?: boolean;
-    }) => Promise<any>;
-    sendTransaction: (psbt: any) => Promise<ITxid>;
+import { SyscoinTransactionsCore } from './syscoin-core';
+import type { LedgerKeyring } from '../ledger';
+import type { TrezorKeyring } from '../trezor';
+type CoreArguments = ConstructorParameters<typeof SyscoinTransactionsCore>;
+/** Legacy constructor: preserve device arguments while composing shared logic. */
+export declare class SyscoinTransactions extends SyscoinTransactionsCore {
+    constructor(getSyscoinSigner: CoreArguments[0], getReadOnlySigner: CoreArguments[1], getState: CoreArguments[2], getAddress: CoreArguments[3], ledgerSigner: LedgerKeyring, trezorSigner: TrezorKeyring, captureSigningContext?: CoreArguments[5]);
 }
+export {};