@gearbox-protocol/sdk 3.0.0-vfourabi.1 → 3.0.0-vfourabi.3

package/src/sdk/utils/AddressMap.ts

@@ -0,0 +1,111 @@
+import type { Address } from "viem";
+import { getAddress } from "viem";
+
+export class AddressMap<T> {
+  #map: Map<Address, T>;
+  #frozen = false;
+  #name?: string;
+
+  constructor(entries?: Array<[string, T]>, name?: string) {
+    this.#map = new Map<Address, T>();
+    if (entries) {
+      for (const [address, value] of entries) {
+        const key = getAddress(address);
+        this.#map.set(key, value);
+      }
+    }
+    this.#name = name;
+  }
+
+  /**
+   * Adds or updates value
+   * @param address
+   * @param value
+   */
+  public upsert(address: string, value: T): void {
+    if (this.#frozen) {
+      throw new Error(`AddressMap ${this.#name} is frozen`);
+    }
+    const key = getAddress(address);
+    this.#map.set(key, value);
+  }
+
+  /**
+   * Adds value, throws if this address is already used
+   * @param address
+   * @param value
+   */
+  public insert(address: string, value: T): void {
+    if (this.#frozen) {
+      throw new Error(`AddressMap ${this.#name} is frozen`);
+    }
+    const key = getAddress(address);
+    if (this.#map.has(key)) {
+      throw new Error(
+        `address ${address} already exists in ${this.#name ?? "map"}`,
+      );
+    }
+    this.#map.set(key, value);
+  }
+
+  /**
+   * Checks if address is present in map
+   * @param address
+   * @returns
+   */
+  public has(address: string): boolean {
+    const key = getAddress(address);
+    return this.#map.has(key);
+  }
+
+  /**
+   * Returns value, or undefined if the address is not in map
+   * @param address
+   * @returns
+   */
+  public get(address: string): T | undefined {
+    const key = getAddress(address);
+    return this.#map.get(key);
+  }
+
+  /**
+   * Gets address from map, throws if not found
+   * @param address
+   * @returns
+   */
+  public mustGet(address: string): T {
+    const key = getAddress(address);
+    if (!this.#map.has(key)) {
+      throw new Error(`address ${address} not found in ${this.#name ?? "map"}`);
+    }
+    return this.#map.get(key)!;
+  }
+
+  public clear(): void {
+    this.#map.clear();
+  }
+
+  public entries(): Array<[Address, T]> {
+    return Array.from(this.#map.entries());
+  }
+
+  public values(): T[] {
+    return Array.from(this.#map.values());
+  }
+
+  public keys(): Address[] {
+    return Array.from(this.#map.keys());
+  }
+
+  public asRecord(): Record<Address, T> {
+    return Object.fromEntries(this.#map.entries());
+  }
+
+  public get size(): number {
+    return this.#map.size;
+  }
+
+  public freeze(): void {
+    this.#frozen = true;
+  }
+}

package/src/sdk/utils/bytes32ToString.ts

@@ -0,0 +1,6 @@
+import type { Hex } from "viem";
+import { bytesToString, toBytes } from "viem";
+
+export function bytes32ToString(bytes: Hex): string {
+  return bytesToString(toBytes(bytes)).replaceAll("\x00", "");
+}

package/src/sdk/utils/childLogger.ts

@@ -0,0 +1,8 @@
+import type { ILogger } from "../types";
+
+export function childLogger(
+  module: string,
+  logger?: ILogger,
+): ILogger | undefined {
+  return logger?.child?.({ module }) ?? logger;
+}

package/src/sdk/utils/createRawTx.ts

@@ -0,0 +1,86 @@
+import type {
+  Abi,
+  Address,
+  ContractFunctionName,
+  EncodeFunctionDataParameters,
+  Hex,
+} from "viem";
+import {
+  concatHex,
+  encodeAbiParameters,
+  prepareEncodeFunctionData,
+} from "viem";
+import { formatAbiItem } from "viem/utils";
+
+import type { RawTx } from "../types";
+import { json_stringify } from "./json";
+
+/**
+ * @dev Creates a raw transaction data to be processed by the TxBatcher
+ * RawTx is a type that contains all the data needed to create different types of batches,
+ * like Multisig Safe batch over governor/timelock, or multisig direct call.
+ * Also RawTx data used to generate Governor execution batch, used to execute queued txs from EOA.
+ * @returns
+ */
+
+export function createRawTx<
+  const abi extends Abi | readonly unknown[],
+  functionName extends ContractFunctionName<abi> | undefined = undefined,
+>(
+  to: Address,
+  parameters: EncodeFunctionDataParameters<abi, functionName>,
+  description?: string,
+): RawTx {
+  const { args } = parameters as EncodeFunctionDataParameters;
+
+  const fname = parameters.functionName as string;
+
+  const { abi, functionName } = (() => {
+    if (
+      parameters.abi.length === 1 &&
+      parameters.functionName?.startsWith("0x")
+    )
+      return parameters as { abi: Abi; functionName: Hex };
+    return prepareEncodeFunctionData(parameters);
+  })();
+
+  const abiItem = abi[0];
+  const signature = functionName;
+
+  const data =
+    "inputs" in abiItem && abiItem.inputs
+      ? encodeAbiParameters(abiItem.inputs, args ?? [])
+      : undefined;
+  const functionEncodedData = concatHex([signature, data ?? "0x"]);
+
+  const inputs =
+    "inputs" in abiItem && abiItem.inputs ? [...abiItem.inputs] : [];
+
+  const payable = "payble" in abiItem ? abiItem.payble === true : false;
+
+  const contractInputsValues: Record<string, any> = {};
+
+  if (inputs.length > 0 && args && args.length !== 0) {
+    args.forEach((arg, i) => {
+      const methodName = inputs[i].name as string;
+      let stringifiedArg = arg instanceof BigInt ? arg.toString() : arg;
+      contractInputsValues[methodName] = Array.isArray(stringifiedArg)
+        ? json_stringify(stringifiedArg)
+        : stringifiedArg;
+    });
+  }
+
+  return {
+    to,
+    value: "0",
+    contractMethod: {
+      inputs,
+      name: fname,
+      payable,
+    },
+    signature: formatAbiItem(abiItem),
+    callData: functionEncodedData,
+    contractInputsValues,
+    description,
+  };
+}

package/src/sdk/utils/etherscan.ts

@@ -0,0 +1,42 @@
+import type { TransactionReceipt } from "viem";
+
+import type { CreditAccountData } from "../base";
+import type { NetworkType } from "../chain";
+
+export type EtherscanURLParam =
+  | { block: number }
+  | { tx: string }
+  | { address: string };
+
+export function etherscanUrl(
+  entity: EtherscanURLParam | TransactionReceipt | CreditAccountData,
+  network: NetworkType,
+): string {
+  let [prefix, domain] = ["", "etherscan.io"];
+
+  let param: EtherscanURLParam;
+  if ("transactionHash" in entity && "blockHash" in entity) {
+    param = { tx: entity.transactionHash };
+  } else if ("creditAccount" in entity && "creditManager" in entity) {
+    param = { address: entity.creditAccount };
+  } else {
+    param = entity;
+  }
+
+  switch (network) {
+    case "Optimism":
+      prefix = "optimistic.";
+      break;
+    case "Arbitrum":
+      domain = "arbiscan.io";
+      break;
+    case "Base":
+      domain = "basescan.org";
+      break;
+    case "Sonic":
+      domain = "sonicscan.org";
+      break;
+  }
+  const [key, value] = Object.entries(param)[0];
+  return `https://${prefix}${domain}/${key}/${value}`;
+}

package/src/sdk/utils/filterDust.ts

@@ -0,0 +1,20 @@
+import type { Address } from "viem";
+
+import type { CreditAccountData } from "../base";
+
+/**
+ * Helper function to filter out low-balance assets
+ * @param account
+ * @returns
+ */
+export function filterDust(
+  account: CreditAccountData,
+): Record<Address, bigint> {
+  const result: Record<Address, bigint> = {};
+  for (const { token, balance } of account.tokens) {
+    if (balance > 10n) {
+      result[token] = balance;
+    }
+  }
+  return result;
+}

package/src/sdk/utils/formatter.ts

@@ -0,0 +1,124 @@
+import { formatDuration as fmtDuration, intervalToDuration } from "date-fns";
+
+export const toBigInt = (
+  v: string | number | bigint | { type: "BigNumber"; hex: string },
+): bigint => {
+  const value =
+    typeof v === "object" && v.type === "BigNumber" ? v.hex : v.toString();
+  return BigInt(value);
+};
+
+export const percentFmt = (v: number | bigint | string, raw = true): string =>
+  `${(Number(v) / 100).toFixed(2)}%` + (raw ? ` [${v}]` : "");
+
+export function formatBNvalue(
+  num: number | bigint | string | undefined,
+  decimals: number,
+  precision?: number,
+  raw = true,
+): string {
+  return `${formatBN(num, decimals, precision)}` + (raw ? ` [ ${num} ]` : "");
+}
+
+export function formatBN(
+  num: number | bigint | string | undefined,
+  decimals: number,
+  precision?: number,
+): string {
+  if (num === undefined) {
+    return "-";
+  }
+  const numBInt = BigInt(num);
+  // GUSD: 2 decimals
+  const limitedNum = limitNum(numBInt, decimals);
+  const limitedPrecision = limitPrecision(limitedNum, precision);
+  return toHumanFormat(limitedNum, limitedPrecision);
+}
+
+const limitPrecision = (n: bigint, p?: number) => {
+  const notZero = n !== 0n;
+  if (n <= 10n && notZero) {
+    return 6;
+  }
+  if (n <= 100n && notZero) {
+    return 5;
+  }
+  if (n <= 1000n && notZero) {
+    return 4;
+  }
+  if (n <= 10000n && notZero) {
+    return 3;
+  }
+  if (p === undefined && n > 10n ** 21n) {
+    return 2;
+  }
+  if (p === undefined && n > 10n ** 24n) {
+    return 0;
+  }
+
+  return p;
+};
+
+const limitNum = (n: bigint, d = 18): bigint => {
+  let limited = n <= 2n ? 0n : n;
+  if (d <= 6) {
+    return limited * 10n ** BigInt(6 - d);
+  } else {
+    return limited / 10n ** BigInt(d - 6);
+  }
+};
+
+export function toHumanFormat(num: bigint, precision = 2): string {
+  if (num >= BigInt(1e15)) {
+    return `${formatBn4dig(num / BigInt(1e9), precision)}Bn`;
+  }
+
+  if (num >= BigInt(1e12)) {
+    return `${formatBn4dig(num / BigInt(1e6), precision)}M`;
+  }
+
+  if (num >= BigInt(1e9)) {
+    return `${formatBn4dig(num / BigInt(1e3), precision)}K`;
+  }
+
+  return formatBn4dig(num, precision);
+}
+
+export function formatBn4dig(num: bigint, precision = 2): string {
+  if (precision > 6) {
+    throw new Error("Precision is too high, try <= 6");
+  }
+
+  const numStr = num.toString();
+  if (numStr.length <= 6) {
+    const completed = "0".repeat(6 - numStr.length) + numStr;
+    return `0.${completed.slice(0, precision)}`;
+  }
+  return `${numStr.slice(0, numStr.length - 6)}.${numStr.slice(
+    numStr.length - 6,
+    numStr.length - 6 + precision,
+  )}`;
+}
+
+export function fmtBinaryMask(mask: bigint): string {
+  return mask.toString(2).padStart(64, "0");
+}
+
+export function numberWithCommas(x: number | bigint): string {
+  return x.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+}
+
+export function formatDuration(seconds: number, raw = true): string {
+  const now = Math.floor(Date.now() / 1_000) * 1_000;
+  const start = new Date(now);
+  const end = new Date(now + seconds * 1_000);
+  const duration = intervalToDuration({ start, end });
+
+  return `${fmtDuration(duration)}` + (raw ? `[${seconds.toString()}]` : "");
+}
+
+export function formatNumberToString_(value: bigint | number): string {
+  return value
+    .toLocaleString("en-US", { minimumIntegerDigits: 1, useGrouping: true })
+    .replaceAll(",", "_");
+}

package/src/sdk/utils/index.ts

@@ -0,0 +1,10 @@
+export * from "./AddressMap";
+export * from "./bytes32ToString";
+export * from "./childLogger";
+export * from "./createRawTx";
+export * from "./etherscan";
+export * from "./filterDust";
+export * from "./formatter";
+export * from "./json";
+export * from "./mappers";
+export * from "./retry";

package/src/sdk/utils/internal/Hooks.ts

@@ -0,0 +1,51 @@
+export interface IHooks<HookMap extends Record<string, any[]>> {
+  addHook: <K extends keyof HookMap>(
+    hookName: K,
+    fn: (...args: HookMap[K]) => void | Promise<void>,
+  ) => void;
+  removeHook: <K extends keyof HookMap>(
+    hookName: K,
+    fn: (...args: HookMap[K]) => void | Promise<void>,
+  ) => void;
+}
+
+export class Hooks<HookMap extends Record<string, any[]>>
+  implements IHooks<HookMap>
+{
+  #reg: {
+    [K in keyof HookMap]: Array<(...args: HookMap[K]) => void | Promise<void>>;
+  } = {} as any;
+
+  public addHook<K extends keyof HookMap>(
+    hookName: K,
+    fn: (...args: HookMap[K]) => void | Promise<void>,
+  ): void {
+    if (!this.#reg[hookName]) {
+      this.#reg[hookName] = [];
+    }
+    this.#reg[hookName].push(fn);
+  }
+
+  public removeHook<K extends keyof HookMap>(
+    hookName: K,
+    fn: (...args: HookMap[K]) => void | Promise<void>,
+  ): void {
+    if (!this.#reg[hookName]) {
+      return;
+    }
+    this.#reg[hookName] =
+      this.#reg[hookName]?.filter(hookFn => hookFn !== fn) ?? [];
+  }
+
+  public async triggerHooks<K extends keyof HookMap>(
+    hookName: K,
+    ...args: HookMap[K]
+  ): Promise<void> {
+    if (!this.#reg[hookName]) {
+      return;
+    }
+    for (const fn of this.#reg[hookName]) {
+      await fn(...args);
+    }
+  }
+}

package/src/sdk/utils/internal/index.ts

@@ -0,0 +1 @@
+export * from "./Hooks";

package/src/sdk/utils/json.ts

@@ -0,0 +1,27 @@
+// Wrapper around JSON stringify/parse methods to support bigint serialization
+
+function replacer(_key: string, value: any) {
+  if (typeof value === "bigint") {
+    return {
+      __type: "bigint",
+      __value: value.toString(),
+    };
+  } else {
+    return value;
+  }
+}
+
+function reviver(_key: string, value: any) {
+  if (value && value.__type === "bigint") {
+    return BigInt(value.__value);
+  }
+  return value;
+}
+
+export const json_stringify = (obj: any, space = 2) => {
+  return JSON.stringify(obj, replacer, space);
+};
+
+export const json_parse = (s: string) => {
+  return JSON.parse(s, reviver);
+};

package/src/sdk/utils/mappers.ts

@@ -0,0 +1,38 @@
+export type PartialRecord<K extends keyof any, T> = {
+  [P in K]?: T;
+};
+
+export type SupportedValue = string | number;
+
+export class TypedObjectUtils {
+  static keys = <K extends SupportedValue, T>(o: Record<K, T>): Array<K> =>
+    Object.keys(o) as Array<K>;
+
+  static entries = <K extends SupportedValue, T>(
+    o: Record<K, T>,
+  ): Array<[K, T]> => Object.entries(o) as Array<[K, T]>;
+
+  static fromEntries = <K extends SupportedValue, T>(
+    o: Array<[K, T]>,
+  ): Record<K, T> => Object.fromEntries(o) as Record<K, T>;
+
+  static swapKeyValue = <K extends SupportedValue, T extends SupportedValue>(
+    o: Record<K, T>,
+  ): Record<T, K> =>
+    TypedObjectUtils.entries(o).reduce(
+      (acc, [key, value]) => ({ ...acc, [value]: key }),
+      {} as Record<T, K>,
+    );
+
+  static keyToLowercase = <K extends SupportedValue, T>(
+    o: Record<K, T>,
+  ): Record<K, T> =>
+    TypedObjectUtils.entries(o).reduce(
+      (acc, [key, value]) => {
+        const keyTransformed =
+          typeof key === "string" ? key.toLowerCase() : key;
+        return { ...acc, [keyTransformed]: value };
+      },
+      {} as Record<K, T>,
+    );
+}

package/src/sdk/utils/retry.ts

@@ -0,0 +1,24 @@
+export interface RetryOptions {
+  attempts?: number;
+  interval?: number;
+}
+
+export async function retry<T>(
+  fn: () => Promise<T>,
+  options: RetryOptions = {},
+): Promise<T> {
+  const { attempts = 3, interval = 200 } = options;
+  let cause: any;
+  for (let i = 0; i < attempts; i++) {
+    try {
+      const result = await fn();
+      return result;
+    } catch (e) {
+      cause = e;
+      await new Promise(resolve => {
+        setTimeout(resolve, interval);
+      });
+    }
+  }
+  throw new Error(`all attempts failed: ${cause}`);
+}

package/src/sdk/utils/viem/detectNetwork.ts

@@ -0,0 +1,27 @@
+import type { Address, PublicClient } from "viem";
+
+import { ierc20Abi } from "../../../abi/iERC20";
+import { type NetworkType, SUPPORTED_CHAINS } from "../../chain";
+import { USDC } from "../../constants";
+
+const WELL_KNOWN_TOKENS: Record<NetworkType, Address> = {
+  ...USDC,
+  Sonic: "0x29219dd400f2Bf60E5a23d13Be72B486D4038894", // USDC_e
+};
+
+export async function detectNetwork(
+  client: PublicClient,
+): Promise<NetworkType> {
+  for (const chain of SUPPORTED_CHAINS) {
+    try {
+      await client.readContract({
+        abi: ierc20Abi,
+        address: WELL_KNOWN_TOKENS[chain],
+        functionName: "symbol",
+      });
+      return chain;
+    } catch {}
+  }
+
+  throw new Error("Unsupported network");
+}

package/src/sdk/utils/viem/index.ts

@@ -0,0 +1,3 @@
+export * from "./detectNetwork";
+export * from "./sendRawTx";
+export * from "./simulateMulticall";

package/src/sdk/utils/viem/sendRawTx.ts

@@ -0,0 +1,36 @@
+import type {
+  Account,
+  Chain,
+  Client,
+  SendTransactionReturnType,
+  Transport,
+} from "viem";
+import { sendTransaction } from "viem/actions";
+import { getAction } from "viem/utils";
+
+import type { RawTx } from "../../types";
+
+export interface SendRawTxParameters {
+  account?: Account;
+  tx: RawTx;
+}
+
+export async function sendRawTx<
+  chain extends Chain | undefined = Chain | undefined,
+>(
+  client: Client<Transport, chain, Account | undefined>,
+  params: SendRawTxParameters,
+): Promise<SendTransactionReturnType> {
+  const { account, tx } = params;
+  return getAction(
+    client,
+    sendTransaction,
+    "sendTransaction",
+  )({
+    // @ts-expect-error
+    account,
+    data: tx.callData,
+    to: tx.to,
+    value: BigInt(tx.value),
+  }) as Promise<SendTransactionReturnType>;
+}