@sidhujag/sysweb3-keyring 2.1.4 → 2.1.6

package/types/transactions/ethereum.d.ts

@@ -1,6 +1,7 @@
 import { TypedMessage, SignTypedDataVersion, TypedDataV1 } from '@metamask/eth-sig-util';
 import { INetwork } from '@sidhujag/sysweb3-network';
 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 CaptureEvmSubmission } from './evm-submission';
@@ -66,13 +67,18 @@ export declare class EthereumTransactions<TLedger extends EthereumLedgerSigner |
         receivingAddress: string;
         value: any;
     }) => string;
-    getFeeDataWithDynamicMaxPriorityFeePerGas: (provider?: CustomJsonRpcProvider) => Promise<{
+    getFeeDataWithDynamicMaxPriorityFeePerGas: (provider?: EvmFeeReader) => Promise<{
         maxFeePerGas: BigNumber;
         maxPriorityFeePerGas: BigNumber;
         baseFeePerGas?: BigNumber | undefined;
         gasPrice: BigNumber;
     }>;
-    calculateNewGasValues: (oldTxsParams: IGasParams, isForCancel: boolean, isLegacy: boolean) => IGasParams;
+    calculateNewGasValues: (oldTxsParams: IGasParams, isForCancel: boolean, isLegacy: boolean, bounds: Readonly<{
+        chainId: bigint;
+        retainedCancellationGasLimit?: bigint;
+        sampledBlockGasLimit: bigint;
+        sampledBaseFeePerGas: bigint | null;
+    }>) => IGasParams;
     cancelSentTransaction: (txHash: string, isLegacy: boolean | undefined, fallbackNonce: number | undefined, options: IEvmCancellationOptions) => Promise<{
         error?: boolean;
         isCanceled: boolean;
@@ -81,7 +87,7 @@ export declare class EthereumTransactions<TLedger extends EthereumLedgerSigner |
         maximumFee?: string;
         transaction?: TransactionResponse;
     }>;
-    sendFormattedTransaction: (...args: EvmFormattedSendArguments) => Promise<any>;
+    sendFormattedTransaction: (...args: EvmFormattedSendArguments) => Promise<unknown>;
     private sendFormattedTransactionInternal;
     sendTransactionWithEditedFee: (txHash: string, isLegacy: boolean | undefined, options: IEvmReplacementOptions) => Promise<{
         maximumFee?: string;

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

@@ -1,4 +1,5 @@
 import type { planEvmCancellationFees } from '../evm-fees';
+import type { EvmRetainedCancellationOrigin } from '../types';
 /** A host supplies the authenticated original identity and the captured fee plan. */
 export type EvmCancellationEnvelopeIntent = Readonly<{
     payer: string;
@@ -6,5 +7,7 @@ export type EvmCancellationEnvelopeIntent = Readonly<{
     nonce: number | string;
     feePlan: ReturnType<typeof planEvmCancellationFees>;
 }>;
+/** Verify the selected signed bytes and snapshot the host's exact fee floor. */
+export declare function authenticateRetainedCancellation(origin: EvmRetainedCancellationOrigin, hash: string, payer: string, chainId: number): EvmRetainedCancellationOrigin;
 /** 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

@@ -25,5 +25,5 @@ export declare const normalizeGasLimitedTransaction: (transaction: TransactionRe
 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) | undefined, beforeSign: (() => void) | undefined, 
 /** Synchronous final-envelope check; throw to reject. Promise results are rejected. */
-validateBeforeSign: ((transaction: TransactionRequest) => void) | undefined, submission: EvmSubmissionBoundary) => Promise<any>;
+validateBeforeSign: ((transaction: TransactionRequest) => void) | undefined, submission: EvmSubmissionBoundary) => Promise<unknown>;
 export declare const sameAddress: (left: string, right: string) => boolean;

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

@@ -1,4 +1,5 @@
 import { Transaction } from 'ethers/transaction';
+import type { EvmRetainedCancellationOrigin, EvmWalletNonce } from '../types';
 export type EvmSubmissionContext = Readonly<{
     account: Readonly<{
         id: number;
@@ -13,6 +14,8 @@ export type EvmSubmissionContext = Readonly<{
     }>;
     operation: 'send' | 'cancel' | 'speed-up' | 'erc20' | 'erc721' | 'erc1155';
     originalHash?: string;
+    origin?: EvmRetainedCancellationOrigin;
+    walletNonce?: EvmWalletNonce;
 }>;
 /** Signed wire bytes only; never a key, password or mutable transaction request. */
 export type EvmSignedSubmission = Readonly<{
@@ -24,11 +27,19 @@ export type EvmSignedSubmission = Readonly<{
     nonce: number;
     type: number | null;
 }>;
+/** The transport calls this after preflight, immediately around synchronous wire initiation. */
+export type AdmitEvmSignedDispatch<T> = (initiate: () => Promise<T>, preflight?: () => Promise<void>) => Promise<T>;
+export type EvmSignedBroadcast<T> = (request: Readonly<{
+    rawTransaction: string;
+    admit: AdmitEvmSignedDispatch<T>;
+}>) => Promise<T>;
 export type EvmSubmissionLifecycle = Readonly<{
     /** Synchronous host wallet/session/revision check, including A -> B -> A. */
     assertCurrent: () => void;
     /** Resolve only after durable acknowledgement. A rejection never dispatches. */
     persistSigned: (record: EvmSignedSubmission) => Promise<void>;
+    /** Admit the exact retained record, releasing the owner before the remote response. */
+    dispatchSigned: <T>(record: EvmSignedSubmission, initiate: () => Promise<T>, preflight: () => Promise<void>) => Promise<T>;
 }>;
 export type CaptureEvmSubmission = (context: EvmSubmissionContext) => EvmSubmissionLifecycle;
 declare const evmSubmissionBrand: unique symbol;
@@ -37,6 +48,7 @@ export type EvmSubmissionBoundary = Readonly<{
     context: EvmSubmissionContext;
     assertCurrent: () => void;
     persistSigned: (record: EvmSignedSubmission) => Promise<void>;
+    dispatchSigned: EvmSubmissionLifecycle['dispatchSigned'];
 }>;
 /** Capture once, before RPC or device work. Never reread host capabilities later. */
 export declare function captureEvmSubmission(input: EvmSubmissionContext, assertCurrent: () => void, capture: CaptureEvmSubmission): EvmSubmissionBoundary;
@@ -52,7 +64,7 @@ export declare function copyEvmSubmissionFailure(source: unknown, target: Error)
 /** Compare signed wire bytes with the complete envelope captured before signing. */
 export declare function assertSignedEvmTransactionMatches(rawTransaction: string, expectedUnsignedTransaction: string, expectedFrom?: string): Transaction;
 /** 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>;
+export declare function submitSignedEvmTransaction<T>(rawTransaction: string, broadcast: EvmSignedBroadcast<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 declare function submitSignedHardwareEvmTransaction<T>(rawTransaction: string, broadcast: EvmSignedBroadcast<T>, boundary: EvmSubmissionBoundary, beforeBroadcast: (() => void) | undefined, expectedUnsignedTransaction: string, verifyCurrentChain: () => Promise<void>): Promise<T>;
 export {};

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

@@ -1,6 +1,6 @@
 import { ITxid } from '@sidhujag/sysweb3-utils';
 import { Psbt } from 'bitcoinjs-lib';
-import { ISyscoinTransactions, KeyringAccountType, accountType, type SyscoinOwnedReadOptions, type SyscoinOwnedSubmissionOptions } from '../types';
+import { ISyscoinTransactions, KeyringAccountType, accountType, type SyscoinOwnedReadOptions, type SyscoinOwnedSubmissionOptions, type SyscoinRetainedSubmissionOptions } from '../types';
 import { ExcludedOutpoint } from '../utils/excluded-utxos';
 import { type PsbtAccountScope } from '../utils/psbt-account-scope';
 import type { SyscoinHDSigner } from '../signers';
@@ -115,5 +115,7 @@ export declare class SyscoinTransactionsCore implements ISyscoinTransactions {
         psbt: any;
     }, ownedRead: SyscoinOwnedReadOptions) => Promise<any>;
     sendTransaction: (rawTransaction: string, authority: SyscoinOwnedSubmissionOptions) => Promise<ITxid>;
+    /** Replay only the bytes and destination authenticated by the selected wallet. */
+    replayRetainedTransaction: (txid: string, authority: SyscoinRetainedSubmissionOptions) => Promise<ITxid>;
 }
 export {};

package/types/types.d.ts

@@ -9,6 +9,7 @@ import { SyscoinHDSigner } from './signers';
 import { TrezorKeyring } from './trezor';
 import type { KeyringCore } from './keyring-core';
 import type { PreparedEvmTransaction } from './transactions/prepared-evm';
+import type { OwnedUtxoRpcVerification } from '@sidhujag/sysweb3-network';
 export type AccessListish = Array<{
     address: string;
     storageKeys: string[];
@@ -37,10 +38,15 @@ export type EvmLocalAccount = {
     privateKey: string;
     publicKey: string;
 };
+export type EvmWalletNonce = Readonly<{
+    nonce: number;
+    source: 'automatic' | 'manual';
+}>;
 export interface IEvmSendOptions {
     /** Synchronous host admission, rechecked immediately before signing and broadcast. */
     assertCurrent: () => void;
     mode: 'reviewed-native' | 'specialized';
+    walletNonce?: EvmWalletNonce;
 }
 export type EvmFormattedSendArguments = [
     approvedTransaction: PreparedEvmTransaction,
@@ -75,8 +81,30 @@ type EvmOriginalAdmission<Original> = {
 };
 export type IEvmReplacementOptions = EvmReplacementFeeApproval & EvmOriginalAdmission<TransactionResponse> & {
     beforeBroadcast?: () => void;
+    /** Exact signed original obtained from the host's protected cancellation lineage. */
+    retainedCancellation?: string;
 };
-export type IEvmCancellationOptions = EvmReplacementFeeApproval & EvmOriginalAdmission<TransactionResponse | null>;
+export type EvmRetainedCancellationOrigin = Readonly<{
+    kind: 'retained';
+    rawTransaction: string;
+    nonce: number;
+    tipHash: string;
+    feeFloor: Readonly<{
+        type: 0;
+        gasPrice: bigint;
+    } | {
+        type: 2;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+    }>;
+}>;
+export type IEvmCancellationOptions = EvmReplacementFeeApproval & ((EvmOriginalAdmission<TransactionResponse | null> & {
+    origin?: never;
+}) | (Omit<EvmOriginalAdmission<never>, 'validateOriginal'> & {
+    /** The host owns the protected journal lineage and its live admission. */
+    origin: EvmRetainedCancellationOrigin;
+    validateOriginal?: never;
+}));
 export interface IEthereumTransactions {
     cancelSentTransaction: (txHash: string, isLegacy: boolean | undefined, fallbackNonce: number | undefined, options: IEvmCancellationOptions) => Promise<{
         error?: boolean;
@@ -146,6 +174,23 @@ export type SyscoinSubmissionDescriptor = Readonly<{
 export type SyscoinOwnedSubmissionOptions = SyscoinOwnedReadOptions & Readonly<{
     prepare: (descriptor: SyscoinSubmissionDescriptor) => Promise<void>;
 }>;
+export type SyscoinRetainedSubmissionOwner = Readonly<{
+    account: Readonly<{
+        id: number;
+        type: string;
+        xpub: string;
+    }>;
+    chainId: number;
+    genesisHash: string;
+    slip44: number;
+}>;
+export type SyscoinRetainedSubmission = SyscoinSubmissionDescriptor & Readonly<{
+    owner: SyscoinRetainedSubmissionOwner;
+}>;
+/** The trusted wallet host reads the authenticated journal, not a UI payload. */
+export type SyscoinRetainedSubmissionOptions = SyscoinOwnedSubmissionOptions & Pick<OwnedUtxoRpcVerification, 'readJson'> & Readonly<{
+    readRetained: (owner: SyscoinRetainedSubmissionOwner, txid: string) => Promise<SyscoinRetainedSubmission | undefined>;
+}>;
 export interface ISyscoinTransactions {
     getEstimateSysTransactionFee: ({ txOptions, amount, receivingAddress, feeRate, token, isMax, nativeSweep, excludedOutpoints, }: {
         amount: number | string;
@@ -168,6 +213,7 @@ export interface ISyscoinTransactions {
     getRecommendedFee: (explorerUrl: string, ownedRead: SyscoinOwnedReadOptions) => Promise<number>;
     decodeRawTransaction: (psbtOrHex: any, isRawHex?: boolean) => any;
     sendTransaction: (rawTransaction: string, authority: SyscoinOwnedSubmissionOptions) => Promise<ITxid>;
+    replayRetainedTransaction: (txid: string, authority: SyscoinRetainedSubmissionOptions) => Promise<ITxid>;
     signPSBT: ({ psbt, isTrezor, isLedger, }: {
         isLedger?: boolean;
         isTrezor?: boolean;
@@ -340,6 +386,8 @@ export interface ILatestUpdateForSysAccount {
     xpub: any;
 }
 export type IReviewedEvmTokenApproval = Readonly<{
+    /** Nonce selected by the host's ordinary wallet policy before signing. */
+    nonce: number;
     assertCurrent: () => void;
     signal: AbortSignal;
 }>;

package/types/utils/excluded-utxos.d.ts

@@ -4,7 +4,7 @@ export interface ExcludedOutpoint {
 }
 export declare const excludedOutpointIds: (outpoints?: readonly ExcludedOutpoint[]) => Set<string>;
 /** Preserve the backend's asset metadata while removing only reserved outputs. */
-export declare const filterExcludedUtxos: (raw: any, excluded: ReadonlySet<string>) => any;
+export declare const filterExcludedUtxos: (raw: any, excluded: ReadonlySet<string>, onExcluded?: (row: any, outpoint: string) => void) => any;
 export declare const assertNoExcludedInputs: (psbt: {
     txInputs: {
         hash: Uint8Array;