@aegis-engine/core 0.6.0 → 0.8.0

package/dist/services/kyberSwap.d.ts

@@ -80,6 +80,18 @@ export declare class KyberSwapContractError extends Error {
         issues: z.core.$ZodIssue[];
     });
 }
+export declare class KyberSwapResourceLimitError extends Error {
+    readonly ruleId = "REMOTE-LIMIT-001";
+    readonly endpoint: string;
+    readonly limit: number;
+    readonly actual?: number;
+    constructor({ endpoint, limit, actual, resource }: {
+        endpoint: string;
+        limit: number;
+        actual?: number;
+        resource: string;
+    });
+}
 export declare function isRetryableKyberSwapError(error: unknown): boolean;
 export declare function fetchKyberSwapRoute({ tokenIn, tokenOut, amountIn, chainId, origin, fee, signal, timeoutMs }: {
     tokenIn: Address;

package/dist/swap/authorizePermit.d.ts

@@ -1,4 +1,4 @@
-import type { Address, PublicClient } from 'viem';
+import type { Address, Hex, PublicClient } from 'viem';
 import type { AegisSwapChainConfig } from '../config/index.js';
 import type { SignedPermitBatch } from '../encoding.js';
 import { readPermit2RouterAllowance } from '../permit.js';
@@ -9,14 +9,14 @@ import type { AegisSwapApprovalMode, WalletSession } from './types.js';
  * Produces the Permit2 authorization the swap calldata needs.
  *
  * Tries an off-chain Permit2 signature first (`null` calldata permit when the
- * on-chain allowance already covers the spend). Wallets that cannot produce an
- * EOA-style typed-data signature Permit2 can verify — undeployed smart accounts
- * sign ERC-6492, some wallets refuse `eth_signTypedData_v4` — fall back to an
- * on-chain Permit2 approval scoped to the same amount and expiration the permit
- * would have carried, and this returns `null` so the swap proceeds without an
- * inline permit. A user rejection is rethrown untouched.
+ * on-chain allowance already covers the spend), then checks the resolved
+ * signature the way Permit2 will — see `isPermit2AcceptableSignature` for the
+ * shapes that fail. Only explicit typed-data unsupported-method errors use the
+ * on-chain spending-cap fallback. A returned but invalid signature, a user
+ * rejection, or any transport/internal RPC failure stops the attempt; none of
+ * those proves the wallet lacks typed-data support.
  */
-export declare function authorizePermit({ wallet, publicClient, activeChain, permit2, router, token, amount, approvalMode, allowanceRead, setStatus, onAuthorizationProgress, onWalletRequest, onHash }: {
+export declare function authorizePermit({ wallet, publicClient, activeChain, permit2, router, token, amount, approvalMode, allowanceRead, signal, setStatus, onAuthorizationProgress, onWalletRequest, onHash }: {
     wallet: WalletSession;
     publicClient: PublicClient;
     activeChain: AegisSwapChainConfig;
@@ -26,8 +26,10 @@ export declare function authorizePermit({ wallet, publicClient, activeChain, per
     amount: bigint;
     approvalMode: AegisSwapApprovalMode;
     allowanceRead: ReturnType<typeof readPermit2RouterAllowance>;
+    /** Stops preparation before a signature or approval reaches the wallet. */
+    signal?: AbortSignal;
     setStatus: (status: SubmitStatus) => void;
     onAuthorizationProgress?: (progress: AegisSwapAuthorizationProgress) => void;
     onWalletRequest?: () => void;
-    onHash?: (hash: import('viem').Hex) => void;
+    onHash?: (hash: Hex) => void;
 }): Promise<SignedPermitBatch | null>;

package/dist/swap/executeSwapTransaction.d.ts

@@ -1,3 +1,4 @@
+import type { AegisTransactionObservation } from './receiptWait.js';
 import { type Hex, type PublicClient } from 'viem';
 import type { AegisSwapChainConfig, AegisSwapMarket, AegisSwapToken } from '../config/index.js';
 import { type SignedPermitBatch } from '../encoding.js';
@@ -22,7 +23,7 @@ export type SwapExecutionResult = {
  * or reverted receipt. Setting the success status and the post-success refreshes
  * stay with the caller.
  */
-export declare function executeSwapTransaction({ wallet, publicClient, activeChain, market, inputToken, outputToken, swapQuote, permit, setStatus, setTxHash, onSubmitted }: {
+export declare function executeSwapTransaction({ wallet, publicClient, activeChain, market, inputToken, outputToken, swapQuote, permit, signal, setStatus, setTxHash, onSubmitted, onTransactionObservation }: {
     wallet: WalletSession;
     publicClient: PublicClient;
     activeChain: AegisSwapChainConfig;
@@ -31,7 +32,10 @@ export declare function executeSwapTransaction({ wallet, publicClient, activeCha
     outputToken: AegisSwapToken;
     swapQuote: DirectSwapQuote;
     permit: SignedPermitBatch | null;
+    /** Cancels preparation before the swap transaction is broadcast. */
+    signal?: AbortSignal;
     setStatus: (status: SubmitStatus) => void;
     setTxHash: (hash: Hex | null) => void;
+    onTransactionObservation?: (event: AegisTransactionObservation) => void;
     onSubmitted?: (hash: Hex, swap?: AegisSwapSubmitDetails) => void;
 }): Promise<SwapExecutionResult>;

package/dist/swap/receiptWait.d.ts

@@ -14,15 +14,24 @@ export declare function waitForReceiptWithTimeout(args: {
     timeoutMs: number;
     onReplaced?: OnReplacedParameter;
 }): Promise<TransactionReceipt>;
+/** Read-only execution evidence. It contains identity, never executable intent. */
+export type AegisTransactionObservation = Readonly<{
+    executionChanged?: boolean;
+    hash: Hex;
+    status: 'submitted' | 'confirmed' | 'reverted' | 'cancelled';
+    replacesHash?: Hex;
+}>;
 export type SubmittedReceiptOutcome = Readonly<{
     status: 'confirmed' | 'reverted' | 'cancelled';
     hash: Hex;
     replacesHash?: Hex;
+    executionChanged?: boolean;
     receipt: TransactionReceipt;
 }> | Readonly<{
     status: 'unresolved';
     hash: Hex;
     replacesHash?: Hex;
+    executionChanged?: boolean;
 }>;
 /**
  * Reconciles one already-submitted transaction without any broadcast path.

package/dist/swap/sendSwapTransaction.d.ts

@@ -1,5 +1,6 @@
 import { type Address, type Chain, type Hex, type PublicClient, type TransactionReceipt } from 'viem';
 import type { AegisSwapReceiptSummary } from '../transactionProgress.js';
+import { type AegisTransactionObservation } from './receiptWait.js';
 import { type SwapSettlementContext } from './settlement.js';
 import type { AegisSwapSubmitDetails, WalletSession } from './types.js';
 /**
@@ -47,6 +48,8 @@ export declare function sendGuardedTransactionAndAwait(args: {
     signal?: AbortSignal;
     cancelledMessage: string;
     revertedMessage: string;
+    onTransactionObservation?: (event: AegisTransactionObservation) => void;
+    onWalletRequest?: () => void;
     onHash?: (hash: Hex | null) => void;
     onSubmitted?: (hash: Hex) => void;
 }): Promise<{
@@ -62,6 +65,8 @@ export declare function sendSwapTransactionAndAwait(args: {
     data: Hex;
     value: bigint;
     gas?: bigint;
+    /** Cancels only before a transaction hash exists. */
+    signal?: AbortSignal;
     swapDetails: AegisSwapSubmitDetails;
     /**
      * When provided, the summary also carries `settledAmountOut` decoded from
@@ -69,6 +74,8 @@ export declare function sendSwapTransactionAndAwait(args: {
      * native). Best-effort: decoding failures leave the field undefined.
      */
     settlement?: SwapSettlementContext;
+    onTransactionObservation?: (event: AegisTransactionObservation) => void;
+    onWalletRequest?: () => void;
     onHash?: (hash: Hex | null) => void;
     onSubmitted?: (hash: Hex, swap?: AegisSwapSubmitDetails) => void;
 }): Promise<{

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/swap/trustedMarket.d.ts

@@ -0,0 +1,25 @@
+import type { AegisPoolKey, AegisSwapMarket } from '../config/index.js';
+import { UserFacingError } from '../errors.js';
+/**
+ * DIRECT-MARKET-001
+ *
+ * Backend market DTOs are discovery data, not execution authorization. This
+ * catalogue is shipped with Core so a coherently malicious `/v1/config` plus
+ * `/v1/markets` response cannot introduce a new token pair, pool key, hook, or
+ * signing target. Adding a backend-executable pool therefore requires a
+ * reviewed SDK release.
+ */
+export declare const DIRECT_SWAP_MARKET_TRUST_RULE_ID: "DIRECT-MARKET-001";
+export declare class DirectSwapMarketTrustError extends UserFacingError {
+    readonly ruleId: "DIRECT-MARKET-001";
+    constructor(detail?: string);
+}
+export declare function isDirectSwapMarketTrusted(market: AegisSwapMarket): boolean;
+export declare function assertDirectSwapMarketTrusted(market: AegisSwapMarket): void;
+export declare function assertDirectSwapPoolKeyMatchesMarket(market: AegisSwapMarket, poolKey: AegisPoolKey): void;
+/**
+ * Explicit exception path for an embedding application's own static pool
+ * configuration. Never call this for network or storage data. The returned
+ * object is the same identity that Core must receive at quote and send time.
+ */
+export declare function authorizeHostDirectSwapMarket<T extends AegisSwapMarket>(market: T): T;