@evaafi/sdk 0.6.4 → 0.9.0

package/dist/contracts/AbstractMaster.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractEvaaMaster = void 0;
+const core_1 = require("@ton/core");
+const __1 = require("..");
+const parser_1 = require("../api/parser");
+const general_1 = require("../constants/general");
+const userJettonWallet_1 = require("../utils/userJettonWallet");
+const JettonWallet_1 = require("./JettonWallet");
+const UserContract_1 = require("./UserContract");
+/**
+ * Abstract EVAA Master base that encapsulates shared logic and structure.
+ * Concrete implementations (Classic/Pyth) should override message creation for
+ * withdraw/liquidation and supply-withdraw wrapping.
+ */
+class AbstractEvaaMaster {
+    constructor(parameters) {
+        this.lastSync = 0;
+        this._poolConfig = parameters.poolConfig;
+        this.address = this._poolConfig.masterAddress;
+        this.debug = parameters?.debug;
+    }
+    get poolConfig() {
+        return this._poolConfig;
+    }
+    get data() {
+        return this._data;
+    }
+    // ---------- Common helpers ----------
+    createJettonTransferMessage(parameters, defaultFees, message) {
+        if (parameters.amount == undefined &&
+            parameters.liquidationAmount == undefined &&
+            parameters.supplyAmount == undefined) {
+            throw new Error('Either amount or liquidationAmount or supplyAmount must be provided');
+        }
+        return (0, core_1.beginCell)()
+            .storeUint(general_1.OPCODES.JETTON_TRANSFER, 32)
+            .storeUint(parameters.queryID, 64)
+            .storeCoins(parameters.amount ?? parameters.liquidationAmount ?? parameters.supplyAmount ?? 0n)
+            .storeAddress(parameters.destinationAddress ?? this.address)
+            .storeAddress(parameters.responseAddress ?? parameters.userAddress ?? parameters.liquidatorAddress)
+            .storeBit(0)
+            .storeCoins(parameters.forwardAmount ?? defaultFees)
+            .storeBit(1)
+            .storeRef(message)
+            .endCell();
+    }
+    buildSupplyWithdrawOperationPayload(parameters) {
+        const isTon = (0, __1.isTonAsset)(parameters.supplyAsset);
+        const supplyData = (0, core_1.beginCell)();
+        if (isTon) {
+            supplyData.storeUint(parameters.supplyAmount, 64);
+        }
+        const withdrawData = (0, core_1.beginCell)()
+            .storeUint(parameters.withdrawAmount, 64)
+            .storeUint(parameters.withdrawAsset.assetId, 256)
+            .storeAddress(parameters.withdrawRecipient);
+        const generalData = this.buildGeneralDataPayload(parameters);
+        return (0, core_1.beginCell)().storeRef(supplyData).storeRef(withdrawData).storeRef(generalData).endCell();
+    }
+    // ---------- Public message builders (shared) ----------
+    createSupplyMessage(parameters) {
+        const subaccountId = parameters.subaccountId ?? 0;
+        const isTon = (0, __1.isTonAsset)(parameters.asset);
+        const operationPayload = (0, core_1.beginCell)()
+            .storeUint(general_1.OPCODES.SUPPLY_MASTER, 32)
+            .storeBuilder(isTon ? (0, core_1.beginCell)().storeUint(parameters.queryID, 64) : (0, core_1.beginCell)())
+            .storeInt(parameters.includeUserCode ? -1 : 0, 2)
+            .storeBuilder(isTon ? (0, core_1.beginCell)().storeUint(parameters.amount, 64) : (0, core_1.beginCell)())
+            .storeAddress(parameters.userAddress)
+            .storeRef(parameters.payload)
+            .storeInt(subaccountId, 16)
+            .storeInt(parameters.returnRepayRemainingsFlag ? -1 : 0, 2)
+            .storeAddress(parameters.customPayloadRecipient)
+            .storeInt(parameters.customPayloadSaturationFlag ? -1 : 0, 2)
+            .endCell();
+        if (!isTon) {
+            return this.createJettonTransferMessage(parameters, general_1.FEES.SUPPLY, operationPayload);
+        }
+        else {
+            return operationPayload;
+        }
+    }
+    // ---------- Sending operations ----------
+    async sendSupply(provider, via, value, parameters) {
+        const message = this.createSupplyMessage(parameters);
+        await this.sendTx(provider, via, value, message, parameters.asset);
+    }
+    async sendSupplyWithdraw(provider, via, value, parameters) {
+        const message = this.createSupplyWithdrawMessage(parameters);
+        await this.sendTx(provider, via, value, message, parameters.supplyAsset);
+    }
+    buildLiquidationInnerBuilder(parameters) {
+        const subaccountId = parameters.subaccountId ?? 0;
+        return (0, core_1.beginCell)()
+            .storeRef(parameters.payload)
+            .storeInt(subaccountId, 16)
+            .storeAddress(parameters.customPayloadRecipient)
+            .storeInt(parameters.customPayloadSaturationFlag ? -1 : 0, 2);
+    }
+    buildLiquidationOperationPayloadBuilder(parameters) {
+        return (0, core_1.beginCell)()
+            .storeAddress(parameters.borrowerAddress)
+            .storeUint(parameters.collateralAsset, 256)
+            .storeUint(parameters.minCollateralAmount, 64)
+            .storeInt(parameters.includeUserCode ? -1 : 0, 2)
+            .storeUint((0, __1.isTonAsset)(parameters.asset) ? parameters.liquidationAmount : 0, 64);
+    }
+    // ---------- Read helpers ----------
+    calculateUserSCAddr(userAddress, lendingCode, subaccountId = 0) {
+        const subaccount = (0, core_1.beginCell)();
+        if (subaccountId !== 0) {
+            if (!(0, __1.isValidSubaccountId)(subaccountId))
+                throw new Error('Invalid subaccount id');
+            subaccount.storeInt(subaccountId, 16);
+        }
+        const lendingData = (0, core_1.beginCell)()
+            .storeAddress(this.address)
+            .storeAddress(userAddress)
+            .storeUint(0, 8)
+            .storeBit(0)
+            .storeBuilder(subaccount)
+            .endCell();
+        const stateInit = (0, core_1.beginCell)()
+            .store((0, core_1.storeStateInit)({
+            code: lendingCode,
+            data: lendingData,
+        }))
+            .endCell();
+        return new core_1.Address(0, stateInit.hash());
+    }
+    openUserContract(userAddress, subaccountId = 0) {
+        return UserContract_1.EvaaUser.createFromAddress(this.calculateUserSCAddr(userAddress, this._poolConfig.lendingCode, subaccountId), this._poolConfig);
+    }
+    getOpenedUserContract(provider, userAddress, subaccountId = 0) {
+        return provider.open(this.openUserContract(userAddress, subaccountId));
+    }
+    async sendOnchainGetter(provider, via, value, queryID, forwardPayload) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
+            body: (0, core_1.beginCell)()
+                .storeUint(general_1.OPCODES.ONCHAIN_GETTER, 32)
+                .storeUint(queryID, 64)
+                .storeRef(forwardPayload)
+                .endCell(),
+        });
+    }
+    async sendTx(provider, via, value, message, asset) {
+        if (!(0, __1.isTonAsset)(asset)) {
+            if (!via.address)
+                throw new Error('Via address is required for jetton supply');
+            const jettonWallet = provider.open(JettonWallet_1.JettonWallet.createFromAddress((0, userJettonWallet_1.getUserJettonWallet)(via.address, asset)));
+            await jettonWallet.sendTransfer(via, value, message);
+        }
+        else {
+            await provider.internal(via, {
+                value,
+                sendMode: core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
+                body: message,
+            });
+        }
+    }
+    // Centralized sync logic used by concrete masters (Classic/Pyth)
+    async syncMasterData(provider, oracleParser) {
+        const state = (await provider.getState()).state;
+        if (state.type === 'active') {
+            this._data = (0, parser_1.parseMasterData)(state.data.toString('base64'), this._poolConfig.poolAssetsConfig, this._poolConfig.masterConstants, oracleParser);
+            if (this._data.upgradeConfig.masterCodeVersion !== this._poolConfig.masterVersion) {
+                throw Error(`Outdated SDK pool version. It supports only master code version ${this._poolConfig.masterVersion}, but the current master code version is ${this._data.upgradeConfig.masterCodeVersion}`);
+            }
+            this.lastSync = Math.floor(Date.now() / 1000);
+        }
+        else {
+            throw Error('Master contract is not active');
+        }
+    }
+}
+exports.AbstractEvaaMaster = AbstractEvaaMaster;

package/dist/contracts/ClassicMaster.d.ts

@@ -0,0 +1,34 @@
+import { Builder, Cell, ContractProvider, Sender } from '@ton/core';
+import { LiquidationParameters } from '..';
+import { ClassicOracleInfo } from '../api/parsers/ClassicOracleParser';
+import { AbstractEvaaMaster, BaseMasterConfig, BaseMasterData, EvaaParameters, LiquidationInnerParameters, LiquidationOperationBuilderParameters, SupplyWithdrawParameters, WithdrawParameters } from './AbstractMaster';
+export type ClassicSupplyWithdrawParameters = SupplyWithdrawParameters & {
+    priceData?: Cell;
+};
+/**
+ * Parameters for the withdraw message
+ * @property priceData - price data cell. Can be obtained from the getPrices function
+ */
+export type ClassicWithdrawParameters = WithdrawParameters & {
+    priceData: Cell;
+};
+export type ClassicLiquidationOperationParameters = LiquidationOperationBuilderParameters & LiquidationInnerParameters & {
+    priceData: Cell;
+};
+export type ClassicLiquidationParameters = LiquidationParameters & ClassicLiquidationOperationParameters;
+export type ClassicMasterConfig = BaseMasterConfig & {
+    oraclesInfo: ClassicOracleInfo;
+};
+export type ClassicMasterData = BaseMasterData & {
+    masterConfig: ClassicMasterConfig;
+};
+export declare class EvaaMasterClassic extends AbstractEvaaMaster<ClassicMasterData> {
+    constructor(parameters: EvaaParameters);
+    buildGeneralDataPayload(parameters: ClassicSupplyWithdrawParameters): Cell;
+    createSupplyWithdrawMessage(parameters: ClassicSupplyWithdrawParameters): Cell;
+    sendWithdraw(provider: ContractProvider, via: Sender, value: bigint, parameters: ClassicWithdrawParameters): Promise<void>;
+    protected buildLiquidationOperationPayload(parameters: ClassicLiquidationOperationParameters): Builder;
+    createLiquidationMessage(parameters: ClassicLiquidationParameters): Cell;
+    sendLiquidation(provider: ContractProvider, via: Sender, value: bigint, parameters: ClassicLiquidationParameters): Promise<void>;
+    getSync(provider: ContractProvider): Promise<void>;
+}

package/dist/contracts/ClassicMaster.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaaMasterClassic = void 0;
+const core_1 = require("@ton/core");
+const __1 = require("..");
+const ClassicOracleParser_1 = require("../api/parsers/ClassicOracleParser");
+const general_1 = require("../constants/general");
+const AbstractMaster_1 = require("./AbstractMaster");
+class EvaaMasterClassic extends AbstractMaster_1.AbstractEvaaMaster {
+    constructor(parameters) {
+        super(parameters);
+    }
+    buildGeneralDataPayload(parameters) {
+        return (0, core_1.beginCell)()
+            .storeInt(parameters.includeUserCode ? -1 : 0, 2)
+            .storeMaybeRef(parameters.priceData)
+            .storeUint(parameters.tonForRepayRemainings ?? 0n, 64)
+            .storeRef(parameters.payload)
+            .storeInt(parameters.subaccountId ?? 0, 16)
+            .storeInt(parameters.returnRepayRemainingsFlag ? -1 : 0, 2)
+            .storeInt(parameters.customPayloadSaturationFlag ? -1 : 0, 2)
+            .endCell();
+    }
+    createSupplyWithdrawMessage(parameters) {
+        const isTon = (0, __1.isTonAsset)(parameters.supplyAsset);
+        const operationPayload = this.buildSupplyWithdrawOperationPayload(parameters);
+        const refOpCode = parameters.priceData
+            ? general_1.OPCODES.SUPPLY_WITHDRAW_MASTER
+            : general_1.OPCODES.SUPPLY_WITHDRAW_MASTER_WITHOUT_PRICES;
+        if (!isTon) {
+            return this.createJettonTransferMessage(parameters, general_1.FEES.SUPPLY_WITHDRAW, (0, core_1.beginCell)().storeUint(refOpCode, 32).storeSlice(operationPayload.beginParse()).endCell());
+        }
+        else {
+            return (0, core_1.beginCell)()
+                .storeUint(refOpCode, 32)
+                .storeUint(parameters.queryID, 64)
+                .storeSlice(operationPayload.beginParse())
+                .endCell();
+        }
+    }
+    async sendWithdraw(provider, via, value, parameters) {
+        // Compatibility layer using supply-withdraw with TON zero supply
+        await this.sendSupplyWithdraw(provider, via, value, {
+            supplyAsset: __1.TON_MAINNET,
+            supplyAmount: 0n,
+            queryID: parameters.queryID,
+            withdrawAsset: parameters.asset,
+            withdrawAmount: parameters.amount,
+            withdrawRecipient: parameters.userAddress,
+            includeUserCode: parameters.includeUserCode,
+            forwardAmount: parameters.forwardAmount,
+            payload: parameters.payload,
+            subaccountId: parameters.subaccountId ?? 0,
+            customPayloadSaturationFlag: parameters.customPayloadSaturationFlag ?? false,
+            returnRepayRemainingsFlag: parameters.returnRepayRemainingsFlag ?? false,
+            tonForRepayRemainings: 0n,
+            priceData: parameters.priceData,
+        });
+    }
+    buildLiquidationOperationPayload(parameters) {
+        const operationPayloadBuilder = this.buildLiquidationOperationPayloadBuilder(parameters);
+        const innerBuilder = this.buildLiquidationInnerBuilder(parameters);
+        return operationPayloadBuilder.storeRef(innerBuilder).storeRef(parameters.priceData);
+    }
+    createLiquidationMessage(parameters) {
+        const isTon = (0, __1.isTonAsset)(parameters.asset);
+        const operationPayload = this.buildLiquidationOperationPayload(parameters);
+        if (!isTon) {
+            return this.createJettonTransferMessage(parameters, general_1.FEES.LIQUIDATION_JETTON_FWD, (0, core_1.beginCell)().storeUint(general_1.OPCODES.LIQUIDATE_MASTER, 32).storeBuilder(operationPayload).endCell());
+        }
+        else {
+            return (0, core_1.beginCell)()
+                .storeUint(general_1.OPCODES.LIQUIDATE_MASTER, 32)
+                .storeUint(parameters.queryID, 64)
+                .storeBuilder(operationPayload)
+                .endCell();
+        }
+    }
+    async sendLiquidation(provider, via, value, parameters) {
+        const message = this.createLiquidationMessage(parameters);
+        await this.sendTx(provider, via, value, message, parameters.asset);
+    }
+    async getSync(provider) {
+        await this.syncMasterData(provider, new ClassicOracleParser_1.ClassicOracleParser());
+    }
+}
+exports.EvaaMasterClassic = EvaaMasterClassic;

package/dist/contracts/PythMaster.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="node" />
+import { HexString } from '@pythnetwork/hermes-client';
+import { Address, Cell, ContractProvider, Dictionary, Sender } from '@ton/core';
+import { PythOracleInfo } from '../api/parsers/PythOracleParser';
+import { AbstractEvaaMaster, BaseMasterConfig, BaseMasterData, EvaaParameters, LiquidationInnerParameters, LiquidationOperationBuilderParameters, LiquidationParameters, SupplyWithdrawParameters, WithdrawParameters } from './AbstractMaster';
+/**
+ * pyth specific parameters
+ */
+export type PythBaseData = {
+    priceData: Buffer | Cell;
+    targetFeeds: HexString[];
+    requestedRefTokens: bigint[];
+};
+export type ProxySpecificPythParams = {
+    pythAddress: Address;
+    minPublishTime: number | bigint;
+    maxPublishTime: number | bigint;
+};
+export type OnchainSpecificPythParams = {
+    publishGap: number | bigint;
+    maxStaleness: number | bigint;
+};
+export type JettonPythParams = PythBaseData & OnchainSpecificPythParams;
+export type TonPythParams = PythBaseData & ProxySpecificPythParams;
+export type PythProxyParams = {
+    pyth: PythBaseData & (ProxySpecificPythParams | OnchainSpecificPythParams) & {
+        pythAddress: Address;
+    };
+};
+export type PythSupplyWithdrawParameters = SupplyWithdrawParameters & Partial<PythProxyParams>;
+export type PythWithdrawParameters = WithdrawParameters & {
+    pyth: TonPythParams;
+};
+export type PythLiquidationOperationParameters = LiquidationOperationBuilderParameters & LiquidationInnerParameters & PythProxyParams;
+export type PythLiquidationParameters = LiquidationParameters & PythLiquidationOperationParameters;
+export type PythMasterConfig = BaseMasterConfig & {
+    oraclesInfo: PythOracleInfo;
+};
+export type PythMasterData = BaseMasterData & {
+    masterConfig: PythMasterConfig;
+};
+export declare class EvaaMasterPyth extends AbstractEvaaMaster<PythMasterData> {
+    constructor(parameters: EvaaParameters);
+    protected buildPythMasterMessage(args: {
+        queryId: number | bigint;
+        opCode: number | bigint;
+        updateDataCell: Cell;
+        targetFeedsCell: Cell;
+        publishGap: number | bigint;
+        maxStaleness: number | bigint;
+    }, operationPayload: Cell): Cell;
+    protected buildPythProxyMessage(targetAddress: Address, priceUpdateData: Cell, targetPythFeeds: Cell, minPublishTime: number | bigint, maxPublishTime: number | bigint, operationPayload: Cell): Cell;
+    createSupplyWithdrawMessage(parameters: PythSupplyWithdrawParameters): Cell;
+    buildRefTokensDict(requestedRefTokens: bigint[]): Dictionary<bigint, Buffer>;
+    buildGeneralDataPayload(parameters: PythSupplyWithdrawParameters): Cell;
+    sendWithdraw(provider: ContractProvider, via: Sender, value: bigint, parameters: PythWithdrawParameters): Promise<void>;
+    protected buildLiquidationOperationPayload(parameters: PythLiquidationOperationParameters): Cell;
+    createLiquidationMessage(parameters: PythLiquidationParameters): Cell;
+    sendLiquidation(provider: ContractProvider, via: Sender, value: bigint, parameters: PythLiquidationParameters): Promise<void>;
+    getSync(provider: ContractProvider): Promise<void>;
+}

package/dist/contracts/PythMaster.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvaaMasterPyth = void 0;
+const core_1 = require("@ton/core");
+const PythOracleParser_1 = require("../api/parsers/PythOracleParser");
+const prices_1 = require("../api/prices");
+const constants_1 = require("../constants");
+const general_1 = require("../constants/general");
+const utils_1 = require("../utils/utils");
+const AbstractMaster_1 = require("./AbstractMaster");
+class EvaaMasterPyth extends AbstractMaster_1.AbstractEvaaMaster {
+    constructor(parameters) {
+        super(parameters);
+    }
+    buildPythMasterMessage(args, operationPayload) {
+        return (0, core_1.beginCell)()
+            .storeUint(args.opCode, 32)
+            .storeUint(args.queryId, 64)
+            .storeRef((0, core_1.beginCell)()
+            .storeRef(args.updateDataCell)
+            .storeRef(args.targetFeedsCell)
+            .storeUint(args.publishGap, 64)
+            .storeUint(args.maxStaleness, 64)
+            .endCell())
+            .storeRef(operationPayload)
+            .endCell();
+    }
+    buildPythProxyMessage(targetAddress, priceUpdateData, targetPythFeeds, minPublishTime, maxPublishTime, operationPayload) {
+        return (0, core_1.beginCell)()
+            .storeUint(5, 32) // pyth::op_parse_price_feed_updates
+            .storeRef(priceUpdateData)
+            .storeRef(targetPythFeeds)
+            .storeUint(minPublishTime, 64)
+            .storeUint(maxPublishTime, 64)
+            .storeAddress(targetAddress)
+            .storeRef(operationPayload)
+            .endCell();
+    }
+    // TODO: support without OPCODES.SUPPLY_WITHDRAW_MASTER_WITHOUT_PRICES
+    createSupplyWithdrawMessage(parameters) {
+        const operationPayload = this.buildSupplyWithdrawOperationPayload(parameters);
+        if (!(0, utils_1.isTonAsset)(parameters.supplyAsset)) {
+            const { priceData, targetFeeds, publishGap, maxStaleness } = parameters.pyth;
+            const masterMessage = this.buildPythMasterMessage({
+                queryId: parameters.queryID,
+                opCode: general_1.OPCODES.SUPPLY_WITHDRAW_MASTER_JETTON,
+                updateDataCell: (0, prices_1.packPythUpdatesData)(priceData),
+                targetFeedsCell: (0, prices_1.composeFeedsCell)(targetFeeds),
+                publishGap,
+                maxStaleness,
+            }, operationPayload);
+            return this.createJettonTransferMessage(parameters, general_1.FEES.SUPPLY_WITHDRAW, masterMessage);
+        }
+        else {
+            const { priceData, targetFeeds, minPublishTime, maxPublishTime } = parameters.pyth;
+            const wrappedOperationPayload = (0, core_1.beginCell)()
+                .storeUint(general_1.OPCODES.SUPPLY_WITHDRAW_MASTER, 32)
+                .storeUint(parameters.queryID, 64)
+                .storeRef(operationPayload)
+                .endCell();
+            return this.buildPythProxyMessage(this.address, (0, prices_1.packPythUpdatesData)(priceData), (0, prices_1.composeFeedsCell)(targetFeeds), minPublishTime, maxPublishTime, wrappedOperationPayload);
+        }
+    }
+    // private createPythWithdrawMessage(parameters: PythWithdrawParameters): Cell {
+    //     const extraTail =
+    //         (parameters.subaccountId ?? 0) == 0
+    //             ? beginCell().endCell()
+    //             : beginCell()
+    //                   .storeInt(parameters.subaccountId ?? 0, 16)
+    //                   .storeUint(0, 2)
+    //                   .endCell();
+    //     const wrappedOperationPayload = beginCell()
+    //         .storeUint(OPCODES.SUPPLY_WITHDRAW_MASTER, 32) // op_code: 0x4
+    //         .storeUint(parameters.queryID, 64)
+    //         .storeRef(
+    //             beginCell()
+    //                 .storeUint(parameters.asset.assetId, 256)
+    //                 .storeUint(parameters.amount, 64)
+    //                 .storeAddress(parameters.userAddress)
+    //                 .storeInt(parameters.includeUserCode ? -1 : 0, 2)
+    //                 .storeUint(parameters.amountToTransfer, 64)
+    //                 .storeRef(parameters.payload)
+    //                 .storeSlice(extraTail.beginParse())
+    //                 .endCell(),
+    //         )
+    //         .endCell();
+    //     const { priceData, targetFeeds, minPublishTime, maxPublishTime } = parameters.pyth as TonPythParams;
+    //     return makePythProxyMessage(
+    //         this.address,
+    //         packPythUpdatesData(priceData),
+    //         composeFeedsCell(targetFeeds),
+    //         minPublishTime,
+    //         maxPublishTime,
+    //         wrappedOperationPayload,
+    //     );
+    // }
+    buildRefTokensDict(requestedRefTokens) {
+        const refsDict = core_1.Dictionary.empty(core_1.Dictionary.Keys.BigUint(256), core_1.Dictionary.Values.Buffer(0));
+        for (const refToken of requestedRefTokens) {
+            refsDict.set(refToken, Buffer.alloc(0));
+        }
+        return refsDict;
+    }
+    buildGeneralDataPayload(parameters) {
+        const refTokensDict = this.buildRefTokensDict(parameters.pyth?.requestedRefTokens ?? []);
+        return (0, core_1.beginCell)()
+            .storeInt(parameters.includeUserCode ? -1 : 0, 2)
+            .storeDict(refTokensDict, core_1.Dictionary.Keys.BigUint(256), core_1.Dictionary.Values.Buffer(0))
+            .storeUint(parameters.tonForRepayRemainings ?? 0n, 64)
+            .storeRef(parameters.payload)
+            .storeInt(parameters.subaccountId ?? 0, 16)
+            .storeInt(parameters.returnRepayRemainingsFlag ? -1 : 0, 2)
+            .storeInt(parameters.customPayloadSaturationFlag ? -1 : 0, 2)
+            .endCell();
+    }
+    async sendWithdraw(provider, via, value, parameters) {
+        const message = this.createSupplyWithdrawMessage({
+            supplyAsset: constants_1.TON_MAINNET,
+            supplyAmount: 0n,
+            queryID: parameters.queryID,
+            withdrawAsset: parameters.asset,
+            withdrawAmount: parameters.amount,
+            withdrawRecipient: parameters.userAddress,
+            includeUserCode: parameters.includeUserCode,
+            forwardAmount: parameters.forwardAmount,
+            payload: parameters.payload,
+            subaccountId: parameters.subaccountId ?? 0,
+            customPayloadSaturationFlag: parameters.customPayloadSaturationFlag ?? false,
+            returnRepayRemainingsFlag: parameters.returnRepayRemainingsFlag ?? false,
+            tonForRepayRemainings: 0n,
+            pyth: parameters.pyth,
+        });
+        await via.send({
+            value,
+            to: parameters.pyth.pythAddress,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
+            body: message,
+        });
+    }
+    buildLiquidationOperationPayload(parameters) {
+        const operationPayloadBuilder = this.buildLiquidationOperationPayloadBuilder(parameters);
+        const innerBuilder = this.buildLiquidationInnerBuilder(parameters);
+        const refTokensDict = this.buildRefTokensDict(parameters.pyth.requestedRefTokens);
+        return operationPayloadBuilder.storeDict(refTokensDict).storeRef(innerBuilder).endCell();
+    }
+    createLiquidationMessage(parameters) {
+        const isTon = (0, utils_1.isTonAsset)(parameters.asset);
+        const operationPayload = this.buildLiquidationOperationPayload(parameters);
+        if (!isTon) {
+            const { priceData, targetFeeds, publishGap, maxStaleness } = parameters.pyth;
+            const masterMessage = this.buildPythMasterMessage({
+                queryId: parameters.queryID,
+                opCode: general_1.OPCODES.LIQUIDATE_MASTER,
+                updateDataCell: (0, prices_1.packPythUpdatesData)(priceData),
+                targetFeedsCell: (0, prices_1.composeFeedsCell)(targetFeeds),
+                publishGap,
+                maxStaleness,
+            }, operationPayload);
+            return this.createJettonTransferMessage(parameters, general_1.FEES.LIQUIDATION_JETTON_FWD, masterMessage);
+        }
+        else {
+            const { priceData, targetFeeds, minPublishTime, maxPublishTime } = parameters.pyth;
+            const wrappedOperationPayload = (0, core_1.beginCell)()
+                .storeUint(general_1.OPCODES.LIQUIDATE_MASTER, 32)
+                .storeUint(parameters.queryID, 64)
+                .storeRef(operationPayload)
+                .endCell();
+            return this.buildPythProxyMessage(this.address, (0, prices_1.packPythUpdatesData)(priceData), (0, prices_1.composeFeedsCell)(targetFeeds), minPublishTime, maxPublishTime, wrappedOperationPayload);
+        }
+    }
+    async sendLiquidation(provider, via, value, parameters) {
+        const message = this.createLiquidationMessage(parameters);
+        await this.sendTx(provider, via, value, message, parameters.asset);
+    }
+    async getSync(provider) {
+        await this.syncMasterData(provider, new PythOracleParser_1.PythOracleParser());
+    }
+}
+exports.EvaaMasterPyth = EvaaMasterPyth;

package/dist/contracts/UserContract.d.ts

@@ -1,7 +1,6 @@
 import { Address, Cell, Contract, ContractProvider, Dictionary, Sender } from '@ton/core';
-import { UserData, UserLiteData } from '../types/User';
 import { ExtendedAssetsConfig, ExtendedAssetsData, PoolConfig } from '../types/Master';
-import { LiquidationBaseData } from './MasterContract';
+import { UserData, UserLiteData } from '../types/User';
 /**
  * User contract wrapper
  */
@@ -48,9 +47,4 @@ export declare class EvaaUser implements Contract {
      * @returns true if user is liquidable
      */
     get isLiquidable(): boolean;
-    /**
-     * Get liquidation parameters for passing to liquidation message
-     * @returns liquidation parameters if user is liquidable, otherwise undefined
-     */
-    get liquidationParameters(): LiquidationBaseData | undefined;
 }

package/dist/contracts/UserContract.js

@@ -5,7 +5,6 @@ const core_1 = require("@ton/core");
 const parser_1 = require("../api/parser");
 const general_1 = require("../constants/general");
 const pools_1 = require("../constants/pools");
-const assets_1 = require("../constants/assets");
 /**
  * User contract wrapper
  */
@@ -57,7 +56,7 @@ class EvaaUser {
             value,
             sendMode: core_1.SendMode.PAY_GAS_SEPARATELY + core_1.SendMode.IGNORE_ERRORS,
             body: (0, core_1.beginCell)()
-                .storeCoins(BigInt(general_1.OPCODES.ONCHAIN_GETTER))
+                .storeUint(general_1.OPCODES.ONCHAIN_GETTER, 32)
                 .storeUint(queryID, 64)
                 .storeRef(forwardPayload)
                 .endCell(),
@@ -98,22 +97,5 @@ class EvaaUser {
         }
         return this._data.liquidationData.liquidable;
     }
-    /**
-     * Get liquidation parameters for passing to liquidation message
-     * @returns liquidation parameters if user is liquidable, otherwise undefined
-     */
-    get liquidationParameters() {
-        if (!this._data || this._data.type === 'inactive' || !this._data.liquidationData.liquidable) {
-            return undefined;
-        }
-        return {
-            borrowerAddress: this._data.ownerAddress,
-            loanAsset: this._data.liquidationData.greatestLoanAsset.assetId,
-            collateralAsset: this._data.liquidationData.greatestCollateralAsset.assetId,
-            minCollateralAmount: this._data.liquidationData.minCollateralAmount,
-            liquidationAmount: this._data.liquidationData.liquidationAmount,
-            tonLiquidation: this._data.liquidationData.greatestLoanAsset.assetId === assets_1.TON_MAINNET.assetId,
-        };
-    }
 }
 exports.EvaaUser = EvaaUser;

package/dist/contracts/index.d.ts

@@ -0,0 +1,5 @@
+export * from './AbstractMaster';
+export * from './ClassicMaster';
+export * from './PythMaster';
+export * from './UserContract';
+export * from './JettonWallet';

package/dist/contracts/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./AbstractMaster"), exports);
+__exportStar(require("./ClassicMaster"), exports);
+__exportStar(require("./PythMaster"), exports);
+__exportStar(require("./UserContract"), exports);
+__exportStar(require("./JettonWallet"), exports);