@sidhujag/sysweb3-keyring 2.1.2 → 2.1.4

package/types/providers.d.ts

@@ -39,7 +39,7 @@ declare class BaseProvider extends JsonRpcProvider {
     private bindMethods;
     private throttledRequest;
     private canMakeRequest;
-    verifyConfiguredChainId(): Promise<void>;
+    verifyConfiguredChainId(fresh?: boolean): Promise<void>;
     private fetchAndVerifyConfiguredChainId;
     private cooldown;
     private validateRpcResponses;

package/types/software.d.ts

@@ -1,20 +1,10 @@
 /** Software-only entry: explicit host storage, no browser/device initialization. */
 import { KeyringCore } from './keyring-core';
-import type { KeyringStoragePort } from './keyring-core';
+import type { KeyringHost, KeyringOptions } from './keyring-host';
 import type { EncryptedEvmHdRuntimeAccount, EvmHdRuntimeAccountOptions, EvmHdRuntimeAccountRequest } from './software-hd-account';
-import type { CaptureEvmSubmission } from './transactions/evm-submission';
 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, options?: {
-    captureEvmSubmission?: CaptureEvmSubmission;
-}) => SoftwareKeyringHost;
 export declare class SoftwareKeyring extends KeyringCore<undefined, undefined> {
-    constructor(host: SoftwareKeyringHost);
+    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,
@@ -27,17 +17,15 @@ export declare class SoftwareKeyring extends KeyringCore<undefined, undefined> {
      * 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>;
+    static createInitialized(host: KeyringHost, seed: string, password: string, vaultStateGetter: () => any, options: KeyringOptions): Promise<SoftwareKeyring>;
 }
+export { createKeyringHost } from './keyring-host';
+export type { KeyringHost, KeyringOptions } from './keyring-host';
 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 { DeviceUnlockControls, DeviceUnlockCredential, DeviceUnlockPort, DeviceUnlockVaultPair, KeyringStoragePort, } from './keyring-core';
+export type { IKeyringAccountState, SyscoinOwnedReadOptions, SyscoinOwnedSubmissionOptions, SyscoinSubmissionDescriptor, } from './types';
 export type { PreparedEvmTransaction, PreparedEvmSigningOptions, PreparedSoftwareEvmSigningRequest, SignedPreparedEvmTransaction, } from './transactions/prepared-evm';
 export type { EncryptedEvmHdRuntimeAccount, EvmHdRuntimeAccountOptions, EvmHdRuntimeAccountRequest, } from './software-hd-account';
 export { captureEvmSubmission, submitSignedEvmTransaction, evmSubmissionFailure, } from './transactions/evm-submission';

package/types/storage-core.d.ts

@@ -8,13 +8,15 @@ export interface VaultStoragePort {
 export interface VaultPersistence {
     setEncryptedVault(decryptedVault: any, pwd: string, freshVaultKeys?: {
         salt: string;
-    }): Promise<void>;
+    }, assertCurrent?: () => void): Promise<void>;
     getDecryptedVault(pwd: string, legacyPassword?: string): Promise<any>;
 }
 export declare class VaultAuthenticationError extends Error {
     readonly code = "INVALID_PASSWORD";
     constructor();
 }
+/** Authenticate a captured current-format vault. This path has no CBC fallback. */
+export declare const decryptCurrentVault: (vault: string, key: string) => Promise<unknown>;
 /**
  * Create once per wallet authority and share across its network keyrings.
  * The host owns storage durability and cross-context atomic creation.

package/types/transactions/ethereum.d.ts

@@ -2,7 +2,7 @@ import { TypedMessage, SignTypedDataVersion, TypedDataV1 } from '@metamask/eth-s
 import { INetwork } from '@sidhujag/sysweb3-network';
 import { BigNumber, TransactionResponse } from '../ethers-v6';
 import { CustomJsonRpcProvider } from '../providers';
-import { IResponseFromSendErcSignedTransaction, ISendSignedErcTransactionProps, IEthereumTransactions, IEvmCancellationOptions, IEvmReplacementOptions, IEvmSendOptions, SimpleTransactionRequest, KeyringAccountType, accountType, IGasParams } from '../types';
+import { IResponseFromSendErcSignedTransaction, ISendSignedErc20TransactionProps, ISendSignedErc721TransactionProps, ISendSignedErc1155TransactionProps, IReviewedEvmTokenApproval, IEthereumTransactions, IEvmCancellationOptions, IEvmReplacementOptions, EvmFormattedSendArguments, SimpleTransactionRequest, KeyringAccountType, accountType, IGasParams } from '../types';
 import { type CaptureEvmSubmission } from './evm-submission';
 import type { LedgerKeyring } from '../ledger';
 import type { TrezorKeyring } from '../trezor';
@@ -18,8 +18,8 @@ export declare class EthereumTransactions<TLedger extends EthereumLedgerSigner |
     trezorSigner: TTrezor;
     ledgerSigner: TLedger;
     private getNetwork;
-    private captureSigningContext?;
-    private readonly captureSubmissionLifecycle?;
+    private readonly captureSigningContext;
+    private readonly captureSubmissionLifecycle;
     private abortController;
     private getDecryptedPrivateKey;
     private gasOverrides;
@@ -37,15 +37,17 @@ export declare class EthereumTransactions<TLedger extends EthereumLedgerSigner |
         activeAccountId: number;
         activeAccountType: KeyringAccountType;
         activeNetwork: INetwork;
-    }, ledgerSigner: TLedger, trezorSigner: TTrezor, captureSigningContext?: () => () => void, captureSubmissionLifecycle?: CaptureEvmSubmission);
+    }, ledgerSigner: TLedger, trezorSigner: TTrezor, captureSigningContext: () => () => void, captureSubmissionLifecycle: CaptureEvmSubmission | null);
     private requireLedgerSigner;
     private requireTrezorSigner;
     private assertHardwareSignerAvailable;
+    private captureSessionGuard;
     private captureEvmSigningContext;
     private captureSubmission;
+    private authorizeHardwareTransaction;
+    private submitSignedHardwareTransaction;
     get web3Provider(): CustomJsonRpcProvider;
     private ensureProvidersInitialized;
-    private isUtxoNetwork;
     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;
@@ -57,7 +59,8 @@ export declare class EthereumTransactions<TLedger extends EthereumLedgerSigner |
     decryptMessage: (msgParams: string[]) => string;
     toBigNumber: (aBigNumberish: string | number) => BigNumber;
     private toHex0x;
-    private resolveEvmFeeParams;
+    private captureReviewedTokenApproval;
+    private reviewedTokenFees;
     getData: ({ contractAddress, receivingAddress, value, }: {
         contractAddress: string;
         receivingAddress: string;
@@ -78,9 +81,9 @@ export declare class EthereumTransactions<TLedger extends EthereumLedgerSigner |
         maximumFee?: string;
         transaction?: TransactionResponse;
     }>;
-    sendFormattedTransaction: (params: SimpleTransactionRequest, isLegacy?: boolean, options?: IEvmSendOptions) => Promise<any>;
+    sendFormattedTransaction: (...args: EvmFormattedSendArguments) => Promise<any>;
     private sendFormattedTransactionInternal;
-    sendTransactionWithEditedFee: (txHash: string, isLegacy?: boolean, options?: IEvmReplacementOptions) => Promise<{
+    sendTransactionWithEditedFee: (txHash: string, isLegacy: boolean | undefined, options: IEvmReplacementOptions) => Promise<{
         maximumFee?: string;
         error?: boolean;
         isSpeedUp: boolean;
@@ -90,9 +93,9 @@ export declare class EthereumTransactions<TLedger extends EthereumLedgerSigner |
         code?: string;
         message?: string;
     }>;
-    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>;
+    sendSignedErc20Transaction: (request: ISendSignedErc20TransactionProps, approval: IReviewedEvmTokenApproval) => Promise<IResponseFromSendErcSignedTransaction>;
+    sendSignedErc721Transaction: (request: ISendSignedErc721TransactionProps, approval: IReviewedEvmTokenApproval) => Promise<IResponseFromSendErcSignedTransaction>;
+    sendSignedErc1155Transaction: (request: ISendSignedErc1155TransactionProps, approval: IReviewedEvmTokenApproval) => Promise<IResponseFromSendErcSignedTransaction>;
     getRecommendedNonce: (address: string) => Promise<number>;
     getFeeByType: (type: string) => Promise<string>;
     getGasLimit: (toAddress: string) => Promise<number>;

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

@@ -0,0 +1,10 @@
+import type { planEvmCancellationFees } from '../evm-fees';
+/** A host supplies the authenticated original identity and the captured fee plan. */
+export type EvmCancellationEnvelopeIntent = Readonly<{
+    payer: string;
+    chainId: number | string;
+    nonce: number | string;
+    feePlan: ReturnType<typeof planEvmCancellationFees>;
+}>;
+/** Checks the exact unsigned bytes. Original eligibility and approval remain host checks. */
+export declare function assertEvmCancellationEnvelope(unsigned: string, { payer, chainId, nonce, feePlan }: EvmCancellationEnvelopeIntent): void;

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

@@ -23,7 +23,7 @@ export declare const parsePersonalMessage: (hexMessage: string) => string;
 /** Pin the checked gas and chain to the same detached envelope that is serialized. */
 export declare const normalizeGasLimitedTransaction: (transaction: TransactionRequest) => TransactionRequest;
 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, 
+export declare const sendLocalEvmTransaction: (provider: CustomJsonRpcProvider, privateKey: string, transaction: Deferrable<Record<string, any>>, beforeBroadcast: (() => void) | undefined, beforeSign: (() => void) | undefined, 
 /** Synchronous final-envelope check; throw to reject. Promise results are rejected. */
-validateBeforeSign?: (transaction: TransactionRequest) => void, submission?: EvmSubmissionBoundary) => Promise<any>;
+validateBeforeSign: ((transaction: TransactionRequest) => void) | undefined, submission: EvmSubmissionBoundary) => Promise<any>;
 export declare const sameAddress: (left: string, right: string) => boolean;

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

@@ -31,13 +31,17 @@ export type EvmSubmissionLifecycle = Readonly<{
     persistSigned: (record: EvmSignedSubmission) => Promise<void>;
 }>;
 export type CaptureEvmSubmission = (context: EvmSubmissionContext) => EvmSubmissionLifecycle;
+declare const evmSubmissionBrand: unique symbol;
 export type EvmSubmissionBoundary = Readonly<{
+    [evmSubmissionBrand]: true;
     context: EvmSubmissionContext;
     assertCurrent: () => void;
-    persistSigned?: (record: EvmSignedSubmission) => Promise<void>;
+    persistSigned: (record: EvmSignedSubmission) => Promise<void>;
 }>;
 /** Capture once, before RPC or device work. Never reread host capabilities later. */
-export declare function captureEvmSubmission(input: EvmSubmissionContext, assertCurrent: () => void, capture?: CaptureEvmSubmission): EvmSubmissionBoundary;
+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. */
 export declare function evmSubmissionFailure(error: unknown): Readonly<{
     transactionNotBroadcast: boolean;
@@ -47,5 +51,8 @@ export declare function evmSubmissionFailure(error: unknown): Readonly<{
 export declare function copyEvmSubmissionFailure(source: unknown, target: Error): void;
 /** Compare signed wire bytes with the complete envelope captured before signing. */
 export declare function assertSignedEvmTransactionMatches(rawTransaction: string, expectedUnsignedTransaction: string, expectedFrom?: string): Transaction;
-/** The sole local-signature dispatch boundary. No nonce/fee selection or retry. */
-export declare function submitSignedEvmTransaction<T>(rawTransaction: string, broadcast: (rawTransaction: string) => Promise<T>, boundary?: EvmSubmissionBoundary, beforeBroadcast?: () => void, expectedUnsignedTransaction?: string): Promise<T>;
+/** Submit software-signed bytes through the captured durable boundary. */
+export declare function submitSignedEvmTransaction<T>(rawTransaction: string, broadcast: (rawTransaction: string) => Promise<T>, boundary: EvmSubmissionBoundary, beforeBroadcast: (() => void) | undefined, expectedUnsignedTransaction: string): Promise<T>;
+/** @internal Device signatures always require a fresh live chain probe after persistence. */
+export declare function submitSignedHardwareEvmTransaction<T>(rawTransaction: string, broadcast: (rawTransaction: string) => Promise<T>, boundary: EvmSubmissionBoundary, beforeBroadcast: (() => void) | undefined, expectedUnsignedTransaction: string, verifyCurrentChain: () => Promise<void>): Promise<T>;
+export {};

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

@@ -1,7 +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. */
+/** The software transaction engine never imports this device adapter. */
 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/index.d.ts

@@ -1,3 +1,4 @@
 export * from './ethereum';
-export * from './syscoin';
-export * from './evm-submission';
+export { assertDurableEvmSubmission, assertSignedEvmTransactionMatches, captureEvmSubmission, copyEvmSubmissionFailure, evmSubmissionFailure, submitSignedEvmTransaction, } from './evm-submission';
+export type { CaptureEvmSubmission, EvmSignedSubmission, EvmSubmissionBoundary, EvmSubmissionContext, EvmSubmissionLifecycle, } from './evm-submission';
+export { readPublicSyscoinFee } from './syscoin-core';

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

@@ -50,4 +50,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): SignedPreparedEvmTransaction;
+export declare function signPreparedEvmEnvelope(transaction: PreparedEvmTransaction, privateKey: string): Readonly<{
+    signed: SignedPreparedEvmTransaction;
+    expectedUnsigned: string;
+}>;

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

@@ -1,6 +1,6 @@
-import { ITxid, txUtils } from '@sidhujag/sysweb3-utils';
+import { ITxid } from '@sidhujag/sysweb3-utils';
 import { Psbt } from 'bitcoinjs-lib';
-import { ISyscoinTransactions, KeyringAccountType, accountType } from '../types';
+import { ISyscoinTransactions, KeyringAccountType, accountType, type SyscoinOwnedReadOptions, type SyscoinOwnedSubmissionOptions } from '../types';
 import { ExcludedOutpoint } from '../utils/excluded-utxos';
 import { type PsbtAccountScope } from '../utils/psbt-account-scope';
 import type { SyscoinHDSigner } from '../signers';
@@ -12,10 +12,11 @@ export interface ISyscoinHardwareSigningRequest {
         xpub: string;
     }>;
     assertCurrent: () => void;
-    getRawTransaction?: ReturnType<typeof txUtils>['getRawTransaction'];
+    getRawTransaction?: (txid: string) => Promise<unknown>;
     readonly network: Readonly<INetwork>;
     psbt: Psbt;
     scope: PsbtAccountScope;
+    signal: AbortSignal;
 }
 /**
  * Trusted wallet-authority adapter, not an untrusted plugin entry point.
@@ -30,19 +31,48 @@ export interface ISyscoinHardwareSigners {
 export declare const createHardwareSignerUnavailableError: (hardware: string) => Error & {
     code: string;
 };
+type BlockbookRead = Pick<SyscoinOwnedReadOptions, 'fetch' | 'signal'>;
+/** Public network fee estimate. It has no wallet, account or signing access. */
+export declare function readPublicSyscoinFee(explorerUrl: string, owner: SyscoinOwnedReadOptions): Promise<number>;
+/** Internal captured context for the keyring's existing read-only builder and address lookup. */
+export type SyscoinUtxoReadContext = Readonly<{
+    assertCurrent: () => void;
+    network: Readonly<INetwork>;
+    transport: BlockbookRead;
+    xpub: string;
+}>;
+type OwnedPreparation = Readonly<{
+    account: Readonly<{
+        address: string;
+        xpub: string;
+    }>;
+    accountId: number;
+    accountType: KeyringAccountType;
+    read: SyscoinUtxoReadContext;
+}>;
+type GetUtxoReadState = () => {
+    accounts: Partial<Record<KeyringAccountType, accountType>>;
+    activeAccountId: number;
+    activeAccountType: KeyringAccountType;
+    activeNetwork: INetwork;
+};
+/** Bind both transaction preparation and address reads to the active wallet. */
+export declare function captureOwnedSyscoinRead(options: SyscoinOwnedReadOptions, getState: GetUtxoReadState, captureSigningContext: (bindSessionRevision: boolean) => () => void): OwnedPreparation;
+type GetUtxoAddress = (xpub: string, isChangeAddress: boolean) => Promise<string>;
+type ReadOnlySigner = {
+    main: any;
+    getOwnedAddress?: GetUtxoAddress;
+};
 export declare class SyscoinTransactionsCore implements ISyscoinTransactions {
     private getSigner;
     private getReadOnlySigner;
     private hardwareSigners;
     private getState;
-    private getAddress;
-    private captureSigningContext?;
+    private captureSigningContext;
     constructor(getSyscoinSigner: () => {
         hd: SyscoinHDSigner;
         main: any;
-    }, getReadOnlySigner: () => {
-        main: any;
-    }, getState: () => {
+    }, getReadOnlySigner: (read?: SyscoinUtxoReadContext) => ReadOnlySigner, getState: () => {
         accounts: {
             HDAccount: accountType;
             Imported: accountType;
@@ -52,14 +82,11 @@ export declare class SyscoinTransactionsCore implements ISyscoinTransactions {
         activeAccountId: number;
         activeAccountType: KeyringAccountType;
         activeNetwork: INetwork;
-    }, getAddress: (xpub: string, isChangeAddress: boolean) => Promise<string>, hardwareSigners?: ISyscoinHardwareSigners, captureSigningContext?: () => () => void);
+    }, hardwareSigners: ISyscoinHardwareSigners, captureSigningContext: (bindSessionRevision: boolean) => () => 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 captureOwnedRead;
+    getRecommendedFee: (explorerUrl: string, ownedRead: SyscoinOwnedReadOptions) => Promise<number>;
     private signPSBTWithSigner;
     private createNativeSweepPSBT;
     private createUnsignedPSBT;
@@ -76,17 +103,17 @@ export declare class SyscoinTransactionsCore implements ISyscoinTransactions {
         isMax?: boolean | false;
         nativeSweep?: boolean;
         excludedOutpoints?: readonly ExcludedOutpoint[];
-    }) => Promise<{
+    }, ownedRead: SyscoinOwnedReadOptions) => Promise<{
         grossAmount?: string | undefined;
         recipientAmount?: string | undefined;
         fee: number;
         psbt: any;
     }>;
-    private sendSignedTransaction;
-    signPSBT: ({ psbt, isTrezor, isLedger, }: {
-        psbt: any;
-        isTrezor?: boolean;
+    signPSBT: ({ psbt }: {
         isLedger?: boolean;
-    }) => Promise<any>;
-    sendTransaction: (psbt: any) => Promise<ITxid>;
+        isTrezor?: boolean;
+        psbt: any;
+    }, ownedRead: SyscoinOwnedReadOptions) => Promise<any>;
+    sendTransaction: (rawTransaction: string, authority: SyscoinOwnedSubmissionOptions) => Promise<ITxid>;
 }
+export {};

package/types/trezor/connect.d.ts

@@ -1,7 +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", "signTransaction", "ethereumSignTransaction", "signMessage", "ethereumSignMessage", "ethereumSignTypedData", "verifyMessage", "ethereumVerifyMessage"];
-type Method = (typeof methods)[number];
+declare const methods: readonly ["getFeatures", "getAccountInfo", "ethereumGetAddress", "ethereumGetPublicKey", "getPublicKey", "getAddress", "signMessage", "ethereumSignMessage", "ethereumSignTypedData", "verifyMessage", "ethereumVerifyMessage"];
+type ForwardedMethod = (typeof methods)[number];
 type Compatible<T> = T extends {
     success: false;
 } ? T & {
@@ -20,7 +21,7 @@ type CompatibleCall<FunctionType> = FunctionType extends {
     (...args: C): Promise<Compatible<Awaited<T>>>;
 } : never;
 type Calls = {
-    [Name in Method]: CompatibleCall<Client[Name]>;
+    [Name in ForwardedMethod]: CompatibleCall<Client[Name]>;
 };
 type ConnectionEvent = {
     type: 'disconnected';
@@ -30,6 +31,8 @@ type ConnectionEvent = {
 };
 export declare const subscribeTrezorEvents: (listener: (event: ConnectionEvent) => void) => (() => void);
 declare const TrezorConnect: 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'];
     dispose: () => Promise<void>;
 };

package/types/trezor/index.d.ts

@@ -1,6 +1,7 @@
 import { TypedMessage, SignTypedDataVersion, TypedDataV1 } from '@metamask/eth-sig-util';
 import { Psbt } from 'bitcoinjs-lib';
 import { Buffer } from 'buffer';
+import type { HardwareTransactionAuthority } from '../hardware-transaction-authority';
 import type { AccountInfo, EthereumTransaction, EthereumTransactionEIP1559 } from '@trezor/connect-webextension';
 export interface TrezorControllerState {
     hdPath: string;
@@ -28,7 +29,7 @@ export declare class TrezorKeyring {
     /**
      * Initialize Trezor script.
      */
-    init(): Promise<boolean>;
+    init(assertCurrent?: () => void): Promise<boolean>;
     /**
      * Execute operation with automatic retry
      */
@@ -102,7 +103,7 @@ export declare class TrezorKeyring {
      * @param outputs - utxo transaction outputs
      * @returns signature object
      */
-    signUtxoTransaction(utxoTransaction: any, psbt: Psbt): Promise<Psbt>;
+    signUtxoTransaction(utxoTransaction: any, psbt: Psbt, authority: HardwareTransactionAuthority): Promise<Psbt>;
     private setHdPath;
     convertToAddressNFormat(path: string): any[];
     isScriptHash(address: string, networkInfo: any): boolean;
@@ -122,7 +123,7 @@ export declare class TrezorKeyring {
         tx: EthereumTransaction | EthereumTransactionEIP1559;
         coin: string;
         slip44: number;
-    }): Promise<import("@trezor/connect-webextension").OkWithDevice<{
+    }, authority: HardwareTransactionAuthority): Promise<import("@trezor/connect-webextension").OkWithDevice<{
         authorizationList?: {
             address: string;
             chainId: number;