curvance 4.1.2 → 5.1.0

package/dist/classes/CToken.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CToken = void 0;
+exports.CToken = exports.LEVERAGE = void 0;
 const helpers_1 = require("../helpers");
 const ProtocolReader_1 = require("./ProtocolReader");
 const ERC20_1 = require("./ERC20");
@@ -19,6 +19,7 @@ const FormatConverter_1 = __importDefault(require("./FormatConverter"));
 const EXCLUDED_ZAP_SYMBOLS = new Set([
     'eBTC', 'earnAUSD', 'vUSD', 'syzUSD', 'ezETH', 'YZM', 'wsrUSD', 'sAUSD',
 ]);
+const EXECUTION_DEBT_BUFFER_TIME = 100n;
 /**
  * Leverage operation buffers — centralized for tuning.
  * Calibrated for fresh-state operation via getLeverageSnapshot under
@@ -69,7 +70,7 @@ const EXCLUDED_ZAP_SYMBOLS = new Set([
  * onRedeem lines 482-493), so the economic loss from the overshoot is
  * zero — only the contract's naive equity-loss check sees it as loss.
  */
-const LEVERAGE = {
+exports.LEVERAGE = {
     /** Max leverage cap: fraction of theoretical max the user can select.
      *  Prevents boundary singularity at exact max leverage — the contract's
      *  post-op `canBorrow` check re-evaluates LTV against fresh on-chain
@@ -113,10 +114,44 @@ const LEVERAGE = {
      *  for that amplification (see leverageDown). Bump when aggregator fees
      *  are enabled to keep dust prevention reliable. */
     DELEVERAGE_OVERHEAD_BPS: 20n,
-    /** BPS buffer on virtualConvertToShares for leverage + collateral cap.
+    /** BPS buffer on expected-share calculations for zap/leverage paths.
      *  Covers exchange rate drift from interest accrual since cache load. */
     SHARES_BUFFER_BPS: 2n,
+    /** Per-leverage-unit BPS buffer for `checkSlippage` on vault + native-vault
+     *  leverage-up paths. Absorbs the drift between the collateral vault's
+     *  fundamental mint rate at tx time and the stored oracle price that
+     *  `marketManager.statusOf` uses inside `checkSlippage`. The vault-token
+     *  oracle publishes discretely; the vault's exchange rate accrues
+     *  continuously — so new shares are minted at `r_current` but valued at
+     *  `r_oracle`, leaving a (L-1)-amplified equity-fraction gap that the
+     *  simple path doesn't see in practice (vault-token markets default to
+     *  the vault/native-vault PM and `leverageDown` drift goes the other
+     *  direction as a gain). Empirically calibrated against the ~3% user
+     *  slippage failure threshold on shMON/WMON native-vault leverage-up;
+     *  refine via fork testing if drift distribution turns out wider. The
+     *  constant is NOT "feed divergence" — shMON oracle IS derived from
+     *  p_MON × r_shMON off-chain; the gap is between publish-time snapshot
+     *  and tx-time state, not between two independent feeds. */
+    LEVERAGE_UP_VAULT_DRIFT_BPS: 30n,
 };
+const USER_CACHE_FIELDS = [
+    "userAssetBalance",
+    "userShareBalance",
+    "userUnderlyingBalance",
+    "userCollateral",
+    "userDebt",
+    "liquidationPrice",
+];
+function createUserCacheFreshness(value) {
+    return {
+        userAssetBalance: value,
+        userShareBalance: value,
+        userUnderlyingBalance: value,
+        userCollateral: value,
+        userDebt: value,
+        liquidationPrice: value,
+    };
+}
 class CToken extends Calldata_1.Calldata {
     provider;
     address;
@@ -132,13 +167,14 @@ class CToken extends Calldata_1.Calldata {
     nativeApy = (0, decimal_js_1.default)(0);
     incentiveSupplyApy = (0, decimal_js_1.default)(0);
     incentiveBorrowApy = (0, decimal_js_1.default)(0);
+    userCacheFreshness;
     get signer() { return this.market.signer; }
     get account() { return this.market.account; }
     constructor(provider, address, cache, market) {
         super();
         this.provider = provider;
         this.address = address;
-        this.contract = (0, helpers_1.contractSetup)(provider, address, BaseCToken_json_1.default);
+        this.contract = (0, helpers_1.contractSetup)(this.provider, address, BaseCToken_json_1.default);
         this.cache = cache;
         this.market = market;
         const chainSettings = this.currentChainConfig;
@@ -163,6 +199,31 @@ class CToken extends Calldata_1.Calldata {
             this.leverageTypes.push('simple');
         this.zapTypes.push('simple');
     }
+    getUserCacheFreshness() {
+        if (this.userCacheFreshness == undefined) {
+            this.userCacheFreshness = createUserCacheFreshness(true);
+        }
+        return this.userCacheFreshness;
+    }
+    markUserCacheFresh(fields = USER_CACHE_FIELDS) {
+        const freshness = this.getUserCacheFreshness();
+        for (const field of fields) {
+            freshness[field] = true;
+        }
+    }
+    invalidateUserCache(fields = USER_CACHE_FIELDS) {
+        const freshness = this.getUserCacheFreshness();
+        for (const field of fields) {
+            freshness[field] = false;
+        }
+    }
+    readFreshUserCache(field, accessLabel) {
+        if (!this.getUserCacheFreshness()[field]) {
+            throw new Error(`Token-level user data is stale for ${this.address} after a summary-only refresh on market ${this.market.address}. ` +
+                `Call market.reloadUserData(account) or Market.reloadUserMarkets(...) before ${accessLabel}.`);
+        }
+        return this.cache[field];
+    }
     get setup() { return this.market.setup; }
     get currentChain() { return this.setup.chain; }
     get currentChainConfig() { return (0, helpers_1.getChainConfig)(this.currentChain); }
@@ -173,6 +234,49 @@ class CToken extends Calldata_1.Calldata {
     getWriteContract() {
         return (0, helpers_1.contractSetup)(this.requireSigner(), this.address, BaseCToken_json_1.default);
     }
+    getZapType(zap) {
+        return typeof zap === "object" ? zap.type : zap;
+    }
+    isZapInstruction(zap) {
+        return this.getZapType(zap) !== "none";
+    }
+    async getZapInputDecimals(zap) {
+        const zapType = this.getZapType(zap);
+        switch (zapType) {
+            case "none":
+                return this.asset.decimals;
+            case "native-vault":
+            case "native-simple":
+                return 18n;
+            case "vault": {
+                const vaultAsset = await this.getVaultAsset(true);
+                return vaultAsset.decimals ?? await vaultAsset.contract.decimals();
+            }
+            case "simple":
+                if (typeof zap !== "object") {
+                    return this.asset.decimals;
+                }
+                if (zap.inputToken.toLowerCase() === helpers_1.NATIVE_ADDRESS.toLowerCase()) {
+                    return 18n;
+                }
+                const inputErc20 = new ERC20_1.ERC20(this.provider, zap.inputToken, undefined, undefined, this.signer);
+                return inputErc20.decimals ?? await inputErc20.contract.decimals();
+        }
+    }
+    async getZapAssetAmount(amount, zap) {
+        return FormatConverter_1.default.decimalToBigInt(amount, await this.getZapInputDecimals(zap));
+    }
+    async assertVaultLeverageBorrowAssetSupported(borrow, type) {
+        const expectedAsset = type === "native-vault"
+            ? this.currentChainConfig.wrapped_native
+            : await this.getVaultAsset(false);
+        const actualAsset = borrow.asset.address;
+        if (actualAsset.toLowerCase() === expectedAsset.toLowerCase()) {
+            return;
+        }
+        throw new Error(`${type} leverage requires borrow asset ${expectedAsset}, received ${actualAsset}. ` +
+            `Use simple leverage for cross-asset borrow routes.`);
+    }
     get adapters() { return this.cache.adapters; }
     get borrowPaused() { return this.cache.borrowPaused; }
     get collateralizationPaused() { return this.cache.collateralizationPaused; }
@@ -191,23 +295,36 @@ class CToken extends Calldata_1.Calldata {
         // for the loss channels this buffer absorbs and the tuning history.
         const theoretical = (0, decimal_js_1.default)(this.cache.maxLeverage).div(helpers_1.BPS);
         const factor = theoretical.sub(1);
-        return (0, decimal_js_1.default)(1).add(factor.mul(LEVERAGE.MAX_LEVERAGE_FACTOR));
+        return (0, decimal_js_1.default)(1).add(factor.mul(exports.LEVERAGE.MAX_LEVERAGE_FACTOR));
     }
     get canLeverage() { return this.leverageTypes.length > 0; }
     get totalAssets() { return this.cache.totalAssets; }
     get totalSupply() { return this.cache.totalSupply; }
     get liquidationPrice() {
-        if (this.cache.liquidationPrice == helpers_1.UINT256_MAX)
+        const liquidationPrice = this.readFreshUserCache("liquidationPrice", "reading token liquidationPrice");
+        if (liquidationPrice == helpers_1.UINT256_MAX)
             return null;
-        return (0, helpers_1.toDecimal)(this.cache.liquidationPrice, 18n);
+        return (0, helpers_1.toDecimal)(liquidationPrice, 18n);
     }
     get irmTargetRate() { return (0, decimal_js_1.default)(this.cache.irmTargetRate).div(helpers_1.WAD); }
     get irmMaxRate() { return (0, decimal_js_1.default)(this.cache.irmMaxRate).div(helpers_1.WAD); }
     get irmTargetUtilization() { return (0, decimal_js_1.default)(this.cache.irmTargetUtilization).div(helpers_1.WAD); }
     get interestFee() { return (0, decimal_js_1.default)(this.cache.interestFee).div(helpers_1.BPS); }
     virtualConvertToAssets(shares) {
+        if (this.totalSupply === 0n || this.totalAssets === 0n) {
+            return shares;
+        }
         return (shares * this.totalAssets) / this.totalSupply;
     }
+    formatAssets(assets) {
+        return FormatConverter_1.default.bigIntToDecimal(assets, this.asset.decimals);
+    }
+    formatShares(shares) {
+        return FormatConverter_1.default.bigIntToDecimal(shares, this.decimals);
+    }
+    formatSharesAsAssets(shares) {
+        return this.formatAssets(this.virtualConvertToAssets(shares));
+    }
     /**
      * Convert assets to shares using cached totalSupply/totalAssets.
      * @param bufferBps Optional downward buffer in BPS to account for
@@ -215,19 +332,35 @@ class CToken extends Calldata_1.Calldata {
      *                  Matches the buffer pattern in async convertToShares().
      */
     virtualConvertToShares(assets, bufferBps = 0n) {
-        const shares = (assets * this.totalSupply) / this.totalAssets;
+        const shares = this.totalSupply === 0n || this.totalAssets === 0n
+            ? assets
+            : (assets * this.totalSupply) / this.totalAssets;
         return bufferBps > 0n ? shares * (10000n - bufferBps) / 10000n : shares;
     }
-    getLeverage() {
-        if (this.getUserCollateral(true).equals(0)) {
-            return null;
+    getMarketLeverageState() {
+        const currentCollateralInUsd = this.market.userCollateral;
+        const currentDebt = this.market.userDebt;
+        const equity = currentCollateralInUsd.sub(currentDebt);
+        if (currentCollateralInUsd.lte(0) || equity.lte(0)) {
+            return {
+                currentCollateralInUsd,
+                currentDebt,
+                currentLeverage: null,
+            };
         }
-        const leverage = this.getUserCollateral(true).div(this.getUserCollateral(true).sub(this.market.userDebt));
-        return leverage.eq(1) ? null : leverage;
+        const currentLeverage = currentCollateralInUsd.div(equity);
+        return {
+            currentCollateralInUsd,
+            currentDebt,
+            currentLeverage: currentLeverage.eq(1) ? null : currentLeverage,
+        };
+    }
+    getLeverage() {
+        return this.getMarketLeverageState().currentLeverage;
     }
     getRemainingCollateral(formatted = true) {
         const diff = this.cache.collateralCap - this.cache.collateral;
-        return formatted ? this.convertTokensToUsd(diff) : diff;
+        return formatted ? this.convertSharesToUsdSync(diff) : diff;
     }
     getRemainingDebt(formatted = true) {
         const diff = this.cache.debtCap - this.cache.debt;
@@ -267,36 +400,52 @@ class CToken extends Calldata_1.Calldata {
         return inBPS ? (0, decimal_js_1.default)(this.cache.closeFactorMax).div(helpers_1.BPS) : this.cache.closeFactorMax;
     }
     getUserShareBalance(inUSD) {
-        return inUSD ? this.convertTokensToUsd(this.cache.userShareBalance, false) : FormatConverter_1.default.bigIntToDecimal(this.cache.userShareBalance, this.decimals);
+        const userShareBalance = this.readFreshUserCache("userShareBalance", "reading token user share balance");
+        return inUSD ? this.convertTokensToUsd(userShareBalance, false) : this.formatShares(userShareBalance);
+    }
+    getUserShareBalanceAssets() {
+        const userShareBalance = this.readFreshUserCache("userShareBalance", "reading token user share balance as assets");
+        return this.formatSharesAsAssets(userShareBalance);
     }
     getUserAssetBalance(inUSD) {
-        return inUSD ? this.convertTokensToUsd(this.cache.userAssetBalance) : FormatConverter_1.default.bigIntToDecimal(this.cache.userAssetBalance, this.asset.decimals);
+        const userAssetBalance = this.readFreshUserCache("userAssetBalance", "reading token user asset balance");
+        return inUSD ? this.convertTokensToUsd(userAssetBalance) : this.formatAssets(userAssetBalance);
     }
     getUserUnderlyingBalance(inUSD) {
-        return inUSD ? this.convertTokensToUsd(this.cache.userUnderlyingBalance) : FormatConverter_1.default.bigIntToDecimal(this.cache.userUnderlyingBalance, this.decimals);
+        const userUnderlyingBalance = this.readFreshUserCache("userUnderlyingBalance", "reading token user underlying balance");
+        return inUSD ? this.convertTokensToUsd(userUnderlyingBalance) : this.formatAssets(userUnderlyingBalance);
     }
     getCollateralCap(inUSD) {
-        return inUSD ? this.convertTokensToUsd(this.cache.collateralCap) : this.cache.collateralCap;
+        return inUSD ? this.convertSharesToUsdSync(this.cache.collateralCap) : this.cache.collateralCap;
     }
     getDebtCap(inUSD) {
         return inUSD ? this.convertTokensToUsd(this.cache.debtCap) : this.cache.debtCap;
     }
     getCollateral(inUSD) {
-        return inUSD ? this.convertTokensToUsd(this.cache.collateral) : this.cache.collateral;
+        return inUSD ? this.convertSharesToUsdSync(this.cache.collateral) : this.cache.collateral;
     }
     getDebt(inUSD) {
         return inUSD ? this.convertTokensToUsd(this.cache.debt) : this.cache.debt;
     }
     getUserCollateral(inUSD) {
-        return inUSD ? this.convertTokensToUsd(this.cache.userCollateral, false) : FormatConverter_1.default.bigIntToDecimal(this.cache.userCollateral, this.decimals);
+        const userCollateral = this.getUserCollateralShares();
+        return inUSD ? this.convertTokensToUsd(userCollateral, false) : this.formatShares(userCollateral);
+    }
+    getUserCollateralShares() {
+        return this.readFreshUserCache("userCollateral", "reading token user collateral shares");
+    }
+    getUserCollateralAssets() {
+        return this.formatSharesAsAssets(this.getUserCollateralShares());
     }
     async fetchUserCollateral(formatted = false) {
         const collateral = await this.contract.collateralPosted(this.getAccountOrThrow());
         this.cache.userCollateral = collateral;
+        this.markUserCacheFresh(["userCollateral"]);
         return formatted ? (0, helpers_1.toDecimal)(collateral, this.decimals) : collateral;
     }
     getUserDebt(inUSD) {
-        return inUSD ? this.convertTokensToUsd(this.cache.userDebt) : FormatConverter_1.default.bigIntToDecimal(this.cache.userDebt, this.asset.decimals);
+        const userDebt = this.readFreshUserCache("userDebt", "reading token user debt");
+        return inUSD ? this.convertTokensToUsd(userDebt) : FormatConverter_1.default.bigIntToDecimal(userDebt, this.asset.decimals);
     }
     earnChange(amount, rateType) {
         const rate = this.getApy(false);
@@ -320,6 +469,16 @@ class CToken extends Calldata_1.Calldata {
     async getVaultAsset(asErc20) {
         return asErc20 ? await this.getUnderlyingVault().fetchAsset(true) : await this.getUnderlyingVault().fetchAsset(false);
     }
+    async getExpectedVaultShares(assets) {
+        const vault = this.getUnderlyingVault();
+        const vaultSharesRaw = await vault.previewDeposit(assets);
+        // Vault/native-vault flows mint vault shares first, then convert those
+        // into Curvance shares. Buffer the inner preview so exchange-rate drift
+        // between quote time and inclusion cannot trip the outer expectedShares
+        // check on otherwise-valid deposits/leverage/zaps.
+        const vaultShares = vaultSharesRaw * (10000n - exports.LEVERAGE.SHARES_BUFFER_BPS) / 10000n;
+        return this.convertToShares(vaultShares);
+    }
     getAsset(asErc20) {
         return asErc20
             ? new ERC20_1.ERC20(this.provider, this.cache.asset.address, this.cache.asset, this.setup.contracts.OracleManager, this.signer)
@@ -349,22 +508,22 @@ class CToken extends Calldata_1.Calldata {
         // TODO: add underlying yield rate
         return asPercentage ? (0, decimal_js_1.default)(this.cache.supplyRate).div(helpers_1.WAD).mul(helpers_1.SECONDS_PER_YEAR) : this.cache.supplyRate;
     }
-    getTvl(inUSD = true) {
-        const tvl = this.cache.totalSupply;
-        return inUSD ? this.convertTokensToUsd(tvl) : tvl;
+    getDeposits(inUSD = true) {
+        const deposits = this.cache.totalAssets;
+        return inUSD ? this.convertTokensToUsd(deposits) : deposits;
     }
-    async fetchTvl(inUSD = true) {
-        const tvl = await this.fetchTotalSupply();
-        this.cache.totalSupply = tvl;
-        return inUSD ? this.getTvl(true) : this.getTvl(false);
+    async fetchDeposits(inUSD = true) {
+        const deposits = await this.fetchTotalAssets();
+        this.cache.totalAssets = deposits;
+        return inUSD ? this.getDeposits(true) : this.getDeposits(false);
     }
     getTotalCollateral(inUSD = true) {
         const totalCollateral = this.cache.collateral;
-        return inUSD ? this.convertTokensToUsd(totalCollateral) : totalCollateral;
+        return inUSD ? this.convertSharesToUsdSync(totalCollateral) : totalCollateral;
     }
     async fetchTotalCollateral(inUSD = true) {
         const totalCollateral = await this.contract.marketCollateralPosted();
-        return inUSD ? this.fetchConvertTokensToUsd(totalCollateral) : totalCollateral;
+        return inUSD ? this.fetchConvertSharesToUsd(totalCollateral) : totalCollateral;
     }
     getPositionManager(type) {
         const signer = this.requireSigner();
@@ -383,29 +542,24 @@ class CToken extends Calldata_1.Calldata {
         return new Zapper_1.Zapper(zap_contract, signer, type, this.setup);
     }
     async isZapAssetApproved(instructions, amount) {
-        if (instructions == 'none' || typeof instructions != 'object') {
+        if (instructions == 'none') {
             return true;
         }
-        if (instructions.inputToken.toLowerCase() === helpers_1.NATIVE_ADDRESS.toLowerCase()) {
+        const approvalTarget = await this.resolveZapApprovalTarget(instructions);
+        if (approvalTarget == null) {
             return true;
         }
-        const signer = this.requireSigner();
-        const asset = new ERC20_1.ERC20(this.provider, instructions.inputToken, undefined, undefined, signer);
-        const plugin = this.getPluginAddress(instructions.type, 'zapper');
-        const allowance = await asset.allowance(signer.address, plugin);
-        return allowance >= amount;
+        return this.hasTokenApproval(approvalTarget, amount);
     }
     async approveZapAsset(instructions, amount) {
-        if (instructions == 'none' || typeof instructions != 'object') {
+        if (instructions == 'none') {
             throw new Error("Plugin does not have an associated contract");
         }
-        if (instructions.inputToken.toLowerCase() === helpers_1.NATIVE_ADDRESS.toLowerCase()) {
+        const approvalTarget = await this.resolveZapApprovalTarget(instructions);
+        if (approvalTarget == null) {
             return;
         }
-        const signer = this.requireSigner();
-        const asset = new ERC20_1.ERC20(this.provider, instructions.inputToken, undefined, undefined, signer);
-        const plugin = this.getPluginAddress(instructions.type, 'zapper');
-        return asset.approve(plugin, amount);
+        return approvalTarget.token.approve(approvalTarget.spender, amount);
     }
     async isPluginApproved(plugin, type) {
         if (plugin == 'none') {
@@ -545,8 +699,22 @@ class CToken extends Calldata_1.Calldata {
         receiver ??= signer.address;
         owner ??= signer.address;
         const shares = this.convertTokenInputToShares(amount);
-        const calldata = this.getCallData("redeemCollateral", [shares, receiver, owner]);
-        return this.oracleRoute(calldata);
+        const signerAddress = signer.address;
+        let method = "redeemCollateral";
+        if (owner.toLowerCase() !== signerAddress.toLowerCase()) {
+            const isDelegated = await this.contract.isDelegate(owner, signerAddress);
+            if (isDelegated) {
+                method = "redeemCollateralFor";
+            }
+            else {
+                const allowance = await this.contract.allowance(owner, signerAddress);
+                if (allowance < shares) {
+                    throw new Error(`Please approve ${this.symbol} shares for ${signerAddress} or delegate ${signerAddress} before redeeming collateral for ${owner}.`);
+                }
+            }
+        }
+        const calldata = this.getCallData(method, [shares, receiver, owner]);
+        return this.oracleRoute(calldata, {}, owner);
     }
     async postCollateral(amount) {
         const signer = this.requireSigner();
@@ -555,6 +723,9 @@ class CToken extends Calldata_1.Calldata {
         const collateral = await this.fetchUserCollateral();
         const available_shares = balance - collateral;
         const max_shares = available_shares < shares ? available_shares : shares;
+        if (max_shares <= 0n) {
+            throw new Error("No cToken shares available to post as collateral.");
+        }
         const calldata = this.getCallData("postCollateral", [max_shares]);
         const tx = await this.oracleRoute(calldata);
         // Reload collateral state after execution
@@ -591,56 +762,56 @@ class CToken extends Calldata_1.Calldata {
         }
         return asset.balanceOf(signer.address, false);
     }
-    // TODO: Hack to remove
     async ensureUnderlyingAmount(amount, zap) {
         const balance = await this.getZapBalance(zap);
-        const isZapping = typeof zap === 'object' && zap.type !== 'none';
-        // Use the zap input token's decimals when zapping, otherwise the deposit token's decimals
-        let decimals = this.asset.decimals;
-        if (isZapping && zap.inputToken) {
-            if (zap.inputToken.toLowerCase() === helpers_1.NATIVE_ADDRESS.toLowerCase()) {
-                decimals = 18n;
-            }
-            else {
-                const inputErc20 = new ERC20_1.ERC20(this.provider, zap.inputToken, undefined, undefined, this.signer);
-                decimals = inputErc20.decimals ?? await inputErc20.contract.decimals();
-            }
-        }
+        const decimals = await this.getZapInputDecimals(zap);
         const assets = FormatConverter_1.default.decimalToBigInt(amount, decimals);
         if (assets > balance) {
-            console.warn('[WARNING] Detected higher deposit amount then underlying balance, changing to the underlying balance. Diff: ', {
-                balance: balance,
-                formatted: FormatConverter_1.default.bigIntToDecimal(balance, decimals),
-                attempt: {
-                    raw: assets,
-                    formatted: amount
-                },
-            });
-            return FormatConverter_1.default.bigIntToDecimal(balance, decimals);
+            const formattedBalance = FormatConverter_1.default.bigIntToDecimal(balance, decimals);
+            throw new Error(`Insufficient balance: requested ${amount.toString()}, available ${formattedBalance.toString()}.`);
         }
         return amount;
     }
-    async removeCollateral(amount, removeAll = false) {
-        const current_shares = await this.fetchUserCollateral();
-        let max_shares;
-        if (removeAll) {
-            max_shares = current_shares;
+    getExecutionDebtBufferTime() {
+        return this.market.userDebt.greaterThan(0) ? EXECUTION_DEBT_BUFFER_TIME : 0n;
+    }
+    async resolveCollateralRemovalShares(amount) {
+        const max_removable_shares = await this.maxRemovableCollateral(true, this.getExecutionDebtBufferTime());
+        const requested_shares = this.convertTokenInputToShares(amount);
+        let shares = max_removable_shares < requested_shares ? max_removable_shares : requested_shares;
+        // If within 0.1% of the safe removable collateral, remove it all to avoid dust.
+        const threshold = max_removable_shares / 1000n || 10n;
+        if (max_removable_shares - shares <= threshold) {
+            shares = max_removable_shares;
         }
-        else {
-            const shares = this.convertTokenInputToShares(amount);
-            max_shares = current_shares < shares ? current_shares : shares;
-            // If within 0.1% of full collateral, remove everything to avoid dust
-            const threshold = current_shares / 1000n || 10n;
-            if (current_shares - max_shares <= threshold) {
-                max_shares = current_shares;
-            }
+        return shares;
+    }
+    async executeCollateralRemoval(shares) {
+        if (shares === 0n) {
+            throw new Error("No removable collateral available.");
         }
-        const calldata = this.getCallData("removeCollateral", [max_shares]);
+        const calldata = this.getCallData("removeCollateral", [shares]);
         const tx = await this.oracleRoute(calldata);
         // Reload collateral state after execution
         await this.fetchUserCollateral();
         return tx;
     }
+    async maxRemovableCollateral(in_shares = false, bufferTime = 0n) {
+        if (in_shares) {
+            const breakdown = await this.maxRedemption(true, bufferTime, true);
+            return breakdown.max_collateral;
+        }
+        const breakdown = await this.maxRedemption(false, bufferTime, true);
+        return breakdown.max_collateral;
+    }
+    async removeCollateralExact(amount) {
+        const shares = await this.resolveCollateralRemovalShares(amount);
+        return this.executeCollateralRemoval(shares);
+    }
+    async removeMaxCollateral() {
+        const shares = await this.maxRemovableCollateral(true, this.getExecutionDebtBufferTime());
+        return this.executeCollateralRemoval(shares);
+    }
     convertTokenInputToShares(amount) {
         return this.virtualConvertToShares(FormatConverter_1.default.decimalToBigInt(amount, this.asset.decimals));
     }
@@ -661,7 +832,7 @@ class CToken extends Calldata_1.Calldata {
     async convertToAssets(shares) {
         return this.contract.convertToAssets(shares);
     }
-    async convertToShares(assets, bufferBps = 2n) {
+    async convertToShares(assets, bufferBps = exports.LEVERAGE.SHARES_BUFFER_BPS) {
         const shares = await this.contract.convertToShares(assets);
         return bufferBps > 0n ? shares * (10000n - bufferBps) / 10000n : shares;
     }
@@ -695,7 +866,7 @@ class CToken extends Calldata_1.Calldata {
                 interface: new NativeToken_1.NativeToken(this.currentChain, this.provider, this.setup.contracts.OracleManager, this.signer, this.account),
                 type: 'native-vault'
             });
-            tokens_exclude.push(helpers_1.EMPTY_ADDRESS, helpers_1.NATIVE_ADDRESS);
+            tokens_exclude.push(helpers_1.EMPTY_ADDRESS.toLowerCase(), helpers_1.NATIVE_ADDRESS.toLowerCase());
         }
         if (this.zapTypes.includes('native-simple')) {
             tokens.push({
@@ -703,7 +874,7 @@ class CToken extends Calldata_1.Calldata {
                 type: 'native-simple'
             });
             if (!this.zapTypes.includes('native-vault')) {
-                tokens_exclude.push(helpers_1.EMPTY_ADDRESS, helpers_1.NATIVE_ADDRESS);
+                tokens_exclude.push(helpers_1.EMPTY_ADDRESS.toLowerCase(), helpers_1.NATIVE_ADDRESS.toLowerCase());
             }
         }
         if (this.zapTypes.includes('vault')) {
@@ -714,7 +885,7 @@ class CToken extends Calldata_1.Calldata {
             });
             tokens_exclude.push(vault_asset.address.toLocaleLowerCase());
         }
-        if (this.zapTypes.includes('simple')) {
+        if (this.zapTypes.includes('simple') && this.currentChainConfig.dexAgg.router !== helpers_1.EMPTY_ADDRESS) {
             let dexAggSearch = await this.currentChainConfig.dexAgg.getAvailableTokens(this.provider, search, this.account);
             tokens = tokens.concat(dexAggSearch.filter(token => !tokens_exclude.includes(token.interface.address.toLocaleLowerCase())));
             // Add native MON as a zap option for any token with a simple zapper
@@ -758,6 +929,7 @@ class CToken extends Calldata_1.Calldata {
         this.cache.assetPrice = snapshot.collateralAssetPrice;
         this.cache.sharePrice = snapshot.sharePrice;
         borrow.cache.assetPrice = snapshot.debtAssetPrice;
+        this.market.cache.user.collateral = snapshot.collateralUsd;
         this.market.cache.user.debt = snapshot.debtUsd;
         return snapshot;
     }
@@ -771,47 +943,133 @@ class CToken extends Calldata_1.Calldata {
      * equity-fraction denominator amplifies it by (L-1)x automatically.
      * The user's swap-level slippage (passed separately to _swapSafe) is
      * unaffected — that's the layer that bounds MEV extraction.
+     *
+     * Applied uniformly to simple AND vault/native-vault leverage-up paths.
+     * Simple path uses the buffer for share-rounding + Redstone drift as
+     * described above. Vault paths inherit the flat 10 bps through the
+     * shared `slippage` variable before the per-branch
+     * `amplifyContractSlippage(..., LEVERAGE_UP_VAULT_DRIFT_BPS)` expansion;
+     * the flat addition is not amplified (base term stays flat) and covers
+     * the same residual class (share-rounding, oracle drift) on vault paths
+     * too. Removing the buffer for vault would save a trivial amount of
+     * user slippage budget at the cost of a false-negative risk on the
+     * residuals — we keep it for symmetry.
      */
     _leverageUpSlippage(slippage, leverage) {
         if (leverage.lte(1))
             return slippage;
-        return slippage + LEVERAGE.LEVERAGE_UP_BUFFER_BPS;
+        return slippage + exports.LEVERAGE.LEVERAGE_UP_BUFFER_BPS;
+    }
+    assertSimpleLeverageSwapAssetsDiffer(borrow) {
+        if (borrow.asset.address.toLowerCase() === this.asset.address.toLowerCase()) {
+            throw new Error("Simple leverage requires distinct collateral and borrow assets.");
+        }
+    }
+    async assertLeverageBorrowCapacity(borrow, borrowAssets) {
+        if (borrowAssets === 0n) {
+            return;
+        }
+        const [assetsHeld, outstandingDebt] = await Promise.all([
+            borrow.fetchLiquidity(),
+            borrow.marketOutstandingDebt(),
+        ]);
+        const remainingDebtCap = borrow.cache.debtCap > outstandingDebt
+            ? borrow.cache.debtCap - outstandingDebt
+            : 0n;
+        const capacity = assetsHeld < remainingDebtCap ? assetsHeld : remainingDebtCap;
+        if (borrowAssets > capacity) {
+            throw new Error("Selected borrow token does not have enough remaining debt capacity or liquidity for this leverage operation.");
+        }
     }
-    previewLeverageUp(newLeverage, borrow, depositAmount) {
-        const currentLeverage = this.getLeverage() ?? (0, decimal_js_1.default)(0);
-        if (newLeverage.lte(currentLeverage)) {
+    assertSelectedBorrowDebtCanDeleverage(borrow, selectedDebtAssets, requiredDebtReductionUsd) {
+        if (requiredDebtReductionUsd.lte(0)) {
+            return;
+        }
+        const price = borrow.getPrice(true);
+        if (!price.isFinite() || price.lte(0)) {
+            throw new Error("Selected borrow token has an invalid price for deleverage sizing.");
+        }
+        const requiredDebtAssets = FormatConverter_1.default.decimalToBigInt(requiredDebtReductionUsd.div(price), borrow.asset.decimals);
+        if (requiredDebtAssets > selectedDebtAssets) {
+            throw new Error("Selected borrow token debt is too small for the requested deleverage target.");
+        }
+    }
+    computePostDepositNaturalLeverage(currentCollateralInUsd, currentDebtInUsd, depositInUsd) {
+        if (currentDebtInUsd.lte(0))
+            return (0, decimal_js_1.default)(1);
+        const collateralAfterDeposit = currentCollateralInUsd.add(depositInUsd);
+        const equityAfterDeposit = collateralAfterDeposit.sub(currentDebtInUsd);
+        if (equityAfterDeposit.lte(0))
+            return (0, decimal_js_1.default)(1);
+        return collateralAfterDeposit.div(equityAfterDeposit);
+    }
+    resolveLeverageUpPreview({ operation, targetLeverage, borrow, depositAssets = 0n, positionManagerType, }) {
+        const leverageState = this.getMarketLeverageState();
+        const currentLeverage = leverageState.currentLeverage ?? (0, decimal_js_1.default)(1);
+        const currentCollateralInUsd = leverageState.currentCollateralInUsd;
+        const depositInAssets = FormatConverter_1.default.bigIntToDecimal(depositAssets, this.asset.decimals);
+        const depositInUsd = depositAssets > 0n
+            ? this.convertTokensToUsd(depositAssets, true)
+            : (0, decimal_js_1.default)(0);
+        const currentDebt = leverageState.currentDebt;
+        const effectiveCurrentLeverage = depositAssets > 0n
+            ? this.computePostDepositNaturalLeverage(currentCollateralInUsd, currentDebt, depositInUsd)
+            : currentLeverage;
+        const cappedTargetLeverage = targetLeverage.gt(this.maxLeverage)
+            ? this.maxLeverage
+            : targetLeverage;
+        const resolvedTargetLeverage = operation === 'deposit-and-leverage'
+            ? decimal_js_1.default.max(cappedTargetLeverage, effectiveCurrentLeverage)
+            : cappedTargetLeverage;
+        if (operation === 'leverage-up' && resolvedTargetLeverage.lte(effectiveCurrentLeverage)) {
             throw new Error("New leverage must be more than current leverage");
         }
-        if (newLeverage.gt(this.maxLeverage)) {
-            newLeverage = this.maxLeverage;
+        const collateralAfterDepositInUsd = currentCollateralInUsd.add(depositInUsd);
+        const notional = collateralAfterDepositInUsd.sub(currentDebt);
+        if (notional.lte(0)) {
+            throw new Error("Position has no positive equity to leverage.");
         }
-        const collateralAvail = this.cache.userCollateral + (depositAmount ? depositAmount : BigInt(0));
-        const collateralInUsd = this.convertTokensToUsd(collateralAvail, false);
-        const currentDebt = this.market.userDebt;
-        const notional = collateralInUsd.sub(currentDebt);
-        const leverageFactor = newLeverage.sub(1);
         const borrowPrice = borrow.getPrice(true);
-        const rawDebtInUsd = notional.mul(newLeverage).sub(notional);
-        const borrowAmount = rawDebtInUsd.sub(currentDebt).div(borrowPrice);
-        // Fee preview: queried from the configured fee policy.
-        const borrowAssets = FormatConverter_1.default.decimalToBigInt(borrowAmount, borrow.asset.decimals);
-        const feeBps = this.setup.feePolicy.getFeeBps({
-            operation: 'leverage-up',
-            inputToken: borrow.asset.address,
-            outputToken: this.asset.address,
-            inputAmount: borrowAssets,
-            currentLeverage,
-            targetLeverage: newLeverage,
-        });
+        const rawDebtInUsd = notional.mul(resolvedTargetLeverage).sub(notional);
+        const debtIncrease = decimal_js_1.default.max(rawDebtInUsd.sub(currentDebt), (0, decimal_js_1.default)(0));
+        const borrowAmount = borrowPrice.gt(0)
+            ? debtIncrease.div(borrowPrice)
+            : (0, decimal_js_1.default)(0);
+        const borrowAssets = debtIncrease.gt(0)
+            ? FormatConverter_1.default.decimalToBigInt(borrowAmount, borrow.asset.decimals)
+            : 0n;
+        const feePolicyCurrentLeverage = operation === 'deposit-and-leverage'
+            ? effectiveCurrentLeverage
+            : currentLeverage;
+        const hasSwapFee = positionManagerType !== 'vault' && positionManagerType !== 'native-vault';
+        const feeBps = borrowAssets > 0n && hasSwapFee
+            ? this.setup.feePolicy.getFeeBps({
+                operation,
+                inputToken: borrow.asset.address,
+                outputToken: this.asset.address,
+                inputAmount: borrowAssets,
+                currentLeverage: feePolicyCurrentLeverage,
+                targetLeverage: resolvedTargetLeverage,
+            })
+            : 0n;
         const feeAssets = borrowAmount.mul((0, decimal_js_1.default)(Number(feeBps))).div((0, decimal_js_1.default)(10000));
         const feeUsd = feeAssets.mul(borrowPrice);
-        // Subtract fee from displayed collateral — the fee reduces swap
-        // output, so the user receives less collateral than rawDebtInUsd.
-        const newCollateralInUsd = notional.add(rawDebtInUsd).sub(feeUsd);
+        const collateralIncreaseFromBorrow = decimal_js_1.default.max(debtIncrease.sub(feeUsd), (0, decimal_js_1.default)(0));
+        const collateralIncrease = depositInUsd.add(collateralIncreaseFromBorrow);
+        const collateralIncreaseInAssets = depositInAssets.add(this.convertUsdToTokens(collateralIncreaseFromBorrow, true));
+        const newCollateralInUsd = currentCollateralInUsd.add(collateralIncrease);
         return {
+            currentLeverage,
+            effectiveCurrentLeverage,
+            targetLeverage: resolvedTargetLeverage,
             borrowAmount,
+            borrowAssets,
+            debtIncrease,
+            debtIncreaseInAssets: borrowAmount,
             newDebt: rawDebtInUsd,
             newDebtInAssets: borrow.convertUsdToTokens(rawDebtInUsd, true),
+            collateralIncrease,
+            collateralIncreaseInAssets,
             newCollateral: newCollateralInUsd,
             newCollateralInAssets: this.convertUsdToTokens(newCollateralInUsd, true),
             feeBps,
@@ -819,6 +1077,26 @@ class CToken extends Calldata_1.Calldata {
             feeUsd,
         };
     }
+    previewDepositAndLeverage(newLeverage, borrow, depositAmount, positionManagerType) {
+        return this.resolveLeverageUpPreview({
+            operation: 'deposit-and-leverage',
+            targetLeverage: newLeverage,
+            borrow,
+            depositAssets: depositAmount,
+            positionManagerType,
+        });
+    }
+    previewLeverageUp(newLeverage, borrow, depositAmount, positionManagerType) {
+        if ((depositAmount ?? 0n) > 0n) {
+            return this.previewDepositAndLeverage(newLeverage, borrow, depositAmount, positionManagerType);
+        }
+        return this.resolveLeverageUpPreview({
+            operation: 'leverage-up',
+            targetLeverage: newLeverage,
+            borrow,
+            positionManagerType,
+        });
+    }
     previewLeverageDown(newLeverage, currentLeverage, borrow) {
         if (newLeverage.gte(currentLeverage)) {
             throw new Error("New leverage must be less than current leverage");
@@ -826,10 +1104,13 @@ class CToken extends Calldata_1.Calldata {
         if (newLeverage.lt((0, decimal_js_1.default)(1))) {
             throw new Error("New leverage must be at least 1");
         }
-        const collateralAvail = this.cache.userCollateral;
-        const collateralInUsd = this.convertTokensToUsd(collateralAvail, false);
-        const currentDebt = this.market.userDebt;
+        const leverageState = this.getMarketLeverageState();
+        const collateralInUsd = leverageState.currentCollateralInUsd;
+        const currentDebt = leverageState.currentDebt;
         const equity = collateralInUsd.sub(currentDebt);
+        if (equity.lte(0)) {
+            throw new Error("Position has no positive equity to deleverage.");
+        }
         const targetCollateralUsd = equity.mul(newLeverage);
         const newDebtUsd = targetCollateralUsd.sub(equity);
         const collateralAssetReductionUsd = collateralInUsd.sub(targetCollateralUsd);
@@ -870,22 +1151,30 @@ class CToken extends Calldata_1.Calldata {
     async leverageUp(borrow, newLeverage, type, slippage_ = (0, decimal_js_1.default)(0.05), simulate = false) {
         try {
             this.requireSigner();
-            const slippage = this._leverageUpSlippage(FormatConverter_1.default.percentageToBps(slippage_), newLeverage);
             const manager = this.getPositionManager(type);
+            if (type === 'vault' || type === 'native-vault') {
+                await this.assertVaultLeverageBorrowAssetSupported(borrow, type);
+            }
+            else if (type === 'simple') {
+                this.assertSimpleLeverageSwapAssetsDiffer(borrow);
+            }
             let calldata;
             await this._getLeverageSnapshot(borrow);
-            const { borrowAmount } = this.previewLeverageUp(newLeverage, borrow);
+            const preview = this.previewLeverageUp(newLeverage, borrow, undefined, type);
+            const slippage = this._leverageUpSlippage(FormatConverter_1.default.percentageToBps(slippage_), preview.targetLeverage);
+            const { borrowAmount, borrowAssets, feeBps, targetLeverage } = preview;
+            if (borrowAssets === 0n) {
+                if (simulate) {
+                    return {
+                        success: false,
+                        error: "Target leverage must exceed the current leverage enough to borrow more.",
+                    };
+                }
+                throw new Error("Target leverage must exceed the current leverage enough to borrow more.");
+            }
+            await this.assertLeverageBorrowCapacity(borrow, borrowAssets);
             switch (type) {
                 case 'simple': {
-                    const borrowAssets = FormatConverter_1.default.decimalToBigInt(borrowAmount, borrow.asset.decimals);
-                    const feeBps = this.setup.feePolicy.getFeeBps({
-                        operation: 'leverage-up',
-                        inputToken: borrow.asset.address,
-                        outputToken: this.asset.address,
-                        inputAmount: borrowAssets,
-                        currentLeverage: this.getLeverage() ?? (0, decimal_js_1.default)(1),
-                        targetLeverage: newLeverage,
-                    });
                     const feeReceiver = feeBps > 0n ? this.setup.feePolicy.feeReceiver : undefined;
                     const { action, quote } = await this.currentChainConfig.dexAgg.quoteAction(manager.address, borrow.asset.address, this.asset.address, borrowAssets, slippage, feeBps, feeReceiver);
                     // Fee-aware slippage expansion now lives inside KyberSwap.quoteAction
@@ -896,12 +1185,12 @@ class CToken extends Calldata_1.Calldata {
                     // as equity loss amplified by (L-1) — same pattern as
                     // deleverage. Expand the contract-level tolerance to absorb it.
                     // See `amplifyContractSlippage` in helpers.ts for rationale.
-                    const contractSlippage = (0, helpers_1.amplifyContractSlippage)(slippage, newLeverage.sub(1), feeBps);
+                    const contractSlippage = (0, helpers_1.amplifyContractSlippage)(slippage, targetLeverage.sub(1), feeBps);
                     calldata = manager.getLeverageCalldata({
                         borrowableCToken: borrow.address,
-                        borrowAssets: FormatConverter_1.default.decimalToBigInt(borrowAmount, borrow.asset.decimals),
+                        borrowAssets: borrowAssets,
                         cToken: this.address,
-                        expectedShares: this.virtualConvertToShares(BigInt(quote.min_out), LEVERAGE.SHARES_BUFFER_BPS),
+                        expectedShares: this.virtualConvertToShares(BigInt(quote.min_out), exports.LEVERAGE.SHARES_BUFFER_BPS),
                         swapAction: action,
                         auxData: "0x",
                     }, FormatConverter_1.default.bpsToBpsWad(contractSlippage));
@@ -909,14 +1198,20 @@ class CToken extends Calldata_1.Calldata {
                 }
                 case 'native-vault':
                 case 'vault': {
+                    // No DEX leg, so no fee-driven forced loss to absorb.
+                    // The `(L-1)×K` expansion here covers the vault-token
+                    // collateral drift between the vault's fundamental mint
+                    // rate at tx time and the stored oracle price that
+                    // `checkSlippage` reads. See LEVERAGE_UP_VAULT_DRIFT_BPS.
+                    const contractSlippage = (0, helpers_1.amplifyContractSlippage)(slippage, targetLeverage.sub(1), exports.LEVERAGE.LEVERAGE_UP_VAULT_DRIFT_BPS);
                     calldata = manager.getLeverageCalldata({
                         borrowableCToken: borrow.address,
-                        borrowAssets: FormatConverter_1.default.decimalToBigInt(borrowAmount, borrow.asset.decimals),
+                        borrowAssets: borrowAssets,
                         cToken: this.address,
                         expectedShares: await PositionManager_1.PositionManager.getVaultExpectedShares(this, borrow, borrowAmount),
                         swapAction: PositionManager_1.PositionManager.emptySwapAction(),
                         auxData: "0x",
-                    }, FormatConverter_1.default.bpsToBpsWad(slippage));
+                    }, FormatConverter_1.default.bpsToBpsWad(contractSlippage));
                     break;
                 }
                 default:
@@ -926,7 +1221,6 @@ class CToken extends Calldata_1.Calldata {
             }
             if (simulate)
                 return this.simulateOracleRoute(calldata, { to: manager.address });
-            await this._checkPositionManagerApproval(manager);
             return this.oracleRoute(calldata, { to: manager.address });
         }
         catch (error) {
@@ -946,10 +1240,15 @@ class CToken extends Calldata_1.Calldata {
             const config = this.currentChainConfig;
             const slippage = (0, helpers_1.toBps)(slippage_);
             const manager = this.getPositionManager(type);
+            if (type === 'simple') {
+                this.assertSimpleLeverageSwapAssetsDiffer(borrowToken);
+            }
             let calldata;
             const snapshot = await this._getLeverageSnapshot(borrowToken);
-            const { collateralAssetReduction } = this.previewLeverageDown(newLeverage, currentLeverage);
+            const preview = this.previewLeverageDown(newLeverage, currentLeverage);
+            const { collateralAssetReduction } = preview;
             const isFullDeleverage = newLeverage.equals(1);
+            const maxTokenCollateral = this.virtualConvertToAssets(this.readFreshUserCache("userCollateral", "executing leverage down"));
             switch (type) {
                 case 'simple': {
                     let swapCollateral = collateralAssetReduction;
@@ -990,20 +1289,33 @@ class CToken extends Calldata_1.Calldata {
                         // Total overhead = base overhead (DEX impact + drift) + fee bps.
                         // Additive approximation is accurate to sub-bp at typical
                         // fee+overhead magnitudes (< 100 bps combined).
-                        const overheadBps = LEVERAGE.DELEVERAGE_OVERHEAD_BPS + feeBps;
+                        const overheadBps = exports.LEVERAGE.DELEVERAGE_OVERHEAD_BPS + feeBps;
                         swapCollateral = debtInCollateral * (10000n + overheadBps) / 10000n;
-                        const maxCollateral = this.virtualConvertToAssets(this.cache.userCollateral);
-                        if (swapCollateral > maxCollateral) {
-                            swapCollateral = maxCollateral;
+                        if (swapCollateral > maxTokenCollateral) {
+                            const error = "Selected collateral token does not have enough posted collateral to fully deleverage.";
+                            if (simulate) {
+                                return { success: false, error };
+                            }
+                            throw new Error(error);
                         }
                     }
-                    else if (feeBps > 0n) {
-                        // Partial deleverage: inflate swap size to compensate
-                        // for fee deduction on input. KyberSwap deducts feeBps
-                        // from input before swapping, so without compensation
-                        // the swap underdelivers and actual leverage is slightly
-                        // higher than target.
-                        swapCollateral = swapCollateral * 10000n / (10000n - feeBps);
+                    else {
+                        this.assertSelectedBorrowDebtCanDeleverage(borrowToken, snapshot.debtTokenBalance, decimal_js_1.default.max(this.market.userDebt.sub(preview.newDebt), (0, decimal_js_1.default)(0)));
+                        if (feeBps > 0n) {
+                            // Partial deleverage: inflate swap size to compensate
+                            // for fee deduction on input. KyberSwap deducts feeBps
+                            // from input before swapping, so without compensation
+                            // the swap underdelivers and actual leverage is slightly
+                            // higher than target.
+                            swapCollateral = swapCollateral * 10000n / (10000n - feeBps);
+                        }
+                    }
+                    if (!isFullDeleverage && swapCollateral > maxTokenCollateral) {
+                        const error = "Selected collateral token does not have enough posted collateral to reach the requested leverage target.";
+                        if (simulate) {
+                            return { success: false, error };
+                        }
+                        throw new Error(error);
                     }
                     const { action, quote } = await config.dexAgg.quoteAction(manager.address, this.asset.address, borrowToken.asset.address, swapCollateral, slippage, feeBps, feeReceiver);
                     // Fee-aware slippage expansion for `_swapSafe` is handled by
@@ -1025,7 +1337,7 @@ class CToken extends Calldata_1.Calldata {
                         ? currentLeverage.sub(1)
                         : currentLeverage.sub(newLeverage);
                     const forcedBps = isFullDeleverage
-                        ? LEVERAGE.DELEVERAGE_OVERHEAD_BPS + feeBps
+                        ? exports.LEVERAGE.DELEVERAGE_OVERHEAD_BPS + feeBps
                         : feeBps;
                     const contractSlippage = (0, helpers_1.amplifyContractSlippage)(slippage, leverageDelta, forcedBps);
                     calldata = manager.getDeleverageCalldata({
@@ -1045,7 +1357,6 @@ class CToken extends Calldata_1.Calldata {
             }
             if (simulate)
                 return this.simulateOracleRoute(calldata, { to: manager.address });
-            await this._checkPositionManagerApproval(manager);
             return this.oracleRoute(calldata, { to: manager.address });
         }
         catch (error) {
@@ -1062,35 +1373,44 @@ class CToken extends Calldata_1.Calldata {
                 throw new Error("Multiplier must be greater than 1");
             }
             depositAmount = await this.ensureUnderlyingAmount(depositAmount, 'none');
-            const slippage = this._leverageUpSlippage((0, helpers_1.toBps)(slippage_), multiplier);
             const manager = this.getPositionManager(type);
+            if (type === 'vault' || type === 'native-vault') {
+                await this.assertVaultLeverageBorrowAssetSupported(borrow, type);
+            }
+            else if (type === 'simple') {
+                this.assertSimpleLeverageSwapAssetsDiffer(borrow);
+            }
             let calldata;
             const depositAssets = FormatConverter_1.default.decimalToBigInt(depositAmount, this.asset.decimals);
+            await this._checkTokenApproval(this.getPositionManagerDepositApprovalTarget(manager), depositAssets);
             await this._getLeverageSnapshot(borrow);
-            const { borrowAmount } = this.previewLeverageUp(multiplier, borrow, depositAssets);
+            const preview = this.previewDepositAndLeverage(multiplier, borrow, depositAssets, type);
+            if (preview.borrowAssets === 0n) {
+                if (simulate) {
+                    return {
+                        success: false,
+                        error: "Target leverage must exceed the post-deposit leverage to borrow more.",
+                    };
+                }
+                throw new Error("Target leverage must exceed the post-deposit leverage to borrow more.");
+            }
+            const slippage = this._leverageUpSlippage((0, helpers_1.toBps)(slippage_), preview.targetLeverage);
+            const { borrowAmount, borrowAssets, feeBps, targetLeverage } = preview;
+            await this.assertLeverageBorrowCapacity(borrow, borrowAssets);
             switch (type) {
                 case 'simple': {
-                    const borrowAssets = FormatConverter_1.default.decimalToBigInt(borrowAmount, borrow.asset.decimals);
-                    const feeBps = this.setup.feePolicy.getFeeBps({
-                        operation: 'deposit-and-leverage',
-                        inputToken: borrow.asset.address,
-                        outputToken: this.asset.address,
-                        inputAmount: borrowAssets,
-                        currentLeverage: this.getLeverage() ?? (0, decimal_js_1.default)(1),
-                        targetLeverage: multiplier,
-                    });
                     const feeReceiver = feeBps > 0n ? this.setup.feePolicy.feeReceiver : undefined;
                     const { action, quote } = await this.currentChainConfig.dexAgg.quoteAction(manager.address, borrow.asset.address, this.asset.address, borrowAssets, slippage, feeBps, feeReceiver);
                     // Fee-aware slippage expansion for `_swapSafe` is handled by
                     // KyberSwap.quoteAction. See KyberSwap.ts for rationale.
                     // Fee amplification: same pattern as leverageUp. See
                     // `amplifyContractSlippage` in helpers.ts.
-                    const contractSlippage = (0, helpers_1.amplifyContractSlippage)(slippage, multiplier.sub(1), feeBps);
+                    const contractSlippage = (0, helpers_1.amplifyContractSlippage)(slippage, targetLeverage.sub(1), feeBps);
                     calldata = manager.getDepositAndLeverageCalldata(FormatConverter_1.default.decimalToBigInt(depositAmount, this.asset.decimals), {
                         borrowableCToken: borrow.address,
                         borrowAssets: borrowAssets,
                         cToken: this.address,
-                        expectedShares: this.virtualConvertToShares(BigInt(quote.min_out), LEVERAGE.SHARES_BUFFER_BPS),
+                        expectedShares: this.virtualConvertToShares(BigInt(quote.min_out), exports.LEVERAGE.SHARES_BUFFER_BPS),
                         swapAction: action,
                         auxData: "0x",
                     }, FormatConverter_1.default.bpsToBpsWad(contractSlippage));
@@ -1098,14 +1418,20 @@ class CToken extends Calldata_1.Calldata {
                 }
                 case 'native-vault':
                 case 'vault': {
+                    // Mirrors the leverageUp vault branch: absorb (L-1) ×
+                    // LEVERAGE_UP_VAULT_DRIFT_BPS for vault-token collateral
+                    // drift. Uses `multiplier.sub(1)` per the per-call-site
+                    // asymmetry documented in helpers.ts (depositAndLeverage
+                    // leverageDelta = multiplier - 1).
+                    const contractSlippage = (0, helpers_1.amplifyContractSlippage)(slippage, targetLeverage.sub(1), exports.LEVERAGE.LEVERAGE_UP_VAULT_DRIFT_BPS);
                     calldata = manager.getDepositAndLeverageCalldata(FormatConverter_1.default.decimalToBigInt(depositAmount, this.asset.decimals), {
                         borrowableCToken: borrow.address,
-                        borrowAssets: FormatConverter_1.default.decimalToBigInt(borrowAmount, borrow.asset.decimals),
+                        borrowAssets: borrowAssets,
                         cToken: this.address,
                         expectedShares: await PositionManager_1.PositionManager.getVaultExpectedShares(this, borrow, borrowAmount),
                         swapAction: PositionManager_1.PositionManager.emptySwapAction(),
                         auxData: "0x",
-                    }, FormatConverter_1.default.bpsToBpsWad(slippage));
+                    }, FormatConverter_1.default.bpsToBpsWad(contractSlippage));
                     break;
                 }
                 default:
@@ -1115,7 +1441,6 @@ class CToken extends Calldata_1.Calldata {
             }
             if (simulate)
                 return this.simulateOracleRoute(calldata, { to: manager.address });
-            await this._checkPositionManagerApproval(manager);
             return this.oracleRoute(calldata, { to: manager.address });
         }
         catch (error) {
@@ -1129,19 +1454,10 @@ class CToken extends Calldata_1.Calldata {
             amount = await this.ensureUnderlyingAmount(amount, zap);
             const signer = this.requireSigner();
             receiver ??= signer.address;
-            const isZapping = typeof zap === 'object' && zap.type !== 'none';
             const depositAssets = FormatConverter_1.default.decimalToBigInt(amount, this.asset.decimals);
-            let zapAssets = depositAssets;
-            if (isZapping && zap.inputToken) {
-                const isNative = zap.inputToken.toLowerCase() === helpers_1.NATIVE_ADDRESS.toLowerCase();
-                const zapDecimals = isNative ? 18n : (() => {
-                    const inputErc20 = new ERC20_1.ERC20(this.provider, zap.inputToken, undefined, undefined, this.signer);
-                    return inputErc20.decimals ?? inputErc20.contract.decimals();
-                })();
-                zapAssets = FormatConverter_1.default.decimalToBigInt(amount, await zapDecimals);
-            }
+            const zapAssets = await this.getZapAssetAmount(amount, zap);
             const default_calldata = this.getCallData("deposit", [depositAssets, receiver]);
-            const { calldata, calldata_overrides } = await this.zap(zapAssets, zap, false, default_calldata);
+            const { calldata, calldata_overrides } = await this.zap(zapAssets, zap, false, default_calldata, receiver);
             return this.simulateOracleRoute(calldata, calldata_overrides);
         }
         catch (error) {
@@ -1153,33 +1469,27 @@ class CToken extends Calldata_1.Calldata {
             amount = await this.ensureUnderlyingAmount(amount, zap);
             const signer = this.requireSigner();
             receiver ??= signer.address;
-            const isZapping = typeof zap === 'object' && zap.type !== 'none';
             const depositAssets = FormatConverter_1.default.decimalToBigInt(amount, this.asset.decimals);
-            let zapAssets = depositAssets;
-            if (isZapping && zap.inputToken) {
-                const isNative = zap.inputToken.toLowerCase() === helpers_1.NATIVE_ADDRESS.toLowerCase();
-                const zapDecimals = isNative ? 18n : (() => {
-                    const inputErc20 = new ERC20_1.ERC20(this.provider, zap.inputToken, undefined, undefined, this.signer);
-                    return inputErc20.decimals ?? inputErc20.contract.decimals();
-                })();
-                zapAssets = FormatConverter_1.default.decimalToBigInt(amount, await zapDecimals);
-            }
-            const default_calldata = this.getCallData("depositAsCollateral", [depositAssets, receiver]);
-            const { calldata, calldata_overrides } = await this.zap(zapAssets, zap, true, default_calldata);
+            const zapAssets = await this.getZapAssetAmount(amount, zap);
+            const collateralMethod = receiver.toLowerCase() === signer.address.toLowerCase()
+                ? "depositAsCollateral"
+                : "depositAsCollateralFor";
+            const default_calldata = this.getCallData(collateralMethod, [depositAssets, receiver]);
+            const { calldata, calldata_overrides } = await this.zap(zapAssets, zap, true, default_calldata, receiver);
             return this.simulateOracleRoute(calldata, calldata_overrides);
         }
         catch (error) {
             return { success: false, error: error?.reason || error?.message || String(error) };
         }
     }
-    async zap(assets, zap, collateralize = false, default_calldata) {
+    async zap(assets, zap, collateralize = false, default_calldata, receiver = this.requireSigner().address) {
         let calldata;
         let calldata_overrides = {};
         let slippage = 0n;
         let inputToken = null;
         let type_of_zap;
         if (typeof zap == 'object') {
-            slippage = BigInt(zap.slippage.mul(helpers_1.BPS).toString());
+            slippage = FormatConverter_1.default.percentageToBps(zap.slippage);
             inputToken = zap.inputToken;
             type_of_zap = zap.type;
         }
@@ -1197,20 +1507,20 @@ class CToken extends Calldata_1.Calldata {
             case 'simple':
                 if (inputToken == null)
                     throw new Error("Input token must be provided for simple zap");
-                calldata = await zapper.getSimpleZapCalldata(this, inputToken, this.asset.address, assets, collateralize, slippage);
+                calldata = await zapper.getSimpleZapCalldata(this, inputToken, this.asset.address, assets, collateralize, slippage, receiver);
                 const isNativeSimpleZap = inputToken.toLowerCase() === helpers_1.NATIVE_ADDRESS.toLowerCase();
                 calldata_overrides = isNativeSimpleZap ? { value: assets, to: zapper.address } : { to: zapper.address };
                 break;
             case 'vault':
-                calldata = await zapper.getVaultZapCalldata(this, assets, collateralize);
+                calldata = await zapper.getVaultZapCalldata(this, assets, collateralize, false, receiver);
                 calldata_overrides = { to: zapper.address };
                 break;
             case 'native-vault':
-                calldata = await zapper.getNativeZapCalldata(this, assets, collateralize);
+                calldata = await zapper.getNativeZapCalldata(this, assets, collateralize, false, receiver);
                 calldata_overrides = { value: assets, to: zapper.address };
                 break;
             case 'native-simple':
-                calldata = await zapper.getNativeZapCalldata(this, assets, collateralize, true);
+                calldata = await zapper.getNativeZapCalldata(this, assets, collateralize, true, receiver);
                 calldata_overrides = { value: assets, to: zapper.address };
                 break;
             default:
@@ -1222,84 +1532,50 @@ class CToken extends Calldata_1.Calldata {
         amount = await this.ensureUnderlyingAmount(amount, zap);
         const signer = this.requireSigner();
         receiver ??= signer.address;
-        // When zapping, the swap amount uses input token decimals, but the
-        // default deposit calldata uses the deposit token decimals.
-        const isZapping = typeof zap === 'object' && zap.type !== 'none';
         const depositAssets = FormatConverter_1.default.decimalToBigInt(amount, this.asset.decimals);
-        let zapAssets = depositAssets;
-        if (isZapping && zap.inputToken) {
-            if (zap.inputToken.toLowerCase() === helpers_1.NATIVE_ADDRESS.toLowerCase()) {
-                zapAssets = FormatConverter_1.default.decimalToBigInt(amount, 18n);
-            }
-            else {
-                const inputErc20 = new ERC20_1.ERC20(this.provider, zap.inputToken, undefined, undefined, this.signer);
-                const zapDecimals = inputErc20.decimals ?? await inputErc20.contract.decimals();
-                zapAssets = FormatConverter_1.default.decimalToBigInt(amount, zapDecimals);
-            }
-        }
-        const zapType = typeof zap == 'object' ? zap.type : zap;
-        const isNative = zapType == 'native-simple' || zapType == 'native-vault' || zapType == 'none'
-            || (typeof zap == 'object' && zap.inputToken.toLowerCase() === helpers_1.NATIVE_ADDRESS.toLowerCase());
+        const zapAssets = await this.getZapAssetAmount(amount, zap);
+        await this._checkDepositApprovals(zap, depositAssets, zapAssets);
         const default_calldata = this.getCallData("deposit", [depositAssets, receiver]);
-        const { calldata, calldata_overrides } = await this.zap(zapAssets, zap, false, default_calldata);
-        if (isNative) {
-            await this._checkAssetApproval(depositAssets);
-        }
-        else {
-            const zapper = this.getZapper(zapType);
-            if (!zapper) {
-                throw new Error(`No zapper contract found for type '${zapType}' on ${this.symbol}`);
-            }
-            await this._checkDepositApprovals(zapper, zapAssets);
-        }
-        return this.oracleRoute(calldata, calldata_overrides);
+        const { calldata, calldata_overrides } = await this.zap(zapAssets, zap, false, default_calldata, receiver);
+        return this.oracleRoute(calldata, calldata_overrides, receiver);
     }
     async depositAsCollateral(amount, zap = 'none', receiver = null) {
         amount = await this.ensureUnderlyingAmount(amount, zap);
         const signer = this.requireSigner();
         receiver ??= signer.address;
-        // When zapping, the swap amount uses input token decimals, but collateral
-        // cap checks and the default deposit calldata use the deposit token decimals.
-        const isZapping = typeof zap === 'object' && zap.type !== 'none';
         const depositAssets = FormatConverter_1.default.decimalToBigInt(amount, this.asset.decimals);
-        let zapAssets = depositAssets;
-        if (isZapping && zap.inputToken) {
-            if (zap.inputToken.toLowerCase() === helpers_1.NATIVE_ADDRESS.toLowerCase()) {
-                zapAssets = FormatConverter_1.default.decimalToBigInt(amount, 18n);
-            }
-            else {
-                const inputErc20 = new ERC20_1.ERC20(this.provider, zap.inputToken, undefined, undefined, this.signer);
-                const zapDecimals = inputErc20.decimals ?? await inputErc20.contract.decimals();
-                zapAssets = FormatConverter_1.default.decimalToBigInt(amount, zapDecimals);
-            }
-        }
-        if (!isZapping) {
+        const zapAssets = await this.getZapAssetAmount(amount, zap);
+        if (!this.isZapInstruction(zap)) {
             const collateralCapError = "There is not enough collateral left in this tokens collateral cap for this deposit.";
             const remainingCollateral = this.getRemainingCollateral(false);
-            if (remainingCollateral == 0n)
+            if (remainingCollateral <= 0n)
                 throw new Error(collateralCapError);
             if (remainingCollateral > 0n) {
-                const shares = this.virtualConvertToShares(depositAssets, LEVERAGE.SHARES_BUFFER_BPS);
+                const shares = this.virtualConvertToShares(depositAssets);
                 if (shares > remainingCollateral) {
                     throw new Error(collateralCapError);
                 }
             }
         }
-        const default_calldata = this.getCallData("depositAsCollateral", [depositAssets, receiver]);
-        const { calldata, calldata_overrides, zapper } = await this.zap(zapAssets, zap, true, default_calldata);
-        await this._checkDepositApprovals(zapper, zapAssets);
-        return this.oracleRoute(calldata, calldata_overrides);
+        await this._checkDepositApprovals(zap, depositAssets, zapAssets, true, receiver);
+        const collateralMethod = receiver.toLowerCase() === signer.address.toLowerCase()
+            ? "depositAsCollateral"
+            : "depositAsCollateralFor";
+        const default_calldata = this.getCallData(collateralMethod, [depositAssets, receiver]);
+        const { calldata, calldata_overrides } = await this.zap(zapAssets, zap, true, default_calldata, receiver);
+        return this.oracleRoute(calldata, calldata_overrides, receiver);
     }
     async redeem(amount) {
         const signer = this.requireSigner();
         const receiver = signer.address;
         const owner = signer.address;
-        const buffer = this.market.userDebt.greaterThan(0) ? 100n : 0n;
+        const buffer = this.getExecutionDebtBufferTime();
         const balance_avail = await this.balanceOf(signer.address);
         const max_shares = await this.maxRedemption(true, buffer);
         const converted_shares = this.convertTokenInputToShares(amount);
-        let shares = max_shares < converted_shares ? max_shares : converted_shares;
-        if (balance_avail - shares <= 10n) {
+        const maxExecutableShares = max_shares < balance_avail ? max_shares : balance_avail;
+        let shares = maxExecutableShares < converted_shares ? maxExecutableShares : converted_shares;
+        if (maxExecutableShares === balance_avail && balance_avail - shares <= 10n) {
             shares = balance_avail;
         }
         const calldata = this.getCallData("redeem", [shares, receiver, owner]);
@@ -1322,6 +1598,7 @@ class CToken extends Calldata_1.Calldata {
         const snapshot = await this.contract.getSnapshot(account);
         return {
             asset: snapshot.asset,
+            underlying: snapshot.underlying,
             decimals: BigInt(snapshot.decimals),
             isCollateral: snapshot.isCollateral,
             collateralPosted: BigInt(snapshot.collateralPosted),
@@ -1355,19 +1632,49 @@ class CToken extends Calldata_1.Calldata {
         const decimals = this.asset.decimals ?? this.decimals;
         return FormatConverter_1.default.bigIntTokensToUsd(tokenAmount, price, decimals);
     }
-    async convertSharesToUsd(tokenAmount) {
-        tokenAmount = this.virtualConvertToShares(tokenAmount);
+    convertSharesToUsdSync(tokenAmount) {
         const price = this.getPrice(false, false, false);
         const decimals = this.decimals;
         return FormatConverter_1.default.bigIntTokensToUsd(tokenAmount, price, decimals);
     }
-    buildMultiCallAction(calldata) {
+    async fetchConvertSharesToUsd(tokenAmount) {
+        await this.fetchPrice(false);
+        await this.fetchDecimals();
+        return this.convertSharesToUsdSync(tokenAmount);
+    }
+    async convertSharesToUsd(tokenAmount) {
+        return this.convertSharesToUsdSync(tokenAmount);
+    }
+    buildMultiCallAction(calldata, target = this.address) {
         return {
-            target: this.address,
+            target,
             isPriceUpdate: false,
             data: calldata
         };
     }
+    hasNonZeroNativeValueOverride(override) {
+        const value = override.value;
+        if (value == null) {
+            return false;
+        }
+        if (typeof value === "bigint") {
+            return value > 0n;
+        }
+        if (typeof value === "number") {
+            return value > 0;
+        }
+        if (typeof value === "string") {
+            return BigInt(value) > 0n;
+        }
+        return true;
+    }
+    assertOracleMulticallSupportsValue(priceUpdates, override) {
+        if (priceUpdates.length === 0 || !this.hasNonZeroNativeValueOverride(override)) {
+            return;
+        }
+        throw new Error("Native gas-token zaps cannot be combined with oracle price-update multicalls. " +
+            "Use the wrapped-native zap path or retry when no oracle update is required.");
+    }
     async _checkPositionManagerApproval(manager) {
         const isApproved = await this.isPluginApproved(manager.type, 'positionManager');
         if (!isApproved) {
@@ -1375,71 +1682,172 @@ class CToken extends Calldata_1.Calldata {
         }
     }
     async _checkZapperApproval(zapper) {
-        if (!this.setup.approval_protection) {
-            return;
+        const plugin_allowed = await this.isPluginApproved(zapper.type, 'zapper');
+        if (!plugin_allowed) {
+            throw new Error(`Please approve the ${zapper.type} Zapper to be able to move ${this.symbol} on your behalf.`);
         }
-        if (this.setup.approval_protection && zapper) {
-            const plugin_allowed = await this.isPluginApproved(zapper.type, 'zapper');
-            if (!plugin_allowed) {
-                throw new Error(`Please approve the ${zapper.type} Zapper to be able to move ${this.symbol} on your behalf.`);
-            }
+    }
+    async _checkDelegateApproval(owner, delegate, delegateLabel) {
+        const pluginAllowed = await this.contract.isDelegate(owner, delegate);
+        if (!pluginAllowed) {
+            throw new Error(`Please approve ${delegateLabel} as a delegate for ${this.symbol} on behalf of ${owner}.`);
         }
     }
-    async _checkErc20Approval(erc20_address, amount, spender) {
-        const signer = this.requireSigner();
-        const erc20 = new ERC20_1.ERC20(this.provider, erc20_address, undefined, undefined, signer);
-        const allowance = await erc20.allowance(signer.address, spender);
-        if (allowance < amount) {
-            const symbol = await erc20.fetchSymbol();
-            throw new Error(`Please approve ${symbol} for ${spender}: ${amount}`);
+    getDepositAssetApprovalTarget() {
+        const asset = this.getAsset(true);
+        return {
+            token: asset,
+            spender: this.address,
+            spenderLabel: this.symbol,
+        };
+    }
+    getPositionManagerDepositApprovalTarget(manager) {
+        return {
+            token: this.getAsset(true),
+            spender: manager.address,
+            spenderLabel: `${manager.type} PositionManager`,
+        };
+    }
+    async resolveZapApprovalTarget(instructions) {
+        const zapType = typeof instructions == 'object' ? instructions.type : instructions;
+        if (zapType == 'none') {
+            return null;
+        }
+        const spender = this.getPluginAddress(zapType, 'zapper');
+        if (spender == null) {
+            throw new Error("Plugin does not have an associated contract");
+        }
+        switch (zapType) {
+            case 'native-vault':
+            case 'native-simple':
+                return null;
+            case 'vault':
+                return {
+                    token: await this.getVaultAsset(true),
+                    spender,
+                    spenderLabel: `${zapType} Zapper`,
+                };
+            case 'simple':
+                if (typeof instructions != 'object') {
+                    throw new Error("Input token must be provided for simple zap approval");
+                }
+                if (instructions.inputToken.toLowerCase() === helpers_1.NATIVE_ADDRESS.toLowerCase()) {
+                    return null;
+                }
+                return {
+                    token: new ERC20_1.ERC20(this.provider, instructions.inputToken, undefined, undefined, this.signer),
+                    spender,
+                    spenderLabel: `${zapType} Zapper`,
+                };
         }
     }
-    async _checkAssetApproval(assets) {
-        if (!this.setup.approval_protection) {
+    async hasTokenApproval(target, amount) {
+        const owner = this.getAccountOrThrow();
+        const allowance = await target.token.allowance(owner, target.spender);
+        return allowance >= amount;
+    }
+    async _checkTokenApproval(target, amount) {
+        const allowance = await this.hasTokenApproval(target, amount);
+        if (allowance) {
             return;
         }
-        const asset = this.getAsset(true);
-        const owner = this.getAccountOrThrow();
-        const allowance = await asset.allowance(owner, this.address);
-        if (allowance < assets) {
-            throw new Error(`Please approve the ${asset.symbol} token for ${this.symbol}`);
+        let tokenLabel = target.token.symbol ?? target.token.address;
+        if (target.token.symbol == undefined) {
+            try {
+                tokenLabel = await target.token.fetchSymbol();
+            }
+            catch {
+                tokenLabel = target.token.address;
+            }
         }
+        throw new Error(`Please approve the ${tokenLabel} token for ${target.spenderLabel}`);
     }
-    async _checkDepositApprovals(zapper, assets) {
-        if (!this.setup.approval_protection) {
-            return;
+    async _checkDepositApprovals(zap, depositAssets, zapAssets, collateralize = false, receiver = null) {
+        const zapType = typeof zap == 'object' ? zap.type : zap;
+        const signer = this.requireSigner();
+        if (zapType != 'none') {
+            const zapper = this.getZapper(zapType);
+            if (!zapper) {
+                throw new Error(`No zapper contract found for type '${zapType}' on ${this.symbol}`);
+            }
+            if (collateralize) {
+                const receiverAddress = receiver ?? signer.address;
+                if (receiverAddress.toLowerCase() === signer.address.toLowerCase()) {
+                    await this._checkZapperApproval(zapper);
+                }
+                else {
+                    await this._checkDelegateApproval(receiverAddress, signer.address, "the connected signer");
+                    await this._checkDelegateApproval(receiverAddress, zapper.address, `${zapper.type} Zapper`);
+                }
+            }
         }
-        if (zapper) {
-            await this._checkZapperApproval(zapper);
+        else if (collateralize && receiver && receiver.toLowerCase() !== signer.address.toLowerCase()) {
+            await this._checkDelegateApproval(receiver, signer.address, "the connected signer");
         }
-        await this._checkAssetApproval(assets);
+        const approvalTarget = zapType == 'none'
+            ? this.getDepositAssetApprovalTarget()
+            : await this.resolveZapApprovalTarget(zap);
+        if (approvalTarget == null) {
+            return;
+        }
+        const approvalAmount = zapType == 'none' ? depositAssets : zapAssets;
+        await this._checkTokenApproval(approvalTarget, approvalAmount);
     }
-    async oracleRoute(calldata, override = {}) {
+    async oracleRoute(calldata, override = {}, reloadAccount = null) {
         const signer = this.requireSigner();
         const price_updates = await this.getPriceUpdates();
+        this.assertOracleMulticallSupportsValue(price_updates, override);
         if (price_updates.length > 0) {
-            const token_action = this.buildMultiCallAction(calldata);
+            const actionTarget = (override.to ?? this.address);
+            const token_action = this.buildMultiCallAction(calldata, actionTarget);
             calldata = this.getCallData("multicall", [[...price_updates, token_action]]);
         }
         const tx = await this.executeCallData(calldata, override);
-        await this.market.reloadUserData(signer.address);
+        if (typeof tx.wait === "function") {
+            await tx.wait();
+        }
+        const refreshAccount = reloadAccount ?? signer.address;
+        await this.market.reloadUserData(refreshAccount, {
+            allowSignerMismatch: refreshAccount.toLowerCase() !== signer.address.toLowerCase(),
+        });
         return tx;
     }
     async simulateOracleRoute(calldata, override = {}) {
         const price_updates = await this.getPriceUpdates();
+        this.assertOracleMulticallSupportsValue(price_updates, override);
         if (price_updates.length > 0) {
-            const token_action = this.buildMultiCallAction(calldata);
+            const actionTarget = (override.to ?? this.address);
+            const token_action = this.buildMultiCallAction(calldata, actionTarget);
             calldata = this.getCallData("multicall", [[...price_updates, token_action]]);
         }
         return this.simulateCallData(calldata, override);
     }
-    async getPriceUpdates() {
-        let price_updates = [];
-        if (this.adapters.includes(ProtocolReader_1.AdaptorTypes.REDSTONE_CORE)) {
-            const redstone = await Redstone_1.Redstone.buildMultiCallAction(this);
-            price_updates.push(redstone);
+    getRedstonePriceUpdateTokens() {
+        const candidates = (this.market?.tokens?.length ? this.market.tokens : [this]);
+        const seenAssets = new Set();
+        const tokens = [];
+        for (const token of candidates) {
+            if (!token.adapters?.includes(ProtocolReader_1.AdaptorTypes.REDSTONE_CORE)) {
+                continue;
+            }
+            let assetAddress;
+            try {
+                assetAddress = token.getAsset(false);
+            }
+            catch {
+                assetAddress = token.cache?.asset?.address ?? token.address;
+            }
+            const key = assetAddress.toLowerCase();
+            if (seenAssets.has(key)) {
+                continue;
+            }
+            seenAssets.add(key);
+            tokens.push(token);
         }
-        return price_updates;
+        return tokens;
+    }
+    async getPriceUpdates() {
+        return Promise.all(this.getRedstonePriceUpdateTokens().map((token) => Redstone_1.Redstone.buildMultiCallAction(token)));
     }
 }
 exports.CToken = CToken;