@folks-finance/xchain-sdk 0.0.1

package/src/chains/evm/hub/utils/events.ts

@@ -0,0 +1,112 @@
+import type { FolksChainId } from "../../../../common/types/chain.js";
+import type { AccountId, LoanId } from "../../../../common/types/lending.js";
+import type { LoanTypeId } from "../../../../common/types/module.js";
+import type { AcceptInviteAddressEventParams, InviteAddressEventParams } from "../types/account.js";
+import type { CreateUserLoanEventParams, DeleteUserLoanEventParams } from "../types/loan.js";
+
+export async function fetchCreateUserLoanEvents(params: CreateUserLoanEventParams) {
+  const { loanManager, accountId, loanTypeIds, eventParams } = params;
+  const logs = await loanManager.getEvents.CreateUserLoan({ accountId }, eventParams);
+  return logs
+    .filter((log) => loanTypeIds === undefined || (log.args.loanTypeId && loanTypeIds.includes(log.args.loanTypeId)))
+    .map((log) => ({
+      blockNumber: log.blockNumber,
+      loanId: log.args.loanId as LoanId,
+      accountId,
+      loanTypeId: log.args.loanTypeId as LoanTypeId,
+    }));
+}
+
+export async function fetchDeleteUserLoanEvents(params: DeleteUserLoanEventParams) {
+  const { loanManager, accountId, eventParams } = params;
+  const logs = await loanManager.getEvents.DeleteUserLoan({ accountId }, eventParams);
+  return logs.map((log) => ({
+    blockNumber: log.blockNumber,
+    loanId: log.args.loanId,
+    accountId,
+  }));
+}
+
+export async function fetchUserLoanIds(params: CreateUserLoanEventParams): Promise<Map<LoanTypeId, Array<LoanId>>> {
+  const createdUserLoans = await fetchCreateUserLoanEvents(params);
+  const deletedUserLoans = await fetchDeleteUserLoanEvents(params);
+
+  // add created and remove deleted through counting
+  const loanIdsMap = new Map<LoanId, { loanTypeId: LoanTypeId; count: number }>();
+  for (const userLoan of createdUserLoans) {
+    const loanId = userLoan.loanId;
+    const loanIdCount = loanIdsMap.get(loanId);
+    if (!loanIdCount) loanIdsMap.set(loanId, { loanTypeId: userLoan.loanTypeId, count: 1 });
+    else loanIdCount.count++;
+  }
+  for (const userLoan of deletedUserLoans) {
+    const loanId = userLoan.loanId as LoanId;
+    const loanIdCount = loanIdsMap.get(loanId);
+    if (loanIdCount)
+      if (loanIdCount.count === 1) loanIdsMap.delete(loanId);
+      else loanIdCount.count--;
+  }
+
+  const loanTypeMap = new Map<LoanTypeId, Array<LoanId>>();
+
+  for (const [loanId, { loanTypeId }] of loanIdsMap.entries()) {
+    const loanTypeIds = loanTypeMap.get(loanTypeId);
+    if (!loanTypeIds) loanTypeMap.set(loanTypeId, [loanId]);
+    else loanTypeIds.push(loanId);
+  }
+
+  return loanTypeMap;
+}
+
+async function fetchReceivedInvitationEventByAddress(params: InviteAddressEventParams) {
+  const { eventParams, accountManager, address, folksChainId } = params;
+
+  const logs = await accountManager.getEvents.InviteAddress(
+    { inviteeAddr: address, inviteeChainId: folksChainId },
+    eventParams,
+  );
+  return logs.map((log) => ({
+    blockNumber: log.blockNumber,
+    accountId: log.args.accountId,
+    folksChainId: log.args.inviteeChainId,
+    id: `${log.args.accountId ?? ""}${log.args.inviteeChainId ?? ""}`,
+  }));
+}
+
+async function fetchAcceptedInvitationEventByAddress(params: AcceptInviteAddressEventParams) {
+  const { eventParams, accountManager, address, folksChainId } = params;
+
+  const logs = await accountManager.getEvents.AcceptInviteAddress(eventParams);
+  return logs
+    .filter((log) => log.args.addr === address && (folksChainId ? log.args.chainId === folksChainId : true))
+    .map((log) => ({
+      blockNumber: log.blockNumber,
+      accountId: log.args.accountId,
+      folksChainId: log.args.chainId,
+      id: `${log.args.accountId ?? ""}${log.args.chainId ?? ""}`,
+    }));
+}
+
+export async function fetchInvitationByAddress(params: InviteAddressEventParams) {
+  const receivedInvitations = await fetchReceivedInvitationEventByAddress(params);
+  const acceptedInvitations = await fetchAcceptedInvitationEventByAddress(params);
+
+  const allEvents = [...receivedInvitations, ...acceptedInvitations];
+  allEvents.sort((a, b) => Number(a.blockNumber) - Number(b.blockNumber));
+
+  const accountStatus = new Map();
+
+  for (const event of allEvents)
+    if (receivedInvitations.includes(event)) accountStatus.set(event.id, true);
+    else if (acceptedInvitations.includes(event)) accountStatus.set(event.id, false);
+
+  return {
+    address: params.address,
+    invitations: allEvents
+      .filter((log) => accountStatus.get(log.id))
+      .map((log) => ({
+        accountId: log.accountId as AccountId,
+        folksChainId: log.folksChainId as FolksChainId,
+      })),
+  };
+}

package/src/chains/evm/hub/utils/loan.ts

@@ -0,0 +1,60 @@
+import {
+  calcBorrowBalance,
+  calcBorrowInterestIndex,
+  calcStableInterestRate,
+} from "../../../../common/utils/formulae.js";
+import { unixTime } from "../../../../common/utils/math-lib.js";
+
+import type { LoanManagerUserLoanBorrow } from "../types/loan.js";
+import type { PoolInfo } from "../types/pool.js";
+
+export function initLoanBorrowInterests(isStable: boolean, poolInfo: PoolInfo): LoanManagerUserLoanBorrow {
+  const lastInterestIndex = isStable ? BigInt(1e18) : poolInfo.variableBorrowData.interestIndex[0];
+  const stableInterestRate = isStable ? poolInfo.stableBorrowData.interestRate[0] : 0n;
+  const lastStableUpdateTimestamp = isStable ? BigInt(unixTime()) : 0n;
+  return {
+    amount: 0n,
+    balance: 0n,
+    lastInterestIndex,
+    stableInterestRate,
+    lastStableUpdateTimestamp,
+    rewardIndex: 0n,
+  };
+}
+
+export function updateLoanBorrowInterests(
+  borrow: LoanManagerUserLoanBorrow,
+  amount: bigint,
+  poolInfo: PoolInfo,
+  isStableInterestRateToUpdate: boolean,
+): LoanManagerUserLoanBorrow {
+  if (borrow.lastStableUpdateTimestamp > 0) {
+    const oldInterestIndex = borrow.lastInterestIndex;
+    const oldStableInterestRate = borrow.stableInterestRate;
+    borrow.lastInterestIndex = calcBorrowInterestIndex(
+      [oldStableInterestRate, 18],
+      [oldInterestIndex, 18],
+      borrow.lastStableUpdateTimestamp,
+    )[0];
+    borrow.lastStableUpdateTimestamp = BigInt(unixTime());
+
+    borrow.balance = calcBorrowBalance(borrow.balance, [borrow.lastInterestIndex, 18], [oldInterestIndex, 18]);
+
+    if (isStableInterestRateToUpdate) {
+      borrow.stableInterestRate = calcStableInterestRate(
+        borrow.balance,
+        amount,
+        [oldStableInterestRate, 18],
+        poolInfo.stableBorrowData.interestRate,
+      )[0];
+    }
+  } else {
+    borrow.balance = calcBorrowBalance(borrow.balance, poolInfo.variableBorrowData.interestIndex, [
+      borrow.lastInterestIndex,
+      18,
+    ]);
+    borrow.lastInterestIndex = poolInfo.variableBorrowData.interestIndex[0];
+  }
+
+  return borrow;
+}