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

Catalyst AMM SDK

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.amplifiedGlobalInvariant = amplifiedGlobalInvariant;
exports.assetsToUnitsAmplified = assetsToUnitsAmplified;
exports.assetsForUnitsAmplified = assetsForUnitsAmplified;
exports.poolTokensToUnitsAmplified = poolTokensToUnitsAmplified;
exports.getDifferenceUnitsAmplified = getDifferenceUnitsAmplified;
exports.findOptimalSwapsAmplified = findOptimalSwapsAmplified;
exports.findOptimalWithdrawalsAmplified = findOptimalWithdrawalsAmplified;
const math_lib_1 = require("../math.lib");
const math_utils_1 = require("../math.utils");
const math_amplified_functions_1 = require("./math.amplified.functions");
const math_amplified_integrals_1 = require("./math.amplified.integrals");
function amplifiedGlobalInvariant(vaults) {
    let invariantSum = 0n;
    for (const vault of vaults) {
        const oneMinusAmp = math_lib_1.WAD - vault.amplification;
        for (let assetIndex = 0; assetIndex < vault.balances.length; ++assetIndex) {
            invariantSum =
                invariantSum +
                    (0, math_lib_1.powWad)(vault.weights[assetIndex] * vault.balances[assetIndex] * math_lib_1.WAD, oneMinusAmp);
        }
    }
    return invariantSum;
}
function assetsToUnitsAmplified(vaults, userDeposit, flat) {
    const units = [];
    for (let vaultIndex = 0; vaultIndex < vaults.length; ++vaultIndex) {
        const vault = vaults[vaultIndex];
        const vaultDeposit = userDeposit[vaultIndex];
        const vaultUnits = [];
        for (let assetIndex = 0; assetIndex < vault.balances.length; ++assetIndex) {
            if (vaultDeposit[assetIndex] === 0n) {
                vaultUnits.push(0n);
                continue;
            }
            const boughtUnits = ((0, math_amplified_functions_1.sendAssetAmp)(vault.balances[assetIndex], vaultDeposit[assetIndex], vault.weights[assetIndex], vault.amplification) *
                (math_lib_1.WAD - vault.vaultFee)) /
                math_lib_1.WAD;
            vaultUnits.push(boughtUnits);
        }
        units.push(vaultUnits);
    }
    return flat ? units.map((v) => (0, math_utils_1.bigNumberSum)(v)) : units;
}
function assetsForUnitsAmplified(vaults, userWithdrawal) {
    const units = userWithdrawal.map((vaultWithdrawal, vaultIndex) => {
        const vault = vaults[vaultIndex];
        return vaultWithdrawal.map((withdraw, assetIndex) => {
            if (vaultWithdrawal[assetIndex] === 0n) {
                return 0n;
            }
            const boughtUnits = (0, math_amplified_functions_1.getAssetAmp)(vault.balances[assetIndex], withdraw, vault.weights[assetIndex], vault.amplification);
            return boughtUnits;
        });
    });
    return units;
}
function poolTokensToUnitsAmplified(vaults, vaultTokens) {
    const units = [];
    for (let vaultIndex = 0; vaultIndex < vaults.length; ++vaultIndex) {
        const vault = vaults[vaultIndex];
        const userVaultTokens = vaultTokens[vaultIndex];
        const oneMinusAmp = math_lib_1.WAD - vault.amplification;
        const walpha_0_ampped = (0, math_amplified_functions_1.balance0Amp)(oneMinusAmp, vault.balances, vault.weights, vault.unitTracker);
        const vaultUnits = (0, math_amplified_integrals_1.calcVaultTokensToUnitsAmp)(userVaultTokens, vault.totalSupply, walpha_0_ampped, oneMinusAmp, vault.balances.length);
        units.push(vaultUnits);
    }
    return units;
}
function getDifferenceUnitsAmplified(vaults, units) {
    const NWAlpha0 = [];
    for (let vaultIndex = 0; vaultIndex < vaults.length; ++vaultIndex) {
        const vault = vaults[vaultIndex];
        NWAlpha0.push((0, math_amplified_functions_1.balance0Amp)(math_lib_1.WAD - vault.amplification, vault.balances, vault.weights, vault.unitTracker) * BigInt(vault.balances.length));
    }
    const sumOfUnits = (0, math_utils_1.bigNumberSum)(units);
    const NWAlpha0Sum = (0, math_utils_1.bigNumberSum)(NWAlpha0);
    const targetUnits = vaults.map((_v, vi) => (NWAlpha0[vi] * sumOfUnits) / NWAlpha0Sum);
    const differenceUnits = targetUnits.map((tu, i) => units[i] - tu);
    return differenceUnits;
}
function findOptimalSwapsAmplified(vaults, units, existingUnitValue) {
    if (units.length !== existingUnitValue.length) {
        throw new Error('Different length units array and existingUnitValue');
    }
    for (let vaultIndex = 1; vaultIndex < vaults.length; ++vaultIndex) {
        if (vaults[0].amplification !== vaults[vaultIndex].amplification) {
            throw new Error('Vault amplification not equal, assumption broken.');
        }
    }
    const newUnbalancedDeposit = units.map((u, i) => u + existingUnitValue[i]);
    if ((0, math_utils_1.bigNumberSum)(newUnbalancedDeposit) < 0n) {
        throw new Error(`More units withdrawn than user have. Net: ${(0, math_utils_1.bigNumberSum)(newUnbalancedDeposit).toString()} units.`);
    }
    const differenceUnits = getDifferenceUnitsAmplified(vaults, newUnbalancedDeposit);
    const movements = (0, math_utils_1.distributeUnitsSorted)(vaults, differenceUnits);
    return movements;
}
function findOptimalWithdrawalsAmplified(vaults, units, existingUnitValue) {
    if (units.length !== existingUnitValue.length) {
        throw new Error('Different length units array and existingUnitValue');
    }
    const newUnbalancedDeposit = units.map((u, i) => u + existingUnitValue[i]);
    if ((0, math_utils_1.bigNumberSum)(newUnbalancedDeposit) < 0n) {
        throw new Error(`More units withdrawn than user have. Net: ${(0, math_utils_1.bigNumberSum)(newUnbalancedDeposit).toString()} units.`);
    }
    const differenceUnits = getDifferenceUnitsAmplified(vaults, newUnbalancedDeposit);
    const movements = (0, math_utils_1.selectDistributeUnits)(vaults, units, differenceUnits, existingUnitValue);
    return movements;
}
//# sourceMappingURL=liquidity.amplified.functions.js.map