@gainsnetwork/sdk 0.0.0-me-rc1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ingenium Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# Gains Network SDK
+
+## Install
+
+```bash
+npm install @gainsnetwork/sdk
+```
+
+## v10 Migration
+
+See [v10-migration.md](docs/v10-migration.md)

package/lib/backend/globalTrades/index.d.ts

@@ -0,0 +1,11 @@
+import { Pair, TradeContainer } from "../../trade";
+import { TradeContainerBackend } from "./../tradingVariables/backend.types";
+import { TradingVariablesCollateral } from "./../tradingVariables/types";
+export type TransformedGlobalTrades = {
+    allTrades: Map<string, NestedTrade>;
+    allLimitOrders: Map<string, NestedTrade>;
+    trades: NestedTrade;
+    limitOrders: NestedTrade;
+};
+export type NestedTrade = Map<number, Map<number, TradeContainer>>;
+export declare const transformGlobalTrades: (rawTrades: TradeContainerBackend[], pairs: Pair[], currentAddress: string | undefined, collaterals: TradingVariablesCollateral[]) => TransformedGlobalTrades | undefined;

package/lib/backend/globalTrades/index.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformGlobalTrades = void 0;
+const trade_1 = require("../../trade");
+const converter_1 = require("./../tradingVariables/converter");
+const transformGlobalTrades = (rawTrades, pairs, currentAddress, collaterals) => {
+    if (rawTrades === undefined)
+        return;
+    const r = (0, converter_1.convertTradesAndLimitOrders)(rawTrades, collaterals);
+    const returnObject = {
+        allTrades: new Map(),
+        allLimitOrders: new Map(),
+        trades: new Map(),
+        limitOrders: new Map(),
+    };
+    currentAddress = currentAddress === undefined ? "" : currentAddress;
+    const _trades = new Map();
+    const _limitOrders = new Map();
+    const _allTrades = new Map();
+    const _allLimitOrders = new Map();
+    for (let s = 0; s < r.length; s++) {
+        if (r[s].trade.tradeType !== trade_1.TradeType.TRADE) {
+            const t = r[s];
+            if (_allLimitOrders.get(t.trade.user) === undefined) {
+                _allLimitOrders.set(t.trade.user, new Map());
+            }
+            const traderMap_all = _allLimitOrders.get(t.trade.user);
+            if (traderMap_all?.get(t.trade.pairIndex) === undefined) {
+                traderMap_all?.set(t.trade.pairIndex, new Map());
+            }
+            const traderPairMap_all = traderMap_all?.get(t.trade.pairIndex);
+            traderPairMap_all?.set(t.trade.index, t);
+            if (t.trade.user.toUpperCase() !== currentAddress.toUpperCase()) {
+                continue;
+            }
+            if (_limitOrders.get(t.trade.pairIndex) === undefined) {
+                _limitOrders.set(t.trade.pairIndex, new Map());
+            }
+            const traderPairMap = _limitOrders.get(t.trade.pairIndex);
+            traderPairMap?.set(t.trade.index, t);
+        }
+        else {
+            const t = r[s];
+            if (_allTrades.get(t.trade.user) === undefined) {
+                _allTrades.set(t.trade.user, new Map());
+            }
+            const traderMap_all = _allTrades.get(t.trade.user);
+            if (traderMap_all?.get(t.trade.pairIndex) === undefined) {
+                traderMap_all?.set(t.trade.pairIndex, new Map());
+            }
+            const traderPairMap_all = traderMap_all?.get(t.trade.pairIndex);
+            traderPairMap_all?.set(t.trade.index, t);
+            if (t.trade.user.toUpperCase() !== currentAddress.toUpperCase()) {
+                continue;
+            }
+            if (_trades.get(t.trade.pairIndex) === undefined) {
+                _trades.set(t.trade.pairIndex, new Map());
+            }
+            const traderPairMap = _trades.get(t.trade.pairIndex);
+            traderPairMap?.set(t.trade.index, t);
+        }
+    }
+    returnObject.trades = _trades;
+    returnObject.limitOrders = _limitOrders;
+    returnObject.allTrades = _allTrades;
+    returnObject.allLimitOrders = _allLimitOrders;
+    return returnObject;
+};
+exports.transformGlobalTrades = transformGlobalTrades;

package/lib/backend/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./tradingVariables";
+export * from "./globalTrades";
+export { convertTradeContainer as convertTradeContainerBackend, convertPairOi as convertPairOiBackend, convertOiWindows as convertOiWindowsBackend, convertOiWindowsSettings as convertOiWindowsSettingsBackend, convertTraderFeeTiers as convertTraderFeeTiersBackend, convertTradingPairs as convertTradingPairsBackend, convertCollaterals as convertCollateralsBackend, } from "./tradingVariables/converter";

package/lib/backend/index.js

@@ -0,0 +1,28 @@
+"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.convertCollateralsBackend = exports.convertTradingPairsBackend = exports.convertTraderFeeTiersBackend = exports.convertOiWindowsSettingsBackend = exports.convertOiWindowsBackend = exports.convertPairOiBackend = exports.convertTradeContainerBackend = void 0;
+__exportStar(require("./tradingVariables"), exports);
+__exportStar(require("./globalTrades"), exports);
+// Re-export backend-specific converters with "Backend" suffix to avoid conflicts
+var converter_1 = require("./tradingVariables/converter");
+Object.defineProperty(exports, "convertTradeContainerBackend", { enumerable: true, get: function () { return converter_1.convertTradeContainer; } });
+Object.defineProperty(exports, "convertPairOiBackend", { enumerable: true, get: function () { return converter_1.convertPairOi; } });
+Object.defineProperty(exports, "convertOiWindowsBackend", { enumerable: true, get: function () { return converter_1.convertOiWindows; } });
+Object.defineProperty(exports, "convertOiWindowsSettingsBackend", { enumerable: true, get: function () { return converter_1.convertOiWindowsSettings; } });
+Object.defineProperty(exports, "convertTraderFeeTiersBackend", { enumerable: true, get: function () { return converter_1.convertTraderFeeTiers; } });
+Object.defineProperty(exports, "convertTradingPairsBackend", { enumerable: true, get: function () { return converter_1.convertTradingPairs; } });
+Object.defineProperty(exports, "convertCollateralsBackend", { enumerable: true, get: function () { return converter_1.convertCollaterals; } });

package/lib/backend/tradingVariables/backend.types.d.ts

@@ -0,0 +1,337 @@
+import { TokenPrices } from "./types";
+export interface TradeContainerBackend {
+    trade: TradeBackend;
+    tradeInfo: TradeInfoBackend;
+    initialAccFees: TradeInitialAccFeesBackend;
+    liquidationParams: LiquidationParamsBackend;
+    tradeFeesData?: TradeFeesDataBackend;
+    uiRealizedPnlData?: UiRealizedPnlDataBackend;
+}
+export interface TradeBackend {
+    user: string;
+    index: string;
+    pairIndex: string;
+    leverage: string;
+    long: boolean;
+    isOpen: boolean;
+    collateralIndex: string;
+    tradeType: string;
+    collateralAmount: string;
+    openPrice: string;
+    tp: string;
+    sl: string;
+    isCounterTrade?: boolean;
+    positionSizeToken?: string;
+}
+export interface TradeInfoBackend {
+    createdBlock: string;
+    tpLastUpdatedBlock: string;
+    slLastUpdatedBlock: string;
+    maxSlippageP: string;
+    lastOiUpdateTs: number;
+    collateralPriceUsd: string;
+    contractsVersion: string;
+    lastPosIncreaseBlock: string;
+}
+export interface TradeInitialAccFeesBackend {
+    accPairFee: string;
+    accGroupFee: string;
+    block: string;
+}
+export interface TradeFeesDataBackend {
+    realizedTradingFeesCollateral: string;
+    realizedPnlCollateral: string;
+    manuallyRealizedNegativePnlCollateral: string;
+    alreadyTransferredNegativePnlCollateral: string;
+    virtualAvailableCollateralInDiamond: string;
+    initialAccFundingFeeP: string;
+    initialAccBorrowingFeeP: string;
+}
+export interface UiRealizedPnlDataBackend {
+    realizedTradingFeesCollateral: string;
+    realizedOldBorrowingFeesCollateral: string;
+    realizedNewBorrowingFeesCollateral: string;
+    realizedFundingFeesCollateral: string;
+    realizedPnlPartialCloseCollateral: string;
+    pnlWithdrawnCollateral: string;
+}
+export interface LiquidationParamsBackend {
+    maxLiqSpreadP: string;
+    startLiqThresholdP: string;
+    endLiqThresholdP: string;
+    startLeverage: string;
+    endLeverage: string;
+}
+export interface TradingGroupBackend {
+    name: string;
+    minLeverage: string;
+    maxLeverage: string;
+}
+export interface FeeBackend {
+    totalPositionSizeFeeP: string;
+    totalLiqCollateralFeeP: string;
+    oraclePositionSizeFeeP: string;
+    minPositionSizeUsd: string;
+}
+export interface OpenInterestBeforeV10Backend {
+    long: string;
+    short: string;
+    max: string;
+}
+export interface OpenInterestCollateralBackend {
+    oiLongCollateral: string;
+    oiShortCollateral: string;
+}
+export interface OpenInterestTokenBackend {
+    oiLongToken: string;
+    oiShortToken: string;
+}
+export interface OpenInterestBackend {
+    beforeV10: OpenInterestBeforeV10Backend;
+    collateral: OpenInterestCollateralBackend;
+    token: OpenInterestTokenBackend;
+}
+export interface GroupOpenInterestBackend {
+    long: string;
+    short: string;
+    max: string;
+}
+export interface PairDepthBandsBackend {
+    aboveSlot1: string;
+    aboveSlot2: string;
+    belowSlot1: string;
+    belowSlot2: string;
+}
+export interface DepthBandsMappingBackend {
+    slot1: string;
+    slot2: string;
+}
+export interface PairBorrowingFeesBackendPairGroup {
+    groupIndex: string;
+    block: string;
+    initialAccFeeLong: string;
+    initialAccFeeShort: string;
+    prevGroupAccFeeLong: string;
+    prevGroupAccFeeShort: string;
+    pairAccFeeLong: string;
+    pairAccFeeShort: string;
+}
+export interface PairBorrowingFeesBackendPair {
+    oi: OpenInterestBackend;
+    feePerBlock: string;
+    accFeeLong: string;
+    accFeeShort: string;
+    accLastUpdatedBlock: string;
+    feeExponent: string;
+    groups: PairBorrowingFeesBackendPairGroup[];
+    feePerBlockCap?: BorrowingFeePerBlockCapBackend;
+}
+export interface PairBorrowingFeesBackendGroup {
+    oi: GroupOpenInterestBackend;
+    feePerBlock: string;
+    accFeeLong: string;
+    accFeeShort: string;
+    accLastUpdatedBlock: string;
+    feeExponent: string;
+}
+export interface BorrowingFeePerBlockCapBackend {
+    minP: string;
+    maxP: string;
+}
+export interface PairParamsBorrowingFeesBackend {
+    pairs: PairBorrowingFeesBackendPair[];
+    groups: PairBorrowingFeesBackendGroup[];
+}
+export interface PairBackend {
+    from: string;
+    to: string;
+    spreadP: string;
+    groupIndex: string;
+    feeIndex: string;
+}
+export type PairFactorBackend = {
+    cumulativeFactor: string;
+    protectionCloseFactor: string;
+    protectionCloseFactorBlocks: string;
+    exemptOnOpen: boolean;
+    exemptAfterProtectionCloseFactor: boolean;
+};
+export interface GlobalTradingVariablesBackend {
+    lastRefreshed: string;
+    refreshId: number;
+    tradingState: number;
+    marketOrdersTimeoutBlocks: number;
+    pairs: PairBackend[];
+    groups: TradingGroupBackend[];
+    fees: FeeBackend[];
+    pairInfos: PairInfosBackend;
+    depthBandsMapping: DepthBandsMappingBackend;
+    collaterals: CollateralBackend[];
+    sssTokenBalance: string;
+    sssLegacyTokenBalance: string;
+    sssRewardTokens: string[];
+    vaultClosingFeeP: string;
+    maxNegativePnlOnOpenP: number;
+    blockConfirmations: number;
+    oiWindowsSettings: OiWindowsSettingsBackend;
+    oiWindows: OiWindowsBackend[];
+    feeTiers: FeeTiersBackend;
+    allTrades: TradeContainerBackend[];
+    currentBlock: number;
+    currentL1Block: number;
+    isForexOpen: boolean;
+    isStocksOpen: boolean;
+    isIndicesOpen: boolean;
+    isCommoditiesOpen: boolean;
+    liquidationParams: {
+        groups: LiquidationParamsBackend[];
+        pairs: LiquidationParamsBackend[];
+    };
+    counterTradeSettings: CounterTradeSettingsBackend[];
+    globalTradeFeeParams: GlobalTradeFeeParamsBackend;
+    negPnlCumulVolMultiplier: string;
+    congestionLevels: {
+        low: number;
+        high: number;
+    };
+}
+export interface FundingFeesBackend {
+    pairGlobalParams: {
+        maxSkewCollateral: string;
+    }[];
+    pairParams: {
+        skewCoefficientPerYear: string;
+        absoluteVelocityPerYearCap: string;
+        absoluteRatePerSecondCap: string;
+        thetaThresholdUsd: string;
+        fundingFeesEnabled: boolean;
+        aprMultiplierEnabled: boolean;
+    }[];
+    pairData: {
+        accFundingFeeLongP: string;
+        accFundingFeeShortP: string;
+        lastFundingRatePerSecondP: string;
+        lastFundingUpdateTs: string;
+    }[];
+}
+export interface BorrowingFeesV2Backend {
+    pairParams: {
+        borrowingRatePerSecondP: string;
+    }[];
+    pairData: {
+        accBorrowingFeeP: string;
+        lastBorrowingUpdateTs: string;
+    }[];
+}
+export interface CollateralBackend {
+    collateralIndex: number;
+    collateral: string;
+    symbol: string;
+    isActive: boolean;
+    prices: TokenPrices;
+    collateralConfig: CollateralConfigBackend;
+    gToken: {
+        address: string;
+        currentBalanceCollateral: string;
+        maxBalanceCollateral: string;
+        marketCap: string;
+    };
+    borrowingFees: {
+        v1: PairParamsBorrowingFeesBackend;
+        v2: BorrowingFeesV2Backend;
+    };
+    fundingFees: FundingFeesBackend;
+    pairOis: OpenInterestBackend[];
+    pairSkewDepths?: string[];
+}
+export interface PairInfosBackend {
+    maxLeverages: string[];
+    pairDepthBands: PairDepthBandsBackend[];
+    pairFactors: PairFactorBackend[];
+}
+export type TraderInfoBackend = {
+    lastDayUpdated: number;
+    trailingPoints: string;
+};
+export type StakingInfoBackend = {
+    stakedGns: string;
+    stakedVaultGns: string;
+    bonusAmount: string;
+    stakeTimestamp: number;
+    feeMultiplierCache: string;
+};
+export type TraderEnrollmentBackend = {
+    status: number;
+};
+export type TraderFeeTiersBackend = {
+    traderEnrollment: TraderEnrollmentBackend;
+    traderInfo: TraderInfoBackend;
+    stakingInfo: StakingInfoBackend;
+    lastDayUpdatedPoints: string;
+    inboundPoints: string;
+    outboundPoints: string;
+    expiredPoints: string[];
+    unclaimedPoints: string;
+};
+export interface UserTradingVariablesBackend {
+    pendingMarketOrdersIds: any[];
+    pendingMarketOrders: any[];
+    feeTiers: TraderFeeTiersBackend;
+    collaterals: Array<{
+        balance: string;
+        allowance: string;
+        decimals: number;
+    }>;
+    protectionCloseFactorWhitelist: boolean;
+    userPriceImpact: Array<{
+        cumulVolPriceImpactMultiplier: string;
+        fixedSpreadP: string;
+    }>;
+}
+export type OpenTradeInfo = {
+    tradeId: string;
+    timestamp: number;
+};
+export type OpenTradeInfoMap = {
+    [key: string]: OpenTradeInfo;
+};
+export type PairOiBackend = {
+    oiLongUsd: string;
+    oiShortUsd: string;
+};
+export type OiWindowsBackend = {
+    [key: string]: PairOiBackend;
+};
+export type OiWindowsSettingsBackend = {
+    startTs: number;
+    windowsDuration: number;
+    windowsCount: number;
+};
+export type CollateralConfigBackend = {
+    precision: string;
+    precisionDelta: string;
+    decimals: number;
+};
+export type FeeTierBackend = {
+    feeMultiplier: string;
+    pointsThreshold: string;
+};
+export type FeeTiersBackend = {
+    tiers: FeeTierBackend[];
+    multipliers: string[];
+    currentDay: number;
+    stakingTiers: FeeTierBackend[];
+    gnsVaultAddress: string;
+    useGnsVaultBalance: boolean;
+};
+export type GlobalTradeFeeParamsBackend = {
+    referralFeeP: string;
+    govFeeP: string;
+    triggerOrderFeeP: string;
+    gnsOtcFeeP: string;
+    gTokenFeeP: string;
+};
+export type CounterTradeSettingsBackend = {
+    maxLeverage: string;
+    feeRateMultiplier: string;
+};

package/lib/backend/tradingVariables/backend.types.js

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

package/lib/backend/tradingVariables/converter.d.ts

@@ -0,0 +1,38 @@
+import { ContestLeaderboardBackendEntry, ContestLeaderboardEntry } from "@gainsnetwork/contests";
+import { BorrowingFee, CollateralConfig, Fee, FeeTiers, GlobalTradeFeeParams, OiWindows, OiWindowsSettings, OpenInterest, Pair, PairOi, Trade, TradeContainer, TradeInfo, TradeInitialAccFees, TraderFeeTiers, TradingGroup, PairFactor, convertLiquidationParams } from "../../";
+import { convertPairDepthBandsFromSlots } from "../../trade/priceImpact/cumulVol/converter";
+import { BorrowingFeePerBlockCapBackend, CollateralBackend, FeeBackend, FeeTiersBackend, GlobalTradeFeeParamsBackend, OiWindowsBackend, OiWindowsSettingsBackend, OpenInterestBackend, PairBackend, PairDepthBandsBackend, DepthBandsMappingBackend, PairFactorBackend, PairOiBackend, PairParamsBorrowingFeesBackend, TradeBackend, TradeContainerBackend, TradeInfoBackend, TradeInitialAccFeesBackend, TraderFeeTiersBackend, TradingGroupBackend } from "./backend.types";
+import { TradingVariablesCollateral } from "./types";
+export declare const convertFees: (fees: FeeBackend[]) => Fee[];
+export declare const convertCollaterals: (collaterals: CollateralBackend[]) => TradingVariablesCollateral[];
+export declare const convertOpenInterests: (interests: OpenInterestBackend[]) => OpenInterest[];
+export declare const convertPairDepthBands: (pairDepthBands: PairDepthBandsBackend[]) => ReturnType<typeof convertPairDepthBandsFromSlots>[];
+export declare const convertDepthBandsMapping: (mapping: DepthBandsMappingBackend) => {
+    bands: number[];
+};
+export declare const convertPairSkewDepths: (pairSkewDepths: string[] | undefined) => {
+    [pairIndex: number]: number;
+};
+export declare const convertPairBorrowingFees: (pairParams: PairParamsBorrowingFeesBackend) => BorrowingFee.Pair[];
+export declare const convertGroupBorrowingFees: (pairParams: PairParamsBorrowingFeesBackend) => BorrowingFee.Group[];
+export declare const convertTradingGroups: (groups: TradingGroupBackend[]) => TradingGroup[];
+export declare const convertTradingPairs: (pairs: PairBackend[]) => Pair[];
+export declare const convertTradesAndLimitOrders: (allItems: TradeContainerBackend[], collaterals: TradingVariablesCollateral[]) => TradeContainer[];
+export declare const convertTradeContainer: (tradeContainer: TradeContainerBackend, collaterals: TradingVariablesCollateral[]) => TradeContainer;
+export declare const convertPairFactor: (pairFactor: PairFactorBackend) => PairFactor;
+export declare const convertTrade: (trade: TradeBackend, collaterals: TradingVariablesCollateral[]) => Trade;
+export declare const convertTradeInfo: (tradeInfo: TradeInfoBackend) => TradeInfo;
+export declare const convertTradeInitialAccFees: (initialAccFees: TradeInitialAccFeesBackend) => TradeInitialAccFees;
+export declare const generateStockPairToActiveStockSplit: (pairs?: PairBackend[]) => Map<string, string>;
+export declare const convertContestLeaderboardEntry: (entry: ContestLeaderboardBackendEntry) => ContestLeaderboardEntry;
+export declare const convertPairOi: (collateral: PairOiBackend) => PairOi;
+export declare const convertOiWindows: (oiWindows: OiWindowsBackend[]) => OiWindows[];
+export declare const convertOiWindowsSettings: (oiWindowsSettings: OiWindowsSettingsBackend) => OiWindowsSettings;
+export declare const convertCollateralConfig: (collateral: CollateralBackend) => CollateralConfig;
+export declare const convertFeeTiers: (feeTiersBackend: FeeTiersBackend) => FeeTiers;
+export declare const convertTraderFeeTiers: (traderFeeTiers: TraderFeeTiersBackend) => TraderFeeTiers;
+export declare const convertGlobalTradeFeeParams: (fee: GlobalTradeFeeParamsBackend) => GlobalTradeFeeParams;
+export declare const convertMaxLeverages: (maxLeverages: string[]) => number[];
+export declare const convertFeePerBlockCap: (feeCap: BorrowingFeePerBlockCapBackend | undefined) => BorrowingFee.BorrowingFeePerBlockCap;
+export declare const convertPairName: (pair?: PairBackend) => string;
+export { convertLiquidationParams };