@gearbox-protocol/sdk 1.20.2 → 1.20.3

package/lib/core/trade.d.ts

@@ -15,13 +15,13 @@ interface BaseTradeInterface {
 export interface TradeProps extends BaseTradeInterface {
     adapter: BaseAdapter;
     tradePath: PathFinderResult;
-    creditFacade: ICreditFacade;
+    creditFacade: string;
 }
 export declare type TradeOperations = "farmWithdraw" | "farmDeposit" | "swap" | "unknownOperation";
 export declare class Trade implements BaseTradeInterface {
     protected helper: BaseAdapter;
     protected tradePath: PathFinderResult;
-    protected creditFacade: ICreditFacade;
+    protected creditFacade: string;
     readonly swapType: SwapOperation;
     readonly sourceAmount: BigNumber;
     readonly expectedAmount: BigNumber;
@@ -36,11 +36,9 @@ export declare class Trade implements BaseTradeInterface {
     getAdapterAddress(): string;
     execute(signer: Signer): Promise<EVMTx>;
     toString(): string;
-    getFromAmount(slippage: number): BigNumber;
-    getToAmount(slippage: number): BigNumber;
     static getOperationName(tokenInAddress: string, tokenOutAddress: string): TradeOperations;
     static executeMulticallPath(creditFacade: string | ICreditFacade, signer: Signer, calls: Array<MultiCall>): Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
-    static executeOnSigner(call: MultiCall, signer: Signer): Promise<import("@ethersproject/abstract-provider").TransactionResponse>;
-    static executeOnCreditFacade(calls: Array<MultiCall>, creditFacade: ICreditFacade): Promise<import("ethers").ContractTransaction>;
+    private static executeOnSigner;
+    private static executeOnCreditFacade;
 }
 export {};

package/lib/core/trade.js

@@ -108,16 +108,6 @@ var Trade = /** @class */ (function () {
         var decimalsTo = decimals_1.decimals[symbolTo];
         return "".concat(this.operationName, " ").concat((0, formatter_1.formatBN)(this.sourceAmount, decimalsFrom), " ").concat(symbolFrom, " \u21D2 ").concat((0, formatter_1.formatBN)(this.expectedAmount, decimalsTo), " ").concat(symbolTo, " on ").concat(this.helper.name);
     };
-    Trade.prototype.getFromAmount = function (slippage) {
-        return this.expectedAmount
-            .mul(constants_1.PERCENTAGE_FACTOR)
-            .div(constants_1.PERCENTAGE_FACTOR + slippage);
-    };
-    Trade.prototype.getToAmount = function (slippage) {
-        return this.expectedAmount
-            .mul(constants_1.PERCENTAGE_FACTOR + slippage)
-            .div(constants_1.PERCENTAGE_FACTOR);
-    };
     Trade.getOperationName = function (tokenInAddress, tokenOutAddress) {
         var tokenInSymbol = token_1.tokenSymbolByAddress[tokenInAddress];
         var tokenOutSymbol = token_1.tokenSymbolByAddress[tokenOutAddress];

package/lib/core/wcOperation/abstractOperations.d.ts

@@ -0,0 +1,23 @@
+import type { TransactionRequest } from "@ethersproject/abstract-provider";
+import { BytesLike } from "ethers";
+import { RawTransaction } from ".";
+export interface BaseWcOperationProps {
+    raw: RawTransaction;
+}
+export declare abstract class BaseWcOperation {
+    readonly id: number;
+    raw: RawTransaction;
+    abstract readonly kind: string;
+    constructor({ raw }: BaseWcOperationProps);
+}
+export interface SupportedWcOperationProps extends BaseWcOperationProps {
+    tx: TransactionRequest;
+    operation: string;
+    calldata: BytesLike;
+}
+export declare abstract class SupportedWcOperation extends BaseWcOperation {
+    tx: TransactionRequest;
+    operation: string;
+    protected calldata: BytesLike;
+    constructor(props: SupportedWcOperationProps);
+}

package/lib/core/wcOperation/abstractOperations.js

@@ -0,0 +1,39 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupportedWcOperation = exports.BaseWcOperation = void 0;
+var BaseWcOperation = /** @class */ (function () {
+    function BaseWcOperation(_a) {
+        var raw = _a.raw;
+        this.id = raw.id;
+        this.raw = raw;
+    }
+    return BaseWcOperation;
+}());
+exports.BaseWcOperation = BaseWcOperation;
+var SupportedWcOperation = /** @class */ (function (_super) {
+    __extends(SupportedWcOperation, _super);
+    function SupportedWcOperation(props) {
+        var _this = _super.call(this, props) || this;
+        _this.operation = props.operation;
+        _this.tx = props.tx;
+        _this.calldata = props.calldata;
+        return _this;
+    }
+    return SupportedWcOperation;
+}(BaseWcOperation));
+exports.SupportedWcOperation = SupportedWcOperation;

package/lib/core/wcOperation/index.d.ts

@@ -0,0 +1,11 @@
+import { ApproveWCOperation, FailedWCOperation, LpWCOperation, SwapWCOperation } from "./operations";
+export * from "./operations";
+export * from "./types";
+export declare type AllWCOperations = FailedWCOperation | ApproveWCOperation | SwapWCOperation | LpWCOperation;
+export declare type SupportedWCOperations = ApproveWCOperation | SwapWCOperation | LpWCOperation;
+export declare class WcOperationCreator {
+    static newSwapOperation: typeof SwapWCOperation.create;
+    static newLPOperation: typeof LpWCOperation.create;
+    static newUnsupportedOperation: typeof FailedWCOperation.create;
+    static newApproveOperation: typeof ApproveWCOperation.create;
+}

package/lib/core/wcOperation/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WcOperationCreator = void 0;
+var operations_1 = require("./operations");
+__exportStar(require("./operations"), exports);
+__exportStar(require("./types"), exports);
+var WcOperationCreator = /** @class */ (function () {
+    function WcOperationCreator() {
+    }
+    WcOperationCreator.newSwapOperation = operations_1.SwapWCOperation.create;
+    WcOperationCreator.newLPOperation = operations_1.LpWCOperation.create;
+    WcOperationCreator.newUnsupportedOperation = operations_1.FailedWCOperation.create;
+    WcOperationCreator.newApproveOperation = operations_1.ApproveWCOperation.create;
+    return WcOperationCreator;
+}());
+exports.WcOperationCreator = WcOperationCreator;

package/lib/core/wcOperation/operations.d.ts

@@ -0,0 +1,88 @@
+import { BigNumber } from "ethers";
+import { CreditManagerData } from "../creditManager";
+import { BaseWcOperation, BaseWcOperationProps, SupportedWcOperation, SupportedWcOperationProps } from "./abstractOperations";
+import { RawTransaction } from "./types";
+export declare type FailedWCOperationType = "unsupported" | "bad_request" | "unsupported_tokens";
+interface FailedWCOperationProps extends BaseWcOperationProps {
+    message: string;
+    kind: FailedWCOperationType;
+}
+export declare class FailedWCOperation extends BaseWcOperation {
+    kind: FailedWCOperationType;
+    message: string;
+    constructor({ raw, kind, message }: FailedWCOperationProps);
+    static create(props: FailedWCOperationProps): FailedWCOperation;
+}
+declare type ApproveWCOperationType = "approve";
+interface ApproveWcOperationProps extends SupportedWcOperationProps {
+    kind: ApproveWCOperationType;
+    to: string;
+    from: string;
+}
+interface CreateApproveWCOperation {
+    to: string;
+    args: [string, BigNumber];
+    raw: RawTransaction;
+    creditManager: CreditManagerData;
+}
+export declare class ApproveWCOperation extends SupportedWcOperation {
+    kind: ApproveWCOperationType;
+    to: string;
+    from: string;
+    constructor(props: ApproveWcOperationProps);
+    static create({ to: token, args, raw, creditManager, }: CreateApproveWCOperation): FailedWCOperation | ApproveWCOperation;
+}
+declare type SwapWCOperationType = "swap";
+interface SwapWCOperationProps extends SupportedWcOperationProps {
+    kind: SwapWCOperationType;
+    from: string;
+    to: string;
+    amountFrom: BigNumber;
+    amountTo: BigNumber;
+}
+interface CreateSwapWCOperationProps {
+    adapter: string;
+    operation: string;
+    from: string;
+    to: string;
+    amountFrom: BigNumber;
+    amountTo: BigNumber;
+    raw: RawTransaction;
+}
+export declare class SwapWCOperation extends SupportedWcOperation {
+    kind: SwapWCOperationType;
+    from: string;
+    to: string;
+    amountFrom: BigNumber;
+    amountTo: BigNumber;
+    constructor(props: SwapWCOperationProps);
+    static create(params: CreateSwapWCOperationProps): SwapWCOperation;
+}
+declare type LpWCOperationType = "lp";
+declare type LpType = "withdraw" | "deposit";
+interface LpWCOperationProps extends SupportedWcOperationProps {
+    kind: LpWCOperationType;
+    from: string;
+    amountFrom: BigNumber;
+    farm: string;
+    lpOperationType: LpType;
+}
+interface CreateLpWCOperation {
+    adapter: string;
+    operation: string;
+    from: string;
+    amountFrom: BigNumber;
+    farm: string;
+    type: LpType;
+    raw: RawTransaction;
+}
+export declare class LpWCOperation extends SupportedWcOperation {
+    kind: LpWCOperationType;
+    from: string;
+    amountFrom: BigNumber;
+    farm: string;
+    lpOperationType: LpType;
+    constructor(props: LpWCOperationProps);
+    static create(params: CreateLpWCOperation): LpWCOperation;
+}
+export {};

package/lib/core/wcOperation/operations.js

@@ -0,0 +1,146 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LpWCOperation = exports.SwapWCOperation = exports.ApproveWCOperation = exports.FailedWCOperation = void 0;
+var types_1 = require("../../types");
+var abstractOperations_1 = require("./abstractOperations");
+var FailedWCOperation = /** @class */ (function (_super) {
+    __extends(FailedWCOperation, _super);
+    function FailedWCOperation(_a) {
+        var raw = _a.raw, kind = _a.kind, message = _a.message;
+        var _this = _super.call(this, { raw: raw }) || this;
+        _this.kind = kind;
+        _this.message = message;
+        return _this;
+    }
+    FailedWCOperation.create = function (props) {
+        return new FailedWCOperation(props);
+    };
+    return FailedWCOperation;
+}(abstractOperations_1.BaseWcOperation));
+exports.FailedWCOperation = FailedWCOperation;
+var ApproveWCOperation = /** @class */ (function (_super) {
+    __extends(ApproveWCOperation, _super);
+    function ApproveWCOperation(props) {
+        var _this = _super.call(this, props) || this;
+        _this.kind = props.kind;
+        _this.from = props.from;
+        _this.to = props.to;
+        return _this;
+    }
+    ApproveWCOperation.create = function (_a) {
+        var token = _a.to, args = _a.args, raw = _a.raw, creditManager = _a.creditManager;
+        try {
+            var spender = args[0], amount = args[1];
+            var cmi = types_1.ICreditManager__factory.createInterface();
+            var cfi = types_1.ICreditFacade__factory.createInterface();
+            var target = creditManager.version === 1
+                ? creditManager.address
+                : creditManager.creditFacade;
+            var calldata = creditManager.version === 1
+                ? cmi.encodeFunctionData("approve", [spender, token])
+                : cfi.encodeFunctionData("approve", [spender, token, amount]);
+            var tx = {
+                to: target,
+                data: calldata,
+            };
+            return new ApproveWCOperation({
+                raw: raw,
+                operation: "approveToken",
+                kind: "approve",
+                tx: tx,
+                calldata: calldata,
+                to: target,
+                from: spender,
+            });
+        }
+        catch (e) {
+            console.error(e);
+            return FailedWCOperation.create({
+                raw: raw,
+                kind: "bad_request",
+                message: "Bad approve inputs",
+            });
+        }
+    };
+    return ApproveWCOperation;
+}(abstractOperations_1.SupportedWcOperation));
+exports.ApproveWCOperation = ApproveWCOperation;
+var SwapWCOperation = /** @class */ (function (_super) {
+    __extends(SwapWCOperation, _super);
+    function SwapWCOperation(props) {
+        var _this = _super.call(this, props) || this;
+        _this.kind = props.kind;
+        _this.to = props.to;
+        _this.from = props.from;
+        _this.amountFrom = props.amountFrom;
+        _this.amountTo = props.amountTo;
+        return _this;
+    }
+    SwapWCOperation.create = function (params) {
+        var _a, _b;
+        var calldata = (_b = (_a = params.raw) === null || _a === void 0 ? void 0 : _a.params[0]) === null || _b === void 0 ? void 0 : _b.data;
+        return new SwapWCOperation({
+            kind: "swap",
+            operation: params.operation,
+            raw: params.raw,
+            calldata: calldata,
+            tx: {
+                to: params.adapter,
+                data: calldata,
+            },
+            from: params.from,
+            to: params.to,
+            amountFrom: params.amountFrom,
+            amountTo: params.amountTo,
+        });
+    };
+    return SwapWCOperation;
+}(abstractOperations_1.SupportedWcOperation));
+exports.SwapWCOperation = SwapWCOperation;
+var LpWCOperation = /** @class */ (function (_super) {
+    __extends(LpWCOperation, _super);
+    function LpWCOperation(props) {
+        var _this = _super.call(this, props) || this;
+        _this.kind = props.kind;
+        _this.from = props.from;
+        _this.amountFrom = props.amountFrom;
+        _this.farm = props.farm;
+        _this.lpOperationType = props.lpOperationType;
+        return _this;
+    }
+    LpWCOperation.create = function (params) {
+        var _a, _b;
+        var calldata = (_b = (_a = params.raw) === null || _a === void 0 ? void 0 : _a.params[0]) === null || _b === void 0 ? void 0 : _b.data;
+        return new LpWCOperation({
+            kind: "lp",
+            operation: params.operation,
+            raw: params.raw,
+            calldata: calldata,
+            tx: {
+                to: params.adapter,
+                data: calldata,
+            },
+            from: params.from,
+            amountFrom: params.amountFrom,
+            farm: params.farm,
+            lpOperationType: params.type,
+        });
+    };
+    return LpWCOperation;
+}(abstractOperations_1.SupportedWcOperation));
+exports.LpWCOperation = LpWCOperation;

package/lib/core/wcOperation/types.d.ts

@@ -0,0 +1,15 @@
+import type { TransactionRequest } from "@ethersproject/abstract-provider";
+import { BigNumber } from "ethers";
+import { FunctionFragment } from "ethers/lib/utils";
+export interface RawTransaction {
+    id: number;
+    method: "eth_sendTransaction";
+    params: [TransactionRequest];
+}
+export interface TxInfo {
+    from?: string;
+    to?: string;
+    amountFrom?: BigNumber;
+    amountTo?: BigNumber;
+    functionFragment: FunctionFragment;
+}

package/lib/core/wcOperation/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/parsers/abstractParser.d.ts

@@ -10,7 +10,7 @@ export declare class AbstractParser {
     protected ifc: utils.Interface;
     adapterName: string;
     constructor(contract: string);
-    parseSelector(calldata: string): ParseSelectorResult;
+    parseSelector(calldata: BytesLike): ParseSelectorResult;
     decodeFunctionData(functionFragment: FunctionFragment | string, data: BytesLike): Result;
     encodeFunctionResult(functionFragment: FunctionFragment | string, data: Array<any>): string;
     tokenSymbol(address: string): SupportedToken;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "1.20.2",
+  "version": "1.20.3",
   "description": "Gearbox SDK",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",

package/lib/core/wcOperation.d.ts

@@ -1,54 +0,0 @@
-import type { TransactionRequest } from "@ethersproject/abstract-provider";
-import { BigNumber, BytesLike } from "ethers";
-import { FunctionFragment } from "ethers/lib/utils";
-export declare type TxType = "unsupported" | "swap" | "approve" | "lp";
-export declare type LpOperationType = "withdraw" | "deposit";
-export interface RawTransaction {
-    id: number;
-    method: "eth_sendTransaction";
-    params: [TransactionRequest];
-}
-export interface TxInfo {
-    from?: string;
-    to?: string;
-    amountFrom?: BigNumber;
-    amountTo?: BigNumber;
-    functionFragment: FunctionFragment;
-}
-export declare class WcSwapOperation {
-    readonly id: number;
-    operation?: string;
-    from?: string;
-    to?: string;
-    amountFrom?: BigNumber;
-    amountTo?: BigNumber;
-    tx?: TransactionRequest;
-    raw: RawTransaction;
-    kind: TxType;
-    protected calldata?: BytesLike;
-    isPending: boolean;
-    farm?: string;
-    lpOperationType?: LpOperationType;
-    static tokens: Record<string, boolean>;
-    constructor(raw: RawTransaction, kind: TxType);
-    static NewSwapOperation(params: {
-        adapter: string;
-        operation: string;
-        from: string;
-        to: string;
-        amountFrom: BigNumber;
-        amountTo: BigNumber;
-        raw: RawTransaction;
-    }): WcSwapOperation;
-    static NewLPOperation(params: {
-        adapter: string;
-        operation: string;
-        from: string;
-        amountFrom: BigNumber;
-        farm: string;
-        type: LpOperationType;
-        raw: RawTransaction;
-    }): WcSwapOperation;
-    static NewUnsupportedOperation(raw: RawTransaction): WcSwapOperation;
-    static NewApproveOperation(creditManager: string, raw: RawTransaction, token: string): WcSwapOperation;
-}

package/lib/core/wcOperation.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WcSwapOperation = void 0;
-var types_1 = require("../types");
-var WcSwapOperation = /** @class */ (function () {
-    function WcSwapOperation(raw, kind) {
-        this.id = raw.id;
-        this.raw = raw;
-        this.kind = kind;
-        this.isPending = false;
-    }
-    WcSwapOperation.NewSwapOperation = function (params) {
-        var _a, _b;
-        var newOperation = new WcSwapOperation(params.raw, "swap");
-        newOperation.operation = params.operation;
-        newOperation.from = params.from;
-        newOperation.to = params.to;
-        newOperation.amountFrom = params.amountFrom;
-        newOperation.amountTo = params.amountTo;
-        newOperation.raw = params.raw;
-        newOperation.calldata = (_b = (_a = params.raw) === null || _a === void 0 ? void 0 : _a.params[0]) === null || _b === void 0 ? void 0 : _b.data;
-        newOperation.tx = {
-            to: params.adapter,
-            data: newOperation.calldata,
-        };
-        return newOperation;
-    };
-    WcSwapOperation.NewLPOperation = function (params) {
-        var _a, _b;
-        var newOperation = new WcSwapOperation(params.raw, "lp");
-        newOperation.operation = params.operation;
-        newOperation.from = params.from;
-        newOperation.amountFrom = params.amountFrom;
-        newOperation.raw = params.raw;
-        newOperation.calldata = (_b = (_a = params.raw) === null || _a === void 0 ? void 0 : _a.params[0]) === null || _b === void 0 ? void 0 : _b.data;
-        newOperation.farm = params.farm;
-        newOperation.tx = {
-            to: params.adapter,
-            data: newOperation.calldata,
-        };
-        newOperation.lpOperationType = params.type;
-        return newOperation;
-    };
-    WcSwapOperation.NewUnsupportedOperation = function (raw) {
-        return new WcSwapOperation(raw, "unsupported");
-    };
-    WcSwapOperation.NewApproveOperation = function (creditManager, raw, token) {
-        var _a, _b;
-        var operation = new WcSwapOperation(raw, "approve");
-        operation.to = token;
-        operation.calldata = (_a = raw === null || raw === void 0 ? void 0 : raw.params[0]) === null || _a === void 0 ? void 0 : _a.data;
-        var tokenI = types_1.IERC20__factory.createInterface();
-        try {
-            var spender = tokenI.decodeFunctionData("approve", ((_b = raw === null || raw === void 0 ? void 0 : raw.params[0]) === null || _b === void 0 ? void 0 : _b.data) || "")[0];
-            var cmi = types_1.ICreditManager__factory.createInterface();
-            operation.from = spender;
-            // @ts-ignore
-            operation.calldata = cmi.encodeFunctionData("approve", [
-                spender,
-                operation.to,
-            ]);
-            operation.tx = {
-                to: creditManager,
-                data: operation.calldata,
-            };
-            return operation;
-        }
-        catch (e) {
-            console.error(e);
-            return WcSwapOperation.NewUnsupportedOperation(raw);
-        }
-    };
-    WcSwapOperation.tokens = {};
-    return WcSwapOperation;
-}());
-exports.WcSwapOperation = WcSwapOperation;