@ember-finance/sdk 2.5.0-pre.9 → 2.5.1

package/dist/src/atomic/instant-withdraw.d.ts

@@ -1,125 +0,0 @@
-/**
- * Chain-agnostic Atomic Liquidity Vault (ALV) instant-withdraw quote core (BET-4111).
- *
- * There is NO on-chain preview/quote function on the ALV, so the SDK computes the
- * quote client-side by mirroring the exact contract math. Both chains use the same
- * formulas with a different fixed-point scale, so this module is parameterised by
- * `scale` (EVM = 1e18, Sui = 1e9) and consumed by both the EVM and Sui readers, which
- * supply the live on-chain inputs (rate/TVL/held-value/config) via RPC.
- *
- * Mirrors:
- *  - swap-with-holdback: EVM `AtomicLiquidityLib.swapEmberShares`,
- *    Sui `atomic_liquidity_vault::swap_ember_shares`
- *  - plain instant withdraw: EVM `AtomicLiquidity.instantWithdraw`,
- *    Sui `do_instant_withdraw_core`
- *  - fixed point: `Math.mul = (a*b)/scale`, `Math.div = (a*scale)/b` (floor)
- *  - fee curve: `_lookupFeeMultiplier` (ascending tiers; highest threshold <= utilization wins; 1x default)
- */
-/** Fixed-point multiply: `(a * b) / scale`, floor (matches Solidity/Move `Math.mul`). */
-export declare function mulFp(a: bigint, b: bigint, scale: bigint): bigint;
-/** Fixed-point divide: `(a * scale) / b`, floor (matches Solidity/Move `Math.div`). */
-export declare function divFp(a: bigint, b: bigint, scale: bigint): bigint;
-/** A single (threshold, multiplier) tier of the fee-multiplier curve (fixed-point at `scale`). */
-export interface FeeMultiplierTier {
-    threshold: bigint;
-    multiplier: bigint;
-}
-/**
- * Resolve the fee multiplier from an ascending curve at a given utilization.
- * Returns the multiplier of the highest tier whose `threshold <= utilization`, or `scale`
- * (1x) when the curve is empty / no tier matches. Mirrors `_lookupFeeMultiplier`.
- */
-export declare function lookupFeeMultiplier(curve: FeeMultiplierTier[], utilization: bigint, scale: bigint): bigint;
-/** Per-source-share EmberShare swap config (fixed-point percentages at `scale`). */
-export interface EmberShareSwapConfig {
-    feePercentage: bigint;
-    holdbackPercentage: bigint;
-    maxUtilizationPercentage: bigint;
-    feeMultiplierCurve: FeeMultiplierTier[];
-    /**
-     * Minimum gross collateral value per swap (collateral units). A swap with
-     * `gross < minSwapGross` reverts `SwapAmountTooSmall`. 0/undefined disables the floor.
-     * EVM-only (no Sui equivalent yet) — omit on Sui.
-     */
-    minSwapGross?: bigint;
-    /**
-     * TVL-independent absolute ceiling on this source share's post-swap held value
-     * (collateral units). A swap pushing `currentHeldValue + gross` above it reverts
-     * `EmberShareHeldValueCapExceeded`. 0/undefined disables it. EVM-only — omit on Sui.
-     */
-    maxHeldValueAbsolute?: bigint;
-}
-export interface SwapQuoteInputs {
-    /** Fixed-point scale: 1e18 (EVM) / 1e9 (Sui). */
-    scale: bigint;
-    /** Gross collateral value of the source shares: `source.convertToAssets(shareAmount)`. */
-    grossAmount: bigint;
-    /** Source shares being swapped (for `resultingShares`). */
-    shareAmount: bigint;
-    /** Caller's current source-share balance (for `resultingShares`). */
-    userShareBalance: bigint;
-    /** Collateral value the ALV already holds for this source share (pre-swap). */
-    currentHeldValue: bigint;
-    /** ALV `totalAssets()`. */
-    vaultTotalAssets: bigint;
-    /** Remaining epoch capacity for this source share: `availableEmberShareCapacity(share)`. */
-    availableCapacity: bigint;
-    config: EmberShareSwapConfig;
-    feeWaived?: boolean;
-    holdbackWaived?: boolean;
-}
-export interface InstantWithdrawQuote {
-    /** Gross collateral value of the redeemed shares. */
-    grossAmount: bigint;
-    /** Paid to the receiver immediately (`gross - fee - holdback`). */
-    instantlyReceive: bigint;
-    /** Held back, released later by the operator (0 for the plain path). */
-    lockedAmount: bigint;
-    /** Fee charged (collateral units). */
-    feeAmount: bigint;
-    /** Effective fee % applied (base * curve multiplier), fixed-point at `scale`. */
-    effectiveFeePercentage: bigint;
-    /** Holdback % applied, fixed-point at `scale` (0 for the plain path). */
-    holdbackPercentage: bigint;
-    /** Post-swap utilization used for the cap + fee-multiplier (0 for the plain path). */
-    utilizationAtSwap: bigint;
-    /** Caller's source-share balance after the withdraw. */
-    resultingShares: bigint;
-    /** True if the swap/withdraw would succeed against ALL caps (utilization, epoch capacity,
-     *  absolute held-value, min-swap floor). Use the granular flags below to explain a `false`. */
-    withinCapacity: boolean;
-    /** True if `gross < minSwapGross` — the swap would revert `SwapAmountTooSmall`.
-     *  Always false for the plain path and when no floor is configured. */
-    belowMinSwap: boolean;
-    /** True if the post-swap held value is within `maxHeldValueAbsolute` (or the cap is disabled).
-     *  Always true for the plain path. */
-    withinHeldValueCap: boolean;
-}
-/**
- * Quote the EmberShare swap-with-holdback path (source tokenized vault -> ALV).
- * Mirrors `swapEmberShares` exactly: post-swap utilization drives the fee multiplier,
- * `net = gross - fee - holdback` is paid now, the holdback is queued for later release.
- */
-export declare function computeSwapQuote(inputs: SwapQuoteInputs): InstantWithdrawQuote;
-export interface PlainInstantQuoteInputs {
-    /** Fixed-point scale: 1e18 (EVM) / 1e9 (Sui). */
-    scale: bigint;
-    /** Gross collateral value of the shares: ALV `convertToAssets(shareAmount)`. */
-    grossAmount: bigint;
-    /** ALV shares being instantly withdrawn. */
-    shareAmount: bigint;
-    /** Caller's current ALV share balance (for `resultingShares`). */
-    userShareBalance: bigint;
-    /** `instantWithdrawFeePercentage`, fixed-point at `scale`. */
-    instantWithdrawFeePercentage: bigint;
-    /** `cumulativeInstantWithdrawShares`. */
-    cumulativeInstantWithdrawShares: bigint;
-    /** `maxInstantWithdrawShares` (cumulative cap). */
-    maxInstantWithdrawShares: bigint;
-}
-/**
- * Quote the ALV's own plain `instantWithdraw` path (atomic-share holders).
- * Mirrors the contract: `net = gross - fee`, no holdback; capped by
- * `cumulative + shares <= maxInstantWithdrawShares`.
- */
-export declare function computePlainInstantQuote(inputs: PlainInstantQuoteInputs): InstantWithdrawQuote;

package/dist/src/atomic/instant-withdraw.js

@@ -1,122 +0,0 @@
-/**
- * Chain-agnostic Atomic Liquidity Vault (ALV) instant-withdraw quote core (BET-4111).
- *
- * There is NO on-chain preview/quote function on the ALV, so the SDK computes the
- * quote client-side by mirroring the exact contract math. Both chains use the same
- * formulas with a different fixed-point scale, so this module is parameterised by
- * `scale` (EVM = 1e18, Sui = 1e9) and consumed by both the EVM and Sui readers, which
- * supply the live on-chain inputs (rate/TVL/held-value/config) via RPC.
- *
- * Mirrors:
- *  - swap-with-holdback: EVM `AtomicLiquidityLib.swapEmberShares`,
- *    Sui `atomic_liquidity_vault::swap_ember_shares`
- *  - plain instant withdraw: EVM `AtomicLiquidity.instantWithdraw`,
- *    Sui `do_instant_withdraw_core`
- *  - fixed point: `Math.mul = (a*b)/scale`, `Math.div = (a*scale)/b` (floor)
- *  - fee curve: `_lookupFeeMultiplier` (ascending tiers; highest threshold <= utilization wins; 1x default)
- */
-/** Fixed-point multiply: `(a * b) / scale`, floor (matches Solidity/Move `Math.mul`). */
-export function mulFp(a, b, scale) {
-    if (a === 0n || b === 0n)
-        return 0n;
-    return (a * b) / scale;
-}
-/** Fixed-point divide: `(a * scale) / b`, floor (matches Solidity/Move `Math.div`). */
-export function divFp(a, b, scale) {
-    if (b === 0n)
-        return 0n;
-    return (a * scale) / b;
-}
-/**
- * Resolve the fee multiplier from an ascending curve at a given utilization.
- * Returns the multiplier of the highest tier whose `threshold <= utilization`, or `scale`
- * (1x) when the curve is empty / no tier matches. Mirrors `_lookupFeeMultiplier`.
- */
-export function lookupFeeMultiplier(curve, utilization, scale) {
-    let multiplier = scale; // 1x
-    for (const tier of curve) {
-        if (utilization >= tier.threshold) {
-            multiplier = tier.multiplier;
-        }
-        else {
-            break; // ascending: once utilization < threshold, all later tiers are higher
-        }
-    }
-    return multiplier;
-}
-/**
- * Quote the EmberShare swap-with-holdback path (source tokenized vault -> ALV).
- * Mirrors `swapEmberShares` exactly: post-swap utilization drives the fee multiplier,
- * `net = gross - fee - holdback` is paid now, the holdback is queued for later release.
- */
-export function computeSwapQuote(inputs) {
-    const { scale, grossAmount, config, feeWaived, holdbackWaived } = inputs;
-    const newHeldValue = inputs.currentHeldValue + grossAmount;
-    const utilizationAtSwap = inputs.vaultTotalAssets === 0n
-        ? 0n
-        : divFp(newHeldValue, inputs.vaultTotalAssets, scale);
-    const feeMultiplier = lookupFeeMultiplier(config.feeMultiplierCurve, utilizationAtSwap, scale);
-    const effectiveFeePercentage = mulFp(config.feePercentage, feeMultiplier, scale);
-    const feeAmount = feeWaived ? 0n : mulFp(grossAmount, effectiveFeePercentage, scale);
-    const holdbackAmount = holdbackWaived
-        ? 0n
-        : mulFp(grossAmount, config.holdbackPercentage, scale);
-    // Mirror the contract's underflow guard.
-    const instantlyReceive = feeAmount + holdbackAmount > grossAmount
-        ? 0n
-        : grossAmount - feeAmount - holdbackAmount;
-    const withinUtilization = utilizationAtSwap <= config.maxUtilizationPercentage;
-    const withinEpochCapacity = grossAmount <= inputs.availableCapacity;
-    // Absolute held-value cap (0/undefined disables it); mirrors EmberShareHeldValueCapExceeded.
-    const maxHeldValueAbsolute = config.maxHeldValueAbsolute ?? 0n;
-    const withinHeldValueCap = maxHeldValueAbsolute === 0n || newHeldValue <= maxHeldValueAbsolute;
-    // Per-swap dust floor (0/undefined disables it); mirrors SwapAmountTooSmall.
-    const minSwapGross = config.minSwapGross ?? 0n;
-    const belowMinSwap = minSwapGross > 0n && grossAmount < minSwapGross;
-    return {
-        grossAmount,
-        instantlyReceive,
-        lockedAmount: holdbackAmount,
-        feeAmount,
-        effectiveFeePercentage,
-        holdbackPercentage: holdbackWaived ? 0n : config.holdbackPercentage,
-        utilizationAtSwap,
-        resultingShares: inputs.userShareBalance >= inputs.shareAmount
-            ? inputs.userShareBalance - inputs.shareAmount
-            : 0n,
-        belowMinSwap,
-        withinHeldValueCap,
-        withinCapacity: withinUtilization &&
-            withinEpochCapacity &&
-            withinHeldValueCap &&
-            !belowMinSwap &&
-            feeAmount + holdbackAmount <= grossAmount
-    };
-}
-/**
- * Quote the ALV's own plain `instantWithdraw` path (atomic-share holders).
- * Mirrors the contract: `net = gross - fee`, no holdback; capped by
- * `cumulative + shares <= maxInstantWithdrawShares`.
- */
-export function computePlainInstantQuote(inputs) {
-    const { scale, grossAmount, shareAmount } = inputs;
-    const feeAmount = mulFp(grossAmount, inputs.instantWithdrawFeePercentage, scale);
-    const instantlyReceive = feeAmount > grossAmount ? 0n : grossAmount - feeAmount;
-    const withinCapacity = inputs.cumulativeInstantWithdrawShares + shareAmount <=
-        inputs.maxInstantWithdrawShares;
-    return {
-        grossAmount,
-        instantlyReceive,
-        lockedAmount: 0n,
-        feeAmount,
-        effectiveFeePercentage: inputs.instantWithdrawFeePercentage,
-        holdbackPercentage: 0n,
-        utilizationAtSwap: 0n,
-        resultingShares: inputs.userShareBalance >= shareAmount
-            ? inputs.userShareBalance - shareAmount
-            : 0n,
-        belowMinSwap: false,
-        withinHeldValueCap: true,
-        withinCapacity
-    };
-}

package/dist/src/evm-vaults/on-chain-calls/atomic-liquidity.d.ts

@@ -1,98 +0,0 @@
-import { Provider } from "ethers";
-import { FeeMultiplierTier, InstantWithdrawQuote } from "../../atomic/instant-withdraw.js";
-/**
- * Read-only views for the Atomic Liquidity Vault (BFE-817/818).
- *
- * Write calls live on the role classes (EVMUserCalls.instantWithdraw /
- * swapEmberShares, EVMOperatorCalls.supplyToStrategy / withdrawFromStrategy /
- * redeemCollectedEmberShares / releaseUsersHoldback, EVMVaultAdminCalls.setStrategy /
- * setEmberShareWhitelist / setSwapWaiver / setMaxInstantWithdrawShares /
- * setInstantWithdrawFeePercentage). Shared lifecycle calls (deposit, redeemShares,
- * cancelPendingWithdrawalRequest, processWithdrawalRequests, collectPlatformFee,
- * updateVaultRate, pause/role/cap setters) reuse the existing EmberVault methods on
- * those same classes.
- *
- * This reader uses an ethers Contract against the bundled AtomicLiquidity ABI and
- * provides typed convenience getters plus a generic `read` for any view not covered.
- *
- * @example
- * ```typescript
- * const reader = new EVMAtomicLiquidityReader(provider);
- * const rate = await reader.rate(vault);
- * const supplied = await reader.getStrategyAssets(vault);
- * const cfg = await reader.read(vault, "emberShareConfigs", [sourceShare]);
- * ```
- */
-export declare class EVMAtomicLiquidityReader {
-    provider: Provider;
-    constructor(_provider: Provider);
-    private contract;
-    /** A source EmberShare vault (ERC-4626) for read-only convertToAssets/balanceOf/accounts. */
-    private shareContract;
-    /** Generic view call for any function on the AtomicLiquidity ABI. */
-    read(vaultAddress: string, functionName: string, args?: unknown[]): Promise<unknown>;
-    /** roles() -> { admin, operator, rateManager }. */
-    roles(vaultAddress: string): Promise<unknown>;
-    /** rate() -> { value, maxRateChangePerUpdate, rateUpdateInterval, lastUpdatedAt }. */
-    rate(vaultAddress: string): Promise<unknown>;
-    /** Current external strategy address (zero if none). */
-    strategy(vaultAddress: string): Promise<string>;
-    /** Assets currently supplied to the strategy. */
-    getStrategyAssets(vaultAddress: string): Promise<bigint>;
-    /** Total assets (idle + strategy + outstanding). */
-    totalAssets(vaultAddress: string): Promise<bigint>;
-    /**
-     * Solvency margin (collateral units, signed): `totalAssets - totalLiabilities`. Negative
-     * means the vault is under-collateralised. Monitoring view added with the audit fixes.
-     */
-    solvencyMargin(vaultAddress: string): Promise<bigint>;
-    /** Total non-transferable shares in circulation. */
-    totalShares(vaultAddress: string): Promise<bigint>;
-    /** Non-transferable share balance of `account`. */
-    shareOf(vaultAddress: string, account: string): Promise<bigint>;
-    /** Cumulative instant-withdraw shares used. */
-    cumulativeInstantWithdrawShares(vaultAddress: string): Promise<bigint>;
-    /** Configured instant-withdraw cap (shares). */
-    maxInstantWithdrawShares(vaultAddress: string): Promise<bigint>;
-    /** Remaining instant-withdraw headroom (shares). */
-    availableInstantWithdrawShares(vaultAddress: string): Promise<bigint>;
-    /** Per-source-share swap config. */
-    emberShareConfigs(vaultAddress: string, share: string): Promise<unknown>;
-    /** Remaining swap capacity for a source share in the current epoch. */
-    availableEmberShareCapacity(vaultAddress: string, share: string): Promise<bigint>;
-    /** Length of the holdback FIFO for a source share. */
-    getHoldbackQueueLength(vaultAddress: string, share: string): Promise<bigint>;
-    /**
-     * Escrowed (deferred) holdback collateral claimable by `account` — accrued when a
-     * holdback payout couldn't be transferred to it during `releaseUsersHoldback` (e.g. a
-     * token-level blocklist). Claim via user `claimHoldback` / `claimHoldbackFor`. 0 if none.
-     */
-    unclaimedHoldback(vaultAddress: string, account: string): Promise<bigint>;
-    /** Whether `operation` ("deposits" | "withdrawals" | "privilegedOperations") is paused. */
-    pauseStatus(vaultAddress: string, operation: string): Promise<boolean>;
-    /** Per-account state (shares + pending withdrawals). */
-    getAccountState(vaultAddress: string, account: string): Promise<unknown>;
-    /** Convert a share amount to assets at the current rate. */
-    convertToAssets(vaultAddress: string, shares: bigint): Promise<bigint>;
-    /** Convert an asset amount to shares at the current rate. */
-    convertToShares(vaultAddress: string, assets: bigint): Promise<bigint>;
-    /** Contract version string. */
-    version(vaultAddress: string): Promise<string>;
-    /**
-     * Live quote for the EmberShare swap-with-holdback "instant withdraw": a holder of a
-     * source vault's shares (`share`) swaps `shareAmount` into this ALV, receiving most of
-     * the value instantly with a small % held back for later operator release.
-     *
-     * All dynamic inputs (rate, TVL, held value, epoch capacity, waivers) are read live via
-     * RPC. The fee-multiplier curve has no on-chain getter (the public `emberShareConfigs`
-     * getter omits the dynamic array), so pass it from bfvs `instantWithdrawConfig`; an empty
-     * curve means a 1x multiplier (matches the contract default).
-     */
-    previewSwapInstantWithdraw(vaultAddress: string, share: string, shareAmount: bigint, owner: string, feeMultiplierCurve?: FeeMultiplierTier[]): Promise<InstantWithdrawQuote>;
-    /**
-     * Live quote for the ALV's own plain `instantWithdraw` (atomic-share holders): burn
-     * `shareAmount` ALV shares for `gross - fee`, no holdback, capped by
-     * `maxInstantWithdrawShares`. All inputs read live via RPC.
-     */
-    previewPlainInstantWithdraw(vaultAddress: string, shareAmount: bigint, owner: string): Promise<InstantWithdrawQuote>;
-}

package/dist/src/evm-vaults/on-chain-calls/atomic-liquidity.js

@@ -1,212 +0,0 @@
-import { Contract } from "ethers";
-import AtomicLiquidityABI from "../../abis/AtomicLiquidity.json" with { type: "json" };
-import EmberVaultABI from "../../abis/EmberVault.json" with { type: "json" };
-import { computeSwapQuote, computePlainInstantQuote } from "../../atomic/instant-withdraw.js";
-/** EVM fixed-point scale (1e18) used by the AtomicLiquidity contract math. */
-const EVM_SCALE = 10n ** 18n;
-/**
- * Read-only views for the Atomic Liquidity Vault (BFE-817/818).
- *
- * Write calls live on the role classes (EVMUserCalls.instantWithdraw /
- * swapEmberShares, EVMOperatorCalls.supplyToStrategy / withdrawFromStrategy /
- * redeemCollectedEmberShares / releaseUsersHoldback, EVMVaultAdminCalls.setStrategy /
- * setEmberShareWhitelist / setSwapWaiver / setMaxInstantWithdrawShares /
- * setInstantWithdrawFeePercentage). Shared lifecycle calls (deposit, redeemShares,
- * cancelPendingWithdrawalRequest, processWithdrawalRequests, collectPlatformFee,
- * updateVaultRate, pause/role/cap setters) reuse the existing EmberVault methods on
- * those same classes.
- *
- * This reader uses an ethers Contract against the bundled AtomicLiquidity ABI and
- * provides typed convenience getters plus a generic `read` for any view not covered.
- *
- * @example
- * ```typescript
- * const reader = new EVMAtomicLiquidityReader(provider);
- * const rate = await reader.rate(vault);
- * const supplied = await reader.getStrategyAssets(vault);
- * const cfg = await reader.read(vault, "emberShareConfigs", [sourceShare]);
- * ```
- */
-export class EVMAtomicLiquidityReader {
-    constructor(_provider) {
-        this.provider = _provider;
-    }
-    contract(vaultAddress) {
-        return new Contract(vaultAddress, AtomicLiquidityABI.abi, this.provider);
-    }
-    /** A source EmberShare vault (ERC-4626) for read-only convertToAssets/balanceOf/accounts. */
-    shareContract(share) {
-        return new Contract(share, EmberVaultABI.abi, this.provider);
-    }
-    /** Generic view call for any function on the AtomicLiquidity ABI. */
-    async read(vaultAddress, functionName, args = []) {
-        return this.contract(vaultAddress)[functionName](...args);
-    }
-    /** roles() -> { admin, operator, rateManager }. */
-    async roles(vaultAddress) {
-        return this.contract(vaultAddress).roles();
-    }
-    /** rate() -> { value, maxRateChangePerUpdate, rateUpdateInterval, lastUpdatedAt }. */
-    async rate(vaultAddress) {
-        return this.contract(vaultAddress).rate();
-    }
-    /** Current external strategy address (zero if none). */
-    async strategy(vaultAddress) {
-        return this.contract(vaultAddress).strategy();
-    }
-    /** Assets currently supplied to the strategy. */
-    async getStrategyAssets(vaultAddress) {
-        return this.contract(vaultAddress).getStrategyAssets();
-    }
-    /** Total assets (idle + strategy + outstanding). */
-    async totalAssets(vaultAddress) {
-        return this.contract(vaultAddress).totalAssets();
-    }
-    /**
-     * Solvency margin (collateral units, signed): `totalAssets - totalLiabilities`. Negative
-     * means the vault is under-collateralised. Monitoring view added with the audit fixes.
-     */
-    async solvencyMargin(vaultAddress) {
-        return this.contract(vaultAddress).solvencyMargin();
-    }
-    /** Total non-transferable shares in circulation. */
-    async totalShares(vaultAddress) {
-        return this.contract(vaultAddress).totalShares();
-    }
-    /** Non-transferable share balance of `account`. */
-    async shareOf(vaultAddress, account) {
-        return this.contract(vaultAddress).shareOf(account);
-    }
-    /** Cumulative instant-withdraw shares used. */
-    async cumulativeInstantWithdrawShares(vaultAddress) {
-        return this.contract(vaultAddress).cumulativeInstantWithdrawShares();
-    }
-    /** Configured instant-withdraw cap (shares). */
-    async maxInstantWithdrawShares(vaultAddress) {
-        return this.contract(vaultAddress).maxInstantWithdrawShares();
-    }
-    /** Remaining instant-withdraw headroom (shares). */
-    async availableInstantWithdrawShares(vaultAddress) {
-        return this.contract(vaultAddress).availableInstantWithdrawShares();
-    }
-    /** Per-source-share swap config. */
-    async emberShareConfigs(vaultAddress, share) {
-        return this.contract(vaultAddress).emberShareConfigs(share);
-    }
-    /** Remaining swap capacity for a source share in the current epoch. */
-    async availableEmberShareCapacity(vaultAddress, share) {
-        return this.contract(vaultAddress).availableEmberShareCapacity(share);
-    }
-    /** Length of the holdback FIFO for a source share. */
-    async getHoldbackQueueLength(vaultAddress, share) {
-        return this.contract(vaultAddress).getHoldbackQueueLength(share);
-    }
-    /**
-     * Escrowed (deferred) holdback collateral claimable by `account` — accrued when a
-     * holdback payout couldn't be transferred to it during `releaseUsersHoldback` (e.g. a
-     * token-level blocklist). Claim via user `claimHoldback` / `claimHoldbackFor`. 0 if none.
-     */
-    async unclaimedHoldback(vaultAddress, account) {
-        return this.contract(vaultAddress).unclaimedHoldback(account);
-    }
-    /** Whether `operation` ("deposits" | "withdrawals" | "privilegedOperations") is paused. */
-    async pauseStatus(vaultAddress, operation) {
-        return this.contract(vaultAddress).pauseStatus(operation);
-    }
-    /** Per-account state (shares + pending withdrawals). */
-    async getAccountState(vaultAddress, account) {
-        return this.contract(vaultAddress).getAccountState(account);
-    }
-    /** Convert a share amount to assets at the current rate. */
-    async convertToAssets(vaultAddress, shares) {
-        return this.contract(vaultAddress).convertToAssets(shares);
-    }
-    /** Convert an asset amount to shares at the current rate. */
-    async convertToShares(vaultAddress, assets) {
-        return this.contract(vaultAddress).convertToShares(assets);
-    }
-    /** Contract version string. */
-    async version(vaultAddress) {
-        return this.contract(vaultAddress).version();
-    }
-    /**
-     * Live quote for the EmberShare swap-with-holdback "instant withdraw": a holder of a
-     * source vault's shares (`share`) swaps `shareAmount` into this ALV, receiving most of
-     * the value instantly with a small % held back for later operator release.
-     *
-     * All dynamic inputs (rate, TVL, held value, epoch capacity, waivers) are read live via
-     * RPC. The fee-multiplier curve has no on-chain getter (the public `emberShareConfigs`
-     * getter omits the dynamic array), so pass it from bfvs `instantWithdrawConfig`; an empty
-     * curve means a 1x multiplier (matches the contract default).
-     */
-    async previewSwapInstantWithdraw(vaultAddress, share, shareAmount, owner, feeMultiplierCurve = []) {
-        const vault = this.contract(vaultAddress);
-        const src = this.shareContract(share);
-        const [grossAmount, cfg, vaultTotalAssets, availableCapacity, custodied, hasRedemption, feeWaived, holdbackWaived, userShareBalance] = await Promise.all([
-            src.convertToAssets(shareAmount),
-            vault.emberShareConfigs(share),
-            vault.totalAssets(),
-            vault.availableEmberShareCapacity(share),
-            src.balanceOf(vaultAddress),
-            vault.hasActiveRedemptionHistory(),
-            vault.feeWaivedAddresses(owner),
-            vault.holdbackWaivedAddresses(owner),
-            src.balanceOf(owner)
-        ]);
-        // currentHeldValue mirrors _heldShareValueInCollateral: custodied + pending
-        // (pending only when the ALV has an active redemption history), valued via the
-        // source vault's convertToAssets.
-        let heldShares = custodied;
-        if (hasRedemption) {
-            // EmberVault.accounts(address) has a single uint256 output
-            // (totalPendingWithdrawalShares); ethers v6 returns the bare bigint for
-            // single-output calls, not a named struct.
-            const pendingWithdrawalShares = (await src.accounts(vaultAddress));
-            heldShares += pendingWithdrawalShares;
-        }
-        const currentHeldValue = heldShares === 0n ? 0n : (await src.convertToAssets(heldShares));
-        return computeSwapQuote({
-            scale: EVM_SCALE,
-            grossAmount,
-            shareAmount,
-            userShareBalance,
-            currentHeldValue,
-            vaultTotalAssets,
-            availableCapacity,
-            config: {
-                feePercentage: cfg.feePercentage,
-                holdbackPercentage: cfg.holdbackPercentage,
-                maxUtilizationPercentage: cfg.maxUtilizationPercentage,
-                minSwapGross: cfg.minSwapGross,
-                maxHeldValueAbsolute: cfg.maxHeldValueAbsolute,
-                feeMultiplierCurve
-            },
-            feeWaived,
-            holdbackWaived
-        });
-    }
-    /**
-     * Live quote for the ALV's own plain `instantWithdraw` (atomic-share holders): burn
-     * `shareAmount` ALV shares for `gross - fee`, no holdback, capped by
-     * `maxInstantWithdrawShares`. All inputs read live via RPC.
-     */
-    async previewPlainInstantWithdraw(vaultAddress, shareAmount, owner) {
-        const vault = this.contract(vaultAddress);
-        const [grossAmount, instantWithdrawFeePercentage, cumulativeInstantWithdrawShares, maxInstantWithdrawShares, userShareBalance] = await Promise.all([
-            vault.convertToAssets(shareAmount),
-            vault.instantWithdrawFeePercentage(),
-            vault.cumulativeInstantWithdrawShares(),
-            vault.maxInstantWithdrawShares(),
-            vault.shareOf(owner)
-        ]);
-        return computePlainInstantQuote({
-            scale: EVM_SCALE,
-            grossAmount,
-            shareAmount,
-            userShareBalance,
-            instantWithdrawFeePercentage,
-            cumulativeInstantWithdrawShares,
-            maxInstantWithdrawShares
-        });
-    }
-}

package/dist/src/sui-vaults/on-chain-calls/atomic-liquidity.d.ts

@@ -1,62 +0,0 @@
-import { BaseClient as SuiClient } from "@mysten/sui/client";
-import { FeeMultiplierTier, InstantWithdrawQuote } from "../../atomic/instant-withdraw.js";
-/**
- * Read-only views + instant-withdraw quotes for the Sui Atomic Liquidity Vault (BET-4111).
- *
- * There is no on-chain preview function and no off-chain view calls on Sui, so this reads
- * the ALV (and source vault) object fields directly and replicates the Move math
- * (`calculate_amount_from_shares`, `get_vault_tvl`, `swap_ember_shares`,
- * `do_instant_withdraw_core`) via the shared chain-agnostic quote core at scale 1e9.
- *
- * @example
- * ```ts
- * const reader = new SuiAtomicLiquidityReader(suiClient);
- * const q = await reader.previewSwapInstantWithdraw(vaultId, sourceVaultId, 100_000000n, owner);
- * ```
- */
-export declare class SuiAtomicLiquidityReader {
-    suiClient: SuiClient;
-    constructor(suiClient: SuiClient);
-    /** Raw Move fields of the AtomicLiquidityVault object. */
-    private vaultFields;
-    /**
-     * Read a `Table<K, V>` entry value. Table entries are plain dynamic fields, so we
-     * resolve the `Field<K,V>` object id via `getDynamicField`, then fetch its json
-     * (`{ name, value }`). Returns the unwrapped `value`, or null if absent.
-     */
-    private readTableValue;
-    /** Rate value (1e9) of any vault object (ALV or source EmberVault). */
-    private rateValue;
-    /** Per-source-share EmberShare config from the `ember_share_configs` table. */
-    getEmberShareConfig(vaultId: string, sourceVaultId: string): Promise<{
-        whitelisted: boolean;
-        feePercentage: bigint;
-        holdbackPercentage: bigint;
-        maxCapacityPercentage: bigint;
-        maxUtilizationPercentage: bigint;
-        epochStartedAt: bigint;
-        epochUsedAmount: bigint;
-        feeMultiplierCurve: FeeMultiplierTier[];
-    } | null>;
-    /** Caller's ALV (non-transferable) share balance from the `shares` table. */
-    shareOf(vaultId: string, account: string): Promise<bigint>;
-    /**
-     * Live quote for the EmberShare swap-with-holdback "instant withdraw" on Sui.
-     * Reads ALV + source vault fields and replicates `swap_ember_shares` math.
-     *
-     * `currentHeldValue` defaults to 0 (the common case before any swap); pass it when the
-     * ALV already custodies source shares. `availableCapacity` (remaining 24h epoch capacity,
-     * collateral units) is bfvs-sourced when precise epoch accounting is required — when
-     * omitted, only the utilization cap gates `withinCapacity`.
-     */
-    previewSwapInstantWithdraw(vaultId: string, sourceVaultId: string, shareAmount: bigint, owner: string, opts?: {
-        availableCapacity?: bigint;
-        currentHeldValue?: bigint;
-        userShareBalance?: bigint;
-    }): Promise<InstantWithdrawQuote>;
-    /**
-     * Live quote for the ALV's own plain `instant_withdraw` on Sui (atomic-share holders).
-     * `net = gross - fee`, no holdback, capped by `max_instant_withdraw_shares`.
-     */
-    previewPlainInstantWithdraw(vaultId: string, shareAmount: bigint, owner: string): Promise<InstantWithdrawQuote>;
-}