@prktsol/prkt 1.0.0 → 1.0.1

package/dist/core/rpc/RpcClient.js

@@ -3,42 +3,77 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RpcClient = void 0;
 const web3_js_1 = require("@solana/web3.js");
 const env_1 = require("../../config/env");
+const RpcFailoverClient_1 = require("./RpcFailoverClient");
 class RpcClient {
     connection;
+    failoverClient;
     constructor(rpcUrl = (0, env_1.getRpcUrl)(), commitment = "confirmed") {
         this.connection = new web3_js_1.Connection(rpcUrl, commitment);
+        const fallbackUrl = (0, env_1.getRpcFallbackUrl)();
+        this.failoverClient =
+            fallbackUrl && fallbackUrl !== rpcUrl
+                ? new RpcFailoverClient_1.RpcFailoverClient({
+                    commitment,
+                    fallbackUrl,
+                    primaryUrl: rpcUrl
+                })
+                : null;
     }
     get rpcUrl() {
         return this.connection.rpcEndpoint;
     }
     async getLatestBlockhash(commitment = "confirmed") {
+        if (this.failoverClient) {
+            return this.failoverClient.getLatestBlockhash(commitment);
+        }
         return this.connection.getLatestBlockhash(commitment);
     }
     async getBalance(publicKey, commitment = "confirmed") {
+        if (this.failoverClient) {
+            return this.failoverClient.getBalance(publicKey, commitment);
+        }
         return this.connection.getBalance(publicKey, commitment);
     }
     async getTokenAccountBalance(publicKey, commitment = "confirmed") {
+        if (this.failoverClient) {
+            return this.failoverClient.getTokenAccountBalance(publicKey, commitment);
+        }
         return this.connection.getTokenAccountBalance(publicKey, commitment);
     }
     async getAccountInfo(publicKey, commitment = "confirmed") {
+        if (this.failoverClient) {
+            return this.failoverClient.getAccountInfo(publicKey, commitment);
+        }
         return this.connection.getAccountInfo(publicKey, commitment);
     }
     async sendTransaction(transaction, options) {
+        if (this.failoverClient) {
+            return this.failoverClient.sendTransaction(transaction, options);
+        }
         return this.connection.sendTransaction(transaction, options);
     }
     async confirmTransaction(strategy, commitment = "confirmed") {
+        if (this.failoverClient) {
+            return this.failoverClient.confirmTransaction(strategy, commitment);
+        }
         if (typeof strategy === "string") {
             return this.connection.confirmTransaction(strategy, commitment);
         }
         return this.connection.confirmTransaction(strategy, commitment);
     }
     async simulateTransaction(transaction, options) {
+        if (this.failoverClient) {
+            return this.failoverClient.simulateTransaction(transaction, options);
+        }
         return this.connection.simulateTransaction(transaction, {
             commitment: options?.commitment ?? "confirmed",
             sigVerify: options?.sigVerify ?? true
         });
     }
     async requestAirdrop(publicKey, lamports) {
+        if (this.failoverClient) {
+            return this.failoverClient.requestAirdrop(publicKey, lamports);
+        }
         return this.connection.requestAirdrop(publicKey, lamports);
     }
 }

package/dist/core/rpc/RpcFailoverClient.d.ts

@@ -0,0 +1,42 @@
+import { Connection, type Commitment, type ConfirmOptions, type PublicKey, type RpcResponseAndContext, type SignatureResult, type SimulatedTransactionResponse, type TransactionConfirmationStrategy, type VersionedTransaction } from "@solana/web3.js";
+export type RpcFailoverConfig = {
+    primaryUrl: string;
+    fallbackUrl?: string | null;
+    commitment?: Commitment;
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+};
+/**
+ * RPC client with automatic failover from primary to fallback URL,
+ * exponential backoff, and random jitter on retries.
+ */
+export declare class RpcFailoverClient {
+    private primaryConnection;
+    private fallbackConnection;
+    private readonly maxRetries;
+    private readonly baseDelayMs;
+    private readonly maxDelayMs;
+    private readonly commitment;
+    readonly primaryUrl: string;
+    readonly fallbackUrl: string | null;
+    constructor(config: RpcFailoverConfig);
+    get connection(): Connection;
+    get rpcUrl(): string;
+    getLatestBlockhash(commitment?: Commitment): Promise<{
+        blockhash: string;
+        lastValidBlockHeight: number;
+    }>;
+    getBalance(publicKey: PublicKey, commitment?: Commitment): Promise<number>;
+    getTokenAccountBalance(publicKey: PublicKey, commitment?: Commitment): Promise<RpcResponseAndContext<import("@solana/web3.js").TokenAmount>>;
+    getAccountInfo(publicKey: PublicKey, commitment?: Commitment): Promise<import("@solana/web3.js").AccountInfo<Buffer<ArrayBufferLike>> | null>;
+    sendTransaction(transaction: VersionedTransaction, options?: ConfirmOptions): Promise<string>;
+    confirmTransaction(strategy: TransactionConfirmationStrategy | string, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
+    simulateTransaction(transaction: VersionedTransaction, options?: {
+        commitment?: Commitment;
+        sigVerify?: boolean;
+    }): Promise<RpcResponseAndContext<SimulatedTransactionResponse>>;
+    requestAirdrop(publicKey: PublicKey, lamports: number): Promise<string>;
+    private executeWithFailover;
+    private backoff;
+}

package/dist/core/tokens/TokenService.d.ts

@@ -0,0 +1,40 @@
+import { Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { RpcClient } from "../rpc/RpcClient";
+import { WalletManager } from "../wallet/WalletManager";
+export declare class TokenService {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    getMintDecimals(mint: PublicKey): Promise<number>;
+    findAssociatedTokenAddress(owner: PublicKey, mint: PublicKey): PublicKey;
+    ensureAtaInstruction(input: {
+        mint: PublicKey;
+        owner: PublicKey;
+        payer: PublicKey;
+    }): Promise<{
+        address: PublicKey;
+        createInstruction: TransactionInstruction | null;
+    }>;
+    buildWrapSolInstructions(input: {
+        wallet: WalletManager;
+        amountLamports: number;
+        createAtaIfMissing: boolean;
+    }): {
+        associatedTokenAddress: PublicKey;
+        createdAssociatedTokenAccount: boolean;
+        instructions: TransactionInstruction[];
+    };
+    buildCreateMintInstructions(input: {
+        payer: PublicKey;
+        mintAuthority: PublicKey;
+        decimals: number;
+    }): Promise<{
+        mintKeypair: Keypair;
+        instructions: TransactionInstruction[];
+    }>;
+    buildMintToInstruction(input: {
+        mint: PublicKey;
+        destinationAta: PublicKey;
+        authority: PublicKey;
+        amount: bigint;
+    }): TransactionInstruction;
+}

package/dist/core/transactions/PostTransactionVerifier.d.ts

@@ -0,0 +1,47 @@
+import { PublicKey } from "@solana/web3.js";
+import { RpcClient } from "../rpc/RpcClient";
+import { TokenService } from "../tokens/TokenService";
+export type BalanceSnapshot = {
+    address: PublicKey;
+    beforeRaw: bigint;
+    decimals: number;
+    kind: "sol" | "spl";
+    label: string;
+};
+export type BalanceVerificationExpectation = {
+    label?: string;
+    maxDecreaseRaw?: bigint;
+    minIncreaseRaw?: bigint;
+    snapshot: BalanceSnapshot;
+};
+export type BalanceVerificationResult = {
+    address: string;
+    afterRaw: bigint;
+    afterUi: string;
+    beforeRaw: bigint;
+    beforeUi: string;
+    deltaRaw: bigint;
+    deltaUi: string;
+    kind: "sol" | "spl";
+    label: string;
+};
+export declare class PostTransactionVerifier {
+    private readonly rpcClient;
+    private readonly tokenService;
+    constructor(rpcClient: RpcClient, tokenService: TokenService);
+    snapshotSolBalance(owner: PublicKey, label?: string): Promise<BalanceSnapshot>;
+    snapshotSplBalanceForOwner(input: {
+        label?: string;
+        mint: PublicKey;
+        owner: PublicKey;
+    }): Promise<BalanceSnapshot>;
+    snapshotSplTokenAccount(input: {
+        label?: string;
+        mint: PublicKey;
+        tokenAccount: PublicKey;
+    }): Promise<BalanceSnapshot>;
+    assertBalanceChanges(expectations: BalanceVerificationExpectation[]): Promise<BalanceVerificationResult[]>;
+    private buildReport;
+    private readCurrentRaw;
+    private getSplTokenBalanceRaw;
+}

package/dist/core/transactions/TransactionService.d.ts

@@ -0,0 +1,46 @@
+import { PublicKey, TransactionInstruction, VersionedTransaction } from "@solana/web3.js";
+import type { BuiltTransaction, SendResult, SendableTransaction, SimulationResult } from "../types/services";
+import { RpcClient } from "../rpc/RpcClient";
+import { WalletManager } from "../wallet/WalletManager";
+export declare class TransactionService {
+    private readonly rpcClient;
+    constructor(rpcClient: RpcClient);
+    buildTransaction(input: {
+        feePayer: PublicKey;
+        instructions: TransactionInstruction[];
+        signer: WalletManager;
+    }): Promise<BuiltTransaction>;
+    buildSolTransferInstruction(input: {
+        from: PublicKey;
+        to: PublicKey;
+        lamports: number;
+    }): TransactionInstruction;
+    buildSolTransferInstructionInSol(input: {
+        from: PublicKey;
+        to: PublicKey;
+        amountSol: number;
+    }): TransactionInstruction;
+    buildSplTransferInstruction(input: {
+        sourceAta: PublicKey;
+        destinationAta: PublicKey;
+        owner: PublicKey;
+        amount: bigint;
+        multiSigners?: PublicKey[];
+        programId?: PublicKey;
+    }): TransactionInstruction;
+    buildSplTransferCheckedInstruction(input: {
+        sourceAta: PublicKey;
+        mint: PublicKey;
+        destinationAta: PublicKey;
+        owner: PublicKey;
+        amount: bigint;
+        decimals: number;
+        multiSigners?: PublicKey[];
+        programId?: PublicKey;
+    }): TransactionInstruction;
+    buildMemoInstruction(memo: string): TransactionInstruction;
+    simulate(transaction: VersionedTransaction): Promise<SimulationResult>;
+    sendAndConfirm(input: SendableTransaction): Promise<SendResult>;
+    private normalizeSendable;
+    private resolveConfirmationTarget;
+}

package/dist/core/types/services.d.ts

@@ -0,0 +1,27 @@
+import type { PublicKey, TransactionConfirmationStrategy, VersionedTransaction } from "@solana/web3.js";
+import type { WalletManager } from "../wallet/WalletManager";
+export type BuiltTransaction = {
+    confirmationStrategy: TransactionConfirmationStrategy;
+    instructionsCount: number;
+    transaction: VersionedTransaction;
+};
+export type SendableTransaction = VersionedTransaction | {
+    confirmationStrategy?: TransactionConfirmationStrategy | string;
+    transaction: VersionedTransaction;
+};
+export type SimulationResult = {
+    err: unknown;
+    logs: string[] | null;
+    unitsConsumed: number | null;
+};
+export type SendResult = {
+    signature: string;
+    slot?: number;
+};
+export type TokenAccountDetails = {
+    address: PublicKey;
+    existed: boolean;
+};
+export type WalletServiceDependencies = {
+    walletManager: WalletManager;
+};

package/dist/core/wallet/WalletManager.d.ts

@@ -0,0 +1,21 @@
+import { Keypair, type PublicKey, VersionedTransaction } from "@solana/web3.js";
+type WalletSource = "env" | "generated" | "remote";
+export declare class WalletManager {
+    private readonly signer;
+    private constructor();
+    static generate(): WalletManager;
+    static loadFromEnv(): WalletManager;
+    static loadRemoteSigner(): WalletManager;
+    static loadConfigured(): WalletManager;
+    static loadOrGenerate(): WalletManager;
+    static fromSecretKey(secretKey: Uint8Array, source?: "generated" | "env"): WalletManager;
+    get payer(): Keypair;
+    get publicKey(): PublicKey;
+    get source(): WalletSource;
+    signTransaction(transaction: VersionedTransaction): Promise<VersionedTransaction>;
+    toSafeSummary(): {
+        publicKey: string;
+        source: WalletSource;
+    };
+}
+export {};

package/dist/defi/DeFiCoordinator.d.ts

@@ -0,0 +1,24 @@
+import type { PolicyConstraints } from "../types/policy";
+import { KoraSigner } from "../kora/KoraSigner";
+import { WalletManager } from "../wallet/WalletManager";
+import type { DeFiExecutionResult, MarketSnapshot } from "./types";
+type StrategyLogger = (message: string) => void;
+export declare class DeFiCoordinator {
+    private readonly walletManager;
+    private readonly koraSigner;
+    private readonly logger;
+    private readonly policy;
+    private readonly kaminoAdapter;
+    private readonly jupiterAdapter;
+    private readonly marinadeAdapter;
+    private readonly raydiumAdapter;
+    constructor(walletManager: WalletManager, koraSigner: KoraSigner, logger?: StrategyLogger, policy?: PolicyConstraints);
+    runStakingStrategy(snapshot: MarketSnapshot): Promise<DeFiExecutionResult | null>;
+    runLiquidityStrategy(snapshot: MarketSnapshot): Promise<DeFiExecutionResult | null>;
+    runLendingStrategy(snapshot: MarketSnapshot): Promise<DeFiExecutionResult | null>;
+    runBorrowingStrategy(snapshot: MarketSnapshot): Promise<DeFiExecutionResult | null>;
+    runTradeStrategy(snapshot: MarketSnapshot): Promise<DeFiExecutionResult | null>;
+    runFullSuite(snapshot: MarketSnapshot): Promise<DeFiExecutionResult[]>;
+    private execute;
+}
+export {};

package/dist/defi/DeFiExecutor.d.ts

@@ -0,0 +1,15 @@
+import type { PolicyConstraints } from "../types/policy";
+import { KoraSigner } from "../kora/KoraSigner";
+import { WalletManager } from "../wallet/WalletManager";
+import type { DeFiExecutionResult, DeFiIntent } from "./types";
+export declare class DeFiExecutor {
+    private readonly policy;
+    private readonly defiPolicyGuard;
+    private readonly policyGuard;
+    constructor(policy: PolicyConstraints);
+    executeIntent(input: {
+        intent: DeFiIntent;
+        koraSigner: KoraSigner;
+        walletManager: WalletManager;
+    }): Promise<DeFiExecutionResult>;
+}

package/dist/defi/DeFiPolicyGuard.d.ts

@@ -0,0 +1,7 @@
+import type { PolicyConstraints } from "../types/policy";
+import type { DeFiIntent } from "./types";
+export declare class DeFiPolicyGuard {
+    private readonly policy;
+    constructor(policy: PolicyConstraints);
+    validateIntent(intent: DeFiIntent): void;
+}

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

@@ -0,0 +1,5 @@
+import type { DeFiIntent, MarketSnapshot } from "../types";
+export declare class JupiterAdapter {
+    readonly protocol: "jupiter";
+    buildTradeIntent(snapshot: MarketSnapshot): DeFiIntent | null;
+}

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

@@ -0,0 +1,6 @@
+import type { DeFiIntent, MarketSnapshot } from "../types";
+export declare class KaminoAdapter {
+    readonly protocol: "kamino";
+    buildDepositIntent(snapshot: MarketSnapshot): DeFiIntent | null;
+    buildBorrowIntent(snapshot: MarketSnapshot): DeFiIntent | null;
+}

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

@@ -0,0 +1,5 @@
+import type { DeFiIntent, MarketSnapshot } from "../types";
+export declare class MarinadeAdapter {
+    readonly protocol: "marinade";
+    buildStakeIntent(snapshot: MarketSnapshot): DeFiIntent | null;
+}

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

@@ -0,0 +1,20 @@
+import type { DeFiIntent, LpInstructionPlan, LpPositionSettings, MarketSnapshot, RaydiumLiquidityPoolConfig, RaydiumUserTokenAccounts } from "../types";
+import { WalletManager } from "../../wallet/WalletManager";
+import { VersionedTransaction } from "@solana/web3.js";
+export declare class RaydiumAdapter {
+    readonly protocol: "raydium";
+    private readonly lpInstructionBuilder;
+    createDefaultPositionSettings(): LpPositionSettings;
+    buildAddLiquidityPlan(settings?: LpPositionSettings): LpInstructionPlan;
+    buildAddLiquidityTransactionDraft(input: {
+        baseAmountIn: number;
+        fixedSide?: "base" | "quote";
+        otherAmountMin: number;
+        owner: WalletManager;
+        poolConfig: RaydiumLiquidityPoolConfig;
+        quoteAmountIn: number;
+        recentBlockhash?: string;
+        userTokenAccounts: RaydiumUserTokenAccounts;
+    }): Promise<VersionedTransaction>;
+    buildAddLiquidityIntent(snapshot: MarketSnapshot, settings?: LpPositionSettings): DeFiIntent | null;
+}

package/dist/defi/kamino/kaminoInstructionCompat.d.ts

@@ -0,0 +1,3 @@
+import { type Instruction as KitInstruction } from "@solana/kit";
+import { TransactionInstruction } from "@solana/web3.js";
+export declare function convertKaminoInstruction(instruction: KitInstruction): TransactionInstruction;

package/dist/defi/kamino/kaminoLiveConfig.d.ts

@@ -0,0 +1,14 @@
+type SupportedKaminoCluster = "devnet" | "localnet" | "mainnet-beta";
+export type KaminoLiveConfig = {
+    actions: {
+        borrowAmountRaw: bigint;
+        depositAmountRaw: bigint;
+    };
+    borrowMint: string;
+    cluster?: SupportedKaminoCluster;
+    depositMint: string;
+    marketAddress: string;
+    programId: string;
+};
+export declare function loadKaminoLiveConfig(): KaminoLiveConfig;
+export {};

package/dist/defi/kamino/loadKaminoMarketWithFallback.d.ts

@@ -0,0 +1,11 @@
+import { type Address } from "@solana/kit";
+import { KaminoMarket } from "@kamino-finance/klend-sdk";
+type Cluster = "devnet" | "localnet" | "mainnet-beta" | "testnet" | "unknown";
+export declare function loadKaminoMarketWithFallback(input: {
+    cluster: Cluster;
+    logger?: (message: string) => void;
+    marketAddress: Address;
+    programAddress: Address;
+    rpcUrl: string;
+}): Promise<KaminoMarket>;
+export {};

package/dist/defi/lp/LpInstructionBuilder.d.ts

@@ -0,0 +1,15 @@
+import type { LpInstructionPlan, LpPositionSettings, MarketSnapshot } from "../types";
+export interface LpInstructionBuilder {
+    buildAddLiquidityPlan(input: {
+        depositLamports: number;
+        settings: LpPositionSettings;
+    }): LpInstructionPlan;
+    buildHarvestFeesPlan(input: {
+        settings: LpPositionSettings;
+        snapshot: MarketSnapshot;
+    }): LpInstructionPlan | null;
+    buildRemoveLiquidityPlan(input: {
+        withdrawLamports: number;
+        settings: LpPositionSettings;
+    }): LpInstructionPlan;
+}

package/dist/defi/lp/RaydiumLpInstructionBuilder.d.ts

@@ -0,0 +1,28 @@
+import { VersionedTransaction } from "@solana/web3.js";
+import { WalletManager } from "../../wallet/WalletManager";
+import type { LpInstructionBuilder } from "./LpInstructionBuilder";
+import type { LpInstructionPlan, LpPositionSettings, MarketSnapshot, RaydiumLiquidityPoolConfig, RaydiumUserTokenAccounts } from "../types";
+export declare class RaydiumLpInstructionBuilder implements LpInstructionBuilder {
+    buildAddLiquidityPlan(input: {
+        depositLamports: number;
+        settings: LpPositionSettings;
+    }): LpInstructionPlan;
+    buildAddLiquidityTransactionDraft(input: {
+        baseAmountIn: number;
+        fixedSide?: "base" | "quote";
+        otherAmountMin: number;
+        owner: WalletManager;
+        poolConfig: RaydiumLiquidityPoolConfig;
+        quoteAmountIn: number;
+        recentBlockhash?: string;
+        userTokenAccounts: RaydiumUserTokenAccounts;
+    }): Promise<VersionedTransaction>;
+    buildHarvestFeesPlan(input: {
+        settings: LpPositionSettings;
+        snapshot: MarketSnapshot;
+    }): LpInstructionPlan | null;
+    buildRemoveLiquidityPlan(input: {
+        withdrawLamports: number;
+        settings: LpPositionSettings;
+    }): LpInstructionPlan;
+}

package/dist/defi/lp/raydiumDevnetConfig.d.ts

@@ -0,0 +1,11 @@
+import type { RaydiumLiquidityPoolConfig, RaydiumUserTokenAccounts } from "../types";
+export type RaydiumLpDevnetConfig = {
+    amounts: {
+        baseAmountIn: number;
+        otherAmountMin: number;
+        quoteAmountIn: number;
+    };
+    poolConfig: RaydiumLiquidityPoolConfig;
+    userTokenAccounts: RaydiumUserTokenAccounts;
+};
+export declare function loadRaydiumLpDevnetConfig(): RaydiumLpDevnetConfig;

package/dist/defi/protocols.d.ts

@@ -0,0 +1,8 @@
+import type { SupportedProtocol } from "../types/policy";
+export type ProtocolPreset = {
+    defaultMarketId: string;
+    description: string;
+    label: string;
+    protocol: SupportedProtocol;
+};
+export declare const PROTOCOL_PRESETS: Record<SupportedProtocol, ProtocolPreset>;

package/dist/defi/types.d.ts

@@ -0,0 +1,65 @@
+import type { SupportedProtocol } from "../types/policy";
+export type DeFiAction = "trade" | "stake" | "unstake" | "add_liquidity" | "remove_liquidity" | "harvest" | "deposit" | "withdraw" | "borrow" | "repay";
+export type DeFiIntent = {
+    action: DeFiAction;
+    amountLamports: number;
+    expectedHealthFactor?: number;
+    marketId: string;
+    memo: string;
+    protocol: SupportedProtocol;
+    slippageBps: number;
+};
+export type MarketSnapshot = {
+    borrowDemandUsdcAtomic?: number;
+    buyThresholdUsd?: number;
+    collateralSolLamports?: number;
+    healthFactor?: number;
+    idleSolLamports?: number;
+    idleUsdcAtomic?: number;
+    liquidityInRange?: boolean;
+    rewardsClaimableAtomic?: number;
+    solPriceUsd?: number;
+};
+export type DeFiExecutionResult = {
+    action: DeFiAction;
+    memo: string;
+    mock: boolean;
+    protocol: SupportedProtocol;
+    signature: string;
+};
+export type LpPositionSettings = {
+    harvestThresholdAtomic: number;
+    maxCapitalLamports: number;
+    maxSlippageBps: number;
+    poolId: string;
+    rebalanceOnOutOfRange: boolean;
+    tokenPair: string;
+};
+export type LpInstructionPlan = {
+    action: "add_liquidity" | "remove_liquidity" | "harvest";
+    amountLamports: number;
+    operatorSummary: string;
+    poolId: string;
+    protocol: "raydium";
+    requiredAccounts: string[];
+    slippageBps: number;
+    tokenPair: string;
+};
+export type RaydiumLiquidityPoolConfig = {
+    authority: string;
+    baseVault: string;
+    lpMint: string;
+    marketEventQueue: string;
+    marketId: string;
+    openOrders: string;
+    poolId: string;
+    poolType: "Standard" | "StablePool";
+    programId: string;
+    quoteVault: string;
+    targetOrders: string;
+};
+export type RaydiumUserTokenAccounts = {
+    baseTokenAccount: string;
+    lpTokenAccount: string;
+    quoteTokenAccount: string;
+};

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

@@ -0,0 +1,24 @@
+import type { KoraSigner } from "../../kora/KoraSigner";
+import type { WalletManager } from "../../wallet/WalletManager";
+import type { PolicyConstraints } from "../../types/policy";
+import type { UniversalDeFiAdapter, UniversalExecutionOptions, UniversalDeFiRequest, UniversalExecutionResult } from "./types";
+type OrchestratorLogger = (message: string) => void;
+export declare class UniversalDeFiOrchestrator {
+    private readonly deps;
+    private readonly adapters;
+    private readonly executor;
+    constructor(deps: {
+        koraSigner: KoraSigner;
+        liveFirst?: boolean;
+        logger?: OrchestratorLogger;
+        policy?: PolicyConstraints;
+        walletManager: WalletManager;
+    }, adapters?: UniversalDeFiAdapter[]);
+    execute(request: UniversalDeFiRequest, options?: UniversalExecutionOptions): Promise<UniversalExecutionResult>;
+    executeBatch(requests: UniversalDeFiRequest[], options?: UniversalExecutionOptions): Promise<UniversalExecutionResult[]>;
+    private resolveAdapter;
+    private log;
+    private tryExecutePreparedLive;
+    private routeToEvm;
+}
+export {};