carbon-js-sdk 0.4.30 → 0.4.31

package/lib/clients/BatchQueryClient.d.ts

@@ -0,0 +1,26 @@
+import { JsonRpcRequest, JsonRpcSuccessResponse } from "@cosmjs/json-rpc";
+import { HttpEndpoint } from "@cosmjs/tendermint-rpc/build/rpcclients/httpclient";
+import { RpcClient } from "@cosmjs/tendermint-rpc/build/rpcclients/rpcclient";
+export interface BatchQueryClientOptions {
+    /** Interval for dispatching batches (in milliseconds) */
+    dispatchInterval: number;
+    /** Max number of items sent in one request */
+    batchSizeLimit: number;
+}
+declare class BatchQueryClient implements RpcClient {
+    protected readonly url: string;
+    protected readonly headers: Record<string, string> | undefined;
+    protected readonly options: BatchQueryClientOptions;
+    private timer?;
+    private readonly queue;
+    constructor(endpoint: string | HttpEndpoint, options?: Partial<BatchQueryClientOptions>);
+    disconnect(): void;
+    execute(request: JsonRpcRequest): Promise<JsonRpcSuccessResponse>;
+    private validate;
+    /**
+     * This is called in an interval where promise rejections cannot be handled.
+     * So this is not async and HTTP errors need to be handled by the queued promises.
+     */
+    private tick;
+}
+export default BatchQueryClient;

package/lib/clients/BatchQueryClient.js

@@ -0,0 +1,100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const json_rpc_1 = require("@cosmjs/json-rpc");
+const http_1 = require("@cosmjs/tendermint-rpc/build/rpcclients/http");
+const rpcclient_1 = require("@cosmjs/tendermint-rpc/build/rpcclients/rpcclient");
+// Those values are private and can change any time.
+// Does a user need to know them? I don't think so. You either set
+// a custom value or leave the option field unset.
+const defaultBatchQueryClientOptions = {
+    dispatchInterval: 20,
+    batchSizeLimit: 20,
+};
+class BatchQueryClient {
+    constructor(endpoint, options = {}) {
+        var _a, _b;
+        this.queue = [];
+        this.options = {
+            batchSizeLimit: (_a = options.batchSizeLimit) !== null && _a !== void 0 ? _a : defaultBatchQueryClientOptions.batchSizeLimit,
+            dispatchInterval: (_b = options.dispatchInterval) !== null && _b !== void 0 ? _b : defaultBatchQueryClientOptions.dispatchInterval,
+        };
+        if (typeof endpoint === "string") {
+            // accept host.name:port and assume http protocol
+            this.url = rpcclient_1.hasProtocol(endpoint) ? endpoint : "http://" + endpoint;
+        }
+        else {
+            this.url = endpoint.url;
+            this.headers = endpoint.headers;
+        }
+        this.timer = (setInterval(() => this.tick(), options.dispatchInterval));
+        this.validate();
+    }
+    disconnect() {
+        this.timer && clearInterval(this.timer);
+        this.timer = undefined;
+    }
+    execute(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.queue.push({ request, resolve, reject });
+                if (this.queue.length >= this.options.batchSizeLimit) {
+                    // this train is full, let's go
+                    this.tick();
+                }
+            });
+        });
+    }
+    validate() {
+        if (!this.options.batchSizeLimit ||
+            !Number.isSafeInteger(this.options.batchSizeLimit) ||
+            this.options.batchSizeLimit < 1) {
+            throw new Error("batchSizeLimit must be a safe integer >= 1");
+        }
+    }
+    /**
+     * This is called in an interval where promise rejections cannot be handled.
+     * So this is not async and HTTP errors need to be handled by the queued promises.
+     */
+    tick() {
+        // Avoid race conditions
+        const batch = this.queue.splice(0, this.options.batchSizeLimit);
+        if (!batch.length)
+            return;
+        const requests = batch.map((s) => s.request);
+        const requestIds = requests.map((request) => request.id);
+        http_1.http("POST", this.url, this.headers, requests).then((raw) => {
+            // Requests with a single entry return as an object
+            const arr = Array.isArray(raw) ? raw : [raw];
+            arr.forEach((el, i) => {
+                const req = batch[i];
+                if (!req)
+                    return;
+                const { reject, resolve } = req;
+                const response = json_rpc_1.parseJsonRpcResponse(el);
+                if (json_rpc_1.isJsonRpcErrorResponse(response)) {
+                    reject(new Error(JSON.stringify(response.error)));
+                }
+                else {
+                    resolve(response);
+                }
+            });
+        }, (error) => {
+            for (const requestId of requestIds) {
+                const req = batch.find((s) => s.request.id === requestId);
+                if (!req)
+                    return;
+                req.reject(error);
+            }
+        });
+    }
+}
+exports.default = BatchQueryClient;

package/lib/insights/delegation.d.ts

@@ -0,0 +1,26 @@
+import { QueryByPageRequest } from "./common";
+export interface DelegationEntry {
+    blockHeight: number;
+    timestamp: string;
+    type: string;
+    denom: string;
+    amount: number;
+    amountValue: number;
+    delegator: string;
+    validator: string;
+    newValidator: string;
+    newShares: number;
+    completionTime: string;
+}
+export interface QueryGetDelegationsResponse {
+    entries: DelegationEntry[];
+}
+export interface GetDelegationsPathParams {
+    delegator: string;
+}
+export interface GetDelegationsQueryParams extends QueryByPageRequest {
+    time?: string;
+    denom?: string;
+    type?: string;
+    validator?: string;
+}

package/lib/insights/delegation.js

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

package/lib/insights/oracles.d.ts

@@ -0,0 +1,17 @@
+import { QueryByTimeRequest, TimeMeta } from "./common";
+export interface OraclesPrice {
+    denom: string;
+    index: number;
+    twap: number;
+}
+export interface QueryGetOraclesPriceRequest extends QueryByTimeRequest {
+    intervalDivision?: number;
+    denom?: string;
+}
+export interface QueryGetOraclesPriceResponse {
+    entries: {
+        timestamp: string;
+        tokens: OraclesPrice[];
+    }[];
+    meta: TimeMeta;
+}

package/lib/insights/oracles.js

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

package/lib/modules/cdp.js

@@ -647,20 +647,21 @@ class CDPModule extends base_1.default {
         });
     }
     getModuleTotalCollateralUsdVal() {
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const network = this.sdkProvider.getConfig().network;
             const collateralPoolAddress = address_1.SWTHAddress.getModuleAddress("collateral_pool", network);
-            const cdpBalances = yield this.sdkProvider.query.bank.AllBalances({ address: collateralPoolAddress });
-            let allCollateralsUsdValue = number_1.BN_ZERO;
-            for (const balance of cdpBalances.balances) {
-                if (!TokenClient_1.default.isCdpToken(balance.denom)) {
-                    continue;
-                }
-                const amount = number_1.bnOrZero(balance.amount);
-                const collateralUsdValue = yield this.getCdpTokenUsdVal(balance.denom, amount);
-                allCollateralsUsdValue = allCollateralsUsdValue.plus(collateralUsdValue);
-            }
-            return allCollateralsUsdValue;
+            const collateralPoolBalances = yield this.sdkProvider.query.bank.AllBalances({ address: collateralPoolAddress });
+            const cdpTokenBalances = ((_a = collateralPoolBalances === null || collateralPoolBalances === void 0 ? void 0 : collateralPoolBalances.balances) !== null && _a !== void 0 ? _a : []).filter(balance => TokenClient_1.default.isCdpToken(balance.denom));
+            const cdpTokenBalancePromises = cdpTokenBalances.map(balance => (this.getCdpTokenUsdVal(balance.denom, number_1.bnOrZero(balance.amount))
+                .then((val) => number_1.bnOrZero(val))
+                .catch((err) => {
+                console.error(err);
+                return number_1.BN_ZERO;
+            })));
+            const cdpBalances = (_b = (yield Promise.all(cdpTokenBalancePromises))) !== null && _b !== void 0 ? _b : [];
+            const totalCollateralsUsdValue = cdpBalances.reduce((prev, curr) => (prev.plus(curr)), number_1.BN_ZERO);
+            return totalCollateralsUsdValue;
         });
     }
     getCdpTokenUsdVal(cdpDenom, amount) {

package/lib/provider/metamask/legacy-accounts.d.ts

@@ -2,5 +2,9 @@ export declare const LEGACY_ACCOUNTS_TESTNET: {
     Ethereum: string[];
 };
 export declare const LEGACY_ACCOUNTS_MAINNET: {
+    OKC: string[];
+    Polygon: string[];
+    Arbitrum: string[];
     Ethereum: string[];
+    "Binance Smart Chain": string[];
 };