@sidhujag/sysweb3-keyring 2.1.6 → 2.1.8

package/types/keyring-manager.d.ts

@@ -1,15 +1,17 @@
 import { HardwareWalletManager } from './hardware-wallet-manager';
-import { KeyringCore } from './keyring-core';
+import { HostKeyring } from './host-keyring';
 import { LedgerKeyring } from './ledger';
 import { TrezorKeyring } from './trezor';
 import type { KeyringHost, KeyringOptions } from './keyring-host';
 import type { LedgerHost } from './ledger/host-types';
 import type { CaptureEvmSubmission } from './transactions/evm-submission';
+import type { TrezorHost } from './trezor/host-types';
 import type { IKeyringManager } from './types';
 export type { ISysAccount } from './keyring-core';
-export type { DeviceUnlockControls, DeviceUnlockPort, DeviceUnlockVaultPair, KeyringStoragePort, } from './keyring-core';
+export type { DeviceUnlockControls, DeviceUnlockPort, DeviceUnlockVaultPair, KeyringStoragePort, PreparedSessionTransfer, } from './keyring-core';
 export type KeyringManagerOptions = Omit<KeyringOptions, 'captureEvmSubmission'> & {
     captureEvmSubmission: CaptureEvmSubmission;
+    trezorHost: TrezorHost;
 } & ({
     ledgerHost: LedgerHost;
     hardwareManager?: never;
@@ -18,7 +20,7 @@ export type KeyringManagerOptions = Omit<KeyringOptions, 'captureEvmSubmission'>
     hardwareManager: HardwareWalletManager;
 });
 /** Browser keyring with an explicit wallet authority and hardware adapter. */
-export declare class KeyringManager extends KeyringCore<LedgerKeyring, TrezorKeyring> implements IKeyringManager {
+export declare class KeyringManager extends HostKeyring<LedgerKeyring, TrezorKeyring> implements IKeyringManager {
     constructor(host: KeyringHost, options: KeyringManagerOptions);
     static createInitialized(host: KeyringHost, seed: string, password: string, vaultStateGetter: () => any, options: KeyringManagerOptions): Promise<KeyringManager>;
 }

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

@@ -1,5 +1,7 @@
 import { type LedgerEvmConfig, type LedgerHost } from './host-types';
 export interface LedgerDmkHost extends LedgerHost {
+    /** Observe connection changes; read getStatus() in the callback. */
+    subscribeStatus(listener: () => void): () => void;
     /** Start before enumerating. The returned capability is single use. */
     beginDeviceSelection(signal?: AbortSignal): (candidate: object) => Promise<void>;
 }

package/types/ledger/dmk-session.d.ts

@@ -37,16 +37,22 @@ export declare class LedgerDmkSession {
     private activeCancel;
     private activeAbort;
     private closing;
+    private closingResult;
+    private readonly closeObservers;
     private stateSubscription;
     private connectionAttempt;
     private connectionAbort;
     private deviceSelection;
     private readonly invalidationListeners;
+    private readonly statusListeners;
+    private reportedConnected;
     constructor(dmk: DeviceManagementKit, requireDeviceSelection?: boolean);
     private get readyConnection();
     getStatus(): {
         connected: boolean;
     };
+    subscribeStatus(listener: () => void): () => void;
+    private publishStatus;
     onInvalidated(listener: () => void): () => void;
     private invalidate;
     /** The platform passes one candidate from its own current DMK picker. */
@@ -61,6 +67,9 @@ export declare class LedgerDmkSession {
     private connectDevice;
     /** Cancel revokes the result and closes I/O; it cannot undo on-device approval. */
     disconnect(): Promise<void>;
+    private closeSession;
+    /** Join late vendor admission and its cleanup after immediate revocation. */
+    retire(): Promise<() => void>;
     runExclusive<Output>(operation: (session: LedgerDmkOperation) => Promise<Output>, options?: LedgerOperationOptions): Promise<Output>;
     runAction<Output>(createAction: (session: LedgerDmkOperation) => Action<Output>, options?: LedgerOperationOptions): Promise<Output>;
     private awaitAction;

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

@@ -120,6 +120,8 @@ export interface LedgerHost {
         useGrantedDevices?: boolean;
     }, options?: LedgerOperationOptions): Promise<void>;
     disconnect(): Promise<void>;
+    /** Complete cleanup and return a guard invalidated by any subsequent reopen. */
+    retire(): Promise<() => void>;
     getStatus(): {
         connected: boolean;
     };

package/types/ledger/index.d.ts

@@ -1,4 +1,4 @@
-import { ConnectionStatus, HardwareWalletType } from '../hardware-wallet-manager';
+import { ConnectionStatus, HardwareWalletType } from '../hardware-wallet-types';
 import type { HardwareWalletManager } from '../hardware-wallet-manager';
 import type { LedgerHost, LedgerUtxoHost } from './host-types';
 import type { IEvmMethods, IUTXOMethods } from './types';
@@ -22,4 +22,6 @@ export declare class LedgerKeyring {
         status: ConnectionStatus;
     };
     destroy(): Promise<void>;
+    /** Complete teardown and prove that no shared-host operation has reopened it. */
+    retire(): Promise<() => void>;
 }

package/types/ledger-hardware.d.ts

@@ -0,0 +1,5 @@
+import { LedgerKeyring } from './ledger';
+import type { KeyringHardware } from './keyring-core';
+import type { LedgerHost } from './ledger/host-types';
+/** Use the same Ledger account and transaction adapters on every host. */
+export declare function createLedgerHardware(host: LedgerHost): KeyringHardware<LedgerKeyring, undefined>;

package/types/software.d.ts

@@ -1,22 +1,8 @@
 /** Software-only entry: explicit host storage, no browser/device initialization. */
-import { KeyringCore } from './keyring-core';
+import { HostKeyring } from './host-keyring';
 import type { KeyringHost, KeyringOptions } from './keyring-host';
-import type { EncryptedEvmHdRuntimeAccount, EvmHdRuntimeAccountOptions, EvmHdRuntimeAccountRequest } from './software-hd-account';
-import type { PreparedEvmSigningOptions, PreparedSoftwareEvmSigningRequest, SignedPreparedEvmTransaction } from './transactions/prepared-evm';
-export declare class SoftwareKeyring extends KeyringCore<undefined, undefined> {
+export declare class SoftwareKeyring extends HostKeyring<undefined, undefined> {
     constructor(host: KeyringHost, options: KeyringOptions);
-    /**
-     * 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;
     static createInitialized(host: KeyringHost, seed: string, password: string, vaultStateGetter: () => any, options: KeyringOptions): Promise<SoftwareKeyring>;
 }
 export { createKeyringHost } from './keyring-host';
@@ -26,7 +12,8 @@ export { INetworkType } from '@sidhujag/sysweb3-network';
 export type { INetwork } from '@sidhujag/sysweb3-network';
 export type { DeviceUnlockControls, DeviceUnlockCredential, DeviceUnlockPort, DeviceUnlockVaultPair, KeyringStoragePort, } from './keyring-core';
 export type { EvmRetainedCancellationOrigin, IKeyringAccountState, SyscoinOwnedReadOptions, SyscoinOwnedSubmissionOptions, SyscoinSubmissionDescriptor, } from './types';
-export type { PreparedEvmTransaction, PreparedEvmSigningOptions, PreparedSoftwareEvmSigningRequest, SignedPreparedEvmTransaction, } from './transactions/prepared-evm';
+export type { EvmAccessList, PreparedEvmTransaction, } from './transactions/evm-envelope';
+export type { PreparedEvmSigningOptions, PreparedSoftwareEvmSigningRequest, SignedPreparedEvmTransaction, } from './transactions/prepared-evm';
 export type { EncryptedEvmHdRuntimeAccount, EvmHdRuntimeAccountOptions, EvmHdRuntimeAccountRequest, } from './software-hd-account';
 export { captureEvmSubmission, submitSignedEvmTransaction, evmSubmissionFailure, } from './transactions/evm-submission';
 export type { CaptureEvmSubmission, EvmSubmissionContext, EvmSubmissionLifecycle, EvmSignedSubmission, EvmSubmissionBoundary, } from './transactions/evm-submission';

package/types/transactions/ethereum.d.ts

@@ -4,7 +4,9 @@ import { BigNumber, TransactionResponse } from '../ethers-v6';
 import { type EvmFeeReader } from '../evm-fees';
 import { CustomJsonRpcProvider } from '../providers';
 import { IResponseFromSendErcSignedTransaction, ISendSignedErc20TransactionProps, ISendSignedErc721TransactionProps, ISendSignedErc1155TransactionProps, IReviewedEvmTokenApproval, IEthereumTransactions, IEvmCancellationOptions, IEvmReplacementOptions, EvmFormattedSendArguments, SimpleTransactionRequest, KeyringAccountType, accountType, IGasParams } from '../types';
+import { type PreparedEvmTransaction } from './evm-envelope';
 import { type CaptureEvmSubmission } from './evm-submission';
+import { type EvmDigestSignOptions, type PreparedSoftwareEvmSigningRequest, type PreparedEvmSigningOptions } from './prepared-evm';
 import type { LedgerKeyring } from '../ledger';
 import type { TrezorKeyring } from '../trezor';
 /** Minimal trusted device capabilities used by EVM transaction routing. */
@@ -43,6 +45,7 @@ export declare class EthereumTransactions<TLedger extends EthereumLedgerSigner |
     private requireTrezorSigner;
     private assertHardwareSignerAvailable;
     private captureSessionGuard;
+    private captureEvmAccountContext;
     private captureEvmSigningContext;
     private captureSubmission;
     private authorizeHardwareTransaction;
@@ -52,7 +55,14 @@ export declare class EthereumTransactions<TLedger extends EthereumLedgerSigner |
     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>;
+    signPreparedEvmTransaction(input: PreparedSoftwareEvmSigningRequest, options: PreparedEvmSigningOptions): Readonly<{
+        rawTransaction: string;
+        hash: string;
+        unsignedHash: string;
+        from: string;
+        transaction: PreparedEvmTransaction;
+    }>;
+    ethSign: (params: string[], input: EvmDigestSignOptions) => Promise<string>;
     signPersonalMessage: (params: string[]) => Promise<string>;
     parsePersonalMessage: (hexMsg: string) => string;
     verifyPersonalMessage: (message: string, sign: string) => string;

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

@@ -0,0 +1,64 @@
+export type EvmAccessList = readonly Readonly<{
+    address: string;
+    storageKeys: readonly string[];
+}>[];
+/**
+ * Fully specified type-0/type-2 transaction. Quantities are canonical decimal
+ * integer strings, nonce is at most MAX_SAFE_INTEGER, and gasLimit is uint64.
+ * The sender is a nonzero hex address. A null destination creates a contract.
+ * Data is even-length 0x hex, at most 512 KiB. Type 2 requires an access list.
+ */
+export type PreparedEvmTransaction = Readonly<{
+    from: string;
+    to: string | null;
+    chainId: string;
+    nonce: string;
+    value: string;
+    gasLimit: string;
+    data: string;
+} & ({
+    type: 0;
+    gasPrice: string;
+} | {
+    type: 2;
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+    accessList: EvmAccessList;
+})>;
+/** Snapshot values without invoking accessors or accepting hidden fields. */
+/** @internal Strict own-data snapshot shared with prepared request binding. */
+export declare function readEvmOwnData(value: unknown, keys: readonly string[]): Record<string, unknown>;
+/** Copy bounded own data while preserving the signed order and duplicates. */
+export declare function snapshotEvmAccessList(value: unknown): EvmAccessList;
+export declare function snapshotPreparedEvmTransaction(input: unknown): PreparedEvmTransaction;
+/** @internal The same validated fields feed unsigned serialization and signing. */
+export declare function prepareUnsignedEvmEnvelope(input: PreparedEvmTransaction): {
+    transaction: PreparedEvmTransaction;
+    unsigned: {
+        gasPrice: bigint;
+        type: 0 | 2;
+        to: string | null;
+        chainId: bigint;
+        nonce: number;
+        value: bigint;
+        gasLimit: bigint;
+        data: string;
+    } | {
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+        accessList: {
+            address: string;
+            storageKeys: string[];
+        }[];
+        type: 0 | 2;
+        to: string | null;
+        chainId: bigint;
+        nonce: number;
+        value: bigint;
+        gasLimit: bigint;
+        data: string;
+    };
+    expectedUnsigned: string;
+};
+/** Validate and serialize the exact envelope used by prepared signing. */
+export declare function serializePreparedEvmTransaction(transaction: PreparedEvmTransaction): string;

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

@@ -15,6 +15,11 @@ export type EvmSubmissionContext = Readonly<{
     operation: 'send' | 'cancel' | 'speed-up' | 'erc20' | 'erc721' | 'erc1155';
     originalHash?: string;
     origin?: EvmRetainedCancellationOrigin;
+    /** Transient identity of the live host fee review, bound to these signed bytes. */
+    review?: Readonly<{
+        id: string;
+        unsignedHash: string;
+    }>;
     walletNonce?: EvmWalletNonce;
 }>;
 /** Signed wire bytes only; never a key, password or mutable transaction request. */
@@ -54,11 +59,11 @@ export type EvmSubmissionBoundary = Readonly<{
 export declare function captureEvmSubmission(input: EvmSubmissionContext, assertCurrent: () => void, capture: CaptureEvmSubmission): EvmSubmissionBoundary;
 /** Refuse any new signature or dispatch without a captured durable port. */
 export declare function assertDurableEvmSubmission(boundary: EvmSubmissionBoundary): void;
-/** Only local stage evidence can label an error as a possibly dispatched send. */
+/** Return owned stage evidence only; unrecognized errors carry no classification. */
 export declare function evmSubmissionFailure(error: unknown): Readonly<{
     transactionNotBroadcast: boolean;
     signedTransactionHash?: string;
-}>;
+}> | undefined;
 /** Preserve local evidence when an existing public API wraps its Error object. */
 export declare function copyEvmSubmissionFailure(source: unknown, target: Error): void;
 /** Compare signed wire bytes with the complete envelope captured before signing. */

package/types/transactions/ledger-signing.d.ts

@@ -0,0 +1,13 @@
+import type { HardwareTransactionAuthority } from '../hardware-transaction-authority';
+import type { IEvmMethods } from '../ledger/types';
+/** Sign the reviewed bytes through the shared Ledger adapter without changing fees or nonce. */
+export declare function signLedgerEvmTransaction(signer: {
+    evm: Pick<IEvmMethods, 'signEVMTransaction'>;
+}, request: Readonly<{
+    accountIndex: number;
+    expectedAddress: string;
+    unsignedTransaction: string;
+}>, authority: HardwareTransactionAuthority): Promise<Readonly<{
+    rawTransaction: string;
+    hash: string;
+}>>;

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

@@ -1,26 +1,17 @@
-/**
- * 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;
-})>;
+import type { PreparedEvmTransaction } from './evm-envelope';
+export type EvmSigningIdentity = Readonly<{
+    id: number;
+    type: 'HDAccount' | 'Imported' | 'Ledger' | 'Trezor' | 'SmartAccount';
+    expectedAddress: string;
+}>;
+export declare function snapshotEvmSigningIdentity(input: unknown): EvmSigningIdentity;
+export type EvmDigestSignOptions = Readonly<{
+    selectedAccount: EvmSigningIdentity;
+    targetAccount: EvmSigningIdentity;
+    assertCurrent(): void;
+}>;
 export type PreparedSoftwareEvmSigningRequest = Readonly<{
+    selectedAccount: EvmSigningIdentity;
     account: Readonly<{
         id: number;
         type: 'HDAccount' | 'Imported';
@@ -50,7 +41,7 @@ export type SignedPreparedEvmTransaction = Readonly<{
 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): Readonly<{
+export declare function signPreparedEvmEnvelope(input: PreparedEvmTransaction, privateKey: string): Readonly<{
     signed: SignedPreparedEvmTransaction;
     expectedUnsigned: string;
 }>;

package/types/trezor/connect.d.ts

@@ -1,8 +1,8 @@
 import type { HardwareTransactionAuthority } from '../hardware-transaction-authority';
-import type { ConnectDynamicSettings, TrezorConnectPublicAPI } from '@trezor/connect-webextension';
-type Client = TrezorConnectPublicAPI<ConnectDynamicSettings>;
-declare const methods: readonly ["getFeatures", "getAccountInfo", "ethereumGetAddress", "ethereumGetPublicKey", "getPublicKey", "getAddress", "signMessage", "ethereumSignMessage", "ethereumSignTypedData", "verifyMessage", "ethereumVerifyMessage"];
-type ForwardedMethod = (typeof methods)[number];
+import type { TrezorCalls, TrezorHost, TrezorMethod } from './host-types';
+type Client = TrezorCalls;
+type TransactionMethod = 'ethereumSignTransaction' | 'signTransaction';
+type ForwardedMethod = Exclude<TrezorMethod, TransactionMethod>;
 type Compatible<T> = T extends {
     success: false;
 } ? T & {
@@ -23,23 +23,25 @@ type CompatibleCall<FunctionType> = FunctionType extends {
 type Calls = {
     [Name in ForwardedMethod]: CompatibleCall<Client[Name]>;
 };
-type ConnectionEvent = {
+export type ConnectionEvent = {
     type: 'disconnected';
 } | {
     type: 'model';
     model: string;
 };
-export declare const subscribeTrezorEvents: (listener: (event: ConnectionEvent) => void) => (() => void);
-declare const TrezorConnect: Calls & {
+export type TrezorConnection = Calls & {
     ethereumSignTransactionOwned: (request: Parameters<Client['ethereumSignTransaction']>[0], authority: HardwareTransactionAuthority) => ReturnType<CompatibleCall<Client['ethereumSignTransaction']>>;
     signTransactionOwned: (request: Parameters<Client['signTransaction']>[0], authority: HardwareTransactionAuthority) => ReturnType<CompatibleCall<Client['signTransaction']>>;
-    init: Client['init'];
+    init: () => Promise<void>;
     dispose: () => Promise<void>;
+    retire: () => Promise<() => void>;
+    subscribe(listener: (event: ConnectionEvent) => void): () => void;
 };
+export declare function createTrezorConnection(host: TrezorHost): TrezorConnection;
 export declare const trezorResponseError: (response: {
     payload?: {
         error?: string;
         code?: string;
     };
 }, prefix?: string) => Error;
-export default TrezorConnect;
+export {};

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

@@ -0,0 +1,25 @@
+import type { ConnectDynamicSettings, TrezorConnectPublicAPI } from '@trezor/connect-webextension';
+export declare const TREZOR_METHODS: readonly ["getFeatures", "getAccountInfo", "ethereumGetAddress", "ethereumGetPublicKey", "getPublicKey", "getAddress", "signMessage", "ethereumSignMessage", "ethereumSignTypedData", "verifyMessage", "ethereumVerifyMessage", "ethereumSignTransaction", "signTransaction"];
+export type TrezorMethod = (typeof TREZOR_METHODS)[number];
+export type TrezorCalls = Pick<TrezorConnectPublicAPI<ConnectDynamicSettings>, TrezorMethod>;
+type GuardedCall<Call> = Call extends {
+    (...args: infer A): infer R;
+    (...args: infer B): infer S;
+    (...args: infer C): infer T;
+} ? {
+    (assertCurrent: () => void, ...args: A): R;
+    (assertCurrent: () => void, ...args: B): S;
+    (assertCurrent: () => void, ...args: C): T;
+} : never;
+/** Recheck after asynchronous preparation and immediately before device I/O. */
+export type TrezorHostCalls = {
+    [Method in TrezorMethod]: GuardedCall<TrezorCalls[Method]>;
+};
+/** One explicitly owned client. This contract imports no platform runtime. */
+export type TrezorHost = TrezorHostCalls & {
+    /** Check after asynchronous preparation and immediately before prompting. */
+    init(assertCurrent: () => void): Promise<void>;
+    /** Retire this host's client according to its platform cleanup requirements. */
+    dispose(pendingCalls: readonly Promise<unknown>[]): Promise<void>;
+};
+export {};

package/types/trezor/index.d.ts

@@ -2,17 +2,14 @@ import { TypedMessage, SignTypedDataVersion, TypedDataV1 } from '@metamask/eth-s
 import { Psbt } from 'bitcoinjs-lib';
 import { Buffer } from 'buffer';
 import type { HardwareTransactionAuthority } from '../hardware-transaction-authority';
+import type { TrezorConnection } from './connect';
 import type { AccountInfo, EthereumTransaction, EthereumTransactionEIP1559 } from '@trezor/connect-webextension';
 export interface TrezorControllerState {
     hdPath: string;
     paths: Record<string, number>;
 }
-declare global {
-    interface Window {
-        TrezorConnect: any;
-    }
-}
 export declare class TrezorKeyring {
+    private readonly connection;
     hdPath: string;
     publicKey: Buffer;
     chainCode: Buffer;
@@ -21,10 +18,11 @@ export declare class TrezorKeyring {
     private hardwareWalletManager;
     private initialized;
     private lifecycleGeneration;
+    private retirementEpoch;
     private unsubscribeTrezor?;
     private readonly onTrezorConnected;
     private readonly onTrezorDisconnected;
-    constructor();
+    constructor(connection: TrezorConnection);
     private observeTrezor;
     /**
      * Initialize Trezor script.
@@ -177,9 +175,11 @@ export declare class TrezorKeyring {
     /**
      * Check Trezor status
      */
-    getStatus(): import("../hardware-wallet-manager").HardwareWalletStatus | undefined;
+    getStatus(): import("../hardware-wallet-types").HardwareWalletStatus | undefined;
     /**
      * Clean up resources
      */
     destroy(): Promise<void>;
+    /** Wait for the old device call and transport ownership to be fully retired. */
+    retire(): Promise<() => void>;
 }

package/types/trezor/webextension-host.d.ts

@@ -0,0 +1,7 @@
+import type { TrezorHost } from './host-types';
+import type { ConnectDynamicSettings, TrezorConnectPublicAPI } from '@trezor/connect-webextension';
+type Client = TrezorConnectPublicAPI<ConnectDynamicSettings>;
+export type TrezorWebExtensionSettings = Parameters<Client['init']>[0];
+/** Explicit browser composition. The shared signer never loads this module. */
+export declare function createTrezorWebExtensionHost(settings: TrezorWebExtensionSettings): TrezorHost;
+export {};

package/types/trezor-hardware.d.ts

@@ -0,0 +1,6 @@
+import { TrezorKeyring } from './trezor';
+import type { KeyringHardware } from './keyring-core';
+import type { TrezorHost } from './trezor/host-types';
+/** Use the same Trezor account and transaction adapters on every host. */
+export declare function createTrezorHardware(host: TrezorHost): KeyringHardware<undefined, TrezorKeyring>;
+export type { TrezorHost } from './trezor/host-types';

package/types/types.d.ts

@@ -7,8 +7,8 @@ import { LedgerKeyring } from './ledger';
 import { IDecryptPrivateRecordParams, IEncryptedPrivateRecord, IEncryptPrivateRecordParams } from './private-records';
 import { SyscoinHDSigner } from './signers';
 import { TrezorKeyring } from './trezor';
-import type { KeyringCore } from './keyring-core';
-import type { PreparedEvmTransaction } from './transactions/prepared-evm';
+import type { KeyringCore, PreparedSessionTransfer } from './keyring-core';
+import type { PreparedEvmTransaction } from './transactions/evm-envelope';
 import type { OwnedUtxoRpcVerification } from '@sidhujag/sysweb3-network';
 export type AccessListish = Array<{
     address: string;
@@ -43,12 +43,22 @@ export type EvmWalletNonce = Readonly<{
     source: 'automatic' | 'manual';
 }>;
 export interface IEvmSendOptions {
+    selectedAccount: import('./transactions/prepared-evm').EvmSigningIdentity;
+    targetAccount: import('./transactions/prepared-evm').EvmSigningIdentity;
     /** Synchronous host admission, rechecked immediately before signing and broadcast. */
     assertCurrent: () => void;
-    mode: 'reviewed-native' | 'specialized';
+    mode: 'reviewed-native' | 'reviewed-generic' | 'specialized';
     walletNonce?: EvmWalletNonce;
 }
 export type EvmFormattedSendArguments = [
+    approvedTransaction: PreparedEvmTransaction,
+    isLegacy: boolean | undefined,
+    options: IEvmSendOptions & {
+        mode: 'reviewed-generic';
+        reviewId: string;
+        walletNonce: EvmWalletNonce;
+    }
+] | [
     approvedTransaction: PreparedEvmTransaction,
     isLegacy: boolean | undefined,
     options: IEvmSendOptions & {
@@ -115,7 +125,8 @@ export interface IEthereumTransactions {
         transaction?: TransactionResponse;
     }>;
     decryptMessage: (msgParams: string[]) => string;
-    ethSign: (params: string[]) => Promise<string>;
+    ethSign: (params: string[], options: import('./transactions/prepared-evm').EvmDigestSignOptions) => Promise<string>;
+    signPreparedEvmTransaction: (request: import('./transactions/prepared-evm').PreparedSoftwareEvmSigningRequest, options: import('./transactions/prepared-evm').PreparedEvmSigningOptions) => import('./transactions/prepared-evm').SignedPreparedEvmTransaction;
     getBalance: (address: string) => Promise<number>;
     getEncryptedPubKey: () => string;
     getErc20TokensByAddress?: (address: string, isSupported: boolean, apiUrl: string) => Promise<any[]>;
@@ -233,6 +244,7 @@ export interface IKeyringManager {
         needsAccountCreation?: boolean;
     }>;
     isUnlocked: () => boolean;
+    captureUnlockedSessionGuard: () => () => void;
     logout: () => void;
     ledgerSigner: LedgerKeyring;
     trezorSigner: TrezorKeyring;
@@ -283,7 +295,7 @@ export interface IKeyringManager {
     initializeWalletSecurely: (seedPhrase: string, password: string, prvPassword?: string) => Promise<IKeyringAccountState>;
     initializeSession: (seedPhrase: string, password: string) => Promise<void>;
     createFirstAccount: (label?: string) => Promise<IKeyringAccountState>;
-    transferSessionTo: (targetKeyring: KeyringCore) => void;
+    prepareSessionTransfer: (targetKeyring: KeyringCore, assertCurrent: () => void) => Promise<PreparedSessionTransfer>;
     lockWallet: () => Promise<void>;
     setVaultStateGetter: (getter: () => any) => void;
 }