@catalabs/catalyst-sdk/build/math/amplified/math.amplified.functions.js

Catalyst AMM SDK

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.sendAssetAmp = sendAssetAmp;
exports.getAssetAmp = getAssetAmp;
exports.receiveAssetAmp = receiveAssetAmp;
exports.balance0Amp = balance0Amp;
exports.withdrawEqualAmp = withdrawEqualAmp;
exports.solvWithdrawEqualAmp = solvWithdrawEqualAmp;
exports.withdrawMixedAmp = withdrawMixedAmp;
const math_lib_1 = require("../math.lib");
const math_amplified_integrals_1 = require("./math.amplified.integrals");
const SMALL_SWAP_RATIO = 10n ** 12n;
const SMALL_SWAP_RETURN = 10n ** 16n * 95n;
function sendAssetAmp(fromBalance, input, fromWeight, amp) {
    const oneMinusAmp = math_lib_1.WAD - amp;
    let calc = (0, math_lib_1.powWad)(fromWeight * (fromBalance + input) * math_lib_1.WAD, oneMinusAmp);
    if (fromBalance !== 0n) {
        calc = calc - (0, math_lib_1.powWad)(fromWeight * fromBalance * math_lib_1.WAD, oneMinusAmp);
    }
    if (fromBalance / SMALL_SWAP_RATIO >= input) {
        return (calc * SMALL_SWAP_RETURN) / math_lib_1.WAD;
    }
    return calc;
}
function getAssetAmp(fromBalance, input, fromWeight, amp) {
    const oneMinusAmp = math_lib_1.WAD - amp;
    let calc = 0n;
    if (fromBalance > 0n) {
        calc = (0, math_lib_1.powWad)(fromWeight * fromBalance * math_lib_1.WAD, oneMinusAmp);
        if (fromBalance > input) {
            calc =
                calc - (0, math_lib_1.powWad)(fromWeight * (fromBalance - input) * math_lib_1.WAD, oneMinusAmp);
        }
    }
    return calc;
}
function receiveAssetAmp(toBalance, U, toWeight, amp) {
    const oneMinusAmp = math_lib_1.WAD - amp;
    const W_BxBtoOMA = (0, math_lib_1.powWad)(toWeight * toBalance * math_lib_1.WAD, oneMinusAmp);
    return ((toBalance *
        (math_lib_1.WAD -
            (0, math_lib_1.powWad)(((W_BxBtoOMA - U) * math_lib_1.WAD + (W_BxBtoOMA - 1n)) / W_BxBtoOMA, (math_lib_1.WAD * math_lib_1.WAD) / oneMinusAmp))) /
        math_lib_1.WAD);
}
function balance0Amp(oneMinusAmp, tokenAmounts, tokenWeights, unitTracker) {
    if (tokenAmounts.length !== tokenWeights.length) {
        throw new Error('Different length between tokenAmounts and tokenWeights');
    }
    let weightedAssetBalanceSum = 0n;
    for (let i = 0; i < tokenAmounts.length; i++) {
        const weightAssetBalance = tokenWeights[i] * tokenAmounts[i];
        let wab = 0n;
        if (weightAssetBalance !== 0n) {
            wab = (0, math_lib_1.powWad)(weightAssetBalance * math_lib_1.WAD, oneMinusAmp);
            weightedAssetBalanceSum = weightedAssetBalanceSum + wab;
        }
    }
    const walpha_0_ampped = (weightedAssetBalanceSum - unitTracker) / BigInt(tokenAmounts.length);
    return walpha_0_ampped;
}
function withdrawEqualAmp(vaultTokens, totalSupply, escrowedVaultTokens, tokenWeights, poolBalance, escrowedTokens, amplification, unitTracker) {
    if (poolBalance.length !== tokenWeights.length) {
        throw new Error('Different length between poolBalance and tokenWeights');
    }
    if (poolBalance.length !== escrowedTokens.length) {
        throw new Error('Different length between poolBalance and escrowedTokens');
    }
    const oneMinusAmp = math_lib_1.WAD - amplification;
    const walpha_0_ampped = balance0Amp(oneMinusAmp, poolBalance, tokenWeights, unitTracker);
    const amounts = [];
    const ts = totalSupply + escrowedVaultTokens;
    const pt_fraction = ((ts - vaultTokens) * math_lib_1.WAD) / ts;
    const innerdiff = pt_fraction === 0n
        ? walpha_0_ampped
        : (walpha_0_ampped * (math_lib_1.WAD - (0, math_lib_1.powWad)(pt_fraction, oneMinusAmp))) / math_lib_1.WAD;
    const oneMinusAmpInverse = (math_lib_1.WAD * math_lib_1.WAD) / oneMinusAmp;
    for (let i = 0; i < poolBalance.length; i++) {
        const ampWeightAssetBalance = (0, math_lib_1.powWad)((poolBalance[i] - escrowedTokens[i]) * math_lib_1.WAD, oneMinusAmp);
        let weightedTokenAmount = poolBalance[i] - escrowedTokens[i];
        if (innerdiff < ampWeightAssetBalance) {
            weightedTokenAmount =
                (weightedTokenAmount *
                    (math_lib_1.WAD -
                        (0, math_lib_1.powWad)(((ampWeightAssetBalance - innerdiff) * math_lib_1.WAD) /
                            ampWeightAssetBalance, oneMinusAmpInverse))) /
                    math_lib_1.WAD;
        }
        const tokenAmount = weightedTokenAmount / tokenWeights[i];
        amounts.push(tokenAmount);
    }
    return amounts;
}
function solvWithdrawEqualAmp(referenceTokenWithdraw, referenceTokenIndex, totalSupply, escrowedVaultTokens, tokenWeights, poolBalance, escrowedTokens, amplification, unitTracker) {
    if (poolBalance.length !== tokenWeights.length) {
        throw new Error('Different length between poolBalance and tokenWeights');
    }
    if (poolBalance.length !== escrowedTokens.length) {
        throw new Error('Different length between poolBalance and escrowedTokens');
    }
    const oneMinusAmp = math_lib_1.WAD - amplification;
    const walpha_0_ampped = balance0Amp(oneMinusAmp, poolBalance, tokenWeights, unitTracker);
    const ts = totalSupply + escrowedVaultTokens;
    const wa = poolBalance[referenceTokenIndex] - escrowedTokens[referenceTokenIndex];
    const targetPostBalance = wa - referenceTokenWithdraw;
    return ((ts *
        (math_lib_1.WAD -
            (0, math_lib_1.powWad)(math_lib_1.WAD -
                ((0, math_lib_1.powWad)(wa * math_lib_1.WAD, oneMinusAmp) -
                    (0, math_lib_1.powWad)(targetPostBalance * math_lib_1.WAD, oneMinusAmp) * math_lib_1.WAD) /
                    walpha_0_ampped, (math_lib_1.WAD * math_lib_1.WAD) / oneMinusAmp))) /
        math_lib_1.WAD);
}
function withdrawMixedAmp(vaultTokens, withdrawRatio, totalSupply, escrowedVaultTokens, tokenWeights, poolBalance, escrowedTokens, amplification, unitTracker) {
    if (poolBalance.length !== tokenWeights.length) {
        throw new Error('Different length between poolBalance and tokenWeights');
    }
    if (poolBalance.length !== escrowedTokens.length) {
        throw new Error('Different length between poolBalance and escrowedTokens');
    }
    if (poolBalance.length !== withdrawRatio.length) {
        throw new Error('Different length between poolBalance and withdrawRatio');
    }
    const oneMinusAmp = math_lib_1.WAD - amplification;
    const walpha_0_ampped = balance0Amp(oneMinusAmp, poolBalance, tokenWeights, unitTracker);
    const ts = totalSupply + escrowedVaultTokens;
    let U = (0, math_amplified_integrals_1.calcVaultTokensToUnitsAmp)(vaultTokens, ts, walpha_0_ampped, oneMinusAmp, poolBalance.length);
    const amounts = [];
    for (let i = 0; i < poolBalance.length; i++) {
        const U_i = (U * withdrawRatio[i]) / math_lib_1.WAD;
        if (U_i === 0n) {
            amounts.push(0n);
            continue;
        }
        U = U - U_i;
        const tokenAmount = (0, math_amplified_integrals_1.calcPriceCurveLimitAmp)(U_i, poolBalance[i] - escrowedTokens[i], tokenWeights[i], oneMinusAmp);
        amounts[i] = tokenAmount / math_lib_1.WAD;
    }
    return amounts;
}
//# sourceMappingURL=math.amplified.functions.js.map