@evaafi/sdk 0.9.0 → 0.9.2-a

package/dist/contracts/AbstractMaster.d.ts

@@ -6,151 +6,184 @@ import { ExtendedAssetsConfig, ExtendedAssetsData, PoolAssetConfig, PoolConfig,
 import { ClassicLiquidationOperationParameters, ClassicLiquidationParameters, ClassicSupplyWithdrawParameters, ClassicWithdrawParameters } from './ClassicMaster';
 import { PythLiquidationOperationParameters, PythLiquidationParameters, PythSupplyWithdrawParameters, PythWithdrawParameters } from './PythMaster';
 import { EvaaUser } from './UserContract';
-type JettonParams = {
-    queryID: bigint;
-    amount?: bigint;
-    liquidationAmount?: bigint;
-    supplyAmount?: bigint;
-    responseAddress?: Address;
-    userAddress?: Address;
-    liquidatorAddress?: Address;
-    forwardAmount?: bigint;
-    destinationAddress?: Address;
-};
+export interface JettonParams {
+    readonly queryID: bigint;
+    readonly amount?: bigint;
+    readonly liquidationAmount?: bigint;
+    readonly supplyAmount?: bigint;
+    readonly responseAddress?: Address;
+    readonly userAddress?: Address;
+    readonly liquidatorAddress?: Address;
+    readonly forwardAmount?: bigint;
+    readonly destinationAddress?: Address;
+}
+type RequireAtLeastOne<T, K extends keyof T> = T & {
+    [P in K]: Required<T>[P];
+}[K];
+export type ValidJettonParams = RequireAtLeastOne<JettonParams, 'amount' | 'liquidationAmount' | 'supplyAmount'>;
 /**
- * Parameters for the Evaa contract
- * @property testnet - true for testnet, false for mainnet
- * @property debug - true to enable debug mode (optional)
+ * Parameters for initializing an Evaa contract instance
+ * @interface EvaaParameters
  */
-export type EvaaParameters = {
-    poolConfig: PoolConfig;
-    debug?: boolean;
-};
+export interface EvaaParameters {
+    /** Pool configuration containing contract addresses and settings */
+    readonly poolConfig: PoolConfig;
+    /** Optional debug mode flag for development purposes */
+    readonly 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
+ * Parameters for supply operations
+ * @interface SupplyParameters
  */
-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;
-};
+export interface SupplyParameters {
+    /** Asset configuration for the supply operation */
+    readonly asset: PoolAssetConfig;
+    /** Unique identifier for this operation */
+    readonly queryID: bigint;
+    /** Whether to include user contract code update */
+    readonly includeUserCode: boolean;
+    /** Amount to supply (must be positive) */
+    readonly amount: bigint;
+    /** Address of the user performing the supply */
+    readonly userAddress: Address;
+    /** Optional address for operation response */
+    readonly responseAddress?: Address;
+    /** Optional forward amount for transaction fees */
+    readonly forwardAmount?: bigint;
+    /** Operation payload cell */
+    readonly payload: Cell;
+    /** Optional subaccount identifier (0-255) */
+    readonly subaccountId?: number;
+    /** Whether to return repay remainings */
+    readonly returnRepayRemainingsFlag?: boolean;
+    /** Optional custom payload recipient address */
+    readonly customPayloadRecipient?: Address;
+    /** Whether to saturate custom payload */
+    readonly 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)
+ * Parameters for withdraw operations
+ * @interface WithdrawParameters
  */
-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;
-};
+export interface WithdrawParameters {
+    /** Unique identifier for this operation */
+    readonly queryID: bigint;
+    /** Amount to withdraw (must be positive) */
+    readonly amount: bigint;
+    /** Address of the user performing the withdrawal */
+    readonly userAddress: Address;
+    /** Whether to include user contract code update */
+    readonly includeUserCode: boolean;
+    /** Asset configuration for the withdrawal */
+    readonly asset: PoolAssetConfig;
+    /** Operation payload cell */
+    readonly payload: Cell;
+    /** Optional subaccount identifier (0-255) */
+    readonly subaccountId?: number;
+    /** Optional forward amount for transaction fees */
+    readonly forwardAmount?: bigint;
+    /** Actual amount to transfer after calculations */
+    readonly amountToTransfer: bigint;
+    /** Whether to saturate custom payload */
+    readonly customPayloadSaturationFlag: boolean;
+    /** Whether to return repay remainings */
+    readonly returnRepayRemainingsFlag: boolean;
+}
 /**
  * Parameters for liquidation inner operations
  * @interface LiquidationInnerParameters
  */
-export type LiquidationInnerParameters = {
+export interface LiquidationInnerParameters {
     /** Liquidation operation payload cell */
-    payload: Cell;
-    subaccountId: number;
-    customPayloadRecipient: Address;
-    customPayloadSaturationFlag: boolean;
-};
+    readonly payload: Cell;
+    /** Subaccount identifier for the operation */
+    readonly subaccountId: number;
+    /** Address to receive custom payload */
+    readonly customPayloadRecipient: Address;
+    /** Whether to saturate the custom payload */
+    readonly 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
+ * Base parameters for liquidation operations
+ * @interface LiquidationParameters
+ * @description Can be obtained from the user contract liquidationParameters getter
  */
-export type LiquidationParameters = {
-    loanAsset: bigint;
-    queryID: bigint;
-    liquidatorAddress: Address;
-};
+export interface LiquidationParameters {
+    /** Asset ID of the loan being liquidated */
+    readonly loanAsset: bigint;
+    /** Unique identifier for this operation */
+    readonly queryID: bigint;
+    /** Address where collateral will be sent upon liquidation */
+    readonly 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)
+ * Parameters for building liquidation operations
+ * @interface LiquidationOperationBuilderParameters
  */
-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;
-};
-export type BaseMasterConfig = {
-    ifActive: number;
-    admin: Address;
-    tokenKeys: Cell | null;
-    supervisor: Address | null;
-};
+export interface LiquidationOperationBuilderParameters {
+    /** Asset configuration for the liquidation */
+    readonly asset: PoolAssetConfig;
+    /** Address of the borrower being liquidated */
+    readonly borrowerAddress: Address;
+    /** Asset ID of the collateral to be seized */
+    readonly collateralAsset: bigint;
+    /** Minimum collateral amount expected from liquidation */
+    readonly minCollateralAmount: bigint;
+    /** Amount of debt to liquidate */
+    readonly liquidationAmount: bigint;
+    /** Whether to include user contract code update */
+    readonly includeUserCode: boolean;
+}
+export interface SupplyWithdrawParameters {
+    readonly queryID: bigint;
+    readonly supplyAmount: bigint;
+    readonly supplyAsset: PoolAssetConfig;
+    readonly withdrawAmount: bigint;
+    readonly withdrawAsset: PoolAssetConfig;
+    readonly withdrawRecipient: Address;
+    readonly includeUserCode: boolean;
+    readonly tonForRepayRemainings?: bigint;
+    readonly payload: Cell;
+    readonly subaccountId?: number;
+    readonly returnRepayRemainingsFlag?: boolean;
+    readonly customPayloadSaturationFlag?: boolean;
+    readonly forwardAmount?: bigint;
+    readonly responseAddress?: Address;
+}
+export interface BaseMasterConfig {
+    readonly ifActive: number;
+    readonly admin: Address;
+    readonly tokenKeys: Cell | null;
+    readonly supervisor: Address | null;
+}
 export type OracleInfo = PythOracleInfo | ClassicOracleInfo;
-export type MasterConfig<T extends OracleInfo> = BaseMasterConfig & {
-    oraclesInfo: T;
-};
-export type BaseMasterData = {
-    meta: string;
-    upgradeConfig: UpgradeConfig;
-    assetsConfig: ExtendedAssetsConfig;
-    assetsData: ExtendedAssetsData;
-    assetsReserves: Dictionary<bigint, bigint>;
-    apy: {
-        supply: Dictionary<bigint, number>;
-        borrow: Dictionary<bigint, number>;
+export interface MasterConfig<T extends OracleInfo> extends BaseMasterConfig {
+    readonly oraclesInfo: T;
+}
+export interface BaseMasterData {
+    readonly meta: string;
+    readonly upgradeConfig: UpgradeConfig;
+    readonly assetsConfig: ExtendedAssetsConfig;
+    readonly assetsData: ExtendedAssetsData;
+    readonly assetsReserves: Dictionary<bigint, bigint>;
+    readonly apy: {
+        readonly supply: Dictionary<bigint, number>;
+        readonly borrow: Dictionary<bigint, number>;
     };
-};
-export type MasterData<T extends MasterConfig<OracleInfo>> = BaseMasterData & {
-    masterConfig: T;
-};
+}
+export interface MasterData<T extends MasterConfig<OracleInfo>> extends BaseMasterData {
+    readonly 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.
+ * Abstract base class for EVAA Master contracts
+ *
+ * This class provides shared functionality for both Classic and Pyth master implementations,
+ * including message creation, validation, and transaction handling. Concrete implementations
+ * must override oracle-specific methods for withdraw/liquidation operations.
+ *
+ * @template T - Master data type extending MasterData with specific oracle configuration
+ * @abstract
+ * @implements {Contract}
  */
 export declare abstract class AbstractEvaaMaster<T extends MasterData<MasterConfig<OracleInfo>>> implements Contract {
     readonly address: Address;
@@ -158,14 +191,79 @@ export declare abstract class AbstractEvaaMaster<T extends MasterData<MasterConf
     protected readonly debug?: boolean;
     protected _data?: T;
     protected lastSync: number;
+    /**
+     * Initialize the abstract master contract
+     * @param parameters - Configuration parameters for the Evaa master
+     */
     constructor(parameters: EvaaParameters);
+    /**
+     * Get the current pool configuration
+     * @returns {PoolConfig} The pool configuration object
+     */
     get poolConfig(): PoolConfig;
+    /**
+     * Get the synchronized master data
+     * @returns {T | undefined} Master data if available, undefined otherwise
+     */
     get data(): T | undefined;
+    /**
+     * Validates jetton parameters ensuring at least one amount field is provided
+     * @private
+     * @static
+     * @param parameters - Jetton parameters to validate
+     * @returns {ValidJettonParams} Validated parameters
+     * @throws {Error} When no amount fields are provided
+     */
+    private static validateJettonParams;
+    /**
+     * Creates a jetton transfer message with the provided parameters
+     * @protected
+     * @param parameters - Jetton transfer parameters
+     * @param defaultFees - Default fee amount for the operation
+     * @param message - Operation message cell to include
+     * @returns {Cell} Complete jetton transfer message cell
+     * @throws {Error} When validation fails or required addresses are missing
+     */
     protected createJettonTransferMessage(parameters: JettonParams, defaultFees: bigint, message: Cell): Cell;
+    /**
+     * Builds general data payload for supply-withdraw operations
+     * @abstract
+     * @param parameters - Supply-withdraw parameters (oracle-specific)
+     * @returns {Cell} General data payload cell
+     */
     abstract buildGeneralDataPayload(parameters: PythSupplyWithdrawParameters | ClassicSupplyWithdrawParameters): Cell;
     protected buildSupplyWithdrawOperationPayload(parameters: PythSupplyWithdrawParameters | ClassicSupplyWithdrawParameters): Cell;
+    /**
+     * Validates supply operation parameters
+     * @private
+     * @static
+     * @param parameters - Supply parameters to validate
+     * @throws {Error} When amount is invalid or subaccount ID is out of range
+     */
+    private static validateSupplyParameters;
+    /**
+     * Creates a supply operation message
+     * @param parameters - Supply operation parameters
+     * @returns {Cell} Complete supply message cell
+     * @throws {Error} When validation fails
+     */
     createSupplyMessage(parameters: SupplyParameters): Cell;
+    /**
+     * Creates a supply-withdraw operation message
+     * @abstract
+     * @param parameters - Oracle-specific supply-withdraw parameters
+     * @returns {Cell} Complete supply-withdraw message cell
+     * @remarks Concrete classes must wrap the operation payload correctly for their oracle
+     */
     abstract createSupplyWithdrawMessage(parameters: ClassicSupplyWithdrawParameters | PythSupplyWithdrawParameters): Cell;
+    /**
+     * Sends a supply operation to the master contract
+     * @param provider - Contract provider instance
+     * @param via - Sender instance
+     * @param value - Transaction value in nanoTON
+     * @param parameters - Supply operation parameters
+     * @throws {Error} When validation fails or transaction fails
+     */
     sendSupply(provider: ContractProvider, via: Sender, value: bigint, parameters: SupplyParameters): Promise<void>;
     sendSupplyWithdraw(provider: ContractProvider, via: Sender, value: bigint, parameters: ClassicSupplyWithdrawParameters | PythSupplyWithdrawParameters): Promise<void>;
     abstract sendWithdraw(provider: ContractProvider, via: Sender, value: bigint, parameters: ClassicWithdrawParameters | PythWithdrawParameters): Promise<void>;
@@ -174,7 +272,21 @@ export declare abstract class AbstractEvaaMaster<T extends MasterData<MasterConf
     protected abstract buildLiquidationOperationPayload(parameters: PythLiquidationOperationParameters | ClassicLiquidationOperationParameters): Cell | Builder;
     protected buildLiquidationOperationPayloadBuilder(parameters: LiquidationOperationBuilderParameters): Builder;
     abstract sendLiquidation(provider: ContractProvider, via: Sender, value: bigint, parameters: ClassicLiquidationParameters | PythLiquidationParameters): Promise<void>;
+    /**
+     * Calculates the user smart contract address for a given user and subaccount
+     * @param userAddress - The user's wallet address
+     * @param lendingCode - The user contract code cell
+     * @param subaccountId - Optional subaccount identifier (default: 0)
+     * @returns {Address} The calculated user contract address
+     * @throws {Error} When subaccount ID is invalid
+     */
     calculateUserSCAddr(userAddress: Address, lendingCode: Cell, subaccountId?: number): Address;
+    /**
+     * Creates a user contract instance for the given address and subaccount
+     * @param userAddress - The user's wallet address
+     * @param subaccountId - Optional subaccount identifier (default: 0)
+     * @returns {EvaaUser} User contract instance
+     */
     openUserContract(userAddress: Address, subaccountId?: number): EvaaUser;
     getOpenedUserContract(provider: ContractProvider, userAddress: Address, subaccountId?: number): OpenedContract<EvaaUser>;
     sendOnchainGetter(provider: ContractProvider, via: Sender, value: bigint, queryID: bigint, forwardPayload: Cell): Promise<void>;

package/dist/contracts/AbstractMaster.js

@@ -9,38 +9,82 @@ 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.
+ * Abstract base class for EVAA Master contracts
+ *
+ * This class provides shared functionality for both Classic and Pyth master implementations,
+ * including message creation, validation, and transaction handling. Concrete implementations
+ * must override oracle-specific methods for withdraw/liquidation operations.
+ *
+ * @template T - Master data type extending MasterData with specific oracle configuration
+ * @abstract
+ * @implements {Contract}
  */
 class AbstractEvaaMaster {
+    /**
+     * Initialize the abstract master contract
+     * @param parameters - Configuration parameters for the Evaa master
+     */
     constructor(parameters) {
         this.lastSync = 0;
         this._poolConfig = parameters.poolConfig;
         this.address = this._poolConfig.masterAddress;
         this.debug = parameters?.debug;
     }
+    /**
+     * Get the current pool configuration
+     * @returns {PoolConfig} The pool configuration object
+     */
     get poolConfig() {
         return this._poolConfig;
     }
+    /**
+     * Get the synchronized master data
+     * @returns {T | undefined} Master data if available, undefined otherwise
+     */
     get data() {
         return this._data;
     }
-    // ---------- Common helpers ----------
-    createJettonTransferMessage(parameters, defaultFees, message) {
+    // ========== VALIDATION METHODS ==========
+    /**
+     * Validates jetton parameters ensuring at least one amount field is provided
+     * @private
+     * @static
+     * @param parameters - Jetton parameters to validate
+     * @returns {ValidJettonParams} Validated parameters
+     * @throws {Error} When no amount fields are provided
+     */
+    static validateJettonParams(parameters) {
         if (parameters.amount == undefined &&
             parameters.liquidationAmount == undefined &&
             parameters.supplyAmount == undefined) {
-            throw new Error('Either amount or liquidationAmount or supplyAmount must be provided');
+            throw new Error(`JettonParams validation failed: ${general_1.VALIDATION.ERRORS.MISSING_JETTON_AMOUNT}`);
+        }
+        return parameters;
+    }
+    /**
+     * Creates a jetton transfer message with the provided parameters
+     * @protected
+     * @param parameters - Jetton transfer parameters
+     * @param defaultFees - Default fee amount for the operation
+     * @param message - Operation message cell to include
+     * @returns {Cell} Complete jetton transfer message cell
+     * @throws {Error} When validation fails or required addresses are missing
+     */
+    createJettonTransferMessage(parameters, defaultFees, message) {
+        const validParams = AbstractEvaaMaster.validateJettonParams(parameters);
+        const amount = validParams.amount ?? validParams.liquidationAmount ?? validParams.supplyAmount ?? 0n;
+        const responseAddress = validParams.responseAddress ?? validParams.userAddress ?? validParams.liquidatorAddress;
+        if (!responseAddress) {
+            throw new Error(`JettonTransfer validation failed: ${general_1.VALIDATION.ERRORS.MISSING_RESPONSE_ADDRESS}`);
         }
         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)
+            .storeUint(validParams.queryID, 64)
+            .storeCoins(amount)
+            .storeAddress(validParams.destinationAddress ?? this.address)
+            .storeAddress(responseAddress)
             .storeBit(0)
-            .storeCoins(parameters.forwardAmount ?? defaultFees)
+            .storeCoins(validParams.forwardAmount ?? defaultFees)
             .storeBit(1)
             .storeRef(message)
             .endCell();
@@ -58,8 +102,27 @@ class AbstractEvaaMaster {
         const generalData = this.buildGeneralDataPayload(parameters);
         return (0, core_1.beginCell)().storeRef(supplyData).storeRef(withdrawData).storeRef(generalData).endCell();
     }
-    // ---------- Public message builders (shared) ----------
+    // ========== MESSAGE BUILDERS ==========
+    /**
+     * Validates supply operation parameters
+     * @private
+     * @static
+     * @param parameters - Supply parameters to validate
+     * @throws {Error} When amount is invalid or subaccount ID is out of range
+     */
+    static validateSupplyParameters(parameters) {
+        if (parameters.subaccountId !== undefined && !(0, __1.isValidSubaccountId)(parameters.subaccountId)) {
+            throw new Error(`Supply validation failed: ${general_1.VALIDATION.ERRORS.INVALID_SUBACCOUNT_ID}`);
+        }
+    }
+    /**
+     * Creates a supply operation message
+     * @param parameters - Supply operation parameters
+     * @returns {Cell} Complete supply message cell
+     * @throws {Error} When validation fails
+     */
     createSupplyMessage(parameters) {
+        AbstractEvaaMaster.validateSupplyParameters(parameters);
         const subaccountId = parameters.subaccountId ?? 0;
         const isTon = (0, __1.isTonAsset)(parameters.asset);
         const operationPayload = (0, core_1.beginCell)()
@@ -81,7 +144,15 @@ class AbstractEvaaMaster {
             return operationPayload;
         }
     }
-    // ---------- Sending operations ----------
+    // ========== TRANSACTION OPERATIONS ==========
+    /**
+     * Sends a supply operation to the master contract
+     * @param provider - Contract provider instance
+     * @param via - Sender instance
+     * @param value - Transaction value in nanoTON
+     * @param parameters - Supply operation parameters
+     * @throws {Error} When validation fails or transaction fails
+     */
     async sendSupply(provider, via, value, parameters) {
         const message = this.createSupplyMessage(parameters);
         await this.sendTx(provider, via, value, message, parameters.asset);
@@ -106,7 +177,15 @@ class AbstractEvaaMaster {
             .storeInt(parameters.includeUserCode ? -1 : 0, 2)
             .storeUint((0, __1.isTonAsset)(parameters.asset) ? parameters.liquidationAmount : 0, 64);
     }
-    // ---------- Read helpers ----------
+    // ========== CONTRACT INTERACTION HELPERS ==========
+    /**
+     * Calculates the user smart contract address for a given user and subaccount
+     * @param userAddress - The user's wallet address
+     * @param lendingCode - The user contract code cell
+     * @param subaccountId - Optional subaccount identifier (default: 0)
+     * @returns {Address} The calculated user contract address
+     * @throws {Error} When subaccount ID is invalid
+     */
     calculateUserSCAddr(userAddress, lendingCode, subaccountId = 0) {
         const subaccount = (0, core_1.beginCell)();
         if (subaccountId !== 0) {
@@ -129,6 +208,12 @@ class AbstractEvaaMaster {
             .endCell();
         return new core_1.Address(0, stateInit.hash());
     }
+    /**
+     * Creates a user contract instance for the given address and subaccount
+     * @param userAddress - The user's wallet address
+     * @param subaccountId - Optional subaccount identifier (default: 0)
+     * @returns {EvaaUser} User contract instance
+     */
     openUserContract(userAddress, subaccountId = 0) {
         return UserContract_1.EvaaUser.createFromAddress(this.calculateUserSCAddr(userAddress, this._poolConfig.lendingCode, subaccountId), this._poolConfig);
     }
@@ -167,12 +252,12 @@ class AbstractEvaaMaster {
         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}`);
+                throw new Error(`${general_1.VALIDATION.ERRORS.OUTDATED_SDK_VERSION}. SDK supports version ${this._poolConfig.masterVersion}, but contract version is ${this._data.upgradeConfig.masterCodeVersion}`);
             }
             this.lastSync = Math.floor(Date.now() / 1000);
         }
         else {
-            throw Error('Master contract is not active');
+            throw new Error(general_1.VALIDATION.ERRORS.MASTER_CONTRACT_INACTIVE);
         }
     }
 }

package/dist/contracts/ClassicMaster.d.ts

@@ -2,26 +2,26 @@ 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;
-};
+export interface ClassicSupplyWithdrawParameters extends SupplyWithdrawParameters {
+    readonly 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 interface ClassicWithdrawParameters extends WithdrawParameters {
+    readonly 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 interface ClassicMasterConfig extends BaseMasterConfig {
+    readonly oraclesInfo: ClassicOracleInfo;
+}
+export interface ClassicMasterData extends BaseMasterData {
+    readonly masterConfig: ClassicMasterConfig;
+}
 export declare class EvaaMasterClassic extends AbstractEvaaMaster<ClassicMasterData> {
     constructor(parameters: EvaaParameters);
     buildGeneralDataPayload(parameters: ClassicSupplyWithdrawParameters): Cell;