@aegis-engine/core 0.7.0 → 0.8.0

package/dist/internal/guardedWalletTransaction.d.ts

@@ -0,0 +1,31 @@
+import type { Chain, Hex, PublicClient, TransactionReceipt } from 'viem';
+import { type Eip1193Provider } from '../wallet.js';
+import { type AegisTransactionObservation } from '../swap/receiptWait.js';
+/**
+ * Sends one already-prepared wallet transaction through the safety boundary
+ * shared by swaps and authorization writes.
+ *
+ * Preparation and simulation stay with the caller. This helper owns the
+ * invariants that begin immediately before the wallet prompt: verify the
+ * active chain, honor cancellation until a hash exists, publish submitted and
+ * replacement hashes without trusting host callbacks, and reconcile the
+ * receipt. Once submitted, caller cancellation cannot hide the mined result.
+ */
+export declare function runGuardedWalletTransaction(args: {
+    provider: Eip1193Provider;
+    publicClient: PublicClient;
+    chain: Chain;
+    signal?: AbortSignal;
+    timeoutMs: number;
+    submit: () => Promise<Hex>;
+    unreadableChainMessage: string;
+    cancelledMessage: string;
+    revertedMessage: string;
+    onWalletRequest?: () => void;
+    onHash?: (hash: Hex, replacement?: {
+        replacesHash: Hex;
+        executionChanged: boolean;
+    }) => void;
+    onTransactionObservation?: (event: AegisTransactionObservation) => void;
+    onSubmitted?: (hash: Hex) => void;
+}): Promise<TransactionReceipt>;

package/dist/permit.d.ts

@@ -1,8 +1,20 @@
 import { type Address, type Chain, type Hex, type PublicClient } from 'viem';
-import type { Eip1193Provider } from './wallet.js';
+import { type Eip1193Provider } from './wallet.js';
 import type { SignedPermitBatch } from './encoding.js';
 export declare const MAX_UINT160: bigint;
 export declare const MAX_UINT256: bigint;
+/** "No limit" only counts once the standing grant still reads as effectively
+ *  unlimited. Half the type maximum tolerates tokens and Permit2 flows that
+ *  decrement a max grant on spend — an equality test against the maximum would
+ *  re-approve before every swap — while an exact-sized allowance, however large
+ *  against today's amount, never qualifies. */
+export declare const UNLIMITED_ERC20_FLOOR: bigint;
+export declare const UNLIMITED_PERMIT2_FLOOR: bigint;
+/** Whether an ERC-20 grant reads as "no limit" rather than a number worth
+ *  showing — formatting the integer yields a quantity nobody can read. */
+export declare function isUnlimitedErc20Approval(amount: bigint): boolean;
+/** The Permit2 counterpart, against the uint160 wire type's own floor. */
+export declare function isUnlimitedPermit2Approval(amount: bigint): boolean;
 export declare const SWAP_TX_DEADLINE_SECONDS = 600;
 export declare const DEFAULT_PERMIT_EXPIRATION_SECONDS: number;
 export declare const PERMIT2_FAR_FUTURE_EXPIRATION: number;
@@ -14,8 +26,14 @@ export declare function approveErc20ToPermit2(args: {
     token: Address;
     permit2: Address;
     amount?: bigint;
+    /** Stops preparation before the approval is handed to the wallet. */
+    signal?: AbortSignal;
     onWalletRequest?: () => void;
-    onHash?: (hash: Hex) => void;
+    onHash?: (hash: Hex, replacement?: {
+        replacesHash: Hex;
+        executionChanged: boolean;
+    }) => void;
+    onSubmitted?: (hash: Hex) => void;
 }): Promise<Hex>;
 export declare function readErc20Allowance(args: {
     publicClient: PublicClient;
@@ -30,9 +48,25 @@ export declare function approveErc20Spender(args: {
     chain: Chain;
     token: Address;
     spender: Address;
-    onHash?: (hash: Hex) => void;
     amount?: bigint;
+    /** Stops preparation before the approval is handed to the wallet. */
+    signal?: AbortSignal;
+    onWalletRequest?: () => void;
+    onHash?: (hash: Hex, replacement?: {
+        replacesHash: Hex;
+        executionChanged: boolean;
+    }) => void;
+    onSubmitted?: (hash: Hex) => void;
 }): Promise<Hex>;
+/**
+ * Installs a Permit2 -> router spending cap on-chain: the fallback for wallets
+ * whose typed-data signature Permit2 will not accept.
+ *
+ * `amount` follows the same convention as the ERC-20 writers above — omitted
+ * means maximum authority (MAX_UINT160), and an explicit `0n` revokes. Anything
+ * wider than the uint160 wire type is clamped. `expiration` defaults to
+ * Permit2's far-future sentinel.
+ */
 export declare function approvePermit2ToRouter(args: {
     provider: Eip1193Provider;
     publicClient: PublicClient;
@@ -43,8 +77,14 @@ export declare function approvePermit2ToRouter(args: {
     router: Address;
     amount?: bigint;
     expiration?: number;
+    /** Stops preparation before the approval is handed to the wallet. */
+    signal?: AbortSignal;
     onWalletRequest?: () => void;
-    onHash?: (hash: Hex) => void;
+    onHash?: (hash: Hex, replacement?: {
+        replacesHash: Hex;
+        executionChanged: boolean;
+    }) => void;
+    onSubmitted?: (hash: Hex) => void;
 }): Promise<Hex>;
 export declare function readPermit2RouterAllowance(args: {
     publicClient: PublicClient;
@@ -53,7 +93,36 @@ export declare function readPermit2RouterAllowance(args: {
     token: Address;
     router: Address;
 }): Promise<readonly [amount: bigint, expiration: number, nonce: number]>;
-export declare function hasUsablePermit2Allowance(allowance: Awaited<ReturnType<typeof readPermit2RouterAllowance>>, amount: bigint): boolean;
+export declare function hasUsablePermit2Allowance(allowance: Awaited<ReturnType<typeof readPermit2RouterAllowance>>, amount: bigint, sizing?: 'exact' | 'max'): boolean;
+/**
+ * True only when Permit2's own `SignatureVerification` would accept this
+ * signature. It branches on the owner's code, not on the signature's shape: an
+ * address with code is checked through ERC-1271 alone, with no ecrecover
+ * fallback, so an EIP-7702-delegated EOA whose delegate does not implement
+ * `isValidSignature` rejects the ordinary 65-byte signature its own key just
+ * produced. A codeless owner takes the other branch and reverts on any length
+ * other than 64 or 65, which is where an ERC-6492 wrapper from an undeployed
+ * smart account dies.
+ *
+ * viem's `verifyTypedData` is used only for the codeless branch it models
+ * exactly, in `eoa` mode: its default `auto` mode opens with an `eth_call` that
+ * deploys viem's ERC-6492 validator, a blocking round trip sitting between the
+ * wallet signature and the submit on every ordinary swap.
+ *
+ * `false` means the owner refused, never "the check could not run": an RPC
+ * failure throws so the caller cannot mistake it for an unsignable wallet.
+ */
+export declare function isPermit2AcceptableSignature(args: {
+    publicClient: PublicClient;
+    chainId: number;
+    permit2: Address;
+    signed: SignedPermitBatch;
+    /**
+     * The owner's deployed code, read by the caller so a failed read propagates
+     * instead of arriving here as a `false`.
+     */
+    ownerCode: Hex | undefined;
+}): Promise<boolean>;
 export declare function buildSignedPermitBatch(args: {
     provider: Eip1193Provider;
     publicClient: PublicClient;
@@ -67,11 +136,15 @@ export declare function buildSignedPermitBatch(args: {
     /**
      * 'max' signs a MAX_UINT160 permit (still expiring in 30 minutes) so quick
      * follow-up swaps reuse it instead of prompting for a new signature each
-     * time — Permit2 decrements exact-sized permits to zero on transfer.
-     * Defaults to 'exact'.
+     * time — Permit2 decrements exact-sized permits to zero on transfer. It also
+     * re-signs over a merely amount-covering standing cap, because that cap is
+     * not the unlimited authority 'max' asked for. Defaults to 'exact'.
      */
     sizing?: 'exact' | 'max';
     /** Pre-started readPermit2RouterAllowance result to overlap with other RPC work. */
     allowanceRead?: ReturnType<typeof readPermit2RouterAllowance>;
+    /** Stops preparation before typed data is handed to the wallet. */
+    signal?: AbortSignal;
+    /** Fires only when a new typed-data signature is actually requested. */
     onWalletRequest?: () => void;
 }): Promise<SignedPermitBatch | null>;

package/dist/quote/aggregatedSwapQuote.d.ts

@@ -13,5 +13,9 @@ export declare class AggregatedSwapBuildMismatchError extends UserFacingError {
         actual: bigint;
     });
 }
+/** Absolute settlement floor established by the quote the user approved. */
+export type AggregatedSwapExecutionIntent = Readonly<{
+    reviewedAmountOutMinimum: bigint;
+}>;
 export declare function assertAggregatedRouterTrusted(router: Address, chainId: number): void;
-export declare function fetchAggregatedSwapQuote(inputToken: AegisSwapToken, outputToken: AegisSwapToken, amount: bigint, slippageBps: number, mode?: 'exactIn' | 'exactOut', account?: Address | null, signal?: AbortSignal, _publicClient?: PublicClient): Promise<AggregatedSwapQuote>;
+export declare function fetchAggregatedSwapQuote(inputToken: AegisSwapToken, outputToken: AegisSwapToken, amount: bigint, slippageBps: number, mode?: 'exactIn' | 'exactOut', account?: Address | null, signal?: AbortSignal, _publicClient?: PublicClient, executionIntent?: AggregatedSwapExecutionIntent): Promise<AggregatedSwapQuote>;

package/dist/quote/kyberCalldata.d.ts

@@ -189,6 +189,10 @@ export declare const KYBER_META_AGGREGATION_ROUTER_V2_ABI: readonly [{
         readonly type: "uint256";
     }];
 }];
+export type KyberSettlementFeePolicy = Readonly<{
+    receiver: Address;
+    feeBps: number;
+}>;
 export declare class AggregatedSwapCalldataError extends UserFacingError {
     readonly reason: string;
     constructor(reason: string);
@@ -207,5 +211,5 @@ export declare function assertKyberCalldataMatchesQuote(args: {
     recipient: Address;
     /** Lowest acceptable value for the calldata's embedded minReturnAmount. */
     minReturnFloor: bigint;
-    feeRecipient: Address | null;
+    feePolicy: KyberSettlementFeePolicy | null;
 }): void;