@evaafi/sdk 0.6.4 → 0.9.0-a

package/src/contracts/AbstractMaster.ts

@@ -0,0 +1,450 @@
+import {
+    Address,
+    beginCell,
+    Builder,
+    Cell,
+    Contract,
+    ContractProvider,
+    Dictionary,
+    OpenedContract,
+    Sender,
+    SendMode,
+    storeStateInit,
+} from '@ton/core';
+import { isTonAsset, isValidSubaccountId } from '..';
+import { parseMasterData } from '../api/parser';
+import { OracleParser } from '../api/parsers/AbstractOracleParser';
+import { ClassicOracleInfo } from '../api/parsers/ClassicOracleParser';
+import { PythOracleInfo } from '../api/parsers/PythOracleParser';
+import { FEES, OPCODES } from '../constants/general';
+import { ExtendedAssetsConfig, ExtendedAssetsData, PoolAssetConfig, PoolConfig, UpgradeConfig } from '../types/Master';
+import { getUserJettonWallet } from '../utils/userJettonWallet';
+import {
+    ClassicLiquidationOperationParameters,
+    ClassicLiquidationParameters,
+    ClassicSupplyWithdrawParameters,
+    ClassicWithdrawParameters,
+} from './ClassicMaster';
+import { JettonWallet } from './JettonWallet';
+import {
+    PythLiquidationOperationParameters,
+    PythLiquidationParameters,
+    PythSupplyWithdrawParameters,
+    PythWithdrawParameters,
+} from './PythMaster';
+import { EvaaUser } from './UserContract';
+
+// Internal
+type JettonParams = {
+    queryID: bigint;
+    amount?: bigint;
+    liquidationAmount?: bigint;
+    supplyAmount?: bigint;
+    responseAddress?: Address;
+    userAddress?: Address;
+    liquidatorAddress?: Address;
+    forwardAmount?: bigint;
+    destinationAddress?: Address;
+};
+
+/**
+ * Parameters for the Evaa contract
+ * @property testnet - true for testnet, false for mainnet
+ * @property debug - true to enable debug mode (optional)
+ */
+export type EvaaParameters = {
+    poolConfig: PoolConfig;
+    debug?: boolean;
+};
+
+/**
+ * Base parameters for supply
+ * @property queryID - unique query ID
+ * @property includeUserCode - true to include user code for update (needed when user contract code version is outdated)
+ * @property amount - amount to supply
+ * @property userAddress - user address
+ * @property asset
+ */
+export type SupplyParameters = {
+    asset: PoolAssetConfig;
+    queryID: bigint;
+    includeUserCode: boolean;
+    amount: bigint;
+    userAddress: Address;
+    responseAddress?: Address;
+    forwardAmount?: bigint;
+    payload: Cell;
+    subaccountId?: number;
+    returnRepayRemainingsFlag?: boolean;
+    customPayloadRecipient?: Address;
+    customPayloadSaturationFlag?: boolean;
+};
+
+/**
+ * Parameters for the withdraw message
+ * @property queryID - unique query ID
+ * @property asset - asset config
+ * @property amount - amount to withdraw
+ * @property userAddress - user address
+ * @property includeUserCode - true to include user code for update (needed when user contract code version is outdated)
+ */
+export type WithdrawParameters = {
+    queryID: bigint;
+    amount: bigint;
+    userAddress: Address;
+    includeUserCode: boolean;
+    asset: PoolAssetConfig;
+    payload: Cell;
+    subaccountId?: number;
+    forwardAmount?: bigint;
+    amountToTransfer: bigint;
+    customPayloadSaturationFlag: boolean;
+    returnRepayRemainingsFlag: boolean;
+};
+
+/**
+ * Parameters for liquidation inner operations
+ * @interface LiquidationInnerParameters
+ */
+export type LiquidationInnerParameters = {
+    /** Liquidation operation payload cell */
+    payload: Cell;
+    subaccountId: number;
+    customPayloadRecipient: Address;
+    customPayloadSaturationFlag: boolean;
+};
+
+/**
+ * Base data for liquidation. Can be obtained from the user contract liquidationParameters getter
+ * @property loanAsset - loan asset ID
+ * @property queryID - unique query ID
+ * @property liquidatorAddress - liquidator address, where and collateral will be sent
+ */
+export type LiquidationParameters = {
+    loanAsset: bigint;
+    queryID: bigint;
+    liquidatorAddress: Address;
+};
+
+/**
+ * @property asset - asset config
+ * @property borrowerAddress - borrower address (user address that is being liquidated)
+ * @property collateralAsset - collateral asset ID
+ * @property minCollateralAmount - minimal amount to receive from the liquidation
+ * @property liquidationAmount - amount to liquidate
+ * @property includeUserCode - true to include user code for update (needed when user contract code version is outdated)
+ */
+export type LiquidationOperationBuilderParameters = {
+    asset: PoolAssetConfig;
+    borrowerAddress: Address;
+    collateralAsset: bigint;
+    minCollateralAmount: bigint;
+    liquidationAmount: bigint;
+    includeUserCode: boolean;
+};
+
+export type SupplyWithdrawParameters = {
+    queryID: bigint;
+    supplyAmount: bigint;
+    supplyAsset: PoolAssetConfig;
+    withdrawAmount: bigint;
+    withdrawAsset: PoolAssetConfig;
+    withdrawRecipient: Address;
+    includeUserCode: boolean;
+    tonForRepayRemainings?: bigint;
+    payload: Cell;
+    subaccountId?: number;
+    returnRepayRemainingsFlag?: boolean;
+    customPayloadSaturationFlag?: boolean;
+    forwardAmount?: bigint;
+    responseAddress?: Address;
+};
+
+// Base shared configuration for all master types
+export type BaseMasterConfig = {
+    ifActive: number;
+    admin: Address;
+    tokenKeys: Cell | null;
+    supervisor: Address | null;
+};
+
+export type OracleInfo = PythOracleInfo | ClassicOracleInfo;
+
+// Generic master configuration with oracle info
+export type MasterConfig<T extends OracleInfo> = BaseMasterConfig & {
+    oraclesInfo: T;
+};
+
+// Base shared data for all master types
+export type BaseMasterData = {
+    meta: string;
+    upgradeConfig: UpgradeConfig;
+    assetsConfig: ExtendedAssetsConfig;
+    assetsData: ExtendedAssetsData;
+    assetsReserves: Dictionary<bigint, bigint>;
+    apy: {
+        supply: Dictionary<bigint, number>;
+        borrow: Dictionary<bigint, number>;
+    };
+};
+
+// Generic master data with config
+export type MasterData<T extends MasterConfig<OracleInfo>> = BaseMasterData & {
+    masterConfig: T;
+};
+
+/**
+ * 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.
+ */
+export abstract class AbstractEvaaMaster<T extends MasterData<MasterConfig<OracleInfo>>> implements Contract {
+    readonly address: Address;
+    protected _poolConfig: PoolConfig;
+    protected readonly debug?: boolean;
+    protected _data?: T;
+    protected lastSync = 0;
+
+    constructor(parameters: EvaaParameters) {
+        this._poolConfig = parameters.poolConfig;
+        this.address = this._poolConfig.masterAddress;
+        this.debug = parameters?.debug;
+    }
+
+    get poolConfig(): PoolConfig {
+        return this._poolConfig;
+    }
+
+    get data(): T | undefined {
+        return this._data;
+    }
+
+    // ---------- Common helpers ----------
+    protected createJettonTransferMessage(parameters: JettonParams, defaultFees: bigint, message: Cell): Cell {
+        if (
+            parameters.amount == undefined &&
+            parameters.liquidationAmount == undefined &&
+            parameters.supplyAmount == undefined
+        ) {
+            throw new Error('Either amount or liquidationAmount or supplyAmount must be provided');
+        }
+        return beginCell()
+            .storeUint(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();
+    }
+
+    abstract buildGeneralDataPayload(parameters: PythSupplyWithdrawParameters | ClassicSupplyWithdrawParameters): Cell;
+
+    protected buildSupplyWithdrawOperationPayload(
+        parameters: PythSupplyWithdrawParameters | ClassicSupplyWithdrawParameters,
+    ): Cell {
+        const isTon = isTonAsset(parameters.supplyAsset);
+
+        const supplyData = beginCell();
+        if (isTon) {
+            supplyData.storeUint(parameters.supplyAmount, 64);
+        }
+
+        const withdrawData = beginCell()
+            .storeUint(parameters.withdrawAmount, 64)
+            .storeUint(parameters.withdrawAsset.assetId, 256)
+            .storeAddress(parameters.withdrawRecipient);
+
+        const generalData = this.buildGeneralDataPayload(parameters);
+        return beginCell().storeRef(supplyData).storeRef(withdrawData).storeRef(generalData).endCell();
+    }
+
+    // ---------- Public message builders (shared) ----------
+    createSupplyMessage(parameters: SupplyParameters): Cell {
+        const subaccountId = parameters.subaccountId ?? 0;
+        const isTon = isTonAsset(parameters.asset);
+
+        const operationPayload = beginCell()
+            .storeUint(OPCODES.SUPPLY_MASTER, 32)
+            .storeBuilder(isTon ? beginCell().storeUint(parameters.queryID, 64) : beginCell())
+            .storeInt(parameters.includeUserCode ? -1 : 0, 2)
+            .storeBuilder(isTon ? beginCell().storeUint(parameters.amount, 64) : 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, FEES.SUPPLY, operationPayload);
+        } else {
+            return operationPayload;
+        }
+    }
+
+    // Concrete classes must wrap the operation payload correctly for their oracle
+    abstract createSupplyWithdrawMessage(
+        parameters: ClassicSupplyWithdrawParameters | PythSupplyWithdrawParameters,
+    ): Cell;
+
+    // ---------- Sending operations ----------
+    async sendSupply(provider: ContractProvider, via: Sender, value: bigint, parameters: SupplyParameters) {
+        const message = this.createSupplyMessage(parameters);
+
+        await this.sendTx(provider, via, value, message, parameters.asset);
+    }
+
+    async sendSupplyWithdraw(
+        provider: ContractProvider,
+        via: Sender,
+        value: bigint,
+        parameters: ClassicSupplyWithdrawParameters | PythSupplyWithdrawParameters,
+    ) {
+        const message = this.createSupplyWithdrawMessage(parameters);
+
+        await this.sendTx(provider, via, value, message, parameters.supplyAsset);
+    }
+
+    // Abstract where oracle path differs
+    abstract sendWithdraw(
+        provider: ContractProvider,
+        via: Sender,
+        value: bigint,
+        parameters: ClassicWithdrawParameters | PythWithdrawParameters,
+    ): Promise<void>;
+
+    abstract createLiquidationMessage(parameters: ClassicLiquidationParameters | PythLiquidationParameters): Cell;
+
+    protected buildLiquidationInnerBuilder(parameters: LiquidationInnerParameters): Builder {
+        const subaccountId = parameters.subaccountId ?? 0;
+
+        return beginCell()
+            .storeRef(parameters.payload)
+            .storeInt(subaccountId, 16)
+            .storeAddress(parameters.customPayloadRecipient)
+            .storeInt(parameters.customPayloadSaturationFlag ? -1 : 0, 2);
+    }
+
+    protected abstract buildLiquidationOperationPayload(
+        parameters: PythLiquidationOperationParameters | ClassicLiquidationOperationParameters,
+    ): Cell | Builder;
+
+    protected buildLiquidationOperationPayloadBuilder(parameters: LiquidationOperationBuilderParameters): Builder {
+        return beginCell()
+            .storeAddress(parameters.borrowerAddress)
+            .storeUint(parameters.collateralAsset, 256)
+            .storeUint(parameters.minCollateralAmount, 64)
+            .storeInt(parameters.includeUserCode ? -1 : 0, 2)
+            .storeUint(isTonAsset(parameters.asset) ? parameters.liquidationAmount : 0, 64);
+    }
+
+    abstract sendLiquidation(
+        provider: ContractProvider,
+        via: Sender,
+        value: bigint,
+        parameters: ClassicLiquidationParameters | PythLiquidationParameters,
+    ): Promise<void>;
+
+    // ---------- Read helpers ----------
+    calculateUserSCAddr(userAddress: Address, lendingCode: Cell, subaccountId: number = 0): Address {
+        const subaccount = beginCell();
+        if (subaccountId !== 0) {
+            if (!isValidSubaccountId(subaccountId)) throw new Error('Invalid subaccount id');
+            subaccount.storeInt(subaccountId, 16);
+        }
+
+        const lendingData = beginCell()
+            .storeAddress(this.address)
+            .storeAddress(userAddress)
+            .storeUint(0, 8)
+            .storeBit(0)
+            .storeBuilder(subaccount)
+            .endCell();
+
+        const stateInit = beginCell()
+            .store(
+                storeStateInit({
+                    code: lendingCode,
+                    data: lendingData,
+                }),
+            )
+            .endCell();
+
+        return new Address(0, stateInit.hash());
+    }
+
+    openUserContract(userAddress: Address, subaccountId: number = 0): EvaaUser {
+        return EvaaUser.createFromAddress(
+            this.calculateUserSCAddr(userAddress, this._poolConfig.lendingCode, subaccountId),
+            this._poolConfig,
+        );
+    }
+
+    getOpenedUserContract(
+        provider: ContractProvider,
+        userAddress: Address,
+        subaccountId: number = 0,
+    ): OpenedContract<EvaaUser> {
+        return provider.open(this.openUserContract(userAddress, subaccountId));
+    }
+
+    async sendOnchainGetter(
+        provider: ContractProvider,
+        via: Sender,
+        value: bigint,
+        queryID: bigint,
+        forwardPayload: Cell,
+    ) {
+        await provider.internal(via, {
+            value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY + SendMode.IGNORE_ERRORS,
+            body: beginCell()
+                .storeUint(OPCODES.ONCHAIN_GETTER, 32)
+                .storeUint(queryID, 64)
+                .storeRef(forwardPayload)
+                .endCell(),
+        });
+    }
+
+    async sendTx(provider: ContractProvider, via: Sender, value: bigint, message: Cell, asset: PoolAssetConfig) {
+        if (!isTonAsset(asset)) {
+            if (!via.address) throw new Error('Via address is required for jetton supply');
+            const jettonWallet = provider.open(JettonWallet.createFromAddress(getUserJettonWallet(via.address, asset)));
+            await jettonWallet.sendTransfer(via, value, message);
+        } else {
+            await provider.internal(via, {
+                value,
+                sendMode: SendMode.PAY_GAS_SEPARATELY + SendMode.IGNORE_ERRORS,
+                body: message,
+            });
+        }
+    }
+
+    // Centralized sync logic used by concrete masters (Classic/Pyth)
+    protected async syncMasterData(provider: ContractProvider, oracleParser: OracleParser): Promise<void> {
+        const state = (await provider.getState()).state;
+        if (state.type === 'active') {
+            this._data = parseMasterData(
+                state.data!.toString('base64'),
+                this._poolConfig.poolAssetsConfig,
+                this._poolConfig.masterConstants,
+                oracleParser,
+            ) as T;
+            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');
+        }
+    }
+
+    protected abstract getSync(provider: ContractProvider): Promise<void>;
+}

package/src/contracts/ClassicMaster.ts

@@ -0,0 +1,149 @@
+import { beginCell, Builder, Cell, ContractProvider, Sender } from '@ton/core';
+import { isTonAsset, LiquidationParameters, TON_MAINNET } from '..';
+import { ClassicOracleInfo, ClassicOracleParser } from '../api/parsers/ClassicOracleParser';
+import { FEES, OPCODES } from '../constants/general';
+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 class EvaaMasterClassic extends AbstractEvaaMaster<ClassicMasterData> {
+    constructor(parameters: EvaaParameters) {
+        super(parameters);
+    }
+
+    buildGeneralDataPayload(parameters: ClassicSupplyWithdrawParameters): Cell {
+        return 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: ClassicSupplyWithdrawParameters): Cell {
+        const isTon = isTonAsset(parameters.supplyAsset);
+
+        const operationPayload = this.buildSupplyWithdrawOperationPayload(parameters);
+
+        const refOpCode = parameters.priceData
+            ? OPCODES.SUPPLY_WITHDRAW_MASTER
+            : OPCODES.SUPPLY_WITHDRAW_MASTER_WITHOUT_PRICES;
+
+        if (!isTon) {
+            return this.createJettonTransferMessage(
+                parameters,
+                FEES.SUPPLY_WITHDRAW,
+                beginCell().storeUint(refOpCode, 32).storeSlice(operationPayload.beginParse()).endCell(),
+            );
+        } else {
+            return beginCell()
+                .storeUint(refOpCode, 32)
+                .storeUint(parameters.queryID, 64)
+                .storeSlice(operationPayload.beginParse())
+                .endCell();
+        }
+    }
+
+    async sendWithdraw(
+        provider: ContractProvider,
+        via: Sender,
+        value: bigint,
+        parameters: ClassicWithdrawParameters,
+    ): Promise<void> {
+        // Compatibility layer using supply-withdraw with TON zero supply
+        await this.sendSupplyWithdraw(provider, via, value, {
+            supplyAsset: 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,
+        });
+    }
+
+    protected buildLiquidationOperationPayload(parameters: ClassicLiquidationOperationParameters): Builder {
+        const operationPayloadBuilder = this.buildLiquidationOperationPayloadBuilder(parameters);
+        const innerBuilder = this.buildLiquidationInnerBuilder(parameters);
+
+        return operationPayloadBuilder.storeRef(innerBuilder).storeRef(parameters.priceData);
+    }
+
+    createLiquidationMessage(parameters: ClassicLiquidationParameters): Cell {
+        const isTon = isTonAsset(parameters.asset);
+        const operationPayload = this.buildLiquidationOperationPayload(parameters);
+
+        if (!isTon) {
+            return this.createJettonTransferMessage(
+                parameters,
+                FEES.LIQUIDATION_JETTON_FWD,
+                beginCell().storeUint(OPCODES.LIQUIDATE_MASTER, 32).storeBuilder(operationPayload).endCell(),
+            );
+        } else {
+            return beginCell()
+                .storeUint(OPCODES.LIQUIDATE_MASTER, 32)
+                .storeUint(parameters.queryID, 64)
+                .storeBuilder(operationPayload)
+                .endCell();
+        }
+    }
+
+    async sendLiquidation(
+        provider: ContractProvider,
+        via: Sender,
+        value: bigint,
+        parameters: ClassicLiquidationParameters,
+    ): Promise<void> {
+        const message = this.createLiquidationMessage(parameters);
+
+        await this.sendTx(provider, via, value, message, parameters.asset);
+    }
+
+    async getSync(provider: ContractProvider) {
+        await this.syncMasterData(provider, new ClassicOracleParser());
+    }
+}