fix: items

Author: grinry

apps/web-app/src/components/MoneyMarket/components/BorrowDialog/BorrowDialog.tsx

@@ -104,7 +104,7 @@ const BorrowDialogForm = () => {
   };
 
   const handleEscapes = (e: Event) => {
-    borrowRequestStore.getState().reset();
+    // borrowRequestStore.getState().reset();
     e.preventDefault();
   };
 

apps/web-app/src/components/MoneyMarket/components/LendDialog/LendDialog.tsx

@@ -94,7 +94,7 @@ const LendDialogForm = () => {
   };
 
   const handleEscapes = (e: Event) => {
-    lendRequestStore.getState().reset();
+    // lendRequestStore.getState().reset();
     e.preventDefault();
   };
 

apps/web-app/src/components/MoneyMarket/components/WithdrawDialog/WithdrawDialog.tsx

@@ -13,6 +13,7 @@ import { Item, ItemContent, ItemGroup } from '@/components/ui/item';
 import { useAppForm } from '@/hooks/app-form';
 import { sdk } from '@/lib/sdk';
 import { useSlayerTx } from '@/lib/transactions';
+import { shouldUseFullAmount } from '@/lib/utils';
 import { validateDecimal } from '@/lib/validations';
 import { Decimal } from '@sovryn/slayer-shared';
 import { useMemo } from 'react';
@@ -101,8 +102,9 @@ const WithdrawDialogForm = () => {
             token: position.token,
           },
           value.amount,
-          // if max amount + summary.borrowPowerUsed.eq(0) then flag it as true
-          false,
+          // if position can be withdrawn in full and user entered near full amount, use full withdrawal to avoid dust issues
+          maximumWithdrawAmount.eq(position.supplied) &&
+            shouldUseFullAmount(value.amount, position.supplied),
           {
             account: address!,
           },
@@ -124,7 +126,7 @@ const WithdrawDialogForm = () => {
   };
 
   const handleEscapes = (e: Event) => {
-    withdrawRequestStore.getState().reset();
+    // withdrawRequestStore.getState().reset();
     e.preventDefault();
   };
 

apps/web-app/src/lib/transactions/index.ts

@@ -1,9 +1,12 @@
 import type { SdkTransactionRequest } from '@sovryn/slayer-sdk';
+import debug from 'debug';
 import { useCallback, useEffect } from 'react';
 import type { Account, Chain } from 'viem';
 import { useStore } from 'zustand';
 import { txStore, type TxHandlers } from './store';
 
+const log = debug('slayer-app:useSlayerTx');
+
 export const useSlayerTx = <chain extends Chain, account extends Account>(
   handlers: TxHandlers = {},
 ) => {
@@ -12,14 +15,18 @@ export const useSlayerTx = <chain extends Chain, account extends Account>(
   const begin = useCallback(
     async (waitFor: () => Promise<SdkTransactionRequest<chain, account>[]>) => {
       setIsFetching(true);
+      log('Beginning transaction preparation...');
       if (waitFor) {
         const txs = await waitFor();
+        log('Prepared transactions:', txs);
         setItems(txs);
         setHandlers(handlers);
         return new Promise<boolean>((resolve) => {
           const originalOnClosed = handlers.onClosed;
           handlers.onClosed = (withSuccess: boolean) => {
+            log('Transaction modal closed with success:', withSuccess);
             if (originalOnClosed) {
+              log('Calling onClosed handler with success:', withSuccess);
               originalOnClosed(withSuccess);
             }
             resolve(withSuccess);

apps/web-app/src/lib/utils.ts

@@ -7,11 +7,14 @@ export function cn(...inputs: Array<ClassValue>) {
   return twMerge(clsx(inputs));
 }
 
-export function isFullAmount<T extends Decimalish = Decimalish>(
+// if value is within percentageThreshold of total, return true
+// e.g. value=99, total=100, percentageThreshold=1 => true
+// it helps to decide whether to use full amount in cases like withdrawing nearly all supplied assets
+export function shouldUseFullAmount<T extends Decimalish = Decimalish>(
   value: T,
   total: T,
-  // default to 0.1% threshold
-  percentageThreshold = 0.1,
+  // default to 0.5% (half percent) threshold
+  percentageThreshold = 0.5,
 ): boolean {
   const decimalValue = Decimal.from(value);
   const decimalTotal = Decimal.from(total);

packages/sdk/src/managers/money-market/money-market.manager.ts

@@ -1,5 +1,7 @@
 import { areAddressesEqual, Decimal, Decimalish } from '@sovryn/slayer-shared';
+import debug from 'debug';
 import { Account, Address, encodeFunctionData, type Chain } from 'viem';
+import { bobSepolia } from 'viem/chains';
 import { BaseClient, type SdkRequestOptions } from '../../lib/context.js';
 import { buildQuery, toAddress } from '../../lib/helpers.js';
 import {
@@ -16,6 +18,12 @@ import {
   TransactionOpts,
 } from '../../types.js';
 
+const log = debug('slayer-sdk:managers:money-market');
+
+const aWETH = {
+  [bobSepolia.id]: '0x63719589aC40057556a791FAa701264567b5b627',
+} as const;
+
 const poolAbi = [
   {
     type: 'function',
@@ -63,17 +71,6 @@ const poolAbi = [
     ],
     outputs: [],
   },
-  {
-    type: 'function',
-    name: 'withdrawETH',
-    stateMutability: 'nonpayable',
-    inputs: [
-      { type: 'address', name: 'pool' },
-      { type: 'uint256', name: 'amount' },
-      { type: 'address', name: 'to' },
-    ],
-    outputs: [],
-  },
   {
     type: 'function',
     name: 'setUserUseReserveAsCollateral',
@@ -123,6 +120,18 @@ const wethGatewayAbi = [
     ],
     outputs: [],
   },
+
+  {
+    type: 'function',
+    name: 'withdrawETH',
+    stateMutability: 'nonpayable',
+    inputs: [
+      { type: 'address', name: 'pool' },
+      { type: 'uint256', name: 'amount' },
+      { type: 'address', name: 'to' },
+    ],
+    outputs: [],
+  },
 ] as const;
 
 export class MoneyMarketManager<chain extends Chain> extends BaseClient<chain> {
@@ -323,9 +332,21 @@ export class MoneyMarketManager<chain extends Chain> extends BaseClient<chain> {
     const pool = reserve.pool;
     const value = Decimal.from(amount);
 
+    log(
+      `Preparing withdraw of ${value.toString()} ${asset.symbol} from pool ${pool.id}`,
+      { reserve, amount, isMaxAmount, opts },
+    );
+
     if (asset.isNative || areAddressesEqual(asset.address, pool.weth)) {
+      const aWethAddress = aWETH[this.ctx.chainId as keyof typeof aWETH];
+      if (!aWethAddress) {
+        throw new Error(
+          `aWETH address not configured for chain ${this.ctx.chainId}`,
+        );
+      }
+
       const approval = await makeApprovalTransaction({
-        token: pool.weth,
+        token: aWethAddress,
         spender: pool.wethGateway,
         amount: isMaxAmount
           ? Decimal.MAX_UINT_256.toBigInt()
@@ -350,12 +371,12 @@ export class MoneyMarketManager<chain extends Chain> extends BaseClient<chain> {
           title: `Withdraw ${asset.symbol}`,
           description: `Withdraw ${value.toString()} ${asset.symbol}`,
           request: makeTransactionRequest({
-            to: pool.address,
+            to: pool.wethGateway,
             value: 0n,
             chain: this.ctx.publicClient.chain,
             account: opts.account,
             data: encodeFunctionData({
-              abi: poolAbi,
+              abi: wethGatewayAbi,
               functionName: 'withdrawETH',
               args: [
                 toAddress(pool.address),

packages/shared/src/lib/decimal.ts

@@ -11,6 +11,7 @@ D.set({
 });
 
 const DEFAULT_PRECISION = 18;
+const MAX_UINT_128 = '0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF';
 const MAX_UINT_256 =
   '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff';
 
@@ -24,12 +25,19 @@ export class Decimal {
 
   static ZERO = new Decimal('0');
   static ONE = new Decimal('1');
-  static INFINITY = new Decimal('Infinity', 0);
-  static MAX_UINT_256 = new Decimal(MAX_UINT_256, 0);
+  static INFINITY = new Decimal(MAX_UINT_256, 0).sub('1', 0);
+  static MAX_UINT_128 = new Decimal(MAX_UINT_128, 0).sub('1', 0);
+  static MAX_UINT_256 = new Decimal(MAX_UINT_256, 0).sub('1', 0);
 
   static DEFAULT_PRECISION = DEFAULT_PRECISION;
 
   constructor(value: string, precision: number = DEFAULT_PRECISION) {
+    if (value?.toLowerCase() === 'infinity') {
+      this.d = new D(MAX_UINT_256).sub(new D(1));
+      this.precision = 0;
+      return;
+    }
+
     this.d = new D(value);
     this.precision = precision;
   }
@@ -47,8 +55,8 @@ export class Decimal {
     }
 
     if (typeof value === 'string') {
-      if (value === 'Infinity') {
-        return new Decimal(MAX_UINT_256, 0);
+      if (value?.toLowerCase() === 'infinity') {
+        return new Decimal(MAX_UINT_256, 0).sub('1', 0);
       }
 
       if (!stringRepresentationFormat.test(value)) {