@evaafi/sdk 0.5.3 → 0.5.5

package/src/contracts/MasterContract.ts

@@ -10,20 +10,16 @@ import {
     storeStateInit,
 } from '@ton/core';
 import {
-    EVAA_MASTER_MAINNET,
-    EVAA_MASTER_TESTNET,
     FEES,
-    LENDING_CODE,
-    MAINNET_VERSION,
     OPCODES,
-    TESTNET_VERSION,
-} from '../constants';
+} from '../constants/general';
 import { Maybe } from '@ton/core/dist/utils/maybe';
 import { EvaaUser } from './UserContract';
 import { parseMasterData } from '../api/parser';
-import { MasterData } from '../types/Master';
+import { MasterData, PoolAssetConfig, PoolConfig, PoolJettonAssetConfig, PoolTonAssetConfig } from '../types/Master';
 import { JettonWallet } from './JettonWallet';
 import { getUserJettonWallet } from '../utils/userJettonWallet';
+import { getPrices, MAINNET_POOL_CONFIG } from '..';
 
 /**
  * Parameters for the Evaa contract
@@ -31,7 +27,7 @@ import { getUserJettonWallet } from '../utils/userJettonWallet';
  * @property debug - true to enable debug mode (optional)
  */
 export type EvaaParameters = {
-    testnet: boolean;
+    poolConfig: PoolConfig;
     debug?: boolean;
 };
 
@@ -58,7 +54,6 @@ export type SupplyBaseParameters = {
     includeUserCode: boolean;
     amount: bigint;
     userAddress: Address;
-    assetID: bigint;
     /* Will be in v6 
     amountToTransfer: bigint;
     payload: Cell; */
@@ -68,7 +63,7 @@ export type SupplyBaseParameters = {
  * @property type - 'ton'
  */
 export type TonSupplyParameters = SupplyBaseParameters & {
-    type: 'ton';
+    asset: PoolAssetConfig;
 };
 /**
  * Parameters for the jetton supply message
@@ -76,12 +71,16 @@ export type TonSupplyParameters = SupplyBaseParameters & {
  */
 export type JettonSupplyParameters = SupplyBaseParameters &
     JettonMessageParameters & {
-        type: 'jetton';
+        asset: PoolJettonAssetConfig & PoolAssetConfig;
     };
 
+export type SupplyParameters = TonSupplyParameters | JettonSupplyParameters;
+
+
 /**
  * Parameters for the withdraw message
  * @property queryID - unique query ID
+ *  * @property assetID - asset ID
  * @property assetID - asset ID
  * @property amount - amount to withdraw
  * @property userAddress - user address
@@ -90,11 +89,11 @@ export type JettonSupplyParameters = SupplyBaseParameters &
  */
 export type WithdrawParameters = {
     queryID: bigint;
-    assetID: bigint;
     amount: bigint;
     userAddress: Address;
     includeUserCode: boolean;
     priceData: Cell;
+    asset: PoolAssetConfig;
     /* Will be in v6 
     amountToTransfer: bigint;
     payload: Cell; */
@@ -137,7 +136,7 @@ export type LiquidationBaseParameters = LiquidationBaseData & {
  * @property type - 'ton'
  */
 export type TonLiquidationParameters = LiquidationBaseParameters & {
-    type: 'ton';
+    asset: PoolAssetConfig;
 };
 /**
  * Parameters for the jetton liquidation message
@@ -145,15 +144,15 @@ export type TonLiquidationParameters = LiquidationBaseParameters & {
  */
 export type JettonLiquidationParameters = LiquidationBaseParameters &
     JettonMessageParameters & {
-        type: 'jetton';
+        asset: PoolAssetConfig & PoolJettonAssetConfig
     };
 
 /**
  * Evaa master contract wrapper
  */
 export class Evaa implements Contract {
-    readonly address: Address = EVAA_MASTER_MAINNET;
-    readonly network: 'mainnet' | 'testnet' = 'mainnet';
+    readonly address: Address;
+    private poolConfig: PoolConfig;
     private readonly debug?: boolean;
     private _data?: MasterData;
     private lastSync = 0;
@@ -163,10 +162,8 @@ export class Evaa implements Contract {
      * @param parameters Evaa contract parameters
      */
     constructor(parameters?: EvaaParameters) {
-        if (parameters?.testnet) {
-            this.network = 'testnet';
-            this.address = EVAA_MASTER_TESTNET;
-        }
+        this.poolConfig = parameters?.poolConfig ?? MAINNET_POOL_CONFIG;
+        this.address = this.poolConfig.masterAddress;
         this.debug = parameters?.debug;
     }
 
@@ -174,16 +171,18 @@ export class Evaa implements Contract {
      * Create supply message
      * @returns supply message as a cell
      */
-    createSupplyMessage(parameters: TonSupplyParameters | JettonSupplyParameters): Cell {
-        if (parameters.type === 'jetton') {
+    createSupplyMessage(parameters: SupplyParameters): Cell {
+        if ('jettonMasterAddress' in parameters.asset) {
+            const jettonParams = parameters as JettonSupplyParameters;
+
             return beginCell()
                 .storeUint(OPCODES.JETTON_TRANSFER, 32)
                 .storeUint(parameters.queryID, 64)
                 .storeCoins(parameters.amount)
                 .storeAddress(this.address)
-                .storeAddress(parameters.responseAddress ?? parameters.userAddress)
+                .storeAddress(jettonParams.responseAddress ?? parameters.userAddress)
                 .storeBit(0)
-                .storeCoins(parameters.forwardAmount ?? FEES.SUPPLY_JETTON_FWD)
+                .storeCoins(jettonParams.forwardAmount ?? FEES.SUPPLY_JETTON_FWD)
                 .storeBit(1)
                 .storeRef(
                     beginCell()
@@ -218,7 +217,7 @@ export class Evaa implements Contract {
         return beginCell()
             .storeUint(OPCODES.WITHDRAW, 32)
             .storeUint(parameters.queryID, 64)
-            .storeUint(parameters.assetID, 256)
+            .storeUint(parameters.asset.assetId, 256)
             .storeUint(parameters.amount, 64)
             .storeAddress(parameters.userAddress)
             .storeInt(parameters.includeUserCode ? -1 : 0, 2)
@@ -234,15 +233,17 @@ export class Evaa implements Contract {
      * @returns liquidation message as a cell
      */
     createLiquidationMessage(parameters: TonLiquidationParameters | JettonLiquidationParameters): Cell {
-        if (parameters.type === 'jetton') {
+        if ('jettonMasterAddress' in parameters.asset) {
+            const jettonParams = parameters as JettonLiquidationParameters;
+
             return beginCell()
                 .storeUint(OPCODES.JETTON_TRANSFER, 32)
                 .storeUint(parameters.queryID, 64)
                 .storeCoins(parameters.liquidationAmount)
                 .storeAddress(this.address)
-                .storeAddress(parameters.responseAddress ?? parameters.liquidatorAddress)
+                .storeAddress(jettonParams.responseAddress ?? parameters.liquidatorAddress)
                 .storeBit(0)
-                .storeCoins(parameters.forwardAmount ?? FEES.LIQUIDATION_JETTON_FWD)
+                .storeCoins(jettonParams.forwardAmount ?? FEES.LIQUIDATION_JETTON_FWD)
                 .storeBit(1)
                 .storeRef(
                     beginCell()
@@ -279,7 +280,7 @@ export class Evaa implements Contract {
      * @param userAddress
      * @returns user contract address
      */
-    calculateUserSCAddr(userAddress: Address): Address {
+    calculateUserSCAddr(userAddress: Address, lendingCode: Cell): Address {
         const lendingData = beginCell()
             .storeAddress(this.address)
             .storeAddress(userAddress)
@@ -290,7 +291,7 @@ export class Evaa implements Contract {
         const stateInit = beginCell()
             .store(
                 storeStateInit({
-                    code: LENDING_CODE,
+                    code: lendingCode,
                     data: lendingData,
                 }),
             )
@@ -304,7 +305,7 @@ export class Evaa implements Contract {
      * @returns user contract
      */
     openUserContract(userAddress: Address): EvaaUser {
-        return EvaaUser.createFromAddress(this.calculateUserSCAddr(userAddress), this.network === 'testnet');
+        return EvaaUser.createFromAddress(this.calculateUserSCAddr(userAddress, this.poolConfig.lendingCode), this.poolConfig);
     }
 
     getOpenedUserContract(provider: ContractProvider, userAddress: Address): OpenedContract<EvaaUser> {
@@ -326,12 +327,13 @@ export class Evaa implements Contract {
     ) {
         const message = this.createSupplyMessage(parameters);
 
-        if (parameters.type === 'jetton') {
+        if ('jettonMasterAddress' in parameters.asset) {
             if (!via.address) {
                 throw Error('Via address is required for jetton supply');
             }
+
             const jettonWallet = provider.open(
-                JettonWallet.createFromAddress(getUserJettonWallet(via.address, parameters.assetID, this.network)),
+                JettonWallet.createFromAddress(getUserJettonWallet(via.address, parameters.asset)),
             );
             await jettonWallet.sendTransfer(via, value, message);
         } else {
@@ -340,11 +342,13 @@ export class Evaa implements Contract {
                 sendMode: SendMode.PAY_GAS_SEPARATELY + SendMode.IGNORE_ERRORS,
                 body: message,
             });
+
         }
     }
 
     async sendWithdraw(provider: ContractProvider, via: Sender, value: bigint, parameters: WithdrawParameters) {
         const message = this.createWithdrawMessage(parameters);
+
         await provider.internal(via, {
             value,
             sendMode: SendMode.PAY_GAS_SEPARATELY + SendMode.IGNORE_ERRORS,
@@ -360,12 +364,13 @@ export class Evaa implements Contract {
     ) {
         const message = this.createLiquidationMessage(parameters);
 
-        if (parameters.type === 'jetton') {
+        if ('jettonMasterAddress' in parameters.asset) {
             if (!via.address) {
                 throw Error('Via address is required for jetton liquidation');
             }
+            
             const jettonWallet = provider.open(
-                JettonWallet.createFromAddress(getUserJettonWallet(via.address, parameters.loanAsset, this.network)),
+                JettonWallet.createFromAddress(getUserJettonWallet(via.address, parameters.asset)),
             );
             await jettonWallet.sendTransfer(via, value, message);
         } else {
@@ -405,15 +410,10 @@ export class Evaa implements Contract {
     async getSync(provider: ContractProvider) {
         const state = (await provider.getState()).state;
         if (state.type === 'active') {
-            this._data = parseMasterData(state.data!.toString('base64'), this.network === 'testnet');
-            if (this.network === 'testnet' && this._data.upgradeConfig.masterCodeVersion !== TESTNET_VERSION) {
+            this._data = parseMasterData(state.data!.toString('base64'), this.poolConfig.poolAssetsConfig, this.poolConfig.masterConstants);
+            if (this._data.upgradeConfig.masterCodeVersion !== this.poolConfig.masterVersion) {
                 throw Error(
-                    `Outdated SDK version. It supports only master code version ${TESTNET_VERSION} on testnet, but the current master code version is ${this._data.upgradeConfig.masterCodeVersion}`,
-                );
-            }
-            if (this.network === 'mainnet' && this._data.upgradeConfig.masterCodeVersion !== MAINNET_VERSION) {
-                throw Error(
-                    `Outdated SDK version. It supports only master code version ${MAINNET_VERSION} on mainnet, but the current master code version is ${this._data.upgradeConfig.masterCodeVersion}`,
+                    `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);
@@ -421,4 +421,12 @@ export class Evaa implements Contract {
             throw Error('Master contract is not active');
         }
     }
+
+    async getPrices(provider: ContractProvider, endpoints?: string[]) {
+        if ((endpoints?.length ?? 0) > 0) {
+            return await getPrices(endpoints, this.poolConfig.nftId);
+        } else {
+            return await getPrices(undefined, this.poolConfig.nftId);
+        }
+    }
 }

package/src/contracts/UserContract.ts

@@ -1,38 +1,39 @@
 import { Address, beginCell, Cell, Contract, ContractProvider, Dictionary, Sender, SendMode } from '@ton/core';
 import { UserData, UserLiteData } from '../types/User';
 import { parseUserData, parseUserLiteData } from '../api/parser';
-import { AssetConfig, ExtendedAssetData } from '../types/Master';
+import { AssetConfig, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, PoolConfig } from '../types/Master';
 import { LiquidationBaseData } from './MasterContract';
-import { MAINNET_ASSETS_ID, OPCODES } from '../constants';
+import { OPCODES } from '../constants/general';
+import { MAINNET_POOL_CONFIG } from '../constants/pools';
+import { TON_MAINNET } from '../constants/assets';
 
 /**
  * User contract wrapper
  */
 export class EvaaUser implements Contract {
     readonly address: Address;
-    readonly testnet: boolean = false;
     private lastSync = 0;
     private _liteData?: UserLiteData;
     private _data?: UserData;
+    private poolConfig: PoolConfig;
 
     /**
      * Create user contract wrapper from address
      * @param address user contract address
-     * @param testnet testnet flag
      */
-    static createFromAddress(address: Address, testnet: boolean = false) {
-        return new EvaaUser(address, testnet);
+    static createFromAddress(address: Address, poolConfig: PoolConfig = MAINNET_POOL_CONFIG) {
+        return new EvaaUser(address, poolConfig);
     }
 
-    private constructor(address: Address, testnet: boolean = false) {
+    private constructor(address: Address, poolConfig: PoolConfig = MAINNET_POOL_CONFIG) {
         this.address = address;
-        this.testnet = testnet;
+        this.poolConfig = poolConfig;
     }
 
     async getSyncLite(
         provider: ContractProvider,
-        assetsData: Dictionary<bigint, ExtendedAssetData>,
-        assetsConfig: Dictionary<bigint, AssetConfig>,
+        assetsData: ExtendedAssetsData,
+        assetsConfig: ExtendedAssetsConfig,
     ) {
         const state = (await provider.getState()).state;
         if (state.type === 'active') {
@@ -40,7 +41,8 @@ export class EvaaUser implements Contract {
                 state.data!.toString('base64'),
                 assetsData,
                 assetsConfig,
-                this.testnet,
+                this.poolConfig.poolAssetsConfig,
+                this.poolConfig.masterConstants
             );
             this.lastSync = Math.floor(Date.now() / 1000);
         } else {
@@ -57,12 +59,12 @@ export class EvaaUser implements Contract {
      * @returns true if user data was calculated
      */
     calculateUserData(
-        assetsData: Dictionary<bigint, ExtendedAssetData>,
-        assetsConfig: Dictionary<bigint, AssetConfig>,
+        assetsData: ExtendedAssetsData,
+        assetsConfig: ExtendedAssetsConfig,
         prices: Dictionary<bigint, bigint>,
     ): boolean {
         if (this._liteData) {
-            this._data = parseUserData(this._liteData, assetsData, assetsConfig, prices, this.testnet);
+            this._data = parseUserData(this._liteData, assetsData, assetsConfig, prices, this.poolConfig.poolAssetsConfig, this.poolConfig.masterConstants);
             return true;
         }
         return false;
@@ -92,8 +94,8 @@ export class EvaaUser implements Contract {
 
     async getSync(
         provider: ContractProvider,
-        assetsData: Dictionary<bigint, ExtendedAssetData>,
-        assetsConfig: Dictionary<bigint, AssetConfig>,
+        assetsData: ExtendedAssetsData,
+        assetsConfig: ExtendedAssetsConfig,
         prices: Dictionary<bigint, bigint>,
     ) {
         const state = (await provider.getState()).state;
@@ -102,9 +104,10 @@ export class EvaaUser implements Contract {
                 state.data!.toString('base64'),
                 assetsData,
                 assetsConfig,
-                this.testnet,
+                this.poolConfig.poolAssetsConfig,
+                this.poolConfig.masterConstants
             );
-            this._data = parseUserData(this._liteData, assetsData, assetsConfig, prices, this.testnet);
+            this._data = parseUserData(this._liteData, assetsData, assetsConfig, prices, this.poolConfig.poolAssetsConfig, this.poolConfig.masterConstants);
             this.lastSync = Math.floor(Date.now() / 1000);
         } else {
             this._data = { type: 'inactive' };
@@ -154,7 +157,7 @@ export class EvaaUser implements Contract {
             collateralAsset: this._data.liquidationData.greatestCollateralAsset,
             minCollateralAmount: this._data.liquidationData.minCollateralAmount,
             liquidationAmount: this._data.liquidationData.liquidationAmount,
-            tonLiquidation: this._data.liquidationData.greatestLoanAsset === MAINNET_ASSETS_ID.TON,
+            tonLiquidation: this._data.liquidationData.greatestLoanAsset === TON_MAINNET.assetId,
         };
     }
 }

package/src/index.ts

@@ -9,6 +9,7 @@ export {
     calculateAssetData,
     calculateAssetInterest,
     getAvailableToBorrow,
+    calculateMaximumWithdrawAmount,
     presentValue,
     calculateLiquidationData,
 } from './api/math';
@@ -45,6 +46,11 @@ export {
     AssetApy,
     ExtendedAssetData,
     MasterData,
+    PoolConfig,
+    ExtendedAssetsData,
+    ExtendedAssetsConfig,
+    PoolAssetConfig,
+    PoolAssetsConfig,
 } from './types/Master';
 export {
     BalanceType,
@@ -65,12 +71,35 @@ export {
     MAINNET_VERSION,
     EVAA_MASTER_TESTNET,
     TESTNET_VERSION,
-    JETTON_MASTER_ADDRESSES,
-    MASTER_CONSTANTS,
     LENDING_CODE,
     OPCODES,
     FEES,
-} from './constants';
+    MASTER_CONSTANTS
+} from './constants/general';
+
+export {
+    MAINNET_POOL_CONFIG,
+    TESTNET_POOL_CONFIG,
+    MAINNET_LP_POOL_CONFIG,
+    TESTNET_LP_POOL_CONFIG
+} from './constants/pools';
+
+export {
+    TON_MAINNET,
+    USDT_MAINNET,
+    TONUSDT_DEDUST_MAINNET,
+    TON_STORM_MAINNET,
+    USDT_STORM_MAINNET,
+    JUSDT_MAINNET,
+    JUSDC_MAINNET,
+    STTON_MAINNET,
+    TSTON_MAINNET,
+    JUSDT_TESTNET,
+    JUSDC_TESTNET,
+    STTON_TESTNET,
+} from './constants/assets';
+
+export * from './constants/assets'
 
 // Utils
 export { getLastSentBoc, getTonConnectSender } from './utils/tonConnectSender';

package/src/types/Master.ts

@@ -1,5 +1,38 @@
 import { Address, Cell, Dictionary } from '@ton/core';
 
+export type MasterConstants = {
+    FACTOR_SCALE: bigint,
+    ASSET_COEFFICIENT_SCALE: bigint,
+    ASSET_PRICE_SCALE: bigint,
+    ASSET_RESERVE_FACTOR_SCALE: bigint,
+    ASSET_LIQUIDATION_RESERVE_FACTOR_SCALE: bigint,
+    ASSET_ORIGINATION_FEE_SCALE: bigint
+};
+
+export type PoolAssetConfig = (PoolTonAssetConfig | PoolJettonAssetConfig) & {
+    name: string;
+};
+export type PoolAssetsConfig = PoolAssetConfig[];
+
+export type PoolTonAssetConfig = {
+    assetId: bigint;
+}
+
+export type PoolJettonAssetConfig = {
+    assetId: bigint;
+    jettonMasterAddress: Address;
+    jettonWalletCode: Cell;
+}
+
+export type PoolConfig = {
+    masterAddress: Address;
+    masterVersion: number;
+    masterConstants: MasterConstants;
+    nftId: string;
+    poolAssetsConfig: PoolAssetsConfig;
+    lendingCode: Cell;
+};
+
 export type UpgradeConfig = {
     masterCodeVersion: number;
     userCodeVersion: number;
@@ -67,13 +100,15 @@ export type AssetApy = {
 };
 
 export type ExtendedAssetData = AssetData & AssetInterest & AssetApy;
+export type ExtendedAssetsData = Dictionary<bigint, ExtendedAssetData>;
+export type ExtendedAssetsConfig = Dictionary<bigint, AssetConfig>;
 
 export type MasterData = {
     meta: string;
     upgradeConfig: UpgradeConfig;
     masterConfig: MasterConfig;
-    assetsConfig: Dictionary<bigint, AssetConfig>;
-    assetsData: Dictionary<bigint, ExtendedAssetData>;
+    assetsConfig: ExtendedAssetsConfig;
+    assetsData: ExtendedAssetsData;
     assetsReserves: Dictionary<bigint, bigint>;
     apy: {
         supply: Dictionary<bigint, number>;

package/src/types/User.ts

@@ -1,5 +1,5 @@
 import { Address, Cell, Dictionary } from '@ton/core';
-import { AssetConfig, ExtendedAssetData } from './Master';
+import { AssetConfig, ExtendedAssetData, ExtendedAssetsConfig, ExtendedAssetsData, MasterConfig, MasterConstants } from './Master';
 
 export enum BalanceType {
     supply = 'supply',
@@ -88,6 +88,7 @@ export type PredictHealthFactorArgs = {
     tokenSymbol: string;
     balances: Dictionary<bigint, bigint>;
     prices: Dictionary<bigint, bigint>;
-    assetsData: Dictionary<bigint, ExtendedAssetData>;
-    assetsConfig: Dictionary<bigint, AssetConfig>;
+    assetsData: ExtendedAssetsData;
+    assetsConfig: ExtendedAssetsConfig;
+    masterConstants: MasterConstants;
 };

package/src/utils/userJettonWallet.ts

@@ -1,68 +1,72 @@
 import { Address, beginCell, Cell, storeStateInit } from '@ton/core';
-import { JETTON_MASTER_ADDRESSES, JETTON_WALLETS_CODE, MAINNET_ASSETS_ID } from '../constants';
+import { PoolAssetConfig, PoolJettonAssetConfig } from '../types/Master';
+
+export function getUserJettonWallet(ownerAddress: Address, poolAssetConfig: PoolAssetConfig & PoolJettonAssetConfig) {
+    const jettonMasterAddress = poolAssetConfig.jettonMasterAddress;
+    const jettonWalletCode = poolAssetConfig.jettonWalletCode;
+
+  if (poolAssetConfig.name === 'USDT') {
+    const lib_prep = beginCell().storeUint(2, 8).storeBuffer(jettonWalletCode.hash()).endCell();
+    const jwallet_code = new Cell({ exotic: true, bits: lib_prep.bits, refs: lib_prep.refs });
+
+    const jettonData = beginCell()
+      .storeUint(0, 4)
+      .storeCoins(0)
+      .storeAddress(ownerAddress)
+      .storeAddress(jettonMasterAddress)
+      .endCell();
+
+    const stateInit = beginCell()
+      .store(
+        storeStateInit({
+          code: jwallet_code,
+          data: jettonData
+        })
+      )
+      .endCell();
+    return new Address(0, stateInit.hash());
+  }
+
+  if (poolAssetConfig.name === 'tsTON') {
+    const lib_prep = beginCell().storeUint(2, 8).storeBuffer(jettonWalletCode.hash()).endCell();
+    const jwallet_code = new Cell({ exotic: true, bits: lib_prep.bits, refs: lib_prep.refs });
+
+    const jettonData = beginCell()
+      .storeCoins(0)
+      .storeAddress(ownerAddress)
+      .storeAddress(jettonMasterAddress)
+      .storeRef(jwallet_code)
+      .storeCoins(0)
+      .storeUint(0, 48)
+      .endCell();
 
-export function getUserJettonWallet(ownerAddress: Address, assetID: bigint, network: 'mainnet' | 'testnet'): Address {
-    const builder = beginCell().storeCoins(0).storeAddress(ownerAddress);
-    let jettonWalletCode: Cell;
-    switch (assetID) {
-        case MAINNET_ASSETS_ID.jUSDT:
-            if (network === 'mainnet') {
-                builder.storeAddress(JETTON_MASTER_ADDRESSES.jUSDT_MAINNET);
-                jettonWalletCode = JETTON_WALLETS_CODE.jUSDT_MAINNET;
-            } else {
-                builder.storeAddress(JETTON_MASTER_ADDRESSES.jUSDT_TESTNET);
-                jettonWalletCode = JETTON_WALLETS_CODE.jUSDT_TESTNET;
-            }
-            break;
-        case MAINNET_ASSETS_ID.jUSDC:
-            if (network === 'mainnet') {
-                builder.storeAddress(JETTON_MASTER_ADDRESSES.jUSDC_MAINNET);
-                jettonWalletCode = JETTON_WALLETS_CODE.jUSDC_MAINNET;
-            } else {
-                builder.storeAddress(JETTON_MASTER_ADDRESSES.jUSDC_TESTNET);
-                jettonWalletCode = JETTON_WALLETS_CODE.jUSDC_TESTNET;
-            }
-            break;
-        case MAINNET_ASSETS_ID.stTON:
-            if (network === 'mainnet') {
-                builder.storeAddress(JETTON_MASTER_ADDRESSES.stTON_MAINNET);
-                jettonWalletCode = JETTON_WALLETS_CODE.stTON_MAINNET;
-            } else {
-                builder.storeAddress(JETTON_MASTER_ADDRESSES.stTON_TESTNET);
-                jettonWalletCode = JETTON_WALLETS_CODE.stTON_TESTNET;
-            }
-            break;
-        case MAINNET_ASSETS_ID.tsTON:
-            if (network === 'mainnet') {
-                builder.storeAddress(JETTON_MASTER_ADDRESSES.tsTON_MAINNET);
-                jettonWalletCode = JETTON_WALLETS_CODE.tsTON_MAINNET;
-            } else {
-                // builder.storeAddress(JETTON_MASTER_ADDRESSES.tsTON_TESTNET);
-                // jettonWalletCode = JETTON_WALLETS_CODE.tsTON_TESTNET;
-                throw new Error('tsTON is not supported on testnet');
-            }
-            break;
-        case MAINNET_ASSETS_ID.USDT:
-            if (network === 'mainnet') {
-                builder.storeAddress(JETTON_MASTER_ADDRESSES.USDT_MAINNET);
-                jettonWalletCode = JETTON_WALLETS_CODE.USDT_MAINNET;
-            } else {
-                // builder.storeAddress(JETTON_MASTER_ADDRESSES.USDT_TESTNET);
-                // jettonWalletCode = JETTON_WALLETS_CODE.USDT_TESTNET;
-                throw new Error('USDT is not supported on testnet');
-            }
-            break;
-        default:
-            throw new Error('Unsupported asset');
-    }
-    const data = builder.storeRef(jettonWalletCode).endCell();
     const stateInit = beginCell()
-        .store(
-            storeStateInit({
-                code: jettonWalletCode,
-                data: data,
-            }),
-        )
-        .endCell();
+      .store(
+        storeStateInit({
+          code: jwallet_code,
+          data: jettonData
+        })
+      )
+      .endCell();
+
     return new Address(0, stateInit.hash());
+  }
+
+  const jettonData = beginCell()
+    .storeCoins(0)
+    .storeAddress(ownerAddress)
+    .storeAddress(jettonMasterAddress)
+    .storeRef(jettonWalletCode)
+    .endCell();
+
+  const stateInit = beginCell()
+    .store(
+      storeStateInit({
+        code: jettonWalletCode,
+        data: jettonData
+      })
+    )
+    .endCell();
+
+  return new Address(0, stateInit.hash());
 }