@gearbox-protocol/sdk 13.0.0-next.9 → 13.0.1

package/dist/esm/sdk/router/AbstractRouterContract.js

@@ -1,12 +1,8 @@
 import { BaseContract } from "../base/index.js";
 import { PERCENTAGE_FACTOR } from "../constants/math.js";
 import { AddressMap, AddressSet, formatBN, isDust } from "../utils/index.js";
-import { Hooks } from "../utils/internal/index.js";
 import { limitLeftover } from "./helpers.js";
 class AbstractRouterContract extends BaseContract {
-  hooks = new Hooks();
-  addHook = this.hooks.addHook.bind(this.hooks);
-  removeHook = this.hooks.removeHook.bind(this.hooks);
   sdk;
   constructor(sdk, args) {
     super(sdk, args);

package/dist/esm/sdk/router/RouterV310Contract.js

@@ -1,13 +1,11 @@
 import { getAddress } from "viem";
 import { gearboxRouterAbi } from "../../abi/router/gearboxRouter.js";
-import { BigIntMath } from "../sdk-legacy/index.js";
 import { AddressMap } from "../utils/AddressMap.js";
 import { formatBN } from "../utils/formatter.js";
 import { isDust } from "../utils/index.js";
 import { AbstractRouterContract } from "./AbstractRouterContract.js";
 import { assetsMap, balancesMap, limitLeftover } from "./helpers.js";
 const abi = gearboxRouterAbi;
-const ERR_NOT_IMPLEMENTED = new Error("Not implemented in router v3.1");
 class RouterV310Contract extends AbstractRouterContract {
   #numSplits = new AddressMap();
   #defaultNumSplits = 4n;
@@ -141,11 +139,6 @@ class RouterV310Contract extends AbstractRouterContract {
       props.creditAccount.creditAccount,
       tData
     ]);
-    if (props.calls.length > 0 && result.length === 0 && !!props.forceCalls) {
-      return {
-        calls: [...props.calls]
-      };
-    }
     return {
       calls: [...result]
     };
@@ -289,27 +282,6 @@ class RouterV310Contract extends AbstractRouterContract {
       claimRewards: t.claimRewards
     }));
   }
-  /**
-   * Implements {@link IRouterContract.findAllSwaps}
-   * @deprecated v3.0 legacy method
-   */
-  findAllSwaps(_) {
-    throw ERR_NOT_IMPLEMENTED;
-  }
-  /**
-   * Implements {@link IRouterContract.getAvailableConnectors}
-   * @deprecated v3.0 legacy method
-   */
-  getAvailableConnectors(_) {
-    throw ERR_NOT_IMPLEMENTED;
-  }
-  /**
-   * Implements {@link IRouterContract.getFindClosePathInput}
-   * @deprecated v3.0 legacy method
-   */
-  getFindClosePathInput(_, __, ___) {
-    throw ERR_NOT_IMPLEMENTED;
-  }
 }
 function balancesAfterOpen(target, targetAmount, expected, leftover) {
   const result = {};
@@ -323,10 +295,9 @@ function balancesAfterOpen(target, targetAmount, expected, leftover) {
     if (t === targetAddr) {
       result[t] = (expected.get(t) ?? 0n) + targetAmount;
     } else {
-      result[t] = BigIntMath.min(
-        expected.get(t) ?? 0n,
-        limitLeftover(leftover.get(t), t) ?? 0n
-      );
+      const exp = expected.get(t) ?? 0n;
+      const left = limitLeftover(leftover.get(t), t) ?? 0n;
+      result[t] = exp < left ? exp : left;
     }
   }
   return result;

package/dist/esm/sdk/router/createRouter.js

@@ -1,14 +1,10 @@
-import { isV300, isV310 } from "../constants/index.js";
-import { RouterV300Contract } from "./RouterV300Contract.js";
+import { isV310 } from "../constants/index.js";
 import { RouterV310Contract } from "./RouterV310Contract.js";
 function createRouter(sdk, address, version) {
   const contract = sdk.getContract(address);
   if (contract) {
     return contract;
   }
-  if (isV300(version)) {
-    return new RouterV300Contract(sdk, address, version);
-  }
   if (isV310(version)) {
     return new RouterV310Contract(sdk, address, version);
   }

package/dist/esm/sdk/router/helpers.js

@@ -2,9 +2,6 @@ import { AddressMap } from "../utils/index.js";
 function balancesMap(assets) {
   return new AddressMap(assets.map(({ token, balance }) => [token, balance]));
 }
-function compareRouterResults(a, b) {
-  return a.amount > b.amount ? a : b;
-}
 function assetsMap(assets) {
   return new AddressMap(assets.map((a) => [a.token, a]));
 }
@@ -20,6 +17,5 @@ function limitLeftover(balance, token) {
 export {
   assetsMap,
   balancesMap,
-  compareRouterResults,
   limitLeftover
 };

package/dist/esm/sdk/router/index.js

@@ -1,6 +1,5 @@
 export * from "./createRouter.js";
 import { assetsMap } from "./helpers.js";
-export * from "./RouterV300Contract.js";
 export * from "./RouterV310Contract.js";
 export * from "./types.js";
 export {

package/dist/esm/sdk/utils/abi-decode.js

@@ -1,8 +1,19 @@
 import {
   AbiFunctionNotFoundError,
-  getAbiItem
+  getAbiItem,
+  toFunctionSelector,
+  toFunctionSignature
 } from "viem";
 import { json_stringify } from "../../sdk/utils/index.js";
+function getFunctionSignature(abi, calldataOrSelector) {
+  const selector = calldataOrSelector.slice(0, 10);
+  for (const item of abi) {
+    if (item.type === "function" && toFunctionSelector(item) === selector) {
+      return toFunctionSignature(item);
+    }
+  }
+  throw new Error(`Function with selector ${selector} not found in ABI`);
+}
 function functionArgsToMap(abi, functionName, args) {
   const abiItem = getAbiItem({
     abi,
@@ -32,6 +43,36 @@ function functionArgsToMap(abi, functionName, args) {
   }
   return namedArgs;
 }
+function functionArgsToRecord(abi, functionName, args) {
+  const abiItem = getAbiItem({
+    abi,
+    name: functionName,
+    args
+  });
+  if (!abiItem || abiItem.type !== "function") {
+    throw new AbiFunctionNotFoundError(functionName);
+  }
+  const namedArgs = {};
+  if (Array.isArray(args)) {
+    args.forEach((value, i) => {
+      const input = abiItem.inputs?.[i];
+      const key = input?.name || `${i}`;
+      namedArgs[key] = value;
+    });
+  } else {
+    Object.entries(args || {}).forEach(([key, value]) => {
+      const index = parseInt(key, 10);
+      if (!Number.isNaN(index) && abiItem.inputs?.[index]?.name) {
+        namedArgs[abiItem.inputs[index].name] = value;
+      } else {
+        namedArgs[key] = value;
+      }
+    });
+  }
+  return namedArgs;
+}
 export {
-  functionArgsToMap
+  functionArgsToMap,
+  functionArgsToRecord,
+  getFunctionSignature
 };

package/dist/esm/sdk/utils/formatter.js

@@ -1,4 +1,6 @@
 import { formatDuration as fmtDuration, intervalToDuration } from "date-fns";
+import Decimal from "decimal.js-light";
+import { LEVERAGE_DECIMALS, PERCENTAGE_FACTOR } from "../constants/index.js";
 const toBigInt = (v) => {
   const value = typeof v === "object" && v.type === "BigNumber" ? v.hex : v.toString();
   return BigInt(value);
@@ -98,14 +100,48 @@ function formatTimestamp(timestamp, raw = true) {
   });
   return raw ? `${result} [${timestamp}]` : result;
 }
+function rayToNumber(num) {
+  return Number(toBigInt(num) / 10n ** 21n) / 1e6;
+}
+function toSignificant(num, decimals, precision = 6) {
+  if (num === 1n) return "0";
+  const divider = new Decimal(10).toPower(decimals);
+  const number = new Decimal(num.toString()).div(divider);
+  return number.toSignificantDigits(precision, 4).toString();
+}
+function toBN(num, decimals) {
+  if (num === "") return 0n;
+  const multiplier = new Decimal(10).toPower(decimals);
+  const number = new Decimal(num).mul(multiplier);
+  return BigInt(number.toFixed(0));
+}
+function shortAddress(address) {
+  return address === void 0 ? "" : `${address.slice(0, 6)}...${address.slice(address.length - 4)}`;
+}
+function shortHash(address) {
+  return address === void 0 ? "" : `${address.slice(0, 5)}...`;
+}
+function formatPercentage(healthFactor, decimals = 2) {
+  return (healthFactor / Number(PERCENTAGE_FACTOR)).toFixed(decimals);
+}
+function formatLeverage(leverage, decimals = 2) {
+  return (leverage / Number(LEVERAGE_DECIMALS)).toFixed(decimals);
+}
 export {
   fmtBinaryMask,
   formatBN,
   formatBNvalue,
   formatDuration,
+  formatLeverage,
   formatNumberToString_,
+  formatPercentage,
   formatTimestamp,
   numberWithCommas,
   percentFmt,
-  toBigInt
+  rayToNumber,
+  shortAddress,
+  shortHash,
+  toBN,
+  toBigInt,
+  toSignificant
 };

package/dist/types/abi/310/iLinearInterestRateModelV310.d.ts

@@ -0,0 +1,111 @@
+export declare const iLinearInterestRateModelV310Abi: readonly [{
+    readonly type: "function";
+    readonly name: "availableToBorrow";
+    readonly inputs: readonly [{
+        readonly name: "expectedLiquidity";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "availableLiquidity";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "calcBorrowRate";
+    readonly inputs: readonly [{
+        readonly name: "expectedLiquidity";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "availableLiquidity";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "checkOptimalBorrowing";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "contractType";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getModelParameters";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "U_1";
+        readonly type: "uint16";
+        readonly internalType: "uint16";
+    }, {
+        readonly name: "U_2";
+        readonly type: "uint16";
+        readonly internalType: "uint16";
+    }, {
+        readonly name: "R_base";
+        readonly type: "uint16";
+        readonly internalType: "uint16";
+    }, {
+        readonly name: "R_slope1";
+        readonly type: "uint16";
+        readonly internalType: "uint16";
+    }, {
+        readonly name: "R_slope2";
+        readonly type: "uint16";
+        readonly internalType: "uint16";
+    }, {
+        readonly name: "R_slope3";
+        readonly type: "uint16";
+        readonly internalType: "uint16";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "isBorrowingMoreU2Forbidden";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "serialize";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "serializedData";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "version";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }];
+    readonly stateMutability: "view";
+}];