@gearbox-protocol/sdk 1.26.1 → 1.27.0

package/lib/tokens/tokens.spec.js

@@ -0,0 +1,110 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const chains_1 = require("../core/chains");
+const types_1 = require("../types");
+const multicall_1 = __importDefault(require("../utils/multicall"));
+const token_1 = require("./token");
+const erc20 = types_1.IERC20Metadata__factory.createInterface();
+const EXCEPTIONS_IN_SYMBOLS = {
+    Mainnet: {
+        // Our Symbol <-> On-chain Symbol
+        [token_1.tokenDataByNetwork.Mainnet.STETH]: "stETH",
+    },
+    Arbitrum: {
+        // Our Symbol <-> On-chain Symbol
+        [token_1.tokenDataByNetwork.Arbitrum.crvUSDTWBTCWETH]: "crv3crypto",
+        [token_1.tokenDataByNetwork.Arbitrum["50OHM_50WETH"]]: "50WETH_50OHM",
+    },
+};
+class TokenSuite {
+    provider;
+    network;
+    calls;
+    responses = {};
+    constructor(network) {
+        this.network = network;
+        const url = process.env[`${network.toUpperCase()}_TESTS_FORK`];
+        if (!url) {
+            throw new Error(`${network} provder not found in env`);
+        }
+        this.provider = new ethers_1.ethers.providers.StaticJsonRpcProvider(url, chains_1.CHAINS[network]);
+        // Omit NOT DEPLOYED
+        const entries = Object.entries(token_1.tokenDataByNetwork[network]).filter(([_, addr]) => addr?.startsWith("0x"));
+        this.calls = entries.map(([symbol, address]) => ({
+            address,
+            interface: erc20,
+            method: "symbol()",
+            key: symbol,
+        }));
+    }
+    async fetchSymbols() {
+        // even safe multicall fails when one of addresses is an EOA and not contract address
+        if (this.network === "Arbitrum") {
+            for (const call of this.calls) {
+                const c = types_1.IERC20Metadata__factory.connect(call.address, this.provider);
+                try {
+                    const s = await c.symbol();
+                    this.responses[call.key] = {
+                        address: call.address,
+                        symbol: this.sanitize(s),
+                    };
+                }
+                catch (e) {
+                    this.responses[call.key] = {
+                        address: call.address,
+                        error: e,
+                    };
+                }
+            }
+        }
+        else {
+            const resps = await (0, multicall_1.default)(this.calls, this.provider);
+            for (let i = 0; i < resps.length; i++) {
+                const call = this.calls[i];
+                const resp = resps[i];
+                this.responses[call.key] = {
+                    address: call.address,
+                    symbol: resp.error ? undefined : this.sanitize(resp.value ?? ""),
+                    error: resp.error ? new Error("multicall error") : undefined,
+                };
+            }
+        }
+    }
+    /**
+     * Given <symbol, address> token map on our sdk, asserts that symbol found on chain for this address is the same
+     * Takes into account some exceptions
+     * @param sdkSymbol Symbol of token in SDK
+     */
+    assertSymbol(sdkSymbol) {
+        const r = this.responses[sdkSymbol];
+        if (r.error) {
+            throw new Error(`failed to verify ${sdkSymbol} on address ${r.address}: ${console.error}`);
+        }
+        const expectedSymbol = EXCEPTIONS_IN_SYMBOLS[this.network][r.address] ?? sdkSymbol;
+        if (r.symbol !== expectedSymbol) {
+            throw new Error(`Expected ${expectedSymbol} but found ${r.symbol} at ${r.address}`);
+        }
+    }
+    sanitize(symbol) {
+        return symbol.replace(/\-f$/, "").replaceAll("-", "_");
+    }
+}
+describe("Tokens", () => {
+    const suites = chains_1.supportedChains.map(n => new TokenSuite(n));
+    before(async function () {
+        this.timeout(60000);
+        await Promise.all(suites.map(s => s.fetchSymbols()));
+    });
+    suites.forEach(suite => {
+        suite.calls.forEach(call => {
+            // eslint-disable-next-line max-nested-callbacks
+            it(`${call.key} on ${suite.network}`, () => {
+                suite.assertSymbol(call.key);
+            });
+        });
+    });
+});

package/lib/utils/mappers.d.ts

@@ -1,7 +1,8 @@
 type SupportedValue = string | number;
-declare const objectEntries: <K extends SupportedValue, T>(o: Record<K, T>) => [K, T][];
-declare const swapKeyValue: <K extends SupportedValue, T extends SupportedValue>(o: Record<K, T>) => Record<T, K>;
-declare const keyToLowercase: <K extends SupportedValue, T>(o: Record<K, T>) => Record<K, T>;
-declare const filterEmptyKeys: <K extends SupportedValue, T>(o: Record<K, T>) => Record<K, T>;
+export declare class TypedObjectUtils {
+    static entries: <K extends SupportedValue, T>(o: Record<K, T>) => [K, T][];
+    static fromEntries: <K extends SupportedValue, T>(o: [K, T][]) => Record<K, T>;
+    static swapKeyValue: <K extends SupportedValue, T extends SupportedValue>(o: Record<K, T>) => Record<T, K>;
+    static keyToLowercase: <K extends SupportedValue, T>(o: Record<K, T>) => Record<K, T>;
+}
 export type { SupportedValue };
-export { filterEmptyKeys, keyToLowercase, objectEntries, swapKeyValue };

package/lib/utils/mappers.js

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.swapKeyValue = exports.objectEntries = exports.keyToLowercase = exports.filterEmptyKeys = void 0;
-const objectEntries = (o) => Object.entries(o);
-exports.objectEntries = objectEntries;
-const swapKeyValue = (o) => objectEntries(o).reduce((acc, [key, value]) => ({ ...acc, [value]: key }), {});
-exports.swapKeyValue = swapKeyValue;
-const keyToLowercase = (o) => objectEntries(o).reduce((acc, [key, value]) => {
-    const keyTransformed = typeof key === "string" ? key.toLowerCase() : key;
-    return { ...acc, [keyTransformed]: value };
-}, {});
-exports.keyToLowercase = keyToLowercase;
-const filterEmptyKeys = (o) => objectEntries(o).reduce((acc, [key, value]) => (key ? { ...acc, [key]: value } : acc), {});
-exports.filterEmptyKeys = filterEmptyKeys;
+exports.TypedObjectUtils = void 0;
+class TypedObjectUtils {
+    static entries = (o) => Object.entries(o);
+    static fromEntries = (o) => Object.fromEntries(o);
+    static swapKeyValue = (o) => TypedObjectUtils.entries(o).reduce((acc, [key, value]) => ({ ...acc, [value]: key }), {});
+    static keyToLowercase = (o) => TypedObjectUtils.entries(o).reduce((acc, [key, value]) => {
+        const keyTransformed = typeof key === "string" ? key.toLowerCase() : key;
+        return { ...acc, [keyTransformed]: value };
+    }, {});
+}
+exports.TypedObjectUtils = TypedObjectUtils;

package/lib/utils/multicall.d.ts

@@ -10,7 +10,21 @@ export interface MCall<T extends ethers.utils.Interface> {
     method: keyof T["functions"];
     params?: any;
 }
+export interface KeyedCall<T extends ethers.utils.Interface> extends MCall<T> {
+    key: string;
+}
 export declare function multicall<R extends Array<any>>(calls: Array<MCall<any>>, p: Signer | ethers.providers.Provider, overrides?: CallOverrides): Promise<R>;
+/**
+ * Like multicall from sdk, but uses tryAggregate instead of aggregate
+ * @param calls
+ * @param p
+ * @param overrides
+ * @returns
+ */
+export default function safeMulticall<V = any, T extends MCall<any> = MCall<any>>(calls: T[], p: Signer | ethers.providers.Provider, overrides?: CallOverrides): Promise<Array<{
+    error: boolean;
+    value?: V;
+}>>;
 export declare class MultiCallContract<T extends ethers.utils.Interface> {
     private readonly _address;
     private readonly _interface;

package/lib/utils/multicall.js

@@ -11,9 +11,42 @@ async function multicall(calls, p, overrides) {
     })), overrides || {});
     return returnData
         .map((d, num) => calls[num].interface.decodeFunctionResult(calls[num].method, d))
-        .map(r => (Array.isArray(r) && r.length <= 1 ? r[0] : r));
+        .map(unwrapArray);
 }
 exports.multicall = multicall;
+/**
+ * Like multicall from sdk, but uses tryAggregate instead of aggregate
+ * @param calls
+ * @param p
+ * @param overrides
+ * @returns
+ */
+async function safeMulticall(calls, p, overrides) {
+    if (!calls.length) {
+        return [];
+    }
+    const multiCallContract = types_1.Multicall2__factory.connect("0xcA11bde05977b3631167028862bE2a173976CA11", p);
+    const resp = await multiCallContract.callStatic.tryAggregate(false, calls.map(c => ({
+        target: c.address,
+        callData: c.interface.encodeFunctionData(c.method, c.params),
+    })), overrides ?? {});
+    return resp.map((d, num) => ({
+        error: !d.success,
+        value: d.success
+            ? unwrapArray(calls[num].interface.decodeFunctionResult(calls[num].method, d.returnData))
+            : undefined,
+    }));
+}
+exports.default = safeMulticall;
+function unwrapArray(data) {
+    if (!data) {
+        return data;
+    }
+    if (Array.isArray(data)) {
+        return data.length === 1 ? data[0] : data;
+    }
+    return data;
+}
 class MultiCallContract {
     _address;
     _interface;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "1.26.1",
+  "version": "1.27.0",
   "description": "Gearbox SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -23,7 +23,7 @@
     "lint": "eslint \"**/*.ts\" --fix",
     "lint:ci": "eslint \"**/*.ts\"",
     "typecheck:ci": "tsc --noEmit",
-    "test": "npx mocha --require ts-node/register src/**/*.spec.ts"
+    "test": "npx mocha -r ts-node/register -r dotenv/config src/**/*.spec.ts"
   },
   "dependencies": {
     "@types/deep-eql": "^4.0.0",
@@ -40,6 +40,7 @@
     "@typechain/ethers-v5": "10.0.0",
     "@types/chai": "^4.3.3",
     "@types/jest": "^28.1.7",
+    "@types/mocha": "^10.0.1",
     "@types/node": "^18.7.6",
     "@types/rimraf": "^3.0.2",
     "chai": "^4.3.6",