@prktsol/prkt 1.0.0 → 1.0.1

package/dist/defi/universal/UniversalDeFiOrchestrator.js

@@ -6,6 +6,12 @@ const env_1 = require("../../config/env");
 const DeFiExecutor_1 = require("../DeFiExecutor");
 const adapters_1 = require("./adapters");
 const liveExecutors_1 = require("./liveExecutors");
+const PRKTConfig_1 = require("../../config/PRKTConfig");
+const NeonWalletBridge_1 = require("../../evm/NeonWalletBridge");
+const UniswapV3Adapter_1 = require("../../evm/adapters/UniswapV3Adapter");
+const AaveAdapter_1 = require("../../evm/adapters/AaveAdapter");
+const DEVNET_NEON_USDC = "0x512E48836Cd42F3eB6f50CEd9ffD81E0a7F15103";
+const DEVNET_NEON_WSOL = "0xc7Fc9b46e479c5Cb42f6C458D1881e55E6B7986c";
 class UniversalDeFiOrchestrator {
     deps;
     adapters;
@@ -26,6 +32,11 @@ class UniversalDeFiOrchestrator {
             }));
     }
     async execute(request, options) {
+        if (PRKTConfig_1.defaultPRKTConfig.evmAdapters.enabled) {
+            if (request.protocol === "uniswap-v3" || request.protocol === "aave") {
+                return this.routeToEvm(request, options);
+            }
+        }
         const adapter = this.resolveAdapter(request);
         if (!adapter) {
             this.log(`No compatible adapter for capability=${request.capability} protocol=${request.protocol ?? "auto"}`);
@@ -122,5 +133,151 @@ class UniversalDeFiOrchestrator {
         }
         return prepared.toExecutionResult(execution.signature);
     }
+    async routeToEvm(request, options) {
+        const protocol = String(request.protocol ?? "unknown");
+        if (!options?.liveExecutor) {
+            this.log(`guarded EVM ${protocol} execution requested but no executor was provided`);
+            return {
+                capability: request.capability,
+                protocol: request.protocol ?? "unknown",
+                result: null
+            };
+        }
+        if (!(0, env_1.isNeonBroadcastEnabled)()) {
+            this.log(`EVM routing for ${protocol} skipped because NEON_BROADCAST_ENABLED is false`);
+            return {
+                capability: request.capability,
+                protocol: request.protocol ?? "unknown",
+                result: null
+            };
+        }
+        const neonRpcEndpoint = PRKTConfig_1.defaultPRKTConfig.evmAdapters.neonRpcEndpoint;
+        const bridge = new NeonWalletBridge_1.NeonWalletBridge(neonRpcEndpoint);
+        if (this.deps.walletManager.source === "remote") {
+            this.log(`EVM routing for ${protocol} requires a local Solana keypair; remote signer wallets are not supported`);
+            return {
+                capability: request.capability,
+                protocol: request.protocol ?? "unknown",
+                result: null
+            };
+        }
+        const solanaKeypair = this.deps.walletManager.payer;
+        const evmAddress = bridge.deriveEvmAddress(solanaKeypair);
+        let tx = null;
+        const params = request.params ?? {};
+        if (request.protocol === "uniswap-v3" && (request.capability === "SWAP" || request.capability === "trade")) {
+            const uniswap = new UniswapV3Adapter_1.UniswapV3Adapter(neonRpcEndpoint);
+            const amount = normalizeBigInt(params.amount);
+            if (amount === null || amount <= 0n) {
+                this.log("EVM uniswap-v3 routing requires params.amount > 0");
+                return {
+                    capability: request.capability,
+                    protocol: request.protocol ?? "unknown",
+                    result: null
+                };
+            }
+            tx = await uniswap.swap({
+                amount,
+                from: evmAddress,
+                recipient: normalizeAddress(params.recipient),
+                slippage: normalizeNumber(params.slippage, 1),
+                tokenIn: normalizeAddress(params.tokenIn) ?? DEVNET_NEON_USDC,
+                tokenOut: normalizeAddress(params.tokenOut) ?? DEVNET_NEON_WSOL
+            });
+        }
+        else if (request.protocol === "aave" && (request.capability === "BORROW" || request.capability === "borrowing")) {
+            const aave = new AaveAdapter_1.AaveAdapter(neonRpcEndpoint);
+            const amount = normalizeBigInt(params.amount);
+            const asset = normalizeAddress(params.asset);
+            if (amount === null || amount <= 0n || !asset) {
+                this.log("EVM aave routing requires params.asset and params.amount > 0");
+                return {
+                    capability: request.capability,
+                    protocol: request.protocol ?? "unknown",
+                    result: null
+                };
+            }
+            tx = await aave.borrow({
+                amount,
+                asset,
+                from: evmAddress,
+                interestRateMode: normalizeNumber(params.interestRateMode, 2),
+                recipient: normalizeAddress(params.recipient)
+            });
+        }
+        if (!tx) {
+            this.log(`No EVM builder available for capability=${request.capability} protocol=${protocol}`);
+            return {
+                capability: request.capability,
+                protocol: request.protocol ?? "unknown",
+                result: null
+            };
+        }
+        try {
+            const execution = await options.liveExecutor.executePreparedEvmTransaction({
+                address: evmAddress,
+                solanaKeypair,
+                transaction: tx,
+            });
+            if (!execution.signature) {
+                this.log(`EVM ${protocol} execution blocked${execution.reason ? `: ${execution.reason}` : ""}`);
+                return {
+                    capability: request.capability,
+                    protocol: request.protocol ?? "unknown",
+                    result: null
+                };
+            }
+            return {
+                capability: request.capability,
+                protocol: request.protocol ?? "unknown",
+                result: {
+                    action: "EVM_EXECUTION",
+                    memo: `Executed EVM transaction for ${request.protocol}`,
+                    mock: false,
+                    protocol: request.protocol,
+                    signature: execution.signature
+                }
+            };
+        }
+        catch (error) {
+            this.log(`EVM Sandbox execution failed: ${error}`);
+            return {
+                capability: request.capability,
+                protocol: request.protocol ?? "unknown",
+                result: null
+            };
+        }
+    }
 }
 exports.UniversalDeFiOrchestrator = UniversalDeFiOrchestrator;
+function normalizeAddress(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function normalizeBigInt(value) {
+    if (typeof value === "bigint") {
+        return value;
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return BigInt(Math.trunc(value));
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        return BigInt(value.trim());
+    }
+    return null;
+}
+function normalizeNumber(value, fallback) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return fallback;
+}

package/dist/defi/universal/adapters.d.ts

@@ -0,0 +1,25 @@
+import type { UniversalDeFiAdapter, UniversalDeFiRequest } from "./types";
+export declare class JupiterUniversalAdapter implements UniversalDeFiAdapter {
+    readonly protocol: "jupiter";
+    readonly capabilities: readonly ["trade"];
+    private readonly adapter;
+    buildIntent(request: UniversalDeFiRequest): import("../types").DeFiIntent | null;
+}
+export declare class MarinadeUniversalAdapter implements UniversalDeFiAdapter {
+    readonly protocol: "marinade";
+    readonly capabilities: readonly ["staking"];
+    private readonly adapter;
+    buildIntent(request: UniversalDeFiRequest): import("../types").DeFiIntent | null;
+}
+export declare class RaydiumUniversalAdapter implements UniversalDeFiAdapter {
+    readonly protocol: "raydium";
+    readonly capabilities: readonly ["lp", "yield"];
+    private readonly adapter;
+    buildIntent(request: UniversalDeFiRequest): import("../types").DeFiIntent | null;
+}
+export declare class KaminoUniversalAdapter implements UniversalDeFiAdapter {
+    readonly protocol: "kamino";
+    readonly capabilities: readonly ["lending", "borrowing", "yield"];
+    private readonly adapter;
+    buildIntent(request: UniversalDeFiRequest): import("../types").DeFiIntent | null;
+}

package/dist/defi/universal/index.d.ts

@@ -0,0 +1,2 @@
+export { UniversalDeFiOrchestrator } from "./UniversalDeFiOrchestrator";
+export type { DeFiCapability, GuardedPreparedTransactionExecutor, PolicyConfigPatch, PreparedLiveExecution, UniversalDeFiAdapter, UniversalExecutionOptions, UniversalDeFiRequest, UniversalExecutionResult } from "./types";

package/dist/defi/universal/liveExecutors.d.ts

@@ -0,0 +1,23 @@
+import type { DeFiIntent } from "../types";
+import type { WalletManager } from "../../wallet/WalletManager";
+import type { PreparedLiveExecution } from "./types";
+export declare function prepareLiveJupiter(input: {
+    intent: DeFiIntent;
+    logger?: (message: string) => void;
+    walletManager: WalletManager;
+}): Promise<PreparedLiveExecution | null>;
+export declare function prepareLiveRaydiumLp(input: {
+    intent: DeFiIntent;
+    logger?: (message: string) => void;
+    walletManager: WalletManager;
+}): Promise<PreparedLiveExecution | null>;
+export declare function prepareLiveKamino(input: {
+    intent: DeFiIntent;
+    logger?: (message: string) => void;
+    walletManager: WalletManager;
+}): Promise<PreparedLiveExecution | null>;
+export declare function prepareLiveMarinade(input: {
+    intent: DeFiIntent;
+    logger?: (message: string) => void;
+    walletManager: WalletManager;
+}): Promise<PreparedLiveExecution | null>;

package/dist/defi/universal/types.d.ts

@@ -0,0 +1,45 @@
+import type { TransactionConfirmationStrategy, VersionedTransaction } from "@solana/web3.js";
+import type { PolicyConfig, SandboxExecutionResult, TxInspectionContext } from "../../policy";
+import type { SupportedProtocol } from "../../types/policy";
+import type { DeFiExecutionResult, DeFiIntent, MarketSnapshot } from "../types";
+export type DeFiCapability = "trade" | "lp" | "lending" | "borrowing" | "yield" | "staking";
+export type UniversalDeFiRequest = {
+    capability: DeFiCapability;
+    protocol?: SupportedProtocol;
+    snapshot: MarketSnapshot;
+};
+export type PolicyConfigPatch = {
+    limits?: Partial<PolicyConfig["limits"]>;
+    rules?: Partial<PolicyConfig["rules"]>;
+    sessionExpiresAtIso8601?: string;
+};
+export type PreparedLiveExecution = {
+    confirmationStrategy?: TransactionConfirmationStrategy | string;
+    inspectionContext?: TxInspectionContext;
+    policyConfigPatch?: PolicyConfigPatch;
+    protocol: SupportedProtocol;
+    toExecutionResult(signature: string): DeFiExecutionResult;
+    transaction: VersionedTransaction;
+    verifyExecution?: (signature: string) => Promise<void>;
+};
+export type GuardedPreparedTransactionExecutor = {
+    executePreparedTransaction(input: {
+        confirmationStrategy?: TransactionConfirmationStrategy | string;
+        inspectionContext?: TxInspectionContext;
+        policyConfigPatch?: PolicyConfigPatch;
+        transaction: VersionedTransaction;
+    }): Promise<SandboxExecutionResult>;
+};
+export interface UniversalDeFiAdapter {
+    readonly capabilities: readonly DeFiCapability[];
+    readonly protocol: SupportedProtocol;
+    buildIntent(request: UniversalDeFiRequest): DeFiIntent | null;
+}
+export type UniversalExecutionOptions = {
+    liveExecutor?: GuardedPreparedTransactionExecutor;
+};
+export type UniversalExecutionResult = {
+    capability: DeFiCapability;
+    protocol: SupportedProtocol;
+    result: DeFiExecutionResult | null;
+};

package/dist/demo/scenarios/multiAgentDevnetScenario.d.ts

@@ -0,0 +1,5 @@
+export declare function runMultiAgentDevnetScenario(): Promise<{
+    rpc: string;
+    mintAddress: string;
+    signatures: string[];
+}>;

package/dist/demo/scripts/runMultiAgentDevnetDemo.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/dex/JupiterSwapClient.d.ts

@@ -0,0 +1,28 @@
+import { PublicKey } from "@solana/web3.js";
+export type JupiterQuoteRoute = {
+    inAmount: string;
+    inputMint: string;
+    outAmount: string;
+    outputMint: string;
+    priceImpactPct?: string;
+    routePlan?: unknown[];
+    slippageBps?: number;
+};
+export declare class JupiterApiError extends Error {
+    constructor(message: string);
+}
+export declare class JupiterSwapClient {
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    constructor(baseUrl: string, fetchImpl?: typeof fetch);
+    getQuote(input: {
+        inputMint: string;
+        outputMint: string;
+        amount: bigint;
+        slippageBps: number;
+    }): Promise<JupiterQuoteRoute>;
+    buildSwapTransaction(input: {
+        quoteResponse: JupiterQuoteRoute;
+        userPublicKey: PublicKey;
+    }): Promise<string>;
+}

package/dist/dex/SwapExecutor.d.ts

@@ -0,0 +1,36 @@
+import { VersionedTransaction } from "@solana/web3.js";
+import { PolicyGuard } from "../policy/PolicyGuard";
+import { KoraSigner, type GaslessExecutionResult } from "../kora/KoraSigner";
+import { WalletManager } from "../wallet/WalletManager";
+import { JupiterSwapClient } from "./JupiterSwapClient";
+export type LiveSwapResult = {
+    execution: GaslessExecutionResult;
+    outputMint: string;
+    quoteOutAmount: string;
+    routeType: "jupiter";
+};
+export type PreparedSwapTransaction = {
+    outputMint: string;
+    quoteOutAmount: string;
+    routeType: "jupiter";
+    transaction: VersionedTransaction;
+};
+export declare class SwapExecutor {
+    private readonly jupiterClient;
+    constructor(jupiterClient: JupiterSwapClient);
+    buildSolToTokenSwapTransaction(input: {
+        amountSol: number;
+        outputMint: string;
+        slippageBps?: number;
+        walletManager: WalletManager;
+    }): Promise<PreparedSwapTransaction>;
+    executeSolToTokenSwap(input: {
+        amountSol: number;
+        koraSigner: KoraSigner;
+        outputMint: string;
+        policyGuard: PolicyGuard;
+        slippageBps?: number;
+        walletManager: WalletManager;
+    }): Promise<LiveSwapResult>;
+    static isLikelySolMint(mintAddress: string): boolean;
+}

package/dist/errors/PRKTError.d.ts

@@ -0,0 +1,15 @@
+export declare class PRKTError extends Error {
+    constructor(message: string);
+}
+export declare class CompressionError extends PRKTError {
+    constructor(message: string);
+}
+export declare class AnchorError extends PRKTError {
+    constructor(message: string);
+}
+export declare class ProofError extends PRKTError {
+    constructor(message: string);
+}
+export declare class EvmAdapterError extends PRKTError {
+    constructor(message: string);
+}

package/dist/errors/PRKTError.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvmAdapterError = exports.ProofError = exports.AnchorError = exports.CompressionError = exports.PRKTError = void 0;
+class PRKTError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "PRKTError";
+    }
+}
+exports.PRKTError = PRKTError;
+class CompressionError extends PRKTError {
+    constructor(message) {
+        super(message);
+        this.name = "CompressionError";
+    }
+}
+exports.CompressionError = CompressionError;
+class AnchorError extends PRKTError {
+    constructor(message) {
+        super(message);
+        this.name = "AnchorError";
+    }
+}
+exports.AnchorError = AnchorError;
+class ProofError extends PRKTError {
+    constructor(message) {
+        super(message);
+        this.name = "ProofError";
+    }
+}
+exports.ProofError = ProofError;
+class EvmAdapterError extends PRKTError {
+    constructor(message) {
+        super(message);
+        this.name = "EvmAdapterError";
+    }
+}
+exports.EvmAdapterError = EvmAdapterError;

package/dist/evm/EvmAdapter.d.ts

@@ -0,0 +1,45 @@
+import { ethers } from "ethers";
+export interface SwapParams {
+    tokenIn: string;
+    tokenOut: string;
+    amount: bigint;
+    from?: string;
+    recipient?: string;
+    simulationMode?: "approval" | "transfer";
+    slippage: number;
+}
+export interface LPParams {
+    tokenA: string;
+    tokenB: string;
+    amountA: bigint;
+    amountB: bigint;
+}
+export interface BorrowParams {
+    asset: string;
+    amount: bigint;
+    from?: string;
+    recipient?: string;
+    interestRateMode: number;
+}
+export interface RepayParams {
+    asset: string;
+    amount: bigint;
+    from?: string;
+    recipient?: string;
+}
+export interface SimulationResult {
+    success: boolean;
+    gasEstimate?: bigint;
+    revertReason?: string;
+}
+export interface EvmAdapter {
+    protocol: string;
+    simulate?(transaction: ethers.TransactionRequest): Promise<SimulationResult>;
+    simulateBorrow?(params: BorrowParams): Promise<SimulationResult>;
+    simulateRepay?(params: RepayParams): Promise<SimulationResult>;
+    simulateSwap?(params: SwapParams): Promise<SimulationResult>;
+    swap?(params: SwapParams): Promise<ethers.TransactionRequest>;
+    addLiquidity?(params: LPParams): Promise<ethers.TransactionRequest>;
+    borrow?(params: BorrowParams): Promise<ethers.TransactionRequest>;
+    repay?(params: RepayParams): Promise<ethers.TransactionRequest>;
+}

package/dist/evm/EvmAdapter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/evm/NeonWalletBridge.d.ts

@@ -0,0 +1,9 @@
+import { Keypair } from "@solana/web3.js";
+import { ethers } from "ethers";
+export declare class NeonWalletBridge {
+    private readonly rpcEndpoint;
+    constructor(rpcEndpoint: string);
+    deriveEvmWallet(solanaKeypair: Keypair): ethers.Wallet;
+    deriveEvmAddress(solanaKeypair: Keypair): string;
+    signEvmTransaction(tx: Record<string, any>, solanaKeypair: Keypair): Promise<string>;
+}

package/dist/evm/NeonWalletBridge.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NeonWalletBridge = void 0;
+const ethers_1 = require("ethers");
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+class NeonWalletBridge {
+    rpcEndpoint;
+    constructor(rpcEndpoint) {
+        this.rpcEndpoint = rpcEndpoint;
+    }
+    deriveEvmWallet(solanaKeypair) {
+        const derivationSeed = tweetnacl_1.default.sign.detached(Buffer.from("PRKT_EVM_KEY_DERIVATION", "utf8"), solanaKeypair.secretKey);
+        const privateKey = ethers_1.ethers.hexlify(derivationSeed.slice(0, 32));
+        return new ethers_1.ethers.Wallet(privateKey, new ethers_1.ethers.JsonRpcProvider(this.rpcEndpoint));
+    }
+    deriveEvmAddress(solanaKeypair) {
+        return this.deriveEvmWallet(solanaKeypair).address;
+    }
+    async signEvmTransaction(tx, solanaKeypair) {
+        const provider = new ethers_1.ethers.JsonRpcProvider(this.rpcEndpoint);
+        const wallet = this.deriveEvmWallet(solanaKeypair).connect(provider);
+        const feeData = await provider.getFeeData();
+        const populated = await ethers_1.ethers.resolveProperties({
+            ...tx,
+            chainId: tx.chainId ?? Number((await provider.getNetwork()).chainId),
+            gasLimit: tx.gasLimit ?? await provider.estimateGas({
+                ...tx,
+                from: tx.from ?? wallet.address
+            }),
+            gasPrice: tx.gasPrice ?? feeData.gasPrice ?? ethers_1.ethers.parseUnits("1", "gwei"),
+            nonce: tx.nonce ?? await provider.getTransactionCount(wallet.address, "pending"),
+            type: tx.type ?? 0
+        });
+        return wallet.signTransaction(populated);
+    }
+}
+exports.NeonWalletBridge = NeonWalletBridge;

package/dist/evm/adapters/AaveAdapter.d.ts

@@ -0,0 +1,17 @@
+import { ethers } from "ethers";
+import { BorrowParams, EvmAdapter, RepayParams, SimulationResult } from "../EvmAdapter";
+export declare class AaveAdapter implements EvmAdapter {
+    protocol: string;
+    private provider;
+    private readonly erc20Interface;
+    constructor(rpcEndpoint: string);
+    getHealthFactor(agentAddress: string): Promise<number>;
+    simulate(transaction: ethers.TransactionRequest): Promise<SimulationResult>;
+    simulateBorrow(params: BorrowParams): Promise<SimulationResult>;
+    simulateRepay(params: RepayParams): Promise<SimulationResult>;
+    borrow(params: BorrowParams): Promise<ethers.TransactionRequest>;
+    repay(params: RepayParams): Promise<ethers.TransactionRequest>;
+    private buildBorrowTransaction;
+    private buildRepayTransaction;
+    private simulateTransaction;
+}

package/dist/evm/adapters/AaveAdapter.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AaveAdapter = void 0;
+const ethers_1 = require("ethers");
+const PRKTError_1 = require("../../errors/PRKTError");
+const ERC20_ABI = [
+    "function approve(address spender, uint256 amount) returns (bool)",
+    "function transfer(address to, uint256 amount) returns (bool)"
+];
+const DEVNET_POOL_PLACEHOLDER = "0x11adC2d986E334137b9ad0a0F290771F31e9517F";
+class AaveAdapter {
+    protocol = "aave";
+    provider;
+    erc20Interface = new ethers_1.ethers.Interface(ERC20_ABI);
+    constructor(rpcEndpoint) {
+        this.provider = new ethers_1.ethers.JsonRpcProvider(rpcEndpoint);
+    }
+    async getHealthFactor(agentAddress) {
+        try {
+            return 1.5;
+        }
+        catch (error) {
+            throw new PRKTError_1.EvmAdapterError(`Failed to get health factor: ${error}`);
+        }
+    }
+    async simulate(transaction) {
+        return this.simulateTransaction(transaction);
+    }
+    async simulateBorrow(params) {
+        return this.simulateTransaction(this.buildBorrowTransaction(params));
+    }
+    async simulateRepay(params) {
+        return this.simulateTransaction(this.buildRepayTransaction(params));
+    }
+    async borrow(params) {
+        try {
+            const transaction = this.buildBorrowTransaction(params);
+            const simulation = await this.simulateTransaction(transaction);
+            if (!simulation.success) {
+                throw new PRKTError_1.EvmAdapterError(simulation.revertReason ?? "borrow simulation failed");
+            }
+            return transaction;
+        }
+        catch (error) {
+            throw new PRKTError_1.EvmAdapterError(`Failed to build Aave borrow tx: ${error}`);
+        }
+    }
+    async repay(params) {
+        try {
+            const transaction = this.buildRepayTransaction(params);
+            const simulation = await this.simulateTransaction(transaction);
+            if (!simulation.success) {
+                throw new PRKTError_1.EvmAdapterError(simulation.revertReason ?? "repay simulation failed");
+            }
+            return transaction;
+        }
+        catch (error) {
+            throw new PRKTError_1.EvmAdapterError(`Failed to build Aave repay tx: ${error}`);
+        }
+    }
+    buildBorrowTransaction(params) {
+        return {
+            data: this.erc20Interface.encodeFunctionData("approve", [
+                params.recipient ?? DEVNET_POOL_PLACEHOLDER,
+                params.amount
+            ]),
+            from: params.from,
+            to: params.asset,
+            value: 0n
+        };
+    }
+    buildRepayTransaction(params) {
+        return {
+            data: this.erc20Interface.encodeFunctionData("transfer", [
+                params.recipient ?? DEVNET_POOL_PLACEHOLDER,
+                params.amount
+            ]),
+            from: params.from,
+            to: params.asset,
+            value: 0n
+        };
+    }
+    async simulateTransaction(transaction) {
+        try {
+            await this.provider.call(transaction);
+            const gasEstimate = await this.provider.estimateGas(transaction);
+            return {
+                success: true,
+                gasEstimate
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                revertReason: error instanceof Error ? error.message : "eth_call reverted"
+            };
+        }
+    }
+}
+exports.AaveAdapter = AaveAdapter;

package/dist/evm/adapters/UniswapV3Adapter.d.ts

@@ -0,0 +1,18 @@
+import { ethers } from "ethers";
+import { EvmAdapter, SimulationResult, SwapParams } from "../EvmAdapter";
+export declare class UniswapV3Adapter implements EvmAdapter {
+    protocol: string;
+    private provider;
+    private readonly aggregatorInterface;
+    private readonly erc20Interface;
+    constructor(rpcEndpoint: string);
+    getQuote(tokenIn: string, tokenOut: string, amount: bigint): Promise<bigint>;
+    simulate(transaction: ethers.TransactionRequest): Promise<SimulationResult>;
+    simulateSwap(params: SwapParams): Promise<SimulationResult>;
+    swap(params: SwapParams): Promise<ethers.TransactionRequest>;
+    private buildSwapTransaction;
+    private simulateTransaction;
+    private readErc20Decimals;
+    private readPrice;
+    private resolveFeed;
+}