@gainsnetwork/sdk 1.4.5 → 1.5.0-rc2

package/lib/contracts/types/generated/factories/GNSMultiCollatDiamond__factory.js

@@ -3715,6 +3715,21 @@ const _abi = [
         type: "function",
         signature: "0xfed8a190",
     },
+    {
+        inputs: [],
+        name: "DepthBandsAboveMax",
+        type: "error",
+    },
+    {
+        inputs: [],
+        name: "DepthBandsIncomplete",
+        type: "error",
+    },
+    {
+        inputs: [],
+        name: "WrongDepthBandsOrder",
+        type: "error",
+    },
     {
         inputs: [],
         name: "WrongWindowsCount",
@@ -3745,6 +3760,26 @@ const _abi = [
         type: "event",
         signature: "0x2742ec28d0252b4477106a77a10b04e1c1ecd2b568c7168d56c3a3154d3a3122",
     },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "slot1",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "slot2",
+                type: "uint256",
+            },
+        ],
+        name: "DepthBandsMappingUpdated",
+        type: "event",
+        signature: "0x22391293f5705268ac47df15d88a7704e1267eff228801ac480dbe5ecf5ea3ef",
+    },
     {
         anonymous: false,
         inputs: [
@@ -3871,6 +3906,44 @@ const _abi = [
         type: "event",
         signature: "0xbe433d32d9112c2fcf91407f28314200753b05ef3e9c85b8a0e9d135e77a6c29",
     },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: "uint256",
+                name: "pairIndex",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "aboveSlot1",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "aboveSlot2",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "belowSlot1",
+                type: "uint256",
+            },
+            {
+                indexed: false,
+                internalType: "uint256",
+                name: "belowSlot2",
+                type: "uint256",
+            },
+        ],
+        name: "PairDepthBandsUpdated",
+        type: "event",
+        signature: "0x7a9ee81b0015d0b7824d14757416905ea9ace5b9ad54dc08cb426cd0ae3dff9f",
+    },
     {
         anonymous: false,
         inputs: [
@@ -4230,6 +4303,39 @@ const _abi = [
         type: "function",
         signature: "0x81688f7b",
     },
+    {
+        inputs: [],
+        name: "getDepthBandsMapping",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "slot1",
+                type: "uint256",
+            },
+            {
+                internalType: "uint256",
+                name: "slot2",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+        signature: "0xd40e0d20",
+    },
+    {
+        inputs: [],
+        name: "getDepthBandsMappingDecoded",
+        outputs: [
+            {
+                internalType: "uint16[]",
+                name: "bands",
+                type: "uint16[]",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+        signature: "0x9615d82a",
+    },
     {
         inputs: [],
         name: "getNegPnlCumulVolMultiplier",
@@ -4367,29 +4473,39 @@ const _abi = [
                 type: "uint256",
             },
         ],
-        name: "getPairDepth",
+        name: "getPairDepthBands",
         outputs: [
             {
                 components: [
                     {
-                        internalType: "uint128",
-                        name: "onePercentDepthAboveUsd",
-                        type: "uint128",
+                        internalType: "uint256",
+                        name: "aboveSlot1",
+                        type: "uint256",
                     },
                     {
-                        internalType: "uint128",
-                        name: "onePercentDepthBelowUsd",
-                        type: "uint128",
+                        internalType: "uint256",
+                        name: "aboveSlot2",
+                        type: "uint256",
+                    },
+                    {
+                        internalType: "uint256",
+                        name: "belowSlot1",
+                        type: "uint256",
+                    },
+                    {
+                        internalType: "uint256",
+                        name: "belowSlot2",
+                        type: "uint256",
                     },
                 ],
-                internalType: "struct IPriceImpact.PairDepth",
+                internalType: "struct IPriceImpact.PairDepthBands",
                 name: "",
                 type: "tuple",
             },
         ],
         stateMutability: "view",
         type: "function",
-        signature: "0x375bb2bb",
+        signature: "0xc693e1be",
     },
     {
         inputs: [
@@ -4399,29 +4515,109 @@ const _abi = [
                 type: "uint256[]",
             },
         ],
-        name: "getPairDepths",
+        name: "getPairDepthBandsArray",
         outputs: [
             {
                 components: [
                     {
-                        internalType: "uint128",
-                        name: "onePercentDepthAboveUsd",
-                        type: "uint128",
+                        internalType: "uint256",
+                        name: "aboveSlot1",
+                        type: "uint256",
                     },
                     {
-                        internalType: "uint128",
-                        name: "onePercentDepthBelowUsd",
-                        type: "uint128",
+                        internalType: "uint256",
+                        name: "aboveSlot2",
+                        type: "uint256",
+                    },
+                    {
+                        internalType: "uint256",
+                        name: "belowSlot1",
+                        type: "uint256",
+                    },
+                    {
+                        internalType: "uint256",
+                        name: "belowSlot2",
+                        type: "uint256",
                     },
                 ],
-                internalType: "struct IPriceImpact.PairDepth[]",
+                internalType: "struct IPriceImpact.PairDepthBands[]",
                 name: "",
                 type: "tuple[]",
             },
         ],
         stateMutability: "view",
         type: "function",
-        signature: "0x0d569f27",
+        signature: "0x35bf34e8",
+    },
+    {
+        inputs: [
+            {
+                internalType: "uint256",
+                name: "_pairIndex",
+                type: "uint256",
+            },
+        ],
+        name: "getPairDepthBandsDecoded",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "totalDepthAboveUsd",
+                type: "uint256",
+            },
+            {
+                internalType: "uint256",
+                name: "totalDepthBelowUsd",
+                type: "uint256",
+            },
+            {
+                internalType: "uint16[]",
+                name: "bandsAbove",
+                type: "uint16[]",
+            },
+            {
+                internalType: "uint16[]",
+                name: "bandsBelow",
+                type: "uint16[]",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+        signature: "0x2b363e71",
+    },
+    {
+        inputs: [
+            {
+                internalType: "uint256[]",
+                name: "_indices",
+                type: "uint256[]",
+            },
+        ],
+        name: "getPairDepthBandsDecodedArray",
+        outputs: [
+            {
+                internalType: "uint256[]",
+                name: "totalDepthAboveUsd",
+                type: "uint256[]",
+            },
+            {
+                internalType: "uint256[]",
+                name: "totalDepthBelowUsd",
+                type: "uint256[]",
+            },
+            {
+                internalType: "uint16[][]",
+                name: "bandsAbove",
+                type: "uint16[][]",
+            },
+            {
+                internalType: "uint16[][]",
+                name: "bandsBelow",
+                type: "uint16[][]",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+        signature: "0x299f621d",
     },
     {
         inputs: [
@@ -4850,6 +5046,25 @@ const _abi = [
         type: "function",
         signature: "0x5a1449ab",
     },
+    {
+        inputs: [
+            {
+                internalType: "uint256",
+                name: "_slot1",
+                type: "uint256",
+            },
+            {
+                internalType: "uint256",
+                name: "_slot2",
+                type: "uint256",
+            },
+        ],
+        name: "initializeDepthBandsMapping",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+        signature: "0xbb8f07af",
+    },
     {
         inputs: [
             {
@@ -4931,6 +5146,25 @@ const _abi = [
         type: "function",
         signature: "0xa7d518fc",
     },
+    {
+        inputs: [
+            {
+                internalType: "uint256",
+                name: "_slot1",
+                type: "uint256",
+            },
+            {
+                internalType: "uint256",
+                name: "_slot2",
+                type: "uint256",
+            },
+        ],
+        name: "setDepthBandsMapping",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+        signature: "0x7e8462f7",
+    },
     {
         inputs: [
             {
@@ -4991,21 +5225,38 @@ const _abi = [
                 type: "uint256[]",
             },
             {
-                internalType: "uint128[]",
-                name: "_depthsAboveUsd",
-                type: "uint128[]",
-            },
-            {
-                internalType: "uint128[]",
-                name: "_depthsBelowUsd",
-                type: "uint128[]",
+                components: [
+                    {
+                        internalType: "uint256",
+                        name: "aboveSlot1",
+                        type: "uint256",
+                    },
+                    {
+                        internalType: "uint256",
+                        name: "aboveSlot2",
+                        type: "uint256",
+                    },
+                    {
+                        internalType: "uint256",
+                        name: "belowSlot1",
+                        type: "uint256",
+                    },
+                    {
+                        internalType: "uint256",
+                        name: "belowSlot2",
+                        type: "uint256",
+                    },
+                ],
+                internalType: "struct IPriceImpact.PairDepthBands[]",
+                name: "_depthBands",
+                type: "tuple[]",
             },
         ],
-        name: "setPairDepths",
+        name: "setPairDepthBands",
         outputs: [],
         stateMutability: "nonpayable",
         type: "function",
-        signature: "0x6474b399",
+        signature: "0x88be5e4f",
     },
     {
         inputs: [

package/lib/contracts/utils/pairs.d.ts

@@ -1,7 +1,18 @@
-import { Pair, Fee, OpenInterest, PairDepth, PairIndex } from "../../trade/types";
+import { Fee, OpenInterest, Pair, PairIndex } from "../../trade/types";
 import { Contracts } from "../../contracts/types";
 export declare const fetchPairs: (contracts: Contracts, pairIxs: PairIndex[]) => Promise<Pair[]>;
-export declare const fetchPairDepths: (contracts: Contracts, pairIxs: number[]) => Promise<PairDepth[]>;
+export declare const fetchPairDepthBands: (contracts: Contracts, pairIxs: number[]) => Promise<any[]>;
+export declare const fetchPairDepthBandsDecoded: (contracts: Contracts, pairIxs: number[]) => Promise<{
+    totalDepthAboveUsd: number[];
+    totalDepthBelowUsd: number[];
+    bandsAbove: number[][];
+    bandsBelow: number[][];
+}>;
+export declare const fetchDepthBandsMapping: (contracts: Contracts) => Promise<{
+    slot1: string;
+    slot2: string;
+}>;
+export declare const fetchDepthBandsMappingDecoded: (contracts: Contracts) => Promise<number[]>;
 export declare const fetchFees: (contracts: Contracts, feeIxs: PairIndex[]) => Promise<Fee[]>;
 export declare const fetchOpenInterest: (contracts: Contracts, collateralIndex: number, pairIxs: number[]) => Promise<OpenInterest[]>;
 export declare const getPairDescription: (pairIndex: PairIndex) => string;

package/lib/contracts/utils/pairs.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPairDescription = exports.fetchOpenInterest = exports.fetchFees = exports.fetchPairDepths = exports.fetchPairs = void 0;
+exports.getPairDescription = exports.fetchOpenInterest = exports.fetchFees = exports.fetchDepthBandsMappingDecoded = exports.fetchDepthBandsMapping = exports.fetchPairDepthBandsDecoded = exports.fetchPairDepthBands = exports.fetchPairs = void 0;
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
@@ -31,26 +31,83 @@ const fetchPairs = async (contracts, pairIxs) => {
     }
 };
 exports.fetchPairs = fetchPairs;
-const fetchPairDepths = async (contracts, pairIxs) => {
+const fetchPairDepthBands = async (contracts, pairIxs) => {
+    if (!contracts || pairIxs.length === 0) {
+        return [];
+    }
+    const { gnsMultiCollatDiamond: multiCollatContract } = contracts;
+    try {
+        // Returns array of PairDepthBands structs (encoded slots)
+        return await multiCollatContract.getPairDepthBandsArray(pairIxs);
+    }
+    catch (error) {
+        console.error(`Unexpected error while fetching pair depth bands!`);
+        throw error;
+    }
+};
+exports.fetchPairDepthBands = fetchPairDepthBands;
+const fetchPairDepthBandsDecoded = async (contracts, pairIxs) => {
+    if (!contracts || pairIxs.length === 0) {
+        return {
+            totalDepthAboveUsd: [],
+            totalDepthBelowUsd: [],
+            bandsAbove: [],
+            bandsBelow: [],
+        };
+    }
+    const { gnsMultiCollatDiamond: multiCollatContract } = contracts;
+    try {
+        // Returns decoded values
+        // Using quoted signature for overloaded function
+        const [totalDepthAboveUsd, totalDepthBelowUsd, bandsAbove, bandsBelow] = await multiCollatContract.getPairDepthBandsDecodedArray(pairIxs);
+        return {
+            totalDepthAboveUsd: totalDepthAboveUsd.map((v) => parseFloat(v.toString())),
+            totalDepthBelowUsd: totalDepthBelowUsd.map((v) => parseFloat(v.toString())),
+            bandsAbove: bandsAbove.map((bands) => bands.map((b) => parseInt(b.toString()))),
+            bandsBelow: bandsBelow.map((bands) => bands.map((b) => parseInt(b.toString()))),
+        };
+    }
+    catch (error) {
+        console.error(`Unexpected error while fetching decoded pair depth bands!`);
+        throw error;
+    }
+};
+exports.fetchPairDepthBandsDecoded = fetchPairDepthBandsDecoded;
+const fetchDepthBandsMapping = async (contracts) => {
+    if (!contracts) {
+        return { slot1: "0", slot2: "0" };
+    }
+    const { gnsMultiCollatDiamond: multiCollatContract } = contracts;
+    try {
+        // Returns two uint256 slots
+        const [slot1, slot2] = await multiCollatContract.getDepthBandsMapping();
+        return {
+            slot1: slot1.toString(),
+            slot2: slot2.toString(),
+        };
+    }
+    catch (error) {
+        console.error(`Unexpected error while fetching depth bands mapping!`);
+        throw error;
+    }
+};
+exports.fetchDepthBandsMapping = fetchDepthBandsMapping;
+const fetchDepthBandsMappingDecoded = async (contracts) => {
     if (!contracts) {
         return [];
     }
     const { gnsMultiCollatDiamond: multiCollatContract } = contracts;
     try {
-        const pairParams = await multiCollatContract.getPairDepths(pairIxs);
-        return pairParams.map(pair => {
-            return {
-                onePercentDepthAboveUsd: parseFloat(pair.onePercentDepthAboveUsd.toString()),
-                onePercentDepthBelowUsd: parseFloat(pair.onePercentDepthBelowUsd.toString()),
-            };
-        });
+        // Returns array of 30 uint16 values
+        const bands = await multiCollatContract.getDepthBandsMappingDecoded();
+        return bands.map((b) => parseInt(b.toString()));
     }
     catch (error) {
-        console.error(`Unexpected error while fetching pairs!`);
+        console.error(`Unexpected error while fetching decoded depth bands mapping!`);
         throw error;
     }
 };
-exports.fetchPairDepths = fetchPairDepths;
+exports.fetchDepthBandsMappingDecoded = fetchDepthBandsMappingDecoded;
 const fetchFees = async (contracts, feeIxs) => {
     if (!contracts) {
         return [];

package/lib/index.d.ts

@@ -5,5 +5,6 @@ export * from "./constants";
 export * from "./utils";
 export * from "./vault";
 export * from "./backend";
+export * from "./pricing";
 export * from "./trade/fees/borrowing/index";
 export { ContractsVersion } from "./contracts/types";

package/lib/index.js

@@ -22,6 +22,7 @@ __exportStar(require("./constants"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./vault"), exports);
 __exportStar(require("./backend"), exports);
+__exportStar(require("./pricing"), exports);
 // Not sure why this is needed, but it is. Barrel imports are not working.
 __exportStar(require("./trade/fees/borrowing/index"), exports);
 // Export ContractsVersion for frontend usage

package/lib/pricing/depthBands.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @dev Depth bands encoding/decoding functions
+ */
+/**
+ * Encode depth bands data into two uint256 slots
+ * @param totalDepthUsd Total depth in USD (must fit in uint32)
+ * @param bandPercentagesBps Array of 30 band percentages in basis points
+ * @returns Two slots as bigints
+ */
+export declare function encodeDepthBands(totalDepthUsd: number, bandPercentagesBps: number[]): {
+    slot1: bigint;
+    slot2: bigint;
+};
+/**
+ * Decode depth bands from two uint256 slots
+ * @param slot1 First slot containing totalDepthUsd and bands 0-13
+ * @param slot2 Second slot containing bands 14-29
+ * @returns Total depth and array of band percentages
+ */
+export declare function decodeDepthBands(slot1: bigint, slot2: bigint): {
+    totalDepthUsd: number;
+    bands: number[];
+};
+/**
+ * Encode depth bands mapping (global offsets for all pairs)
+ * @param bands Array of 30 band offset values in ppm
+ * @returns Two slots as bigints
+ */
+export declare function encodeDepthBandsMapping(bands: number[]): {
+    slot1: bigint;
+    slot2: bigint;
+};
+/**
+ * Decode depth bands mapping from two uint256 slots
+ * @param slot1 First slot containing bands 0-13 (starting at bit 32, first 32 bits unused)
+ * @param slot2 Second slot containing bands 14-29
+ * @returns Array of band offset values in ppm
+ */
+export declare function decodeDepthBandsMapping(slot1: bigint, slot2: bigint): number[];

package/lib/pricing/depthBands.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * @dev Depth bands encoding/decoding functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeDepthBandsMapping = exports.encodeDepthBandsMapping = exports.decodeDepthBands = exports.encodeDepthBands = void 0;
+const DEPTH_BANDS_COUNT = 30;
+const DEPTH_BANDS_PER_SLOT1 = 14;
+/**
+ * Encode depth bands data into two uint256 slots
+ * @param totalDepthUsd Total depth in USD (must fit in uint32)
+ * @param bandPercentagesBps Array of 30 band percentages in basis points
+ * @returns Two slots as bigints
+ */
+function encodeDepthBands(totalDepthUsd, bandPercentagesBps) {
+    // Pack slot1: totalDepthUsd (32 bits) + bands 0-13 (14 * 16 bits)
+    let slot1 = BigInt(totalDepthUsd);
+    for (let i = 0; i < DEPTH_BANDS_PER_SLOT1; i++) {
+        const shift = 32 + i * 16;
+        slot1 |= BigInt(bandPercentagesBps[i]) << BigInt(shift);
+    }
+    // Pack slot2: bands 14-29 (16 * 16 bits)
+    let slot2 = BigInt(0);
+    for (let i = DEPTH_BANDS_PER_SLOT1; i < DEPTH_BANDS_COUNT; i++) {
+        const shift = (i - DEPTH_BANDS_PER_SLOT1) * 16;
+        slot2 |= BigInt(bandPercentagesBps[i]) << BigInt(shift);
+    }
+    return { slot1, slot2 };
+}
+exports.encodeDepthBands = encodeDepthBands;
+/**
+ * Decode depth bands from two uint256 slots
+ * @param slot1 First slot containing totalDepthUsd and bands 0-13
+ * @param slot2 Second slot containing bands 14-29
+ * @returns Total depth and array of band percentages
+ */
+function decodeDepthBands(slot1, slot2) {
+    const totalDepthUsd = Number(slot1 & BigInt(0xffffffff));
+    const bands = [];
+    // Extract bands 0-13 from slot1
+    for (let i = 0; i < DEPTH_BANDS_PER_SLOT1; i++) {
+        const shift = 32 + i * 16;
+        bands.push(Number((slot1 >> BigInt(shift)) & BigInt(0xffff)));
+    }
+    // Extract bands 14-29 from slot2
+    for (let i = DEPTH_BANDS_PER_SLOT1; i < DEPTH_BANDS_COUNT; i++) {
+        const shift = (i - DEPTH_BANDS_PER_SLOT1) * 16;
+        bands.push(Number((slot2 >> BigInt(shift)) & BigInt(0xffff)));
+    }
+    return { totalDepthUsd, bands };
+}
+exports.decodeDepthBands = decodeDepthBands;
+/**
+ * Encode depth bands mapping (global offsets for all pairs)
+ * @param bands Array of 30 band offset values in ppm
+ * @returns Two slots as bigints
+ */
+function encodeDepthBandsMapping(bands) {
+    // Pack slot1: bands 0-13 (starting at bit 32, first 32 bits unused)
+    let slot1 = BigInt(0);
+    for (let i = 0; i < DEPTH_BANDS_PER_SLOT1; i++) {
+        const shift = 32 + i * 16; // Start at bit 32 to match contract
+        slot1 |= BigInt(bands[i]) << BigInt(shift);
+    }
+    // Pack slot2: bands 14-29 (16 * 16 bits)
+    let slot2 = BigInt(0);
+    for (let i = DEPTH_BANDS_PER_SLOT1; i < DEPTH_BANDS_COUNT; i++) {
+        const shift = (i - DEPTH_BANDS_PER_SLOT1) * 16;
+        slot2 |= BigInt(bands[i]) << BigInt(shift);
+    }
+    return { slot1, slot2 };
+}
+exports.encodeDepthBandsMapping = encodeDepthBandsMapping;
+/**
+ * Decode depth bands mapping from two uint256 slots
+ * @param slot1 First slot containing bands 0-13 (starting at bit 32, first 32 bits unused)
+ * @param slot2 Second slot containing bands 14-29
+ * @returns Array of band offset values in ppm
+ */
+function decodeDepthBandsMapping(slot1, slot2) {
+    const bands = [];
+    // Extract bands 0-13 from slot1 (skip first 32 bits which are unused for mappings)
+    for (let i = 0; i < DEPTH_BANDS_PER_SLOT1; i++) {
+        const shift = 32 + i * 16; // Start at bit 32, not bit 0
+        bands.push(Number((slot1 >> BigInt(shift)) & BigInt(0xffff)));
+    }
+    // Extract bands 14-29 from slot2
+    for (let i = DEPTH_BANDS_PER_SLOT1; i < DEPTH_BANDS_COUNT; i++) {
+        const shift = (i - DEPTH_BANDS_PER_SLOT1) * 16;
+        bands.push(Number((slot2 >> BigInt(shift)) & BigInt(0xffff)));
+    }
+    return bands;
+}
+exports.decodeDepthBandsMapping = decodeDepthBandsMapping;

package/lib/pricing/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @dev Pricing module exports
+ */
+export * from "./depthBands";