@sidhujag/sysweb3-keyring 2.1.2 → 2.1.4

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"}

package/cjs/utils/blockbook-cache.js

@@ -1,76 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.invalidateBlockbookAccountCache = exports.fetchBackendAccountCached = void 0;
-const syscoinjs = __importStar(require("syscoinjs-lib"));
-const inflightFetches = new Map();
-const buildKey = (backendUrl, xpub, options) => `${backendUrl}::${xpub}::${options}`;
-const fetchBackendAccountCached = (backendUrl, xpub, options) => {
-    const key = buildKey(backendUrl, xpub, options);
-    const inflight = inflightFetches.get(key);
-    if (inflight) {
-        return inflight.promise;
-    }
-    const promise = Promise.resolve(syscoinjs.utils.fetchBackendAccount(backendUrl, xpub, options, true));
-    inflightFetches.set(key, { promise });
-    // Drop the entry as soon as the request settles so subsequent
-    // callers always fetch fresh data
-    const dropEntry = () => {
-        const entry = inflightFetches.get(key);
-        if (entry && entry.promise === promise) {
-            inflightFetches.delete(key);
-        }
-    };
-    promise.then(dropEntry, dropEntry);
-    return promise;
-};
-exports.fetchBackendAccountCached = fetchBackendAccountCached;
-/**
- * Drop in-flight account fetches. Without arguments clears everything;
- * with an xpub only that account's entries are dropped (any backend).
- */
-const invalidateBlockbookAccountCache = (xpub) => {
-    if (!xpub) {
-        inflightFetches.clear();
-        return;
-    }
-    for (const key of Array.from(inflightFetches.keys())) {
-        if (key.includes(`::${xpub}::`)) {
-            inflightFetches.delete(key);
-        }
-    }
-};
-exports.invalidateBlockbookAccountCache = invalidateBlockbookAccountCache;
-//# sourceMappingURL=blockbook-cache.js.map

package/cjs/utils/blockbook-cache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"blockbook-cache.js","sourceRoot":"","sources":["../../../src/utils/blockbook-cache.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,yDAA2C;AAmB3C,MAAM,eAAe,GAAG,IAAI,GAAG,EAAuB,CAAC;AAEvD,MAAM,QAAQ,GAAG,CAAC,UAAkB,EAAE,IAAY,EAAE,OAAe,EAAE,EAAE,CACrE,GAAG,UAAU,KAAK,IAAI,KAAK,OAAO,EAAE,CAAC;AAEhC,MAAM,yBAAyB,GAAG,CACvC,UAAkB,EAClB,IAAY,EACZ,OAAe,EACD,EAAE;IAChB,MAAM,GAAG,GAAG,QAAQ,CAAC,UAAU,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAEhD,MAAM,QAAQ,GAAG,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC1C,IAAI,QAAQ,EAAE,CAAC;QACb,OAAO,QAAQ,CAAC,OAAO,CAAC;IAC1B,CAAC;IAED,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAC5B,SAAS,CAAC,KAAa,CAAC,mBAAmB,CAC1C,UAAU,EACV,IAAI,EACJ,OAAO,EACP,IAAI,CACL,CACF,CAAC;IAEF,eAAe,CAAC,GAAG,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;IAEtC,8DAA8D;IAC9D,kCAAkC;IAClC,MAAM,SAAS,GAAG,GAAG,EAAE;QACrB,MAAM,KAAK,GAAG,eAAe,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACvC,IAAI,KAAK,IAAI,KAAK,CAAC,OAAO,KAAK,OAAO,EAAE,CAAC;YACvC,eAAe,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC,CAAC;IACF,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;IAEnC,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AAlCW,QAAA,yBAAyB,6BAkCpC;AAEF;;;GAGG;AACI,MAAM,+BAA+B,GAAG,CAAC,IAAa,EAAE,EAAE;IAC/D,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,eAAe,CAAC,KAAK,EAAE,CAAC;QACxB,OAAO;IACT,CAAC;IACD,KAAK,MAAM,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC;QACrD,IAAI,GAAG,CAAC,QAAQ,CAAC,KAAK,IAAI,IAAI,CAAC,EAAE,CAAC;YAChC,eAAe,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;AACH,CAAC,CAAC;AAVW,QAAA,+BAA+B,mCAU1C"}

package/types/hardware-wallet-manager-singleton.d.ts

@@ -1,19 +0,0 @@
-import { HardwareWalletManager } from './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.
- */
-declare class HardwareWalletManagerSingleton {
-    private static instance;
-    /**
-     * Get the shared HardwareWalletManager instance
-     * Creates one if it doesn't exist
-     */
-    static getInstance(): HardwareWalletManager;
-    /**
-     * Reset the singleton instance (useful for testing)
-     */
-    static resetInstance(): void;
-}
-export { HardwareWalletManagerSingleton };

package/types/storage.d.ts

@@ -1,5 +0,0 @@
-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/syscoin.d.ts

@@ -1,9 +0,0 @@
-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 {};

package/types/utils/blockbook-cache.d.ts

@@ -1,6 +0,0 @@
-export declare const fetchBackendAccountCached: (backendUrl: string, xpub: string, options: string) => Promise<any>;
-/**
- * Drop in-flight account fetches. Without arguments clears everything;
- * with an xpub only that account's entries are dropped (any backend).
- */
-export declare const invalidateBlockbookAccountCache: (xpub?: string) => void;