@gearbox-protocol/sdk 0.0.2

package/lib/core/creditSession.d.ts

@@ -0,0 +1,26 @@
+import { BigNumber } from "ethers";
+import { CreditOperation } from "./creditOperation";
+import { CreditSessionPayload } from "../payload/creditSession";
+export declare type CreditSessionStatus = "active" | "closed" | "repaid" | "liquidated";
+export declare class CreditSession {
+    readonly id: string;
+    readonly status: CreditSessionStatus;
+    readonly name: string;
+    readonly background: string;
+    readonly borrower: string;
+    readonly creditManager: string;
+    readonly account: string;
+    readonly since: number;
+    readonly sinceDate: string;
+    readonly closedAt: number;
+    readonly closedAtDate: string;
+    readonly initialAmount: BigNumber;
+    readonly borrowedAmount: BigNumber;
+    readonly totalValue: BigNumber;
+    readonly healthFactor: number;
+    readonly profit: BigNumber;
+    readonly profitPercentage: number;
+    readonly score: number;
+    readonly operations: Array<CreditOperation>;
+    constructor(payload: CreditSessionPayload);
+}

package/lib/core/creditSession.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreditSession = void 0;
+var ethers_1 = require("ethers");
+var moment_1 = __importDefault(require("moment"));
+var constants_1 = require("./constants");
+var statusEnum = [
+    "active",
+    "closed",
+    "repaid",
+    "liquidated",
+];
+var CreditSession = /** @class */ (function () {
+    function CreditSession(payload) {
+        this.id = payload.id;
+        this.status = statusEnum[payload.status];
+        this.name = payload.name;
+        this.background = payload.background;
+        this.borrower = payload.borrower;
+        this.creditManager = payload.creditManager;
+        this.account = payload.account;
+        this.since = payload.since;
+        this.closedAt = payload.closedAt;
+        this.initialAmount = ethers_1.BigNumber.from(payload.initialAmount || 0);
+        this.borrowedAmount = ethers_1.BigNumber.from(payload.borrowedAmount || 0);
+        this.profit = ethers_1.BigNumber.from(payload.profit || 0);
+        this.profitPercentage = payload.profitPercentage || 0;
+        this.totalValue = ethers_1.BigNumber.from(payload.totalValue || 0);
+        this.healthFactor =
+            ethers_1.BigNumber.from(payload.healthFactor || 0).toNumber() / constants_1.PERCENTAGE_FACTOR;
+        this.score = payload.score;
+        this.operations = (payload.operations || []).map(function (op) {
+            op.date = (0, moment_1.default)(op.timestamp * 1000).format("Do MMM YYYY");
+            return op;
+        });
+        this.sinceDate = (0, moment_1.default)(payload.sinceTimestamp * 1000).format("Do MMM YYYY");
+        this.closedAtDate = (0, moment_1.default)(payload.closedAtTimestamp * 1000).format("Do MMM YYYY");
+    }
+    return CreditSession;
+}());
+exports.CreditSession = CreditSession;

package/lib/core/errors.d.ts

@@ -0,0 +1,26 @@
+export interface MetamaskError {
+    code: number;
+    message: string;
+    data: string;
+}
+export declare class NetworkError extends Error {
+    constructor();
+}
+export declare class IncorrectEthAddressError extends Error {
+    constructor();
+}
+export declare class PoolNotExistsError extends Error {
+    constructor();
+}
+export declare class CreditManagerNotExistsError extends Error {
+    constructor();
+}
+export declare class UserHasNotAccountError extends Error {
+    constructor();
+}
+export declare class PathNotFoundError extends Error {
+    constructor();
+}
+export declare class AccountsInAlllCreditManagersError extends Error {
+    constructor();
+}

package/lib/core/errors.js

@@ -0,0 +1,74 @@
+"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.AccountsInAlllCreditManagersError = exports.PathNotFoundError = exports.UserHasNotAccountError = exports.CreditManagerNotExistsError = exports.PoolNotExistsError = exports.IncorrectEthAddressError = exports.NetworkError = void 0;
+var NetworkError = /** @class */ (function (_super) {
+    __extends(NetworkError, _super);
+    function NetworkError() {
+        return _super.call(this, "errors.networkError") || this;
+    }
+    return NetworkError;
+}(Error));
+exports.NetworkError = NetworkError;
+var IncorrectEthAddressError = /** @class */ (function (_super) {
+    __extends(IncorrectEthAddressError, _super);
+    function IncorrectEthAddressError() {
+        return _super.call(this, "errors.incorrectEthAddressError") || this;
+    }
+    return IncorrectEthAddressError;
+}(Error));
+exports.IncorrectEthAddressError = IncorrectEthAddressError;
+var PoolNotExistsError = /** @class */ (function (_super) {
+    __extends(PoolNotExistsError, _super);
+    function PoolNotExistsError() {
+        return _super.call(this, "errors.poolDoesntExistsError") || this;
+    }
+    return PoolNotExistsError;
+}(Error));
+exports.PoolNotExistsError = PoolNotExistsError;
+var CreditManagerNotExistsError = /** @class */ (function (_super) {
+    __extends(CreditManagerNotExistsError, _super);
+    function CreditManagerNotExistsError() {
+        return _super.call(this, "errors.creditManagerDoesntExistsError") || this;
+    }
+    return CreditManagerNotExistsError;
+}(Error));
+exports.CreditManagerNotExistsError = CreditManagerNotExistsError;
+var UserHasNotAccountError = /** @class */ (function (_super) {
+    __extends(UserHasNotAccountError, _super);
+    function UserHasNotAccountError() {
+        return _super.call(this, "errors.noOpenedAccountsError") || this;
+    }
+    return UserHasNotAccountError;
+}(Error));
+exports.UserHasNotAccountError = UserHasNotAccountError;
+var PathNotFoundError = /** @class */ (function (_super) {
+    __extends(PathNotFoundError, _super);
+    function PathNotFoundError() {
+        return _super.call(this, "errors.pathNotFoundError") || this;
+    }
+    return PathNotFoundError;
+}(Error));
+exports.PathNotFoundError = PathNotFoundError;
+var AccountsInAlllCreditManagersError = /** @class */ (function (_super) {
+    __extends(AccountsInAlllCreditManagersError, _super);
+    function AccountsInAlllCreditManagersError() {
+        return _super.call(this, "errors.youOpenedAccountsInAllCreditManagersError") || this;
+    }
+    return AccountsInAlllCreditManagersError;
+}(Error));
+exports.AccountsInAlllCreditManagersError = AccountsInAlllCreditManagersError;

package/lib/core/event.d.ts

@@ -0,0 +1,42 @@
+import { BigNumber } from "ethers";
+export declare type BasicEvent = {
+    protocol: string;
+    txHash: string;
+    timestamp: number;
+};
+export declare type BasicSwapEvent = BasicEvent & {
+    from: string;
+    fromAmount: BigNumber;
+    to: string;
+    toAmount: BigNumber;
+};
+export declare type HistoryEvent = (BasicEvent & {
+    action: "OpenCreditAccount";
+    initialFunds: BigNumber;
+    leverage: number;
+}) | (BasicEvent & {
+    action: "CloseCreditAccount";
+    remainingFunds: BigNumber;
+}) | (BasicEvent & {
+    action: "LiquidateCreditAccount";
+    remainingFunds: BigNumber;
+}) | (BasicEvent & {
+    action: "IncreaseBorrowedAmount";
+    amount: BigNumber;
+}) | (BasicEvent & {
+    action: "AddCollateral";
+    token: string;
+    amount: BigNumber;
+}) | (BasicEvent & {
+    action: "RepayCreditAccount";
+    repayAmount: BigNumber;
+}) | (BasicEvent & {
+    action: "TransferAccount";
+    newAccount: string;
+}) | (BasicSwapEvent & {
+    action: "Swap";
+}) | (BasicSwapEvent & {
+    action: "Deposit";
+}) | (BasicSwapEvent & {
+    action: "Withdraw";
+});

package/lib/core/event.js

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

package/lib/core/eventOrTx.d.ts

@@ -0,0 +1,36 @@
+import { TokenData } from "./tokenData";
+import { TxSerialized } from "./transactions";
+export interface Display {
+    toString(tokenData: Record<string, TokenData>): string;
+}
+export declare type TxStatus = "pending" | "success" | "reverted";
+export interface EventOrTxProps {
+    block: number;
+    txHash: string;
+    txStatus: TxStatus;
+    timestamp: number;
+}
+export declare abstract class EventOrTx implements Display {
+    block: number;
+    readonly txHash: string;
+    readonly timestamp: number;
+    protected _txStatus: TxStatus;
+    constructor({ block, txHash, txStatus, timestamp }: EventOrTxProps);
+    get isPending(): boolean;
+    get txStatus(): TxStatus;
+    compare(item: EventOrTx): number;
+    abstract toString(tokenData: Record<string, TokenData>): string;
+}
+export declare type EVMEventProps = Omit<EventOrTxProps, "txStatus">;
+export declare abstract class EVMEvent extends EventOrTx {
+    constructor(opts: EVMEventProps);
+}
+declare type OptionalFields = "block" | "txStatus";
+export declare type EVMTxProps = Omit<EventOrTxProps, OptionalFields> & Partial<Pick<EventOrTxProps, OptionalFields>>;
+export declare abstract class EVMTx extends EventOrTx {
+    constructor({ txHash, block, txStatus, timestamp }: EVMTxProps);
+    abstract serialize(): TxSerialized;
+    revert(block: number): void;
+    success(block: number): void;
+}
+export {};

package/lib/core/eventOrTx.js

@@ -0,0 +1,97 @@
+"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 __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMTx = exports.EVMEvent = exports.EventOrTx = void 0;
+var EventOrTx = /** @class */ (function () {
+    function EventOrTx(_a) {
+        var block = _a.block, txHash = _a.txHash, txStatus = _a.txStatus, _b = _a.timestamp, timestamp = _b === void 0 ? 0 : _b;
+        this.block = block;
+        this.txHash = txHash;
+        this._txStatus = txStatus;
+        this.timestamp = timestamp;
+    }
+    Object.defineProperty(EventOrTx.prototype, "isPending", {
+        get: function () {
+            return this._txStatus === "pending";
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(EventOrTx.prototype, "txStatus", {
+        get: function () {
+            return this._txStatus;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    EventOrTx.prototype.compare = function (item) {
+        if (this.isPending && !item.isPending) {
+            return -1;
+        }
+        if (!this.isPending && item.isPending) {
+            return 1;
+        }
+        return this.block > item.block ? -1 : 1;
+    };
+    return EventOrTx;
+}());
+exports.EventOrTx = EventOrTx;
+var EVMEvent = /** @class */ (function (_super) {
+    __extends(EVMEvent, _super);
+    function EVMEvent(opts) {
+        return _super.call(this, __assign(__assign({}, opts), { txStatus: "success" })) || this;
+    }
+    return EVMEvent;
+}(EventOrTx));
+exports.EVMEvent = EVMEvent;
+var EVMTx = /** @class */ (function (_super) {
+    __extends(EVMTx, _super);
+    function EVMTx(_a) {
+        var txHash = _a.txHash, _b = _a.block, block = _b === void 0 ? 0 : _b, _c = _a.txStatus, txStatus = _c === void 0 ? "pending" : _c, _d = _a.timestamp, timestamp = _d === void 0 ? 0 : _d;
+        var _this = _super.call(this, {
+            block: block,
+            txStatus: txStatus,
+            txHash: txHash,
+            timestamp: timestamp
+        }) || this;
+        if (_this.txStatus !== "pending" && _this.block === 0) {
+            throw new Error("Block not specified for non-pending tx");
+        }
+        return _this;
+    }
+    EVMTx.prototype.revert = function (block) {
+        this._txStatus = "reverted";
+        this.block = block;
+    };
+    EVMTx.prototype.success = function (block) {
+        this._txStatus = "success";
+        this.block = block;
+    };
+    return EVMTx;
+}(EventOrTx));
+exports.EVMTx = EVMTx;