@aegis-engine/core 0.10.0 → 0.11.0

package/dist/encoding.d.ts

@@ -33,8 +33,114 @@ export type BuiltSwapTransaction = {
     value: bigint;
 };
 export declare const MAX_UINT128: bigint;
+export declare const AEGIS_ACTION: {
+    readonly SWAP_EXACT_IN_SINGLE: 6;
+    readonly SWAP_EXACT_IN: 7;
+    readonly SWAP_EXACT_OUT_SINGLE: 8;
+    readonly SETTLE: 11;
+    readonly TAKE: 14;
+    readonly TAKE_PORTION: 16;
+    readonly SWEEP: 20;
+};
+export declare const SWAP_EXACT_IN_ABI: readonly [{
+    readonly name: "params";
+    readonly type: "tuple";
+    readonly components: readonly [{
+        readonly name: "currencyIn";
+        readonly type: "address";
+    }, {
+        readonly name: "path";
+        readonly type: "tuple[]";
+        readonly components: readonly [{
+            readonly name: "intermediateCurrency";
+            readonly type: "address";
+        }, {
+            readonly name: "fee";
+            readonly type: "uint24";
+        }, {
+            readonly name: "tickSpacing";
+            readonly type: "int24";
+        }, {
+            readonly name: "hooks";
+            readonly type: "address";
+        }, {
+            readonly name: "hookData";
+            readonly type: "bytes";
+        }];
+    }, {
+        readonly name: "amountIn";
+        readonly type: "uint128";
+    }, {
+        readonly name: "amountOutMinimum";
+        readonly type: "uint128";
+    }];
+}];
+export declare const SETTLE_ABI: readonly [{
+    readonly name: "currency";
+    readonly type: "address";
+}, {
+    readonly name: "amount";
+    readonly type: "uint256";
+}, {
+    readonly name: "payerIsUser";
+    readonly type: "bool";
+}];
+export declare const TAKE_ABI: readonly [{
+    readonly name: "currency";
+    readonly type: "address";
+}, {
+    readonly name: "recipient";
+    readonly type: "address";
+}, {
+    readonly name: "amount";
+    readonly type: "uint256";
+}];
+export declare const TAKE_PORTION_ABI: readonly [{
+    readonly name: "currency";
+    readonly type: "address";
+}, {
+    readonly name: "recipient";
+    readonly type: "address";
+}, {
+    readonly name: "bips";
+    readonly type: "uint256";
+}];
 export declare function assertUint128(value: bigint, label?: string): void;
 export declare function computePoolId(poolKey: AegisPoolKey): Hex;
+/** One hop of an exact-input path: the pool and the currency it pays out. */
+export type AegisPathHop = {
+    poolKey: AegisPoolKey;
+    currencyOut: Address;
+};
+/** V4 PathKeys for a hop list; the quoter and the router read the same shape. */
+export declare function v4PathKeys(path: readonly AegisPathHop[]): {
+    intermediateCurrency: `0x${string}`;
+    fee: number;
+    tickSpacing: number;
+    hooks: `0x${string}`;
+    hookData: Hex;
+}[];
+/**
+ * Multi-hop exact input through the deployed Aegis router: SWAP_EXACT_IN,
+ * SETTLE, optional fee TAKE_PORTION, a fixed TAKE of the net minimum (reverts
+ * the whole swap on a shortfall), then TAKE(OPEN_DELTA) for any surplus.
+ */
+export declare function buildExactInPathTransaction(args: {
+    currencyIn: Address;
+    path: readonly AegisPathHop[];
+    amountIn: bigint;
+    /** Gross floor for the swap action, before the fee portion. */
+    amountOutMinimum: bigint;
+    /** Net payout the recipient must receive after the fee. */
+    amountOutNetMinimum: bigint;
+    recipient: Address;
+    deadline: bigint;
+    permit?: SignedPermitBatch | null;
+    fee?: {
+        recipient: Address;
+        bips: number;
+    } | null;
+}): BuiltSwapTransaction;
 export declare function buildExactInSwapTransaction(args: {
     poolKey: AegisPoolKey;
     zeroForOne: boolean;

package/dist/quote/aegisRouteProvider.d.ts

@@ -0,0 +1,43 @@
+import { type Address, type PublicClient } from 'viem';
+import { type TrustedSwapPool } from '../swap/trustedMarket.js';
+import { type AggregatedRouteProvider } from './routeProvider.js';
+/** Canonical Multicall3; its runtime code is live on Ink (57073). */
+export declare const MULTICALL3_ADDRESS: Address;
+export declare const AEGIS_ROUTE_MAX_HOPS = 3;
+type AegisRouteLeg = {
+    pool: TrustedSwapPool;
+    currencyIn: Address;
+    currencyOut: Address;
+};
+export type AegisRouteCandidate = readonly AegisRouteLeg[];
+export type AegisRouteQuote = {
+    route: AegisRouteCandidate;
+    /** Gross pool output, before the app fee. */
+    amountOut: bigint;
+    gasEstimate: bigint;
+};
+/**
+ * Every simple exact-input path of one to three hops between two tokens, over
+ * the chain's shipped pool catalogue only. Breadth-first, so the direct pool
+ * comes first and shorter paths survive the candidate cap.
+ */
+export declare function enumerateAegisRoutes(chainId: number, tokenIn: Address, tokenOut: Address, maxCandidates?: number): AegisRouteCandidate[];
+/**
+ * Quotes every candidate in ONE eth_call: Multicall3 `aggregate3` with
+ * `allowFailure` over V4Quoter `quoteExactInput`, plus Multicall3's own
+ * `getBlockNumber`, so all results (and the block they share) come from one
+ * state. A failed or malformed sub-call yields `null` for that candidate.
+ */
+export declare function quoteAegisRoutes(publicClient: Pick<PublicClient, 'call'>, routes: readonly AegisRouteCandidate[], amountIn: bigint): Promise<{
+    blockNumber: bigint;
+    quotes: (AegisRouteQuote | null)[];
+}>;
+/** Highest gross output; ties keep the earlier (shorter) candidate. */
+export declare function bestAegisRouteQuote(quotes: readonly (AegisRouteQuote | null)[]): AegisRouteQuote | null;
+/**
+ * In-house provider for chains Kyber does not cover. Routes only through the
+ * shipped pool catalogue and settles on the deployed Aegis router, whose
+ * input is pulled through Permit2.
+ */
+export declare function createAegisRouteProvider(chainId: number): AggregatedRouteProvider;
+export {};

package/dist/quote/aggregatedSwapQuote.d.ts

@@ -1,5 +1,6 @@
 import { type Address, type PublicClient } from 'viem';
 import { type AegisSwapToken } from '../config/index.js';
+import type { SignedPermitBatch } from '../encoding.js';
 import { UserFacingError } from '../errors.js';
 import { type AggregatedSwapLiquiditySources } from '../services/kyberSwap.js';
 import type { AggregatedSwapQuote } from '../types/aggregatedSwap.js';
@@ -17,6 +18,8 @@ export declare class AggregatedSwapBuildMismatchError extends UserFacingError {
 /** Absolute settlement floor established by the quote the user approved. */
 export type AggregatedSwapExecutionIntent = Readonly<{
     reviewedAmountOutMinimum: bigint;
+    /** Signed Permit2 grant for routers that pull input through Permit2. */
+    permit?: SignedPermitBatch | null;
 }>;
 export declare function assertAggregatedRouterTrusted(router: Address, chainId: number): void;
 /**
@@ -25,6 +28,8 @@ export declare function assertAggregatedRouterTrusted(router: Address, chainId:
  * Host-constructed quotes without the commitment fail closed.
  */
 export declare function assertAggregatedQuoteLiquidity(quote: Pick<AggregatedSwapQuote, 'hops' | 'liquiditySources'>, liquiditySources: AggregatedSwapLiquiditySources): void;
-export declare function fetchAggregatedSwapQuote(inputToken: AegisSwapToken, outputToken: AegisSwapToken, amount: bigint, slippageBps: number, mode?: 'exactIn' | 'exactOut', account?: Address | null, signal?: AbortSignal, _publicClient?: PublicClient, executionIntent?: AggregatedSwapExecutionIntent, options?: {
+export declare function fetchAggregatedSwapQuote(inputToken: AegisSwapToken, outputToken: AegisSwapToken, amount: bigint, slippageBps: number, mode?: 'exactIn' | 'exactOut', account?: Address | null, signal?: AbortSignal, 
+/** Read client; the on-chain Ink provider quotes through it. */
+publicClient?: PublicClient, executionIntent?: AggregatedSwapExecutionIntent, options?: {
     liquiditySources?: AggregatedSwapLiquiditySources;
 }): Promise<AggregatedSwapQuote>;

package/dist/quote/routeProvider.d.ts

@@ -1,4 +1,5 @@
-import type { Address } from 'viem';
+import type { Address, PublicClient } from 'viem';
+import type { SignedPermitBatch } from '../encoding.js';
 import { UserFacingError } from '../errors.js';
 import { type AggregatedSwapLiquiditySources, type KyberSwapBuild, type KyberSwapFeeParams, type KyberSwapRoute, type KyberSwapRouteSummary } from '../services/kyberSwap.js';
 import { assertKyberCalldataMatchesQuote } from './kyberCalldata.js';
@@ -21,15 +22,32 @@ export declare class NoAegisRouteError extends UserFacingError {
 export declare function assertAegisOnlyRouteLegs(route: KyberSwapRouteSummary['route']): void;
 /** Maps a provider "no route under these sources" failure to NoAegisRouteError. */
 export declare function toNoAegisRouteError(error: unknown): unknown;
+/**
+ * Provider-neutral route and build shapes. Kyber's wire layout is the
+ * canonical one; another provider fills only the fields it can attest (an
+ * in-house route has no USD values, request id or route composition).
+ */
+export type AggregatedRoute = KyberSwapRoute & {
+    /** Block the route was quoted at, when the provider quotes on-chain. */
+    blockNumber?: bigint;
+};
+type AggregatedRouteBuild = KyberSwapBuild;
 /**
  * Internal seam behind fetchAggregatedSwapQuote: quote → build → validate.
- * KyberSwap is the only implementation. Another provider (for example an
- * in-house Ink router) slots in by returning the same route/build shapes and
- * its own router-specific calldata check, without UI changes.
+ * KyberSwap serves Ethereum, BSC, Unichain and Base; the in-house Aegis
+ * provider serves Ink, where Kyber has no coverage.
  */
 export type AggregatedRouteProvider = {
     readonly id: string;
+    /** Names the route source in user-facing trust errors. */
+    readonly label: string;
     trustedRouter(chainId: number): Address | undefined;
+    /**
+     * Set when the router pulls input through Permit2 (ERC-20 approval to
+     * Permit2, then a Permit2 grant to the router) rather than a direct ERC-20
+     * allowance to the router.
+     */
+    permit2?(chainId: number): Address | undefined;
     quote(args: {
         chainId: number;
         tokenIn: Address;
@@ -38,17 +56,24 @@ export type AggregatedRouteProvider = {
         origin?: Address | null;
         fee: KyberSwapFeeParams | null;
         liquiditySources: AggregatedSwapLiquiditySources;
+        /** Read client for providers that quote on-chain. */
+        publicClient?: PublicClient;
         signal?: AbortSignal;
-    }): Promise<KyberSwapRoute>;
+    }): Promise<AggregatedRoute>;
     build(args: {
         chainId: number;
-        route: KyberSwapRoute;
+        route: AggregatedRoute;
         sender: Address;
         recipient: Address;
         slippageBps: number;
+        /** Absolute net floor the calldata must enforce (Kyber derives it from slippageBps). */
+        amountOutMinimum: bigint;
+        /** Signed Permit2 grant to embed, for Permit2 providers. */
+        permit?: SignedPermitBatch | null;
         signal?: AbortSignal;
-    }): Promise<KyberSwapBuild>;
-    validateRoute(route: KyberSwapRoute, liquiditySources: AggregatedSwapLiquiditySources): void;
+    }): Promise<AggregatedRouteBuild>;
+    validateRoute(route: AggregatedRoute, liquiditySources: AggregatedSwapLiquiditySources): void;
     validateCalldata(args: Parameters<typeof assertKyberCalldataMatchesQuote>[0]): void;
 };
 export declare function aggregatedRouteProviderForChain(chainId: number): AggregatedRouteProvider;
+export {};

package/dist/{sdkRuntime-UJvZ2vPs.js → sdkRuntime-Dcfu-Hbw.js}

@@ -3,7 +3,7 @@ var _s = (e, t, n) => t in e ? Ps(e, t, { enumerable: !0, configurable: !0, writ
 var ie = (e, t, n) => _s(e, typeof t != "symbol" ? t + "" : t, n);
 import { keccak256 as Et, zeroAddress as Ee, erc721Abi as Wt, hashTypedData as Cs, isAddress as on, erc20Abi as Or, encodeFunctionData as Dn, BaseError as ra, ContractFunctionRevertedError as Qi, numberToHex as Ms, encodeAbiParameters as Xi, parseAbiParameters as Rs, RpcRequestError as Zi, isHex as Ji, decodeErrorResult as Ss, ExecutionRevertedError as Ga, getEventSelector as Ze, getAbiItem as Je, parseAbi as aa, toEventSelector as Os } from "viem";
 import "viem/actions";
-import { X as ja, J as Ka } from "./transactionHistory-D3PDVGkr.js";
+import { X as ja, J as Ka } from "./transactionHistory-B-F6o9hW.js";
 class f extends Array {
   constructor(t, n) {
     if (super(t), this.sign = n, t > f.__kMaxLength) throw new RangeError("Maximum BigInt size exceeded");

package/dist/swap/trustedMarket.d.ts

@@ -1,3 +1,4 @@
+import { type Address, type Hex } from 'viem';
 import type { AegisPoolKey, AegisSwapMarket } from '../config/index.js';
 import { UserFacingError } from '../errors.js';
 /**
@@ -10,6 +11,19 @@ import { UserFacingError } from '../errors.js';
  * reviewed SDK release.
  */
 export declare const DIRECT_SWAP_MARKET_TRUST_RULE_ID: "DIRECT-MARKET-001";
+type TrustedTokenIdentity = {
+    address: Address;
+    decimals: number;
+};
+type TrustedDirectSwapMarketIdentity = {
+    chainId: number;
+    poolId: Hex;
+    poolKey: AegisPoolKey;
+    tokens: readonly [TrustedTokenIdentity, TrustedTokenIdentity];
+    router: Address;
+    permit2: Address;
+    quoter: Address;
+};
 export declare class DirectSwapMarketTrustError extends UserFacingError {
     readonly ruleId: "DIRECT-MARKET-001";
     constructor(detail?: string);
@@ -23,3 +37,12 @@ export declare function assertDirectSwapPoolKeyMatchesMarket(market: AegisSwapMa
  * object is the same identity that Core must receive at quote and send time.
  */
 export declare function authorizeHostDirectSwapMarket<T extends AegisSwapMarket>(market: T): T;
+/** A reviewed pool from the shipped catalogue, as multi-hop routing sees it. */
+export type TrustedSwapPool = Pick<TrustedDirectSwapMarketIdentity, 'chainId' | 'poolId' | 'poolKey' | 'router' | 'permit2' | 'quoter'>;
+/**
+ * DIRECT-MARKET-001 applied to routed swaps: the only pools a multi-hop route
+ * may touch are the shipped catalogue's pools on that chain. Host-authorized
+ * markets are deliberately excluded; routing never widens the catalogue.
+ */
+export declare function trustedSwapPoolsForChain(chainId: number): readonly TrustedSwapPool[];
+export {};

package/dist/{transactionHistory-D3PDVGkr.js → transactionHistory-B-F6o9hW.js}

@@ -6908,10 +6908,10 @@ export {
   fd as Q,
   on as R,
   z as S,
-  Yf as T,
+  nh as T,
   Bn as U,
-  nh as V,
-  eh as W,
+  eh as V,
+  Yf as W,
   zf as X,
   Fl as Y,
   hd as Z,

package/package.json

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