@aegis-engine/core 0.5.0 → 0.7.0

package/dist/swap/authorizePermit.d.ts

@@ -3,6 +3,7 @@ import type { AegisSwapChainConfig } from '../config/index.js';
 import type { SignedPermitBatch } from '../encoding.js';
 import { readPermit2RouterAllowance } from '../permit.js';
 import type { SubmitStatus } from '../transactionProgress.js';
+import type { AegisSwapAuthorizationProgress } from '../actions/types.js';
 import type { AegisSwapApprovalMode, WalletSession } from './types.js';
 /**
  * Produces the Permit2 authorization the swap calldata needs.
@@ -15,7 +16,7 @@ import type { AegisSwapApprovalMode, WalletSession } from './types.js';
  * would have carried, and this returns `null` so the swap proceeds without an
  * inline permit. A user rejection is rethrown untouched.
  */
-export declare function authorizePermit({ wallet, publicClient, activeChain, permit2, router, token, amount, approvalMode, allowanceRead, setStatus }: {
+export declare function authorizePermit({ wallet, publicClient, activeChain, permit2, router, token, amount, approvalMode, allowanceRead, setStatus, onAuthorizationProgress, onWalletRequest, onHash }: {
     wallet: WalletSession;
     publicClient: PublicClient;
     activeChain: AegisSwapChainConfig;
@@ -26,4 +27,7 @@ export declare function authorizePermit({ wallet, publicClient, activeChain, per
     approvalMode: AegisSwapApprovalMode;
     allowanceRead: ReturnType<typeof readPermit2RouterAllowance>;
     setStatus: (status: SubmitStatus) => void;
+    onAuthorizationProgress?: (progress: AegisSwapAuthorizationProgress) => void;
+    onWalletRequest?: () => void;
+    onHash?: (hash: import('viem').Hex) => void;
 }): Promise<SignedPermitBatch | null>;

package/dist/swap/receiptWait.d.ts

@@ -4,9 +4,9 @@ export declare const SWAP_RECEIPT_TIMEOUT_MS: number;
 type OnReplacedParameter = NonNullable<Parameters<PublicClient['waitForTransactionReceipt']>[0]['onReplaced']>;
 /**
  * waitForTransactionReceipt with a hard timeout, mapping viem's timeout error
- * to the SDK's TransactionReceiptTimeoutError (which carries the tx hash so
- * the UI can degrade to an explorer link). Every other failure passes through
- * untouched.
+ * to a submitted-receipt error carrying the latest hash. Terminal replacement
+ * and revert errors remain terminal; every unresolved RPC failure stays
+ * receipt-recoverable instead of making the original call safe to resend.
  */
 export declare function waitForReceiptWithTimeout(args: {
     publicClient: PublicClient;
@@ -14,4 +14,27 @@ export declare function waitForReceiptWithTimeout(args: {
     timeoutMs: number;
     onReplaced?: OnReplacedParameter;
 }): Promise<TransactionReceipt>;
+export type SubmittedReceiptOutcome = Readonly<{
+    status: 'confirmed' | 'reverted' | 'cancelled';
+    hash: Hex;
+    replacesHash?: Hex;
+    receipt: TransactionReceipt;
+}> | Readonly<{
+    status: 'unresolved';
+    hash: Hex;
+    replacesHash?: Hex;
+}>;
+/**
+ * Reconciles one already-submitted transaction without any broadcast path.
+ *
+ * A speed-up (`repriced`) preserves the submitted call. A generic same-nonce
+ * replacement or wallet cancellation does not, so even a successful receipt
+ * for either is reported as cancelled. RPC and timeout failures stay
+ * unresolved because the original transaction may still mine.
+ */
+export declare function reconcileSubmittedReceipt(args: {
+    publicClient: Pick<PublicClient, 'waitForTransactionReceipt'>;
+    hash: Hex;
+    timeoutMs: number;
+}): Promise<SubmittedReceiptOutcome>;
 export {};

package/dist/swap/sendSwapTransaction.d.ts

@@ -2,6 +2,19 @@ import { type Address, type Chain, type Hex, type PublicClient, type Transaction
 import type { AegisSwapReceiptSummary } from '../transactionProgress.js';
 import { type SwapSettlementContext } from './settlement.js';
 import type { AegisSwapSubmitDetails, WalletSession } from './types.js';
+/**
+ * Settlement facts (gas, block, fee) lifted off a mined receipt.
+ *
+ * viem types gasUsed/effectiveGasPrice as required bigints, but a non-EIP-1559
+ * chain or a lean RPC can omit them; fall back to 0n so the summary degrades
+ * gracefully (the view hides zero rows) instead of throwing.
+ */
+export declare function summarizeTransactionReceipt(receipt: {
+    transactionHash: Hex;
+    blockNumber?: bigint;
+    gasUsed?: bigint;
+    effectiveGasPrice?: bigint;
+}): AegisSwapReceiptSummary;
 /**
  * Guarded send pipeline shared by the swap and engine planes.
  *

package/dist/swap/settlement.d.ts

@@ -4,6 +4,7 @@ export type SwapSettlementContext = {
     recipient: Address;
     /** Output token address; zero address or the 0xEeee… sentinel means native. */
     outputToken: Address;
+    inputToken?: Address;
 };
 /**
  * Best-effort decode of what the swap actually settled to the recipient:
@@ -13,3 +14,6 @@ export type SwapSettlementContext = {
  * never failed retroactively over display data.
  */
 export declare function resolveSettledAmountOut(publicClient: PublicClient, receipt: TransactionReceipt, settlement: SwapSettlementContext): Promise<bigint | undefined>;
+/** Receipt-local input transfers, net of token refunds. Native spends have no
+ * Transfer logs and remain unknown here rather than using a block balance guess. */
+export declare function resolveSettledAmountIn(receipt: TransactionReceipt, settlement: SwapSettlementContext): bigint | undefined;

package/dist/transactionProgress.d.ts

@@ -1,4 +1,4 @@
-import type { Hex } from 'viem';
+import type { Address, Hex } from 'viem';
 export type SubmitStatus = 'idle' | 'approving' | 'signing' | 'submitting' | 'success';
 /**
  * On-chain settlement facts pulled from the swap's mined receipt. Raw base
@@ -19,6 +19,8 @@ export type AegisSwapReceiptSummary = {
      * case UIs should keep showing the quote estimate with a "~" affordance.
      */
     settledAmountOut?: bigint;
+    /** Net input-token transfers from the payer in this receipt, after refunds. */
+    settledAmountIn?: bigint;
 };
 export declare function isBusy(status: SubmitStatus): boolean;
 export type TransactionProgressState = 'pending' | 'mining' | 'success' | 'error';
@@ -29,23 +31,87 @@ export type AegisSwapWalletPromptProgress = {
     /** 1-based prompt currently awaiting the wallet; null while idle/mining/terminal. */
     active: number | null;
 };
+/** Immutable token identity recorded when the swap transaction is broadcast. */
+export type AegisSwapStatusTransactionToken = {
+    address: Address;
+    symbol: string;
+};
+/**
+ * Immutable execution identity attached to status snapshots once a transaction
+ * hash exists. Hosts can keep rendering and indexing the submitted swap even
+ * if controlled chain, account, or market props change while it confirms.
+ */
+export type AegisSwapStatusTransactionContext = {
+    hash: Hex;
+    chainId: number;
+    account: Address;
+    inputToken: AegisSwapStatusTransactionToken;
+    outputToken: AegisSwapStatusTransactionToken;
+    explorerUrl: string | null;
+};
 export type TransactionProgressView = {
     state: TransactionProgressState;
     label: string;
     walletPrompts: AegisSwapWalletPromptProgress;
-    /** Calm fill showing completed wallet-provider prompts. */
+    /** Calm fill showing settled rail steps; the final action settles on receipt. */
     completePct: number;
     /** Visual activity layer width; pending/mining sweeps full-width by default. */
     activeWidthPct: number;
+    /**
+     * Steps the rail divides itself into, so a three-step flow reads
+     * 33/66/100 instead of one indivisible half. Presentation only, and separate
+     * from `walletPrompts`: the Engine counts settlement steps it can name, not
+     * provider prompts it cannot predict. Absent when the total is not known
+     * before the first prompt — the rail then stays one continuous bar rather
+     * than inventing a denominator that could grow mid-flight.
+     */
+    steps?: number;
+};
+/**
+ * Chips the top rail divides itself into. Explicit settlement steps when a
+ * producer counts them, else the wallet-prompt plan — which is the swap path's
+ * step count already. Fewer than two is not a division worth drawing, so the
+ * rail stays one continuous bar. Where along those chips the bar sits comes
+ * from `completePct`, so only the count is needed here.
+ */
+export declare function progressRailSteps(view: TransactionProgressView | null | undefined): number | undefined;
+export declare function normalizeProgressCount(value: number): number;
+/** Shared geometry for every widget and host rail. The final action is only
+ * complete after confirmation, even if every wallet prompt has finished. */
+export declare function transactionSequenceProgress({ total, completed, confirmed }: {
+    total: number;
+    completed: number;
+    confirmed?: boolean;
+}): {
+    total: number;
+    completed: number;
+    completePct: number;
+    steps?: number;
 };
-export declare function transactionProgressView({ status, inputSymbol, txHash, actionError, approvalRequired, approvalDone, authorizationRequired }: {
+export declare function transactionProgressView({ status, inputSymbol, txHash, transactionStage, actionError, approvalRequired, approvalPrompts, approvalDone, resetRequired, approvalsCompleted, authorizationRequired, authorizationPrompts, authorizationsCompleted }: {
     status: SubmitStatus;
     inputSymbol: string;
     txHash: Hex | null;
+    /** Which submitted transaction owns txHash during receipt recovery. */
+    transactionStage?: 'permission' | 'swap' | null;
     actionError: string | null;
     approvalRequired: boolean;
+    /** Explicit executor plan, including every prerequisite approval. */
+    approvalPrompts?: number;
     approvalDone: boolean;
+    /** Whether the approval spends an extra approve(0) prompt first. */
+    resetRequired?: boolean;
+    /**
+     * Approval prompts already confirmed on-chain, from the executor's
+     * onApprovalProgress. Only read while approving — the later phases place the
+     * approval step behind them regardless.
+     */
+    approvalsCompleted?: number;
     authorizationRequired: boolean;
+    /** Executor-reported Permit2 prompts; overrides the boolean prediction. */
+    authorizationPrompts?: number;
+    /** Permit2 authorization prompts already completed by the wallet. */
+    authorizationsCompleted?: number;
 }): TransactionProgressView | null;
 export type AegisSwapStatusSnapshot = {
     status: SubmitStatus;
@@ -57,6 +123,17 @@ export type AegisSwapStatusSnapshot = {
     /** Rail geometry; null while idle. */
     completePct: number | null;
     activeWidthPct: number | null;
+    /**
+     * Segmented rail chip count; null for a continuous or hidden rail.
+     * Optional so existing host-authored snapshot fixtures may omit it.
+     */
+    steps?: number | null;
     txHash: Hex | null;
+    /**
+     * Submission-time chain, account, and asset identity for `txHash`. Null
+     * before broadcast. Optional so existing host-authored snapshot fixtures
+     * remain source-compatible.
+     */
+    transaction?: AegisSwapStatusTransactionContext | null;
     error: string | null;
 };

package/dist/wallet.d.ts

@@ -27,7 +27,7 @@ export declare function getProviderAccount(provider: Eip1193Provider): Promise<A
 export declare function requestProviderAccount(provider: Eip1193Provider): Promise<Address | null>;
 export declare function getProviderChainId(provider: Eip1193Provider): Promise<number | null>;
 export declare function switchProviderChain(provider: Eip1193Provider, chain: number | ProviderChainConfig): Promise<void>;
-export declare function createSwapPublicClient(chain: Chain, rpcUrls: readonly string[]): PublicClient;
+export declare function createSwapPublicClient(chain: Chain, rpcUrls: readonly string[], readProvider?: Eip1193Provider): PublicClient;
 export declare function subscribeProvider(provider: Eip1193Provider, handlers: {
     onAccountsChanged?: () => void;
     onChainChanged?: () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aegis-engine/core",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "React-free Aegis Swap and Engine quoting, risk, approval, and execution operations.",
   "license": "MIT",
   "type": "module",