defi-dash-sdk 0.1.3 → 0.1.4

package/dist/sdk.js

@@ -7,41 +7,40 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefiDashSDK = void 0;
-const transactions_1 = require("@mysten/sui/transactions");
 const sdk_ts_1 = require("@7kprotocol/sdk-ts");
 const types_1 = require("./types");
-const sui_scallop_sdk_1 = require("@scallop-io/sui-scallop-sdk");
 const adapter_1 = require("./protocols/suilend/adapter");
 const adapter_2 = require("./protocols/navi/adapter");
 const adapter_3 = require("./protocols/scallop/adapter");
 const flash_loan_1 = require("./protocols/scallop/flash-loan");
 const utils_1 = require("./utils");
-const gas_1 = require("./utils/gas");
 const errors_1 = require("./utils/errors");
+const execution_1 = require("./utils/execution");
 const leverage_1 = require("./strategies/leverage");
 const deleverage_1 = require("./strategies/deleverage");
-const constants_1 = require("./protocols/suilend/constants");
+const leverage_preview_1 = require("./strategies/leverage-preview");
+const leverage_route_1 = require("./strategies/leverage-route");
 /**
  * DeFi Dash SDK - Main entry point
  *
- * @example Node.js usage:
+ * @example Node.js usage (build + execute):
  * ```typescript
- * const sdk = new DefiDashSDK();
- * await sdk.initialize(suiClient, keypair);
- * const result = await sdk.leverage({ protocol: LendingProtocol.Suilend, ... });
+ * const sdk = await DefiDashSDK.create(suiClient, keypair);
+ *
+ * const tx = new Transaction();
+ * tx.setSender(address);
+ * await sdk.buildLeverageTransaction(tx, { protocol, depositAsset, ... });
+ * const result = await sdk.execute(tx);   // or sdk.dryRun(tx)
  * ```
  *
  * @example Browser usage:
  * ```typescript
- * const sdk = new DefiDashSDK();
- * await sdk.initialize(suiClient, userAddress);  // No keypair needed
+ * const sdk = await DefiDashSDK.create(suiClient, userAddress);
  *
  * const tx = new Transaction();
  * tx.setSender(userAddress);
  * await sdk.buildLeverageTransaction(tx, { protocol, depositAsset, ... });
- *
- * // Sign with wallet adapter
- * await signAndExecute({ transaction: tx });
+ * await signAndExecute({ transaction: tx }); // wallet adapter
  * ```
  */
 class DefiDashSDK {
@@ -51,25 +50,34 @@ class DefiDashSDK {
         this.options = options;
     }
     /**
-     * Initialize the SDK
+     * Create and initialize the SDK in one step (recommended).
      *
      * @param suiClient - Sui client instance
      * @param keypairOrAddress - Ed25519Keypair (Node.js) or user address string (Browser)
+     * @param options - SDK options
      *
      * @example Node.js
      * ```typescript
-     * await sdk.initialize(suiClient, keypair);
+     * const sdk = await DefiDashSDK.create(suiClient, keypair);
      * ```
      *
      * @example Browser
      * ```typescript
-     * await sdk.initialize(suiClient, account.address);
+     * const sdk = await DefiDashSDK.create(suiClient, account.address);
      * ```
      */
+    static async create(suiClient, keypairOrAddress, options = {}) {
+        const sdk = new DefiDashSDK(options);
+        await sdk.initialize(suiClient, keypairOrAddress);
+        return sdk;
+    }
+    /**
+     * Initialize the SDK (internal — use `DefiDashSDK.create()`)
+     */
     async initialize(suiClient, keypairOrAddress) {
         this.suiClient = suiClient;
         // Detect if keypair or address
-        if (typeof keypairOrAddress === "string") {
+        if (typeof keypairOrAddress === 'string') {
             // Browser mode: address only
             this._userAddress = keypairOrAddress;
         }
@@ -119,21 +127,9 @@ class DefiDashSDK {
         }
         return this._userAddress;
     }
-    /**
-     * Resolve asset symbol to coin type
-     */
+    /** Resolve asset symbol to coin type */
     resolveCoinType(asset) {
-        // If already a full coin type, normalize it
-        if (asset.includes("::")) {
-            return (0, utils_1.normalizeCoinType)(asset);
-        }
-        // Look up by symbol
-        const upperSymbol = asset.toUpperCase();
-        const coinType = types_1.COIN_TYPES[upperSymbol];
-        if (coinType) {
-            return (0, utils_1.normalizeCoinType)(coinType);
-        }
-        throw new errors_1.UnknownAssetError(asset);
+        return (0, utils_1.resolveCoinType)(asset);
     }
     // ============================================================================
     // Browser-Compatible Transaction Builder Methods
@@ -166,11 +162,13 @@ class DefiDashSDK {
     async buildLeverageTransaction(tx, params) {
         this.ensureInitialized();
         // Validate that exactly one of depositAmount or depositValueUsd is provided
-        if (!params.depositAmount && !params.depositValueUsd) {
-            throw new errors_1.InvalidParameterError("Either depositAmount or depositValueUsd must be provided");
+        const hasAmount = params.depositAmount != null;
+        const hasValueUsd = params.depositValueUsd != null;
+        if (!hasAmount && !hasValueUsd) {
+            throw new errors_1.InvalidParameterError('Either depositAmount or depositValueUsd must be provided');
         }
-        if (params.depositAmount && params.depositValueUsd) {
-            throw new errors_1.InvalidParameterError("Cannot provide both depositAmount and depositValueUsd. Choose one.");
+        if (hasAmount && hasValueUsd) {
+            throw new errors_1.InvalidParameterError('Cannot provide both depositAmount and depositValueUsd. Choose one.');
         }
         const protocol = this.getProtocol(params.protocol);
         // Clear adapter state for new transaction (Scallop tracks unstaked obligations)
@@ -178,11 +176,21 @@ class DefiDashSDK {
             protocol.clearPendingState?.();
         }
         const coinType = this.resolveCoinType(params.depositAsset);
-        const reserve = (0, constants_1.getReserveByCoinType)(coinType);
-        const decimals = reserve?.decimals || 8;
+        const decimals = (0, utils_1.getDecimals)(coinType);
+        // Validate multiplier against protocol limits
+        if (params.multiplier <= 1) {
+            throw new errors_1.InvalidParameterError(`Multiplier must be greater than 1 (got ${params.multiplier})`);
+        }
+        const riskParams = await protocol.getAssetRiskParams(coinType);
+        if (params.multiplier > riskParams.maxMultiplier) {
+            throw new errors_1.InvalidParameterError(`Multiplier ${params.multiplier}x exceeds protocol max ${riskParams.maxMultiplier.toFixed(2)}x (LTV ${(riskParams.ltv * 100).toFixed(0)}%)`);
+        }
         // Convert depositValueUsd to depositAmount if needed
         let depositAmountStr;
-        if (params.depositValueUsd) {
+        if (hasValueUsd) {
+            if (params.depositValueUsd <= 0) {
+                throw new errors_1.InvalidParameterError('depositValueUsd must be positive');
+            }
             const price = await (0, sdk_ts_1.getTokenPrice)(coinType);
             const amountInToken = params.depositValueUsd / price;
             depositAmountStr = amountInToken.toFixed(decimals);
@@ -191,6 +199,9 @@ class DefiDashSDK {
             depositAmountStr = params.depositAmount;
         }
         const depositAmount = (0, utils_1.parseUnits)(depositAmountStr, decimals);
+        if (depositAmount <= 0n) {
+            throw new errors_1.InvalidParameterError('depositAmount must be positive');
+        }
         await (0, leverage_1.buildLeverageTransaction)(tx, {
             protocol,
             flashLoanClient: this.flashLoanClient,
@@ -249,193 +260,66 @@ class DefiDashSDK {
         });
     }
     // ============================================================================
-    // Node.js Strategy Methods (with execution)
+    // Position Methods
     // ============================================================================
     /**
-     * Execute leverage strategy (Node.js only)
-     *
-     * Opens a leveraged position by:
-     * 1. Taking a flash loan
-     * 2. Swapping borrowed USDC for deposit asset
-     * 3. Depositing total collateral (user deposit + swapped amount)
-     * 4. Borrowing USDC to repay flash loan
-     *
-     * @param params - Leverage parameters
-     * @param params.protocol - Lending protocol to use (Suilend, Scallop, or Navi)
-     * @param params.depositAsset - Asset symbol (e.g., "SUI", "LBTC") or full coin type
-     * @param params.depositAmount - Amount to deposit (required if depositValueUsd not provided)
-     * @param params.depositValueUsd - USD value to deposit (required if depositAmount not provided)
-     * @param params.multiplier - Leverage multiplier (e.g., 2.0 for 2x leverage)
-     * @param params.dryRun - If true, simulates transaction and returns gas estimate without executing
+     * Get position for a single protocol
      *
-     * @returns Strategy result with success status, transaction digest (if executed), and gas used
-     *
-     * @throws {SDKNotInitializedError} If SDK not initialized
-     * @throws {KeypairRequiredError} If keypair not provided (Node.js mode required)
-     * @throws {InvalidParameterError} If both or neither depositAmount and depositValueUsd provided
-     * @throws {UnknownAssetError} If asset symbol not recognized
+     * @param protocol - Lending protocol to query
+     * @returns Position info or null if no active position
      *
      * @example
      * ```typescript
-     * // Leverage with fixed amount
-     * const result = await sdk.leverage({
-     *   protocol: LendingProtocol.Suilend,
-     *   depositAsset: 'LBTC',
-     *   depositAmount: '0.001',
-     *   multiplier: 2.0,
-     *   dryRun: true
-     * });
-     *
-     * // Leverage with USD value
-     * const result = await sdk.leverage({
-     *   protocol: LendingProtocol.Scallop,
-     *   depositAsset: 'SUI',
-     *   depositValueUsd: 100,  // $100 worth of SUI
-     *   multiplier: 3.0,
-     *   dryRun: false
-     * });
+     * const position = await sdk.getPosition(LendingProtocol.Navi);
+     * if (position) {
+     *   console.log(`Collateral: ${position.collateral.symbol} $${position.collateral.valueUsd}`);
+     *   console.log(`Debt: ${position.debt.symbol} $${position.debt.valueUsd}`);
+     * }
      * ```
-     *
-     * @remarks
-     * - Requires SDK to be initialized with keypair (Node.js mode)
-     * - For browser usage, use {@link buildLeverageTransaction} instead
-     * - Scallop protocol uses optimized native SDK for oracle updates
-     * - Gas is automatically optimized via dry run (20% buffer added)
      */
-    async leverage(params) {
+    async getPosition(protocol) {
         this.ensureInitialized();
-        if (!this.keypair) {
-            return {
-                success: false,
-                error: "Keypair required for execution. Use buildLeverageTransaction for browser.",
-            };
-        }
-        // Scallop uses its own SDK builder for oracle updates
-        if (params.protocol === types_1.LendingProtocol.Scallop) {
-            return this.executeScallopLeverage(params);
-        }
-        const tx = new transactions_1.Transaction();
-        tx.setSender(this.userAddress);
-        try {
-            await this.buildLeverageTransaction(tx, params);
-            if (params.dryRun) {
-                return this.dryRunWithGasOptimization(tx);
-            }
-            // execute() runs dryrun first and optimizes gas budget
-            return this.execute(tx);
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.message || String(error),
-            };
-        }
+        return this.getProtocol(protocol).getPosition(this.userAddress);
     }
     /**
-     * Execute deleverage strategy (Node.js only)
+     * Get all open positions across all supported protocols
      *
-     * Closes or reduces a leveraged position by:
-     * 1. Taking a flash loan to repay debt
-     * 2. Withdrawing collateral
-     * 3. Swapping portion of collateral to USDC
-     * 4. Repaying flash loan
-     * 5. Keeping remaining collateral
-     *
-     * @param params - Deleverage parameters
-     * @param params.protocol - Lending protocol where position exists
-     * @param params.dryRun - If true, simulates transaction without executing
+     * Queries Suilend, Navi, and Scallop in parallel and returns
+     * only the protocols that have an active position (collateral > 0 or debt > 0).
      *
-     * @returns Strategy result with success status, transaction digest, and gas used
-     *
-     * @throws {SDKNotInitializedError} If SDK not initialized
-     * @throws {KeypairRequiredError} If keypair not provided (Node.js mode required)
-     * @throws {PositionNotFoundError} If no position exists on the protocol
-     * @throws {NoDebtError} If position has no debt (use withdraw instead)
+     * @returns Array of open positions with protocol identifier
      *
      * @example
      * ```typescript
-     * // Dry run first to preview
-     * const preview = await sdk.deleverage({
-     *   protocol: LendingProtocol.Suilend,
-     *   dryRun: true
-     * });
-     *
-     * if (preview.success) {
-     *   console.log(`Estimated gas: ${preview.gasUsed}`);
-     *
-     *   // Execute for real
-     *   const result = await sdk.deleverage({
-     *     protocol: LendingProtocol.Suilend,
-     *     dryRun: false
-     *   });
+     * const positions = await sdk.getOpenPositions();
      *
-     *   if (result.success) {
-     *     console.log(`Position closed: ${result.txDigest}`);
+     * for (const { protocol, position } of positions) {
+     *   console.log(`${protocol}: ${position.collateral.symbol} $${position.collateral.valueUsd.toFixed(2)}`);
+     *   if (position.debt.amount > 0n) {
+     *     console.log(`  Debt: ${position.debt.symbol} $${position.debt.valueUsd.toFixed(2)}`);
      *   }
+     *   console.log(`  Net: $${position.netValueUsd.toFixed(2)}`);
      * }
      * ```
-     *
-     * @remarks
-     * - Requires SDK to be initialized with keypair (Node.js mode)
-     * - For browser usage, use {@link buildDeleverageTransaction} instead
-     * - Automatically fetches current position and calculates optimal swap amounts
-     * - Gas is automatically optimized via dry run (20% buffer added)
      */
-    async deleverage(params) {
+    async getOpenPositions() {
         this.ensureInitialized();
-        if (!this.keypair) {
-            return {
-                success: false,
-                error: "Keypair required for execution. Use buildDeleverageTransaction for browser.",
-            };
-        }
-        const tx = new transactions_1.Transaction();
-        tx.setSender(this.userAddress);
-        try {
-            await this.buildDeleverageTransaction(tx, params);
-            if (params.dryRun) {
-                return this.dryRunWithGasOptimization(tx);
+        const allProtocols = [
+            types_1.LendingProtocol.Suilend,
+            types_1.LendingProtocol.Navi,
+            types_1.LendingProtocol.Scallop,
+        ];
+        const results = await Promise.all(allProtocols.map(async (p) => {
+            try {
+                const position = await this.getProtocol(p).getPosition(this.userAddress);
+                return position ? { protocol: p, position } : null;
             }
-            // execute() runs dryrun first and optimizes gas budget
-            return this.execute(tx);
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.message || String(error),
-            };
-        }
-    }
-    // ============================================================================
-    // Position Methods
-    // ============================================================================
-    /**
-     * Get current lending position on a specific protocol
-     *
-     * @param protocol - The lending protocol to query
-     *
-     * @returns Position information including collateral, debt, and metrics, or null if no position exists
-     *
-     * @throws {SDKNotInitializedError} If SDK not initialized
-     * @throws {UnsupportedProtocolError} If protocol not supported
-     *
-     * @example
-     * ```typescript
-     * const position = await sdk.getPosition(LendingProtocol.Suilend);
-     *
-     * if (position) {
-     *   console.log(`Collateral: ${position.collateral.amount} ${position.collateral.symbol}`);
-     *   console.log(`Debt: ${position.debt.amount} ${position.debt.symbol}`);
-     *   console.log(`Health Factor: ${position.healthFactor}`);
-     *   console.log(`Net Value: $${position.netValueUsd}`);
-     * } else {
-     *   console.log('No position found');
-     * }
-     * ```
-     */
-    async getPosition(protocol) {
-        this.ensureInitialized();
-        return this.getProtocol(protocol).getPosition(this.userAddress);
+            catch (e) {
+                console.warn(`[DefiDashSDK] Failed to fetch position for ${p}:`, e);
+                return null;
+            }
+        }));
+        return results.filter((r) => r !== null);
     }
     // ============================================================================
     // Aggregation Methods
@@ -488,7 +372,7 @@ class DefiDashSDK {
                 }
             }
             catch (e) {
-                // Silently skip failed protocol fetches
+                console.warn(`[DefiDashSDK] Failed to fetch portfolio for ${p}:`, e);
             }
             // Return resilient default
             return {
@@ -513,6 +397,7 @@ class DefiDashSDK {
      * Useful for showing users what their leveraged position will look like.
      *
      * @param params - Preview parameters
+     * @param params.protocol - Lending protocol to use (suilend, navi, scallop)
      * @param params.depositAsset - Asset symbol (e.g., "SUI", "LBTC") or full coin type
      * @param params.depositAmount - Amount to deposit (required if depositValueUsd not provided)
      * @param params.depositValueUsd - USD value to deposit (required if depositAmount not provided)
@@ -521,12 +406,14 @@ class DefiDashSDK {
      * @returns Preview containing position metrics, flash loan details, and risk parameters
      *
      * @throws {InvalidParameterError} If both or neither depositAmount and depositValueUsd provided
+     * @throws {InvalidParameterError} If multiplier exceeds protocol's max multiplier
      * @throws {UnknownAssetError} If asset symbol not recognized
      *
      * @example
      * ```typescript
      * // Preview with fixed amount
      * const preview = await sdk.previewLeverage({
+     *   protocol: 'suilend',
      *   depositAsset: 'LBTC',
      *   depositAmount: '0.001',
      *   multiplier: 2.0
@@ -536,11 +423,13 @@ class DefiDashSDK {
      * console.log(`Flash Loan: ${preview.flashLoanUsdc / 1e6} USDC`);
      * console.log(`Total Position: $${preview.totalPositionUsd}`);
      * console.log(`Position LTV: ${preview.ltvPercent.toFixed(1)}%`);
+     * console.log(`Max Multiplier: ${preview.maxMultiplier.toFixed(2)}x`);
      * console.log(`Liquidation Price: $${preview.liquidationPrice}`);
      * console.log(`Price Drop Buffer: ${preview.priceDropBuffer.toFixed(1)}%`);
      *
      * // Preview with USD value
      * const preview2 = await sdk.previewLeverage({
+     *   protocol: 'scallop',
      *   depositAsset: 'SUI',
      *   depositValueUsd: 100,  // $100 worth
      *   multiplier: 3.0
@@ -548,37 +437,59 @@ class DefiDashSDK {
      * ```
      *
      * @remarks
-     * - Does not require SDK initialization (standalone utility)
+     * - Queries protocol-specific LTV to calculate accurate max multiplier
+     * - Max multiplier = 1 / (1 - LTV), e.g., 65% LTV → 2.857x max
      * - Fetches current market prices from 7k Protocol
      * - Calculations are estimates; actual execution may differ slightly
      * - Higher multipliers increase both returns and liquidation risk
      */
     async previewLeverage(params) {
-        // Validate that exactly one is provided
-        if (!params.depositAmount && !params.depositValueUsd) {
-            throw new errors_1.InvalidParameterError("Either depositAmount or depositValueUsd must be provided");
-        }
-        if (params.depositAmount && params.depositValueUsd) {
-            throw new errors_1.InvalidParameterError("Cannot provide both depositAmount and depositValueUsd. Choose one.");
-        }
+        const protocol = this.getProtocol(params.protocol);
         const coinType = this.resolveCoinType(params.depositAsset);
-        const reserve = (0, constants_1.getReserveByCoinType)(coinType);
-        const decimals = reserve?.decimals || 8;
-        // Convert depositValueUsd to depositAmount if needed
-        let depositAmountStr;
-        if (params.depositValueUsd) {
-            const price = await (0, sdk_ts_1.getTokenPrice)(coinType);
-            const amountInToken = params.depositValueUsd / price;
-            depositAmountStr = amountInToken.toFixed(decimals);
-        }
-        else {
-            depositAmountStr = params.depositAmount;
-        }
-        const depositAmount = (0, utils_1.parseUnits)(depositAmountStr, decimals);
-        return (0, leverage_1.calculateLeveragePreview)({
-            depositCoinType: coinType,
-            depositAmount,
+        return (0, leverage_preview_1.previewLeverage)({
+            coinType,
+            depositAmount: params.depositAmount,
+            depositValueUsd: params.depositValueUsd,
             multiplier: params.multiplier,
+        }, {
+            protocol,
+            swapClient: this.swapClient,
+            suiClient: this.suiClient,
+        });
+    }
+    // ============================================================================
+    // Route Finding
+    // ============================================================================
+    /**
+     * Find the best leverage route across all initialized protocols for a given asset.
+     *
+     * Returns two recommendations:
+     * 1. **bestMaxMultiplier** — the protocol offering the highest possible leverage
+     * 2. **bestApy** — the protocol with the highest net APY at a safe multiplier
+     *
+     * The safe multiplier = min(maxMultiplier across protocols) - LEVERAGE_MULTIPLIER_BUFFER
+     *
+     * @example
+     * ```typescript
+     * const route = await sdk.findBestLeverageRoute({
+     *   depositAsset: 'SUI',
+     *   depositValueUsd: 100,
+     * });
+     *
+     * console.log(route.bestMaxMultiplier.protocol); // e.g. 'scallop'
+     * console.log(route.bestApy.protocol);           // e.g. 'suilend'
+     * console.log(route.safeMultiplier);             // e.g. 2.83
+     * ```
+     */
+    async findBestLeverageRoute(params) {
+        this.ensureInitialized();
+        return (0, leverage_route_1.findBestLeverageRoute)(params, {
+            protocols: this.protocols,
+            previewFn: (protocol, previewParams) => this.previewLeverage({
+                protocol,
+                ...previewParams,
+            }),
+            resolveCoinType: (asset) => this.resolveCoinType(asset),
         });
     }
     // ============================================================================
@@ -605,34 +516,31 @@ class DefiDashSDK {
         return this.userAddress;
     }
     // ============================================================================
-    // Internal Methods
+    // Execution Methods
     // ============================================================================
     /**
-     * Dry run with gas optimization
+     * Dry run a transaction with gas optimization
+     *
+     * Simulates the transaction and returns estimated gas usage.
+     * Does NOT execute the transaction on-chain.
      *
-     * Uses small fixed budget for dryrun, returns actual gas estimation.
+     * @param tx - Built transaction to simulate
+     * @returns Strategy result with gas estimate
+     *
+     * @example
+     * ```typescript
+     * const tx = new Transaction();
+     * tx.setSender(address);
+     * await sdk.buildLeverageTransaction(tx, params);
+     * const result = await sdk.dryRun(tx);
+     * console.log(`Estimated gas: ${result.gasUsed}`);
+     * ```
      */
-    async dryRunWithGasOptimization(tx) {
-        // Use small fixed budget for dryrun simulation
-        tx.setGasBudget(gas_1.DRYRUN_GAS_BUDGET);
-        const result = await this.suiClient.dryRunTransactionBlock({
-            transactionBlock: await tx.build({ client: this.suiClient }),
-        });
-        if (result.effects.status.status === "success") {
-            const actualGas = (0, gas_1.calculateActualGas)(result.effects.gasUsed);
-            const optimizedBudget = (0, gas_1.calculateOptimizedBudget)(actualGas);
-            return {
-                success: true,
-                gasUsed: optimizedBudget,
-            };
-        }
-        return {
-            success: false,
-            error: result.effects.status.error || "Dry run failed",
-        };
+    async dryRun(tx) {
+        return (0, execution_1.dryRunTransaction)(this.suiClient, tx);
     }
     /**
-     * Execute transaction with gas optimization
+     * Execute a transaction with gas optimization (Node.js only)
      *
      * Flow:
      * 1. Dryrun with small fixed budget to get actual gas usage
@@ -640,285 +548,25 @@ class DefiDashSDK {
      * 3. Check user has enough balance
      * 4. Execute with optimized budget
      *
-     * This ensures we never overpay for gas.
+     * @param tx - Built transaction to execute
+     * @returns Strategy result with transaction digest and gas used
+     *
+     * @throws {KeypairRequiredError} If keypair not provided
+     *
+     * @example
+     * ```typescript
+     * const tx = new Transaction();
+     * tx.setSender(address);
+     * await sdk.buildLeverageTransaction(tx, params);
+     * const result = await sdk.execute(tx);
+     * console.log(`TX: ${result.txDigest}`);
+     * ```
      */
     async execute(tx) {
         if (!this.keypair) {
             throw new errors_1.KeypairRequiredError();
         }
-        // Step 1: Check user's available gas balance first
-        const balance = await this.suiClient.getBalance({
-            owner: this.userAddress,
-        });
-        const userBalance = BigInt(balance.totalBalance);
-        // Step 2: Set dryrun budget (use available balance or default, whichever is lower)
-        const dryrunBudget = userBalance < BigInt(gas_1.DRYRUN_GAS_BUDGET)
-            ? userBalance
-            : BigInt(gas_1.DRYRUN_GAS_BUDGET);
-        if (dryrunBudget < 10000000n) {
-            // Min 0.01 SUI for dryrun
-            return {
-                success: false,
-                error: `Insufficient balance for gas. Have: ${Number(userBalance) / 1e9} SUI`,
-            };
-        }
-        tx.setGasBudget(dryrunBudget);
-        const dryRunResult = await this.suiClient.dryRunTransactionBlock({
-            transactionBlock: await tx.build({ client: this.suiClient }),
-        });
-        if (dryRunResult.effects.status.status !== "success") {
-            return {
-                success: false,
-                error: `Dry run failed: ${dryRunResult.effects.status.error}`,
-            };
-        }
-        // Step 3: Calculate optimized gas budget (actual + 20% buffer)
-        const actualGas = (0, gas_1.calculateActualGas)(dryRunResult.effects.gasUsed);
-        const optimizedBudget = (0, gas_1.calculateOptimizedBudget)(actualGas);
-        // Step 4: Check if user has enough balance for actual execution
-        if (userBalance < optimizedBudget) {
-            return {
-                success: false,
-                error: `Insufficient balance for gas. Need: ${Number(optimizedBudget) / 1e9} SUI, Have: ${Number(userBalance) / 1e9} SUI`,
-            };
-        }
-        // Step 4: Execute with optimized gas budget
-        tx.setGasBudget(optimizedBudget);
-        const result = await this.suiClient.signAndExecuteTransaction({
-            signer: this.keypair,
-            transaction: tx,
-            options: {
-                showEffects: true,
-            },
-        });
-        if (result.effects?.status.status === "success") {
-            return {
-                success: true,
-                txDigest: result.digest,
-                gasUsed: BigInt(result.effects.gasUsed.computationCost),
-            };
-        }
-        return {
-            success: false,
-            txDigest: result.digest,
-            error: result.effects?.status.error || "Execution failed",
-        };
-    }
-    // ============================================================================
-    // Scallop-Specific Methods (uses Scallop SDK builder for oracle updates)
-    // ============================================================================
-    /**
-     * Execute Scallop leverage using native Scallop SDK builder
-     *
-     * Scallop requires oracle price updates via their SDK's updateAssetPricesQuick.
-     * This method uses the Scallop SDK builder internally.
-     */
-    async executeScallopLeverage(params) {
-        if (!this.keypair) {
-            return { success: false, error: "Keypair required" };
-        }
-        try {
-            // Resolve coin type and amounts
-            const coinType = this.resolveCoinType(params.depositAsset);
-            const reserve = (0, constants_1.getReserveByCoinType)(coinType);
-            const decimals = reserve?.decimals || 9;
-            const symbol = coinType.split("::").pop()?.toUpperCase() || "SUI";
-            const isSui = coinType.endsWith("::sui::SUI");
-            // Get coin name for Scallop (e.g., "sui", "usdc")
-            const coinName = this.getScallopCoinName(coinType);
-            // Calculate deposit amount
-            let depositAmountStr;
-            if (params.depositValueUsd) {
-                const price = await (0, sdk_ts_1.getTokenPrice)(coinType);
-                depositAmountStr = (params.depositValueUsd / price).toFixed(decimals);
-            }
-            else {
-                depositAmountStr = params.depositAmount;
-            }
-            const depositAmountRaw = (0, utils_1.parseUnits)(depositAmountStr, decimals);
-            const depositAmountHuman = parseFloat(depositAmountStr);
-            // Calculate flash loan amount
-            const depositPrice = await (0, sdk_ts_1.getTokenPrice)(coinType);
-            const initialEquityUsd = depositAmountHuman * depositPrice;
-            const flashLoanUsd = initialEquityUsd * (params.multiplier - 1);
-            const flashLoanUsdc = BigInt(Math.ceil(flashLoanUsd * 1e6 * 1.02));
-            const flashLoanFee = flash_loan_1.ScallopFlashLoanClient.calculateFee(flashLoanUsdc);
-            const repaymentAmount = flashLoanUsdc + flashLoanFee;
-            const borrowFeeBuffer = 1.003;
-            const borrowAmount = BigInt(Math.ceil(Number(repaymentAmount) * borrowFeeBuffer));
-            // Initialize Scallop SDK with secret key
-            // Scallop SDK requires the original secret key string (not extracted from keypair)
-            if (!this.options.secretKey) {
-                return {
-                    success: false,
-                    error: "Scallop operations require secretKey in SDK options. Pass { secretKey: 'suiprivkey...' } to DefiDashSDK constructor.",
-                };
-            }
-            const scallop = new sui_scallop_sdk_1.Scallop({
-                secretKey: this.options.secretKey,
-                networkType: "mainnet",
-            });
-            await scallop.init();
-            const builder = await scallop.createScallopBuilder();
-            const client = await scallop.createScallopClient();
-            const tx = builder.createTxBlock();
-            tx.setSender(this.userAddress);
-            // Check for existing obligation
-            const existingObligations = await client.getObligations();
-            const hasExistingObligation = existingObligations.length > 0;
-            let existingObligationId = null;
-            let existingObligationKeyId = null;
-            let isCurrentlyLocked = false;
-            if (hasExistingObligation) {
-                existingObligationId = existingObligations[0].id;
-                existingObligationKeyId = existingObligations[0].keyId;
-                isCurrentlyLocked = existingObligations[0].locked;
-            }
-            // Get swap quote
-            const swapQuotes = await this.swapClient.quote({
-                amountIn: flashLoanUsdc.toString(),
-                coinTypeIn: types_1.COIN_TYPES.USDC,
-                coinTypeOut: coinType,
-            });
-            if (swapQuotes.length === 0) {
-                return { success: false, error: `No swap quotes for USDC → ${symbol}` };
-            }
-            const bestQuote = swapQuotes.sort((a, b) => Number(b.amountOut) - Number(a.amountOut))[0];
-            // Build transaction using Scallop SDK
-            // Step 1: Flash loan USDC
-            const [loanCoin, receipt] = await tx.borrowFlashLoan(Number(flashLoanUsdc), "usdc");
-            // Step 2: Swap USDC → deposit asset
-            const swappedAsset = await this.swapClient.swap({
-                quote: bestQuote,
-                signer: this.userAddress,
-                coinIn: loanCoin,
-                tx: tx.txBlock,
-            }, 100);
-            // Step 3: Prepare deposit coin
-            let depositCoin;
-            if (isSui) {
-                const [userDeposit] = tx.splitSUIFromGas([Number(depositAmountRaw)]);
-                tx.mergeCoins(userDeposit, [swappedAsset]);
-                depositCoin = userDeposit;
-            }
-            else {
-                const userCoins = await this.suiClient.getCoins({
-                    owner: this.userAddress,
-                    coinType,
-                });
-                if (userCoins.data.length === 0) {
-                    return { success: false, error: `No ${symbol} coins in wallet` };
-                }
-                const primaryCoin = tx.txBlock.object(userCoins.data[0].coinObjectId);
-                if (userCoins.data.length > 1) {
-                    const otherCoins = userCoins.data
-                        .slice(1)
-                        .map((c) => tx.txBlock.object(c.coinObjectId));
-                    tx.mergeCoins(primaryCoin, otherCoins);
-                }
-                const [userContribution] = tx.splitCoins(primaryCoin, [
-                    Number(depositAmountRaw),
-                ]);
-                tx.mergeCoins(userContribution, [swappedAsset]);
-                depositCoin = userContribution;
-            }
-            // Step 4: Handle obligation
-            let obligation;
-            let obligationKey;
-            let obligationHotPotato;
-            let isNewObligation = false;
-            if (hasExistingObligation && existingObligationId && existingObligationKeyId) {
-                obligation = tx.txBlock.object(existingObligationId);
-                obligationKey = tx.txBlock.object(existingObligationKeyId);
-                if (isCurrentlyLocked) {
-                    tx.unstakeObligation(obligation, obligationKey);
-                }
-                tx.addCollateral(obligation, depositCoin, coinName);
-            }
-            else {
-                [obligation, obligationKey, obligationHotPotato] = tx.openObligation();
-                tx.addCollateral(obligation, depositCoin, coinName);
-                isNewObligation = true;
-            }
-            // Step 5: Update oracles (critical for Scallop!)
-            await tx.updateAssetPricesQuick([coinName, "usdc"]);
-            // Step 6: Borrow USDC
-            const borrowedUsdc = tx.borrow(obligation, obligationKey, Number(borrowAmount), "usdc");
-            // Step 7: Repay flash loan
-            await tx.repayFlashLoan(borrowedUsdc, receipt, "usdc");
-            // Step 8: Finalize
-            if (isNewObligation) {
-                tx.returnObligation(obligation, obligationHotPotato);
-                tx.stakeObligation(obligation, obligationKey);
-                tx.transferObjects([obligationKey], this.userAddress);
-            }
-            else {
-                tx.stakeObligation(obligation, obligationKey);
-            }
-            // Execute
-            if (params.dryRun) {
-                tx.txBlock.setGasBudget(gas_1.DRYRUN_GAS_BUDGET);
-                const dryRunResult = await this.suiClient.dryRunTransactionBlock({
-                    transactionBlock: await tx.txBlock.build({ client: this.suiClient }),
-                });
-                if (dryRunResult.effects.status.status === "success") {
-                    const actualGas = (0, gas_1.calculateActualGas)(dryRunResult.effects.gasUsed);
-                    const optimizedBudget = (0, gas_1.calculateOptimizedBudget)(actualGas);
-                    return { success: true, gasUsed: optimizedBudget };
-                }
-                return {
-                    success: false,
-                    error: dryRunResult.effects.status.error || "Dry run failed",
-                };
-            }
-            // For real execution, do dryrun first to optimize gas
-            tx.txBlock.setGasBudget(gas_1.DRYRUN_GAS_BUDGET);
-            const dryRunResult = await this.suiClient.dryRunTransactionBlock({
-                transactionBlock: await tx.txBlock.build({ client: this.suiClient }),
-            });
-            if (dryRunResult.effects.status.status !== "success") {
-                return {
-                    success: false,
-                    error: `Dry run failed: ${dryRunResult.effects.status.error}`,
-                };
-            }
-            const actualGas = (0, gas_1.calculateActualGas)(dryRunResult.effects.gasUsed);
-            const optimizedBudget = (0, gas_1.calculateOptimizedBudget)(actualGas);
-            tx.txBlock.setGasBudget(optimizedBudget);
-            const result = await builder.signAndSendTxBlock(tx);
-            // Fetch transaction details to get actual gas used
-            const txDetails = await this.suiClient.waitForTransaction({
-                digest: result.digest,
-                options: { showEffects: true },
-            });
-            const gasUsed = txDetails.effects?.gasUsed
-                ? BigInt(txDetails.effects.gasUsed.computationCost)
-                : actualGas;
-            return {
-                success: true,
-                txDigest: result.digest,
-                gasUsed,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error.message || String(error),
-            };
-        }
-    }
-    /**
-     * Get Scallop coin name from coin type
-     */
-    getScallopCoinName(coinType) {
-        const normalized = (0, utils_1.normalizeCoinType)(coinType);
-        const COIN_NAME_MAP = {
-            "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI": "sui",
-            "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC": "usdc",
-            "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN": "wusdc",
-            "0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c::coin::COIN": "wusdt",
-        };
-        return COIN_NAME_MAP[normalized] || normalized.split("::").pop()?.toLowerCase() || "sui";
+        return (0, execution_1.executeTransaction)(this.suiClient, this.keypair, this.userAddress, tx);
     }
 }
 exports.DefiDashSDK = DefiDashSDK;