@steerprotocol/app-loader 3.0.6 → 3.1.0

package/lib/internal/asyncHostCalls.d.ts

@@ -0,0 +1,37 @@
+type StagedHostCall = {
+    kind: 'fetch-buffer';
+    run: () => Promise<ArrayBuffer>;
+} | {
+    kind: 'ccxt-ohlcv';
+    run: () => Promise<number[][]>;
+} | {
+    kind: 'panoptic-json';
+    run: () => Promise<string>;
+};
+type CompletedHostCall = {
+    kind: 'fetch-buffer';
+    value: ArrayBuffer;
+} | {
+    kind: 'ccxt-ohlcv';
+    value: number[][];
+} | {
+    kind: 'panoptic-json';
+    value: string;
+};
+type AsyncHostCallSlot = {
+    stage(call: StagedHostCall): void;
+    complete(): Promise<void>;
+    take(kind: 'fetch-buffer'): Extract<CompletedHostCall, {
+        kind: 'fetch-buffer';
+    }>;
+    take(kind: 'ccxt-ohlcv'): Extract<CompletedHostCall, {
+        kind: 'ccxt-ohlcv';
+    }>;
+    take(kind: 'panoptic-json'): Extract<CompletedHostCall, {
+        kind: 'panoptic-json';
+    }>;
+    reset(): void;
+};
+declare function createAsyncHostCallSlot(): AsyncHostCallSlot;
+export { createAsyncHostCallSlot };
+export type { AsyncHostCallSlot, CompletedHostCall, StagedHostCall };

package/lib/internal/instantiate.d.ts

@@ -1,15 +1,14 @@
 import { Candle } from '../Candle';
 import { RawTradeData } from '../RawTradeData';
 import type { WasmModule } from '../WasmModule';
-/**
- * Runtime-provided host adapters for environment-specific dependencies.
- */
+import type { JsonValue, PanopticCallRequest, PanopticCallResponse } from './panopticHostEnvelope';
 type RuntimeAdapters = {
     getFetch?: () => Promise<typeof fetch>;
     getCcxt?: () => Promise<any>;
+    callPanoptic?: (method: string, request: PanopticCallRequest) => Promise<PanopticCallResponse>;
 };
 export { Candle, RawTradeData };
-export type { WasmModule };
+export type { JsonValue, PanopticCallRequest, PanopticCallResponse, WasmModule };
 /**
  * Instantiates a wasm module and wraps its exports with host-side helpers.
  * @param module - Compiled wasm module.

package/lib/internal/loadOptions.d.ts

@@ -0,0 +1 @@
+export type { LoadWasmOptions } from '../loadOptions';

package/lib/internal/panoptic/deps.d.ts

@@ -0,0 +1,24 @@
+type RuntimeImport = (specifier: string) => Promise<unknown>;
+type PanopticDependencyKey = 'sdk' | 'sdkV2' | 'uniswap' | 'viem';
+type PanopticDependencies = {
+    sdk(): Promise<Record<string, unknown>>;
+    sdkV2(): Promise<Record<string, unknown>>;
+    uniswap(): Promise<Record<string, unknown>>;
+    viem(): Promise<Record<string, unknown>>;
+};
+declare const PANOPTIC_MODULE_SPECIFIERS: Record<PanopticDependencyKey, string>;
+declare function createPanopticDependencies(): PanopticDependencies;
+/**
+ * Loads a Panoptic runtime module through always-dynamic import.
+ */
+declare function loadPanopticModule(key: PanopticDependencyKey): Promise<unknown>;
+/**
+ * Test-only hook for proving the dynamic-import path without installing the SDK.
+ */
+declare function __setPanopticRuntimeImportForTests(importer: RuntimeImport): void;
+/**
+ * Test-only cache reset.
+ */
+declare function __resetPanopticRuntimeForTests(): void;
+export { PANOPTIC_MODULE_SPECIFIERS, __resetPanopticRuntimeForTests, __setPanopticRuntimeImportForTests, createPanopticDependencies, loadPanopticModule, };
+export type { PanopticDependencies, RuntimeImport };

package/lib/internal/panoptic/dynamicJobs/fragments.d.ts

@@ -0,0 +1,10 @@
+type DynamicJobFragment = {
+    target: string;
+    userProvidedData: string;
+    strategyProvidedData: string;
+    value: string;
+};
+declare function makeDynamicJobFragment(input: DynamicJobFragment): DynamicJobFragment;
+declare function validateDynamicJobFragment(value: unknown, label: string): DynamicJobFragment;
+export { makeDynamicJobFragment, validateDynamicJobFragment };
+export type { DynamicJobFragment };

package/lib/internal/panoptic/dynamicJobs/renderExecuteJob.d.ts

@@ -0,0 +1,8 @@
+import type { PanopticHandler } from '../handlers';
+type DynamicJobExecutePayload = {
+    functionName: 'executeJob(address[],bytes[],bytes[])';
+    typesArray: string[];
+    valuesArray: string[][];
+};
+declare function renderExecuteJob({ request, method }: Parameters<PanopticHandler>[0]): DynamicJobExecutePayload;
+export { renderExecuteJob };

package/lib/internal/panoptic/fragments/collateral.d.ts

@@ -0,0 +1,5 @@
+import type { PanopticHandler } from '../handlers';
+declare function depositFragment({ deps, method, request, options }: Parameters<PanopticHandler>[0]): Promise<import("../dynamicJobs/fragments").DynamicJobFragment>;
+declare function withdrawFragment({ deps, method, request, options }: Parameters<PanopticHandler>[0]): Promise<import("../dynamicJobs/fragments").DynamicJobFragment>;
+declare function withdrawWithPositionsFragment({ deps, method, request, options }: Parameters<PanopticHandler>[0]): Promise<import("../dynamicJobs/fragments").DynamicJobFragment>;
+export { depositFragment, withdrawFragment, withdrawWithPositionsFragment };

package/lib/internal/panoptic/fragments/erc20.d.ts

@@ -0,0 +1,3 @@
+import type { PanopticHandler } from '../handlers';
+declare function approveFragment({ deps, method, request, options }: Parameters<PanopticHandler>[0]): Promise<import("../dynamicJobs/fragments").DynamicJobFragment>;
+export { approveFragment };

package/lib/internal/panoptic/fragments/hypovault.d.ts

@@ -0,0 +1,12 @@
+import type { PanopticHandler } from '../handlers';
+declare function fulfillDepositsFragment({ deps, method, request, options }: Parameters<PanopticHandler>[0]): Promise<import("../dynamicJobs/fragments").DynamicJobFragment>;
+declare function fulfillWithdrawalsFragment({ deps, method, request, options }: Parameters<PanopticHandler>[0]): Promise<import("../dynamicJobs/fragments").DynamicJobFragment>;
+declare function manageCalldataParts({ deps, method, request, options }: Parameters<PanopticHandler>[0]): Promise<{
+    functionName: string;
+    calldata: string;
+    userProvidedData: string;
+    strategyProvidedData: string;
+    value: string;
+}>;
+declare function manageFragment({ deps, method, request, options }: Parameters<PanopticHandler>[0]): Promise<import("../dynamicJobs/fragments").DynamicJobFragment>;
+export { fulfillDepositsFragment, fulfillWithdrawalsFragment, manageCalldataParts, manageFragment };

package/lib/internal/panoptic/fragments/merkle.d.ts

@@ -0,0 +1,22 @@
+import type { PanopticHandler } from '../handlers';
+declare function manageVaultWithVerificationFragment({ deps, method, request, options }: Parameters<PanopticHandler>[0]): Promise<import("../dynamicJobs/fragments").DynamicJobFragment>;
+declare function findLeaf({ request, method }: Parameters<PanopticHandler>[0]): {
+    action: string;
+    description: string;
+    leafDigest: string;
+    decoder: string;
+    target: string;
+    functionSignature: string;
+    functionSelector: string;
+    canSendValue: boolean;
+    proof: string[];
+};
+declare function buildManageArgs({ request, method }: Parameters<PanopticHandler>[0]): {
+    proofs: string[][];
+    decoders: string[];
+    innerTargets: string[];
+    innerDatas: string[];
+    values: bigint[];
+    leaves: Record<string, unknown>[];
+};
+export { buildManageArgs, findLeaf, manageVaultWithVerificationFragment };

package/lib/internal/panoptic/fragments/panoptic.d.ts

@@ -0,0 +1,17 @@
+import type { PanopticHandler } from '../handlers';
+declare function dispatchCalldataParts({ deps, request, method }: Parameters<PanopticHandler>[0]): Promise<{
+    functionName: string;
+    userProvidedData: string;
+    strategyProvidedData: string;
+    calldata: string;
+}>;
+declare function dispatchFragment({ deps, request, options, method }: Parameters<PanopticHandler>[0]): Promise<import("../dynamicJobs/fragments").DynamicJobFragment>;
+declare function dispatchExplicitCalldataParts({ deps, request, method }: Parameters<PanopticHandler>[0]): Promise<{
+    functionName: string;
+    userProvidedData: string;
+    strategyProvidedData: string;
+    calldata: string;
+    value: string;
+}>;
+declare function dispatchExplicitFragment({ deps, request, options, method }: Parameters<PanopticHandler>[0]): Promise<import("../dynamicJobs/fragments").DynamicJobFragment>;
+export { dispatchCalldataParts, dispatchExplicitCalldataParts, dispatchExplicitFragment, dispatchFragment };

package/lib/internal/panoptic/fragments/permit2.d.ts

@@ -0,0 +1,3 @@
+import type { PanopticHandler } from '../handlers';
+declare function approveFragment({ deps, method, request, options }: Parameters<PanopticHandler>[0]): Promise<import("../dynamicJobs/fragments").DynamicJobFragment>;
+export { approveFragment };

package/lib/internal/panoptic/fragments/support.d.ts

@@ -0,0 +1,16 @@
+type SplitCalldataOptions = {
+    expectedSelector?: string;
+    staticArgWords?: number;
+    requireStrategyData?: boolean;
+};
+type SplitCalldataResult = {
+    calldata: string;
+    userProvidedData: string;
+    strategyProvidedData: string;
+    target?: string;
+};
+declare function splitCalldata(value: unknown, method: string, options?: SplitCalldataOptions): SplitCalldataResult;
+declare function assertUserProvidedData(value: string, expected: string, method: string): void;
+declare function addressAbiWord(address: string): string;
+declare function uint256AbiWord(value: bigint): string;
+export { addressAbiWord, assertUserProvidedData, splitCalldata, uint256AbiWord };

package/lib/internal/panoptic/fragments/uniswap.d.ts

@@ -0,0 +1,10 @@
+import type { PanopticHandler } from '../handlers';
+declare function buildV3ExactInExecuteCalldataParts({ deps, request, method, options }: Parameters<PanopticHandler>[0]): Promise<{
+    functionName: string;
+    calldata: string;
+    userProvidedData: string;
+    strategyProvidedData: string;
+    value: string;
+}>;
+declare function buildV3ExactInExecuteFragment({ deps, request, method, options }: Parameters<PanopticHandler>[0]): Promise<import("../dynamicJobs/fragments").DynamicJobFragment>;
+export { buildV3ExactInExecuteCalldataParts, buildV3ExactInExecuteFragment };

package/lib/internal/panoptic/fragments/weth.d.ts

@@ -0,0 +1,19 @@
+import type { PanopticHandler } from '../handlers';
+type WethCalldataParts = {
+    functionName: 'deposit' | 'withdraw';
+    calldata: string;
+    userProvidedData: string;
+    strategyProvidedData: string;
+    value: string;
+};
+type HypovaultWethInnerCall = {
+    functionName: 'deposit' | 'withdraw';
+    target: string;
+    data: string;
+    value: string;
+};
+declare function depositCalldataParts({ request, method }: Parameters<PanopticHandler>[0]): WethCalldataParts;
+declare function withdrawCalldataParts({ request, method }: Parameters<PanopticHandler>[0]): WethCalldataParts;
+declare function hypovaultWethDepositInnerCall({ request, method }: Parameters<PanopticHandler>[0]): HypovaultWethInnerCall;
+declare function hypovaultWethWithdrawInnerCall({ request, method }: Parameters<PanopticHandler>[0]): HypovaultWethInnerCall;
+export { depositCalldataParts, hypovaultWethDepositInnerCall, hypovaultWethWithdrawInnerCall, withdrawCalldataParts };

package/lib/internal/panoptic/handlers.d.ts

@@ -0,0 +1,27 @@
+import { projectPanopticSerializableValue } from '../panopticSerialization';
+import type { PanopticRuntimeOptions } from '../../panoptic';
+import type { PanopticOperationOptions } from '../panopticSources';
+import type { PanopticDependencies } from './deps';
+import { type PanopticCallRequest, type PanopticCallResponse } from './protocol';
+type PanopticHandlerContext = {
+    deps: PanopticDependencies;
+    method: string;
+    request: PanopticCallRequest;
+    options: PanopticRuntimeOptions;
+    operationOptions?: PanopticOperationOptions;
+};
+type PanopticHandler = (context: PanopticHandlerContext) => Promise<unknown> | unknown;
+type ExecutePanopticHandlerInput = {
+    method: string;
+    handler: PanopticHandler;
+    request: PanopticCallRequest;
+    deps: PanopticDependencies;
+    options?: PanopticRuntimeOptions;
+    operationOptions?: PanopticOperationOptions;
+    responseLimits?: Parameters<typeof projectPanopticSerializableValue>[1];
+};
+declare function getPanopticHandler(method: string): PanopticHandler | undefined;
+declare function getPanopticHandlerNames(): string[];
+declare function executePanopticHandler(input: ExecutePanopticHandlerInput): Promise<PanopticCallResponse>;
+export { executePanopticHandler, getPanopticHandler, getPanopticHandlerNames };
+export type { PanopticHandler };

package/lib/internal/panoptic/protocol.d.ts

@@ -0,0 +1,29 @@
+import type { PanopticJsonValue } from '../../panoptic';
+type JsonValue = PanopticJsonValue;
+type PanopticCallRequest = {
+    context?: {
+        chainId?: string;
+        sourceId?: string;
+        blockNumber?: string;
+        account?: string;
+        panopticSubgraphId?: string;
+        rpcUrl?: string;
+    };
+    args?: JsonValue;
+};
+type PanopticCallResponse = {
+    ok: true;
+    result: JsonValue;
+};
+declare function parsePanopticRequest(value: string, maxBytes?: number): PanopticCallRequest;
+declare function assertPanopticSuccessResponse(value: PanopticCallResponse): void;
+declare function panopticSuccess(result: JsonValue): PanopticCallResponse;
+declare function isJsonRecord(value: unknown): value is {
+    [key: string]: JsonValue;
+};
+declare function requestArgs(request: PanopticCallRequest, method: string): {
+    [key: string]: JsonValue;
+};
+declare function sanitizePanopticError(error: unknown): string;
+export { assertPanopticSuccessResponse, isJsonRecord, panopticSuccess, parsePanopticRequest, requestArgs, sanitizePanopticError, };
+export type { JsonValue, PanopticCallRequest, PanopticCallResponse };

package/lib/internal/panoptic/reads/account.d.ts

@@ -0,0 +1,11 @@
+import type { PanopticHandler } from '../handlers';
+declare function getPosition({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function getPositions({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function getOpenPositionIds({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function getAccountCollateral({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function getAccountSummaryBasic({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function getAccountSummaryRisk({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function getNetLiquidationValue({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function getNetLiquidationValues({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function getLiquidationPrices({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+export { getAccountCollateral, getAccountSummaryBasic, getAccountSummaryRisk, getLiquidationPrices, getNetLiquidationValue, getNetLiquidationValues, getOpenPositionIds, getPosition, getPositions, };

package/lib/internal/panoptic/reads/greeks.d.ts

@@ -0,0 +1,5 @@
+import type { PanopticHandler } from '../handlers';
+declare function getPositionGreeks({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function calculatePositionGreeks({ deps, method, request }: Parameters<PanopticHandler>[0]): Promise<unknown>;
+declare function calculateAccountGreeksPure({ deps, method, request }: Parameters<PanopticHandler>[0]): Promise<unknown>;
+export { calculateAccountGreeksPure, calculatePositionGreeks, getPositionGreeks };

package/lib/internal/panoptic/reads/hypovault.d.ts

@@ -0,0 +1,7 @@
+import type { PanopticHandler } from '../handlers';
+declare function buildVaultManagerInputAtBlock({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function verifyVaultOpenTokenIdsAtBlock({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function getOpenPositionIds({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function getEpochContext({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function getPositionsHashStatus({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+export { buildVaultManagerInputAtBlock, getEpochContext, getOpenPositionIds, getPositionsHashStatus, verifyVaultOpenTokenIdsAtBlock, };

package/lib/internal/panoptic/reads/pool.d.ts

@@ -0,0 +1,10 @@
+import type { PanopticHandler } from '../handlers';
+declare function getPool({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function fetchPoolId({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function getPoolMetadata({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function getRiskParameters({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function getUtilization({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function getOracleState({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function getTickSpacing({ deps, method, request }: Parameters<PanopticHandler>[0]): Promise<unknown>;
+declare function getPricesAtTick({ deps, method, request }: Parameters<PanopticHandler>[0]): Promise<unknown>;
+export { fetchPoolId, getOracleState, getPool, getPoolMetadata, getPricesAtTick, getRiskParameters, getTickSpacing, getUtilization, };

package/lib/internal/panoptic/reads/uniswap.d.ts

@@ -0,0 +1,6 @@
+import type { PanopticHandler } from '../handlers';
+declare function resolveSwapRoute({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function quoteSwapExactInViaRouter({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function quoteSwapExactOutViaRouter({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+declare function checkRouterApproval({ deps, method, request, options, }: Parameters<PanopticHandler>[0]): Promise<Record<string, unknown>>;
+export { checkRouterApproval, quoteSwapExactInViaRouter, quoteSwapExactOutViaRouter, resolveSwapRoute };

package/lib/internal/panoptic/support.d.ts

@@ -0,0 +1,20 @@
+import type { JsonValue, PanopticCallRequest } from './protocol';
+import { preparePanopticSourceContext, type PanopticResolvedCallContext } from '../panopticSources';
+declare function rejectContext(request: PanopticCallRequest, method: string): void;
+declare function requireSourceContext(request: PanopticCallRequest, method: string): void;
+declare function rejectExtraKeys(args: {
+    [key: string]: JsonValue;
+}, allowedKeys: readonly string[], method: string): void;
+declare function requireString(value: unknown, label: string): string;
+declare function requireSdkFunction(sdkModule: Record<string, unknown>, name: string, label: string): (...args: unknown[]) => unknown;
+declare function prepareRuntimeSourceContext(deps: {
+    viem: () => Promise<Record<string, unknown>>;
+}, request: PanopticCallRequest, options: {
+    sourceRegistry?: Parameters<typeof preparePanopticSourceContext>[2];
+    operation?: Parameters<typeof preparePanopticSourceContext>[3];
+    clientCache?: Parameters<typeof preparePanopticSourceContext>[4];
+}): Promise<PanopticResolvedCallContext>;
+declare function withSource(value: unknown, sourceContext: PanopticResolvedCallContext, blockNumberRole: 'pinned' | 'sdkResult' | 'preflight' | 'staticReference', label: string, blockNumber?: string, reconciled?: boolean): Record<string, unknown>;
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+export { isRecord, prepareRuntimeSourceContext, rejectContext, rejectExtraKeys, requireSdkFunction, requireSourceContext, requireString, withSource, };
+export type { PanopticResolvedCallContext };

package/lib/internal/panopticBrowserRuntime.d.ts

@@ -0,0 +1,6 @@
+import type { PanopticCallRequest, PanopticCallResponse } from './panopticHostEnvelope';
+/**
+ * Browser Panoptic adapter placeholder. Phase 8 owns the browser loading model.
+ */
+declare function callBrowserPanoptic(method: string, request: PanopticCallRequest): Promise<PanopticCallResponse>;
+export { callBrowserPanoptic };

package/lib/internal/panopticDtos.d.ts

@@ -0,0 +1,72 @@
+import type { JsonValue } from './panopticHostEnvelope';
+import type { JsonRecord } from './panopticJsonArgs';
+declare function collateralAddressesValue(value: JsonValue, label: string): {
+    collateralToken0: string;
+    collateralToken1: string;
+};
+declare function poolInfoArrayArg(args: JsonRecord, fieldName: string): {
+    pool: string;
+    token0: string;
+    token1: string;
+    maxPriceDeviation: number;
+}[];
+declare function poolMetadataValue(value: JsonValue, label: string): {
+    poolKeyBytes: string;
+    poolId: bigint;
+    collateralToken0Address: string;
+    collateralToken1Address: string;
+    riskEngineAddress: string;
+    token0Asset: string;
+    token1Asset: string;
+    token0Symbol: string;
+    token1Symbol: string;
+    token0Decimals: bigint;
+    token1Decimals: bigint;
+    token0Name: string;
+    token1Name: string;
+    underlyingPoolId: string;
+    isV4: boolean;
+    tickSpacing: bigint;
+    fee: bigint;
+    sfpmAddress: string;
+};
+declare function tokenIdLegArrayArg(args: JsonRecord, fieldName: string): {
+    index: bigint;
+    asset: bigint;
+    optionRatio: bigint;
+    isLong: boolean;
+    tokenType: bigint;
+    riskPartner: bigint;
+    strike: bigint;
+    width: bigint;
+    tickLower: bigint;
+    tickUpper: bigint;
+}[];
+declare function storedPositionArrayArg(args: JsonRecord, fieldName: string): {
+    tokenId: bigint;
+    legs: {
+        index: bigint;
+        asset: bigint;
+        optionRatio: bigint;
+        isLong: boolean;
+        tokenType: bigint;
+        riskPartner: bigint;
+        strike: bigint;
+        width: bigint;
+        tickLower: bigint;
+        tickUpper: bigint;
+    }[];
+    tickAtMint: bigint;
+    positionSize: bigint;
+}[];
+declare function vaultCandidatesByPoolArrayArg(args: JsonRecord, fieldName: string): {
+    poolAddress: string;
+    candidates: bigint[];
+}[];
+declare function uniswapAddressesValue(value: JsonValue, label: string): {
+    universalRouter: string;
+    v4Quoter: string;
+    poolManager: string;
+    permit2: string;
+};
+export { collateralAddressesValue, poolInfoArrayArg, poolMetadataValue, storedPositionArrayArg, tokenIdLegArrayArg, uniswapAddressesValue, vaultCandidatesByPoolArrayArg, };

package/lib/internal/panopticHostEnvelope.d.ts

@@ -0,0 +1,2 @@
+export { assertPanopticSuccessResponse, parsePanopticRequest } from './panoptic/protocol';
+export type { JsonValue, PanopticCallRequest, PanopticCallResponse } from './panoptic/protocol';

package/lib/internal/panopticHostImport.d.ts

@@ -0,0 +1,17 @@
+import type { AsyncHostCallSlot } from './asyncHostCalls';
+import { type PanopticCallRequest, type PanopticCallResponse } from './panopticHostEnvelope';
+type PanopticRuntimeAdapter = {
+    callPanoptic?: (method: string, request: PanopticCallRequest) => Promise<PanopticCallResponse>;
+};
+type PanopticHostImportOptions = {
+    runtime: PanopticRuntimeAdapter;
+    hostCalls: AsyncHostCallSlot;
+    getAsyncifyState: () => number;
+    rewindingState: number;
+    stopRewind: () => void;
+    startUnwind: () => void;
+    liftString: (ptr: number) => string | null;
+    lowerString: (value: string, owner: 'host' | 'wasm') => number;
+};
+declare function createPanopticHostImport(options: PanopticHostImportOptions): (methodPtr: number, paramsJsonPtr: number) => number | void;
+export { createPanopticHostImport };

package/lib/internal/panopticJsonArgs.d.ts

@@ -0,0 +1,26 @@
+import type { JsonValue } from './panopticHostEnvelope';
+type JsonRecord = {
+    [key: string]: JsonValue;
+};
+declare function decimalValue(value: JsonValue | undefined, label: string): bigint;
+declare function signedDecimalValue(value: JsonValue | undefined, label: string): bigint;
+declare function stringValue(value: JsonValue | undefined, label: string): string;
+declare function booleanValue(value: JsonValue | undefined, label: string): boolean;
+declare function numberValue(value: JsonValue | undefined, label: string): number;
+declare function decimalArg(args: JsonRecord, fieldName: string): bigint;
+declare function signedDecimalArg(args: JsonRecord, fieldName: string): bigint;
+declare function optionalDecimalArg(args: JsonRecord, fieldName: string): bigint | undefined;
+declare function optionalSignedDecimalArg(args: JsonRecord, fieldName: string): bigint | undefined;
+declare function optionalBooleanArg(args: JsonRecord, fieldName: string): boolean | undefined;
+declare function optionalStringArg(args: JsonRecord, fieldName: string): string | undefined;
+declare function decimalArrayArg(args: JsonRecord, fieldName: string): bigint[];
+declare function optionalDecimalArrayArg(args: JsonRecord, fieldName: string): bigint[] | undefined;
+declare function signedDecimalArrayArg(args: JsonRecord, fieldName: string): bigint[];
+declare function decimalMatrixArg(args: JsonRecord, fieldName: string): bigint[][];
+declare function optionalStringArrayArg(args: JsonRecord, fieldName: string): string[] | undefined;
+declare function decimalArrayValue(value: JsonValue | undefined, label: string): bigint[];
+declare function arrayValue(value: JsonValue | undefined, label: string): JsonValue[];
+declare function recordValue(value: JsonValue | undefined, label: string): JsonRecord;
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+export { arrayValue, booleanValue, decimalArg, decimalArrayArg, decimalArrayValue, decimalMatrixArg, decimalValue, isRecord, numberValue, optionalBooleanArg, optionalDecimalArg, optionalDecimalArrayArg, optionalSignedDecimalArg, optionalStringArg, optionalStringArrayArg, recordValue, signedDecimalArg, signedDecimalArrayArg, signedDecimalValue, stringValue, };
+export type { JsonRecord };

package/lib/internal/panopticRuntime.d.ts

@@ -0,0 +1,12 @@
+import type { PanopticRuntimeOptions } from '../panoptic';
+import type { PanopticCallRequest, PanopticCallResponse } from './panopticHostEnvelope';
+import { PANOPTIC_MODULE_SPECIFIERS, __resetPanopticRuntimeForTests, __setPanopticRuntimeImportForTests, loadPanopticModule, type RuntimeImport } from './panoptic/deps';
+declare const PANOPTIC_RUNTIME_METHOD_NAMES: readonly string[];
+/**
+ * Node/root Panoptic adapter skeleton. Source/client context is prepared before
+ * method implementations land in later phases.
+ */
+declare function callNodePanoptic(method: string, request: PanopticCallRequest, options?: PanopticRuntimeOptions): Promise<PanopticCallResponse>;
+declare function createNodePanopticAdapter(options?: PanopticRuntimeOptions): (method: string, request: PanopticCallRequest) => Promise<PanopticCallResponse>;
+export { PANOPTIC_MODULE_SPECIFIERS, PANOPTIC_RUNTIME_METHOD_NAMES, callNodePanoptic, createNodePanopticAdapter, loadPanopticModule, __resetPanopticRuntimeForTests, __setPanopticRuntimeImportForTests, };
+export type { PanopticRuntimeOptions, RuntimeImport };

package/lib/internal/panopticScalars.d.ts

@@ -0,0 +1,10 @@
+import type { JsonRecord } from './panopticJsonArgs';
+declare function uint48Arg(args: JsonRecord, fieldName: string): bigint;
+declare function uint128Arg(args: JsonRecord, fieldName: string): bigint;
+declare function uint160Arg(args: JsonRecord, fieldName: string): bigint;
+declare function uint256Arg(args: JsonRecord, fieldName: string): bigint;
+declare function optionalUint256Arg(args: JsonRecord, fieldName: string): bigint | undefined;
+declare function uint256ArrayArg(args: JsonRecord, fieldName: string): bigint[];
+declare function int24Arg(args: JsonRecord, fieldName: string): bigint;
+declare function optionalInt24Arg(args: JsonRecord, fieldName: string): bigint | undefined;
+export { int24Arg, optionalInt24Arg, optionalUint256Arg, uint48Arg, uint128Arg, uint160Arg, uint256Arg, uint256ArrayArg, };

package/lib/internal/panopticSerialization.d.ts

@@ -0,0 +1,19 @@
+import type { JsonValue } from './panopticHostEnvelope';
+type PanopticJsonResourceLimits = {
+    maxArrayItems?: number;
+    maxObjectKeys?: number;
+    maxDepth?: number;
+    maxRequestBytes?: number;
+    maxResponseBytes?: number;
+    maxCalldataBytes?: number;
+    maxStringBytes?: number;
+    maxDecimalDigits?: number;
+};
+declare function normalizePanopticAddress(value: unknown, fieldName?: string): string;
+declare function normalizePanopticHex(value: unknown, fieldName?: string, maxBytes?: number): string;
+declare function normalizePanopticDecimalString(value: unknown, fieldName?: string, maxDigits?: number): string;
+declare function normalizePanopticSignedDecimalString(value: unknown, fieldName?: string, maxDigits?: number): string;
+declare function projectPanopticSerializableValue(value: unknown, limits?: PanopticJsonResourceLimits, label?: string): JsonValue;
+declare function projectPanopticSerializableRequest(value: unknown, limits?: PanopticJsonResourceLimits, label?: string): JsonValue;
+declare function utf8ByteLength(value: string): number;
+export { normalizePanopticAddress, normalizePanopticDecimalString, normalizePanopticHex, normalizePanopticSignedDecimalString, projectPanopticSerializableRequest, projectPanopticSerializableValue, utf8ByteLength, };

package/lib/internal/panopticSources.d.ts

@@ -0,0 +1,22 @@
+import type { PanopticAuditEvent, PanopticClientCacheOptions, PanopticOperationOptions, PanopticRpcSource, PanopticSourceRegistry, PanopticSubgraphSource, SourceMeta } from '../panoptic';
+import type { PanopticCallRequest } from './panopticHostEnvelope';
+type ResolvedPanopticSource = {
+    source: PanopticRpcSource;
+    chainId: string;
+    rpcUrl: string;
+    normalizedRpcUrl: string;
+    overrideApplied: boolean;
+};
+type PanopticResolvedCallContext = {
+    source: ResolvedPanopticSource;
+    client: unknown;
+    blockNumber: string;
+    sourceMeta: SourceMeta;
+};
+declare function resolvePanopticSource(context: PanopticCallRequest['context'] | undefined, registry: PanopticSourceRegistry | undefined): ResolvedPanopticSource;
+declare function preparePanopticSourceContext(request: PanopticCallRequest, viemModule: unknown, registry: PanopticSourceRegistry | undefined, operationOptions?: PanopticOperationOptions, cacheOptions?: PanopticClientCacheOptions): Promise<PanopticResolvedCallContext>;
+declare function getPanopticPublicClient(viemModule: unknown, source: ResolvedPanopticSource, options?: PanopticClientCacheOptions): unknown;
+declare function runPanopticOperation<T>(label: string, operation: () => Promise<T>, options?: PanopticOperationOptions): Promise<T>;
+declare function __resetPanopticSourceStateForTests(): void;
+export { getPanopticPublicClient, preparePanopticSourceContext, resolvePanopticSource, runPanopticOperation, __resetPanopticSourceStateForTests, };
+export type { PanopticAuditEvent, PanopticClientCacheOptions, PanopticOperationOptions, PanopticResolvedCallContext, PanopticRpcSource, PanopticSourceRegistry, PanopticSubgraphSource, SourceMeta, };

package/lib/loadOptions.d.ts

@@ -0,0 +1,5 @@
+import type { PanopticRuntimeOptions } from './panoptic';
+type LoadWasmOptions = {
+    panoptic?: PanopticRuntimeOptions;
+};
+export type { LoadWasmOptions };