@aegis-engine/core 0.9.2 → 0.11.0

package/dist/config/constants.d.ts

@@ -19,4 +19,4 @@ export declare const AEGIS_SWAP_DEFAULT_METADATA_ENDPOINT = "https://aegis.marke
 export declare const AGGREGATED_SWAP_FEE_BPS = 50;
 export declare const AGGREGATED_SWAP_FEE_RECIPIENT: `0x${string}`;
 export declare const AGGREGATED_SWAP_KYBER_ROUTER: `0x${string}`;
-export declare const AGGREGATED_SWAP_SUPPORTED_CHAIN_IDS: readonly [1];
+export declare const AGGREGATED_SWAP_SUPPORTED_CHAIN_IDS: readonly [1, 56, 130, 8453];

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

@@ -4,12 +4,14 @@ export { assertUint128, buildExactInSwapTransaction, buildExactOutSwapTransactio
 export type { BuiltSwapTransaction, ExecutionBatch, PermitBatch, PermitDetails, SignedPermitBatch, SwapOutputFee } from './encoding.js';
 export { getZeroForOne, outputFeeForQuote, quoteSpendAmount, reconcileSubmitQuote, sameQuote } from './quote.js';
 export type { DirectSwapQuote, ReconciledSubmitQuote, SwapQuoteMode } from './quote.js';
-export { AggregatedSwapBuildMismatchError, aggregatedSwapErrorMessage, fetchAggregatedSwapQuote } from './quote/aggregatedSwapQuote.js';
+export { AggregatedSwapBuildMismatchError, aggregatedSwapErrorMessage, assertAggregatedQuoteLiquidity, fetchAggregatedSwapQuote } from './quote/aggregatedSwapQuote.js';
+export { NoAegisRouteError, assertAegisOnlyRouteLegs } from './quote/routeProvider.js';
+export type { NoAegisRouteReason } from './quote/routeProvider.js';
 export type { AggregatedSwapExecutionIntent } from './quote/aggregatedSwapQuote.js';
 export { AggregatedSwapCalldataError } from './quote/kyberCalldata.js';
 export type { AggregatedSwapQuote, AggregatedSwapRoute, HopInfo } from './types/aggregatedSwap.js';
-export { KyberSwapApiError, KyberSwapContractError, KyberSwapResourceLimitError, buildKyberSwapRoute, fetchKyberSwapRoute, isRetryableKyberSwapError } from './services/kyberSwap.js';
-export type { KyberSwapBuild, KyberSwapError, KyberSwapFeeParams, KyberSwapRoute, KyberSwapRouteLeg, KyberSwapRouteSummary } from './services/kyberSwap.js';
+export { KYBER_AEGIS_LIQUIDITY_SOURCE, KyberSwapApiError, KyberSwapContractError, KyberSwapResourceLimitError, buildKyberSwapRoute, fetchKyberSwapRoute, isRetryableKyberSwapError } from './services/kyberSwap.js';
+export type { AggregatedSwapLiquiditySources, KyberSwapBuild, KyberSwapError, KyberSwapFeeParams, KyberSwapRoute, KyberSwapRouteLeg, KyberSwapRouteSummary } from './services/kyberSwap.js';
 export { approveErc20Spender, approveErc20ToPermit2, approvePermit2ToRouter, buildSignedPermitBatch, DEFAULT_PERMIT_EXPIRATION_SECONDS, hasUsablePermit2Allowance, isUnlimitedErc20Approval, isUnlimitedPermit2Approval, MAX_UINT160, MAX_UINT256, PERMIT2_FAR_FUTURE_EXPIRATION, readErc20Allowance, readPermit2RouterAllowance, SWAP_TX_DEADLINE_SECONDS, UNLIMITED_ERC20_FLOOR, UNLIMITED_PERMIT2_FLOOR } from './permit.js';
 export { fetchGlobalTokenMetadata, resolveTokenIconUrl } from './metadata.js';
 export type { AegisSwapGlobalTokenMetadata, TokenMetadataByAddress } from './metadata.js';

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,6 +1,8 @@
 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';
 export declare function aggregatedSwapErrorMessage(error: unknown, fallbackMessage: string): string;
 export declare class AggregatedSwapBuildMismatchError extends UserFacingError {
@@ -16,6 +18,18 @@ 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;
-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>;
+/**
+ * Re-checks, immediately before signing, that an executable quote was built
+ * under Aegis-only routing and that every hop it reports is an Aegis pool.
+ * 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, 
+/** 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

@@ -0,0 +1,79 @@
+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';
+export type NoAegisRouteReason = 'no-route' | 'non-aegis-leg';
+/**
+ * Aegis-only routing found no executable path. `reason` separates "the
+ * provider has no all-Aegis path" from "the provider answered with a path that
+ * leaves Aegis pools", which is refused rather than trusted.
+ */
+export declare class NoAegisRouteError extends UserFacingError {
+    readonly reason: NoAegisRouteReason;
+    readonly detail?: string;
+    constructor(reason: NoAegisRouteReason, detail?: string);
+}
+/**
+ * Fails closed unless the route is non-empty and every hop of every split is
+ * tagged with Kyber's Aegis source. The tag is Kyber's own attribution; there
+ * is deliberately no pool-id allowlist on top of it.
+ */
+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 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;
+        tokenOut: Address;
+        amountIn: bigint;
+        origin?: Address | null;
+        fee: KyberSwapFeeParams | null;
+        liquiditySources: AggregatedSwapLiquiditySources;
+        /** Read client for providers that quote on-chain. */
+        publicClient?: PublicClient;
+        signal?: AbortSignal;
+    }): Promise<AggregatedRoute>;
+    build(args: {
+        chainId: number;
+        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<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/services/kyberSwap.d.ts

@@ -55,6 +55,14 @@ export type KyberSwapBuild = {
      */
     deadline?: number;
 };
+/**
+ * Liquidity the aggregator may route through. `'aegis'` restricts Kyber to the
+ * Aegis-hooked Uniswap v4 pools it indexes as {@link KYBER_AEGIS_LIQUIDITY_SOURCE};
+ * `'any'` leaves source selection to Kyber.
+ */
+export type AggregatedSwapLiquiditySources = 'aegis' | 'any';
+/** Kyber's liquidity-source id for Uniswap v4 pools that use the Aegis hook. */
+export declare const KYBER_AEGIS_LIQUIDITY_SOURCE = "uniswap-v4-aegis";
 export type KyberSwapError = {
     code?: number;
     message?: string;
@@ -93,13 +101,15 @@ export declare class KyberSwapResourceLimitError extends Error {
     });
 }
 export declare function isRetryableKyberSwapError(error: unknown): boolean;
-export declare function fetchKyberSwapRoute({ tokenIn, tokenOut, amountIn, chainId, origin, fee, signal, timeoutMs }: {
+export declare function fetchKyberSwapRoute({ tokenIn, tokenOut, amountIn, chainId, origin, fee, liquiditySources, signal, timeoutMs }: {
     tokenIn: Address;
     tokenOut: Address;
     amountIn: string;
     chainId?: number;
     origin?: Address | null;
     fee?: KyberSwapFeeParams | null;
+    /** `'aegis'` sends `includedSources=uniswap-v4-aegis`; defaults to `'any'`. */
+    liquiditySources?: AggregatedSwapLiquiditySources;
     signal?: AbortSignal;
     /** Abort after this many ms (composes with `signal`); defaults to 20s. */
     timeoutMs?: number;

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/dist/types/aggregatedSwap.d.ts

@@ -1,5 +1,6 @@
 import type { Address, Hex } from 'viem';
 import type { AegisSwapToken } from '../config/index.js';
+import type { AggregatedSwapLiquiditySources } from '../services/kyberSwap.js';
 export type HopInfo = {
     dex: string;
     inputToken: AegisSwapToken;
@@ -13,6 +14,12 @@ export type AggregatedSwapQuote = {
     amountOut: bigint;
     gasEstimate: bigint;
     hops: HopInfo[];
+    /**
+     * Liquidity set the route was requested and validated under. `'aegis'`
+     * quotes passed the all-Aegis leg check; execution in Aegis-only mode
+     * re-checks it (and every hop) before signing.
+     */
+    liquiditySources?: AggregatedSwapLiquiditySources;
     routerAddress: Address;
     calldata: Hex | null;
     /**

package/package.json

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