@sidhujag/sysweb3-keyring 2.0.0 → 2.1.1

package/types/transactions/ethereum.d.ts

@@ -3,6 +3,7 @@ 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 { type CaptureEvmSubmission } from './evm-submission';
 import type { LedgerKeyring } from '../ledger';
 import type { TrezorKeyring } from '../trezor';
 /** Minimal trusted device capabilities used by EVM transaction routing. */
@@ -18,6 +19,7 @@ export declare class EthereumTransactions<TLedger extends EthereumLedgerSigner |
     ledgerSigner: TLedger;
     private getNetwork;
     private captureSigningContext?;
+    private readonly captureSubmissionLifecycle?;
     private abortController;
     private getDecryptedPrivateKey;
     private gasOverrides;
@@ -35,11 +37,12 @@ export declare class EthereumTransactions<TLedger extends EthereumLedgerSigner |
         activeAccountId: number;
         activeAccountType: KeyringAccountType;
         activeNetwork: INetwork;
-    }, ledgerSigner: TLedger, trezorSigner: TTrezor, captureSigningContext?: () => () => void);
+    }, ledgerSigner: TLedger, trezorSigner: TTrezor, captureSigningContext?: () => () => void, captureSubmissionLifecycle?: CaptureEvmSubmission);
     private requireLedgerSigner;
     private requireTrezorSigner;
     private assertHardwareSignerAvailable;
     private captureEvmSigningContext;
+    private captureSubmission;
     get web3Provider(): CustomJsonRpcProvider;
     private ensureProvidersInitialized;
     private isUtxoNetwork;
@@ -61,20 +64,17 @@ export declare class EthereumTransactions<TLedger extends EthereumLedgerSigner |
         value: any;
     }) => string;
     getFeeDataWithDynamicMaxPriorityFeePerGas: (provider?: CustomJsonRpcProvider) => Promise<{
-        gasPrice: BigNumber;
         maxFeePerGas: BigNumber;
         maxPriorityFeePerGas: BigNumber;
-        baseFeePerGas?: undefined;
-    } | {
+        baseFeePerGas?: BigNumber | undefined;
         gasPrice: BigNumber;
-        baseFeePerGas: BigNumber;
-        maxFeePerGas: BigNumber;
-        maxPriorityFeePerGas: BigNumber;
     }>;
     calculateNewGasValues: (oldTxsParams: IGasParams, isForCancel: boolean, isLegacy: boolean) => IGasParams;
     cancelSentTransaction: (txHash: string, isLegacy: boolean | undefined, fallbackNonce: number | undefined, options: IEvmCancellationOptions) => Promise<{
         error?: boolean;
         isCanceled: boolean;
+        transactionNotBroadcast?: boolean;
+        signedTransactionHash?: string;
         maximumFee?: string;
         transaction?: TransactionResponse;
     }>;
@@ -84,6 +84,8 @@ export declare class EthereumTransactions<TLedger extends EthereumLedgerSigner |
         maximumFee?: string;
         error?: boolean;
         isSpeedUp: boolean;
+        transactionNotBroadcast?: boolean;
+        signedTransactionHash?: string;
         transaction?: TransactionResponse;
         code?: string;
         message?: string;
@@ -94,7 +96,7 @@ export declare class EthereumTransactions<TLedger extends EthereumLedgerSigner |
     getRecommendedNonce: (address: string) => Promise<number>;
     getFeeByType: (type: string) => Promise<string>;
     getGasLimit: (toAddress: string) => Promise<number>;
-    getTxGasLimit: (tx: SimpleTransactionRequest) => Promise<any>;
+    getTxGasLimit: (tx: SimpleTransactionRequest) => Promise<BigNumber>;
     getRecommendedGasPrice: (formatted?: boolean) => Promise<string | {
         gwei: string;
         ethers: string;

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

@@ -1,6 +1,7 @@
 import ecc from '@bitcoinerlab/secp256k1';
 import { type Deferrable, type TransactionRequest } from '../ethers-v6';
 import { CustomJsonRpcProvider } from '../providers';
+import { type EvmSubmissionBoundary } from './evm-submission';
 export type EvmLocalAccount = {
     address: string;
     privateKey: string;
@@ -19,8 +20,10 @@ export declare const signDigestHex: (digest: string | Uint8Array, privateKey: st
 export declare const hashPersonalMessage: (message: Uint8Array) => string;
 export declare const signPersonalMessage: (message: string | Uint8Array, privateKey: string | Uint8Array) => string;
 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, 
 /** Synchronous final-envelope check; throw to reject. Promise results are rejected. */
-validateBeforeSign?: (transaction: TransactionRequest) => void) => Promise<any>;
+validateBeforeSign?: (transaction: TransactionRequest) => void, submission?: EvmSubmissionBoundary) => Promise<any>;
 export declare const sameAddress: (left: string, right: string) => boolean;

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

@@ -0,0 +1,48 @@
+export type EvmSubmissionContext = Readonly<{
+    account: Readonly<{
+        id: number;
+        type: string;
+        address: string;
+    }>;
+    network: Readonly<{
+        kind: string;
+        chainId: number;
+        slip44: number;
+        url: string;
+    }>;
+    operation: 'send' | 'cancel' | 'speed-up' | 'erc20' | 'erc721' | 'erc1155';
+    originalHash?: string;
+}>;
+/** Signed wire bytes only; never a key, password or mutable transaction request. */
+export type EvmSignedSubmission = Readonly<{
+    context: EvmSubmissionContext;
+    rawTransaction: string;
+    hash: string;
+    from: string;
+    chainId: string;
+    nonce: number;
+    type: number | null;
+}>;
+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>;
+}>;
+export type CaptureEvmSubmission = (context: EvmSubmissionContext) => EvmSubmissionLifecycle;
+export type EvmSubmissionBoundary = Readonly<{
+    context: EvmSubmissionContext;
+    assertCurrent: () => 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;
+/** Only local stage evidence can label an error as a possibly dispatched send. */
+export declare function evmSubmissionFailure(error: unknown): Readonly<{
+    transactionNotBroadcast: boolean;
+    signedTransactionHash?: string;
+}>;
+/** Preserve local evidence when an existing public API wraps its Error object. */
+export declare function copyEvmSubmissionFailure(source: unknown, target: Error): void;
+/** 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): Promise<T>;

package/types/transactions/index.d.ts

@@ -1,2 +1,3 @@
 export * from './ethereum';
 export * from './syscoin';
+export * from './evm-submission';

package/types/types.d.ts

@@ -81,6 +81,8 @@ export interface IEthereumTransactions {
     cancelSentTransaction: (txHash: string, isLegacy: boolean | undefined, fallbackNonce: number | undefined, options: IEvmCancellationOptions) => Promise<{
         error?: boolean;
         isCanceled: boolean;
+        transactionNotBroadcast?: boolean;
+        signedTransactionHash?: string;
         maximumFee?: string;
         transaction?: TransactionResponse;
     }>;
@@ -106,6 +108,8 @@ export interface IEthereumTransactions {
     sendTransactionWithEditedFee: (txHash: string, isLegacy?: boolean, options?: IEvmReplacementOptions) => Promise<{
         maximumFee?: string;
         isSpeedUp: boolean;
+        transactionNotBroadcast?: boolean;
+        signedTransactionHash?: string;
         transaction?: TransactionResponse;
         error?: boolean;
     }>;