@evaafi/sdk 0.2.0

package/src/types/User.ts

@@ -0,0 +1,66 @@
+import { Address, Cell, Dictionary } from '@ton/core';
+
+export enum BalanceType {
+    supply = 'supply',
+    borrow = 'borrow',
+}
+
+export type UserBalance = {
+    amount: bigint;
+    type?: BalanceType;
+};
+
+export type UserLiqudationData = {
+    greatestCollateralValue: bigint;
+    greatestCollateralAsset: bigint;
+    greatestLoanValue: bigint;
+    greatestLoanAsset: bigint;
+    totalDebt: bigint;
+    totalLimit: bigint;
+};
+
+export type LiquidableData = UserLiqudationData & {
+    liquidable: true;
+    liquidationAmount: bigint;
+    minCollateralAmount: bigint;
+};
+
+export type NonLiquidableData = UserLiqudationData & {
+    liquidable: false;
+};
+
+export type LiquidationData = LiquidableData | NonLiquidableData;
+
+export type UserLiteData = {
+    type: 'active';
+    codeVersion: number;
+    masterAddress: Address;
+    ownerAddress: Address;
+    principals: Dictionary<bigint, bigint>;
+    state: number;
+    balances: Dictionary<bigint, UserBalance>;
+    trackingSupplyIndex: bigint;
+    trackingBorrowIndex: bigint;
+    dutchAuctionStart: number;
+    backupCell: Cell;
+};
+
+export type UserDataActive = UserLiteData & {
+    withdrawalLimits: Dictionary<bigint, bigint>;
+    borrowLimits: Dictionary<bigint, bigint>;
+    repayLimits?: Dictionary<bigint, bigint>;
+    supplyBalance: bigint;
+    borrowBalance: bigint;
+    availableToBorrow: bigint;
+    limitUsedPercent: number;
+    limitUsed: bigint;
+    healthFactor: number;
+
+    liquidationData: LiquidationData;
+};
+
+export type UserDataInactive = {
+    type: 'inactive';
+};
+
+export type UserData = UserDataActive | UserDataInactive;

package/src/utils/sha256BigInt.ts

@@ -0,0 +1,7 @@
+import sha256 from 'crypto-js/sha256';
+
+export function sha256Hash(input: string): bigint {
+    const hash = sha256(input);
+    const hashHex = hash.toString();
+    return BigInt('0x' + hashHex);
+}

package/src/utils/tonConnectSender.ts

@@ -0,0 +1,37 @@
+import { ITonConnect, SendTransactionResponse } from '@tonconnect/sdk';
+import { Address, beginCell, Sender, SenderArguments, storeStateInit } from '@ton/core';
+
+/*
+This is not the best solution to get the BOC of the sent external message, however the Sender
+interface does not support returning any value from send(), so at the moment you can get it from
+this global variable.
+ */
+let lastSentBoc: SendTransactionResponse | undefined;
+
+export function getLastSentBoc() {
+    return lastSentBoc;
+}
+
+export function getTonConnectSender(connector: ITonConnect): Sender {
+    return {
+        get address(): Address | undefined {
+            return connector.account ? Address.parse(connector.account.address) : undefined;
+        },
+
+        async send(args: SenderArguments): Promise<void> {
+            lastSentBoc = await connector.sendTransaction({
+                validUntil: Date.now() + 2 * 60 * 1000, // 1 minutes
+                messages: [
+                    {
+                        address: args.to.toString(),
+                        amount: args.value.toString(),
+                        payload: args.body?.toBoc().toString('base64'),
+                        stateInit: args.init
+                            ? beginCell().store(storeStateInit(args.init)).endCell().toBoc().toString('base64')
+                            : undefined,
+                    },
+                ],
+            });
+        },
+    };
+}

package/src/utils/userJettonWallet.ts

@@ -0,0 +1,34 @@
+import { Address, beginCell, storeStateInit } from '@ton/core';
+import { ASSET_ID, JETTON_MASTER_ADDRESSES, JETTON_WALLET_CODE } from '../constants';
+
+export function getUserJettonWallet(ownerAddress: Address, assetID: bigint, network: 'mainnet' | 'testnet'): Address {
+    const builder = beginCell().storeCoins(0).storeAddress(ownerAddress);
+    switch (assetID) {
+        case ASSET_ID.jUSDT:
+            if (network === 'mainnet') {
+                builder.storeAddress(JETTON_MASTER_ADDRESSES.jUSDT_MAINNET);
+            } else {
+                builder.storeAddress(JETTON_MASTER_ADDRESSES.jUSDT_TESTNET);
+            }
+            break;
+        case ASSET_ID.jUSDC:
+            if (network === 'mainnet') {
+                builder.storeAddress(JETTON_MASTER_ADDRESSES.jUSDC_MAINNET);
+            } else {
+                builder.storeAddress(JETTON_MASTER_ADDRESSES.jUSDC_TESTNET);
+            }
+            break;
+        default:
+            throw new Error('Unsupported asset');
+    }
+    const data = builder.storeRef(JETTON_WALLET_CODE).endCell();
+    const stateInit = beginCell()
+        .store(
+            storeStateInit({
+                code: JETTON_WALLET_CODE,
+                data: data,
+            }),
+        )
+        .endCell();
+    return new Address(0, stateInit.hash());
+}