@evaafi/sdk 0.6.2 → 0.6.3-b

package/src/constants/general.ts

@@ -1,7 +1,6 @@
 import { Address, Cell, toNano } from '@ton/core';
 import { OracleNFT } from '../types/Master';
 
-
 const ASSET_PRICE_SCALE = BigInt(1e9);
 
 export const MASTER_CONSTANTS = {
@@ -22,13 +21,20 @@ export const NULL_ADDRESS = Address.parse('UQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
 
 export const EVAA_MASTER_MAINNET = Address.parse('EQC8rUZqR_pWV1BylWUlPNBzyiTYVoBEmQkMIQDZXICfnuRr');
 export const MAINNET_VERSION = 6;
-export const EVAA_MASTER_TESTNET = Address.parse('EQDLsg3w-iBj26Gww7neYoJAxiT2t77Zo8ro56b0yuHsPp3C');
+export const EVAA_MASTER_TESTNET = Address.parse('kQBae_Pt-NcxX0yhNnsYyK-Kh6ZBnIUQhxheKTvNLTgZf7AV');
 export const TESTNET_VERSION = 0;
 export const EVAA_LP_MAINNET = Address.parse('EQBIlZX2URWkXCSg3QF2MJZU-wC5XkBoLww-hdWk2G37Jc6N');
 export const EVAA_LP_MAINNET_VERSION = 3;
 export const EVAA_ALTS_MAINNET = Address.parse('EQANURVS3fhBO9bivig34iyJQi97FhMbpivo1aUEAS2GYSu-');
 export const EVAA_ALTS_MAINNET_VERSION = 0;
 
+export const EVAA_ETHENA_MAINNET = Address.parse('EQCn95X_qLJa5VUXfyIQkWDH2iq3PTatsO4esunMaIsnyyeW');
+export const EVAA_ETHENA_VERSION = 0;
+
+export const EVAA_REWARDS_MASTER_TESTNET = Address.parse('EQCnp0iRGcfDJAvnKhAEN9sB-nPYSPuc83Ff4y75s8AtoSW1');
+export const EVAA_USDT_REWARDS_MASTER_MAINNET = Address.parse('EQD22Fhylp1tX-xoVX81aMTSJNPV8j9klwApTLgjGmofISVD');
+export const EVAA_TON_REWARDS_MASTER_MAINNET = Address.parse('EQDM_gdrntBg4fy5Rg9DgDF0AUu3FYoqxHEOsHNIC4_DTDuC');
+
 export const ORACLES_MAINNET: OracleNFT[] = [
     {id: 0, address: '0xd3a8c0b9fd44fd25a49289c631e3ac45689281f2f8cf0744400b4c65bed38e5d', pubkey: Buffer.from('b404f4a2ebb62f2623b370c89189748a0276c071965b1646b996407f10d72eb9', 'hex') }, 
     {id: 1, address: '0x2c21cabdaa89739de16bde7bc44e86401fac334a3c7e55305fe5e7563043e191', pubkey: Buffer.from('9ad115087520d91b6b45d6a8521eb4616ee6914af07fabdc2e9d1826dbb17078', 'hex') },
@@ -54,12 +60,32 @@ export const JETTON_WALLET_STANDART_CODE = Cell.fromBase64(
 export const JETTON_WALLET_STANDART_CODE_TESTNET = Cell.fromBase64(
     'te6cckECEQEAAyMAART/APSkE/S88sgLAQIBYgIDAgLMBAUAG6D2BdqJofQB9IH0gahhAgHUBgcCASAICQDDCDHAJJfBOAB0NMDAXGwlRNfA/AM4PpA+kAx+gAxcdch+gAx+gAwc6m0AALTH4IQD4p+pVIgupUxNFnwCeCCEBeNRRlSILqWMUREA/AK4DWCEFlfB7y6k1nwC+BfBIQP8vCAAET6RDBwuvLhTYAIBIAoLAIPUAQa5D2omh9AH0gfSBqGAJpj8EIC8aijKkQXUEIPe7L7wndCVj5cWLpn5j9ABgJ0CgR5CgCfQEsZ4sA54tmZPaqQB8VA9M/+gD6QCHwAe1E0PoA+kD6QNQwUTahUirHBfLiwSjC//LiwlQ0QnBUIBNUFAPIUAT6AljPFgHPFszJIsjLARL0APQAywDJIPkAcHTIywLKB8v/ydAE+kD0BDH6ACDXScIA8uLEd4AYyMsFUAjPFnD6AhfLaxPMgMAgEgDQ4AnoIQF41FGcjLHxnLP1AH+gIizxZQBs8WJfoCUAPPFslQBcwjkXKRceJQCKgToIIJycOAoBS88uLFBMmAQPsAECPIUAT6AljPFgHPFszJ7VQC9ztRND6APpA+kDUMAjTP/oAUVGgBfpA+kBTW8cFVHNtcFQgE1QUA8hQBPoCWM8WAc8WzMkiyMsBEvQA9ADLAMn5AHB0yMsCygfL/8nQUA3HBRyx8uLDCvoAUaihggiYloBmtgihggiYloCgGKEnlxBJEDg3XwTjDSXXCwGAPEADXO1E0PoA+kD6QNQwB9M/+gD6QDBRUaFSSccF8uLBJ8L/8uLCBYIJMS0AoBa88uLDghB73ZfeyMsfFcs/UAP6AiLPFgHPFslxgBjIywUkzxZw+gLLaszJgED7AEATyFAE+gJYzxYBzxbMye1UgAHBSeaAYoYIQc2LQnMjLH1Iwyz9Y+gJQB88WUAfPFslxgBDIywUkzxZQBvoCFctqFMzJcfsAECQQIwB8wwAjwgCwjiGCENUydttwgBDIywVQCM8WUAT6AhbLahLLHxLLP8ly+wCTNWwh4gPIUAT6AljPFgHPFszJ7VSV6u3X');
 
+export const EVAA_REWARDS_MASTER_CODE_TESTNET = Cell.fromBoc(
+    Buffer.from(
+        'b5ee9c7241020e01000386000114ff00f4a413f4bcf2c80b01020162020b046ad03322c700925f03e0d0d3030171b0925f03e0fa403002d31fd33f715230bae302725230bae30282107362d09c5230bae3027413ba0304070800c46c21ed44d0fa40fa00fa40d4d401d001d1fa40d3ffd3ffd11034102307fa40308103e8820afaf0801abe19f2f48103ea5196c70519f2f48103ee8b0212c705f2f41036453304c85004cf16cbff12cbffc9c85005cf165003fa0258cf16ccccc9ed5402fe6c22ed44d0fa40fa00fa40d4d401d001d1fa40d3ffd3ffd11034102307fa40fa003021ed44d0fa40fa00fa40d4d401d001d1fa40d3ffd3ffd11034102335355bc8f828cf1613cbffcbffc9c85003cf1670fa0212ccc97020c8cb0113f400f400cb00c9f9007074c8cb02ca07cbffc9d08103ea51c1c7051cf2f45306bce302050600466c810173c8cb1fcb3f01fa02c9718018c8cb055003cf1670fa0212cb6accc98040fb0001d23a8b3544f4e8f9025220ba8e16385288708018c8cb0558cf1658fa02cb6ac98040fb008e3b22544a030a702082100f8a7ea5c8cb1f13cb3f5004fa0222cf1658cf16cb0021fa02cb1fc9718018c8cb055003cf1670fa0212cb6accc98040fb00e25037a110365e40010a00ec6c21ed44d0fa40fa00fa40d4d401d001d1fa40d3ffd3ffd1103410238103e8820afaf08052a0bef2f48b3544f4e8f9025220ba993738068209c9c380a18e11388103ea5192c70519f2f405fa00301056e213a010364515503304c85004cf16cbff12cbffc9c85005cf165003fa0258cf16ccccc9ed5402ea8f6ced44d0fa40fa00fa40d4d401d001d1fa40d3ffd3ffd11034102308fa40fa00308103e8821005f5e1001cbe1bf2f48103ea51b7c7051bf2f48103ed5395bbf2f48b3544f4e8f9025210ba8e16365279708018c8cb0558cf1658fa02cb6ac98040fb00e30e5026a14615503304e05f04840ff2f0090a00745468281b702082100f8a7ea5c8cb1f13cb3f5004fa0222cf1658cf16cb0021fa02cb1fc9718018c8cb055003cf1670fa0212cb6accc98040fb000038c85004cf16cbff12cbffc9c85005cf165003fa0258cf16ccccc9ed540201580c0d0039bbc24ed44d0fa40fa00fa40d4d401d001d1fa40d3ffd3ffd1103410238009fb87b6ed44d0fa40fa00fa40d4d401d001d1fa40d3ffd3ffd11034102335355bc8f828cf1613cbffcbffc9c85003cf1670fa0212ccc97020c8cb0113f400f400cb00c9f9007074c8cb02ca07cbffc9d0872ac1c8c',
+        'hex',
+    ),
+)[0];
+export const EVAA_REWARDS_MASTER_CODE_MAINNET = EVAA_REWARDS_MASTER_CODE_TESTNET;
+
+export const EVAA_REWARDS_USER_CODE_TESTNET = Cell.fromBoc(
+    Buffer.from(
+        'b5ee9c724102060100014e000114ff00f4a413f4bcf2c80b01020162020502f8d03322c700925f03e0d0d3030171b0925f03e0fa403002d31fd33f725230ba8ed63233ed44d0fa40fa00d401d001d1fa40d3ffd3ffd1058308d718d430d08103e8821005f5e10019be18f2f48103e927f901541027f910f2f405fa40fa00308103eaf82813c70512f2f48103ec5313bcf2f45203a15006e0313273ba030400b8ed44d0fa40fa00d401d001d1fa40d3ffd3ffd110235f0372c8cb1f13cb3f01cf1658fa02c9718018c8cb055003cf1670fa0212cb6accc9820a625a0070fb02810080fb005521c85003cf16cbffcbffc9c85003cf1601fa02ccc9ed5400888e3ced44d0fa40fa00d401d001d1fa40d3ffd3ffd105fa00308103ea5173c70517f2f45025a14143c85003cf16cbffcbffc9c85003cf1601fa02ccc9ed54e05b840ff2f0002ba17849da89a1f481f401a803a003a3f481a7ffa7ffa333f41908',
+        'hex',
+    ),
+)[0];
+export const EVAA_REWARDS_USER_CODE_MAINNET = EVAA_REWARDS_USER_CODE_TESTNET;
+
 export const OPCODES = {
     SUPPLY: 0x1,
     WITHDRAW: 0x2,
     LIQUIDATE: 0x3,
     JETTON_TRANSFER: 0xf8a7ea5,
     ONCHAIN_GETTER: 0x9998,
+    REWARD_CLAIM: 0x2,
+    REWARD_TON_TOP_UP: 0x7362d09c,
+    REWARD_JETTON_MINT: 0x178d4519,
+    REWARD_JETTON_TRANSFER: 0x0f8a7ea5,
 };
 
 export const FEES = {
@@ -70,4 +96,9 @@ export const FEES = {
     LIQUIDATION: toNano('0.8'),
     LIQUIDATION_JETTON: toNano('1'),
     LIQUIDATION_JETTON_FWD: toNano('0.8'),
+    REWARD_MASTER_TON_TOP_UP: toNano('0.03'),
+    REWARD_MASTER_DEPLOY: toNano('0.05'),
+    REWARD_MASTER_WITHDRAW: toNano('0.1'),
+    REWARD_USER_DEPLOY: toNano('0.05'),
+    REWARD_USER_CLAIM: toNano('0.1'),
 };

package/src/constants/pools.ts

@@ -1,6 +1,50 @@
-import { CATI_MAINNET, DOGS_MAINNET, JUSDC_MAINNET, JUSDC_TESTNET, JUSDT_MAINNET, JUSDT_TESTNET, NOT_MAINNET, STTON_MAINNET, STTON_TESTNET, TON_MAINNET, TON_STORM_MAINNET, TONUSDT_DEDUST_MAINNET, TSTON_MAINNET, USDT_MAINNET, USDT_STORM_MAINNET, UTON_MAINNET } from "./assets";
-import { PoolConfig } from "../types/Master";
-import { EVAA_MASTER_MAINNET, EVAA_MASTER_TESTNET, LENDING_CODE, MAINNET_VERSION, MASTER_CONSTANTS, TESTNET_VERSION, EVAA_LP_MAINNET, EVAA_LP_MAINNET_VERSION, ORACLES_MAINNET, ORACLES_LP, ORACLES_TESTNET, EVAA_ALTS_MAINNET, EVAA_ALTS_MAINNET_VERSION, ORACLES_ALTS } from "./general";
+import { Address } from '@ton/core';
+import { PoolConfig } from '../types/Master';
+import { EvaaRewardsConfig } from '../types/MasterRewards';
+import {
+    CATI_MAINNET,
+    DOGS_MAINNET,
+    EUSDT_TESTNET,
+    JUSDC_MAINNET,
+    JUSDT_MAINNET,
+    NOT_MAINNET,
+    STTON_MAINNET,
+    TGBTC_TESTNET,
+    TON_MAINNET,
+    TON_STORM_MAINNET,
+    TON_TESTNET,
+    TONUSDT_DEDUST_MAINNET,
+    TSTON_MAINNET,
+    TSUSDE_MAINNET,
+    USDE_MAINNET,
+    USDT_MAINNET,
+    USDT_STORM_MAINNET,
+} from './assets';
+import {
+    EVAA_ALTS_MAINNET,
+    EVAA_ALTS_MAINNET_VERSION,
+    EVAA_ETHENA_MAINNET,
+    EVAA_ETHENA_VERSION,
+    EVAA_LP_MAINNET,
+    EVAA_LP_MAINNET_VERSION,
+    EVAA_MASTER_MAINNET,
+    EVAA_MASTER_TESTNET,
+    EVAA_REWARDS_MASTER_CODE_MAINNET,
+    EVAA_REWARDS_MASTER_CODE_TESTNET,
+    EVAA_REWARDS_MASTER_TESTNET,
+    EVAA_REWARDS_USER_CODE_MAINNET,
+    EVAA_REWARDS_USER_CODE_TESTNET,
+    EVAA_TON_REWARDS_MASTER_MAINNET,
+    EVAA_USDT_REWARDS_MASTER_MAINNET,
+    LENDING_CODE,
+    MAINNET_VERSION,
+    MASTER_CONSTANTS,
+    ORACLES_ALTS,
+    ORACLES_LP,
+    ORACLES_MAINNET,
+    ORACLES_TESTNET,
+    TESTNET_VERSION,
+} from './general';
 
 export const MAINNET_POOL_CONFIG: PoolConfig = {
     masterAddress: EVAA_MASTER_MAINNET,
@@ -15,9 +59,24 @@ export const MAINNET_POOL_CONFIG: PoolConfig = {
         STTON_MAINNET,
         TSTON_MAINNET,
         USDT_MAINNET,
-        UTON_MAINNET // announce
+        USDE_MAINNET,
+        TSUSDE_MAINNET,
+        // UTON_MAINNET // announce xdddd fake announce 
     ],
-    lendingCode: LENDING_CODE
+    lendingCode: LENDING_CODE,
+};
+
+export const MAINNET_TEST_ETHENA_POOL_CONFIG: PoolConfig = {
+    masterAddress: EVAA_ETHENA_MAINNET,
+    masterVersion: EVAA_ETHENA_VERSION,
+    masterConstants: MASTER_CONSTANTS,
+    oracles: ORACLES_MAINNET,
+    minimalOracles: 3,
+    poolAssetsConfig: [
+        TON_MAINNET,
+        USDE_MAINNET,
+    ],
+    lendingCode: LENDING_CODE,
 };
 
 export const TESTNET_POOL_CONFIG: PoolConfig = {
@@ -26,13 +85,8 @@ export const TESTNET_POOL_CONFIG: PoolConfig = {
     masterConstants: MASTER_CONSTANTS,
     oracles: ORACLES_TESTNET,
     minimalOracles: 3,
-    poolAssetsConfig: [
-        TON_MAINNET,
-        JUSDT_TESTNET,
-        JUSDC_TESTNET,
-        STTON_TESTNET
-    ],
-    lendingCode: LENDING_CODE
+    poolAssetsConfig: [TON_TESTNET, TGBTC_TESTNET],
+    lendingCode: LENDING_CODE,
 };
 
 export const MAINNET_LP_POOL_CONFIG: PoolConfig = {
@@ -41,14 +95,8 @@ export const MAINNET_LP_POOL_CONFIG: PoolConfig = {
     masterConstants: MASTER_CONSTANTS,
     oracles: ORACLES_LP,
     minimalOracles: 3,
-    poolAssetsConfig: [
-        TON_MAINNET,
-        USDT_MAINNET,
-        TONUSDT_DEDUST_MAINNET,
-        TON_STORM_MAINNET,
-        USDT_STORM_MAINNET
-    ],
-    lendingCode: LENDING_CODE
+    poolAssetsConfig: [TON_MAINNET, USDT_MAINNET, TONUSDT_DEDUST_MAINNET, TON_STORM_MAINNET, USDT_STORM_MAINNET],
+    lendingCode: LENDING_CODE,
 };
 
 export const MAINNET_ALTS_POOL_CONFIG: PoolConfig = {
@@ -57,12 +105,46 @@ export const MAINNET_ALTS_POOL_CONFIG: PoolConfig = {
     masterConstants: MASTER_CONSTANTS,
     oracles: ORACLES_ALTS,
     minimalOracles: 3,
-    poolAssetsConfig: [
-        TON_MAINNET,
-        USDT_MAINNET,
-        CATI_MAINNET,
-        NOT_MAINNET,
-        DOGS_MAINNET
-    ],
-    lendingCode: LENDING_CODE
+    poolAssetsConfig: [TON_MAINNET, USDT_MAINNET, CATI_MAINNET, NOT_MAINNET, DOGS_MAINNET],
+    lendingCode: LENDING_CODE,
+};
+
+export const TESTNET_MASTER_REWARD_CONFIG: EvaaRewardsConfig = {
+    adminAddress: EVAA_REWARDS_MASTER_TESTNET,
+    evaaMasterAddress: new Address(0, Buffer.alloc(32, 0)),
+    rewardMasterCode: EVAA_REWARDS_MASTER_CODE_TESTNET,
+    rewardUserCode: EVAA_REWARDS_USER_CODE_TESTNET,
+    asset: TON_TESTNET,
+    availableReward: 0,
+    publicKey: Buffer.from('c38be45e033419b49cd22c97fbd23610fbc851a931208f8b4a1817dd11cb63ac', 'hex'), // adminAddress publicKey
+};
+
+export const TESTNET_MASTER_EUSDT_REWARD_CONFIG: EvaaRewardsConfig = {
+    adminAddress: EVAA_REWARDS_MASTER_TESTNET,
+    evaaMasterAddress: new Address(0, Buffer.alloc(32, 0)),
+    rewardMasterCode: EVAA_REWARDS_MASTER_CODE_TESTNET,
+    rewardUserCode: EVAA_REWARDS_USER_CODE_TESTNET,
+    asset: EUSDT_TESTNET,
+    availableReward: 0,
+    publicKey: Buffer.from('c38be45e033419b49cd22c97fbd23610fbc851a931208f8b4a1817dd11cb63ac', 'hex'), // adminAddress publicKey
+};
+
+export const MAINNET_MASTER_TON_REWARD_CONFIG: EvaaRewardsConfig = {
+    adminAddress: EVAA_TON_REWARDS_MASTER_MAINNET,
+    evaaMasterAddress: new Address(0, Buffer.alloc(32, 0)),
+    rewardMasterCode: EVAA_REWARDS_MASTER_CODE_MAINNET,
+    rewardUserCode: EVAA_REWARDS_USER_CODE_MAINNET,
+    asset: TON_MAINNET,
+    availableReward: 0,
+    publicKey: Buffer.from('bfe9a30221db4dff4c17e55d985e0b13a8f597bbb28002f311dc4429dad1ca95', 'hex'), // adminAddress publicKey
+};
+
+export const MAINNET_MASTER_USDT_REWARD_CONFIG: EvaaRewardsConfig = {
+    adminAddress: EVAA_USDT_REWARDS_MASTER_MAINNET,
+    evaaMasterAddress: new Address(0, Buffer.alloc(32, 0)),
+    rewardMasterCode: EVAA_REWARDS_MASTER_CODE_MAINNET,
+    rewardUserCode: EVAA_REWARDS_USER_CODE_MAINNET,
+    asset: USDT_MAINNET,
+    availableReward: 0,
+    publicKey: Buffer.from('9813725d6cead1c9bbc0e24b21d4fc62a7fa8ac4bb01b6758df30169a71dba67', 'hex'), // adminAddress publicKey
 };

package/src/index.ts

@@ -14,7 +14,10 @@ export {
     calculateLiquidationData,
     predictHealthFactor,
     calculateHealthParams,
+    calculateInterestWithSupplyBorrow,
+    predictAPY,
     BigMath,
+    getAssetLiquidityMinusReserves,
 } from './api/math';
 
 export {
@@ -55,6 +58,15 @@ export {
 } from './contracts/MasterContract';
 export { EvaaUser } from './contracts/UserContract';
 
+// Rewards contracts wrappers
+export { RewardMaster } from './rewards/RewardMaster';
+export { type EvaaRewardsConfig } from './types/MasterRewards';
+export { RewardUser } from './rewards/RewardUser';
+export { type EvaaUserRewardsConfig } from './types/UserRewards';
+export { JettonMinter as RewardJettonMinter, type JettonMinterConfig, type MintMessage } from './rewards/JettonMinter';
+export { JettonWallet as RewardJettonWallet, type JettonWalletConfig } from './rewards/JettonWallet';
+export { EvaaUserRewards } from './rewards/EvaaRewards';
+
 // Types
 export {
     UpgradeConfig,
@@ -95,14 +107,24 @@ export {
     LENDING_CODE,
     OPCODES,
     FEES,
-    MASTER_CONSTANTS
+    MASTER_CONSTANTS,
+    EVAA_REWARDS_MASTER_TESTNET,
+    EVAA_REWARDS_MASTER_CODE_TESTNET,
+    EVAA_REWARDS_USER_CODE_TESTNET,
+    EVAA_REWARDS_MASTER_CODE_MAINNET,
+    EVAA_REWARDS_USER_CODE_MAINNET,
 } from './constants/general';
 
 export {
     MAINNET_POOL_CONFIG,
     TESTNET_POOL_CONFIG,
     MAINNET_LP_POOL_CONFIG,
-    MAINNET_ALTS_POOL_CONFIG
+    MAINNET_ALTS_POOL_CONFIG,
+    MAINNET_TEST_ETHENA_POOL_CONFIG,
+    // Reward Pools
+    TESTNET_MASTER_REWARD_CONFIG,
+    MAINNET_MASTER_TON_REWARD_CONFIG,
+    MAINNET_MASTER_USDT_REWARD_CONFIG,
 } from './constants/pools';
 
 export {

package/src/prices/PricesCollector.ts

@@ -29,8 +29,8 @@ export class PricesCollector {
 
     // TODO Make UserData class and incapsulate raw bigintegers
 
-    async getPricesForLiquidate(userPrincipals: Dictionary<bigint, bigint>, retries: number = 1, timeout: number = 3000): Promise<Prices>  {
-        const assets = userPrincipals.keys().map(x => this.#poolConfig.poolAssetsConfig.find(asset => asset.assetId == x));
+    async getPricesForLiquidate(realPrincipals: Dictionary<bigint, bigint>, retries: number = 1, timeout: number = 3000): Promise<Prices>  {
+        const assets = this.#filterEmptyPrincipalsAndAssets(realPrincipals);
         if (assets.includes(undefined)) {
             throw new Error("User from another pool");
         }
@@ -38,9 +38,9 @@ export class PricesCollector {
     }
 
 
-    async getPricesForWithdraw(userPrincipals: Dictionary<bigint, bigint>, withdrawAsset: PoolAssetConfig, collateralToDebt = false, retries: number = 1, timeout: number = 3000): Promise<Prices>  {
-        let assets = userPrincipals.keys().map(x => this.#poolConfig.poolAssetsConfig.find(asset => asset.assetId == x));
-        if (checkNotInDebtAtAll(userPrincipals) && userPrincipals.has(withdrawAsset.assetId) && !collateralToDebt) {
+    async getPricesForWithdraw(realPrincipals: Dictionary<bigint, bigint>, withdrawAsset: PoolAssetConfig, collateralToDebt = false, retries: number = 1, timeout: number = 3000): Promise<Prices>  {
+        let assets = this.#filterEmptyPrincipalsAndAssets(realPrincipals);
+        if (checkNotInDebtAtAll(realPrincipals) && (realPrincipals.get(withdrawAsset.assetId) ?? 0n) > 0n && !collateralToDebt) {
             return new Prices(Dictionary.empty<bigint, bigint>(), Cell.EMPTY);
         }
 
@@ -100,7 +100,7 @@ export class PricesCollector {
         }
 
         const medianData = assets.map(asset => ({ assetId: asset.assetId, medianPrice: getMedianPrice(this.#prices, asset.assetId)}));
-
+        
         const nonEmptymedianData = medianData.filter(x => x.medianPrice != null) as { assetId: bigint, medianPrice: bigint }[];
 
         const packedMedianData = packAssetsData(nonEmptymedianData);
@@ -132,4 +132,8 @@ export class PricesCollector {
         this.#prices = this.#prices.filter(verifyPricesTimestamp());
         return this.#prices.length;
     }
+
+    #filterEmptyPrincipalsAndAssets(principals: Dictionary<bigint, bigint>) {
+        return principals.keys().filter(x => principals.get(x)! != 0n).map(x => this.#poolConfig.poolAssetsConfig.find(asset => asset.assetId == x));
+    }
 }

package/src/prices/utils.ts

@@ -128,7 +128,7 @@ export async function collectAndFilterPrices(priceSource: PriceSource, poolConfi
     const prices = await priceSource.getPrices();
          
     //console.debug('[FILTERING] before filtering prices len ', priceSource.sourceName, prices.length);
-    return await (async () => {
+    return (async () => {
             const acceptedPrices: RawPriceData[] = prices.filter(
             price => verifyPricesTimestamp()(price) && verifyPricesSign(poolConfig.oracles)(price)
         );

package/src/rewards/EvaaRewards.ts

@@ -0,0 +1,23 @@
+import { Address, Contract } from '@ton/ton';
+import { EvaaRewardsConfig } from '../types/MasterRewards';
+import { RewardUser } from './RewardUser';
+
+export class EvaaUserRewards implements Contract {
+    readonly address: Address;
+    constructor(
+        readonly userAddress: Address,
+        readonly config: Omit<EvaaRewardsConfig, 'userAddress'>,
+    ) {
+        this.address = this.userAddress;
+    }
+
+    openContract() {
+        return RewardUser.createFromConfig({
+            asset: this.config.asset,
+            rewardMasterAddress: this.config.adminAddress,
+            rewardUserCode: this.config.rewardUserCode,
+            userAddress: this.userAddress,
+            publicKey: this.config.publicKey,
+        });
+    }
+}

package/src/rewards/JettonMinter.ts

@@ -0,0 +1,113 @@
+import { Address, beginCell, Cell, Contract, contractAddress, ContractProvider, Sender, SendMode } from '@ton/ton';
+import { OPCODES } from '../constants/general';
+
+export type JettonMinterConfig = {
+    address: Address;
+    content: Cell;
+    walletCode: Cell;
+};
+
+export type MintMessage = {
+    address: Address;
+    forwardValue: bigint;
+    amount: bigint;
+};
+
+export class JettonMinter implements Contract {
+    constructor(
+        readonly address: Address,
+        readonly init?: { code: Cell; data: Cell },
+    ) {}
+
+    static createFromAddress(address: Address) {
+        return new JettonMinter(address);
+    }
+
+    static jettonMinterConfigToCell(config: JettonMinterConfig): Cell {
+        return beginCell()
+            .storeCoins(0)
+            .storeAddress(config.address)
+            .storeRef(config.content)
+            .storeRef(config.walletCode)
+            .endCell();
+    }
+
+    static createFromConfig(config: JettonMinterConfig, code: Cell, workchain = 0) {
+        const data = this.jettonMinterConfigToCell(config);
+        const init = { code, data };
+        return new JettonMinter(contractAddress(workchain, init), init);
+    }
+
+    async sendDeploy(provider: ContractProvider, via: Sender, value: bigint) {
+        await provider.internal(via, {
+            value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell().endCell(),
+        });
+    }
+
+    sendMintMessage(payload: MintMessage) {
+        return beginCell()
+            .storeUint(21, 32)
+            .storeUint(0, 64)
+            .storeAddress(payload.address)
+            .storeCoins(payload.forwardValue)
+            .storeRef(
+                beginCell()
+                    .storeUint(OPCODES.REWARD_JETTON_MINT, 32)
+                    .storeUint(0, 64)
+                    .storeCoins(payload.amount)
+                    .storeAddress(this.address)
+                    .storeAddress(this.address)
+                    .storeCoins(0)
+                    .storeUint(0, 1)
+                    .endCell(),
+            )
+            .endCell();
+    }
+
+    async sendMint(
+        provider: ContractProvider,
+        via: Sender,
+        value: bigint,
+        forwardValue: bigint,
+        recipient: Address,
+        amount: bigint,
+    ) {
+        await provider.internal(via, {
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell()
+                .storeUint(21, 32)
+                .storeUint(0, 64)
+                .storeAddress(recipient)
+                .storeCoins(forwardValue)
+                .storeRef(
+                    beginCell()
+                        .storeUint(OPCODES.REWARD_JETTON_MINT, 32)
+                        .storeUint(0, 64)
+                        .storeCoins(amount)
+                        .storeAddress(this.address)
+                        .storeAddress(this.address)
+                        .storeCoins(0)
+                        .storeUint(0, 1)
+                        .endCell(),
+                )
+                .endCell(),
+            value: value + forwardValue,
+        });
+    }
+
+    async getWalletAddressOf(provider: ContractProvider, address: Address) {
+        return (
+            await provider.get('get_wallet_address', [
+                { type: 'slice', cell: beginCell().storeAddress(address).endCell() },
+            ])
+        ).stack.readAddress();
+    }
+
+    async getWalletCode(provider: ContractProvider) {
+        let stack = (await provider.get('get_jetton_data', [])).stack;
+        stack.skip(4);
+        return stack.readCell();
+    }
+}

package/src/rewards/JettonWallet.ts

@@ -0,0 +1,77 @@
+import { Address, beginCell, Cell, Contract, contractAddress, ContractProvider, Sender, SendMode } from '@ton/ton';
+import { OPCODES } from '../constants/general';
+
+export type JettonWalletConfig = {
+    owner: Address;
+    minter: Address;
+    walletCode: Cell;
+};
+
+export class JettonWallet implements Contract {
+    constructor(
+        readonly address: Address,
+        readonly init?: { code: Cell; data: Cell },
+    ) {}
+
+    static createFromAddress(address: Address) {
+        return new JettonWallet(address);
+    }
+
+    static jettonWalletConfigToCell(config: JettonWalletConfig): Cell {
+        return beginCell()
+            .storeCoins(0) // baseTrackingAccured always is 0, check smartcontract
+            .storeAddress(config.owner)
+            .storeAddress(config.minter)
+            .storeRef(config.walletCode)
+            .endCell();
+    }
+
+    static createFromConfig(config: JettonWalletConfig, code: Cell, workchain = 0) {
+        const data = this.jettonWalletConfigToCell(config);
+        const init = { code, data };
+        return new JettonWallet(contractAddress(workchain, init), init);
+    }
+
+    async sendDeploy(provider: ContractProvider, via: Sender, value: bigint) {
+        await provider.internal(via, {
+            value,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell().endCell(),
+        });
+    }
+
+    async sendTransfer(
+        provider: ContractProvider,
+        via: Sender,
+        value: bigint,
+        forwardValue: bigint,
+        recipient: Address,
+        amount: bigint,
+        forwardPayload: Cell,
+    ) {
+        await provider.internal(via, {
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell()
+                .storeUint(OPCODES.REWARD_JETTON_TRANSFER, 32)
+                .storeUint(0, 64)
+                .storeCoins(amount)
+                .storeAddress(recipient)
+                .storeAddress(via.address)
+                .storeUint(0, 1)
+                .storeCoins(forwardValue)
+                .storeUint(1, 1)
+                .storeRef(forwardPayload)
+                .endCell(),
+            value: value + forwardValue,
+        });
+    }
+
+    async getJettonBalance(provider: ContractProvider) {
+        let state = await provider.getState();
+        if (state.state.type !== 'active') {
+            return 0n;
+        }
+        let res = await provider.get('get_wallet_data', []);
+        return res.stack.readBigNumber();
+    }
+}

package/src/rewards/RewardMaster.ts

@@ -0,0 +1,110 @@
+import {
+    Address,
+    beginCell,
+    Cell,
+    Contract,
+    contractAddress,
+    ContractProvider,
+    fromNano,
+    Sender,
+    SendMode,
+    StateInit,
+    toNano,
+} from '@ton/ton';
+import { Maybe } from '@ton/ton/dist/utils/maybe';
+import { FEES, OPCODES } from '../constants/general';
+import { EvaaRewardsConfig } from '../types/MasterRewards';
+import { bigIntToBuffer } from '../utils/sha256BigInt';
+
+export class RewardMaster implements Contract {
+    constructor(
+        readonly address: Address,
+        readonly init?: Maybe<StateInit>,
+    ) {}
+
+    static createFromAddress(address: Address) {
+        return new RewardMaster(address);
+    }
+
+    static rewardMasterConfigToCell(config: EvaaRewardsConfig): Cell {
+        return beginCell()
+            .storeAddress(config.adminAddress)
+            .storeCoins(config.availableReward)
+            .storeAddress(null) // The addres null for TON
+            .storeRef(config.rewardUserCode)
+            .storeRef(
+                beginCell()
+                    .storeAddress(config.evaaMasterAddress)
+                    .storeBuffer(bigIntToBuffer(config.asset.assetId), 256 / 8)
+                    .storeBuffer(config.publicKey, 256 / 8)
+                    .endCell(),
+            )
+            .endCell();
+    }
+
+    static createFromConfig(config: EvaaRewardsConfig, workchain = 0) {
+        const data = this.rewardMasterConfigToCell(config);
+        const init = { code: config.rewardMasterCode, data };
+        return new RewardMaster(contractAddress(workchain, init), init);
+    }
+
+    async sendDeploy(provider: ContractProvider, via: Sender, rewardTokenJettonWalletAddress: Address | null) {
+        await provider.internal(via, {
+            value: FEES.REWARD_MASTER_DEPLOY,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell().storeUint(1, 32).storeUint(0, 64).storeAddress(rewardTokenJettonWalletAddress).endCell(),
+        });
+    }
+
+    async sendTonTopUp(provider: ContractProvider, via: Sender, topUpRewardAmount: number) {
+        await provider.internal(via, {
+            value: toNano(topUpRewardAmount) + FEES.REWARD_MASTER_TON_TOP_UP,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: beginCell().storeUint(OPCODES.REWARD_TON_TOP_UP, 32).storeUint(0, 64).endCell(),
+        });
+    }
+
+    private adminWithdrawMessage(destinationAddress: Address, jettonAmount: number) {
+        return beginCell()
+            .storeUint(4, 32)
+            .storeUint(0, 64)
+            .storeAddress(destinationAddress)
+            .storeCoins(toNano(jettonAmount))
+            .endCell();
+    }
+
+    async sendAdminWithdraw(
+        provider: ContractProvider,
+        via: Sender,
+        destinationAddress: Address,
+        jettonAmount: number,
+    ) {
+        await provider.internal(via, {
+            value: FEES.REWARD_MASTER_WITHDRAW,
+            sendMode: SendMode.PAY_GAS_SEPARATELY,
+            body: this.adminWithdrawMessage(destinationAddress, jettonAmount),
+        });
+    }
+
+    async getData(provider: ContractProvider) {
+        const result = await provider.get('load_data', []);
+        const data = {
+            // TODO: maybe it will be typed
+            adminAddress: result.stack.readAddress(),
+            availableReward: Number(fromNano(result.stack.readBigNumber())),
+            rewardUserCode: result.stack.readCell(),
+            evaaMasterAddress: result.stack.readAddress(),
+            rewardTokenJettonWalletAddress: result.stack.readAddressOpt(),
+            assetId: Buffer.from(result.stack.readBigNumber().toString(16), 'hex'),
+            publicKey: Buffer.from(result.stack.readBigNumber().toString(16), 'hex'),
+        };
+        return data;
+    }
+
+    async getRewardUserAddress(provider: ContractProvider, userAddress: Address): Promise<Address> {
+        const result = await provider.get('calculate_reward_user_address', [
+            { type: 'slice', cell: beginCell().storeAddress(userAddress).endCell() },
+        ]);
+        return result.stack.readAddress();
+    }
+}