@evaafi/sdk 0.6.2 → 0.6.3-b

package/dist/rewards/JettonMinter.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JettonMinter = void 0;
+const ton_1 = require("@ton/ton");
+const general_1 = require("../constants/general");
+class JettonMinter {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new JettonMinter(address);
+    }
+    static jettonMinterConfigToCell(config) {
+        return (0, ton_1.beginCell)()
+            .storeCoins(0)
+            .storeAddress(config.address)
+            .storeRef(config.content)
+            .storeRef(config.walletCode)
+            .endCell();
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = this.jettonMinterConfigToCell(config);
+        const init = { code, data };
+        return new JettonMinter((0, ton_1.contractAddress)(workchain, init), init);
+    }
+    async sendDeploy(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)().endCell(),
+        });
+    }
+    sendMintMessage(payload) {
+        return (0, ton_1.beginCell)()
+            .storeUint(21, 32)
+            .storeUint(0, 64)
+            .storeAddress(payload.address)
+            .storeCoins(payload.forwardValue)
+            .storeRef((0, ton_1.beginCell)()
+            .storeUint(general_1.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, via, value, forwardValue, recipient, amount) {
+        await provider.internal(via, {
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)()
+                .storeUint(21, 32)
+                .storeUint(0, 64)
+                .storeAddress(recipient)
+                .storeCoins(forwardValue)
+                .storeRef((0, ton_1.beginCell)()
+                .storeUint(general_1.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, address) {
+        return (await provider.get('get_wallet_address', [
+            { type: 'slice', cell: (0, ton_1.beginCell)().storeAddress(address).endCell() },
+        ])).stack.readAddress();
+    }
+    async getWalletCode(provider) {
+        let stack = (await provider.get('get_jetton_data', [])).stack;
+        stack.skip(4);
+        return stack.readCell();
+    }
+}
+exports.JettonMinter = JettonMinter;

package/dist/rewards/JettonWallet.d.ts

@@ -0,0 +1,23 @@
+import { Address, Cell, Contract, ContractProvider, Sender } from '@ton/ton';
+export type JettonWalletConfig = {
+    owner: Address;
+    minter: Address;
+    walletCode: Cell;
+};
+export declare class JettonWallet implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static createFromAddress(address: Address): JettonWallet;
+    static jettonWalletConfigToCell(config: JettonWalletConfig): Cell;
+    static createFromConfig(config: JettonWalletConfig, code: Cell, workchain?: number): JettonWallet;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    sendTransfer(provider: ContractProvider, via: Sender, value: bigint, forwardValue: bigint, recipient: Address, amount: bigint, forwardPayload: Cell): Promise<void>;
+    getJettonBalance(provider: ContractProvider): Promise<bigint>;
+}

package/dist/rewards/JettonWallet.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JettonWallet = void 0;
+const ton_1 = require("@ton/ton");
+const general_1 = require("../constants/general");
+class JettonWallet {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new JettonWallet(address);
+    }
+    static jettonWalletConfigToCell(config) {
+        return (0, ton_1.beginCell)()
+            .storeCoins(0) // baseTrackingAccured always is 0, check smartcontract
+            .storeAddress(config.owner)
+            .storeAddress(config.minter)
+            .storeRef(config.walletCode)
+            .endCell();
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = this.jettonWalletConfigToCell(config);
+        const init = { code, data };
+        return new JettonWallet((0, ton_1.contractAddress)(workchain, init), init);
+    }
+    async sendDeploy(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)().endCell(),
+        });
+    }
+    async sendTransfer(provider, via, value, forwardValue, recipient, amount, forwardPayload) {
+        await provider.internal(via, {
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)()
+                .storeUint(general_1.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) {
+        let state = await provider.getState();
+        if (state.state.type !== 'active') {
+            return 0n;
+        }
+        let res = await provider.get('get_wallet_data', []);
+        return res.stack.readBigNumber();
+    }
+}
+exports.JettonWallet = JettonWallet;

package/dist/rewards/RewardMaster.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { Address, Cell, Contract, ContractProvider, Sender, StateInit } from '@ton/ton';
+import { Maybe } from '@ton/ton/dist/utils/maybe';
+import { EvaaRewardsConfig } from '../types/MasterRewards';
+export declare class RewardMaster implements Contract {
+    readonly address: Address;
+    readonly init?: Maybe<StateInit>;
+    constructor(address: Address, init?: Maybe<StateInit>);
+    static createFromAddress(address: Address): RewardMaster;
+    static rewardMasterConfigToCell(config: EvaaRewardsConfig): Cell;
+    static createFromConfig(config: EvaaRewardsConfig, workchain?: number): RewardMaster;
+    sendDeploy(provider: ContractProvider, via: Sender, rewardTokenJettonWalletAddress: Address | null): Promise<void>;
+    sendTonTopUp(provider: ContractProvider, via: Sender, topUpRewardAmount: number): Promise<void>;
+    private adminWithdrawMessage;
+    sendAdminWithdraw(provider: ContractProvider, via: Sender, destinationAddress: Address, jettonAmount: number): Promise<void>;
+    getData(provider: ContractProvider): Promise<{
+        adminAddress: Address;
+        availableReward: number;
+        rewardUserCode: Cell;
+        evaaMasterAddress: Address;
+        rewardTokenJettonWalletAddress: Address | null;
+        assetId: Buffer;
+        publicKey: Buffer;
+    }>;
+    getRewardUserAddress(provider: ContractProvider, userAddress: Address): Promise<Address>;
+}

package/dist/rewards/RewardMaster.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RewardMaster = void 0;
+const ton_1 = require("@ton/ton");
+const general_1 = require("../constants/general");
+const sha256BigInt_1 = require("../utils/sha256BigInt");
+class RewardMaster {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new RewardMaster(address);
+    }
+    static rewardMasterConfigToCell(config) {
+        return (0, ton_1.beginCell)()
+            .storeAddress(config.adminAddress)
+            .storeCoins(config.availableReward)
+            .storeAddress(null) // The addres null for TON
+            .storeRef(config.rewardUserCode)
+            .storeRef((0, ton_1.beginCell)()
+            .storeAddress(config.evaaMasterAddress)
+            .storeBuffer((0, sha256BigInt_1.bigIntToBuffer)(config.asset.assetId), 256 / 8)
+            .storeBuffer(config.publicKey, 256 / 8)
+            .endCell())
+            .endCell();
+    }
+    static createFromConfig(config, workchain = 0) {
+        const data = this.rewardMasterConfigToCell(config);
+        const init = { code: config.rewardMasterCode, data };
+        return new RewardMaster((0, ton_1.contractAddress)(workchain, init), init);
+    }
+    async sendDeploy(provider, via, rewardTokenJettonWalletAddress) {
+        await provider.internal(via, {
+            value: general_1.FEES.REWARD_MASTER_DEPLOY,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)().storeUint(1, 32).storeUint(0, 64).storeAddress(rewardTokenJettonWalletAddress).endCell(),
+        });
+    }
+    async sendTonTopUp(provider, via, topUpRewardAmount) {
+        await provider.internal(via, {
+            value: (0, ton_1.toNano)(topUpRewardAmount) + general_1.FEES.REWARD_MASTER_TON_TOP_UP,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)().storeUint(general_1.OPCODES.REWARD_TON_TOP_UP, 32).storeUint(0, 64).endCell(),
+        });
+    }
+    adminWithdrawMessage(destinationAddress, jettonAmount) {
+        return (0, ton_1.beginCell)()
+            .storeUint(4, 32)
+            .storeUint(0, 64)
+            .storeAddress(destinationAddress)
+            .storeCoins((0, ton_1.toNano)(jettonAmount))
+            .endCell();
+    }
+    async sendAdminWithdraw(provider, via, destinationAddress, jettonAmount) {
+        await provider.internal(via, {
+            value: general_1.FEES.REWARD_MASTER_WITHDRAW,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: this.adminWithdrawMessage(destinationAddress, jettonAmount),
+        });
+    }
+    async getData(provider) {
+        const result = await provider.get('load_data', []);
+        const data = {
+            // TODO: maybe it will be typed
+            adminAddress: result.stack.readAddress(),
+            availableReward: Number((0, ton_1.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, userAddress) {
+        const result = await provider.get('calculate_reward_user_address', [
+            { type: 'slice', cell: (0, ton_1.beginCell)().storeAddress(userAddress).endCell() },
+        ]);
+        return result.stack.readAddress();
+    }
+}
+exports.RewardMaster = RewardMaster;

package/dist/rewards/RewardUser.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { Address, Cell, Contract, ContractProvider, Sender, StateInit } from '@ton/ton';
+import { Maybe } from '@ton/ton/dist/utils/maybe';
+import { EvaaUserRewardsConfig } from '../types/UserRewards';
+export declare class RewardUser implements Contract {
+    readonly address: Address;
+    readonly init?: Maybe<StateInit>;
+    constructor(address: Address, init?: Maybe<StateInit>);
+    static createFromAddress(address: Address): RewardUser;
+    static rewardUserConfigToCell(config: EvaaUserRewardsConfig): Cell;
+    static createFromConfig(config: EvaaUserRewardsConfig, workchain?: number): RewardUser;
+    sendDeploy(provider: ContractProvider, via: Sender): Promise<void>;
+    claimMessageToCell(claimAmount: bigint): Cell;
+    signClaimMessage(claimBody: Cell, privateKey: Buffer): Cell;
+    sendClaim(provider: ContractProvider, via: Sender, signedClaimMessage: Cell): Promise<void>;
+    getData(provider: ContractProvider): Promise<{
+        userAddress: Address;
+        baseTrackingAccrued: number;
+        rewardMasterAddress: Address;
+        assetId: Buffer;
+        publicKey: Buffer;
+    }>;
+}

package/dist/rewards/RewardUser.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RewardUser = void 0;
+const crypto_1 = require("@ton/crypto");
+const ton_1 = require("@ton/ton");
+const general_1 = require("../constants/general");
+const sha256BigInt_1 = require("../utils/sha256BigInt");
+class RewardUser {
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new RewardUser(address);
+    }
+    static rewardUserConfigToCell(config) {
+        return (0, ton_1.beginCell)()
+            .storeAddress(config.userAddress)
+            .storeCoins(0)
+            .storeRef((0, ton_1.beginCell)()
+            .storeAddress(config.rewardMasterAddress)
+            .storeBuffer((0, sha256BigInt_1.bigIntToBuffer)(config.asset.assetId), 256 / 8)
+            .storeBuffer(config.publicKey, 256 / 8)
+            .endCell())
+            .endCell();
+    }
+    static createFromConfig(config, workchain = 0) {
+        const data = this.rewardUserConfigToCell(config);
+        const init = { code: config.rewardUserCode, data };
+        return new RewardUser((0, ton_1.contractAddress)(workchain, init), init);
+    }
+    async sendDeploy(provider, via) {
+        await provider.internal(via, {
+            value: general_1.FEES.REWARD_MASTER_DEPLOY,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, ton_1.beginCell)().endCell(),
+        });
+    }
+    claimMessageToCell(claimAmount) {
+        return (0, ton_1.beginCell)().storeAddress(this.address).storeCoins(claimAmount).endCell();
+    }
+    signClaimMessage(claimBody, privateKey) {
+        return (0, ton_1.beginCell)()
+            .storeUint(general_1.OPCODES.REWARD_CLAIM, 32)
+            .storeUint(0, 64)
+            .storeBuffer((0, crypto_1.sign)(claimBody.hash(), privateKey))
+            .storeRef(claimBody)
+            .endCell();
+    }
+    async sendClaim(provider, via, signedClaimMessage) {
+        await provider.internal(via, {
+            value: general_1.FEES.REWARD_USER_CLAIM,
+            sendMode: ton_1.SendMode.PAY_GAS_SEPARATELY,
+            body: signedClaimMessage,
+        });
+    }
+    async getData(provider) {
+        const result = await provider.get('load_data', []);
+        // TODO: maybe it will be typed
+        const data = {
+            userAddress: result.stack.readAddress(),
+            baseTrackingAccrued: Number((0, ton_1.fromNano)(result.stack.readBigNumber())),
+            rewardMasterAddress: result.stack.readAddress(),
+            assetId: Buffer.from(result.stack.readBigNumber().toString(16), 'hex'),
+            publicKey: Buffer.from(result.stack.readBigNumber().toString(16), 'hex'),
+        };
+        return data;
+    }
+}
+exports.RewardUser = RewardUser;

package/dist/types/MasterRewards.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Address, Cell } from '@ton/ton';
+import { PoolAssetConfig } from './Master';
+export type EvaaRewardsConfig = {
+    workchain?: number;
+    adminAddress: Address;
+    evaaMasterAddress: Address;
+    availableReward: number;
+    asset: PoolAssetConfig;
+    rewardMasterCode: Cell;
+    rewardUserCode: Cell;
+    publicKey: Buffer;
+};

package/dist/types/User.d.ts

@@ -1,5 +1,5 @@
 import { Address, Cell, Dictionary } from '@ton/core';
-import { ExtendedAssetsConfig, ExtendedAssetsData, PoolAssetConfig, PoolConfig } from './Master';
+import { AssetConfig, AssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConstants, PoolAssetConfig, PoolConfig } from './Master';
 export declare enum BalanceType {
     supply = "supply",
     borrow = "borrow"
@@ -31,6 +31,7 @@ export type UserLiteData = {
     masterAddress: Address;
     ownerAddress: Address;
     principals: Dictionary<bigint, bigint>;
+    realPrincipals: Dictionary<bigint, bigint>;
     state: number;
     balances: Dictionary<bigint, UserBalance>;
     trackingSupplyIndex: bigint;
@@ -40,6 +41,7 @@ export type UserLiteData = {
     rewards: Dictionary<bigint, UserRewards>;
     backupCell1: Cell | null;
     backupCell2: Cell | null;
+    fullyParsed: boolean;
 };
 export type UserDataActive = UserLiteData & {
     withdrawalLimits: Dictionary<bigint, bigint>;
@@ -52,6 +54,7 @@ export type UserDataActive = UserLiteData & {
     limitUsed: bigint;
     healthFactor: number;
     liquidationData: LiquidationData;
+    havePrincipalWithoutPrice: boolean;
 };
 export type UserDataInactive = {
     type: 'inactive';
@@ -84,3 +87,10 @@ export type PredictHealthFactorArgs = {
     assetsConfig: ExtendedAssetsConfig;
     poolConfig: PoolConfig;
 };
+export type PredictAPYArgs = {
+    balanceChangeType: BalanceChangeType;
+    amount: bigint;
+    assetData: AssetData;
+    assetConfig: AssetConfig;
+    masterConstants: MasterConstants;
+};

package/dist/types/UserRewards.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Address, Cell } from '@ton/ton';
+import { PoolAssetConfig } from './Master';
+export type EvaaUserRewardsConfig = {
+    userAddress: Address;
+    rewardUserCode: Cell;
+    rewardMasterAddress: Address;
+    asset: PoolAssetConfig;
+    publicKey: Buffer;
+};

package/dist/types/UserRewards.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/sha256BigInt.d.ts

@@ -1 +1,3 @@
+/// <reference types="node" />
 export declare function sha256Hash(input: string): bigint;
+export declare function bigIntToBuffer(value: bigint): Buffer;

package/dist/utils/sha256BigInt.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sha256Hash = void 0;
+exports.bigIntToBuffer = exports.sha256Hash = void 0;
 const sha256_1 = __importDefault(require("crypto-js/sha256"));
 function sha256Hash(input) {
     const hash = (0, sha256_1.default)(input);
@@ -11,3 +11,11 @@ function sha256Hash(input) {
     return BigInt('0x' + hashHex);
 }
 exports.sha256Hash = sha256Hash;
+function bigIntToBuffer(value) {
+    let hex = value.toString(16);
+    if (hex.length % 2) {
+        hex = '0' + hex;
+    }
+    return Buffer.from(hex, 'hex');
+}
+exports.bigIntToBuffer = bigIntToBuffer;

package/dist/utils/userJettonWallet.js

@@ -16,12 +16,22 @@ function getUserJettonData(ownerAddress, assetName, jettonWalletCode, jettonMast
         case 'DOGS':
         case 'NOT':
         case 'USDT':
+        case 'USDe':
             return (0, core_1.beginCell)()
                 .storeUint(0, 4)
                 .storeCoins(0)
                 .storeAddress(ownerAddress)
                 .storeAddress(jettonMasterAddress)
                 .endCell();
+        case 'tsUSDe':
+            return (0, core_1.beginCell)()
+                .storeUint(0, 4)
+                .storeCoins(0)
+                .storeAddress(ownerAddress)
+                .storeAddress(jettonMasterAddress)
+                .storeCoins(0)
+                .storeUint(0, 64)
+                .endCell();
         case 'tsTON':
             return (0, core_1.beginCell)()
                 .storeCoins(0)
@@ -31,6 +41,13 @@ function getUserJettonData(ownerAddress, assetName, jettonWalletCode, jettonMast
                 .storeCoins(0)
                 .storeUint(0, 48)
                 .endCell();
+        case 'tgBTC':
+            return (0, core_1.beginCell)()
+                .storeUint(0, 4)
+                .storeCoins(0)
+                .storeAddress(ownerAddress)
+                .storeAddress(jettonMasterAddress)
+                .endCell();
         default:
             return (0, core_1.beginCell)().storeCoins(0)
                 .storeAddress(ownerAddress)

package/package.json

@@ -1,44 +1,44 @@
 {
-  "name": "@evaafi/sdk",
-  "version": "0.6.2",
-  "description": "The EVAA SDK is designed to easily integrate with the EVAA lending protocol on TON blockchain.",
-  "main": "dist/index.js",
-  "files": [
-    "dist",
-    "src"
-  ],
-  "scripts": {
-    "build": "tsc --declaration",
-    "test": "jest"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/evaafi/sdk.git"
-  },
-  "author": "EVAA Finance",
-  "license": "MIT",
-  "homepage": "https://github.com/evaafi/sdk#readme",
-  "devDependencies": {
-    "@orbs-network/ton-access": "^2.3.3",
-    "@ton/core": "0.56.0",
-    "@ton/crypto": "^3.3.0",
-    "@tonconnect/sdk": "^3.0.5",
-    "@types/jest": "^29.5.12",
-    "@types/node": "^20.10.4",
-    "crypto-js": "^4.2.0",
-    "prettier": "^3.2.4",
-    "ts-jest": "^29.2.4",
-    "ts-node": "^10.9.1",
-    "typedoc": "^0.27.4",
-    "typescript": "^5.3.3"
-  },
-  "peerDependencies": {
-    "@ton/core": ">=0.56.0",
-    "@tonconnect/sdk": ">=3.0.0",
-    "crypto-js": ">=4.2.0"
-  },
-  "dependencies": {
-    "@ton/ton": "^14.0.0",
-    "dotenv": "^16.4.5"
-  }
+    "name": "@evaafi/sdk",
+    "version": "0.6.3-b",
+    "description": "The EVAA SDK is designed to easily integrate with the EVAA lending protocol on TON blockchain.",
+    "main": "dist/index.js",
+    "files": [
+        "dist",
+        "src"
+    ],
+    "scripts": {
+        "build": "tsc --declaration",
+        "test": "jest"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/evaafi/sdk.git"
+    },
+    "author": "EVAA Finance",
+    "license": "MIT",
+    "homepage": "https://github.com/evaafi/sdk#readme",
+    "devDependencies": {
+        "@orbs-network/ton-access": "^2.3.3",
+        "@ton/core": "0.56.0",
+        "@ton/crypto": "^3.3.0",
+        "@tonconnect/sdk": "3.0.5",
+        "@types/jest": "^29.5.12",
+        "@types/node": "^20.10.4",
+        "crypto-js": "4.2.0",
+        "prettier": "3.2.4",
+        "ts-jest": "^29.2.4",
+        "ts-node": "^10.9.1",
+        "typedoc": "0.27.4",
+        "typescript": "5.3.3"
+    },
+    "peerDependencies": {
+        "@ton/core": ">=0.56.0",
+        "@tonconnect/sdk": ">=3.0.0",
+        "crypto-js": ">=4.2.0"
+    },
+    "dependencies": {
+        "@ton/ton": "14.0.0",
+        "dotenv": "16.4.5"
+    }
 }