@aegis-engine/core 0.1.0

package/dist/config.d.ts

@@ -0,0 +1,119 @@
+import { type Address, type Chain, type Hex } from 'viem';
+export type AegisSwapBuiltInTokenSymbol = 'USDC' | 'WATER' | 'WOOD' | 'GRASS' | 'STONE';
+export type AegisSwapBuiltInAssetSymbol = Exclude<AegisSwapBuiltInTokenSymbol, 'USDC'>;
+export type AegisSwapBuiltInMarketId = 'WATER_USDC' | 'WOOD_USDC' | 'GRASS_USDC' | 'STONE_USDC';
+export type AegisSwapTokenSymbol = string;
+export type AegisSwapFeeConfig = {
+    bps: number;
+    recipient: Address;
+};
+export type AegisSwapToken = {
+    chainId: number;
+    address: Address;
+    name: string;
+    symbol: AegisSwapTokenSymbol;
+    decimals: number;
+    iconUrl?: string | null;
+};
+export type AegisPoolKey = {
+    currency0: Address;
+    currency1: Address;
+    fee: number;
+    tickSpacing: number;
+    hooks: Address;
+};
+export type AegisSwapUniswapV4Contracts = {
+    permit2: Address;
+    quoter: Address;
+    poolManager?: Address;
+    positionDescriptor?: Address;
+    positionManager?: Address;
+    stateView?: Address;
+    universalRouter?: Address;
+    universalRouterV2_1_1?: Address;
+};
+export type AegisSwapUniswapV4ContractsInput = Partial<AegisSwapUniswapV4Contracts>;
+export type AegisSwapMarket = {
+    id: string;
+    chainId: number;
+    symbol: AegisSwapTokenSymbol;
+    poolId: Hex;
+    poolKey: AegisPoolKey;
+    token: AegisSwapToken;
+    counterToken: AegisSwapToken;
+    router: Address;
+    permit2: Address;
+    quoter: Address;
+    label?: string;
+};
+export type AegisSwapChainConfig = {
+    chainId: number;
+    chain: Chain;
+    name: string;
+    router: Address;
+    permit2: Address;
+    quoter: Address;
+    v4Contracts: AegisSwapUniswapV4Contracts;
+    rpcUrls: string[];
+    explorerTxUrl?: (hash: Hex) => string;
+    poolExplorerUrl?: (poolId: Hex, market: AegisSwapMarket) => string;
+    metadataEndpoint?: string | null;
+    fee?: AegisSwapFeeConfig;
+};
+export type AegisSwapChainConfigInput = Partial<Omit<AegisSwapChainConfig, 'chainId' | 'v4Contracts' | 'fee'>> & {
+    chainId?: number;
+    v4Contracts?: AegisSwapUniswapV4ContractsInput;
+};
+export declare function getExplorerUrl(hash: Hex, chain: AegisSwapChainConfig): string;
+export type AegisSwapPoolConfig = {
+    id: string;
+    symbol?: AegisSwapTokenSymbol;
+    chainId?: number;
+    poolKey: AegisPoolKey;
+    poolId?: Hex;
+    token: AegisSwapToken;
+    counterToken: AegisSwapToken;
+    router?: Address;
+    permit2?: Address;
+    quoter?: Address;
+    label?: string;
+};
+export declare const AEGIS_SWAP_CHAIN_ID = 1;
+export declare const AEGIS_SWAP_ROUTER: `0x${string}`;
+export declare const AEGIS_SWAP_HOOK: `0x${string}`;
+export declare const AEGIS_DYNAMIC_FEE_FLAG = 8388608;
+export declare const AEGIS_SWAP_DEFAULT_FEE_BPS = 50;
+export declare const AEGIS_SWAP_DEFAULT_FEE_RECIPIENT: `0x${string}`;
+export declare function createAegisSwapUniswapV4Contracts(input: AegisSwapUniswapV4ContractsInput): AegisSwapUniswapV4Contracts;
+export declare const UNISWAP_V4_CONTRACTS_BY_CHAIN: Record<number, AegisSwapUniswapV4Contracts>;
+export declare const AEGIS_SWAP_MAINNET_UNISWAP_V4_CONTRACTS: AegisSwapUniswapV4Contracts;
+export declare const AEGIS_SWAP_PERMIT2: `0x${string}`;
+export declare const AEGIS_SWAP_V4_QUOTER: `0x${string}`;
+export declare const AEGIS_SWAP_DEFAULT_RPC_URLS: string[];
+export declare const AEGIS_SWAP_DEFAULT_METADATA_ENDPOINT = "https://aegis.markets/graphql/meta";
+export declare const AEGIS_SWAP_MAINNET_CHAIN: AegisSwapChainConfig;
+export declare const AEGIS_SWAP_CHAINS: Record<number, AegisSwapChainConfig>;
+export declare const AEGIS_SWAP_TOKENS: Record<AegisSwapBuiltInTokenSymbol, AegisSwapToken>;
+export declare const AEGIS_SWAP_MARKETS: Record<AegisSwapBuiltInMarketId, AegisSwapMarket>;
+export declare const AEGIS_SWAP_DEFAULT_POOL_IDS: AegisSwapBuiltInMarketId[];
+export declare const AGGREGATED_SWAP_FEE_BPS = 50;
+export declare const AGGREGATED_SWAP_FEE_RECIPIENT: `0x${string}`;
+export type AggregatedSwapToken = AegisSwapToken;
+export type AggregatedSwapDefaultTokenSymbol = 'USDC' | 'USDT' | 'WETH' | 'ETH' | 'WBTC' | 'STETH';
+export type AggregatedSwapWolfGameTokenSymbol = AegisSwapBuiltInTokenSymbol | 'ETH';
+export type AggregatedSwapTokenSymbol = AggregatedSwapDefaultTokenSymbol | AggregatedSwapWolfGameTokenSymbol;
+export declare const AGGREGATED_SWAP_DEFAULT_TOKENS: Record<AggregatedSwapDefaultTokenSymbol, AggregatedSwapToken>;
+export declare const AGGREGATED_SWAP_WOLFGAME_TOKENS: Record<AggregatedSwapWolfGameTokenSymbol, AggregatedSwapToken>;
+export declare const AGGREGATED_SWAP_DEFAULT_TOKEN_LIST: AegisSwapToken[];
+export declare const AGGREGATED_SWAP_WOLFGAME_TOKEN_LIST: AegisSwapToken[];
+export declare const AGGREGATED_SWAP_TOKEN_PRESETS: {
+    readonly default: AegisSwapToken[];
+    readonly wolfgame: AegisSwapToken[];
+};
+export declare const AGGREGATED_SWAP_CURATED_TOKENS: Record<AggregatedSwapDefaultTokenSymbol, AegisSwapToken>;
+export declare function createAegisSwapChainConfig(input: AegisSwapChainConfigInput & {
+    chainId: number;
+}, base?: AegisSwapChainConfig): AegisSwapChainConfig;
+export declare function createAegisSwapChains(chains?: Partial<Record<number, AegisSwapChainConfigInput>>): Record<number, AegisSwapChainConfig>;
+export declare function createAegisSwapPoolMarket(input: AegisSwapPoolConfig, chains?: Record<number, AegisSwapChainConfig>): AegisSwapMarket;
+export declare function createAegisSwapMarketsFromPools(pools: AegisSwapPoolConfig[] | undefined, chains?: Record<number, AegisSwapChainConfig>): Record<string, AegisSwapMarket>;

package/dist/encoding.d.ts

@@ -0,0 +1,57 @@
+import { type Address, type Hex } from 'viem';
+import type { AegisPoolKey } from './config';
+export type ExecutionBatch = {
+    requiresV4Unlock: boolean;
+    actions: Hex;
+    params: Hex[];
+};
+export type PermitDetails = {
+    token: Address;
+    amount: bigint;
+    expiration: number;
+    nonce: number;
+};
+export type PermitBatch = {
+    details: PermitDetails[];
+    spender: Address;
+    sigDeadline: bigint;
+};
+export type SignedPermitBatch = {
+    owner: Address;
+    permitBatch: PermitBatch;
+    signature: Hex;
+};
+export type SwapOutputFee = {
+    recipient: Address;
+    bips: number;
+} | {
+    recipient: Address;
+    amount: bigint;
+};
+export type BuiltSwapTransaction = {
+    calldata: Hex;
+    value: bigint;
+};
+export declare const MAX_UINT128: bigint;
+export declare function assertUint128(value: bigint, label?: string): void;
+export declare function computePoolId(poolKey: AegisPoolKey): Hex;
+export declare function buildExactInSwapTransaction(args: {
+    poolKey: AegisPoolKey;
+    zeroForOne: boolean;
+    amountIn: bigint;
+    amountOutMinimum: bigint;
+    recipient: Address;
+    deadline: bigint;
+    permit?: SignedPermitBatch | null;
+    fee?: SwapOutputFee | null;
+}): BuiltSwapTransaction;
+export declare function buildExactOutSwapTransaction(args: {
+    poolKey: AegisPoolKey;
+    zeroForOne: boolean;
+    amountOut: bigint;
+    amountInMaximum: bigint;
+    recipient: Address;
+    deadline: bigint;
+    permit?: SignedPermitBatch | null;
+    fee?: SwapOutputFee | null;
+}): BuiltSwapTransaction;

package/dist/errors.d.ts

@@ -0,0 +1,3 @@
+export declare function isUserRejectedError(error: unknown): boolean;
+export declare const USER_REJECTED_MESSAGE = "Request rejected.";
+export declare function errorMessage(error: unknown, fallbackMessage: string): string;

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+export { AEGIS_DYNAMIC_FEE_FLAG, AEGIS_SWAP_CHAINS, AEGIS_SWAP_CHAIN_ID, AEGIS_SWAP_DEFAULT_FEE_BPS, AEGIS_SWAP_DEFAULT_FEE_RECIPIENT, AEGIS_SWAP_DEFAULT_METADATA_ENDPOINT, AEGIS_SWAP_DEFAULT_POOL_IDS, AEGIS_SWAP_DEFAULT_RPC_URLS, AEGIS_SWAP_HOOK, AEGIS_SWAP_MAINNET_CHAIN, AEGIS_SWAP_MAINNET_UNISWAP_V4_CONTRACTS, AEGIS_SWAP_MARKETS, AEGIS_SWAP_PERMIT2, AEGIS_SWAP_ROUTER, AEGIS_SWAP_TOKENS, AEGIS_SWAP_V4_QUOTER, AGGREGATED_SWAP_CURATED_TOKENS, AGGREGATED_SWAP_DEFAULT_TOKEN_LIST, AGGREGATED_SWAP_DEFAULT_TOKENS, AGGREGATED_SWAP_TOKEN_PRESETS, AGGREGATED_SWAP_WOLFGAME_TOKEN_LIST, AGGREGATED_SWAP_WOLFGAME_TOKENS, UNISWAP_V4_CONTRACTS_BY_CHAIN, createAegisSwapChainConfig, createAegisSwapChains, createAegisSwapMarketsFromPools, createAegisSwapPoolMarket, createAegisSwapUniswapV4Contracts, getExplorerUrl } from './config';
+export type { AegisPoolKey, AegisSwapBuiltInAssetSymbol, AegisSwapBuiltInMarketId, AegisSwapBuiltInTokenSymbol, AegisSwapChainConfig, AegisSwapChainConfigInput, AegisSwapFeeConfig, AegisSwapMarket, AegisSwapPoolConfig, AegisSwapToken, AegisSwapTokenSymbol, AegisSwapUniswapV4Contracts, AegisSwapUniswapV4ContractsInput, AggregatedSwapDefaultTokenSymbol, AggregatedSwapToken, AggregatedSwapTokenSymbol, AggregatedSwapWolfGameTokenSymbol } from './config';
+export { assertUint128, buildExactInSwapTransaction, buildExactOutSwapTransaction, computePoolId, MAX_UINT128 } from './encoding';
+export type { BuiltSwapTransaction, ExecutionBatch, PermitBatch, PermitDetails, SignedPermitBatch, SwapOutputFee } from './encoding';
+export { fetchDirectSwapQuote, getZeroForOne, outputFeeForQuote, quoteSpendAmount, reconcileSubmitQuote, sameQuote } from './quote';
+export type { DirectSwapQuote, ReconciledSubmitQuote, SwapQuoteMode } from './quote';
+export { aggregatedSwapErrorMessage, fetchAggregatedSwapQuote } from './quote/aggregatedSwapQuote';
+export type { AggregatedSwapQuote, AggregatedSwapRoute, HopInfo } from './types/aggregatedSwap';
+export { KyberSwapApiError, buildKyberSwapRoute, fetchKyberSwapRoute, isRetryableKyberSwapError } from './services/kyberSwap';
+export type { KyberSwapBuild, KyberSwapError, KyberSwapFeeParams, KyberSwapRoute, KyberSwapRouteLeg, KyberSwapRouteSummary } from './services/kyberSwap';
+export { approveErc20Spender, approveErc20ToPermit2, approvePermit2ToRouter, buildSignedPermitBatch, DEFAULT_PERMIT_EXPIRATION_SECONDS, MAX_UINT160, MAX_UINT256, PERMIT2_FAR_FUTURE_EXPIRATION, readErc20Allowance, readPermit2RouterAllowance, SWAP_TX_DEADLINE_SECONDS } from './permit';
+export { fetchGlobalTokenMetadata, getIchiIconGuess, resolveTokenIconUrl } from './metadata';
+export type { AegisSwapGlobalTokenMetadata, TokenMetadataByAddress } from './metadata';
+export { createSwapPublicClient, getInjectedProvider, getProviderAccount, getProviderChainId, isEip1193Provider, normalizeAccount, normalizeWalletConnection, requestProviderAccount, subscribeProvider, switchProviderChain } from './wallet';
+export type { AegisSwapProviderResolver, AegisSwapWalletConnection, Eip1193Provider, ProviderChainConfig } from './wallet';
+export { approveDirectPoolSwapInput, DirectPoolSwapPriceMovedError, executeDirectPoolSwap } from './actions/directPoolSwap';
+export type { DirectPoolSwapApprovalResult } from './actions/directPoolSwap';
+export { approveKyberSwapInput, executeKyberSwap, isNativeToken, KyberSwapPriceMovedError, NATIVE_TOKEN_ADDRESS } from './actions/kyberSwap';
+export type { KyberSwapApprovalResult } from './actions/kyberSwap';
+export { ensureWalletChain, resolveWalletSession, waitForProviderChain } from './actions/wallet';
+export type { AegisSwapActionCallbacks, AegisSwapActionResult } from './actions/types';
+export { estimateSwapGasWithBuffer } from './swap/gas';
+export type { SwapGasRequest } from './swap/gas';
+export type { AegisSwapApprovalMode, AegisSwapSubmitDetails, WalletSession } from './swap/types';
+export { errorMessage, isUserRejectedError } from './errors';
+export { isBusy, transactionProgressView } from './transactionProgress';
+export type { AegisSwapReceiptSummary, AegisSwapStatusSnapshot, AegisSwapWalletPromptProgress, SubmitStatus, TransactionProgressState, TransactionProgressView } from './transactionProgress';
+export { isDocumentVisible, pollUntil, retryOnError } from './polling';

package/dist/metadata.d.ts

@@ -0,0 +1,25 @@
+import { type Address } from 'viem';
+import type { AegisSwapToken } from './config';
+export type AegisSwapGlobalTokenMetadata = {
+    chainId: number | null;
+    address: string | null;
+    symbol: string | null;
+    displayName: string | null;
+    fullName: string | null;
+    decimals: number | null;
+    iconURL: string | null;
+};
+export declare function getIchiIconGuess(symbol: string | null | undefined): string | null;
+export type TokenMetadataByAddress = Record<string, AegisSwapGlobalTokenMetadata>;
+/**
+ * Canonical icon-source order for a token: explicit config URL, the metadata
+ * service, then the ichi naming guess. Public so hosts rendering their own
+ * token marks resolve identically to the widget.
+ */
+export declare function resolveTokenIconUrl(token: AegisSwapToken, metadataByAddress: TokenMetadataByAddress): string | null;
+export declare function fetchGlobalTokenMetadata(args: {
+    endpoint: string;
+    chainId: number;
+    addresses: Address[];
+    signal?: AbortSignal;
+}): Promise<Map<string, AegisSwapGlobalTokenMetadata>>;

package/dist/permit.d.ts

@@ -0,0 +1,70 @@
+import { type Address, type Chain, type Hex, type PublicClient } from 'viem';
+import type { Eip1193Provider } from './wallet';
+import type { SignedPermitBatch } from './encoding';
+export declare const MAX_UINT160: bigint;
+export declare const MAX_UINT256: bigint;
+export declare const SWAP_TX_DEADLINE_SECONDS = 600;
+export declare const DEFAULT_PERMIT_EXPIRATION_SECONDS: number;
+export declare const PERMIT2_FAR_FUTURE_EXPIRATION: number;
+export declare function approveErc20ToPermit2(args: {
+    provider: Eip1193Provider;
+    publicClient: PublicClient;
+    account: Address;
+    chain: Chain;
+    token: Address;
+    permit2: Address;
+    amount?: bigint;
+}): Promise<Hex>;
+export declare function readErc20Allowance(args: {
+    publicClient: PublicClient;
+    token: Address;
+    owner: Address;
+    spender: Address;
+}): Promise<bigint>;
+export declare function approveErc20Spender(args: {
+    provider: Eip1193Provider;
+    publicClient: PublicClient;
+    account: Address;
+    chain: Chain;
+    token: Address;
+    spender: Address;
+    amount?: bigint;
+}): Promise<Hex>;
+export declare function approvePermit2ToRouter(args: {
+    provider: Eip1193Provider;
+    publicClient: PublicClient;
+    account: Address;
+    chain: Chain;
+    token: Address;
+    permit2: Address;
+    router: Address;
+    amount?: bigint;
+    expiration?: number;
+}): Promise<Hex>;
+export declare function readPermit2RouterAllowance(args: {
+    publicClient: PublicClient;
+    permit2: Address;
+    account: Address;
+    token: Address;
+    router: Address;
+}): Promise<readonly [amount: bigint, expiration: number, nonce: number]>;
+export declare function buildSignedPermitBatch(args: {
+    provider: Eip1193Provider;
+    publicClient: PublicClient;
+    account: Address;
+    chainId: number;
+    chain: Chain;
+    permit2: Address;
+    router: Address;
+    token: Address;
+    amount: bigint;
+    /**
+     * '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'.
+     */
+    sizing?: 'exact' | 'max';
+    /** Pre-started readPermit2RouterAllowance result to overlap with other RPC work. */
+    allowanceRead?: ReturnType<typeof readPermit2RouterAllowance>;
+}): Promise<SignedPermitBatch | null>;

package/dist/polling.d.ts

@@ -0,0 +1,3 @@
+export declare function isDocumentVisible(): boolean;
+export declare function retryOnError<T>(read: () => Promise<T>, attempts: number, delayMs: number, stopped?: () => boolean): Promise<T>;
+export declare function pollUntil<T>(read: () => Promise<T>, done: (value: T) => boolean, attempts: number, delayMs: number): Promise<T>;

package/dist/quote/aggregatedSwapQuote.d.ts

@@ -0,0 +1,5 @@
+import { type Address, type PublicClient } from 'viem';
+import { type AegisSwapToken } from '../config';
+import type { AggregatedSwapQuote } from '../types/aggregatedSwap';
+export declare function aggregatedSwapErrorMessage(error: unknown, fallbackMessage: string): string;
+export declare function fetchAggregatedSwapQuote(inputToken: AegisSwapToken, outputToken: AegisSwapToken, amount: bigint, slippageBps: number, mode?: 'exactIn' | 'exactOut', account?: Address | null, signal?: AbortSignal, _publicClient?: PublicClient): Promise<AggregatedSwapQuote>;

package/dist/quote.d.ts

@@ -0,0 +1,59 @@
+import { type Address, type PublicClient } from 'viem';
+import { type SwapOutputFee } from './encoding';
+import type { AegisPoolKey, AegisSwapFeeConfig, AegisSwapMarket, AegisSwapToken } from './config';
+export type SwapQuoteMode = 'exactIn' | 'exactOut';
+export type DirectSwapQuote = {
+    mode: SwapQuoteMode;
+    poolKey: AegisPoolKey;
+    zeroForOne: boolean;
+    amountIn: bigint;
+    /** Net output the user is quoted to receive (gross minus the widget fee). */
+    amountOut: bigint;
+    /** Pool output before the widget fee is taken. */
+    grossAmountOut: bigint;
+    /**
+     * Swap-action output floor, enforced on-chain. Semantics differ by mode:
+     * - exactIn: gross floor sized so the user still nets `userAmountOutMinimum`
+     *   after the fee portion is taken.
+     * - exactOut: equals `grossAmountOut` (output is fixed; the on-chain
+     *   protection is `amountInMaximum`). Informational only.
+     */
+    amountOutMinimum: bigint;
+    /** exactOut: input ceiling enforced on-chain. exactIn: equals `amountIn`. */
+    amountInMaximum: bigint;
+    /** Minimum the user nets after slippage and fee. Display/reconciliation value. */
+    userAmountOutMinimum: bigint;
+    /** Estimated widget fee in output currency (exact for exactOut, quote-time estimate for exactIn). */
+    feeAmount: bigint;
+    feeBps: number;
+    feeRecipient: Address | null;
+    gasEstimate: bigint;
+};
+export declare function getZeroForOne(poolKey: AegisPoolKey, tokenIn: AegisSwapToken): boolean;
+export declare function fetchDirectSwapQuote(args: {
+    publicClient: PublicClient;
+    account: Address;
+    market: AegisSwapMarket;
+    tokenIn: AegisSwapToken;
+    tokenOut: AegisSwapToken;
+    mode: SwapQuoteMode;
+    amount: bigint;
+    slippageBps: number;
+    fee?: AegisSwapFeeConfig | null;
+    signal?: AbortSignal;
+}): Promise<DirectSwapQuote>;
+export type ReconciledSubmitQuote = {
+    quote: DirectSwapQuote;
+    /**
+     * True when the fresh quote can no longer satisfy the protection the user
+     * saw (exactIn: output below the displayed minimum; exactOut: input above
+     * the displayed maximum). Callers should surface the fresh quote instead of
+     * submitting.
+     */
+    priceMovedBeyondTolerance: boolean;
+};
+export declare function sameQuote(a: DirectSwapQuote, b: DirectSwapQuote): boolean;
+export declare function reconcileSubmitQuote(displayed: DirectSwapQuote | null, fresh: DirectSwapQuote): ReconciledSubmitQuote;
+/** The input-side amount a swap may spend: the bound for allowances and permits. */
+export declare function quoteSpendAmount(quote: DirectSwapQuote): bigint;
+export declare function outputFeeForQuote(quote: DirectSwapQuote): SwapOutputFee | null;

package/dist/services/kyberSwap.d.ts

@@ -0,0 +1,84 @@
+import { type Address, type Hex } from 'viem';
+export type KyberSwapFeeParams = {
+    feeAmount: string;
+    chargeFeeBy: 'currency_in' | 'currency_out';
+    isInBps: boolean;
+    feeReceiver: Address;
+};
+export type KyberSwapRouteLeg = {
+    pool?: string;
+    tokenIn?: Address;
+    tokenOut?: Address;
+    swapAmount?: string;
+    amountOut?: string;
+    exchange?: string;
+    poolType?: string;
+};
+export type KyberSwapRouteSummary = {
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: string;
+    amountOut: string;
+    amountInUsd?: string;
+    amountOutUsd?: string;
+    gas?: string;
+    gasEstimate?: string;
+    gasUsd?: string;
+    priceImpact?: number;
+    route?: KyberSwapRouteLeg[][];
+    routeComposition?: Array<{
+        name: string;
+        part: number;
+    }>;
+    extraFee?: KyberSwapFeeParams | Record<string, unknown>;
+};
+export type KyberSwapRoute = {
+    routeSummary: KyberSwapRouteSummary;
+    routerAddress: Address;
+    requestId?: string;
+};
+export type KyberSwapBuild = {
+    amountIn: string;
+    amountOut: string;
+    gas?: string;
+    gasUsd?: string;
+    data: Hex;
+    routerAddress: Address;
+    transactionValue?: string;
+    requestId?: string;
+};
+export type KyberSwapError = {
+    code?: number;
+    message?: string;
+};
+export declare class KyberSwapApiError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly code?: number;
+    readonly body?: unknown;
+    constructor({ status, statusText, code, message, body }: {
+        status: number;
+        statusText: string;
+        code?: number;
+        message: string;
+        body?: unknown;
+    });
+}
+export declare function isRetryableKyberSwapError(error: unknown): boolean;
+export declare function fetchKyberSwapRoute({ tokenIn, tokenOut, amountIn, chainId, origin, fee, signal }: {
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: string;
+    chainId?: number;
+    origin?: Address | null;
+    fee?: KyberSwapFeeParams | null;
+    signal?: AbortSignal;
+}): Promise<KyberSwapRoute>;
+export declare function buildKyberSwapRoute({ routeSummary, sender, recipient, slippageBps, chainId, signal }: {
+    routeSummary: KyberSwapRouteSummary;
+    sender: Address;
+    recipient: Address;
+    slippageBps: number;
+    chainId?: number;
+    signal?: AbortSignal;
+}): Promise<KyberSwapBuild>;

package/dist/swap/authorizePermit.d.ts

@@ -0,0 +1,29 @@
+import type { Address, PublicClient } from 'viem';
+import type { AegisSwapChainConfig } from '../config';
+import type { SignedPermitBatch } from '../encoding';
+import { readPermit2RouterAllowance } from '../permit';
+import type { SubmitStatus } from '../transactionProgress';
+import type { AegisSwapApprovalMode, WalletSession } from './types';
+/**
+ * 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.
+ */
+export declare function authorizePermit({ wallet, publicClient, activeChain, permit2, router, token, amount, approvalMode, allowanceRead, setStatus }: {
+    wallet: WalletSession;
+    publicClient: PublicClient;
+    activeChain: AegisSwapChainConfig;
+    permit2: Address;
+    router: Address;
+    token: Address;
+    amount: bigint;
+    approvalMode: AegisSwapApprovalMode;
+    allowanceRead: ReturnType<typeof readPermit2RouterAllowance>;
+    setStatus: (status: SubmitStatus) => void;
+}): Promise<SignedPermitBatch | null>;

package/dist/swap/executeSwapTransaction.d.ts

@@ -0,0 +1,38 @@
+import { type Hex, type PublicClient } from 'viem';
+import type { AegisSwapChainConfig, AegisSwapMarket, AegisSwapToken } from '../config';
+import { type SignedPermitBatch } from '../encoding';
+import { type DirectSwapQuote } from '../quote';
+import type { AegisSwapReceiptSummary, SubmitStatus } from '../transactionProgress';
+import type { AegisSwapSubmitDetails, WalletSession } from './types';
+export type SwapExecutionResult = {
+    receipt: {
+        status: 'success' | 'reverted';
+        transactionHash: Hex;
+    };
+    /** Settlement facts (gas, block, fee) lifted off the mined receipt. */
+    summary: AegisSwapReceiptSummary;
+    swapDetails: AegisSwapSubmitDetails;
+};
+/**
+ * Builds the swap calldata, sends it, and waits for the receipt.
+ *
+ * Estimates gas with a 20% headroom bump, surfaces the optimistic hash through
+ * `setTxHash` (and `onSubmitted`) before mining, then tracks replacements: a
+ * wallet speed-up swaps in the hash that actually mines, while a wallet cancel
+ * mines a no-op whose "successful" receipt must not count as a swap — so a
+ * cancelled or reverted receipt throws. 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 }: {
+    wallet: WalletSession;
+    publicClient: PublicClient;
+    activeChain: AegisSwapChainConfig;
+    market: AegisSwapMarket;
+    inputToken: AegisSwapToken;
+    outputToken: AegisSwapToken;
+    swapQuote: DirectSwapQuote;
+    permit: SignedPermitBatch | null;
+    setStatus: (status: SubmitStatus) => void;
+    setTxHash: (hash: Hex | null) => void;
+    onSubmitted?: (hash: Hex, swap?: AegisSwapSubmitDetails) => void;
+}): Promise<SwapExecutionResult>;

package/dist/swap/gas.d.ts

@@ -0,0 +1,8 @@
+import type { Address, Hex, PublicClient } from 'viem';
+export type SwapGasRequest = {
+    account: Address;
+    to: Address;
+    data: Hex;
+    value: bigint;
+};
+export declare function estimateSwapGasWithBuffer(publicClient: Pick<PublicClient, 'estimateGas'>, request: SwapGasRequest): Promise<bigint | undefined>;

package/dist/swap/types.d.ts

@@ -0,0 +1,28 @@
+import type { Address } from 'viem';
+import type { SwapQuoteMode } from '../quote';
+import type { Eip1193Provider } from '../wallet';
+/** A resolved wallet: a provider landed on the active chain plus its account. */
+export type WalletSession = {
+    provider: Eip1193Provider;
+    account: Address;
+};
+/**
+ * ERC-20 approval sizing.
+ *
+ * `exact` approves only the current quote spend. `max` approves the token's
+ * maximum spender allowance so later swaps can skip the approval transaction.
+ */
+export type AegisSwapApprovalMode = 'exact' | 'max';
+/**
+ * Swap context attached to submit callbacks and action results. Amounts are raw
+ * base units.
+ */
+export type AegisSwapSubmitDetails = {
+    mode: SwapQuoteMode;
+    inputSymbol: string;
+    outputSymbol: string;
+    amountIn: bigint;
+    amountOut: bigint;
+    feeAmount: bigint;
+    feeBps: number;
+};

package/dist/transactionProgress.d.ts

@@ -0,0 +1,55 @@
+import type { Hex } from 'viem';
+export type SubmitStatus = 'idle' | 'approving' | 'signing' | 'submitting' | 'success';
+/**
+ * On-chain settlement facts pulled from the swap's mined receipt. Raw base
+ * units / wei so the widget view layer owns formatting (viem `formatEther` /
+ * `formatGwei`) without widening the public success callback.
+ */
+export type AegisSwapReceiptSummary = {
+    transactionHash: Hex;
+    blockNumber: bigint;
+    gasUsed: bigint;
+    effectiveGasPrice: bigint;
+    /** gasUsed * effectiveGasPrice — the L2-exclusive execution fee in native wei. */
+    feeWei: bigint;
+};
+export declare function isBusy(status: SubmitStatus): boolean;
+export type TransactionProgressState = 'pending' | 'mining' | 'success' | 'error';
+export type AegisSwapWalletPromptProgress = {
+    /** Total swap-flow wallet-provider prompts expected from current allowances. */
+    total: number;
+    completed: number;
+    /** 1-based prompt currently awaiting the wallet; null while idle/mining/terminal. */
+    active: number | null;
+};
+export type TransactionProgressView = {
+    state: TransactionProgressState;
+    label: string;
+    walletPrompts: AegisSwapWalletPromptProgress;
+    /** Calm fill showing completed wallet-provider prompts. */
+    completePct: number;
+    /** Visual activity layer width; pending/mining sweeps full-width by default. */
+    activeWidthPct: number;
+};
+export declare function transactionProgressView({ status, inputSymbol, txHash, actionError, approvalRequired, approvalDone, authorizationRequired }: {
+    status: SubmitStatus;
+    inputSymbol: string;
+    txHash: Hex | null;
+    actionError: string | null;
+    approvalRequired: boolean;
+    approvalDone: boolean;
+    authorizationRequired: boolean;
+}): TransactionProgressView | null;
+export type AegisSwapStatusSnapshot = {
+    status: SubmitStatus;
+    progress: TransactionProgressState | null;
+    /** The rail's phase copy (e.g. "Approving USDC for Permit2 · wallet prompt 1 of 3"); null while idle. */
+    label: string | null;
+    /** Swap-flow wallet provider prompt count/progress, derived from current allowances. */
+    walletPrompts: AegisSwapWalletPromptProgress;
+    /** Rail geometry; null while idle. */
+    completePct: number | null;
+    activeWidthPct: number | null;
+    txHash: Hex | null;
+    error: string | null;
+};

package/dist/types/aggregatedSwap.d.ts

@@ -0,0 +1,29 @@
+import type { Address, Hex } from 'viem';
+import type { AegisSwapToken } from '../config';
+export type HopInfo = {
+    dex: string;
+    inputToken: AegisSwapToken;
+    outputToken: AegisSwapToken;
+    part: number;
+};
+export type AggregatedSwapQuote = {
+    inputToken: AegisSwapToken;
+    outputToken: AegisSwapToken;
+    amountIn: bigint;
+    amountOut: bigint;
+    gasEstimate: bigint;
+    hops: HopInfo[];
+    routerAddress: Address;
+    calldata: Hex | null;
+    transactionValue: bigint;
+    priceImpact: number;
+    feeAmount: bigint;
+    feeBps: number;
+    feeRecipient: Address | null;
+    userAmountOutMinimum: bigint;
+    amountOutMinimum: bigint;
+};
+export type AggregatedSwapRoute = {
+    inputToken: AegisSwapToken;
+    outputToken: AegisSwapToken;
+};