@sidhujag/sysweb3-keyring 2.1.3 → 2.1.4

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;

package/types/types.d.ts

@@ -7,6 +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';
 export type AccessListish = Array<{
     address: string;
     storageKeys: string[];
@@ -37,46 +39,44 @@ export type EvmLocalAccount = {
 };
 export interface IEvmSendOptions {
     /** Synchronous host admission, rechecked immediately before signing and broadcast. */
-    assertCurrent?: () => void;
+    assertCurrent: () => void;
+    mode: 'reviewed-native' | 'specialized';
 }
-export interface IEvmReplacementOptions {
-    /** Read-only preview; never requests credentials, a device signature or broadcast. */
-    previewOnly?: boolean;
-    /** Required for sending: maximum execution gas fee in decimal wei approved by the user. */
-    approvedMaximumFee?: string;
-    /** Select the locally controlled outer gas payer for a smart-account transaction. */
-    targetAccount?: {
-        id: number;
-        type: KeyringAccountType;
-    };
-    /** Host guard for the current account, network, session and pending original. */
-    assertCurrentContext?: () => void;
-    /** Synchronous original admission; Promise/thenable returns are rejected, never awaited. */
-    validateOriginal?: (transaction: TransactionResponse) => void;
-    beforeBroadcast?: () => void;
-}
-export interface IEvmCancellationOptions {
-    /** Select the locally controlled outer gas payer for a smart-account transaction. */
+export type EvmFormattedSendArguments = [
+    approvedTransaction: PreparedEvmTransaction,
+    isLegacy: boolean | undefined,
+    options: IEvmSendOptions & {
+        mode: 'reviewed-native';
+    }
+] | [
+    transaction: SimpleTransactionRequest,
+    isLegacy: boolean | undefined,
+    options: IEvmSendOptions & {
+        mode: 'specialized';
+    }
+];
+export type EvmReplacementFeeApproval = {
+    previewOnly: true;
+    approvedMaximumFee?: never;
+} | {
+    previewOnly?: false;
+    approvedMaximumFee: string;
+};
+type EvmOriginalAdmission<Original> = {
+    /** Select a distinct locally controlled gas payer for a smart account. */
     targetAccount?: {
         id: number;
         type: KeyringAccountType;
     };
-    /** Read-only preview; never requests credentials, a device signature or broadcast. */
-    previewOnly?: boolean;
-    /** Required for sending: maximum execution gas fee in decimal wei approved by the user. */
-    approvedMaximumFee?: string;
-    /** Synchronous host guard for selection or session state outside the keyring. */
+    /** Synchronous host guard for the current account, network, session and pending original. */
     assertCurrentContext: () => void;
-    /**
-     * Required synchronous host admission for the reviewed pending original.
-     * Non-null values contain detached, authenticated signed fields. Null means
-     * the RPC did not find the original: admit it only when the supplied fallbackNonce
-     * belongs to trusted, still-current local submission data; otherwise throw.
-     * Invalid non-null RPC replies never become a null/fallback admission.
-     * Promise/thenable returns are rejected, never awaited.
-     */
-    validateOriginal: (transaction: TransactionResponse | null) => void;
-}
+    /** Receives authenticated signed fields. Null requires explicit cancellation fallback admission. */
+    validateOriginal: (transaction: Original) => void;
+};
+export type IEvmReplacementOptions = EvmReplacementFeeApproval & EvmOriginalAdmission<TransactionResponse> & {
+    beforeBroadcast?: () => void;
+};
+export type IEvmCancellationOptions = EvmReplacementFeeApproval & EvmOriginalAdmission<TransactionResponse | null>;
 export interface IEthereumTransactions {
     cancelSentTransaction: (txHash: string, isLegacy: boolean | undefined, fallbackNonce: number | undefined, options: IEvmCancellationOptions) => Promise<{
         error?: boolean;
@@ -99,13 +99,13 @@ export interface IEthereumTransactions {
     signTypedData: (addr: string, typedData: TypedDataV1 | TypedMessage<any>, version: SignTypedDataVersion) => Promise<string>;
     importAccount: (mnemonicOrPrivKey: string) => EvmLocalAccount;
     parsePersonalMessage: (hexMsg: string) => string;
-    sendFormattedTransaction: (params: SimpleTransactionRequest, isLegacy?: boolean, options?: IEvmSendOptions) => Promise<TransactionResponse>;
-    sendSignedErc1155Transaction: ({ receiver, tokenAddress, tokenId, isLegacy, gasPrice, gasLimit, maxFeePerGas, maxPriorityFeePerGas, }: ISendSignedErcTransactionProps) => Promise<IResponseFromSendErcSignedTransaction>;
+    sendFormattedTransaction: (...args: EvmFormattedSendArguments) => Promise<TransactionResponse>;
+    sendSignedErc1155Transaction: (params: ISendSignedErc1155TransactionProps, approval: IReviewedEvmTokenApproval) => Promise<IResponseFromSendErcSignedTransaction>;
     verifyPersonalMessage: (msg: string, sign: string) => string;
     toBigNumber: (aBigNumberish: string | number) => BigNumber;
-    sendSignedErc20Transaction: ({ networkUrl, receiver, tokenAddress, tokenAmount, }: ISendSignedErcTransactionProps) => Promise<IResponseFromSendErcSignedTransaction>;
-    sendSignedErc721Transaction: ({ networkUrl, receiver, tokenAddress, tokenId, }: ISendSignedErcTransactionProps) => Promise<IResponseFromSendErcSignedTransaction>;
-    sendTransactionWithEditedFee: (txHash: string, isLegacy?: boolean, options?: IEvmReplacementOptions) => Promise<{
+    sendSignedErc20Transaction: (params: ISendSignedErc20TransactionProps, approval: IReviewedEvmTokenApproval) => Promise<IResponseFromSendErcSignedTransaction>;
+    sendSignedErc721Transaction: (params: ISendSignedErc721TransactionProps, approval: IReviewedEvmTokenApproval) => Promise<IResponseFromSendErcSignedTransaction>;
+    sendTransactionWithEditedFee: (txHash: string, isLegacy: boolean | undefined, options: IEvmReplacementOptions) => Promise<{
         maximumFee?: string;
         isSpeedUp: boolean;
         transactionNotBroadcast?: boolean;
@@ -131,6 +131,21 @@ export interface ISyscoinTransactionFeeQuote {
     grossAmount?: string;
     recipientAmount?: string;
 }
+/** A trusted wallet host owns the lifetime and HTTP policy of these reads. */
+export type SyscoinOwnedReadOptions = Readonly<{
+    assertCurrent: () => void;
+    fetch: typeof globalThis.fetch;
+    signal: AbortSignal;
+}>;
+/** Exact signed bytes presented to a wallet host before the only POST. */
+export type SyscoinSubmissionDescriptor = Readonly<{
+    rawTransaction: string;
+    txid: string;
+    url: string;
+}>;
+export type SyscoinOwnedSubmissionOptions = SyscoinOwnedReadOptions & Readonly<{
+    prepare: (descriptor: SyscoinSubmissionDescriptor) => Promise<void>;
+}>;
 export interface ISyscoinTransactions {
     getEstimateSysTransactionFee: ({ txOptions, amount, receivingAddress, feeRate, token, isMax, nativeSweep, excludedOutpoints, }: {
         amount: number | string;
@@ -149,15 +164,15 @@ export interface ISyscoinTransactions {
             txid: string;
             vout: number;
         }[];
-    }) => Promise<ISyscoinTransactionFeeQuote>;
-    getRecommendedFee: (explorerUrl: string) => Promise<number>;
+    }, ownedRead: SyscoinOwnedReadOptions) => Promise<ISyscoinTransactionFeeQuote>;
+    getRecommendedFee: (explorerUrl: string, ownedRead: SyscoinOwnedReadOptions) => Promise<number>;
     decodeRawTransaction: (psbtOrHex: any, isRawHex?: boolean) => any;
-    sendTransaction: (psbt: any) => Promise<ITxid>;
+    sendTransaction: (rawTransaction: string, authority: SyscoinOwnedSubmissionOptions) => Promise<ITxid>;
     signPSBT: ({ psbt, isTrezor, isLedger, }: {
         isLedger?: boolean;
         isTrezor?: boolean;
         psbt: any;
-    }) => Promise<any>;
+    }, ownedRead: SyscoinOwnedReadOptions) => Promise<any>;
 }
 export interface IKeyringManager {
     addNewAccount: (label?: string) => Promise<IKeyringAccountState>;
@@ -179,7 +194,6 @@ export interface IKeyringManager {
         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>;
@@ -204,11 +218,11 @@ export interface IKeyringManager {
     importAccount: (privKey: string, label?: string, options?: {
         utxoAddressType?: 'p2wpkh' | 'p2pkh';
     }) => 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>;
+    getNewChangeAddress: (ownedRead: SyscoinOwnedReadOptions) => Promise<string>;
+    getChangeAddress: (id: number, ownedRead: SyscoinOwnedReadOptions) => Promise<string>;
+    getPubkey: (id: number, isChangeAddress: boolean, ownedRead: SyscoinOwnedReadOptions) => Promise<string>;
+    getBip32Path: (id: number, isChangeAddress: boolean, ownedRead: SyscoinOwnedReadOptions) => Promise<string>;
+    updateReceivingAddress: (ownedRead: SyscoinOwnedReadOptions) => Promise<string>;
     getActiveAccount: () => {
         activeAccount: Omit<IKeyringAccountState, 'xprv'>;
         activeAccountType: KeyringAccountType;
@@ -219,12 +233,11 @@ export interface IKeyringManager {
     importLedgerAccount: (label?: string) => Promise<IKeyringAccountState | undefined>;
     getActiveUTXOAccountState: () => any;
     createEthAccount: (privateKey: string) => any;
-    getAddress: (xpub: string, isChangeAddress: boolean) => Promise<string>;
+    getAddress: (xpub: string, isChangeAddress: boolean, ownedRead: SyscoinOwnedReadOptions) => 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;
+    transferSessionTo: (targetKeyring: KeyringCore) => void;
     lockWallet: () => Promise<void>;
     setVaultStateGetter: (getter: () => any) => void;
 }
@@ -326,20 +339,39 @@ export interface ILatestUpdateForSysAccount {
     receivingAddress: any;
     xpub: any;
 }
-export interface ISendSignedErcTransactionProps {
-    decimals?: number;
-    gasLimit?: BigNumberish;
-    gasPrice?: BigNumberish;
-    isLegacy?: boolean;
-    maxFeePerGas?: BigNumberish;
-    maxPriorityFeePerGas?: BigNumberish;
+export type IReviewedEvmTokenApproval = Readonly<{
+    assertCurrent: () => void;
+    signal: AbortSignal;
+}>;
+export type IReviewedEvmTokenFees = {
+    gasLimit: BigNumberish;
+} & ({
+    isLegacy: true;
+    gasPrice: BigNumberish;
+    maxFeePerGas?: never;
+    maxPriorityFeePerGas?: never;
+} | {
+    isLegacy: false;
+    maxFeePerGas: BigNumberish;
+    maxPriorityFeePerGas: BigNumberish;
+    gasPrice?: never;
+});
+type ISendReviewedTokenBase = IReviewedEvmTokenFees & {
     networkUrl: string;
     receiver: string;
-    saveTrezorTx?: (tx: any) => void;
     tokenAddress: string;
-    tokenAmount?: string;
-    tokenId?: bigint | number | string;
-}
+};
+/** Integer amounts and token identifiers are canonical uint256 strings. */
+export type ISendSignedErc20TransactionProps = ISendReviewedTokenBase & {
+    tokenAmountUnits: string;
+    saveTrezorTx?: (tx: any) => void;
+};
+export type ISendSignedErc721TransactionProps = ISendReviewedTokenBase & {
+    tokenId: string;
+};
+export type ISendSignedErc1155TransactionProps = ISendSignedErc721TransactionProps & {
+    tokenAmount: string;
+};
 export interface IResponseFromSendErcSignedTransaction {
     accessList: any[];
     chainId: number;

package/types/utils/owned-blockbook-account.d.ts

@@ -0,0 +1,3 @@
+import type { SyscoinOwnedReadOptions } from '../types';
+/** Read address paths with the host's endpoint policy and independent lifetime. */
+export declare function fetchOwnedBlockbookAccount(backendUrl: string, xpub: string, transport: Pick<SyscoinOwnedReadOptions, 'fetch' | 'signal'>): Promise<any>;

package/cjs/hardware-wallet-manager-singleton.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HardwareWalletManagerSingleton = void 0;
-const hardware_wallet_manager_1 = require("./hardware-wallet-manager");
-/**
- * Singleton wrapper for HardwareWalletManager to ensure a single instance
- * is shared across all KeyringManager instances. This prevents "device already open"
- * errors when multiple networks try to connect to the same Ledger device.
- */
-class HardwareWalletManagerSingleton {
-    /**
-     * Get the shared HardwareWalletManager instance
-     * Creates one if it doesn't exist
-     */
-    static getInstance() {
-        if (!HardwareWalletManagerSingleton.instance) {
-            HardwareWalletManagerSingleton.instance = new hardware_wallet_manager_1.HardwareWalletManager();
-        }
-        return HardwareWalletManagerSingleton.instance;
-    }
-    /**
-     * Reset the singleton instance (useful for testing)
-     */
-    static resetInstance() {
-        if (HardwareWalletManagerSingleton.instance) {
-            // Clean up any existing connections
-            HardwareWalletManagerSingleton.instance.destroy();
-            HardwareWalletManagerSingleton.instance = null;
-        }
-    }
-}
-exports.HardwareWalletManagerSingleton = HardwareWalletManagerSingleton;
-HardwareWalletManagerSingleton.instance = null;
-//# sourceMappingURL=hardware-wallet-manager-singleton.js.map

package/cjs/hardware-wallet-manager-singleton.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hardware-wallet-manager-singleton.js","sourceRoot":"","sources":["../../src/hardware-wallet-manager-singleton.ts"],"names":[],"mappings":";;;AAAA,uEAAkE;AAElE;;;;GAIG;AACH,MAAM,8BAA8B;IAGlC;;;OAGG;IACH,MAAM,CAAC,WAAW;QAChB,IAAI,CAAC,8BAA8B,CAAC,QAAQ,EAAE,CAAC;YAC7C,8BAA8B,CAAC,QAAQ,GAAG,IAAI,+CAAqB,EAAE,CAAC;QACxE,CAAC;QACD,OAAO,8BAA8B,CAAC,QAAQ,CAAC;IACjD,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,aAAa;QAClB,IAAI,8BAA8B,CAAC,QAAQ,EAAE,CAAC;YAC5C,oCAAoC;YACpC,8BAA8B,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;YAClD,8BAA8B,CAAC,QAAQ,GAAG,IAAI,CAAC;QACjD,CAAC;IACH,CAAC;;AAGM,wEAA8B;AAzBtB,uCAAQ,GAAiC,IAAI,CAAC"}

package/cjs/storage.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VaultAuthenticationError = exports.getDecryptedVault = exports.setEncryptedVault = void 0;
-const sysweb3_core_1 = require("@sidhujag/sysweb3-core");
-const storage_core_1 = require("./storage-core");
-// Preserve the legacy process-wide storage authority. Host-isolated consumers
-// import storage-core directly and supply their own asynchronous storage port.
-const storage = sysweb3_core_1.sysweb3Di.getStateStorageDb();
-const persistence = (0, storage_core_1.createVaultPersistence)({
-    get: async (key) => storage.get(key),
-    set: async (key, value) => {
-        await storage.set(key, value);
-    },
-    createManyIfAbsent: async (items) => storage.createManyIfAbsent(items),
-});
-exports.setEncryptedVault = persistence.setEncryptedVault;
-exports.getDecryptedVault = persistence.getDecryptedVault;
-var storage_core_2 = require("./storage-core");
-Object.defineProperty(exports, "VaultAuthenticationError", { enumerable: true, get: function () { return storage_core_2.VaultAuthenticationError; } });
-//# sourceMappingURL=storage.js.map

package/cjs/storage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"storage.js","sourceRoot":"","sources":["../../src/storage.ts"],"names":[],"mappings":";;;AAAA,yDAAmD;AAEnD,iDAAwD;AAExD,8EAA8E;AAC9E,+EAA+E;AAC/E,MAAM,OAAO,GAAG,wBAAS,CAAC,iBAAiB,EAAE,CAAC;AAC9C,MAAM,WAAW,GAAG,IAAA,qCAAsB,EAAC;IACzC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC;IACpC,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE;QACxB,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IAChC,CAAC;IACD,kBAAkB,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,kBAAkB,CAAC,KAAK,CAAC;CACvE,CAAC,CAAC;AAEU,QAAA,iBAAiB,GAAG,WAAW,CAAC,iBAAiB,CAAC;AAClD,QAAA,iBAAiB,GAAG,WAAW,CAAC,iBAAiB,CAAC;AAC/D,+CAA0D;AAAjD,wHAAA,wBAAwB,OAAA"}

package/cjs/transactions/syscoin.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyscoinTransactions = void 0;
-const hardware_psbt_1 = require("./hardware-psbt");
-const syscoin_core_1 = require("./syscoin-core");
-/** Legacy constructor: preserve device arguments while composing shared logic. */
-class SyscoinTransactions extends syscoin_core_1.SyscoinTransactionsCore {
-    constructor(getSyscoinSigner, getReadOnlySigner, getState, getAddress, ledgerSigner, trezorSigner, captureSigningContext) {
-        super(getSyscoinSigner, getReadOnlySigner, getState, getAddress, {
-            ledger: ledgerSigner ? (0, hardware_psbt_1.createLedgerPsbtSigner)(ledgerSigner) : undefined,
-            trezor: trezorSigner ? (0, hardware_psbt_1.createTrezorPsbtSigner)(trezorSigner) : undefined,
-        }, captureSigningContext);
-    }
-}
-exports.SyscoinTransactions = SyscoinTransactions;
-//# sourceMappingURL=syscoin.js.map

package/cjs/transactions/syscoin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"syscoin.js","sourceRoot":"","sources":["../../../src/transactions/syscoin.ts"],"names":[],"mappings":";;;AAAA,mDAGyB;AACzB,iDAAyD;AAOzD,kFAAkF;AAClF,MAAa,mBAAoB,SAAQ,sCAAuB;IAC9D,YACE,gBAAkC,EAClC,iBAAmC,EACnC,QAA0B,EAC1B,UAA4B,EAC5B,YAA2B,EAC3B,YAA2B,EAC3B,qBAAwC;QAExC,KAAK,CACH,gBAAgB,EAChB,iBAAiB,EACjB,QAAQ,EACR,UAAU,EACV;YACE,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,IAAA,sCAAsB,EAAC,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS;YACvE,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,IAAA,sCAAsB,EAAC,YAAY,CAAC,CAAC,CAAC,CAAC,SAAS;SACxE,EACD,qBAAqB,CACtB,CAAC;IACJ,CAAC;CACF;AAtBD,kDAsBC"}