diff --git a/src/Managing.Application.Abstractions/Grains/ICandleStoreGrain.cs b/src/Managing.Application.Abstractions/Grains/ICandleStoreGrain.cs
index d42306b9..acfd954a 100644
--- a/src/Managing.Application.Abstractions/Grains/ICandleStoreGrain.cs
+++ b/src/Managing.Application.Abstractions/Grains/ICandleStoreGrain.cs
@@ -15,6 +15,11 @@ public interface ICandleStoreGrain : IGrainWithStringKey
     /// </summary>
     /// <returns>List of candles ordered by date</returns>
     Task<HashSet<Candle>> GetCandlesAsync();
-    Task<Candle> GetLastCandle();
+    /// <summary>
+    /// Gets the X latest candles from the store
+    /// </summary>
+    /// <param name="count">Number of latest candles to retrieve (default: 1)</param>
+    /// <returns>List of the X latest candles ordered by date</returns>
+    Task<List<Candle>> GetLastCandle(int count = 1);
 }
 
diff --git a/src/Managing.Application.Abstractions/Services/IMessengerService.cs b/src/Managing.Application.Abstractions/Services/IMessengerService.cs
index 232a80d6..78df21ee 100644
--- a/src/Managing.Application.Abstractions/Services/IMessengerService.cs
+++ b/src/Managing.Application.Abstractions/Services/IMessengerService.cs
@@ -12,7 +12,7 @@ public interface IMessengerService
         Timeframe timeframe);
 
     Task SendPosition(Position position);
-    Task SendClosingPosition(Position position);
+    void SendClosingPosition(Position position);
     Task SendMessage(string message);
     Task SendMessage(string message, string channelId);
 
diff --git a/src/Managing.Application/Bots/TradingBotBase.cs b/src/Managing.Application/Bots/TradingBotBase.cs
index 5381fa56..b7bb7f06 100644
--- a/src/Managing.Application/Bots/TradingBotBase.cs
+++ b/src/Managing.Application/Bots/TradingBotBase.cs
@@ -133,7 +133,8 @@ public class TradingBotBase : ITradingBot
             {
                 // Add a small delay to ensure grain is fully activated
                 await Task.Delay(100);
-                LastCandle = await grain.GetLastCandle();
+                var lastCandles = await grain.GetLastCandle(1);
+                LastCandle = lastCandles.FirstOrDefault();
             }
             catch (InvalidOperationException ex) when (ex.Message.Contains("invalid activation"))
             {
@@ -143,7 +144,8 @@ public class TradingBotBase : ITradingBot
                 await Task.Delay(1000);
                 try
                 {
-                    LastCandle = await grain.GetLastCandle();
+                    var lastCandles = await grain.GetLastCandle(1);
+                    LastCandle = lastCandles.FirstOrDefault();
                 }
                 catch (Exception retryEx)
                 {
@@ -1059,13 +1061,30 @@ public class TradingBotBase : ITradingBot
             if (currentCandle != null)
             {
                 List<Candle> recentCandles = null;
-                await ServiceScopeHelpers.WithScopedService<IExchangeService>(_scopeFactory, async exchangeService =>
+                
+                if (Config.IsForBacktest)
                 {
-                    recentCandles = Config.IsForBacktest
-                        ? (LastCandle != null ? new List<Candle>() { LastCandle } : new List<Candle>())
-                        : (await exchangeService.GetCandlesInflux(TradingExchanges.Evm, Config.Ticker,
-                            DateTime.UtcNow.AddHours(-4), Config.Timeframe)).ToList();
-                });
+                    recentCandles = LastCandle != null ? new List<Candle>() { LastCandle } : new List<Candle>();
+                }
+                else
+                {
+                    // Use CandleStoreGrain to get recent candles instead of calling exchange service directly
+                    await ServiceScopeHelpers.WithScopedService<IGrainFactory>(_scopeFactory, async grainFactory =>
+                    {
+                        var grainKey = CandleHelpers.GetCandleStoreGrainKey(Account.Exchange, Config.Ticker, Config.Timeframe);
+                        var grain = grainFactory.GetGrain<ICandleStoreGrain>(grainKey);
+                        
+                        try
+                        {
+                            recentCandles = await grain.GetLastCandle(5);
+                        }
+                        catch (Exception ex)
+                        {
+                            Logger.LogError(ex, "Error retrieving recent candles from CandleStoreGrain for {GrainKey}", grainKey);
+                            recentCandles = new List<Candle>();
+                        }
+                    });
+                }
 
                 // Check if we have any candles before proceeding
                 if (recentCandles == null || !recentCandles.Any())
@@ -1216,7 +1235,8 @@ public class TradingBotBase : ITradingBot
         if (!Config.IsForBacktest)
         {
             await ServiceScopeHelpers.WithScopedService<IMessengerService>(_scopeFactory,
-                async messengerService => { await messengerService.SendClosingPosition(position); });
+                 messengerService => { messengerService.SendClosingPosition(position);
+                 return Task.CompletedTask; });
         }
 
         await CancelAllOrders();
diff --git a/src/Managing.Application/Grains/CandleStoreGrain.cs b/src/Managing.Application/Grains/CandleStoreGrain.cs
index bb9b9272..5e540a93 100644
--- a/src/Managing.Application/Grains/CandleStoreGrain.cs
+++ b/src/Managing.Application/Grains/CandleStoreGrain.cs
@@ -232,7 +232,7 @@ public class CandleStoreGrain : Grain, ICandleStoreGrain, IAsyncObserver<Candle>
         }
     }
 
-    public Task<Candle> GetLastCandle()
+    public Task<List<Candle>> GetLastCandle(int count = 1)
     {
         try
         {
@@ -240,15 +240,33 @@ public class CandleStoreGrain : Grain, ICandleStoreGrain, IAsyncObserver<Candle>
             if (_state.State.Candles == null || _state.State.Candles.Count == 0)
             {
                 _logger.LogDebug("No candles available for grain {GrainKey}", this.GetPrimaryKeyString());
-                return Task.FromResult<Candle>(null);
+                return Task.FromResult(new List<Candle>());
             }
 
-            return Task.FromResult(_state.State.Candles.LastOrDefault());
+            // Validate count parameter
+            if (count <= 0)
+            {
+                _logger.LogWarning("Invalid count parameter {Count} for grain {GrainKey}, using default value 1", 
+                    count, this.GetPrimaryKeyString());
+                count = 1;
+            }
+
+            // Get the last X candles, ordered by date
+            var lastCandles = _state.State.Candles
+                .OrderBy(c => c.Date)
+                .TakeLast(count)
+                .ToList();
+
+            _logger.LogDebug("Retrieved {Count} latest candles for grain {GrainKey}", 
+                lastCandles.Count, this.GetPrimaryKeyString());
+
+            return Task.FromResult(lastCandles);
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Error retrieving last candle for grain {GrainKey}", this.GetPrimaryKeyString());
-            return Task.FromResult<Candle>(null);
+            _logger.LogError(ex, "Error retrieving last {Count} candles for grain {GrainKey}", 
+                count, this.GetPrimaryKeyString());
+            return Task.FromResult(new List<Candle>());
         }
     }
 }
diff --git a/src/Managing.Application/Shared/MessengerService.cs b/src/Managing.Application/Shared/MessengerService.cs
index cb6ce3de..5dd65f01 100644
--- a/src/Managing.Application/Shared/MessengerService.cs
+++ b/src/Managing.Application/Shared/MessengerService.cs
@@ -25,9 +25,21 @@ public class MessengerService : IMessengerService
         await _discordService.SendClosedPosition(address, oldTrade);
     }
 
-    public async Task SendClosingPosition(Position position)
+    public void SendClosingPosition(Position position)
     {
-        await _discordService.SendClosingPosition(position);
+        // Fire-and-forget: Send closing position notification without blocking the thread
+        _ = Task.Run(async () =>
+        {
+            try
+            {
+                await _discordService.SendClosingPosition(position);
+            }
+            catch (Exception ex)
+            {
+                // Log the exception but don't let it affect the main thread
+                Console.WriteLine($"Failed to send closing position notification: {ex.Message}");
+            }
+        });
     }
 
     public async Task SendIncreasePosition(string address, Trade trade, string copyAccountName, Trade? oldTrade = null)
diff --git a/src/Managing.Application/Trading/Commands/OpenPositionRequest.cs b/src/Managing.Application/Trading/Commands/OpenPositionRequest.cs
index 77f45eda..49e1c61e 100644
--- a/src/Managing.Application/Trading/Commands/OpenPositionRequest.cs
+++ b/src/Managing.Application/Trading/Commands/OpenPositionRequest.cs
@@ -1,4 +1,5 @@
-using Managing.Domain.Trades;
+using Managing.Common;
+using Managing.Domain.Trades;
 using Managing.Domain.Users;
 using MediatR;
 using static Managing.Common.Enums;
@@ -29,7 +30,7 @@ namespace Managing.Application.Trading.Commands
             Date = date;
             User = user;
 
-            if (amountToTrade <= 10)
+            if (amountToTrade <= Constants.GMX.Config.MinimumPositionAmount)
             {
                 throw new ArgumentException("Bot trading balance must be greater than zero", nameof(amountToTrade));
             }
@@ -39,7 +40,9 @@ namespace Managing.Application.Trading.Commands
             IsForPaperTrading = isForPaperTrading;
             Price = price;
             SignalIdentifier = signalIdentifier;
-            InitiatorIdentifier = initiatorIdentifier ?? throw new ArgumentNullException(nameof(initiatorIdentifier), "InitiatorIdentifier is required");
+            InitiatorIdentifier = initiatorIdentifier ??
+                                  throw new ArgumentNullException(nameof(initiatorIdentifier),
+                                      "InitiatorIdentifier is required");
         }
 
         public string SignalIdentifier { get; set; }
diff --git a/src/Managing.Infrastructure.Web3/Models/Proxy/GetGmxPositionsResponse.cs b/src/Managing.Infrastructure.Web3/Models/Proxy/GetGmxPositionsResponse.cs
index 343dc4d5..33d10723 100644
--- a/src/Managing.Infrastructure.Web3/Models/Proxy/GetGmxPositionsResponse.cs
+++ b/src/Managing.Infrastructure.Web3/Models/Proxy/GetGmxPositionsResponse.cs
@@ -1,3 +1,4 @@
+using System.Text.Json.Serialization;
 using Newtonsoft.Json;
 
 namespace Managing.Infrastructure.Evm.Models.Proxy;
@@ -45,11 +46,17 @@ public class GmxPosition
 
     [JsonProperty("liquidationPrice")] public double LiquidationPrice { get; set; }
 
-    [JsonProperty("stopLoss")] public GmxTrade StopLoss { get; set; }
+    [JsonProperty("StopLoss")]
+    [JsonPropertyName("StopLoss")]
+    public GmxTrade StopLoss { get; set; }
 
-    [JsonProperty("takeProfit1")] public GmxTrade TakeProfit1 { get; set; }
+    [JsonProperty("TakeProfit1")]
+    [JsonPropertyName("TakeProfit1")]
+    public GmxTrade TakeProfit1 { get; set; }
 
-    [JsonProperty("open")] public GmxTrade Open { get; set; }
+    [JsonProperty("Open")]
+    [JsonPropertyName("Open")]
+    public GmxTrade Open { get; set; }
 }
 
 public class GetGmxPositionsResponse : Web3ProxyBaseResponse
diff --git a/src/Managing.Web3Proxy/package-lock.json b/src/Managing.Web3Proxy/package-lock.json
index a7237eef..d204f5cc 100644
--- a/src/Managing.Web3Proxy/package-lock.json
+++ b/src/Managing.Web3Proxy/package-lock.json
@@ -36,10 +36,11 @@
         "fastify-plugin": "^5.0.1",
         "form-data": "^4.0.1",
         "knex": "^3.1.0",
+        "lodash": "^4.17.21",
         "mysql2": "^3.11.3",
         "postgrator": "^8.0.0",
         "query-string": "^9.1.1",
-        "viem": "^2.23.15",
+        "viem": "2.37.1",
         "vitest": "^3.0.8",
         "zod": "^3.24.2"
       },
@@ -56,6 +57,8 @@
     },
     "node_modules/@adraffy/ens-normalize": {
       "version": "1.11.0",
+      "resolved": "https://registry.npmjs.org/@adraffy/ens-normalize/-/ens-normalize-1.11.0.tgz",
+      "integrity": "sha512-/3DDPKHqqIqxUULp8yP4zODUY1i+2xvVWsv8A79xGWdCAG+8sb0hRh0Rk2QyOJUnnbyPUAZYcpBuRe3nS2OIUg==",
       "license": "MIT"
     },
     "node_modules/@babel/runtime": {
@@ -742,11 +745,25 @@
         "node": ">=8"
       }
     },
+    "node_modules/@noble/ciphers": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/@noble/ciphers/-/ciphers-1.3.0.tgz",
+      "integrity": "sha512-2I0gnIVPtfnMw9ee9h1dJG7tp81+8Ob3OJb3Mv37rx5L40/b0i7djjCVvGOVqc9AEIQyvyu1i6ypKdFw8R8gQw==",
+      "license": "MIT",
+      "engines": {
+        "node": "^14.21.3 || >=16"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
     "node_modules/@noble/curves": {
-      "version": "1.8.1",
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-1.9.1.tgz",
+      "integrity": "sha512-k11yZxZg+t+gWvBbIswW0yoJlu8cHOC7dhunwOzoWH/mXGBiYyR4YY6hAEK/3EUs4UpB8la1RfdRpeGsFHkWsA==",
       "license": "MIT",
       "dependencies": {
-        "@noble/hashes": "1.7.1"
+        "@noble/hashes": "1.8.0"
       },
       "engines": {
         "node": "^14.21.3 || >=16"
@@ -756,7 +773,9 @@
       }
     },
     "node_modules/@noble/hashes": {
-      "version": "1.7.1",
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.8.0.tgz",
+      "integrity": "sha512-jCs9ldd7NwzpgXDIf6P3+NrHh9/sD6CQdxHyjQI+h/6rDNo88ypBxxz45UDuZHz9r3tNz7N/VInSVoVdtXEI4A==",
       "license": "MIT",
       "engines": {
         "node": "^14.21.3 || >=16"
@@ -1514,30 +1533,36 @@
       ]
     },
     "node_modules/@scure/base": {
-      "version": "1.2.4",
+      "version": "1.2.6",
+      "resolved": "https://registry.npmjs.org/@scure/base/-/base-1.2.6.tgz",
+      "integrity": "sha512-g/nm5FgUa//MCj1gV09zTJTaM6KBAHqLN907YVQqf7zC49+DcO4B1so4ZX07Ef10Twr6nuqYEH9GEggFXA4Fmg==",
       "license": "MIT",
       "funding": {
         "url": "https://paulmillr.com/funding/"
       }
     },
     "node_modules/@scure/bip32": {
-      "version": "1.6.2",
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/@scure/bip32/-/bip32-1.7.0.tgz",
+      "integrity": "sha512-E4FFX/N3f4B80AKWp5dP6ow+flD1LQZo/w8UnLGYZO674jS6YnYeepycOOksv+vLPSpgN35wgKgy+ybfTb2SMw==",
       "license": "MIT",
       "dependencies": {
-        "@noble/curves": "~1.8.1",
-        "@noble/hashes": "~1.7.1",
-        "@scure/base": "~1.2.2"
+        "@noble/curves": "~1.9.0",
+        "@noble/hashes": "~1.8.0",
+        "@scure/base": "~1.2.5"
       },
       "funding": {
         "url": "https://paulmillr.com/funding/"
       }
     },
     "node_modules/@scure/bip39": {
-      "version": "1.5.4",
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.6.0.tgz",
+      "integrity": "sha512-+lF0BbLiJNwVlev4eKelw1WWLaiKXw7sSl8T6FvBlWkdX+94aGJ4o8XjUdlyhTCjd8c+B3KT3JfS8P0bLRNU6A==",
       "license": "MIT",
       "dependencies": {
-        "@noble/hashes": "~1.7.1",
-        "@scure/base": "~1.2.4"
+        "@noble/hashes": "~1.8.0",
+        "@scure/base": "~1.2.5"
       },
       "funding": {
         "url": "https://paulmillr.com/funding/"
@@ -2050,6 +2075,8 @@
     },
     "node_modules/abitype": {
       "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/abitype/-/abitype-1.0.8.tgz",
+      "integrity": "sha512-ZeiI6h3GnW06uYDLx0etQtX/p8E24UaHHBj57RSjK7YBFe7iuVn07EDpOeP451D06sF27VOz9JJPlIKJmXgkEg==",
       "license": "MIT",
       "funding": {
         "url": "https://github.com/sponsors/wevm"
@@ -5108,7 +5135,9 @@
       }
     },
     "node_modules/isows": {
-      "version": "1.0.6",
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/isows/-/isows-1.0.7.tgz",
+      "integrity": "sha512-I1fSfDCZL5P0v33sVqeTDSpcstAg/N+wF5HS033mogOVIp4B+oHC7oOCsA3axAbBSGTJ8QubbNmnIRN/h8U7hg==",
       "funding": [
         {
           "type": "github",
@@ -5482,6 +5511,8 @@
     },
     "node_modules/lodash": {
       "version": "4.17.21",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz",
+      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==",
       "license": "MIT"
     },
     "node_modules/lodash.merge": {
@@ -5937,7 +5968,9 @@
       }
     },
     "node_modules/ox": {
-      "version": "0.6.9",
+      "version": "0.9.3",
+      "resolved": "https://registry.npmjs.org/ox/-/ox-0.9.3.tgz",
+      "integrity": "sha512-KzyJP+fPV4uhuuqrTZyok4DC7vFzi7HLUFiUNEmpbyh59htKWkOC98IONC1zgXJPbHAhQgqs6B0Z6StCGhmQvg==",
       "funding": [
         {
           "type": "github",
@@ -5946,12 +5979,13 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "@adraffy/ens-normalize": "^1.10.1",
-        "@noble/curves": "^1.6.0",
-        "@noble/hashes": "^1.5.0",
-        "@scure/bip32": "^1.5.0",
-        "@scure/bip39": "^1.4.0",
-        "abitype": "^1.0.6",
+        "@adraffy/ens-normalize": "^1.11.0",
+        "@noble/ciphers": "^1.3.0",
+        "@noble/curves": "1.9.1",
+        "@noble/hashes": "^1.8.0",
+        "@scure/bip32": "^1.7.0",
+        "@scure/bip39": "^1.6.0",
+        "abitype": "^1.0.9",
         "eventemitter3": "5.0.1"
       },
       "peerDependencies": {
@@ -5963,6 +5997,27 @@
         }
       }
     },
+    "node_modules/ox/node_modules/abitype": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/abitype/-/abitype-1.1.0.tgz",
+      "integrity": "sha512-6Vh4HcRxNMLA0puzPjM5GBgT4aAcFGKZzSgAXvuZ27shJP6NEpielTuqbBmZILR5/xd0PizkBGy5hReKz9jl5A==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/wevm"
+      },
+      "peerDependencies": {
+        "typescript": ">=5.0.4",
+        "zod": "^3.22.0 || ^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        },
+        "zod": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/p-limit": {
       "version": "3.1.0",
       "dev": true,
@@ -7758,9 +7813,9 @@
       }
     },
     "node_modules/viem": {
-      "version": "2.23.15",
-      "resolved": "https://registry.npmjs.org/viem/-/viem-2.23.15.tgz",
-      "integrity": "sha512-2t9lROkSzj/ciEZ08NqAHZ6c+J1wKLwJ4qpUxcHdVHcLBt6GfO9+ycuZycTT05ckfJ6TbwnMXMa3bMonvhtUMw==",
+      "version": "2.37.1",
+      "resolved": "https://registry.npmjs.org/viem/-/viem-2.37.1.tgz",
+      "integrity": "sha512-IzacdIXYlOvzDJwNKIVa53LP/LaP70qvBGAIoGH6R+n06S/ru/nnQxLNZ6+JImvIcxwNwgAl0jUA6FZEIQQWSw==",
       "funding": [
         {
           "type": "github",
@@ -7769,14 +7824,14 @@
       ],
       "license": "MIT",
       "dependencies": {
-        "@noble/curves": "1.8.1",
-        "@noble/hashes": "1.7.1",
-        "@scure/bip32": "1.6.2",
-        "@scure/bip39": "1.5.4",
+        "@noble/curves": "1.9.1",
+        "@noble/hashes": "1.8.0",
+        "@scure/bip32": "1.7.0",
+        "@scure/bip39": "1.6.0",
         "abitype": "1.0.8",
-        "isows": "1.0.6",
-        "ox": "0.6.9",
-        "ws": "8.18.1"
+        "isows": "1.0.7",
+        "ox": "0.9.3",
+        "ws": "8.18.3"
       },
       "peerDependencies": {
         "typescript": ">=5.0.4"
@@ -8161,7 +8216,9 @@
       "license": "ISC"
     },
     "node_modules/ws": {
-      "version": "8.18.1",
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
       "license": "MIT",
       "engines": {
         "node": ">=10.0.0"
diff --git a/src/Managing.Web3Proxy/package.json b/src/Managing.Web3Proxy/package.json
index a9937103..97c6afe3 100644
--- a/src/Managing.Web3Proxy/package.json
+++ b/src/Managing.Web3Proxy/package.json
@@ -55,10 +55,11 @@
     "fastify-plugin": "^5.0.1",
     "form-data": "^4.0.1",
     "knex": "^3.1.0",
+    "lodash": "^4.17.21",
     "mysql2": "^3.11.3",
     "postgrator": "^8.0.0",
     "query-string": "^9.1.1",
-    "viem": "^2.23.15",
+    "viem": "2.37.1",
     "vitest": "^3.0.8",
     "zod": "^3.24.2"
   },
diff --git a/src/Managing.Web3Proxy/src/generated/ManagingApiTypes.ts b/src/Managing.Web3Proxy/src/generated/ManagingApiTypes.ts
index 15844df1..14e59cac 100644
--- a/src/Managing.Web3Proxy/src/generated/ManagingApiTypes.ts
+++ b/src/Managing.Web3Proxy/src/generated/ManagingApiTypes.ts
@@ -1,6 +1,6 @@
 //----------------------
 // <auto-generated>
-//     Generated using the NSwag toolchain v14.2.0.0 (NJsonSchema v11.1.0.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
+//     Generated using the NSwag toolchain v14.3.0.0 (NJsonSchema v11.2.0.0 (Newtonsoft.Json v13.0.0.0)) (http://NSwag.org)
 // </auto-generated>
 //----------------------
 
@@ -18,6 +18,8 @@ export interface Account {
     secret?: string | null;
     user?: User | null;
     balances?: Balance[] | null;
+    isGmxInitialized?: boolean;
+    isPrivyWallet?: boolean;
 }
 
 export enum TradingExchanges {
@@ -37,8 +39,12 @@ export enum AccountType {
 }
 
 export interface User {
+    id?: number;
     name?: string | null;
     accounts?: Account[] | null;
+    agentName?: string | null;
+    avatarUrl?: string | null;
+    telegramChannel?: string | null;
 }
 
 export interface Balance {
@@ -58,30 +64,43 @@ export interface Chain {
     chainId?: number;
 }
 
-export interface Backtest {
-    id: string;
-    finalPnl: number;
-    winRate: number;
-    growthPercentage: number;
-    hodlPercentage: number;
-    ticker: Ticker;
-    scenario: string;
-    positions: Position[];
-    signals: Signal[];
-    timeframe: Timeframe;
-    botType: BotType;
-    accountName: string;
-    candles: Candle[];
-    startDate: Date;
-    endDate: Date;
-    statistics: PerformanceMetrics;
-    fees: number;
-    walletBalances: KeyValuePairOfDateTimeAndDecimal[];
-    optimizedMoneyManagement: MoneyManagement;
-    moneyManagement: MoneyManagement;
-    user: User;
-    strategiesValues: { [key in keyof typeof StrategyType]?: StrategiesResultBase; };
-    score: number;
+export interface GmxClaimableSummary {
+    claimableFundingFees?: FundingFeesData | null;
+    claimableUiFees?: UiFeesData | null;
+    rebateStats?: RebateStatsData | null;
+}
+
+export interface FundingFeesData {
+    totalUsdc?: number;
+}
+
+export interface UiFeesData {
+    totalUsdc?: number;
+}
+
+export interface RebateStatsData {
+    totalRebateUsdc?: number;
+    discountUsdc?: number;
+    rebateFactor?: number;
+    discountFactor?: number;
+}
+
+export interface SwapInfos {
+    success?: boolean;
+    hash?: string | null;
+    message?: string | null;
+    error?: string | null;
+    errorType?: string | null;
+    suggestion?: string | null;
+}
+
+export interface SwapTokensRequest {
+    fromTicker: Ticker;
+    toTicker: Ticker;
+    amount: number;
+    orderType?: string | null;
+    triggerRatio?: number | null;
+    allowedSlippage?: number;
 }
 
 export enum Ticker {
@@ -144,41 +163,119 @@ export enum Ticker {
     SHIB = "SHIB",
     STX = "STX",
     ORDI = "ORDI",
+    APT = "APT",
+    BOME = "BOME",
+    MEME = "MEME",
+    FLOKI = "FLOKI",
+    MEW = "MEW",
+    TAO = "TAO",
+    BONK = "BONK",
+    WLD = "WLD",
+    TBTC = "tBTC",
+    WBTC_b = "WBTC_b",
+    EIGEN = "EIGEN",
+    SUI = "SUI",
+    SEI = "SEI",
+    USDC_e = "USDC_e",
+    DAI = "DAI",
+    TIA = "TIA",
+    TRX = "TRX",
+    TON = "TON",
+    PENDLE = "PENDLE",
+    WstETH = "wstETH",
+    USDe = "USDe",
+    SATS = "SATS",
+    POL = "POL",
+    XLM = "XLM",
+    BCH = "BCH",
+    ICP = "ICP",
+    RENDER = "RENDER",
+    INJ = "INJ",
+    TRUMP = "TRUMP",
+    MELANIA = "MELANIA",
+    ENA = "ENA",
+    FARTCOIN = "FARTCOIN",
+    AI16Z = "AI16Z",
+    ANIME = "ANIME",
+    BERA = "BERA",
+    VIRTUAL = "VIRTUAL",
+    PENGU = "PENGU",
+    ONDO = "ONDO",
+    FET = "FET",
+    AIXBT = "AIXBT",
+    CAKE = "CAKE",
+    S = "S",
+    JUP = "JUP",
+    HYPE = "HYPE",
+    OM = "OM",
+    DOLO = "DOLO",
     Unknown = "Unknown",
 }
 
-export interface Position {
-    accountName: string;
-    date: Date;
-    originDirection: TradeDirection;
+export interface SendTokenRequest {
+    recipientAddress: string;
     ticker: Ticker;
-    moneyManagement: MoneyManagement;
-    open: Trade;
-    stopLoss: Trade;
-    takeProfit1: Trade;
-    takeProfit2?: Trade | null;
-    profitAndLoss?: ProfitAndLoss | null;
-    status: PositionStatus;
-    signalIdentifier?: string | null;
-    identifier: string;
-    initiator: PositionInitiator;
-    user?: User | null;
+    amount: number;
+    chainId?: number | null;
 }
 
-export enum TradeDirection {
-    None = "None",
-    Short = "Short",
-    Long = "Long",
+export interface ExchangeApprovalStatus {
+    exchange?: TradingExchanges;
+    isApproved?: boolean;
 }
 
-export interface MoneyManagement {
+export interface Backtest {
+    id: string;
+    finalPnl: number;
+    winRate: number;
+    growthPercentage: number;
+    hodlPercentage: number;
+    config: TradingBotConfig;
+    positions: { [key: string]: Position; };
+    signals: { [key: string]: LightSignal; };
+    candles: Candle[];
+    startDate: Date;
+    endDate: Date;
+    statistics: PerformanceMetrics;
+    fees: number;
+    walletBalances: KeyValuePairOfDateTimeAndDecimal[];
+    user: User;
+    score: number;
+    requestId?: string;
+    metadata?: any | null;
+    scoreMessage?: string;
+}
+
+export interface TradingBotConfig {
+    accountName: string;
+    moneyManagement: LightMoneyManagement;
+    ticker: Ticker;
+    timeframe: Timeframe;
+    isForWatchingOnly: boolean;
+    botTradingBalance: number;
+    isForBacktest: boolean;
+    cooldownPeriod: number;
+    maxLossStreak: number;
+    flipPosition: boolean;
+    name: string;
+    riskManagement?: RiskManagement | null;
+    scenario?: LightScenario | null;
+    scenarioName?: string | null;
+    maxPositionTimeHours?: number | null;
+    closeEarlyWhenProfitable?: boolean;
+    flipOnlyWhenInProfit: boolean;
+    useSynthApi?: boolean;
+    useForPositionSizing?: boolean;
+    useForSignalFiltering?: boolean;
+    useForDynamicStopLoss?: boolean;
+}
+
+export interface LightMoneyManagement {
     name: string;
     timeframe: Timeframe;
-    balanceAtRisk: number;
     stopLoss: number;
     takeProfit: number;
     leverage: number;
-    user?: User | null;
 }
 
 export enum Timeframe {
@@ -188,10 +285,104 @@ export enum Timeframe {
     OneHour = "OneHour",
     FourHour = "FourHour",
     OneDay = "OneDay",
+    OneMinute = "OneMinute",
+}
+
+export interface RiskManagement {
+    adverseProbabilityThreshold: number;
+    favorableProbabilityThreshold: number;
+    riskAversion: number;
+    kellyMinimumThreshold: number;
+    kellyMaximumCap: number;
+    maxLiquidationProbability: number;
+    signalValidationTimeHorizonHours: number;
+    positionMonitoringTimeHorizonHours: number;
+    positionWarningThreshold: number;
+    positionAutoCloseThreshold: number;
+    kellyFractionalMultiplier: number;
+    riskTolerance: RiskToleranceLevel;
+    useExpectedUtility: boolean;
+    useKellyCriterion: boolean;
+}
+
+export enum RiskToleranceLevel {
+    Conservative = "Conservative",
+    Moderate = "Moderate",
+    Aggressive = "Aggressive",
+}
+
+export interface LightScenario {
+    name?: string | null;
+    indicators?: LightIndicator[] | null;
+    loopbackPeriod?: number | null;
+}
+
+export interface LightIndicator {
+    name?: string | null;
+    type?: IndicatorType;
+    signalType?: SignalType;
+    minimumHistory?: number;
+    period?: number | null;
+    fastPeriods?: number | null;
+    slowPeriods?: number | null;
+    signalPeriods?: number | null;
+    multiplier?: number | null;
+    smoothPeriods?: number | null;
+    stochPeriods?: number | null;
+    cyclePeriods?: number | null;
+}
+
+export enum IndicatorType {
+    RsiDivergence = "RsiDivergence",
+    RsiDivergenceConfirm = "RsiDivergenceConfirm",
+    MacdCross = "MacdCross",
+    EmaCross = "EmaCross",
+    ThreeWhiteSoldiers = "ThreeWhiteSoldiers",
+    SuperTrend = "SuperTrend",
+    ChandelierExit = "ChandelierExit",
+    EmaTrend = "EmaTrend",
+    Composite = "Composite",
+    StochRsiTrend = "StochRsiTrend",
+    Stc = "Stc",
+    StDev = "StDev",
+    LaggingStc = "LaggingStc",
+    SuperTrendCrossEma = "SuperTrendCrossEma",
+    DualEmaCross = "DualEmaCross",
+}
+
+export enum SignalType {
+    Signal = "Signal",
+    Trend = "Trend",
+    Context = "Context",
+}
+
+export interface Position {
+    accountName: string;
+    date: Date;
+    originDirection: TradeDirection;
+    ticker: Ticker;
+    moneyManagement: LightMoneyManagement;
+    Open: Trade;
+    StopLoss: Trade;
+    TakeProfit1: Trade;
+    TakeProfit2?: Trade | null;
+    ProfitAndLoss?: ProfitAndLoss | null;
+    status: PositionStatus;
+    signalIdentifier?: string | null;
+    identifier: string;
+    initiator: PositionInitiator;
+    user: User;
+    initiatorIdentifier: string;
+}
+
+export enum TradeDirection {
+    None = "None",
+    Short = "Short",
+    Long = "Long",
 }
 
 export interface Trade {
-    fee?: number;
+    fee: number;
     date: Date;
     direction: TradeDirection;
     status: TradeStatus;
@@ -199,9 +390,9 @@ export interface Trade {
     ticker: Ticker;
     quantity: number;
     price: number;
-    leverage?: number;
+    leverage: number;
     exchangeOrderId: string;
-    message?: string | null;
+    message: string;
 }
 
 export enum TradeStatus {
@@ -252,10 +443,7 @@ export enum PositionInitiator {
     CopyTrading = "CopyTrading",
 }
 
-export interface ValueObject {
-}
-
-export interface Signal extends ValueObject {
+export interface LightSignal {
     status: SignalStatus;
     direction: TradeDirection;
     confidence: Confidence;
@@ -265,9 +453,9 @@ export interface Signal extends ValueObject {
     identifier: string;
     ticker: Ticker;
     exchange: TradingExchanges;
-    strategyType: StrategyType;
+    indicatorType: IndicatorType;
     signalType: SignalType;
-    user?: User | null;
+    indicatorName: string;
 }
 
 export enum SignalStatus {
@@ -285,49 +473,15 @@ export enum Confidence {
 
 export interface Candle {
     exchange: TradingExchanges;
-    ticker: string;
+    ticker: Ticker;
     openTime: Date;
     date: Date;
     open: number;
     close: number;
-    volume?: number;
     high: number;
     low: number;
-    baseVolume?: number;
-    quoteVolume?: number;
-    tradeCount?: number;
-    takerBuyBaseVolume?: number;
-    takerBuyQuoteVolume?: number;
     timeframe: Timeframe;
-}
-
-export enum StrategyType {
-    RsiDivergence = "RsiDivergence",
-    RsiDivergenceConfirm = "RsiDivergenceConfirm",
-    MacdCross = "MacdCross",
-    EmaCross = "EmaCross",
-    ThreeWhiteSoldiers = "ThreeWhiteSoldiers",
-    SuperTrend = "SuperTrend",
-    ChandelierExit = "ChandelierExit",
-    EmaTrend = "EmaTrend",
-    Composite = "Composite",
-    StochRsiTrend = "StochRsiTrend",
-    Stc = "Stc",
-    StDev = "StDev",
-    LaggingStc = "LaggingStc",
-    SuperTrendCrossEma = "SuperTrendCrossEma",
-}
-
-export enum SignalType {
-    Signal = "Signal",
-    Trend = "Trend",
-    Context = "Context",
-}
-
-export enum BotType {
-    SimpleBot = "SimpleBot",
-    ScalpingBot = "ScalpingBot",
-    FlippingBot = "FlippingBot",
+    volume?: number;
 }
 
 export interface PerformanceMetrics {
@@ -346,8 +500,349 @@ export interface KeyValuePairOfDateTimeAndDecimal {
     value?: number;
 }
 
-export interface StrategiesResultBase {
+export interface DeleteBacktestsRequest {
+    backtestIds: string[];
+}
+
+export interface PaginatedBacktestsResponse {
+    backtests?: LightBacktestResponse[] | null;
+    totalCount?: number;
+    currentPage?: number;
+    pageSize?: number;
+    totalPages?: number;
+    hasNextPage?: boolean;
+    hasPreviousPage?: boolean;
+}
+
+export interface LightBacktestResponse {
+    id: string;
+    config: TradingBotConfig;
+    finalPnl: number;
+    winRate: number;
+    growthPercentage: number;
+    hodlPercentage: number;
+    startDate: Date;
+    endDate: Date;
+    maxDrawdown: number;
+    fees: number;
+    sharpeRatio: number;
+    score: number;
+    scoreMessage: string;
+}
+
+export interface LightBacktest {
+    id?: string | null;
+    config?: TradingBotConfig | null;
+    finalPnl?: number;
+    winRate?: number;
+    growthPercentage?: number;
+    hodlPercentage?: number;
+    startDate?: Date;
+    endDate?: Date;
+    maxDrawdown?: number | null;
+    fees?: number;
+    sharpeRatio?: number | null;
+    score?: number;
+    scoreMessage?: string | null;
+}
+
+export interface RunBacktestRequest {
+    config?: TradingBotConfigRequest | null;
+    startDate?: Date;
+    endDate?: Date;
+    save?: boolean;
+    withCandles?: boolean;
+}
+
+export interface TradingBotConfigRequest {
+    accountName: string;
+    ticker: Ticker;
+    timeframe: Timeframe;
+    isForWatchingOnly: boolean;
+    botTradingBalance: number;
+    name: string;
+    flipPosition: boolean;
+    cooldownPeriod?: number | null;
+    maxLossStreak?: number;
+    scenario?: ScenarioRequest | null;
+    scenarioName?: string | null;
+    moneyManagementName?: string | null;
+    moneyManagement?: MoneyManagementRequest | null;
+    maxPositionTimeHours?: number | null;
+    closeEarlyWhenProfitable?: boolean;
+    flipOnlyWhenInProfit?: boolean;
+    useSynthApi?: boolean;
+    useForPositionSizing?: boolean;
+    useForSignalFiltering?: boolean;
+    useForDynamicStopLoss?: boolean;
+}
+
+export interface ScenarioRequest {
+    name: string;
+    indicators: IndicatorRequest[];
+    loopbackPeriod?: number | null;
+}
+
+export interface IndicatorRequest {
+    name: string;
+    type: IndicatorType;
+    signalType: SignalType;
+    minimumHistory?: number;
+    period?: number | null;
+    fastPeriods?: number | null;
+    slowPeriods?: number | null;
+    signalPeriods?: number | null;
+    multiplier?: number | null;
+    smoothPeriods?: number | null;
+    stochPeriods?: number | null;
+    cyclePeriods?: number | null;
+}
+
+export interface MoneyManagementRequest {
+    name: string;
+    timeframe: Timeframe;
+    stopLoss: number;
+    takeProfit: number;
+    leverage: number;
+}
+
+export interface BundleBacktestRequest {
+    requestId: string;
+    user: User;
+    createdAt: Date;
+    completedAt?: Date | null;
+    status: BundleBacktestRequestStatus;
+    name: string;
+    backtestRequestsJson: string;
+    results?: string[] | null;
+    totalBacktests: number;
+    completedBacktests: number;
+    failedBacktests: number;
+    progressPercentage?: number;
+    errorMessage?: string | null;
+    progressInfo?: string | null;
+    currentBacktest?: string | null;
+    estimatedTimeRemainingSeconds?: number | null;
+}
+
+export enum BundleBacktestRequestStatus {
+    Pending = "Pending",
+    Running = "Running",
+    Completed = "Completed",
+    Failed = "Failed",
+    Cancelled = "Cancelled",
+}
+
+export interface RunBundleBacktestRequest {
+    name: string;
+    requests: RunBacktestRequest[];
+}
+
+export interface GeneticRequest {
+    requestId: string;
+    user: User;
+    createdAt: Date;
+    completedAt?: Date | null;
+    status: GeneticRequestStatus;
+    ticker: Ticker;
+    timeframe: Timeframe;
+    startDate: Date;
+    endDate: Date;
+    balance: number;
+    populationSize: number;
+    generations: number;
+    mutationRate: number;
+    selectionMethod: GeneticSelectionMethod;
+    crossoverMethod: GeneticCrossoverMethod;
+    mutationMethod: GeneticMutationMethod;
+    elitismPercentage: number;
+    maxTakeProfit: number;
+    eligibleIndicators: IndicatorType[];
+    results?: Backtest[] | null;
+    bestFitness?: number | null;
+    bestIndividual?: string | null;
+    errorMessage?: string | null;
+    progressInfo?: string | null;
+    bestChromosome?: string | null;
+    currentGeneration?: number;
+    bestFitnessSoFar?: number | null;
+}
+
+export enum GeneticRequestStatus {
+    Pending = "Pending",
+    Running = "Running",
+    Completed = "Completed",
+    Failed = "Failed",
+    Cancelled = "Cancelled",
+}
+
+export enum GeneticSelectionMethod {
+    Elite = "Elite",
+    Roulette = "Roulette",
+    StochasticUniversalSampling = "StochasticUniversalSampling",
+    Tournament = "Tournament",
+    Truncation = "Truncation",
+}
+
+export enum GeneticCrossoverMethod {
+    AlternatingPosition = "AlternatingPosition",
+    CutAndSplice = "CutAndSplice",
+    Cycle = "Cycle",
+    OnePoint = "OnePoint",
+    OrderBased = "OrderBased",
+    Ordered = "Ordered",
+    PartiallyMapped = "PartiallyMapped",
+    PositionBased = "PositionBased",
+    ThreeParent = "ThreeParent",
+    TwoPoint = "TwoPoint",
+    Uniform = "Uniform",
+    VotingRecombination = "VotingRecombination",
+}
+
+export enum GeneticMutationMethod {
+    Displacement = "Displacement",
+    FlipBit = "FlipBit",
+    Insertion = "Insertion",
+    PartialShuffle = "PartialShuffle",
+    ReverseSequence = "ReverseSequence",
+    Twors = "Twors",
+    Uniform = "Uniform",
+}
+
+export interface RunGeneticRequest {
+    ticker?: Ticker;
+    timeframe?: Timeframe;
+    startDate?: Date;
+    endDate?: Date;
+    balance?: number;
+    populationSize?: number;
+    generations?: number;
+    mutationRate?: number;
+    selectionMethod?: GeneticSelectionMethod;
+    crossoverMethod?: GeneticCrossoverMethod;
+    mutationMethod?: GeneticMutationMethod;
+    elitismPercentage?: number;
+    maxTakeProfit?: number;
+    eligibleIndicators?: IndicatorType[] | null;
+}
+
+export interface MoneyManagement extends LightMoneyManagement {
+    user?: User | null;
+}
+
+export interface StartBotRequest {
+    config?: TradingBotConfigRequest | null;
+}
+
+export interface SaveBotRequest extends StartBotRequest {
+}
+
+export enum BotStatus {
+    Saved = "Saved",
+    Stopped = "Stopped",
+    Running = "Running",
+}
+
+export interface TradingBotResponse {
+    status: string;
+    signals: { [key: string]: LightSignal; };
+    positions: { [key: string]: Position; };
+    candles: Candle[];
+    winRate: number;
+    profitAndLoss: number;
+    identifier: string;
+    agentName: string;
+    createDate: Date;
+    startupTime: Date;
+    name: string;
+    ticker: Ticker;
+}
+
+export interface PaginatedResponseOfTradingBotResponse {
+    items?: TradingBotResponse[] | null;
+    totalCount?: number;
+    pageNumber?: number;
+    pageSize?: number;
+    totalPages?: number;
+    hasPreviousPage?: boolean;
+    hasNextPage?: boolean;
+}
+
+export interface OpenPositionManuallyRequest {
+    identifier?: string;
+    direction?: TradeDirection;
+}
+
+export interface ClosePositionRequest {
+    identifier?: string;
+    positionId?: string;
+}
+
+export interface UpdateBotConfigRequest {
+    identifier: string;
+    config: TradingBotConfigRequest;
+    moneyManagementName?: string | null;
+    moneyManagement?: MoneyManagement | null;
+}
+
+export interface TickerInfos {
+    ticker?: Ticker;
+    imageUrl?: string | null;
+}
+
+export interface SpotlightOverview {
+    spotlights: Spotlight[];
+    dateTime: Date;
+    identifier?: string;
+    scenarioCount?: number;
+}
+
+export interface Spotlight {
+    scenario: Scenario;
+    tickerSignals: TickerSignal[];
+}
+
+export interface Scenario {
+    name?: string | null;
+    indicators?: IndicatorBase[] | null;
+    loopbackPeriod?: number | null;
+    user?: User | null;
+}
+
+export interface IndicatorBase {
+    name?: string | null;
+    type?: IndicatorType;
+    signalType?: SignalType;
+    minimumHistory?: number;
+    period?: number | null;
+    fastPeriods?: number | null;
+    slowPeriods?: number | null;
+    signalPeriods?: number | null;
+    multiplier?: number | null;
+    smoothPeriods?: number | null;
+    stochPeriods?: number | null;
+    cyclePeriods?: number | null;
+    user?: User | null;
+}
+
+export interface TickerSignal {
+    ticker: Ticker;
+    fiveMinutes: LightSignal[];
+    fifteenMinutes: LightSignal[];
+    oneHour: LightSignal[];
+    fourHour: LightSignal[];
+    oneDay: LightSignal[];
+}
+
+export interface CandlesWithIndicatorsResponse {
+    candles?: Candle[] | null;
+    indicatorsValues?: { [key in keyof typeof IndicatorType]?: IndicatorsResultBase; } | null;
+}
+
+export interface IndicatorsResultBase {
     ema?: EmaResult[] | null;
+    fastEma?: EmaResult[] | null;
+    slowEma?: EmaResult[] | null;
     macd?: MacdResult[] | null;
     rsi?: RsiResult[] | null;
     stoch?: StochResult[] | null;
@@ -434,58 +929,169 @@ export interface SuperTrendResult extends ResultBase {
     lowerBand?: number | null;
 }
 
-export interface StartBotRequest {
-    botType: BotType;
-    botName: string;
-    ticker: Ticker;
-    timeframe: Timeframe;
-    isForWatchOnly: boolean;
-    scenario: string;
-    accountName: string;
-    moneyManagementName: string;
+export interface GetCandlesWithIndicatorsRequest {
+    ticker?: Ticker;
+    startDate?: Date;
+    endDate?: Date;
+    timeframe?: Timeframe;
+    scenario?: ScenarioRequest | null;
 }
 
-export interface TradingBot {
-    name: string;
-    status: string;
-    signals: Signal[];
-    positions: Position[];
-    candles: Candle[];
-    winRate: number;
-    profitAndLoss: number;
-    timeframe: Timeframe;
-    ticker: Ticker;
-    scenario: string;
-    isForWatchingOnly: boolean;
-    botType: BotType;
-    accountName: string;
-    moneyManagement: MoneyManagement;
+export interface StrategiesStatisticsViewModel {
+    totalStrategiesRunning?: number;
+    changeInLast24Hours?: number;
 }
 
-export interface SpotlightOverview {
-    spotlights: Spotlight[];
-    dateTime: Date;
+export interface TopStrategiesViewModel {
+    topStrategies?: StrategyPerformance[] | null;
+}
+
+export interface StrategyPerformance {
+    strategyName?: string | null;
+    pnL?: number;
+    agentName?: string | null;
+}
+
+export interface TopStrategiesByRoiViewModel {
+    topStrategiesByRoi?: StrategyRoiPerformance[] | null;
+}
+
+export interface StrategyRoiPerformance {
+    strategyName?: string | null;
+    roi?: number;
+    pnL?: number;
+    volume?: number;
+}
+
+export interface TopAgentsByPnLViewModel {
+    topAgentsByPnL?: AgentPerformance[] | null;
+}
+
+export interface AgentPerformance {
+    agentName?: string | null;
+    pnL?: number;
+    totalROI?: number;
+    totalVolume?: number;
+    activeStrategiesCount?: number;
+    totalBalance?: number;
+}
+
+export interface UserStrategyDetailsViewModel {
+    name?: string | null;
+    state?: BotStatus;
+    pnL?: number;
+    roiPercentage?: number;
+    roiLast24H?: number;
+    runtime?: Date;
+    winRate?: number;
+    totalVolumeTraded?: number;
+    volumeLast24H?: number;
+    wins?: number;
+    losses?: number;
+    positions?: Position[] | null;
     identifier?: string;
-    scenarioCount?: number;
+    walletBalances?: { [key: string]: number; } | null;
+    ticker?: Ticker;
 }
 
-export interface Spotlight {
-    scenario: Scenario;
-    tickerSignals: TickerSignal[];
+export interface PlatformSummaryViewModel {
+    totalAgents?: number;
+    totalActiveStrategies?: number;
+    totalPlatformPnL?: number;
+    totalPlatformVolume?: number;
+    totalPlatformVolumeLast24h?: number;
+    totalOpenInterest?: number;
+    totalPositionCount?: number;
+    agentsChange24h?: number;
+    strategiesChange24h?: number;
+    pnLChange24h?: number;
+    volumeChange24h?: number;
+    openInterestChange24h?: number;
+    positionCountChange24h?: number;
+    volumeByAsset?: { [key in keyof typeof Ticker]?: number; } | null;
+    positionCountByAsset?: { [key in keyof typeof Ticker]?: number; } | null;
+    positionCountByDirection?: { [key in keyof typeof TradeDirection]?: number; } | null;
+    lastUpdated?: Date;
+    last24HourSnapshot?: Date;
+    volumeHistory?: VolumeHistoryPoint[] | null;
 }
 
-export interface Scenario {
-    name?: string | null;
-    strategies?: Strategy[] | null;
+export interface VolumeHistoryPoint {
+    date?: Date;
+    volume?: number;
+}
+
+export interface PaginatedAgentIndexResponse {
+    agentSummaries?: AgentSummaryViewModel[] | null;
+    totalCount?: number;
+    currentPage?: number;
+    pageSize?: number;
+    totalPages?: number;
+    hasNextPage?: boolean;
+    hasPreviousPage?: boolean;
+    timeFilter?: string | null;
+    sortBy?: SortableFields;
+    sortOrder?: string | null;
+    filteredAgentNames?: string | null;
+}
+
+export interface AgentSummaryViewModel {
+    agentName?: string | null;
+    totalPnL?: number;
+    totalROI?: number;
+    wins?: number;
+    losses?: number;
+    activeStrategiesCount?: number;
+    totalVolume?: number;
+    totalBalance?: number;
+}
+
+export enum SortableFields {
+    TotalPnL = "TotalPnL",
+    TotalROI = "TotalROI",
+    Wins = "Wins",
+    Losses = "Losses",
+    AgentName = "AgentName",
+    CreatedAt = "CreatedAt",
+    UpdatedAt = "UpdatedAt",
+    TotalVolume = "TotalVolume",
+    TotalBalance = "TotalBalance",
+}
+
+export interface AgentBalanceHistory {
+    agentName?: string | null;
+    agentBalances?: AgentBalance[] | null;
+}
+
+export interface AgentBalance {
+    agentName?: string | null;
+    totalValue?: number;
+    totalAccountUsdValue?: number;
+    botsAllocationUsdValue?: number;
+    pnL?: number;
+    time?: Date;
+}
+
+export interface BestAgentsResponse {
+    agents?: AgentBalanceHistory[] | null;
+    totalCount?: number;
+    currentPage?: number;
+    pageSize?: number;
+    totalPages?: number;
+}
+
+export interface ScenarioViewModel {
+    name: string;
+    indicators: IndicatorViewModel[];
     loopbackPeriod?: number | null;
-    user?: User | null;
+    userName: string;
 }
 
-export interface Strategy {
-    name?: string | null;
-    type?: StrategyType;
-    signalType?: SignalType;
-    minimumHistory?: number;
+export interface IndicatorViewModel {
+    name: string;
+    type: IndicatorType;
+    signalType: SignalType;
+    minimumHistory: number;
     period?: number | null;
     fastPeriods?: number | null;
     slowPeriods?: number | null;
@@ -494,16 +1100,7 @@ export interface Strategy {
     smoothPeriods?: number | null;
     stochPeriods?: number | null;
     cyclePeriods?: number | null;
-    user?: User | null;
-}
-
-export interface TickerSignal {
-    ticker: Ticker;
-    fiveMinutes: Signal[];
-    fifteenMinutes: Signal[];
-    oneHour: Signal[];
-    fourHour: Signal[];
-    oneDay: Signal[];
+    userName: string;
 }
 
 export enum RiskLevel {
@@ -513,6 +1110,16 @@ export enum RiskLevel {
     Adaptive = "Adaptive",
 }
 
+export interface PrivyInitAddressResponse {
+    success?: boolean;
+    usdcHash?: string | null;
+    orderVaultHash?: string | null;
+    exchangeRouterHash?: string | null;
+    error?: string | null;
+    address?: string | null;
+    isAlreadyInitialized?: boolean;
+}
+
 export interface LoginRequest {
     name: string;
     address: string;
@@ -520,68 +1127,6 @@ export interface LoginRequest {
     message: string;
 }
 
-export interface Workflow {
-    name: string;
-    usage: WorkflowUsage;
-    flows: IFlow[];
-    description: string;
-}
-
-export enum WorkflowUsage {
-    Trading = "Trading",
-    Task = "Task",
-}
-
-export interface IFlow {
-    id: string;
-    name: string;
-    type: FlowType;
-    description: string;
-    acceptedInputs: FlowOutput[];
-    children?: IFlow[] | null;
-    parameters: FlowParameter[];
-    parentId?: string;
-    output?: string | null;
-    outputTypes: FlowOutput[];
-}
-
-export enum FlowType {
-    RsiDivergence = "RsiDivergence",
-    FeedTicker = "FeedTicker",
-    OpenPosition = "OpenPosition",
-}
-
-export enum FlowOutput {
-    Signal = "Signal",
-    Candles = "Candles",
-    Position = "Position",
-    MoneyManagement = "MoneyManagement",
-}
-
-export interface FlowParameter {
-    value?: any | null;
-    name?: string | null;
-}
-
-export interface SyntheticWorkflow {
-    name: string;
-    usage: WorkflowUsage;
-    description: string;
-    flows: SyntheticFlow[];
-}
-
-export interface SyntheticFlow {
-    id: string;
-    parentId?: string | null;
-    type: FlowType;
-    parameters: SyntheticFlowParameter[];
-}
-
-export interface SyntheticFlowParameter {
-    value: string;
-    name: string;
-}
-
 export interface FileResponse {
     data: Blob;
     status: number;
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/abis/index.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/abis/index.ts
index 2ec984b9..00c238c9 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/abis/index.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/abis/index.ts
@@ -1,64 +1,64 @@
 import {Abi, erc20Abi} from "viem";
 
-import ArbitrumNodeInterface from "./ArbitrumNodeInterface.json";
-import ClaimHandler from "./ClaimHandler.json";
-import CustomErrors from "./CustomErrors.json";
-import DataStore from "./DataStore.json";
-import ERC20PermitInterface from "./ERC20PermitInterface.json";
-import ERC721 from "./ERC721.json";
-import EventEmitter from "./EventEmitter.json";
-import ExchangeRouter from "./ExchangeRouter.json";
-import GelatoRelayRouter from "./GelatoRelayRouter.json";
-import GlpManager from "./GlpManager.json";
-import GlvReader from "./GlvReader.json";
-import GlvRouter from "./GlvRouter.json";
-import GMT from "./GMT.json";
-import GmxMigrator from "./GmxMigrator.json";
-import GovToken from "./GovToken.json";
-import LayerZeroProvider from "./LayerZeroProvider.json";
-import MintableBaseToken from "./MintableBaseToken.json";
-import Multicall from "./Multicall.json";
-import MultichainClaimsRouter from "./MultichainClaimsRouter.json";
-import MultichainGlvRouter from "./MultichainGlvRouter.json";
-import MultichainGmRouter from "./MultichainGmRouter.json";
-import MultichainOrderRouter from "./MultichainOrderRouter.json";
-import MultichainSubaccountRouter from "./MultichainSubaccountRouter.json";
-import MultichainTransferRouter from "./MultichainTransferRouter.json";
-import MultichainUtils from "./MultichainUtils.json";
-import MultichainVault from "./MultichainVault.json";
-import OrderBook from "./OrderBook.json";
-import OrderBookReader from "./OrderBookReader.json";
-import OrderExecutor from "./OrderExecutor.json";
-import PositionManager from "./PositionManager.json";
-import PositionRouter from "./PositionRouter.json";
-import Reader from "./Reader.json";
-import ReaderV2 from "./ReaderV2.json";
-import ReferralStorage from "./ReferralStorage.json";
-import RelayParams from "./RelayParams.json";
-import RewardReader from "./RewardReader.json";
-import RewardRouter from "./RewardRouter.json";
-import RewardTracker from "./RewardTracker.json";
-import RouterV2 from "./Router-v2.json";
-import Router from "./Router.json";
-import SmartAccount from "./SmartAccount.json";
-import StBTC from "./StBTC.json";
-import SubaccountGelatoRelayRouter from "./SubaccountGelatoRelayRouter.json";
-import SubaccountRouter from "./SubaccountRouter.json";
-import SyntheticsReader from "./SyntheticsReader.json";
-import SyntheticsRouter from "./SyntheticsRouter.json";
-import Timelock from "./Timelock.json";
-import Token from "./Token.json";
-import Treasury from "./Treasury.json";
-import UniPool from "./UniPool.json";
-import UniswapV2 from "./UniswapV2.json";
-import Vault from "./Vault.json";
-import VaultReader from "./VaultReader.json";
-import VaultV2 from "./VaultV2.json";
-import VaultV2b from "./VaultV2b.json";
-import Vester from "./Vester.json";
-import WETH from "./WETH.json";
-import YieldFarm from "./YieldFarm.json";
-import YieldToken from "./YieldToken.json";
+import ArbitrumNodeInterface from "./ArbitrumNodeInterface.json" with {type: "json"};
+import ClaimHandler from "./ClaimHandler.json" with {type: "json"};
+import CustomErrors from "./CustomErrors.json" with {type: "json"};
+import DataStore from "./DataStore.json" with {type: "json"};
+import ERC20PermitInterface from "./ERC20PermitInterface.json" with {type: "json"};
+import ERC721 from "./ERC721.json" with {type: "json"};
+import EventEmitter from "./EventEmitter.json" with {type: "json"};
+import ExchangeRouter from "./ExchangeRouter.json" with {type: "json"};
+import GelatoRelayRouter from "./GelatoRelayRouter.json" with {type: "json"};
+import GlpManager from "./GlpManager.json" with {type: "json"};
+import GlvReader from "./GlvReader.json" with {type: "json"};
+import GlvRouter from "./GlvRouter.json" with {type: "json"};
+import GMT from "./GMT.json" with {type: "json"};
+import GmxMigrator from "./GmxMigrator.json" with {type: "json"};
+import GovToken from "./GovToken.json" with {type: "json"};
+import LayerZeroProvider from "./LayerZeroProvider.json" with {type: "json"};
+import MintableBaseToken from "./MintableBaseToken.json" with {type: "json"};
+import Multicall from "./Multicall.json" with {type: "json"};
+import MultichainClaimsRouter from "./MultichainClaimsRouter.json" with {type: "json"};
+import MultichainGlvRouter from "./MultichainGlvRouter.json" with {type: "json"};
+import MultichainGmRouter from "./MultichainGmRouter.json" with {type: "json"};
+import MultichainOrderRouter from "./MultichainOrderRouter.json" with {type: "json"};
+import MultichainSubaccountRouter from "./MultichainSubaccountRouter.json" with {type: "json"};
+import MultichainTransferRouter from "./MultichainTransferRouter.json" with {type: "json"};
+import MultichainUtils from "./MultichainUtils.json" with {type: "json"};
+import MultichainVault from "./MultichainVault.json" with {type: "json"};
+import OrderBook from "./OrderBook.json" with {type: "json"};
+import OrderBookReader from "./OrderBookReader.json" with {type: "json"};
+import OrderExecutor from "./OrderExecutor.json" with {type: "json"};
+import PositionManager from "./PositionManager.json" with {type: "json"};
+import PositionRouter from "./PositionRouter.json" with {type: "json"};
+import Reader from "./Reader.json" with {type: "json"};
+import ReaderV2 from "./ReaderV2.json" with {type: "json"};
+import ReferralStorage from "./ReferralStorage.json" with {type: "json"};
+import RelayParams from "./RelayParams.json" with {type: "json"};
+import RewardReader from "./RewardReader.json" with {type: "json"};
+import RewardRouter from "./RewardRouter.json" with {type: "json"};
+import RewardTracker from "./RewardTracker.json" with {type: "json"};
+import RouterV2 from "./Router-v2.json" with {type: "json"};
+import Router from "./Router.json" with {type: "json"};
+import SmartAccount from "./SmartAccount.json" with {type: "json"};
+import StBTC from "./StBTC.json" with {type: "json"};
+import SubaccountGelatoRelayRouter from "./SubaccountGelatoRelayRouter.json" with {type: "json"};
+import SubaccountRouter from "./SubaccountRouter.json" with {type: "json"};
+import SyntheticsReader from "./SyntheticsReader.json" with {type: "json"};
+import SyntheticsRouter from "./SyntheticsRouter.json" with {type: "json"};
+import Timelock from "./Timelock.json" with {type: "json"};
+import Token from "./Token.json" with {type: "json"};
+import Treasury from "./Treasury.json" with {type: "json"};
+import UniPool from "./UniPool.json" with {type: "json"};
+import UniswapV2 from "./UniswapV2.json" with {type: "json"};
+import Vault from "./Vault.json" with {type: "json"};
+import VaultReader from "./VaultReader.json" with {type: "json"};
+import VaultV2 from "./VaultV2.json" with {type: "json"};
+import VaultV2b from "./VaultV2b.json" with {type: "json"};
+import Vester from "./Vester.json" with {type: "json"};
+import WETH from "./WETH.json" with {type: "json"};
+import YieldFarm from "./YieldFarm.json" with {type: "json"};
+import YieldToken from "./YieldToken.json" with {type: "json"};
 
 export type AbiId =
   | "AbstractSubaccountApprovalNonceable"
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/batch.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/batch.ts
index 8aac5fe3..9395de7b 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/batch.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/batch.ts
@@ -10,8 +10,8 @@ export const BATCH_CONFIGS: Record<
 > = {
   [ARBITRUM]: {
     http: {
-      batchSize: 0, // disable batches, here batchSize is the number of eth_calls in a batch
-      wait: 0, // keep this setting in case batches are enabled in future
+      batchSize: 10, // Enable batching with up to 10 eth_calls per batch
+      wait: 16, // 16ms wait time to allow batching
     },
     client: {
       multicall: {
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/chains.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/chains.ts
index a44e1a29..edf98d86 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/chains.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/chains.ts
@@ -1,32 +1,77 @@
-import {arbitrum, avalanche, avalancheFuji, Chain} from "viem/chains";
+import {arbitrum, arbitrumSepolia, avalanche, avalancheFuji, base, Chain, optimismSepolia, sepolia} from "viem/chains";
+import {defineChain} from "viem/utils";
+import {GasLimitsConfig} from "../types/fees";
 
-export const AVALANCHE = 43114;
-export const AVALANCHE_FUJI = 43113;
-export const ARBITRUM = 42161;
-export const BSС_MAINNET = 56;
-export const BSС_TESTNET = 97;
 export const ETH_MAINNET = 1;
+// Production
+export const AVALANCHE = 43114;
+export const ARBITRUM = 42161;
+export const BOTANIX = 3637;
+export const BASE = 8453;
+// Production source
+export const SOURCE_BASE_MAINNET = 8453;
+// Testnets
+export const AVALANCHE_FUJI = 43113;
+export const ARBITRUM_SEPOLIA = 421614;
+// Testnet source
+export const SOURCE_OPTIMISM_SEPOLIA = 11155420;
+export const SOURCE_SEPOLIA = 11155111;
 
-export const SUPPORTED_CHAIN_IDS = [ARBITRUM, AVALANCHE];
-export const SUPPORTED_CHAIN_IDS_DEV = [...SUPPORTED_CHAIN_IDS, AVALANCHE_FUJI];
+export const CONTRACTS_CHAIN_IDS: ContractsChainId[] = [ARBITRUM, AVALANCHE, BOTANIX];
+export const CONTRACTS_CHAIN_IDS_DEV: ContractsChainId[] = [...CONTRACTS_CHAIN_IDS, AVALANCHE_FUJI, ARBITRUM_SEPOLIA];
 
-export const HIGH_EXECUTION_FEES_MAP = {
+export type ContractsChainId =
+  | typeof ARBITRUM
+  | typeof AVALANCHE
+  | typeof AVALANCHE_FUJI
+  | typeof BOTANIX
+  | typeof ARBITRUM_SEPOLIA;
+
+export type SettlementChainId = typeof ARBITRUM_SEPOLIA | typeof ARBITRUM | typeof AVALANCHE;
+export type SourceChainId = typeof SOURCE_OPTIMISM_SEPOLIA | typeof SOURCE_SEPOLIA | typeof SOURCE_BASE_MAINNET;
+export type AnyChainId = ContractsChainId | SettlementChainId | SourceChainId;
+
+export type ChainName =
+  | "Arbitrum"
+  | "Avalanche"
+  | "Avalanche Fuji"
+  | "Arbitrum Sepolia"
+  | "Optimism Sepolia"
+  | "Sepolia"
+  | "Botanix"
+  | "Base";
+
+export const CHAIN_NAMES_MAP: Record<AnyChainId, ChainName> = {
+  [ARBITRUM]: "Arbitrum",
+  [AVALANCHE]: "Avalanche",
+  [AVALANCHE_FUJI]: "Avalanche Fuji",
+  [BOTANIX]: "Botanix",
+  [ARBITRUM_SEPOLIA]: "Arbitrum Sepolia",
+  [SOURCE_OPTIMISM_SEPOLIA]: "Optimism Sepolia",
+  [SOURCE_SEPOLIA]: "Sepolia",
+  [SOURCE_BASE_MAINNET]: "Base",
+};
+
+export const HIGH_EXECUTION_FEES_MAP: Record<ContractsChainId, number> = {
   [ARBITRUM]: 5, // 5 USD
   [AVALANCHE]: 5, // 5 USD
   [AVALANCHE_FUJI]: 5, // 5 USD
+  [BOTANIX]: 5, // 5 USD
+  [ARBITRUM_SEPOLIA]: 5, // 5 USD
 };
 
 // added to maxPriorityFeePerGas
 // applied to EIP-1559 transactions only
 // is not applied to execution fee calculation
-export const MAX_FEE_PER_GAS_MAP = {
+export const MAX_FEE_PER_GAS_MAP: Record<number, bigint> = {
   [AVALANCHE]: 200000000000n, // 200 gwei
+  [BOTANIX]: 20n,
 };
 
 // added to maxPriorityFeePerGas
 // applied to EIP-1559 transactions only
 // is also applied to the execution fee calculation
-export const GAS_PRICE_PREMIUM_MAP = {
+export const GAS_PRICE_PREMIUM_MAP: Record<number, bigint> = {
   [ARBITRUM]: 0n,
   [AVALANCHE]: 6000000000n, // 6 gwei
 };
@@ -34,16 +79,28 @@ export const GAS_PRICE_PREMIUM_MAP = {
 /*
   that was a constant value in ethers v5, after ethers v6 migration we use it as a minimum for maxPriorityFeePerGas
 */
-export const MAX_PRIORITY_FEE_PER_GAS_MAP: Record<number, bigint | undefined> = {
+export const MAX_PRIORITY_FEE_PER_GAS_MAP: Record<ContractsChainId, bigint | undefined> = {
   [ARBITRUM]: 1500000000n,
   [AVALANCHE]: 1500000000n,
   [AVALANCHE_FUJI]: 1500000000n,
+  [ARBITRUM_SEPOLIA]: 1500000000n,
+  [BOTANIX]: 7n,
 };
 
-export const EXCESSIVE_EXECUTION_FEES_MAP = {
+export const EXCESSIVE_EXECUTION_FEES_MAP: Partial<Record<ContractsChainId, number>> = {
   [ARBITRUM]: 10, // 10 USD
   [AVALANCHE]: 10, // 10 USD
   [AVALANCHE_FUJI]: 10, // 10 USD
+  [BOTANIX]: 10, // 10 USD
+};
+
+// avoid botanix gas spikes when chain is not actively used
+// if set, execution fee value should not be less than this in USD equivalent
+export const MIN_EXECUTION_FEE_USD: Partial<Record<ContractsChainId, bigint | undefined>> = {
+  [ARBITRUM]: undefined,
+  [AVALANCHE]: undefined,
+  [AVALANCHE_FUJI]: undefined,
+  [BOTANIX]: 1000000000000000000000000000n, // 1e27 $0.001
 };
 
 // added to gasPrice
@@ -63,34 +120,74 @@ export const EXCESSIVE_EXECUTION_FEES_MAP = {
 //
 // this buffer could also cause issues on a blockchain that uses passed gas price
 // especially if execution fee buffer and lower than gas price buffer defined bellow
-export const GAS_PRICE_BUFFER_MAP = {
+export const GAS_PRICE_BUFFER_MAP: Record<number, bigint> = {
   [ARBITRUM]: 2000n, // 20%
 };
 
-const CHAIN_BY_CHAIN_ID = {
+export const botanix: Chain = defineChain({
+  id: BOTANIX,
+  name: "Botanix",
+  nativeCurrency: {
+    name: "Bitcoin",
+    symbol: "BTC",
+    decimals: 18,
+  },
+  rpcUrls: {
+    default: {
+      http: [
+        // this rpc returns incorrect gas price
+        // "https://rpc.botanixlabs.com",
+
+        "https://rpc.ankr.com/botanix_mainnet",
+      ],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: "BotanixScan",
+      url: "https://botanixscan.io",
+    },
+  },
+  contracts: {
+    multicall3: {
+      address: "0x4BaA24f93a657f0c1b4A0Ffc72B91011E35cA46b",
+    },
+  },
+});
+
+const VIEM_CHAIN_BY_CHAIN_ID: Record<AnyChainId, Chain> = {
   [AVALANCHE_FUJI]: avalancheFuji,
   [ARBITRUM]: arbitrum,
   [AVALANCHE]: avalanche,
+  [ARBITRUM_SEPOLIA]: arbitrumSepolia,
+  [BOTANIX]: botanix,
+  [SOURCE_OPTIMISM_SEPOLIA]: optimismSepolia,
+  [SOURCE_SEPOLIA]: sepolia,
+  [SOURCE_BASE_MAINNET]: base,
 };
 
-export const getChain = (chainId: number): Chain => {
-  return CHAIN_BY_CHAIN_ID[chainId];
+export function getChainName(chainId: number): ChainName {
+  return CHAIN_NAMES_MAP[chainId];
+}
+
+export const getViemChain = (chainId: number): Chain => {
+  return VIEM_CHAIN_BY_CHAIN_ID[chainId];
 };
 
-export function getHighExecutionFee(chainId) {
+export function getHighExecutionFee(chainId: number) {
   return HIGH_EXECUTION_FEES_MAP[chainId] ?? 5;
 }
 
-export function getExcessiveExecutionFee(chainId) {
+export function getExcessiveExecutionFee(chainId: number) {
   return EXCESSIVE_EXECUTION_FEES_MAP[chainId] ?? 10;
 }
 
-export function isSupportedChain(chainId: number, dev = false) {
-  return (dev ? SUPPORTED_CHAIN_IDS_DEV : SUPPORTED_CHAIN_IDS).includes(chainId);
+export function isContractsChain(chainId: number, dev = false): chainId is ContractsChainId {
+  return (dev ? CONTRACTS_CHAIN_IDS_DEV : CONTRACTS_CHAIN_IDS).includes(chainId as ContractsChainId);
 }
 
 export const EXECUTION_FEE_CONFIG_V2: {
-  [chainId: number]: {
+  [chainId in ContractsChainId]: {
     shouldUseMaxPriorityFeePerGas: boolean;
     defaultBufferBps?: number;
   };
@@ -107,4 +204,59 @@ export const EXECUTION_FEE_CONFIG_V2: {
     shouldUseMaxPriorityFeePerGas: false,
     defaultBufferBps: 3000, // 30%
   },
+  [ARBITRUM_SEPOLIA]: {
+    shouldUseMaxPriorityFeePerGas: false,
+    defaultBufferBps: 1000, // 10%
+  },
+  [BOTANIX]: {
+    shouldUseMaxPriorityFeePerGas: true,
+    defaultBufferBps: 3000, // 30%
+  },
+};
+
+type StaticGasLimitsConfig = Pick<
+  GasLimitsConfig,
+  | "createOrderGasLimit"
+  | "updateOrderGasLimit"
+  | "cancelOrderGasLimit"
+  | "tokenPermitGasLimit"
+  | "gmxAccountCollateralGasLimit"
+>;
+
+export const GAS_LIMITS_STATIC_CONFIG: Record<ContractsChainId, StaticGasLimitsConfig> = {
+  [ARBITRUM]: {
+    createOrderGasLimit: 1_000_000n,
+    updateOrderGasLimit: 800_000n,
+    cancelOrderGasLimit: 700_000n,
+    tokenPermitGasLimit: 90_000n,
+    gmxAccountCollateralGasLimit: 0n,
+  },
+  [AVALANCHE]: {
+    createOrderGasLimit: 1_000_000n,
+    updateOrderGasLimit: 800_000n,
+    cancelOrderGasLimit: 700_000n,
+    tokenPermitGasLimit: 90_000n,
+    gmxAccountCollateralGasLimit: 0n,
+  },
+  [AVALANCHE_FUJI]: {
+    createOrderGasLimit: 1_000_000n,
+    updateOrderGasLimit: 800_000n,
+    cancelOrderGasLimit: 700_000n,
+    tokenPermitGasLimit: 90_000n,
+    gmxAccountCollateralGasLimit: 0n,
+  },
+  [ARBITRUM_SEPOLIA]: {
+    createOrderGasLimit: 1_000_000n,
+    updateOrderGasLimit: 800_000n,
+    cancelOrderGasLimit: 1_500_000n,
+    tokenPermitGasLimit: 90_000n,
+    gmxAccountCollateralGasLimit: 400_000n,
+  },
+  [BOTANIX]: {
+    createOrderGasLimit: 1_000_000n,
+    updateOrderGasLimit: 800_000n,
+    cancelOrderGasLimit: 700_000n,
+    tokenPermitGasLimit: 90_000n,
+    gmxAccountCollateralGasLimit: 0n,
+  },
 };
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/contracts.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/contracts.ts
index 305c86ba..385f3915 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/contracts.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/contracts.ts
@@ -1,10 +1,10 @@
 import {type Address, zeroAddress} from "viem";
-import {ARBITRUM, AVALANCHE, AVALANCHE_FUJI} from "./chains.js";
+import {ARBITRUM, ARBITRUM_SEPOLIA, AVALANCHE, AVALANCHE_FUJI, BOTANIX, ContractsChainId} from "./chains.js";
 
 
 export const CONTRACTS = {
   [ARBITRUM]: {
-    // arbitrum mainnet
+    // V1
     Vault: "0x489ee077994B6658eAfA855C308275EAd8097C4A",
     Router: "0xaBBc5F99639c9B6bCb58544ddf04EFA6802F4064",
     VaultReader: "0xfebB9f4CAC4cD523598fE1C5771181440143F24A",
@@ -59,18 +59,35 @@ export const CONTRACTS = {
     SyntheticsReader: "0x65A6CC451BAfF7e7B4FDAb4157763aB4b6b44D0E",
     SyntheticsRouter: "0x7452c558d45f8afC8c83dAe62C3f8A5BE19c71f6",
 
-    GlvReader: "0x6a9505D0B44cFA863d9281EA5B0b34cB36243b45",
-    GlvRouter: "0x994c598e3b0661bb805d53c6fa6b4504b23b68dd",
+    GlvReader: "0xb51e34dc3A7c80E4ABbC3800aD0e487b7b878339",
+    GlvRouter: "0x10Fa5Bd343373101654E896B43Ca38Fd8f3789F9",
     GlvVault: "0x393053B58f9678C9c28c2cE941fF6cac49C3F8f9",
 
+    GelatoRelayRouter: "0x0C08518C41755C6907135266dCCf09d51aE53CC4",
+    SubaccountGelatoRelayRouter: "0xA1D94802EcD642051B677dBF37c8E78ce6dd3784",
+
+    MultichainClaimsRouter: "0x2A7244EE5373D2F161cE99F0D144c12860D651Af",
+    MultichainGlvRouter: "0xFdaFa6fbd4B480017FD37205Cb3A24AE93823956",
+    MultichainGmRouter: "0xF53e30CE07f148fdE6e531Be7dC0b6ad670E8C6e",
+    MultichainOrderRouter: "0x3c796504d47013Ea0552CCa57373B59DF03D34a0",
+    MultichainSubaccountRouter: "0x99CD306B777C5aAb842bA65e4f7FF0554ECDe808",
+    MultichainTransferRouter: "0xC1D1354A948bf717d6d873e5c0bE614359AF954D",
+    MultichainVault: "0xCeaadFAf6A8C489B250e407987877c5fDfcDBE6E",
+    LayerZeroProvider: "0x7129Ea01F0826c705d6F7ab01Cf3C06bb83E9397",
+
+    ChainlinkPriceFeedProvider: "0x38B8dB61b724b51e42A88Cb8eC564CD685a0f53B",
+    ClaimHandler: "0x28f1F4AA95F49FAB62464536A269437B13d48976",
+
+    // External
     ExternalHandler: "0x389CEf541397e872dC04421f166B5Bc2E0b374a5",
-
     OpenOceanRouter: "0x6352a56caadC4F1E25CD6c75970Fa768A3304e64",
-
-    Multicall: "0x842ec2c7d803033edf55e478f461fc547bc54eb2",
+    Multicall: "0xe79118d6D92a4b23369ba356C90b9A7ABf1CB961",
+    ArbitrumNodeInterface: "0x00000000000000000000000000000000000000C8",
+    LayerZeroEndpoint: "0x1a44076050125825900e736c501f859c50fE728c",
+    GelatoRelayAddress: "0xaBcC9b596420A9E9172FD5938620E265a0f9Df92",
   },
   [AVALANCHE]: {
-    // avalanche
+    // V1
     Vault: "0x9ab2De34A33fB459b538c43f251eB825645e8595",
     Router: "0x5F719c2F1095F7B9fc68a68e35B51194f4b6abe8",
     VaultReader: "0x66eC8fc33A26feAEAe156afA3Cb46923651F6f0D",
@@ -117,27 +134,126 @@ export const CONTRACTS = {
     // Synthetics
     DataStore: "0x2F0b22339414ADeD7D5F06f9D604c7fF5b2fe3f6",
     EventEmitter: "0xDb17B211c34240B014ab6d61d4A31FA0C0e20c26",
-    SubaccountRouter: "0x5aEb6AD978f59e220aA9099e09574e1c5E03AafD",
-    ExchangeRouter: "0xe37d052e1deb99901de205e7186e31a36e4ef70c",
+    SubaccountRouter: "0x88a5c6D94634Abd7745f5348e5D8C42868ed4AC3",
+    ExchangeRouter: "0xF0864BE1C39C0AB28a8f1918BC8321beF8F7C317",
     DepositVault: "0x90c670825d0C62ede1c5ee9571d6d9a17A722DFF",
     WithdrawalVault: "0xf5F30B10141E1F63FC11eD772931A8294a591996",
     OrderVault: "0xD3D60D22d415aD43b7e64b510D86A30f19B1B12C",
     ShiftVault: "0x7fC46CCb386e9bbBFB49A2639002734C3Ec52b39",
-    SyntheticsReader: "0x618fCEe30D9A26e8533C3B244CAd2D6486AFf655",
+    SyntheticsReader: "0x1EC018d2b6ACCA20a0bEDb86450b7E27D1D8355B",
     SyntheticsRouter: "0x820F5FfC5b525cD4d88Cd91aCf2c28F16530Cc68",
 
-    GlvReader: "0xae9596a1C438675AcC75f69d32E21Ac9c8fF99bD",
-    GlvRouter: "0x16500c1d8ffe2f695d8dcadf753f664993287ae4",
+    GlvReader: "0x12Ac77003B3D11b0853d1FD12E5AF22a9060eC4b",
+    GlvRouter: "0x4729D9f61c0159F5e02D2C2e5937B3225e55442C",
     GlvVault: "0x527FB0bCfF63C47761039bB386cFE181A92a4701",
 
-    OpenOceanRouter: "0x6352a56caadC4F1E25CD6c75970Fa768A3304e64",
+    GelatoRelayRouter: "0xa61f92ab63cc5C3d60574d40A6e73861c37aaC95",
+    SubaccountGelatoRelayRouter: "0x58b09FD12863218F2ca156808C2Ae48aaCD0c072",
 
+    MultichainClaimsRouter: "0x9080f8A35Da53F4200a68533FB1dC1cA05357bDB",
+    MultichainGlvRouter: "0x2A7244EE5373D2F161cE99F0D144c12860D651Af",
+    MultichainGmRouter: "0x10Fa5Bd343373101654E896B43Ca38Fd8f3789F9",
+    MultichainOrderRouter: "0x99CD306B777C5aAb842bA65e4f7FF0554ECDe808",
+    MultichainSubaccountRouter: "0xB36a4c6cDeDea3f31b3d16F33553F93b96b178F4",
+    MultichainTransferRouter: "0x8c6e20A2211D1b70cD7c0789EcE44fDB19567621",
+    MultichainVault: "0x6D5F3c723002847B009D07Fe8e17d6958F153E4e",
+    LayerZeroProvider: "0xA1D94802EcD642051B677dBF37c8E78ce6dd3784",
+
+    ChainlinkPriceFeedProvider: "0x05d97cee050bfb81FB3EaD4A9368584F8e72C88e",
+    ClaimHandler: "0x7FfedCAC2eCb2C29dDc027B60D6F8107295Ff2eA",
+
+    // External
     ExternalHandler: "0xD149573a098223a9185433290a5A5CDbFa54a8A9",
+    OpenOceanRouter: "0x6352a56caadC4F1E25CD6c75970Fa768A3304e64",
+    Multicall: "0x50474CAe810B316c294111807F94F9f48527e7F8",
+    ArbitrumNodeInterface: zeroAddress,
+    LayerZeroEndpoint: "0x1a44076050125825900e736c501f859c50fE728c",
+    GelatoRelayAddress: "0xaBcC9b596420A9E9172FD5938620E265a0f9Df92",
+  },
+  [BOTANIX]: {
+    // Synthetics
+    DataStore: "0xA23B81a89Ab9D7D89fF8fc1b5d8508fB75Cc094d",
+    EventEmitter: "0xAf2E131d483cedE068e21a9228aD91E623a989C2",
+    SubaccountRouter: "0x11E590f6092D557bF71BaDEd50D81521674F8275",
+    ExchangeRouter: "0x72fa3978E2E330C7B2debc23CB676A3ae63333F6",
+    DepositVault: "0x4D12C3D3e750e051e87a2F3f7750fBd94767742c",
+    WithdrawalVault: "0x46BAeAEdbF90Ce46310173A04942e2B3B781Bf0e",
+    OrderVault: "0xe52B3700D17B45dE9de7205DEe4685B4B9EC612D",
+    ShiftVault: "0xa7EE2737249e0099906cB079BCEe85f0bbd837d4",
 
-    Multicall: "0xcA11bde05977b3631167028862bE2a173976CA11",
+    SyntheticsReader: "0xa254B60cbB85a92F6151B10E1233639F601f2F0F",
+    SyntheticsRouter: "0x3d472afcd66F954Fe4909EEcDd5c940e9a99290c",
+
+    GlvReader: "0x490d660A21fB75701b7781E191cB888D1FE38315",
+    GlvRouter: "0x348Eca94e7c6F35430aF1cAccE27C29E9Bef9ae3",
+    GlvVault: "0xd336087512BeF8Df32AF605b492f452Fd6436CD8",
+
+    GelatoRelayRouter: "0x7f8eF83C92B48a4B5B954A24D98a6cD0Ed4D160a",
+    SubaccountGelatoRelayRouter: "0xfbb9C41046E27405224a911f44602C3667f9D8f6",
+
+    MultichainClaimsRouter: "0x790Ee987b9B253374d700b07F16347a7d4C4ff2e",
+    MultichainGlvRouter: "0xEE027373517a6D96Fe62f70E9A0A395cB5a39Eee",
+    MultichainGmRouter: "0x4ef8394CD5DD7E3EE6D30824689eF461783a3360",
+    MultichainOrderRouter: "0x5c5DBbcDf420B5d81d4FfDBa5b26Eb24E6E60d52",
+    MultichainSubaccountRouter: "0xd3B6E962f135634C43415d57A28E688Fb4f15A58",
+    MultichainTransferRouter: "0x901f26a57edCe65Ef3FBcCD260433De9B2279852",
+    MultichainVault: "0x9a535f9343434D96c4a39fF1d90cC685A4F6Fb20",
+    LayerZeroProvider: "0x61af99b07995cb7Ee8c2FACF6D8fb6042FeAA0d9",
+
+    ChainlinkPriceFeedProvider: "0xDc613305e9267f0770072dEaB8c03162e0554b2d",
+    ClaimHandler: "0x3ca0f3ad78a9d0b2a0c060fe86d1141118a285c4",
+
+    // External
+    ExternalHandler: "0x36b906eA6AE7c74aeEE8cDE66D01B3f1f8843872",
+    OpenOceanRouter: zeroAddress,
+    Multicall: "0x4BaA24f93a657f0c1b4A0Ffc72B91011E35cA46b",
+    LayerZeroEndpoint: "0x6F475642a6e85809B1c36Fa62763669b1b48DD5B",
+    ArbitrumNodeInterface: zeroAddress,
+    GelatoRelayAddress: "0x61aCe8fBA7B80AEf8ED67f37CB60bE00180872aD",
+
+    Vault: zeroAddress,
+    Reader: zeroAddress,
+    PositionRouter: zeroAddress,
+    ReferralStorage: zeroAddress,
+    ReferralReader: zeroAddress,
+    VaultReader: zeroAddress,
+    GlpManager: zeroAddress,
+    RewardRouter: zeroAddress,
+    RewardReader: zeroAddress,
+    GlpRewardRouter: zeroAddress,
+    StakedGmxTracker: zeroAddress,
+    FeeGmxTracker: zeroAddress,
+    GLP: zeroAddress,
+    GMX: zeroAddress,
+    ES_GMX: zeroAddress,
+    BN_GMX: zeroAddress,
+    USDG: zeroAddress,
+    BonusGmxTracker: zeroAddress,
+    StakedGlpTracker: zeroAddress,
+    FeeGlpTracker: zeroAddress,
+    ExtendedGmxTracker: zeroAddress,
+    StakedGmxDistributor: zeroAddress,
+    StakedGlpDistributor: zeroAddress,
+    GmxVester: zeroAddress,
+    GlpVester: zeroAddress,
+    AffiliateVester: zeroAddress,
+    Router: zeroAddress,
+    GovToken: zeroAddress,
+    ES_GMX_IOU: zeroAddress,
+    OrderBook: zeroAddress,
+    OrderExecutor: zeroAddress,
+    OrderBookReader: zeroAddress,
+    PositionManager: zeroAddress,
+    UniswapGmxEthPool: zeroAddress,
+
+    // botanix specific
+    NATIVE_TOKEN: "0x0D2437F93Fed6EA64Ef01cCde385FB1263910C56",
+    StBTC: "0xF4586028FFdA7Eca636864F80f8a3f2589E33795",
+    PBTC: "0x0D2437F93Fed6EA64Ef01cCde385FB1263910C56",
   },
 
   [AVALANCHE_FUJI]: {
+    // V1
     Vault: zeroAddress,
     Router: zeroAddress,
     VaultReader: zeroAddress,
@@ -176,35 +292,128 @@ export const CONTRACTS = {
     PositionManager: zeroAddress,
 
     TraderJoeGmxAvaxPool: zeroAddress,
-    ReferralStorage: "0x58726dB901C9DF3654F45a37DD307a0C44b6420e",
+    ReferralStorage: "0x192e82A18a4ab446dD9968f055431b60640B155D",
     ReferralReader: zeroAddress,
 
     // Synthetics
     DataStore: "0xEA1BFb4Ea9A412dCCd63454AbC127431eBB0F0d4",
     EventEmitter: "0xc67D98AC5803aFD776958622CeEE332A0B2CabB9",
-    ExchangeRouter: "0x52A1c10c462ca4e5219d0Eb4da5052cc73F9050D",
-    SubaccountRouter: "0x0595f01860aa5c4C6091EED096515b4b9FE372CE",
+    ExchangeRouter: "0x0a458C96Ac0B2a130DA4BdF1aAdD4cb7Be036d11",
+    SubaccountRouter: "0xD5EE3ECAF5754CE5Ff74847d0caf094EBB12ed5e",
     DepositVault: "0x2964d242233036C8BDC1ADC795bB4DeA6fb929f2",
     WithdrawalVault: "0x74d49B6A630Bf519bDb6E4efc4354C420418A6A2",
     OrderVault: "0x25D23e8E655727F2687CC808BB9589525A6F599B",
     ShiftVault: "0x257D0EA0B040E2Cd1D456fB4C66d7814102aD346",
-    SyntheticsReader: "0x16Fb5b8846fbfAe09c034fCdF3D3F9492484DA80",
+    SyntheticsReader: "0xf82Cc6EB57F8FF86bc5c5e90B8BA83DbBFB517eE",
     SyntheticsRouter: "0x5e7d61e4C52123ADF651961e4833aCc349b61491",
     Timelock: zeroAddress,
 
-    GlvReader: "0x4599Ed5939C673505B7AFcd020E1d603b0dCAf69",
-    GlvRouter: "0x377d979AB35Cd848497707ffa6Ee91783f925b80",
+    GlvReader: "0xdeaC9ea3c72C102f2a9654b8E1A14Ef86Cdd3146",
+    GlvRouter: "0x6B6595389A0196F882C0f66CB1F401f1D24afEdC",
     GlvVault: "0x76f93b5240DF811a3fc32bEDd58daA5784e46C96",
 
+    GelatoRelayRouter: "0xC2917611f422b1624D7316375690B532c149F54b",
+    SubaccountGelatoRelayRouter: "0x9022ADce7c964852475aB0de801932BaDEB0C765",
+
+    MultichainClaimsRouter: "0xa080c3E026467E1fa6E76D29A057Bf1261a4ec86",
+    MultichainGlvRouter: "0x5060A75868ca21A54C650a70E96fa92405831b15",
+    MultichainGmRouter: "0xe32632F65198eF3080ccDe22A6d23819203dBc42",
+    MultichainOrderRouter: "0x6169DD9Bc75B1d4B7138109Abe58f5645BA6B8fE",
+    MultichainSubaccountRouter: "0xa51181CC37D23d3a4b4B263D2B54e1F34B834432",
+    MultichainTransferRouter: "0x0bD6966B894D9704Ce540babcd425C93d2BD549C",
+    MultichainVault: "0xFd86A5d9D6dF6f0cB6B0e6A18Bea7CB07Ada4F79",
+    LayerZeroProvider: "0xdaa9194bFD143Af71A8d2cFc8F2c0643094a77C5",
+
+    ChainlinkPriceFeedProvider: "0x2e149AbC99cDC98FB0207d6F184DC323CEBB955B",
+    ClaimHandler: "0x01D68cf13B8f67b041b8D565931e1370774cCeBd",
+
+    // External
     OpenOceanRouter: zeroAddress,
-
     ExternalHandler: "0x0d9F90c66C392c4d0e70EE0d399c43729B942512",
+    Multicall: "0x966D1F5c54a714C6443205F0Ec49eEF81F10fdfD",
+    ArbitrumNodeInterface: zeroAddress,
+    LayerZeroEndpoint: "0x6EDCE65403992e310A62460808c4b910D972f10f",
+  },
 
-    Multicall: "0x0f53e512b49202a37c81c6085417C9a9005F2196",
+  [ARBITRUM_SEPOLIA]: {
+    // Synthetics
+    DataStore: "0xCF4c2C4c53157BcC01A596e3788fFF69cBBCD201",
+    EventEmitter: "0xa973c2692C1556E1a3d478e745e9a75624AEDc73",
+    ExchangeRouter: "0x657F9215FA1e839FbA15cF44B1C00D95cF71ed10",
+    SubaccountRouter: "0x7d4dD31B32F6Ae51893B6cffCAb15E75eA30D69b",
+    DepositVault: "0x809Ea82C394beB993c2b6B0d73b8FD07ab92DE5A",
+    WithdrawalVault: "0x7601c9dBbDCf1f5ED1E7Adba4EFd9f2cADa037A5",
+    OrderVault: "0x1b8AC606de71686fd2a1AEDEcb6E0EFba28909a2",
+    ShiftVault: "0x6b6F9B7B9a6b69942DAE74FB95E694ec277117af",
+    SyntheticsReader: "0x37a0A165389B2f959a04685aC8fc126739e86926",
+    SyntheticsRouter: "0x72F13a44C8ba16a678CAD549F17bc9e06d2B8bD2",
+
+    GlvReader: "0x4843D570c726cFb44574c1769f721a49c7e9c350",
+    GlvRouter: "0x7F8af0741e8925C132E84147762902EBBc485d11",
+    GlvVault: "0x40bD50de0977c68ecB958ED4A065E14E1091ce64",
+
+    GelatoRelayRouter: "0x44904137A4d8734a5AB13B32083FFd6B93664491",
+    SubaccountGelatoRelayRouter: "0x209E4408D68EE049957dBba7Ac62177f10ee00ab",
+
+    MultichainClaimsRouter: "0xe06534c26c90AE8c3241BC90dDB69d4Af438f17f",
+    MultichainGlvRouter: "0x29b9a624a29327b1c76317bfF08373281c582B79",
+    MultichainGmRouter: "0x9868Ab73D1cB4DcEEd74e5eB9f86346C935488F3",
+    MultichainOrderRouter: "0x2B977188b3Bf8fbCa2Ca5D6e00DC8542b7690C9E",
+    MultichainSubaccountRouter: "0xf8fbE9411f90618B3c68A8826555Ab54dE090ED7",
+    MultichainTransferRouter: "0xeCfcA6af46B9d20793f82b28bc749dfFC6DEE535",
+    MultichainVault: "0xCd46EF5ed7d08B345c47b5a193A719861Aa2CD91",
+    LayerZeroProvider: "0x3f85e237E950A7FB7cfb6DD4C262353A82588d51",
+
+    ChainlinkPriceFeedProvider: "0xa76BF7f977E80ac0bff49BDC98a27b7b070a937d",
+    ReferralStorage: "0xBbCdA58c228Bb29B5769778181c81Ac8aC546c11",
+    ClaimHandler: "0x96FE82b9C6FE46af537cE465B3befBD7b076C982",
+
+    // External
+    Multicall: "0xD84793ae65842fFac5C20Ab8eaBD699ea1FC79F3",
+    NATIVE_TOKEN: "0x980B62Da83eFf3D4576C647993b0c1D7faf17c73",
+    LayerZeroEndpoint: "0x6EDCE65403992e310A62460808c4b910D972f10f",
+    ArbitrumNodeInterface: "0x00000000000000000000000000000000000000C8",
+    GelatoRelayAddress: "0xaBcC9b596420A9E9172FD5938620E265a0f9Df92",
+    ExternalHandler: zeroAddress,
+
+    GLP: zeroAddress,
+    GMX: zeroAddress,
+    ES_GMX: zeroAddress,
+    BN_GMX: zeroAddress,
+    USDG: zeroAddress,
+    ES_GMX_IOU: zeroAddress,
+    OpenOceanRouter: zeroAddress,
+    Vault: zeroAddress,
+    PositionRouter: zeroAddress,
+    RewardRouter: zeroAddress,
+    StakedGmxTracker: zeroAddress,
+    BonusGmxTracker: zeroAddress,
+    FeeGmxTracker: zeroAddress,
+    StakedGlpTracker: zeroAddress,
+    FeeGlpTracker: zeroAddress,
+    ExtendedGmxTracker: zeroAddress,
+    StakedGmxDistributor: zeroAddress,
+    StakedGlpDistributor: zeroAddress,
+    GmxVester: zeroAddress,
+    GlpVester: zeroAddress,
+    AffiliateVester: zeroAddress,
+    Router: zeroAddress,
+    VaultReader: zeroAddress,
+    Reader: zeroAddress,
+    GlpManager: zeroAddress,
+    RewardReader: zeroAddress,
+    GlpRewardRouter: zeroAddress,
+    Timelock: zeroAddress,
   },
 };
 
-export function getContract(chainId: number, name: string): Address {
+type ExtractContractNames<T extends object> = {
+  [K in keyof T]: keyof T[K];
+}[keyof T];
+
+export type ContractName = ExtractContractNames<typeof CONTRACTS>;
+
+export function getContract(chainId: ContractsChainId, name: ContractName): Address {
   if (!CONTRACTS[chainId]) {
     throw new Error(`Unknown chainId ${chainId}`);
   }
@@ -215,3 +424,4 @@ export function getContract(chainId: number, name: string): Address {
 
   return CONTRACTS[chainId][name];
 }
+
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/dataStore.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/dataStore.ts
index b5edab1a..6504a5a5 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/dataStore.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/dataStore.ts
@@ -1,4 +1,4 @@
-import {hashData, hashString} from "../utils/hash.js";
+import {hashData, hashString, keccakString} from "../utils/hash.js";
 
 export const POSITION_IMPACT_FACTOR_KEY = hashString("POSITION_IMPACT_FACTOR");
 export const MAX_POSITION_IMPACT_FACTOR_KEY = hashString("MAX_POSITION_IMPACT_FACTOR");
@@ -7,6 +7,7 @@ export const POSITION_FEE_FACTOR_KEY = hashString("POSITION_FEE_FACTOR");
 export const SWAP_IMPACT_FACTOR_KEY = hashString("SWAP_IMPACT_FACTOR");
 export const SWAP_IMPACT_EXPONENT_FACTOR_KEY = hashString("SWAP_IMPACT_EXPONENT_FACTOR");
 export const SWAP_FEE_FACTOR_KEY = hashString("SWAP_FEE_FACTOR");
+export const ATOMIC_SWAP_FEE_FACTOR_KEY = hashString("ATOMIC_SWAP_FEE_FACTOR");
 export const FEE_RECEIVER_DEPOSIT_FACTOR_KEY = hashString("FEE_RECEIVER_DEPOSIT_FACTOR");
 export const BORROWING_FEE_RECEIVER_FACTOR_KEY = hashString("BORROWING_FEE_RECEIVER_FACTOR");
 export const FEE_RECEIVER_WITHDRAWAL_FACTOR_KEY = hashString("FEE_RECEIVER_WITHDRAWAL_FACTOR");
@@ -40,6 +41,14 @@ export const MAX_PNL_FACTOR_FOR_TRADERS_KEY = hashString("MAX_PNL_FACTOR_FOR_TRA
 export const MAX_POSITION_IMPACT_FACTOR_FOR_LIQUIDATIONS_KEY = hashString(
   "MAX_POSITION_IMPACT_FACTOR_FOR_LIQUIDATIONS"
 );
+export const CLAIMABLE_COLLATERAL_DELAY_KEY = hashString("CLAIMABLE_COLLATERAL_DELAY");
+export const CLAIMABLE_COLLATERAL_REDUCTION_FACTOR_KEY = hashString("CLAIMABLE_COLLATERAL_REDUCTION_FACTOR");
+export const CLAIMABLE_COLLATERAL_TIME_DIVISOR_KEY = hashString("CLAIMABLE_COLLATERAL_TIME_DIVISOR");
+export const MAX_LENDABLE_IMPACT_FACTOR_KEY = hashString("MAX_LENDABLE_IMPACT_FACTOR");
+export const MAX_LENDABLE_IMPACT_USD_KEY = hashString("MAX_LENDABLE_IMPACT_USD");
+export const MAX_LENDABLE_IMPACT_FACTOR_FOR_WITHDRAWALS_KEY = hashString("MAX_LENDABLE_IMPACT_FACTOR_FOR_WITHDRAWALS");
+export const LENT_POSITION_IMPACT_POOL_AMOUNT_KEY = hashString("LENT_POSITION_IMPACT_POOL_AMOUNT");
+
 export const POSITION_IMPACT_POOL_AMOUNT_KEY = hashString("POSITION_IMPACT_POOL_AMOUNT");
 export const MIN_POSITION_IMPACT_POOL_AMOUNT_KEY = hashString("MIN_POSITION_IMPACT_POOL_AMOUNT");
 export const POSITION_IMPACT_POOL_DISTRIBUTION_RATE_KEY = hashString("POSITION_IMPACT_POOL_DISTRIBUTION_RATE");
@@ -80,8 +89,10 @@ export const SUBACCOUNT_LIST_KEY = hashString("SUBACCOUNT_LIST");
 export const MAX_ALLOWED_SUBACCOUNT_ACTION_COUNT = hashString("MAX_ALLOWED_SUBACCOUNT_ACTION_COUNT");
 export const SUBACCOUNT_ACTION_COUNT = hashString("SUBACCOUNT_ACTION_COUNT");
 export const SUBACCOUNT_ORDER_ACTION = hashString("SUBACCOUNT_ORDER_ACTION");
+export const SUBACCOUNT_INTEGRATION_ID = hashString("SUBACCOUNT_INTEGRATION_ID");
 export const SUBACCOUNT_AUTO_TOP_UP_AMOUNT = hashString("SUBACCOUNT_AUTO_TOP_UP_AMOUNT");
 export const GLV_MAX_MARKET_TOKEN_BALANCE_USD = hashString("GLV_MAX_MARKET_TOKEN_BALANCE_USD");
+export const MIN_COLLATERAL_FACTOR_FOR_LIQUIDATION_KEY = hashString("MIN_COLLATERAL_FACTOR_FOR_LIQUIDATION");
 export const GLV_MAX_MARKET_TOKEN_BALANCE_AMOUNT = hashString("GLV_MAX_MARKET_TOKEN_BALANCE_AMOUNT");
 export const IS_GLV_MARKET_DISABLED = hashString("IS_GLV_MARKET_DISABLED");
 export const GLV_SHIFT_LAST_EXECUTED_AT = hashString("GLV_SHIFT_LAST_EXECUTED_AT");
@@ -93,6 +104,23 @@ export const MAX_AUTO_CANCEL_ORDERS_KEY = hashString("MAX_AUTO_CANCEL_ORDERS");
 export const OPTIMAL_USAGE_FACTOR = hashString("OPTIMAL_USAGE_FACTOR");
 export const BASE_BORROWING_FACTOR = hashString("BASE_BORROWING_FACTOR");
 export const ABOVE_OPTIMAL_USAGE_BORROWING_FACTOR = hashString("ABOVE_OPTIMAL_USAGE_BORROWING_FACTOR");
+export const SUBACCOUNT_EXPIRES_AT = hashString("SUBACCOUNT_EXPIRES_AT");
+export const MULTICHAIN_BALANCE = hashString("MULTICHAIN_BALANCE");
+export const PRICE_FEED_KEY = hashString("PRICE_FEED");
+export const GASLESS_FEATURE_DISABLED_KEY = hashString("GASLESS_FEATURE_DISABLED");
+export const GELATO_RELAY_FEE_MULTIPLIER_FACTOR_KEY = hashString("GELATO_RELAY_FEE_MULTIPLIER_FACTOR");
+export const REQUEST_EXPIRATION_TIME_KEY = hashString("REQUEST_EXPIRATION_TIME");
+
+export const GMX_SIMULATION_ORIGIN = "0x" + keccakString("GMX SIMULATION ORIGIN").slice(-40);
+export const CLAIM_TERMS_KEY = hashString("CLAIM_TERMS");
+export const GENERAL_CLAIM_FEATURE_DISABLED = hashString("GENERAL_CLAIM_FEATURE_DISABLED");
+
+export function subaccountExpiresAtKey(account: string, subaccount: string, actionType: string) {
+  return hashData(
+    ["bytes32", "address", "address", "bytes32"],
+    [SUBACCOUNT_EXPIRES_AT, account, subaccount, actionType]
+  );
+}
 
 export function glvShiftLastExecutedAtKey(glvAddress: string) {
   return hashData(["bytes32", "address"], [GLV_SHIFT_LAST_EXECUTED_AT, glvAddress]);
@@ -142,6 +170,10 @@ export function swapFeeFactorKey(market: string, forPositiveImpact: boolean) {
   return hashData(["bytes32", "address", "bool"], [SWAP_FEE_FACTOR_KEY, market, forPositiveImpact]);
 }
 
+export function atomicSwapFeeFactorKey(market: string) {
+  return hashData(["bytes32", "address"], [ATOMIC_SWAP_FEE_FACTOR_KEY, market]);
+}
+
 export function openInterestKey(market: string, collateralToken: string, isLong: boolean) {
   return hashData(["bytes32", "address", "address", "bool"], [OPEN_INTEREST_KEY, market, collateralToken, isLong]);
 }
@@ -250,7 +282,7 @@ export function depositGasLimitKey() {
 }
 
 export function withdrawalGasLimitKey() {
-  return hashData(["bytes32"], [WITHDRAWAL_GAS_LIMIT_KEY]);
+  return WITHDRAWAL_GAS_LIMIT_KEY;
 }
 
 export function shiftGasLimitKey() {
@@ -281,6 +313,10 @@ export function minCollateralFactorKey(market: string) {
   return hashData(["bytes32", "address"], [MIN_COLLATERAL_FACTOR_KEY, market]);
 }
 
+export function minCollateralFactorForLiquidationKey(market: string) {
+  return hashData(["bytes32", "address"], [MIN_COLLATERAL_FACTOR_FOR_LIQUIDATION_KEY, market]);
+}
+
 export function minCollateralFactorForOpenInterest(market: string, isLong: boolean) {
   return hashData(
     ["bytes32", "address", "bool"],
@@ -353,6 +389,42 @@ export function subaccountActionCountKey(account: string, subaccount: string, ac
   );
 }
 
+export function maxLendableImpactFactorKey(market: string) {
+  return hashData(["bytes32", "address"], [MAX_LENDABLE_IMPACT_FACTOR_KEY, market]);
+}
+
+export function maxLendableImpactFactorForWithdrawalsKey(market: string) {
+  return hashData(["bytes32", "address"], [MAX_LENDABLE_IMPACT_FACTOR_FOR_WITHDRAWALS_KEY, market]);
+}
+
+export function maxLendableImpactUsdKey(market: string) {
+  return hashData(["bytes32", "address"], [MAX_LENDABLE_IMPACT_USD_KEY, market]);
+}
+
+export function subaccountIntegrationIdKey(account: string, subaccount: string) {
+  return hashData(["bytes32", "address", "address"], [SUBACCOUNT_INTEGRATION_ID, account, subaccount]);
+}
+
 export function subaccountAutoTopUpAmountKey(account: string, subaccount: string) {
   return hashData(["bytes32", "address", "address"], [SUBACCOUNT_AUTO_TOP_UP_AMOUNT, account, subaccount]);
 }
+
+export function multichainBalanceKey(account: string, token: string) {
+  return hashData(["bytes32", "address", "address"], [MULTICHAIN_BALANCE, account, token]);
+}
+
+export function priceFeedKey(token: string) {
+  return hashData(["bytes32", "address"], [PRICE_FEED_KEY, token]);
+}
+
+export function gaslessFeatureDisabledKey(module: string) {
+  return hashData(["bytes32", "address"], [GASLESS_FEATURE_DISABLED_KEY, module]);
+}
+
+export function claimTermsKey(distributionId: bigint) {
+  return hashData(["bytes32", "uint256"], [CLAIM_TERMS_KEY, distributionId]);
+}
+
+export function claimsDisabledKey(distributionId: bigint) {
+  return hashData(["bytes32", "uint256"], [GENERAL_CLAIM_FEATURE_DISABLED, distributionId]);
+}
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/tokens.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/tokens.ts
index 5e72f379..ce5a6c66 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/tokens.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/configs/tokens.ts
@@ -1,9 +1,10 @@
-import { zeroAddress } from "viem";
+import {zeroAddress} from "viem";
 
 
-import {ARBITRUM, AVALANCHE, AVALANCHE_FUJI} from "./chains.js";
+import {ARBITRUM, ARBITRUM_SEPOLIA, AVALANCHE, AVALANCHE_FUJI, BASE, BOTANIX} from "./chains.js";
 import {getContract} from "./contracts.js";
-import {Token, TokenCategory} from "../types/tokens.js";
+import {Token, TokenAddressTypesMap, TokenCategory} from "../types/tokens.js";
+
 
 export const NATIVE_TOKEN_ADDRESS = zeroAddress;
 
@@ -31,6 +32,8 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       imageUrl: "https://assets.coingecko.com/coins/images/2518/thumb/weth.png?1628852295",
       coingeckoUrl: "https://www.coingecko.com/en/coins/ethereum",
       isV1Available: true,
+      isPermitSupported: true,
+      contractVersion: "1",
     },
     {
       name: "Wrapped Bitcoin",
@@ -45,6 +48,8 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       coingeckoUrl: "https://www.coingecko.com/en/coins/wrapped-bitcoin",
       explorerUrl: "https://arbiscan.io/address/0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f",
       isV1Available: true,
+      isPermitSupported: true,
+      contractVersion: "1",
     },
     {
       name: "Arbitrum",
@@ -56,6 +61,8 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       imageUrl: "https://assets.coingecko.com/coins/images/16547/small/photo_2023-03-29_21.47.00.jpeg?1680097630",
       coingeckoUrl: "https://www.coingecko.com/en/coins/arbitrum",
       explorerUrl: "https://arbiscan.io/token/0x912ce59144191c1204e64559fe8253a0e49e6548",
+      isPermitSupported: true,
+      contractVersion: "1",
     },
     {
       name: "Wrapped SOL (Wormhole)",
@@ -70,6 +77,9 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       coingeckoSymbol: "SOL",
       explorerUrl: "https://arbiscan.io/token/0x2bCc6D6CdBbDC0a4071e48bb3B969b06B3330c07",
       explorerSymbol: "SOL",
+      isPermitSupported: true,
+      isPermitDisabled: true,
+      contractVersion: "1",
     },
     {
       name: "Chainlink",
@@ -84,6 +94,8 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       coingeckoUrl: "https://www.coingecko.com/en/coins/chainlink",
       explorerUrl: "https://arbiscan.io/token/0xf97f4df75117a78c1a5a0dbb814af92458539fb4",
       isV1Available: true,
+      isPermitSupported: true,
+      contractVersion: "1",
     },
     {
       name: "Uniswap",
@@ -98,6 +110,8 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       coingeckoUrl: "https://www.coingecko.com/en/coins/uniswap",
       explorerUrl: "https://arbiscan.io/token/0xfa7f8980b0f1e64a2062791cc3b0871572f1f7f0",
       isV1Available: true,
+      isPermitSupported: true,
+      contractVersion: "1",
     },
     {
       name: "Bridged USDC (USDC.e)",
@@ -109,6 +123,8 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       coingeckoUrl: "https://www.coingecko.com/en/coins/bridged-usdc-arbitrum",
       explorerUrl: "https://arbiscan.io/token/0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",
       isV1Available: true,
+      isPermitSupported: true,
+      contractVersion: "1",
     },
     {
       name: "USD Coin",
@@ -120,6 +136,7 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       imageUrl: "https://assets.coingecko.com/coins/images/6319/thumb/USD_Coin_icon.png?1547042389",
       coingeckoUrl: "https://www.coingecko.com/en/coins/usd-coin",
       explorerUrl: "https://arbiscan.io/address/0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+      isPermitSupported: true,
     },
     {
       name: "Tether",
@@ -131,6 +148,8 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       explorerUrl: "https://arbiscan.io/address/0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
       coingeckoUrl: "https://www.coingecko.com/en/coins/tether",
       isV1Available: true,
+      isPermitSupported: true,
+      contractVersion: "1",
     },
     {
       name: "Dai",
@@ -142,6 +161,7 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       coingeckoUrl: "https://www.coingecko.com/en/coins/dai",
       explorerUrl: "https://arbiscan.io/token/0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
       isV1Available: true,
+      isPermitSupported: true,
     },
     {
       name: "Frax",
@@ -153,6 +173,8 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       coingeckoUrl: "https://www.coingecko.com/en/coins/frax",
       explorerUrl: "https://arbiscan.io/token/0x17FC002b466eEc40DaE837Fc4bE5c67993ddBd6F",
       isV1Available: true,
+      isPermitSupported: true,
+      contractVersion: "1",
     },
     {
       name: "Magic Internet Money",
@@ -163,6 +185,7 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       isTempHidden: true,
       imageUrl: "https://assets.coingecko.com/coins/images/16786/small/mimlogopng.png",
       isV1Available: true,
+      isPermitSupported: true,
     },
     {
       name: "Bitcoin",
@@ -173,6 +196,7 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       categories: ["layer1"],
       imageUrl: "https://assets.coingecko.com/coins/images/1/small/bitcoin.png?1547033579",
       coingeckoUrl: "https://www.coingecko.com/en/coins/bitcoin",
+      isPermitSupported: true,
     },
     {
       name: "Dogecoin",
@@ -277,6 +301,8 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       imageUrl: "https://assets.coingecko.com/coins/images/12645/standard/AAVE.png?1696512452",
       coingeckoUrl: "https://www.coingecko.com/en/coins/aave",
       coingeckoSymbol: "AAVE",
+      isPermitSupported: true,
+      contractVersion: "1",
     },
     {
       name: "Wrapped AVAX (Wormhole)",
@@ -290,6 +316,9 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       coingeckoUrl: "https://www.coingecko.com/en/coins/avalanche",
       coingeckoSymbol: "AVAX",
       explorerSymbol: "WAVAX",
+      isPermitSupported: true,
+      isPermitDisabled: true,
+      contractVersion: "1",
     },
     {
       name: "Optimism",
@@ -321,6 +350,9 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       categories: ["meme"],
       imageUrl: "https://assets.coingecko.com/coins/images/33566/standard/dogwifhat.jpg?1702499428",
       coingeckoUrl: "https://www.coingecko.com/en/coins/dogwifhat",
+      isPermitSupported: true,
+      isPermitDisabled: true,
+      contractVersion: "1",
     },
     {
       name: "ORDI",
@@ -381,6 +413,8 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       imageUrl:
         "https://assets.coingecko.com/coins/images/11224/standard/0x18084fba666a33d37592fa2633fd49a74dd93a88.png?1696511155",
       coingeckoUrl: "https://www.coingecko.com/en/coins/tbtc",
+      isPermitSupported: true,
+      contractVersion: "1",
     },
     {
       name: "Eigen",
@@ -390,6 +424,8 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       categories: ["layer2"],
       imageUrl: "https://assets.coingecko.com/coins/images/37441/standard/eigen.jpg?1728023974",
       coingeckoUrl: "https://www.coingecko.com/en/coins/eigenlayer",
+      isPermitSupported: true,
+      contractVersion: "1",
     },
     {
       name: "Sats",
@@ -577,6 +613,9 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       categories: ["defi"],
       imageUrl: "https://assets.coingecko.com/coins/images/15069/standard/Pendle_Logo_Normal-03.png?1696514728",
       coingeckoUrl: "https://www.coingecko.com/en/coins/pendle",
+      isPermitSupported: true,
+      isPermitDisabled: true,
+      contractVersion: "1",
     },
     {
       name: "ADA",
@@ -883,6 +922,101 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       coingeckoUrl: "https://www.coingecko.com/en/coins/mantra",
       isSynthetic: true,
     },
+    {
+      name: "Dolomite",
+      symbol: "DOLO",
+      address: "0x97Ce1F309B949f7FBC4f58c5cb6aa417A5ff8964",
+      decimals: 18,
+      priceDecimals: 6,
+      categories: ["defi"],
+      imageUrl: "https://assets.coingecko.com/coins/images/54710/standard/DOLO-small.png?1745398535",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/dolomite",
+      isSynthetic: true,
+    },
+    {
+      name: "LayerZero",
+      symbol: "ZRO",
+      address: "0xa8193C55C34Ed22e1Dbe73FD5Adc668E51578a67",
+      decimals: 18,
+      priceDecimals: 4,
+      categories: ["defi"],
+      imageUrl: "https://assets.coingecko.com/coins/images/28206/standard/ftxG9_TJ_400x400.jpeg?1696527208",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/layerzero",
+      isSynthetic: true,
+    },
+    {
+      name: "Moodeng",
+      symbol: "MOODENG",
+      address: "0xd3898c6570974AEca38a8ACf22fd60739e528A99",
+      decimals: 6,
+      isSynthetic: true,
+      coingeckoUrl: "https://www.coingecko.com/en/coins/moo-deng",
+      imageUrl: "https://assets.coingecko.com/coins/images/50264/standard/MOODENG.jpg?1726726975",
+      categories: ["meme"],
+    },
+    {
+      name: "Monero",
+      symbol: "XMR",
+      address: "0x13674172E6E44D31d4bE489d5184f3457c40153A",
+      decimals: 12,
+      isSynthetic: true,
+      coingeckoUrl: "https://www.coingecko.com/en/coins/monero",
+      imageUrl: "https://assets.coingecko.com/coins/images/69/standard/monero_logo.png?1696501460",
+      categories: ["layer1", "defi"],
+    },
+    {
+      name: "Pi Network",
+      symbol: "PI",
+      address: "0xd1738d37401a0A71f7E382d2cFeCD3ab69687017",
+      decimals: 18,
+      isSynthetic: true,
+      coingeckoUrl: "https://www.coingecko.com/en/coins/pi-network",
+      imageUrl: "https://assets.coingecko.com/coins/images/54342/standard/pi_network.jpg?1739347576",
+      categories: ["layer1"],
+    },
+    {
+      name: "Curve DAO Token",
+      symbol: "CRV",
+      address: "0xe5f01aeAcc8288E9838A60016AB00d7b6675900b",
+      decimals: 18,
+      isSynthetic: true,
+      coingeckoUrl: "https://www.coingecko.com/en/coins/curve-dao-token",
+      imageUrl: "https://assets.coingecko.com/coins/images/12124/standard/Curve.png?1696511967",
+      categories: ["defi"],
+    },
+    {
+      name: "Pump",
+      symbol: "PUMP",
+      address: "0x9c060B2fA953b5f69879a8B7B81f62BFfEF360be",
+      decimals: 18,
+      priceDecimals: 6,
+      imageUrl: "https://assets.coingecko.com/coins/images/67164/standard/pump.jpg?1751949376",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/pump-fun",
+      isSynthetic: true,
+      categories: ["meme"],
+    },
+    {
+      name: "SPX6900",
+      symbol: "SPX6900",
+      address: "0xb736be525A65326513351058427d1f47B0CfB045",
+      decimals: 8,
+      priceDecimals: 4,
+      imageUrl: "https://assets.coingecko.com/coins/images/31401/standard/centeredcoin_%281%29.png?1737048493",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/spx6900",
+      isSynthetic: true,
+      categories: ["meme"],
+    },
+    {
+      name: "Mantle",
+      symbol: "MNT",
+      address: "0x955cd91eEaE618F5a7b49E1e3c7482833B10DAb4",
+      decimals: 18,
+      priceDecimals: 5,
+      imageUrl: "https://assets.coingecko.com/coins/images/30980/standard/token-logo.png?1696529819",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/mantle",
+      isSynthetic: true,
+      categories: ["layer2", "defi"],
+    },
     {
       name: "GMX LP",
       symbol: "GLP",
@@ -909,6 +1043,138 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       imageUrl: "https://raw.githubusercontent.com/gmx-io/gmx-assets/main/GMX-Assets/PNG/GLV_LOGO.png",
       isPlatformToken: true,
     },
+    {
+      name: "Algorand",
+      symbol: "ALGO",
+      address: "0x72Cd3a21aA7A898028d9501868Fbe6dED0020434",
+      decimals: 6,
+      priceDecimals: 5,
+      isSynthetic: true,
+      categories: ["layer1", "defi"],
+      imageUrl: "https://assets.coingecko.com/coins/images/4380/standard/download.png?1696504978",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/algorand",
+    },
+    {
+      name: "Cronos",
+      symbol: "CRO",
+      address: "0xB7EfE7c7f059E84Ab87A83A169c583Fb4A54fAc3",
+      decimals: 8,
+      priceDecimals: 5,
+      isSynthetic: true,
+      categories: ["layer1"],
+      imageUrl: "https://assets.coingecko.com/coins/images/7310/standard/cro_token_logo.png?1696507599",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/cronos",
+    },
+    {
+      name: "Hedera",
+      symbol: "HBAR",
+      address: "0xEb2A83b973f4dbB9511D92dd40d2ba4C683f0971",
+      decimals: 8,
+      priceDecimals: 5,
+      isSynthetic: true,
+      categories: ["layer1", "defi"],
+      imageUrl: "https://assets.coingecko.com/coins/images/3688/standard/hbar.png?1696504364",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/hedera-hashgraph",
+    },
+    {
+      name: "Convex Finance",
+      symbol: "CVX",
+      address: "0x3B6f801C0052Dfe0Ac80287D611F31B7c47B9A6b",
+      decimals: 18,
+      priceDecimals: 4,
+      isSynthetic: true,
+      categories: ["defi"],
+      imageUrl: "https://assets.coingecko.com/coins/images/15585/standard/convex.png?1696515221",
+      coingeckoUrl: "https://www.coingecko.com/nl/coins/convex-finance",
+    },
+    {
+      name: "Kaspa",
+      symbol: "KAS",
+      address: "0x91c6a8F6aFAC036F4ABf1bA55f4E76892E865E4a",
+      decimals: 8,
+      priceDecimals: 6,
+      isSynthetic: true,
+      categories: ["layer1"],
+      imageUrl: "https://assets.coingecko.com/coins/images/25751/standard/kaspa-icon-exchanges.png?1696524837",
+      coingeckoUrl: "https://www.coingecko.com/nl/coins/kaspa",
+    },
+    {
+      name: "Aero",
+      symbol: "AERO",
+      address: "0xEcc5eb985Ddbb8335b175b0A2A1144E4c978F1f6",
+      decimals: 18,
+      priceDecimals: 4,
+      isSynthetic: true,
+      categories: ["defi"],
+      coingeckoUrl: "https://www.coingecko.com/en/coins/aerodrome-finance",
+      imageUrl: "https://assets.coingecko.com/coins/images/31745/standard/token.png?1696530564",
+    },
+    {
+      name: "Brett",
+      symbol: "BRETT",
+      address: "0x4249F6e0808bEfF7368AaAD3F7A3Fd511F61Ee60",
+      decimals: 18,
+      priceDecimals: 4,
+      isSynthetic: true,
+      categories: ["meme"],
+      imageUrl: "https://assets.coingecko.com/coins/images/54317/standard/AERO.png?1728309870",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/brett-2",
+    },
+    {
+      name: "World Liberty Financial",
+      symbol: "WLFI",
+      address: "0xC5799ab6E2818fD8d0788dB8D156B0c5db1Bf97b",
+      decimals: 18,
+      priceDecimals: 5,
+      isSynthetic: true,
+      categories: ["defi"],
+      imageUrl: "https://assets.coingecko.com/coins/images/50767/standard/wlfi.png?1756438915",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/world-liberty-financial",
+    },
+    {
+      name: "OKB",
+      symbol: "OKB",
+      address: "0xd37F01A3379f052FEF70F63c0Be27931891aa2B9",
+      decimals: 18,
+      priceDecimals: 3,
+      isSynthetic: true,
+      categories: ["layer2"],
+      imageUrl: "https://assets.coingecko.com/coins/images/4463/standard/WeChat_Image_20220118095654.png?1696505053",
+      coingeckoUrl: "https://www.coingecko.com/nl/coins/okb",
+    },
+    {
+      name: "Morpho",
+      symbol: "MORPHO",
+      address: "0xF67b2a901D674B443Fa9f6DB2A689B37c07fD4fE",
+      decimals: 18,
+      priceDecimals: 4,
+      isSynthetic: true,
+      categories: ["defi"],
+      imageUrl: "https://assets.coingecko.com/coins/images/29837/standard/Morpho-token-icon.png?1726771230",
+      coingeckoUrl: "https://www.coingecko.com/nl/coins/morpho",
+    },
+    {
+      name: "Venice Token",
+      symbol: "VVV",
+      address: "0xB79Eb5BA64A167676694bB41bc1640F95d309a2F",
+      decimals: 18,
+      priceDecimals: 4,
+      isSynthetic: true,
+      categories: ["defi"],
+      imageUrl: "https://assets.coingecko.com/coins/images/54023/standard/VVV_Token_Transparent.png?1741856877",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/venice-token",
+    },
+    {
+      name: "Moonwell",
+      symbol: "WELL",
+      address: "0x465A31E5bA29b8EAcC860d499D714a6f07e56E85",
+      decimals: 18,
+      priceDecimals: 4,
+      isSynthetic: true,
+      categories: ["defi"],
+      imageUrl: "https://assets.coingecko.com/coins/images/26133/standard/WELL.png?1696525221",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/moonwell",
+    },
   ],
   [AVALANCHE]: [
     {
@@ -987,6 +1253,7 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       coingeckoUrl: "https://www.coingecko.com/en/coins/usd-coin",
       explorerUrl: "https://snowtrace.io/address/0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
       isV1Available: true,
+      isPermitSupported: true,
     },
     {
       name: "Bridged USDC (USDC.e)",
@@ -1008,6 +1275,8 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       imageUrl: "https://assets.coingecko.com/coins/images/325/small/Tether-logo.png",
       coingeckoUrl: "https://www.coingecko.com/en/coins/tether",
       explorerUrl: "https://snowtrace.io/address/0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
+      isPermitSupported: true,
+      contractVersion: "1",
     },
     {
       name: "Tether",
@@ -1040,6 +1309,7 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       coingeckoUrl: "https://www.coingecko.com/en/coins/magic-internet-money",
       explorerUrl: "https://snowtrace.io/address/0x130966628846BFd36ff31a822705796e8cb8C18D",
       isV1Available: true,
+      isPermitSupported: true,
     },
     {
       name: "Chainlink",
@@ -1088,6 +1358,9 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       coingeckoUrl: "https://www.coingecko.com/en/coins/solana",
       coingeckoSymbol: "SOL",
       explorerUrl: "https://snowtrace.io/address/0xFE6B19286885a4F7F55AdAD09C3Cd1f906D2478F",
+      isPermitSupported: true,
+      isPermitDisabled: true,
+      contractVersion: "1",
     },
     {
       name: "XRP",
@@ -1133,6 +1406,28 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       coingeckoUrl: "https://www.coingecko.com/en/coins/melania-meme",
       isSynthetic: true,
     },
+    {
+      name: "Pump",
+      symbol: "PUMP",
+      address: "0xdA598795DfE56388ca3D35e2ccFA96EFf83eC306",
+      decimals: 18,
+      priceDecimals: 6,
+      imageUrl: "https://assets.coingecko.com/coins/images/67164/standard/pump.jpg?1751949376",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/pump-fun",
+      isSynthetic: true,
+      categories: ["meme"],
+    },
+    {
+      name: "World Liberty Financial",
+      symbol: "WLFI",
+      address: "0xbDF8a77ACB7A54597E7760b34D3E632912bB59b7",
+      decimals: 18,
+      priceDecimals: 5,
+      isSynthetic: true,
+      categories: ["defi"],
+      imageUrl: "https://assets.coingecko.com/coins/images/50767/standard/wlfi.png?1756438915",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/world-liberty-financial",
+    },
     {
       name: "Escrowed GMX",
       symbol: "ESGMX",
@@ -1192,6 +1487,7 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       imageUrl: "https://assets.coingecko.com/coins/images/12559/small/coin-round-red.png?1604021818",
       coingeckoUrl: "https://www.coingecko.com/en/coins/avalanche",
       explorerUrl: "https://testnet.snowtrace.io/address/0x1D308089a2D1Ced3f1Ce36B1FcaF815b07217be3",
+      isPermitSupported: true,
     },
     {
       name: "Ethereum (WETH.e)",
@@ -1397,12 +1693,234 @@ export const TOKENS: { [chainId: number]: Token[] } = {
       isPlatformToken: true,
     },
   ],
+  [ARBITRUM_SEPOLIA]: [
+    {
+      name: "Ethereum",
+      symbol: "ETH",
+      decimals: 18,
+      address: zeroAddress,
+      wrappedAddress: "0x980B62Da83eFf3D4576C647993b0c1D7faf17c73",
+      isNative: true,
+      isShortable: true,
+      categories: ["layer1"],
+      imageUrl: "https://assets.coingecko.com/coins/images/279/small/ethereum.png?1595348880",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/ethereum",
+    },
+    {
+      name: "Wrapped ETH",
+      symbol: "WETH",
+      address: "0x980B62Da83eFf3D4576C647993b0c1D7faf17c73",
+      decimals: 18,
+      isWrapped: true,
+      baseSymbol: "ETH",
+      categories: ["layer1"],
+      imageUrl: "https://assets.coingecko.com/coins/images/279/small/ethereum.png?1595348880",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/ethereum",
+    },
+    {
+      name: "Bitcoin",
+      symbol: "BTC",
+      address: "0xF79cE1Cf38A09D572b021B4C5548b75A14082F12",
+      decimals: 8,
+      imageUrl: "https://assets.coingecko.com/coins/images/1/small/bitcoin.png?1746042828",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/bitcoin",
+    },
+    {
+      name: "USD Coin GMX",
+      symbol: "USDC",
+      address: "0x3321Fd36aEaB0d5CdfD26f4A3A93E2D2aAcCB99f",
+      decimals: 6,
+      isStable: true,
+      imageUrl: "https://assets.coingecko.com/coins/images/6319/thumb/USD_Coin_icon.png?1547042389",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/usd-coin",
+    },
+    {
+      name: "USD Coin Stargate",
+      symbol: "USDC.SG",
+      address: "0x3253a335E7bFfB4790Aa4C25C4250d206E9b9773",
+      decimals: 6,
+      isStable: true,
+      imageUrl: "https://assets.coingecko.com/coins/images/6319/thumb/USD_Coin_icon.png?1547042389",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/usd-coin",
+    },
+    {
+      name: "CRV",
+      symbol: "CRV",
+      address: "0xD5DdAED48B09fa1D7944bd662CB05265FCD7077C",
+      decimals: 18,
+      priceDecimals: 5,
+      imageUrl: "https://assets.coingecko.com/coins/images/12134/small/curve.png?1596358786",
+      isSynthetic: true,
+      coingeckoUrl: "https://www.coingecko.com/en/coins/curve-dao-token",
+    },
+    /** Placeholder tokens */
+    {
+      name: "GMX",
+      symbol: "GMX",
+      address: "<gmx-address>",
+      decimals: 18,
+      imageUrl: "https://assets.coingecko.com/coins/images/18323/small/arbit.png?1631532468",
+      isPlatformToken: true,
+    },
+    {
+      name: "Escrowed GMX",
+      symbol: "ESGMX",
+      address: "<esgmx-address>",
+      decimals: 18,
+      isPlatformToken: true,
+    },
+    {
+      name: "GMX LP",
+      symbol: "GLP",
+      address: "<glp-address>",
+      decimals: 18,
+      imageUrl: "https://github.com/gmx-io/gmx-assets/blob/main/GMX-Assets/PNG/GLP_LOGO%20ONLY.png?raw=true",
+      isPlatformToken: true,
+    },
+    {
+      name: "GMX Market tokens",
+      symbol: "GM",
+      address: "<market-token-address>",
+      decimals: 18,
+      imageUrl: "https://raw.githubusercontent.com/gmx-io/gmx-assets/main/GMX-Assets/PNG/GM_LOGO.png",
+      isPlatformToken: true,
+    },
+    {
+      name: "GLV Market tokens",
+      symbol: "GLV",
+      address: "<market-token-address>",
+      decimals: 18,
+      imageUrl: "https://raw.githubusercontent.com/gmx-io/gmx-assets/main/GMX-Assets/PNG/GLV_LOGO.png",
+      isPlatformToken: true,
+    },
+  ],
+  [BOTANIX]: [
+    {
+      name: "Bitcoin",
+      symbol: "BTC",
+      assetSymbol: "BTC",
+      address: NATIVE_TOKEN_ADDRESS,
+      decimals: 18,
+      isNative: true,
+      isShortable: true,
+      categories: ["layer1"],
+      imageUrl: "https://assets.coingecko.com/coins/images/1/standard/bitcoin.png?1696501400",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/bitcoin",
+      baseSymbol: "BTC",
+    },
+    {
+      name: "Pegged BTC",
+      symbol: "PBTC",
+      assetSymbol: "pBTC",
+      address: "0x0D2437F93Fed6EA64Ef01cCde385FB1263910C56",
+      decimals: 18,
+      isShortable: true,
+      categories: ["layer1"],
+      imageUrl: "https://assets.coingecko.com/coins/images/1/standard/bitcoin.png?1696501400",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/bitcoin",
+      baseSymbol: "BTC",
+      isWrapped: true,
+    },
+    {
+      name: "Staked BTC",
+      symbol: "STBTC",
+      assetSymbol: "stBTC",
+      address: "0xF4586028FFdA7Eca636864F80f8a3f2589E33795",
+      decimals: 18,
+      isShortable: true,
+      categories: ["layer1"],
+      imageUrl: "https://assets.coingecko.com/coins/images/1/standard/bitcoin.png?1696501400",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/bitcoin",
+      baseSymbol: "BTC",
+      isStaking: true,
+    },
+    {
+      name: "BTC",
+      symbol: "BTC",
+      address: "0x1B9e25f54225bcdCf347569E38C41Ade9BB686e5",
+      decimals: 8,
+      isShortable: true,
+      categories: ["layer1"],
+      imageUrl: "https://assets.coingecko.com/coins/images/1/standard/bitcoin.png?1696501400",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/bitcoin",
+      isSynthetic: true,
+    },
+    {
+      name: "USDC.E",
+      symbol: "USDC.E",
+      assetSymbol: "USDC.e",
+      address: "0x29eE6138DD4C9815f46D34a4A1ed48F46758A402",
+      decimals: 6,
+      isStable: true,
+      imageUrl: "https://assets.coingecko.com/coins/images/6319/thumb/USD_Coin_icon.png?1547042389",
+      coingeckoUrl: "https://www.coingecko.com/en/coins/bridged-usdc-arbitrum",
+      isPermitSupported: true,
+    },
+    {
+      name: "GMX",
+      symbol: "GMX",
+      address: "",
+      decimals: 18,
+      imageUrl: "https://assets.coingecko.com/coins/images/18323/small/arbit.png?1631532468",
+      isPlatformToken: true,
+    },
+    {
+      name: "Escrowed GMX",
+      symbol: "ESGMX",
+      address: "",
+      decimals: 18,
+      isPlatformToken: true,
+    },
+    {
+      name: "GMX LP",
+      symbol: "GLP",
+      address: "",
+      decimals: 18,
+      imageUrl: "https://github.com/gmx-io/gmx-assets/blob/main/GMX-Assets/PNG/GLP_LOGO%20ONLY.png?raw=true",
+      isPlatformToken: true,
+    },
+    /** Placeholder tokens */
+    {
+      name: "GMX Market tokens",
+      symbol: "GM",
+      address: "<market-token-address>",
+      decimals: 18,
+      imageUrl: "https://raw.githubusercontent.com/gmx-io/gmx-assets/main/GMX-Assets/PNG/GM_LOGO.png",
+      isPlatformToken: true,
+    },
+    {
+      name: "GLV Market tokens",
+      symbol: "GLV",
+      address: "<market-token-address>",
+      decimals: 18,
+      imageUrl: "https://raw.githubusercontent.com/gmx-io/gmx-assets/main/GMX-Assets/PNG/GLV_LOGO.png",
+      isPlatformToken: true,
+    },
+  ],
+  [BASE]: [
+    {
+      name: "Ethereum",
+      symbol: "ETH",
+      address: "0x0000000000000000000000000000000000000000",
+      decimals: 18,
+    },
+    //usdc 
+    {
+      name: "USD Coin",
+      symbol: "USDC",
+      address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+      decimals: 6,
+      isStable: true,
+    },
+  ],
+
 };
 
 export const TOKEN_COLOR_MAP = {
   ETH: "#6062a6",
   BTC: "#F7931A",
   WBTC: "#F7931A",
+  PBTC: "#F7931A",
   USDC: "#2775CA",
   "USDC.E": "#2A5ADA",
   USDT: "#67B18A",
@@ -1441,7 +1959,7 @@ export const TOKENS_BY_SYMBOL_MAP: { [chainId: number]: { [symbol: string]: Toke
 export const WRAPPED_TOKENS_MAP: { [chainId: number]: Token } = {};
 export const NATIVE_TOKENS_MAP: { [chainId: number]: Token } = {};
 
-const CHAIN_IDS = [ARBITRUM, AVALANCHE, AVALANCHE_FUJI];
+const CHAIN_IDS = [ARBITRUM, AVALANCHE, AVALANCHE_FUJI, BOTANIX, ARBITRUM_SEPOLIA];
 
 for (let j = 0; j < CHAIN_IDS.length; j++) {
   const chainId = CHAIN_IDS[j];
@@ -1528,7 +2046,16 @@ export function isValidToken(chainId: number, address: string) {
   return address in TOKENS_MAP[chainId];
 }
 
+export function isValidTokenSafe(chainId: number, address: string) {
+  return address in TOKENS_MAP[chainId];
+}
+
 export function getToken(chainId: number, address: string) {
+  // FIXME APE_deprecated token which is not in use but can be displayed
+  if (chainId === ARBITRUM && address === "0x74885b4D524d497261259B38900f54e6dbAd2210") {
+    return getTokenBySymbol(chainId, "APE");
+  }
+
   if (!TOKENS_MAP[chainId]) {
     throw new Error(`Incorrect chainId ${chainId}`);
   }
@@ -1575,23 +2102,29 @@ export function getTokenBySymbol(
   return token;
 }
 
-export function convertTokenAddress(chainId: number, address: string, convertTo?: "wrapped" | "native") {
+export function convertTokenAddress<T extends keyof TokenAddressTypesMap, R extends TokenAddressTypesMap[T]>(
+  chainId: number,
+  address: string,
+  convertTo?: T
+): R {
   const wrappedToken = getWrappedToken(chainId);
 
   if (convertTo === "wrapped" && address === NATIVE_TOKEN_ADDRESS) {
-    return wrappedToken.address;
+    return wrappedToken.address as R;
   }
 
   if (convertTo === "native" && address === wrappedToken.address) {
-    return NATIVE_TOKEN_ADDRESS;
+    return NATIVE_TOKEN_ADDRESS as R;
   }
 
-  return address;
+  return address as R;
 }
 
-export function getNormalizedTokenSymbol(tokenSymbol) {
+export function getNormalizedTokenSymbol(tokenSymbol: string) {
   if (["WBTC", "WETH", "WAVAX"].includes(tokenSymbol)) {
     return tokenSymbol.substr(1);
+  } else if (["PBTC", "STBTC"].includes(tokenSymbol)) {
+    return "BTC";
   } else if (tokenSymbol.includes(".")) {
     return tokenSymbol.split(".")[0];
   }
@@ -1664,8 +2197,11 @@ export function getCategoryTokenAddresses(chainId: number, category: TokenCatego
 }
 
 export const createTokensMap = (tokens: Token[]) => {
-  return tokens.reduce((acc, token) => {
-    acc[token.address] = token;
-    return acc;
-  }, {});
+  return tokens.reduce(
+    (acc, token) => {
+      acc[token.address] = token;
+      return acc;
+    },
+    {} as Record<string, Token>
+  );
 };
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/index.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/index.ts
index 1bfabe72..80938b0f 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/index.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/index.ts
@@ -1,8 +1,7 @@
-import {Abi, Address, createPublicClient, createWalletClient, http, PublicClient, WalletClient} from "viem";
+import {Abi, Address, createPublicClient, http, PublicClient, WalletClient} from "viem";
 
 import {Accounts} from "./modules/accounts/accounts.js";
 import {BATCH_CONFIGS} from "./configs/batch.js";
-import {getChain} from "./configs/chains.js";
 import {Markets} from "./modules/markets/index.js";
 import {Oracle} from "./modules/oracle.js";
 import {Orders} from "./modules/orders/orders.js";
@@ -13,6 +12,7 @@ import {Utils} from "./modules/utils/utils.js";
 import {GmxSdkConfig} from "./types/sdk.js";
 import {callContract, CallContractOpts} from "./utils/callContract.js";
 import {MAX_TIMEOUT, Multicall, MulticallRequestConfig} from "./utils/multicall.js";
+import {getViemChain} from "./configs/chains.js";
 
 export class GmxSdk {
   public readonly markets = new Markets(this);
@@ -43,23 +43,13 @@ export class GmxSdk {
         }),
         pollingInterval: undefined,
         batch: BATCH_CONFIGS[this.config.chainId].client,
-        chain: getChain(this.config.chainId),
+        chain: getViemChain(this.config.chainId),
       };
       this.publicClient = createPublicClient(clientParams) as any;
     }
 
     this.walletClient =
-      config.walletClient ??
-      createWalletClient({
-        account: config.account as Address,
-        chain: getChain(config.chainId),
-        transport: http(config.rpcUrl, {
-          retryCount: 0,
-          retryDelay: 10000000,
-          batch: BATCH_CONFIGS[config.chainId].http,
-          timeout: MAX_TIMEOUT,
-        }),
-      });
+      config.walletClient;
   }
 
   setAccount(account: Address) {
@@ -80,7 +70,7 @@ export class GmxSdk {
   }
 
   get chain() {
-    return getChain(this.chainId);
+    return getViemChain(this.chainId);
   }
 
   get account() {
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/markets/index.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/markets/index.ts
index 70f3c5e6..7f04bd14 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/markets/index.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/markets/index.ts
@@ -51,8 +51,8 @@ export class Markets extends Module {
             const marketDivisor = getMarketDivisor(market);
 
             claimableFundingData[marketAddress] = {
-              claimableFundingAmountLong: callsResult.claimableFundingAmountLong.returnValues[0] / BigInt(marketDivisor),
-              claimableFundingAmountShort: callsResult.claimableFundingAmountShort.returnValues[0] / BigInt(marketDivisor),
+              claimableFundingAmountLong: callsResult.claimableFundingAmountLong.returnValues[0] / marketDivisor,
+              claimableFundingAmountShort: callsResult.claimableFundingAmountShort.returnValues[0] / marketDivisor,
             };
 
             return claimableFundingData;
@@ -71,7 +71,9 @@ export class Markets extends Module {
     marketsAddresses: string[] | undefined;
     marketsData: MarketsData | undefined;
     tokensData: TokensData | undefined;
-  }): Promise<MarketsResult> {
+  }): Promise<{
+    [marketAddress: string]: MarketValues;
+  }> {
     const dataStoreAddress = getContract(this.chainId, "DataStore");
     const syntheticsReaderAddress = getContract(this.chainId, "SyntheticsReader");
 
@@ -248,8 +250,16 @@ export class Markets extends Module {
             minCollateralFactorForOpenInterestShort:
               dataStoreValues.minCollateralFactorForOpenInterestShort.returnValues[0],
 
-            positionFeeFactorForPositiveImpact: dataStoreValues.positionFeeFactorForPositiveImpact.returnValues[0],
-            positionFeeFactorForNegativeImpact: dataStoreValues.positionFeeFactorForNegativeImpact.returnValues[0],
+            minCollateralFactorForLiquidation: dataStoreValues.minCollateralFactorForLiquidation.returnValues[0],
+
+            positionFeeFactorForBalanceWasImproved:
+              dataStoreValues.positionFeeFactorForBalanceWasImproved.returnValues[0],
+            positionFeeFactorForBalanceWasNotImproved:
+              dataStoreValues.positionFeeFactorForBalanceWasNotImproved.returnValues[0],
+            positionFeeFactorForPositiveImpact:
+              dataStoreValues.positionFeeFactorForPositiveImpact.returnValues[0],
+            positionFeeFactorForNegativeImpact:
+              dataStoreValues.positionFeeFactorForNegativeImpact.returnValues[0],
             positionImpactFactorPositive: dataStoreValues.positionImpactFactorPositive.returnValues[0],
             positionImpactFactorNegative: dataStoreValues.positionImpactFactorNegative.returnValues[0],
             maxPositionImpactFactorPositive: dataStoreValues.maxPositionImpactFactorPositive.returnValues[0],
@@ -257,11 +267,15 @@ export class Markets extends Module {
             maxPositionImpactFactorForLiquidations:
               dataStoreValues.maxPositionImpactFactorForLiquidations.returnValues[0],
             positionImpactExponentFactor: dataStoreValues.positionImpactExponentFactor.returnValues[0],
+            swapFeeFactorForBalanceWasImproved: dataStoreValues.swapFeeFactorForBalanceWasImproved.returnValues[0],
+            swapFeeFactorForBalanceWasNotImproved:
+              dataStoreValues.swapFeeFactorForBalanceWasNotImproved.returnValues[0],
             swapFeeFactorForPositiveImpact: dataStoreValues.swapFeeFactorForPositiveImpact.returnValues[0],
             swapFeeFactorForNegativeImpact: dataStoreValues.swapFeeFactorForNegativeImpact.returnValues[0],
             swapImpactFactorPositive: dataStoreValues.swapImpactFactorPositive.returnValues[0],
             swapImpactFactorNegative: dataStoreValues.swapImpactFactorNegative.returnValues[0],
             swapImpactExponentFactor: dataStoreValues.swapImpactExponentFactor.returnValues[0],
+            atomicSwapFeeFactor: dataStoreValues.atomicSwapFeeFactor.returnValues[0],
 
             virtualMarketId: dataStoreValues.virtualMarketId.returnValues[0],
             virtualLongTokenId: dataStoreValues.virtualLongTokenId.returnValues[0],
@@ -334,7 +348,15 @@ export class Markets extends Module {
     const chainId = this.chainId;
 
     const marketsResult = markets.reduce(
-      (acc: MarketsResult, market) => {
+      (
+        acc: MarketsResult,
+        market: {
+          marketTokenAddress: string;
+          indexTokenAddress: string;
+          longTokenAddress: string;
+          shortTokenAddress: string;
+        }
+      ) => {
         try {
           if (!marketsMap[market.marketTokenAddress]?.isListed) {
             return acc;
@@ -373,6 +395,7 @@ export class Markets extends Module {
 
   async getMarketsInfo(): Promise<MarketsInfoResult> {
     const { marketsData, marketsAddresses } = await this.getMarkets();
+
     const { tokensData, pricesUpdatedAt } = await this.sdk.tokens.getTokensData();
 
     const [marketsValues, marketsConfigs, claimableFundingData] = await Promise.all([
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/markets/query-builders.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/markets/query-builders.ts
index 02bb8d32..86c62701 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/markets/query-builders.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/markets/query-builders.ts
@@ -8,7 +8,8 @@ import {getContractMarketPrices} from "../../utils/markets.js";
 import {getByKey} from "../../utils/objects.js";
 import {MarketConfigMulticallRequestConfig, MarketValuesMulticallRequestConfig} from "./types.js";
 import {getContract} from "../../configs/contracts.js";
-import { ContractCallsConfig } from "../../utils/multicall.js";
+import {ContractCallsConfig} from "../../utils/multicall.js";
+import {ContractsChainId} from "../../configs/chains.js";
 
 export function buildClaimableFundingDataRequest({
   marketsAddresses,
@@ -19,47 +20,50 @@ export function buildClaimableFundingDataRequest({
   marketsAddresses: string[] | undefined;
   marketsData: MarketsData | undefined;
   account: string;
-  chainId: number;
+  chainId: ContractsChainId;
 }) {
   if (!marketsAddresses) {
     return {};
   }
 
-  return marketsAddresses.reduce((request, marketAddress) => {
-    const market = getByKey(marketsData, marketAddress);
+  return marketsAddresses.reduce(
+    (request, marketAddress) => {
+      const market = getByKey(marketsData, marketAddress);
+
+      if (!market) {
+        return request;
+      }
+
+      const keys = hashDataMap({
+        claimableFundingAmountLong: [
+          ["bytes32", "address", "address", "address"],
+          [CLAIMABLE_FUNDING_AMOUNT, marketAddress, market.longTokenAddress, account],
+        ],
+        claimableFundingAmountShort: [
+          ["bytes32", "address", "address", "address"],
+          [CLAIMABLE_FUNDING_AMOUNT, marketAddress, market.shortTokenAddress, account],
+        ],
+      });
+
+      request[marketAddress] = {
+        contractAddress: getContract(chainId, "DataStore"),
+        abiId: "DataStore",
+        calls: {
+          claimableFundingAmountLong: {
+            methodName: "getUint",
+            params: [keys.claimableFundingAmountLong],
+          },
+          claimableFundingAmountShort: {
+            methodName: "getUint",
+            params: [keys.claimableFundingAmountShort],
+          },
+        },
+      } satisfies ContractCallsConfig<any>;
 
-    if (!market) {
       return request;
-    }
-
-    const keys = hashDataMap({
-      claimableFundingAmountLong: [
-        ["bytes32", "address", "address", "address"],
-        [CLAIMABLE_FUNDING_AMOUNT, marketAddress, market.longTokenAddress, account],
-      ],
-      claimableFundingAmountShort: [
-        ["bytes32", "address", "address", "address"],
-        [CLAIMABLE_FUNDING_AMOUNT, marketAddress, market.shortTokenAddress, account],
-      ],
-    });
-
-    request[marketAddress] = {
-      contractAddress: getContract(chainId, "DataStore"),
-      abiId: "DataStore",
-      calls: {
-        claimableFundingAmountLong: {
-          methodName: "getUint",
-          params: [keys.claimableFundingAmountLong],
-        },
-        claimableFundingAmountShort: {
-          methodName: "getUint",
-          params: [keys.claimableFundingAmountShort],
-        },
-      },
-    } satisfies ContractCallsConfig<any>;
-
-    return request;
-  }, {});
+    },
+    {} as Record<string, ContractCallsConfig<any>>
+  );
 }
 
 export async function buildMarketsValuesRequest(
@@ -82,6 +86,13 @@ export async function buildMarketsValuesRequest(
 
   for (const marketAddress of marketsAddresses || []) {
     const market = getByKey(marketsData, marketAddress)!;
+
+    if (!market) {
+      // eslint-disable-next-line no-console
+      console.warn(`No market data found for ${marketAddress}, skipping market values request`);
+      continue;
+    }
+
     const marketPrices = getContractMarketPrices(tokensData!, market)!;
 
     if (!marketPrices) {
@@ -243,204 +254,120 @@ export async function buildMarketsConfigsRequest(
       prebuiltHashedKeys = hashMarketConfigKeys(marketsData[marketAddress]);
     }
 
+    // Add validation to check for undefined keys
+    const requiredKeys = [
+      'isDisabled', 'maxLongPoolAmount', 'maxShortPoolAmount', 'maxLongPoolUsdForDeposit', 
+      'maxShortPoolUsdForDeposit', 'longPoolAmountAdjustment', 'shortPoolAmountAdjustment',
+      'reserveFactorLong', 'reserveFactorShort', 'openInterestReserveFactorLong', 
+      'openInterestReserveFactorShort', 'maxOpenInterestLong', 'maxOpenInterestShort',
+      'minPositionImpactPoolAmount', 'positionImpactPoolDistributionRate', 'borrowingFactorLong',
+      'borrowingFactorShort', 'borrowingExponentFactorLong', 'borrowingExponentFactorShort',
+      'fundingFactor', 'fundingExponentFactor', 'fundingIncreaseFactorPerSecond',
+      'fundingDecreaseFactorPerSecond', 'thresholdForStableFunding', 'thresholdForDecreaseFunding',
+      'minFundingFactorPerSecond', 'maxFundingFactorPerSecond', 'maxPnlFactorForTradersLong',
+      'maxPnlFactorForTradersShort', 'positionFeeFactorForBalanceWasImproved',
+      'positionFeeFactorForBalanceWasNotImproved', 'positionFeeFactorForPositiveImpact',
+      'positionFeeFactorForNegativeImpact', 'positionImpactFactorPositive', 'positionImpactFactorNegative',
+      'maxPositionImpactFactorPositive', 'maxPositionImpactFactorNegative', 'maxPositionImpactFactorForLiquidations',
+      'maxLendableImpactFactor', 'maxLendableImpactFactorForWithdrawals', 'maxLendableImpactUsd',
+      'lentPositionImpactPoolAmount', 'minCollateralFactor', 'minCollateralFactorForLiquidation',
+      'minCollateralFactorForOpenInterestLong', 'minCollateralFactorForOpenInterestShort',
+      'positionImpactExponentFactor', 'swapFeeFactorForBalanceWasImproved', 'swapFeeFactorForBalanceWasNotImproved',
+      'swapFeeFactorForPositiveImpact', 'swapFeeFactorForNegativeImpact', 'atomicSwapFeeFactor',
+      'swapImpactFactorPositive', 'swapImpactFactorNegative', 'swapImpactExponentFactor',
+      'virtualMarketId', 'virtualShortTokenId', 'virtualLongTokenId'
+    ];
+
+    for (const key of requiredKeys) {
+      if (prebuiltHashedKeys[key] === undefined) {
+        if (!marketsData?.[marketAddress]) {
+          throw new Error(`No market data found for the market ${marketAddress}`);
+        }
+        // Regenerate all keys if any are missing
+        prebuiltHashedKeys = hashMarketConfigKeys(marketsData[marketAddress]);
+        break;
+      }
+    }
+
+    // Create calls object, filtering out any undefined keys
+    const calls: Record<string, any> = {};
+    
+    // Helper function to add call if key exists
+    const addCall = (callKey: string, methodName: string, hashKey: any) => {
+      if (hashKey !== undefined) {
+        calls[callKey] = {
+          methodName,
+          params: [hashKey],
+        };
+      } else {
+        console.warn(`Skipping undefined hash key: ${callKey} for market ${marketAddress}`);
+      }
+    };
+
+    addCall('isDisabled', 'getBool', prebuiltHashedKeys.isDisabled);
+    addCall('maxLongPoolAmount', 'getUint', prebuiltHashedKeys.maxLongPoolAmount);
+    addCall('maxShortPoolAmount', 'getUint', prebuiltHashedKeys.maxShortPoolAmount);
+    addCall('maxLongPoolUsdForDeposit', 'getUint', prebuiltHashedKeys.maxLongPoolUsdForDeposit);
+    addCall('maxShortPoolUsdForDeposit', 'getUint', prebuiltHashedKeys.maxShortPoolUsdForDeposit);
+    addCall('longPoolAmountAdjustment', 'getUint', prebuiltHashedKeys.longPoolAmountAdjustment);
+    addCall('shortPoolAmountAdjustment', 'getUint', prebuiltHashedKeys.shortPoolAmountAdjustment);
+    addCall('reserveFactorLong', 'getUint', prebuiltHashedKeys.reserveFactorLong);
+    addCall('reserveFactorShort', 'getUint', prebuiltHashedKeys.reserveFactorShort);
+    addCall('openInterestReserveFactorLong', 'getUint', prebuiltHashedKeys.openInterestReserveFactorLong);
+    addCall('openInterestReserveFactorShort', 'getUint', prebuiltHashedKeys.openInterestReserveFactorShort);
+    addCall('maxOpenInterestLong', 'getUint', prebuiltHashedKeys.maxOpenInterestLong);
+    addCall('maxOpenInterestShort', 'getUint', prebuiltHashedKeys.maxOpenInterestShort);
+    addCall('minPositionImpactPoolAmount', 'getUint', prebuiltHashedKeys.minPositionImpactPoolAmount);
+    addCall('positionImpactPoolDistributionRate', 'getUint', prebuiltHashedKeys.positionImpactPoolDistributionRate);
+    addCall('borrowingFactorLong', 'getUint', prebuiltHashedKeys.borrowingFactorLong);
+    addCall('borrowingFactorShort', 'getUint', prebuiltHashedKeys.borrowingFactorShort);
+    addCall('borrowingExponentFactorLong', 'getUint', prebuiltHashedKeys.borrowingExponentFactorLong);
+    addCall('borrowingExponentFactorShort', 'getUint', prebuiltHashedKeys.borrowingExponentFactorShort);
+    addCall('fundingFactor', 'getUint', prebuiltHashedKeys.fundingFactor);
+    addCall('fundingExponentFactor', 'getUint', prebuiltHashedKeys.fundingExponentFactor);
+    addCall('fundingIncreaseFactorPerSecond', 'getUint', prebuiltHashedKeys.fundingIncreaseFactorPerSecond);
+    addCall('fundingDecreaseFactorPerSecond', 'getUint', prebuiltHashedKeys.fundingDecreaseFactorPerSecond);
+    addCall('thresholdForStableFunding', 'getUint', prebuiltHashedKeys.thresholdForStableFunding);
+    addCall('thresholdForDecreaseFunding', 'getUint', prebuiltHashedKeys.thresholdForDecreaseFunding);
+    addCall('minFundingFactorPerSecond', 'getUint', prebuiltHashedKeys.minFundingFactorPerSecond);
+    addCall('maxFundingFactorPerSecond', 'getUint', prebuiltHashedKeys.maxFundingFactorPerSecond);
+    addCall('maxPnlFactorForTradersLong', 'getUint', prebuiltHashedKeys.maxPnlFactorForTradersLong);
+    addCall('maxPnlFactorForTradersShort', 'getUint', prebuiltHashedKeys.maxPnlFactorForTradersShort);
+    addCall('positionFeeFactorForBalanceWasImproved', 'getUint', prebuiltHashedKeys.positionFeeFactorForBalanceWasImproved);
+    addCall('positionFeeFactorForBalanceWasNotImproved', 'getUint', prebuiltHashedKeys.positionFeeFactorForBalanceWasNotImproved);
+    addCall('positionFeeFactorForPositiveImpact', 'getUint', prebuiltHashedKeys.positionFeeFactorForPositiveImpact);
+    addCall('positionFeeFactorForNegativeImpact', 'getUint', prebuiltHashedKeys.positionFeeFactorForNegativeImpact);
+    addCall('positionImpactFactorPositive', 'getUint', prebuiltHashedKeys.positionImpactFactorPositive);
+    addCall('positionImpactFactorNegative', 'getUint', prebuiltHashedKeys.positionImpactFactorNegative);
+    addCall('maxPositionImpactFactorPositive', 'getUint', prebuiltHashedKeys.maxPositionImpactFactorPositive);
+    addCall('maxPositionImpactFactorNegative', 'getUint', prebuiltHashedKeys.maxPositionImpactFactorNegative);
+    addCall('maxPositionImpactFactorForLiquidations', 'getUint', prebuiltHashedKeys.maxPositionImpactFactorForLiquidations);
+    addCall('maxLendableImpactFactor', 'getUint', prebuiltHashedKeys.maxLendableImpactFactor);
+    addCall('maxLendableImpactFactorForWithdrawals', 'getUint', prebuiltHashedKeys.maxLendableImpactFactorForWithdrawals);
+    addCall('maxLendableImpactUsd', 'getUint', prebuiltHashedKeys.maxLendableImpactUsd);
+    addCall('lentPositionImpactPoolAmount', 'getUint', prebuiltHashedKeys.lentPositionImpactPoolAmount);
+    addCall('minCollateralFactor', 'getUint', prebuiltHashedKeys.minCollateralFactor);
+    addCall('minCollateralFactorForLiquidation', 'getUint', prebuiltHashedKeys.minCollateralFactorForLiquidation);
+    addCall('minCollateralFactorForOpenInterestLong', 'getUint', prebuiltHashedKeys.minCollateralFactorForOpenInterestLong);
+    addCall('minCollateralFactorForOpenInterestShort', 'getUint', prebuiltHashedKeys.minCollateralFactorForOpenInterestShort);
+    addCall('positionImpactExponentFactor', 'getUint', prebuiltHashedKeys.positionImpactExponentFactor);
+    addCall('swapFeeFactorForBalanceWasImproved', 'getUint', prebuiltHashedKeys.swapFeeFactorForBalanceWasImproved);
+    addCall('swapFeeFactorForBalanceWasNotImproved', 'getUint', prebuiltHashedKeys.swapFeeFactorForBalanceWasNotImproved);
+    addCall('swapFeeFactorForPositiveImpact', 'getUint', prebuiltHashedKeys.swapFeeFactorForPositiveImpact);
+    addCall('swapFeeFactorForNegativeImpact', 'getUint', prebuiltHashedKeys.swapFeeFactorForNegativeImpact);
+    addCall('atomicSwapFeeFactor', 'getUint', prebuiltHashedKeys.atomicSwapFeeFactor);
+    addCall('swapImpactFactorPositive', 'getUint', prebuiltHashedKeys.swapImpactFactorPositive);
+    addCall('swapImpactFactorNegative', 'getUint', prebuiltHashedKeys.swapImpactFactorNegative);
+    addCall('swapImpactExponentFactor', 'getUint', prebuiltHashedKeys.swapImpactExponentFactor);
+    addCall('virtualMarketId', 'getBytes32', prebuiltHashedKeys.virtualMarketId);
+    addCall('virtualShortTokenId', 'getBytes32', prebuiltHashedKeys.virtualShortTokenId);
+    addCall('virtualLongTokenId', 'getBytes32', prebuiltHashedKeys.virtualLongTokenId);
+
     request[`${marketAddress}-dataStore`] = {
       contractAddress: dataStoreAddress,
       abiId: "DataStore",
-      calls: {
-        isDisabled: {
-          methodName: "getBool",
-          params: [prebuiltHashedKeys.isDisabled],
-        },
-        maxLongPoolAmount: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.maxLongPoolAmount],
-        },
-        maxShortPoolAmount: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.maxShortPoolAmount],
-        },
-        maxLongPoolUsdForDeposit: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.maxLongPoolUsdForDeposit],
-        },
-        maxShortPoolUsdForDeposit: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.maxShortPoolUsdForDeposit],
-        },
-        longPoolAmountAdjustment: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.longPoolAmountAdjustment],
-        },
-        shortPoolAmountAdjustment: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.shortPoolAmountAdjustment],
-        },
-        reserveFactorLong: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.reserveFactorLong],
-        },
-        reserveFactorShort: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.reserveFactorShort],
-        },
-        openInterestReserveFactorLong: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.openInterestReserveFactorLong],
-        },
-        openInterestReserveFactorShort: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.openInterestReserveFactorShort],
-        },
-        maxOpenInterestLong: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.maxOpenInterestLong],
-        },
-        maxOpenInterestShort: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.maxOpenInterestShort],
-        },
-        minPositionImpactPoolAmount: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.minPositionImpactPoolAmount],
-        },
-        positionImpactPoolDistributionRate: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.positionImpactPoolDistributionRate],
-        },
-        borrowingFactorLong: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.borrowingFactorLong],
-        },
-        borrowingFactorShort: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.borrowingFactorShort],
-        },
-        borrowingExponentFactorLong: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.borrowingExponentFactorLong],
-        },
-        borrowingExponentFactorShort: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.borrowingExponentFactorShort],
-        },
-        fundingFactor: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.fundingFactor],
-        },
-        fundingExponentFactor: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.fundingExponentFactor],
-        },
-        fundingIncreaseFactorPerSecond: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.fundingIncreaseFactorPerSecond],
-        },
-        fundingDecreaseFactorPerSecond: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.fundingDecreaseFactorPerSecond],
-        },
-        thresholdForStableFunding: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.thresholdForStableFunding],
-        },
-        thresholdForDecreaseFunding: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.thresholdForDecreaseFunding],
-        },
-        minFundingFactorPerSecond: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.minFundingFactorPerSecond],
-        },
-        maxFundingFactorPerSecond: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.maxFundingFactorPerSecond],
-        },
-        maxPnlFactorForTradersLong: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.maxPnlFactorForTradersLong],
-        },
-        maxPnlFactorForTradersShort: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.maxPnlFactorForTradersShort],
-        },
-        positionFeeFactorForPositiveImpact: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.positionFeeFactorForPositiveImpact],
-        },
-        positionFeeFactorForNegativeImpact: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.positionFeeFactorForNegativeImpact],
-        },
-        positionImpactFactorPositive: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.positionImpactFactorPositive],
-        },
-        positionImpactFactorNegative: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.positionImpactFactorNegative],
-        },
-        maxPositionImpactFactorPositive: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.maxPositionImpactFactorPositive],
-        },
-        maxPositionImpactFactorNegative: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.maxPositionImpactFactorNegative],
-        },
-        maxPositionImpactFactorForLiquidations: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.maxPositionImpactFactorForLiquidations],
-        },
-        minCollateralFactor: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.minCollateralFactor],
-        },
-        minCollateralFactorForOpenInterestLong: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.minCollateralFactorForOpenInterestLong],
-        },
-        minCollateralFactorForOpenInterestShort: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.minCollateralFactorForOpenInterestShort],
-        },
-        positionImpactExponentFactor: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.positionImpactExponentFactor],
-        },
-        swapFeeFactorForPositiveImpact: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.swapFeeFactorForPositiveImpact],
-        },
-        swapFeeFactorForNegativeImpact: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.swapFeeFactorForNegativeImpact],
-        },
-        swapImpactFactorPositive: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.swapImpactFactorPositive],
-        },
-        swapImpactFactorNegative: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.swapImpactFactorNegative],
-        },
-        swapImpactExponentFactor: {
-          methodName: "getUint",
-          params: [prebuiltHashedKeys.swapImpactExponentFactor],
-        },
-        virtualMarketId: {
-          methodName: "getBytes32",
-          params: [prebuiltHashedKeys.virtualMarketId],
-        },
-        virtualShortTokenId: {
-          methodName: "getBytes32",
-          params: [prebuiltHashedKeys.virtualShortTokenId],
-        },
-        virtualLongTokenId: {
-          methodName: "getBytes32",
-          params: [prebuiltHashedKeys.virtualLongTokenId],
-        },
-      },
-    } satisfies ContractCallsConfig<any>;
+      calls,
+    } as any;
   }
 
   return request;
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/markets/types.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/markets/types.ts
index 0e8843a1..a31c1bc2 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/markets/types.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/markets/types.ts
@@ -93,6 +93,12 @@ export type MarketConfig = Pick<
   | "virtualMarketId"
   | "virtualLongTokenId"
   | "virtualShortTokenId"
+  | "atomicSwapFeeFactor"
+  | "swapFeeFactorForBalanceWasImproved"
+  | "swapFeeFactorForBalanceWasNotImproved"
+  | "positionFeeFactorForBalanceWasImproved"
+  | "positionFeeFactorForBalanceWasNotImproved"
+  | "minCollateralFactorForLiquidation"
 >;
 
 export type MarketValuesMulticallRequestConfig = MulticallRequestConfig<{
@@ -178,7 +184,19 @@ export type MarketConfigMulticallRequestConfig = MulticallRequestConfig<{
       | "swapImpactExponentFactor"
       | "virtualMarketId"
       | "virtualLongTokenId"
-      | "virtualShortTokenId",
+      | "virtualShortTokenId"
+      | "positionFeeFactorForBalanceWasImproved"
+      | "positionFeeFactorForBalanceWasNotImproved"
+      | "swapFeeFactorForBalanceWasImproved"
+      | "swapFeeFactorForBalanceWasNotImproved"
+      | "atomicSwapFeeFactor"
+      | "minCollateralFactorForLiquidation"
+      | "maxLendableImpactFactor"
+      | "maxLendableImpactFactorForWithdrawals"
+      | "maxLendableImpactUsd"
+      | "lentPositionImpactPoolAmount"
+      | "minCollateralFactor",
+
       {
         methodName: string;
         params: any[];
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/helpers.spec.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/helpers.spec.ts
index 37865ab5..161f0663 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/helpers.spec.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/helpers.spec.ts
@@ -1,19 +1,17 @@
-import { describe, it, expect, vi, beforeEach, beforeAll } from "vitest";
+import {beforeAll, beforeEach, describe, expect, it, vi} from "vitest";
 import * as swapPath from "../../utils/swap/swapPath.js";
-import * as tradeAmounts from "../../utils/trade/amounts.js";
-import { arbitrumSdk } from "../../utils/testUtil.js";
-import { ARBITRUM } from "../../configs/chains.js";
-import { getByKey } from "../../utils/objects.js";
-import { MarketInfo, MarketsInfoData } from "../../types/markets.js";
-import { TokenData, TokensData } from "../../types/tokens.js";
+import {arbitrumSdk} from "../../utils/testUtil.js";
+import {ARBITRUM} from "../../configs/chains.js";
+import {getByKey} from "../../utils/objects.js";
+import {MarketInfo, MarketsInfoData} from "../../types/markets.js";
+import {TokenData, TokensData} from "../../types/tokens.js";
+import * as tradeAmounts from "../../utils/trade/increase.js";
 
 describe("increaseOrderHelper", () => {
-  let mockParams;
-  let createIncreaseOrderSpy;
-
   let marketsInfoData: MarketsInfoData;
   let tokensData: TokensData;
-
+  let mockParams: any;
+  let createIncreaseOrderSpy: any;
   let market: MarketInfo;
   let payToken: TokenData;
   let collateralToken: TokenData;
@@ -27,12 +25,6 @@ describe("increaseOrderHelper", () => {
 
     marketsInfoData = result.marketsInfoData;
     tokensData = result.tokensData;
-  });
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    createIncreaseOrderSpy = vi.spyOn(arbitrumSdk.orders, "createIncreaseOrder").mockResolvedValue();
 
     market = getByKey(marketsInfoData, "0x70d95587d40A2caf56bd97485aB3Eec10Bee6336")!;
 
@@ -55,64 +47,112 @@ describe("increaseOrderHelper", () => {
     };
   });
 
-  it("should call createIncreaseOrder with correct parameters for a market order with payAmount", async () => {
-    const findSwapPathSpy = vi.spyOn(swapPath, "createFindSwapPath");
-    const getIncreasePositionAmountsSpy = vi.spyOn(tradeAmounts, "getIncreasePositionAmounts");
+  describe("validation", () => {
+    it("should throw an error if wrong collateral token selected", async () => {
+      const e = await arbitrumSdk.orders
+        .long({
+          ...mockParams,
+          marketAddress: "0x47c031236e19d024b42f8AE6780E44A573170703",
+          collateralTokenAddress: "0xC4da4c24fd591125c3F47b340b6f4f76111883d8",
+        })
+        .catch((error) => {
+          return error.message;
+        });
 
-    await arbitrumSdk.orders.long(mockParams);
+      await expect(e).toBe("collateralTokenAddress: synthetic tokens are not supported");
+    });
 
-    expect(findSwapPathSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        chainId: ARBITRUM,
-        fromTokenAddress: payToken.address,
-        toTokenAddress: collateralToken.address,
-        marketsInfoData: expect.any(Object),
-        estimator: expect.any(Function),
-        allPaths: expect.any(Array),
-      })
-    );
+    it("should throw an error if wrong collateral token selected", async () => {
+      const e = await arbitrumSdk.orders
+        .long({
+          ...mockParams,
+          collateralTokenAddress: "0xFEa7a6a0B346362BF88A9e4A88416B77a57D6c2A",
+        })
+        .catch((error) => {
+          return error.message;
+        });
 
-    expect(getIncreasePositionAmountsSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        isLong: true,
-        initialCollateralAmount: 1000n,
-        leverage: 50000n,
-        strategy: "leverageByCollateral",
-        marketInfo: market,
-      })
-    );
+      await expect(e).toBe("collateralTokenAddress: token is not available");
+    });
 
-    expect(createIncreaseOrderSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        marketsInfoData: expect.any(Object),
-        tokensData: expect.any(Object),
-        marketInfo: market,
-        indexToken: market.indexToken,
-        isLimit: false,
-        marketAddress: market.marketTokenAddress,
-        allowedSlippage: 125,
-        collateralTokenAddress: collateralToken.address,
-        collateralToken,
-        isLong: true,
-        receiveTokenAddress: collateralToken.address,
-        increaseAmounts: expect.objectContaining({
+    it("should throw an error if wrong collateral token selected", async () => {
+      const e = await arbitrumSdk.orders
+        .long({
+          ...mockParams,
+          collateralTokenAddress: "0x912CE59144191C1204E64559FE8253a0e49E6548",
+        })
+        .catch((error) => {
+          return error.message;
+        });
+
+      await expect(e).toBe("Invalid collateral token. Only long WETH and short USDC tokens are available.");
+    });
+  });
+
+  describe("parameters", () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+
+      createIncreaseOrderSpy = vi.spyOn(arbitrumSdk.orders, "createIncreaseOrder").mockResolvedValue();
+    });
+
+    it("should call createIncreaseOrder with correct parameters for a market order with payAmount", async () => {
+      const findSwapPathSpy = vi.spyOn(swapPath, "createFindSwapPath");
+      const getIncreasePositionAmountsSpy = vi.spyOn(tradeAmounts, "getIncreasePositionAmounts");
+
+      await arbitrumSdk.orders.long(mockParams);
+
+      expect(findSwapPathSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          chainId: ARBITRUM,
+          fromTokenAddress: payToken.address,
+          toTokenAddress: collateralToken.address,
+          marketsInfoData: expect.any(Object),
+        })
+      );
+
+      expect(getIncreasePositionAmountsSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          isLong: true,
           initialCollateralAmount: 1000n,
-          estimatedLeverage: 50000n,
-          triggerPrice: undefined,
-          acceptablePrice: 0n,
-          acceptablePriceDeltaBps: 0n,
-          positionFeeUsd: 0n,
-          uiFeeUsd: 0n,
-          swapUiFeeUsd: 0n,
-          feeDiscountUsd: 0n,
-          borrowingFeeUsd: 0n,
-          fundingFeeUsd: 0n,
-          positionPriceImpactDeltaUsd: 0n,
-          limitOrderType: undefined,
-          triggerThresholdType: undefined,
-          externalSwapQuote: undefined,
-        }),
-      })
-    );
+          leverage: 50000n,
+          strategy: "leverageByCollateral",
+          marketInfo: market,
+        })
+      );
+
+      expect(createIncreaseOrderSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          marketsInfoData: expect.any(Object),
+          tokensData: expect.any(Object),
+          marketInfo: market,
+          indexToken: market.indexToken,
+          isLimit: false,
+          marketAddress: market.marketTokenAddress,
+          allowedSlippage: 125,
+          collateralTokenAddress: collateralToken.address,
+          collateralToken,
+          isLong: true,
+          receiveTokenAddress: collateralToken.address,
+          increaseAmounts: expect.objectContaining({
+            initialCollateralAmount: 1000n,
+            estimatedLeverage: 50000n,
+            triggerPrice: undefined,
+            acceptablePrice: 0n,
+            acceptablePriceDeltaBps: 0n,
+            positionFeeUsd: 0n,
+            uiFeeUsd: 0n,
+            swapUiFeeUsd: 0n,
+            feeDiscountUsd: 0n,
+            borrowingFeeUsd: 0n,
+            fundingFeeUsd: 0n,
+            positionPriceImpactDeltaUsd: 0n,
+            limitOrderType: undefined,
+            triggerThresholdType: undefined,
+            swapStrategy: expect.any(Object),
+          }),
+        })
+      );
+    });
   });
 });
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/helpers.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/helpers.ts
index ad6b6635..1f0e6b35 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/helpers.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/helpers.ts
@@ -1,9 +1,9 @@
 import {MarketsInfoData} from "../../types/markets.js";
 import {DecreasePositionSwapType, OrderType} from "../../types/orders.js";
 import {TokenData, TokensData, TokensRatio} from "../../types/tokens.js";
-import {DecreasePositionAmounts, FindSwapPath, SwapAmounts} from "../../types/trade.js";
+import {DecreasePositionAmounts, SwapAmounts, SwapOptimizationOrderArray} from "../../types/trade.js";
 import {getByKey} from "../../utils/objects.js";
-import {createFindSwapPath, findAllSwapPaths, getWrappedAddress} from "../../utils/swap/swapPath.js";
+import {createFindSwapPath} from "../../utils/swap/swapPath.js";
 import {
     convertToUsd,
     getIsEquivalentTokens,
@@ -11,532 +11,580 @@ import {
     getIsWrap,
     getTokensRatioByPrice
 } from "../../utils/tokens.js";
-import {getIncreasePositionAmounts} from "../../utils/trade/amounts.js";
 import {getAcceptablePriceInfo, getDefaultAcceptablePriceImpactBps, getOrderThresholdType} from "../../utils/prices.js";
 
 import type {GmxSdk} from "../..";
-import {createSwapEstimator, getMarketsGraph} from "../../utils/swap/swapRouting.js";
 import {getSwapAmountsByFromValue, getSwapAmountsByToValue} from "../../utils/swap/index.js";
 import {EntryField, SidecarSlTpOrderEntryValid} from "../../types/sidecarOrders.js";
 import {ethers} from "ethers";
+import {GasLimitsConfig} from "../../types/fees.js";
+import {getIncreasePositionAmounts} from "../../utils/trade/increase.js";
 
 /** Base Optional params for helpers, allows to avoid calling markets, tokens and uiFeeFactor methods if they are already passed */
 interface BaseOptionalParams {
     marketsInfoData?: MarketsInfoData;
     tokensData?: TokensData;
     uiFeeFactor?: bigint;
-    skipSimulation?: boolean;
-}
-
-export type PositionIncreaseParams = (
+    gasPrice?: bigint;
+    gasLimits?: GasLimitsConfig;
+  }
+  
+  export type PositionIncreaseParams = (
     | {
-    /** Increase amounts will be calculated based on collateral amount */
-    payAmount: bigint;
-}
+        /** Increase amounts will be calculated based on collateral amount */
+        payAmount: bigint;
+      }
     | {
-    /** Increase amounts will be calculated based on position size amount */
-    sizeAmount: bigint;
-}
-    ) & {
+        /** Increase amounts will be calculated based on position size amount */
+        sizeAmount: bigint;
+      }
+  ) & {
     marketAddress: string;
     payTokenAddress: string;
     collateralTokenAddress: string;
-
+  
     /** @default 100 */
     allowedSlippageBps?: number;
     referralCodeForTxn?: string;
-
+  
     leverage?: bigint;
     /** If presented, then it's limit order */
     limitPrice?: bigint;
     acceptablePriceImpactBuffer?: number;
     fixedAcceptablePriceImpactBps?: bigint;
-
+  
     skipSimulation?: boolean;
     stopLossPrice?: bigint;
     takeProfitPrice?: bigint;
-} & BaseOptionalParams;
-
-async function getAndValidateBaseParams(sdk: GmxSdk, params: BaseOptionalParams) {
-    let tokensData: TokensData | undefined = params.tokensData;
-    let marketsInfoData: MarketsInfoData | undefined = params.marketsInfoData;
-
-    if (!params.marketsInfoData && !params.tokensData) {
-        const result = await sdk.markets.getMarketsInfo();
-        marketsInfoData = result.marketsInfoData;
-        tokensData = result.tokensData;
+  } & BaseOptionalParams;
+  
+  function passThoughOrFetch<T>(value: T, condition: (input: T) => boolean, fetchFn: () => Promise<T>) {
+    if (condition(value)) {
+      return value;
     }
-
-    if (!tokensData) {
-        throw new Error("Tokens data is not available");
+  
+    return fetchFn();
+  }
+  
+  async function getAndValidateBaseParams(
+    sdk: GmxSdk,
+    params: BaseOptionalParams
+  ): Promise<Required<BaseOptionalParams>> {
+    const [marketsInfoResult, uiFeeFactor, gasPrice, gasLimits] = await Promise.all([
+      passThoughOrFetch(
+        {
+          marketsInfoData: params.marketsInfoData,
+          tokensData: params.tokensData,
+        },
+        (input) => Boolean(input.marketsInfoData) && Boolean(input.tokensData),
+        () => sdk.markets.getMarketsInfo()
+      ),
+      passThoughOrFetch(
+        params.uiFeeFactor,
+        (input) => input !== undefined,
+        () => sdk.utils.getUiFeeFactor()
+      ),
+      passThoughOrFetch(
+        params.gasPrice,
+        (input) => input !== undefined,
+        () => sdk.utils.getGasPrice()
+      ),
+      passThoughOrFetch(
+        params.gasLimits,
+        (input) => input !== undefined,
+        () => sdk.utils.getGasLimits()
+      ),
+    ]);
+  
+    if (!marketsInfoResult.marketsInfoData) {
+      throw new Error("Markets info data is not available");
     }
-
-    if (!marketsInfoData) {
-        throw new Error("Markets info data is not available");
+  
+    if (!marketsInfoResult.tokensData) {
+      throw new Error("Tokens data is not available");
     }
-
-    let uiFeeFactor = params.uiFeeFactor;
-    if (!uiFeeFactor) {
-        uiFeeFactor = await sdk.utils.getUiFeeFactor();
+  
+    if (uiFeeFactor === undefined) {
+      throw new Error("Ui fee factor is not available");
     }
-
+  
+    if (gasPrice === undefined) {
+      throw new Error("Gas price is not available");
+    }
+  
+    if (gasLimits === undefined) {
+      throw new Error("Gas limits are not available");
+    }
+  
     return {
-        tokensData,
-        marketsInfoData,
-        uiFeeFactor,
+      tokensData: marketsInfoResult.tokensData,
+      marketsInfoData: marketsInfoResult.marketsInfoData,
+      uiFeeFactor,
+      gasPrice,
+      gasLimits,
     };
-}
-
-export async function increaseOrderHelper(
+  }
+  
+  export async function increaseOrderHelper(
     sdk: GmxSdk,
     params: PositionIncreaseParams & {
-        isLong: boolean;
+      isLong: boolean;
+      stopLossPrice?: bigint;
+      takeProfitPrice?: bigint;
     }
-) {
-    const {tokensData, marketsInfoData, uiFeeFactor} = await getAndValidateBaseParams(sdk, params);
-
+  ) {
+    const { tokensData, marketsInfoData, uiFeeFactor, gasLimits, gasPrice } = await getAndValidateBaseParams(sdk, params);
+  
     const isLimit = Boolean(params.limitPrice);
-
+  
     const fromToken = tokensData[params.payTokenAddress];
     const collateralToken = tokensData[params.collateralTokenAddress];
-
+  
     if (!fromToken) {
-        throw new Error("From token is not available");
+      throw new Error("payTokenAddress: token is not available");
     }
-
+  
     if (!collateralToken) {
-        throw new Error("Collateral token is not available");
+      throw new Error("collateralTokenAddress: token is not available");
     }
-
+  
+    if (fromToken.isSynthetic) {
+      throw new Error("payTokenAddress: synthetic tokens are not supported");
+    }
+  
+    if (collateralToken.isSynthetic) {
+      throw new Error("collateralTokenAddress: synthetic tokens are not supported");
+    }
+  
     const marketInfo = getByKey(marketsInfoData, params.marketAddress);
-
+  
     if (!marketInfo) {
-        throw new Error("Market info is not available");
+      throw new Error("Market info is not available");
     }
-
+  
     const collateralTokenAddress = collateralToken.address;
     const allowedSlippage = params.allowedSlippageBps ?? 100;
-
-    const graph = getMarketsGraph(Object.values(marketsInfoData));
-    const wrappedFromAddress = getWrappedAddress(sdk.chainId, params.payTokenAddress);
-    const wrappedToAddress = getWrappedAddress(sdk.chainId, collateralTokenAddress);
-
-    const allPaths = findAllSwapPaths({
-        chainId: sdk.chainId,
-        fromTokenAddress: params.payTokenAddress,
-        toTokenAddress: collateralTokenAddress,
-        marketsInfoData,
-        graph,
-        wrappedFromAddress,
-        wrappedToAddress,
-    });
-
-    const estimator = createSwapEstimator(marketsInfoData);
-
+  
     const findSwapPath = createFindSwapPath({
-        chainId: sdk.chainId,
-        fromTokenAddress: params.payTokenAddress,
-        toTokenAddress: collateralTokenAddress,
-        marketsInfoData,
-        estimator,
-        allPaths,
-    });
-
-    const payOrSizeAmount = "payAmount" in params ? params.payAmount : params.sizeAmount;
-
-    const increaseAmounts = getIncreasePositionAmounts({
-        marketInfo,
-        indexToken: marketInfo.indexToken,
-        initialCollateralToken: fromToken,
-        collateralToken,
-        isLong: params.isLong,
-        initialCollateralAmount: payOrSizeAmount,
-        position: undefined,
-        indexTokenAmount: payOrSizeAmount,
-        leverage: params.leverage,
-        triggerPrice: params.limitPrice,
-        limitOrderType: params.limitPrice ? OrderType.LimitIncrease : undefined,
-        userReferralInfo: undefined,
-        strategy: "payAmount" in params ? "leverageByCollateral" : "leverageBySize",
-        findSwapPath: findSwapPath,
-        uiFeeFactor,
-        acceptablePriceImpactBuffer: params.acceptablePriceImpactBuffer,
-        fixedAcceptablePriceImpactBps: params.fixedAcceptablePriceImpactBps,
-        externalSwapQuote: undefined,
-    });
-
-    const createSltpEntries: SidecarSlTpOrderEntryValid[] = []
-
-    let stopLossDecreaseAmounts: DecreasePositionAmounts | undefined;
-    if (params.stopLossPrice) {
-        const stopLossCollateralDeltaUsd = convertToUsd(increaseAmounts.collateralDeltaAmount, collateralToken.decimals, params.stopLossPrice);
-
-        // Use a higher acceptable price impact buffer for stop loss orders to ensure execution
-        const stopLossAcceptablePriceImpactBps = params.fixedAcceptablePriceImpactBps ?? 
-            getDefaultAcceptablePriceImpactBps({
-                isIncrease: false,
-                isLong: params.isLong,
-                indexPrice: params.stopLossPrice,
-                sizeDeltaUsd: increaseAmounts.sizeDeltaUsd,
-                priceImpactDeltaUsd: 0n, // We'll calculate this based on current market conditions
-                acceptablePriceImapctBuffer: params.acceptablePriceImpactBuffer ?? 100, // Default 1% buffer for SL orders
-            });
-
-        const acceptablePriceInfo = getAcceptablePriceInfo({
-            marketInfo,
-            isIncrease: false,
-            isLong: params.isLong,
-            indexPrice: params.stopLossPrice,
-            sizeDeltaUsd: increaseAmounts.sizeDeltaUsd,
-            maxNegativePriceImpactBps: stopLossAcceptablePriceImpactBps,
-        });
-
-        // Calculate collateral price based on GMX UI logic
-        const stopLossCollateralPrice = getIsEquivalentTokens(marketInfo.indexToken, collateralToken)
-            ? params.stopLossPrice  // Use trigger price if index token equals collateral token
-            : collateralToken.prices.minPrice; // Otherwise use collateral token's min price
-
-        stopLossDecreaseAmounts = {
-            isFullClose: true,
-            sizeDeltaUsd: increaseAmounts.sizeDeltaUsd,
-            sizeDeltaInTokens: increaseAmounts.sizeDeltaInTokens,
-            collateralDeltaUsd: stopLossCollateralDeltaUsd,
-            collateralDeltaAmount: increaseAmounts.collateralDeltaAmount,
-            indexPrice: params.stopLossPrice,
-            collateralPrice: stopLossCollateralPrice,
-            acceptablePrice: params.isLong ? 0n : ethers.MaxUint256,
-            acceptablePriceDeltaBps: acceptablePriceInfo.acceptablePriceDeltaBps,
-            recommendedAcceptablePriceDeltaBps: 30n,
-            estimatedPnl: 0n,
-            estimatedPnlPercentage: 0n,
-            realizedPnl: 0n,
-            realizedPnlPercentage: 0n,
-            positionFeeUsd: 0n,
-            uiFeeUsd: 0n,
-            swapUiFeeUsd: 0n,
-            feeDiscountUsd: 0n,
-            borrowingFeeUsd: 0n,
-            fundingFeeUsd: 0n,
-            swapProfitFeeUsd: 0n,
-            positionPriceImpactDeltaUsd: 0n,
-            priceImpactDiffUsd: acceptablePriceInfo.priceImpactDeltaUsd,
-            payedRemainingCollateralAmount: 0n,
-            payedOutputUsd: 0n,
-            payedRemainingCollateralUsd: 0n,
-            receiveTokenAmount: 0n,
-            receiveUsd: 0n,
-            decreaseSwapType: DecreasePositionSwapType.SwapPnlTokenToCollateralToken,
-            triggerOrderType: OrderType.StopLossDecrease,
-            triggerPrice: params.stopLossPrice,
-            triggerThresholdType: getOrderThresholdType(OrderType.StopLossDecrease, params.isLong),
-        }
-
-        console.log(stopLossDecreaseAmounts);
-
-        const stopLossEntry: SidecarSlTpOrderEntryValid = {
-            decreaseAmounts: stopLossDecreaseAmounts,
-            id: "sl-order",
-            price: {
-                input: params.stopLossPrice?.toString() ?? "",
-                value: params.stopLossPrice,
-                error: null,
-            } as EntryField,
-            sizeUsd: {
-                input: increaseAmounts.sizeDeltaUsd.toString(),
-                value: increaseAmounts.sizeDeltaUsd,
-                error: null,
-            } as EntryField,
-            percentage: {
-                input: "100",
-                value: 100n,
-                error: null,
-            } as EntryField,
-            txnType: "create",
-            mode: "keepSize",
-            order: null,
-            increaseAmounts: undefined
-        }
-
-        createSltpEntries.push(stopLossEntry)
-    }
-
-    let takeProfitDecreaseAmounts: DecreasePositionAmounts | undefined;
-    if (params.takeProfitPrice) {
-        const takeProfitCollateralDeltaUsd = convertToUsd(increaseAmounts.collateralDeltaAmount, collateralToken.decimals, params.takeProfitPrice);
-
-        // Use a higher acceptable price impact buffer for take profit orders to ensure execution
-        const takeProfitAcceptablePriceImpactBps = params.fixedAcceptablePriceImpactBps ?? 
-            getDefaultAcceptablePriceImpactBps({
-                isIncrease: false,
-                isLong: params.isLong,
-                indexPrice: params.takeProfitPrice,
-                sizeDeltaUsd: increaseAmounts.sizeDeltaUsd,
-                priceImpactDeltaUsd: 0n, // We'll calculate this based on current market conditions
-                acceptablePriceImapctBuffer: params.acceptablePriceImpactBuffer ?? 100, // Default 1% buffer for TP orders
-            });
-
-        const acceptablePriceInfo = getAcceptablePriceInfo({
-            marketInfo,
-            isIncrease: false,
-            isLong: params.isLong,
-            indexPrice: params.takeProfitPrice,
-            sizeDeltaUsd: increaseAmounts.sizeDeltaUsd,
-            maxNegativePriceImpactBps: takeProfitAcceptablePriceImpactBps,
-        });
-
-        // Calculate collateral price based on GMX UI logic
-        const takeProfitCollateralPrice = getIsEquivalentTokens(marketInfo.indexToken, collateralToken)
-            ? params.takeProfitPrice  // Use trigger price if index token equals collateral token
-            : collateralToken.prices.minPrice; // Otherwise use collateral token's min price
-
-        takeProfitDecreaseAmounts = {
-            isFullClose: true,
-            sizeDeltaUsd: increaseAmounts.sizeDeltaUsd,
-            sizeDeltaInTokens: increaseAmounts.sizeDeltaInTokens,
-            collateralDeltaUsd: takeProfitCollateralDeltaUsd,
-            collateralDeltaAmount: increaseAmounts.collateralDeltaAmount,
-            indexPrice: params.takeProfitPrice, // Keep original trigger price for indexPrice
-            collateralPrice: takeProfitCollateralPrice,
-            acceptablePrice: acceptablePriceInfo.acceptablePrice,
-            acceptablePriceDeltaBps: acceptablePriceInfo.acceptablePriceDeltaBps, // Add 0.5% buffer to acceptable price impact
-            recommendedAcceptablePriceDeltaBps: 30n, // Set recommended buffer to 0.5%
-            estimatedPnl: 0n,
-            estimatedPnlPercentage: 0n,
-            realizedPnl: 0n,
-            realizedPnlPercentage: 0n,
-            positionFeeUsd: 0n,
-            uiFeeUsd: 0n,
-            swapUiFeeUsd: 0n,
-            feeDiscountUsd: 0n,
-            borrowingFeeUsd: 0n,
-            fundingFeeUsd: 0n,
-            swapProfitFeeUsd: 0n,
-            positionPriceImpactDeltaUsd: 0n,
-            priceImpactDiffUsd: acceptablePriceInfo.priceImpactDeltaUsd,
-            payedRemainingCollateralAmount: 0n,
-            payedOutputUsd: 0n,
-            payedRemainingCollateralUsd: 0n,
-            receiveTokenAmount: 0n,
-            receiveUsd: 0n,
-            decreaseSwapType: DecreasePositionSwapType.SwapPnlTokenToCollateralToken,
-            triggerOrderType: OrderType.LimitDecrease,
-            triggerPrice: params.takeProfitPrice,
-            triggerThresholdType: getOrderThresholdType(OrderType.LimitDecrease, params.isLong),
-        }
-
-        const takeProfitEntry: SidecarSlTpOrderEntryValid = {
-            decreaseAmounts: takeProfitDecreaseAmounts,
-            id: "tp-order",
-            price: {
-                input: params.takeProfitPrice?.toString() ?? "",
-                value: params.takeProfitPrice,
-                error: null,
-            } as EntryField,
-            sizeUsd: {
-                input: increaseAmounts.sizeDeltaUsd.toString(),
-                value: increaseAmounts.sizeDeltaUsd,
-                error: null,
-            } as EntryField,
-            percentage: {
-                input: "100",
-                value: 100n,
-                error: null,
-            } as EntryField,
-            txnType: "create",
-            mode: "keepSize",
-            order: null,
-            increaseAmounts: undefined
-        }
-
-        createSltpEntries.push(takeProfitEntry)
-    }
-
-    const createIncreaseOrderParams: Parameters<typeof sdk.orders.createIncreaseOrder>[0] = {
-        marketsInfoData,
+      chainId: sdk.chainId,
+      fromTokenAddress: params.payTokenAddress,
+      toTokenAddress: collateralTokenAddress,
+      marketsInfoData,
+      gasEstimationParams: {
+        gasLimits,
+        gasPrice,
         tokensData,
-        isLimit,
-        marketAddress: params.marketAddress,
-        fromToken: tokensData[params.payTokenAddress],
-        allowedSlippage,
-        collateralToken,
-        referralCodeForTxn: params.referralCodeForTxn,
-        triggerPrice: params.limitPrice,
-        collateralTokenAddress: collateralToken.address,
-        isLong: params.isLong,
-        receiveTokenAddress: collateralTokenAddress,
-        indexToken: marketInfo.indexToken,
-        marketInfo,
-        skipSimulation: params.skipSimulation,
-        increaseAmounts,
-        createSltpEntries: createSltpEntries.length > 0 ? createSltpEntries : undefined,
+      },
+      isExpressFeeSwap: false,
+    });
+  
+    const payOrSizeAmount = "payAmount" in params ? params.payAmount : params.sizeAmount;
+  
+    const increaseAmounts = getIncreasePositionAmounts({
+      marketInfo,
+      indexToken: marketInfo.indexToken,
+      initialCollateralToken: fromToken,
+      collateralToken,
+      isLong: params.isLong,
+      initialCollateralAmount: payOrSizeAmount,
+      position: undefined,
+      indexTokenAmount: payOrSizeAmount,
+      leverage: params.leverage,
+      triggerPrice: params.limitPrice,
+      limitOrderType: params.limitPrice ? OrderType.LimitIncrease : undefined,
+      userReferralInfo: undefined,
+      strategy: "payAmount" in params ? "leverageByCollateral" : "leverageBySize",
+      findSwapPath: findSwapPath,
+      uiFeeFactor,
+      acceptablePriceImpactBuffer: params.acceptablePriceImpactBuffer,
+      fixedAcceptablePriceImpactBps: params.fixedAcceptablePriceImpactBps,
+      externalSwapQuote: undefined,
+      marketsInfoData,
+      chainId: sdk.chainId,
+      externalSwapQuoteParams: undefined,
+    });
+
+
+  const createSltpEntries: SidecarSlTpOrderEntryValid[] = []
+
+  let stopLossDecreaseAmounts: DecreasePositionAmounts | undefined;
+  if (params.stopLossPrice) {
+      const stopLossCollateralDeltaUsd = convertToUsd(increaseAmounts.collateralDeltaAmount, collateralToken.decimals, params.stopLossPrice);
+
+      // Use a higher acceptable price impact buffer for stop loss orders to ensure execution
+      const stopLossAcceptablePriceImpactBps = params.fixedAcceptablePriceImpactBps ?? 
+          getDefaultAcceptablePriceImpactBps({
+              isIncrease: false,
+              isLong: params.isLong,
+              indexPrice: params.stopLossPrice,
+              sizeDeltaUsd: increaseAmounts.sizeDeltaUsd,
+              priceImpactDeltaUsd: 0n, // We'll calculate this based on current market conditions
+              acceptablePriceImapctBuffer: params.acceptablePriceImpactBuffer ?? 100, // Default 1% buffer for SL orders
+          });
+
+      const acceptablePriceInfo = getAcceptablePriceInfo({
+          marketInfo,
+          isIncrease: false,
+          isLong: params.isLong,
+          indexPrice: params.stopLossPrice,
+          sizeDeltaUsd: increaseAmounts.sizeDeltaUsd,
+          maxNegativePriceImpactBps: stopLossAcceptablePriceImpactBps,
+          isLimit: false,
+      });
+
+      // Calculate collateral price based on GMX UI logic
+      const stopLossCollateralPrice = getIsEquivalentTokens(marketInfo.indexToken, collateralToken)
+          ? params.stopLossPrice  // Use trigger price if index token equals collateral token
+          : collateralToken.prices.minPrice; // Otherwise use collateral token's min price
+
+      stopLossDecreaseAmounts = {
+          isFullClose: true,
+          sizeDeltaUsd: increaseAmounts.sizeDeltaUsd,
+          sizeDeltaInTokens: increaseAmounts.sizeDeltaInTokens,
+          collateralDeltaUsd: stopLossCollateralDeltaUsd,
+          collateralDeltaAmount: increaseAmounts.collateralDeltaAmount,
+          indexPrice: params.stopLossPrice,
+          collateralPrice: stopLossCollateralPrice,
+          acceptablePrice: params.isLong ? 0n : ethers.MaxUint256,
+          acceptablePriceDeltaBps: acceptablePriceInfo.acceptablePriceDeltaBps,
+          recommendedAcceptablePriceDeltaBps: 30n,
+          estimatedPnl: 0n,
+          estimatedPnlPercentage: 0n,
+          realizedPnl: 0n,
+          realizedPnlPercentage: 0n,
+          positionFeeUsd: 0n,
+          uiFeeUsd: 0n,
+          swapUiFeeUsd: 0n,
+          feeDiscountUsd: 0n,
+          borrowingFeeUsd: 0n,
+          fundingFeeUsd: 0n,
+          swapProfitFeeUsd: 0n,
+          priceImpactDiffUsd: acceptablePriceInfo.priceImpactDeltaUsd,
+          proportionalPendingImpactDeltaUsd: 0n,
+          closePriceImpactDeltaUsd: 0n,
+          totalPendingImpactDeltaUsd: 0n,
+          balanceWasImproved: false,
+          payedRemainingCollateralAmount: 0n,
+          payedOutputUsd: 0n,
+          payedRemainingCollateralUsd: 0n,
+          receiveTokenAmount: 0n,
+          receiveUsd: 0n,
+          decreaseSwapType: DecreasePositionSwapType.SwapPnlTokenToCollateralToken,
+          triggerOrderType: OrderType.StopLossDecrease,
+          triggerPrice: params.stopLossPrice,
+          triggerThresholdType: getOrderThresholdType(OrderType.StopLossDecrease, params.isLong),
+      }
+
+      console.log(stopLossDecreaseAmounts);
+
+      const stopLossEntry: SidecarSlTpOrderEntryValid = {
+          decreaseAmounts: stopLossDecreaseAmounts,
+          id: "sl-order",
+          price: {
+              input: params.stopLossPrice?.toString() ?? "",
+              value: params.stopLossPrice,
+              error: null,
+          } as EntryField,
+          sizeUsd: {
+              input: increaseAmounts.sizeDeltaUsd.toString(),
+              value: increaseAmounts.sizeDeltaUsd,
+              error: null,
+          } as EntryField,
+          percentage: {
+              input: "100",
+              value: 100n,
+              error: null,
+          } as EntryField,
+          txnType: "create",
+          mode: "keepSize",
+          order: null,
+          increaseAmounts: undefined
+      }
+
+      createSltpEntries.push(stopLossEntry)
+  }
+
+  let takeProfitDecreaseAmounts: DecreasePositionAmounts | undefined;
+  if (params.takeProfitPrice) {
+      const takeProfitCollateralDeltaUsd = convertToUsd(increaseAmounts.collateralDeltaAmount, collateralToken.decimals, params.takeProfitPrice);
+
+      // Use a higher acceptable price impact buffer for take profit orders to ensure execution
+      const takeProfitAcceptablePriceImpactBps = params.fixedAcceptablePriceImpactBps ?? 
+          getDefaultAcceptablePriceImpactBps({
+              isIncrease: false,
+              isLong: params.isLong,
+              indexPrice: params.takeProfitPrice,
+              sizeDeltaUsd: increaseAmounts.sizeDeltaUsd,
+              priceImpactDeltaUsd: 0n, // We'll calculate this based on current market conditions
+              acceptablePriceImapctBuffer: params.acceptablePriceImpactBuffer ?? 100, // Default 1% buffer for TP orders
+          });
+
+      const acceptablePriceInfo = getAcceptablePriceInfo({
+          marketInfo,
+          isIncrease: false,
+          isLong: params.isLong,
+          indexPrice: params.takeProfitPrice,
+          sizeDeltaUsd: increaseAmounts.sizeDeltaUsd,
+          maxNegativePriceImpactBps: takeProfitAcceptablePriceImpactBps,
+          isLimit: false,
+      });
+
+      // Calculate collateral price based on GMX UI logic
+      const takeProfitCollateralPrice = getIsEquivalentTokens(marketInfo.indexToken, collateralToken)
+          ? params.takeProfitPrice  // Use trigger price if index token equals collateral token
+          : collateralToken.prices.minPrice; // Otherwise use collateral token's min price
+
+      takeProfitDecreaseAmounts = {
+          isFullClose: true,
+          sizeDeltaUsd: increaseAmounts.sizeDeltaUsd,
+          sizeDeltaInTokens: increaseAmounts.sizeDeltaInTokens,
+          collateralDeltaUsd: takeProfitCollateralDeltaUsd,
+          collateralDeltaAmount: increaseAmounts.collateralDeltaAmount,
+          indexPrice: params.takeProfitPrice, // Keep original trigger price for indexPrice
+          collateralPrice: takeProfitCollateralPrice,
+          acceptablePrice: acceptablePriceInfo.acceptablePrice,
+          acceptablePriceDeltaBps: acceptablePriceInfo.acceptablePriceDeltaBps, // Add 0.5% buffer to acceptable price impact
+          recommendedAcceptablePriceDeltaBps: 30n, // Set recommended buffer to 0.5%
+          estimatedPnl: 0n,
+          estimatedPnlPercentage: 0n,
+          realizedPnl: 0n,
+          realizedPnlPercentage: 0n,
+          positionFeeUsd: 0n,
+          uiFeeUsd: 0n,
+          swapUiFeeUsd: 0n,
+          feeDiscountUsd: 0n,
+          borrowingFeeUsd: 0n,
+          fundingFeeUsd: 0n,
+          swapProfitFeeUsd: 0n,
+          proportionalPendingImpactDeltaUsd: 0n,
+          closePriceImpactDeltaUsd: 0n,
+          totalPendingImpactDeltaUsd: 0n,
+          balanceWasImproved: false,
+          priceImpactDiffUsd: acceptablePriceInfo.priceImpactDeltaUsd,
+          payedRemainingCollateralAmount: 0n,
+          payedOutputUsd: 0n,
+          payedRemainingCollateralUsd: 0n,
+          receiveTokenAmount: 0n,
+          receiveUsd: 0n,
+          decreaseSwapType: DecreasePositionSwapType.SwapPnlTokenToCollateralToken,
+          triggerOrderType: OrderType.LimitDecrease,
+          triggerPrice: params.takeProfitPrice,
+          triggerThresholdType: getOrderThresholdType(OrderType.LimitDecrease, params.isLong),
+      }
+
+      const takeProfitEntry: SidecarSlTpOrderEntryValid = {
+          decreaseAmounts: takeProfitDecreaseAmounts,
+          id: "tp-order",
+          price: {
+              input: params.takeProfitPrice?.toString() ?? "",
+              value: params.takeProfitPrice,
+              error: null,
+          } as EntryField,
+          sizeUsd: {
+              input: increaseAmounts.sizeDeltaUsd.toString(),
+              value: increaseAmounts.sizeDeltaUsd,
+              error: null,
+          } as EntryField,
+          percentage: {
+              input: "100",
+              value: 100n,
+              error: null,
+          } as EntryField,
+          txnType: "create",
+          mode: "keepSize",
+          order: null,
+          increaseAmounts: undefined
+      }
+
+      createSltpEntries.push(takeProfitEntry)
+  }
+  
+    const createIncreaseOrderParams: Parameters<typeof sdk.orders.createIncreaseOrder>[0] = {
+      marketsInfoData,
+      tokensData,
+      isLimit,
+      marketAddress: params.marketAddress,
+      fromToken: tokensData[params.payTokenAddress],
+      allowedSlippage,
+      collateralToken,
+      referralCodeForTxn: params.referralCodeForTxn,
+      triggerPrice: params.limitPrice,
+      collateralTokenAddress: collateralToken.address,
+      isLong: params.isLong,
+      receiveTokenAddress: collateralTokenAddress,
+      indexToken: marketInfo.indexToken,
+      marketInfo,
+      skipSimulation: params.skipSimulation,
+      increaseAmounts,
+      createSltpEntries: createSltpEntries,
     };
-
+  
     return sdk.orders.createIncreaseOrder(createIncreaseOrderParams);
-}
-
-function getTriggerRatio({
-                             toToken,
-                             fromToken,
-                             triggerPrice,
-                         }: {
+  }
+  
+  function getTriggerRatio({
+    toToken,
+    fromToken,
+    triggerPrice,
+  }: {
     toToken: TokenData;
     fromToken: TokenData;
     triggerPrice: bigint;
-}) {
+  }) {
     const fromTokenPrice = fromToken?.prices.minPrice;
     const markPrice = toToken.prices.minPrice;
-
+  
     const markRatio = getTokensRatioByPrice({
-        fromToken,
-        toToken,
-        fromPrice: fromTokenPrice,
-        toPrice: markPrice,
+      fromToken,
+      toToken,
+      fromPrice: fromTokenPrice,
+      toPrice: markPrice,
     });
-
+  
     const triggerRatio: TokensRatio = {
-        ratio: triggerPrice > 0 ? triggerPrice : markRatio.ratio,
-        largestToken: markRatio.largestToken,
-        smallestToken: markRatio.smallestToken,
+      ratio: triggerPrice > 0 ? triggerPrice : markRatio.ratio,
+      largestToken: markRatio.largestToken,
+      smallestToken: markRatio.smallestToken,
     };
-
+  
     return triggerRatio;
-}
-
-export type SwapParams = (
+  }
+  
+  export type SwapParams = (
     | {
-    fromAmount: bigint;
-}
+        fromAmount: bigint;
+      }
     | {
-    toAmount: bigint;
-}
-    ) & {
+        toAmount: bigint;
+      }
+  ) & {
     fromTokenAddress: string;
     toTokenAddress: string;
     allowedSlippageBps?: number;
     referralCodeForTxn?: string;
-
+  
     /** If presented, then it's limit swap order */
     triggerPrice?: bigint;
-} & BaseOptionalParams;
-
-export async function swap(sdk: GmxSdk, params: SwapParams) {
-    const {tokensData, marketsInfoData, uiFeeFactor} = await getAndValidateBaseParams(sdk, params);
-
+  } & BaseOptionalParams;
+  
+  export async function swap(sdk: GmxSdk, params: SwapParams) {
+    const { tokensData, marketsInfoData, uiFeeFactor, gasLimits, gasPrice } = await getAndValidateBaseParams(sdk, params);
+  
     const fromToken = tokensData[params.fromTokenAddress];
     const toToken = tokensData[params.toTokenAddress];
-
+  
     if (!fromToken || !toToken) {
-        throw new Error("From or to token is not available");
+      throw new Error("From or to token is not available");
     }
-
+  
+    if (toToken.isSynthetic) {
+      throw new Error(`Synthetic tokens are not supported: ${toToken.symbol}`);
+    }
+  
+    if (fromToken.isSynthetic) {
+      throw new Error(`Synthetic tokens are not supported: ${fromToken.symbol}`);
+    }
+  
     const isLimit = Boolean(params.triggerPrice);
-
+  
     if (!fromToken || !toToken) {
-        return undefined;
+      return undefined;
     }
-
-    const graph = getMarketsGraph(Object.values(marketsInfoData));
-    const wrappedFromAddress = getWrappedAddress(sdk.chainId, params.fromTokenAddress);
-    const wrappedToAddress = getWrappedAddress(sdk.chainId, params.toTokenAddress);
-
-    const allPaths = findAllSwapPaths({
-        chainId: sdk.chainId,
-        fromTokenAddress: params.fromTokenAddress,
-        toTokenAddress: params.toTokenAddress,
-        marketsInfoData,
-        graph,
-        wrappedFromAddress,
-        wrappedToAddress,
-    });
-
-
-    const estimator = createSwapEstimator(marketsInfoData);
-
+  
     const findSwapPath = createFindSwapPath({
-        chainId: sdk.chainId,
-        fromTokenAddress: params.fromTokenAddress,
-        toTokenAddress: params.toTokenAddress,
-        marketsInfoData,
-        estimator,
-        allPaths,
-    });
-
-    const isWrapOrUnwrap = Boolean(
-        fromToken && toToken && (getIsWrap(fromToken, toToken) || getIsUnwrap(fromToken, toToken))
-    );
-
-
-    const swapOptimizationOrder: Parameters<FindSwapPath>[1]["order"] = isLimit ? ["length", "liquidity"] : undefined;
-
-    let swapAmounts: SwapAmounts | undefined;
-
-    const fromTokenPrice = fromToken.prices.minPrice;
-    const triggerRatio = params.triggerPrice
-        ? getTriggerRatio({
-            fromToken,
-            toToken,
-            triggerPrice: params.triggerPrice,
-        })
-        : undefined;
-
-    if (isWrapOrUnwrap) {
-        const tokenAmount = "fromAmount" in params ? params.fromAmount : params.toAmount;
-        const usdAmount = convertToUsd(tokenAmount, fromToken.decimals, fromTokenPrice)!;
-        const price = fromTokenPrice;
-
-        swapAmounts = {
-            amountIn: tokenAmount,
-            usdIn: usdAmount!,
-            amountOut: tokenAmount,
-            usdOut: usdAmount!,
-            swapPathStats: undefined,
-            priceIn: price,
-            priceOut: price,
-            minOutputAmount: tokenAmount,
-        };
-
-        return swapAmounts;
-    } else if ("fromAmount" in params) {
-        swapAmounts = getSwapAmountsByFromValue({
-            tokenIn: fromToken,
-            tokenOut: toToken,
-            amountIn: params.fromAmount,
-            triggerRatio,
-            isLimit,
-            findSwapPath: findSwapPath,
-            uiFeeFactor,
-            swapOptimizationOrder,
-            allowedSwapSlippageBps: isLimit ? BigInt(params.allowedSlippageBps ?? 100) : undefined,
-        });
-    } else {
-        swapAmounts = getSwapAmountsByToValue({
-            tokenIn: fromToken,
-            tokenOut: toToken,
-            amountOut: params.toAmount,
-            triggerRatio,
-            isLimit: isLimit,
-            findSwapPath: findSwapPath,
-            uiFeeFactor,
-            swapOptimizationOrder,
-            allowedSwapSlippageBps: isLimit ? BigInt(params.allowedSlippageBps ?? 100) : undefined,
-        });
-    }
-
-    if (!swapAmounts) {
-        return undefined;
-    }
-
-    const createSwapOrderParams: Parameters<typeof sdk.orders.createSwapOrder>[0] = {
+      chainId: sdk.chainId,
+      fromTokenAddress: params.fromTokenAddress,
+      toTokenAddress: params.toTokenAddress,
+      marketsInfoData,
+      gasEstimationParams: {
+        gasLimits,
+        gasPrice,
         tokensData,
-        fromToken: tokensData[params.fromTokenAddress],
-        toToken: tokensData[params.toTokenAddress],
-        swapAmounts,
+      },
+      isExpressFeeSwap: false,
+    });
+  
+    const isWrapOrUnwrap = Boolean(
+      fromToken && toToken && (getIsWrap(fromToken, toToken) || getIsUnwrap(fromToken, toToken))
+    );
+  
+    if (isWrapOrUnwrap) {
+      const fromTokenPrice = fromToken.prices.minPrice;
+      const tokenAmount = "fromAmount" in params ? params.fromAmount : params.toAmount;
+      const usdAmount = convertToUsd(tokenAmount, fromToken.decimals, fromTokenPrice)!;
+      const price = fromTokenPrice;
+  
+      return {
+        amountIn: tokenAmount,
+        usdIn: usdAmount!,
+        amountOut: tokenAmount,
+        usdOut: usdAmount!,
+        swapPathStats: undefined,
+        priceIn: price,
+        priceOut: price,
+        minOutputAmount: tokenAmount,
+      };
+    }
+  
+    const swapOptimizationOrder: SwapOptimizationOrderArray | undefined = isLimit ? ["length", "liquidity"] : undefined;
+  
+    let swapAmounts: SwapAmounts | undefined;
+  
+    const triggerRatio = params.triggerPrice
+      ? getTriggerRatio({
+          fromToken,
+          toToken,
+          triggerPrice: params.triggerPrice,
+        })
+      : undefined;
+  
+    if ("fromAmount" in params) {
+      swapAmounts = getSwapAmountsByFromValue({
+        tokenIn: fromToken,
+        tokenOut: toToken,
+        amountIn: params.fromAmount,
+        triggerRatio,
         isLimit,
-        allowedSlippage: params.allowedSlippageBps ?? 100,
-        referralCodeForTxn: params.referralCodeForTxn,
-        triggerPrice: params.triggerPrice,
-        skipSimulation: params.skipSimulation,
+        findSwapPath: findSwapPath,
+        uiFeeFactor,
+        swapOptimizationOrder,
+        allowedSwapSlippageBps: isLimit ? BigInt(params.allowedSlippageBps ?? 100) : undefined,
+        marketsInfoData,
+        chainId: sdk.chainId,
+        externalSwapQuoteParams: undefined,
+      });
+    } else {
+      swapAmounts = getSwapAmountsByToValue({
+        tokenIn: fromToken,
+        tokenOut: toToken,
+        amountOut: params.toAmount,
+        triggerRatio,
+        isLimit: isLimit,
+        findSwapPath: findSwapPath,
+        uiFeeFactor,
+        swapOptimizationOrder,
+        allowedSwapSlippageBps: isLimit ? BigInt(params.allowedSlippageBps ?? 100) : undefined,
+        marketsInfoData,
+        chainId: sdk.chainId,
+        externalSwapQuoteParams: undefined,
+      });
+    }
+  
+    if (!swapAmounts) {
+      return undefined;
+    }
+  
+    const createSwapOrderParams: Parameters<typeof sdk.orders.createSwapOrder>[0] = {
+      tokensData,
+      fromToken: tokensData[params.fromTokenAddress],
+      toToken: tokensData[params.toTokenAddress],
+      swapAmounts,
+      isLimit,
+      allowedSlippage: params.allowedSlippageBps ?? 100,
+      referralCodeForTxn: params.referralCodeForTxn,
+      triggerPrice: params.triggerPrice,
     };
-
+  
     return sdk.orders.createSwapOrder(createSwapOrderParams);
-}
+  }
+  
\ No newline at end of file
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/orders.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/orders.ts
index e5df4248..fd5fc5cc 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/orders.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/orders.ts
@@ -220,6 +220,8 @@ export class Orders extends Module {
       indexToken,
     };
 
+    const swapPath = increaseAmounts.swapStrategy.swapPathStats?.swapPath || [];
+
     return createIncreaseOrderTxn({
       sdk: this.sdk,
       createIncreaseOrderParams: {
@@ -229,7 +231,7 @@ export class Orders extends Module {
         initialCollateralAmount: increaseAmounts.initialCollateralAmount,
         targetCollateralAddress: collateralToken.address,
         collateralDeltaAmount: increaseAmounts.collateralDeltaAmount,
-        swapPath: increaseAmounts.swapPathStats?.swapPath || [],
+        swapPath: swapPath,
         sizeDeltaUsd: increaseAmounts.sizeDeltaUsd,
         sizeDeltaInTokens: increaseAmounts.sizeDeltaInTokens,
         triggerPrice: isLimit ? triggerPrice : undefined,
@@ -375,7 +377,6 @@ export class Orders extends Module {
     referralCodeForTxn,
     tokensData,
     triggerPrice,
-    skipSimulation,
   }: {
     isLimit: boolean;
     allowedSlippage: number;
@@ -385,7 +386,6 @@ export class Orders extends Module {
     toToken: TokenData;
     tokensData: TokensData;
     triggerPrice?: bigint;
-    skipSimulation?: boolean;
   }) {
     const orderType = isLimit ? OrderType.LimitSwap : OrderType.MarketSwap;
 
@@ -393,19 +393,14 @@ export class Orders extends Module {
       swapAmounts,
     });
 
-    if (!swapAmounts?.swapPathStats || !executionFee) {
+    if (!swapAmounts?.swapStrategy.swapPathStats || !executionFee) {
       throw new Error("Swap data is not defined");
     }
 
-    // Validate that swapPathStats has a valid swapPath array
-    if (!swapAmounts.swapPathStats.swapPath || !Array.isArray(swapAmounts.swapPathStats.swapPath)) {
-      throw new Error("Invalid swap path: swapPath is not a valid array");
-    }
-
     return createSwapOrderTxn(this.sdk, {
       fromTokenAddress: fromToken.address,
       fromTokenAmount: swapAmounts.amountIn,
-      swapPath: swapAmounts.swapPathStats.swapPath,
+      swapPath: swapAmounts.swapStrategy.swapPathStats?.swapPath,
       toTokenAddress: toToken.address,
       orderType,
       minOutputAmount: swapAmounts.minOutputAmount,
@@ -414,7 +409,6 @@ export class Orders extends Module {
       allowedSlippage,
       tokensData,
       triggerPrice: isLimit && triggerPrice !== undefined ? triggerPrice : undefined,
-      skipSimulation: skipSimulation,
     });
   }
 
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/transactions/createDecreaseOrderTxn.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/transactions/createDecreaseOrderTxn.ts
index ed367928..5e282c3f 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/transactions/createDecreaseOrderTxn.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/transactions/createDecreaseOrderTxn.ts
@@ -113,7 +113,7 @@ export function createDecreaseEncodedPayload({
           initialCollateralToken: initialCollateralTokenAddress,
           callbackContract: zeroAddress,
           market: p.marketAddress,
-          swapPath: p.swapPath,
+          swapPath: p.swapPath || [],
           uiFeeReceiver: process.env.GMX_UI_FEE_RECEIVER,
         },
         numbers: {
@@ -132,6 +132,7 @@ export function createDecreaseEncodedPayload({
         shouldUnwrapNativeToken: isNativeReceive,
         autoCancel: p.autoCancel,
         referralCode: p.referralCode || zeroHash,
+        dataList: [],
       };
 
       return [
@@ -144,11 +145,15 @@ export function createDecreaseEncodedPayload({
     }),
   ];
 
-  return multicall.filter(Boolean).map((call) =>
-    encodeFunctionData({
+  return multicall.filter(Boolean).map((call) => {
+    // Ensure params is always an array
+    const params = Array.isArray(call!.params) ? call!.params : [];
+    console.log(`Encoding ${call!.method} with params:`, params);
+    
+    return encodeFunctionData({
       abi: abis.ExchangeRouter as Abi,
-      functionName: call!.method,
-      args: call!.params as any,
-    })
-  );
+      functionName: call!.method as any,
+      args: params as any,
+    });
+  });
 }
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/transactions/createIncreaseOrderTxn.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/transactions/createIncreaseOrderTxn.ts
index ceaba01c..a99aea36 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/transactions/createIncreaseOrderTxn.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/transactions/createIncreaseOrderTxn.ts
@@ -113,6 +113,7 @@ export async function createIncreaseOrderTxn({
     acceptablePrice,
     isNativePayment,
     initialCollateralTokenAddress,
+    uiFeeReceiver: sdk.config.settings?.uiFeeReceiverAccount,
   });
 
   const simulationEncodedPayload = await createEncodedPayload({
@@ -123,6 +124,7 @@ export async function createIncreaseOrderTxn({
     acceptablePrice,
     isNativePayment,
     initialCollateralTokenAddress,
+    uiFeeReceiver: sdk.config.settings?.uiFeeReceiverAccount,
   });
 
   const decreaseEncodedPayload = createDecreaseEncodedPayload({
@@ -189,6 +191,7 @@ async function createEncodedPayload({
   acceptablePrice,
   isNativePayment,
   initialCollateralTokenAddress,
+  uiFeeReceiver,
 }: {
   routerAbi: Abi;
   orderVaultAddress: string;
@@ -197,13 +200,16 @@ async function createEncodedPayload({
   acceptablePrice: bigint;
   isNativePayment: boolean;
   initialCollateralTokenAddress: string;
+  uiFeeReceiver: string | undefined;
 }) {
   const orderParams = createOrderParams({
     p,
     acceptablePrice,
     initialCollateralTokenAddress,
     isNativePayment,
+    uiFeeReceiver,
   });
+  
   const multicall = [
     { method: "sendWnt", params: [orderVaultAddress, totalWntAmount] },
 
@@ -216,13 +222,17 @@ async function createEncodedPayload({
       params: [orderParams],
     },
   ];
-  return multicall.filter(Boolean).map((call) =>
-    encodeFunctionData({
+  const validCalls = multicall.filter(Boolean) as Array<{ method: string; params: any[] }>;
+  return validCalls.map((call) => {
+    // Ensure params is always an array
+    const params = Array.isArray(call.params) ? call.params : [];
+    console.log(`Encoding ${call.method} with params:`, params);
+    return encodeFunctionData({
       abi: routerAbi,
-      functionName: call!.method,
-      args: call!.params as any,
-    })
-  );
+      functionName: call.method as any,
+      args: params,
+    });
+  });
 }
 
 function createOrderParams({
@@ -230,11 +240,13 @@ function createOrderParams({
   acceptablePrice,
   initialCollateralTokenAddress,
   isNativePayment,
+  uiFeeReceiver,
 }: {
   p: IncreaseOrderParams;
   acceptablePrice: bigint;
   initialCollateralTokenAddress: string;
   isNativePayment: boolean;
+  uiFeeReceiver: string | undefined;
 }) {
   return {
     addresses: {
@@ -243,8 +255,8 @@ function createOrderParams({
       initialCollateralToken: initialCollateralTokenAddress,
       callbackContract: zeroAddress,
       market: p.marketAddress,
-      swapPath: p.swapPath,
-      uiFeeReceiver: process.env.GMX_UI_FEE_RECEIVER,
+      swapPath: p.swapPath || [],
+      uiFeeReceiver: uiFeeReceiver || zeroAddress,
     },
     numbers: {
       sizeDeltaUsd: p.sizeDeltaUsd,
@@ -262,6 +274,7 @@ function createOrderParams({
     shouldUnwrapNativeToken: isNativePayment,
     autoCancel: false,
     referralCode: p.referralCode || zeroHash,
+    dataList: [],
   };
 }
 
@@ -275,6 +288,7 @@ export function getPendingOrderFromParams(
   const shouldApplySlippage = isMarketOrderType(p.orderType);
   let minOutputAmount = 0n;
   if ("minOutputUsd" in p) {
+    // eslint-disable-next-line
     shouldApplySlippage ? applySlippageToMinOut(p.allowedSlippage, p.minOutputUsd) : p.minOutputUsd;
   }
   if ("minOutputAmount" in p) {
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/transactions/createSwapOrderTxn.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/transactions/createSwapOrderTxn.ts
index dcb13eb2..c794680c 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/transactions/createSwapOrderTxn.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/transactions/createSwapOrderTxn.ts
@@ -32,6 +32,7 @@ export async function createSwapOrderTxn(sdk: GmxSdk, p: SwapOrderParams) {
   const { encodedPayload, totalWntAmount } = await getParams(sdk, p);
   const { encodedPayload: simulationEncodedPayload, totalWntAmount: sumaltionTotalWntAmount } = await getParams(sdk, p);
 
+  p.skipSimulation = true;
   if (p.orderType !== OrderType.LimitSwap && !p.skipSimulation) {
     await simulateExecuteOrder(sdk, {
       primaryPriceOverrides: {},
@@ -41,6 +42,7 @@ export async function createSwapOrderTxn(sdk: GmxSdk, p: SwapOrderParams) {
     });
   }
 
+
   await sdk.callContract(
     getContract(sdk.chainId, "ExchangeRouter"),
     abis.ExchangeRouter as Abi,
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/utils.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/utils.ts
index 162de0af..0612f10e 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/utils.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/orders/utils.ts
@@ -1,19 +1,28 @@
-
-import { Address, isAddressEqual } from "viem";
-import { GmxSdk } from "../../index.js";
-import { accountOrderListKey } from "../../configs/dataStore.js";
-import { getWrappedToken } from "../../configs/tokens.js";
-import { GasLimitsConfig } from "../../types/fees.js";
-import { MarketsInfoData } from "../../types/markets.js";
-import { DecreasePositionSwapType, Order, OrderType } from "../../types/orders.js";
-import { SidecarSlTpOrderEntry, SidecarLimitOrderEntry } from "../../types/sidecarOrders";
-import { TokensData } from "../../types/tokens.js";
-import { estimateExecuteDecreaseOrderGasLimit, estimateOrderOraclePriceCount, getExecutionFee } from "../../utils/fees/index.js";
-import { isSwapOrderType, isLimitOrderType, isIncreaseOrderType, isTriggerDecreaseOrderType } from "../../utils/orders.js";
-import { getSwapPathOutputAddresses } from "../../utils/swap/index.js";
-import { MarketFilterLongShortItemData, MarketFilterLongShortDirection } from "../trades/trades.js";
-import { MulticallRequestConfig, MulticallResult } from "../../utils/multicall.js";
-import { getContract } from "../../configs/contracts.js";
+import {Address, isAddressEqual} from "viem";
+import {GmxSdk} from "../../index.js";
+import {accountOrderListKey} from "../../configs/dataStore.js";
+import {getWrappedToken} from "../../configs/tokens.js";
+import {GasLimitsConfig} from "../../types/fees.js";
+import {MarketsInfoData} from "../../types/markets.js";
+import {DecreasePositionSwapType, Order, OrderType} from "../../types/orders.js";
+import {SidecarLimitOrderEntry, SidecarSlTpOrderEntry} from "../../types/sidecarOrders";
+import {TokensData} from "../../types/tokens.js";
+import {
+    estimateExecuteDecreaseOrderGasLimit,
+    estimateOrderOraclePriceCount,
+    getExecutionFee
+} from "../../utils/fees/index.js";
+import {
+    isIncreaseOrderType,
+    isLimitOrderType,
+    isSwapOrderType,
+    isTriggerDecreaseOrderType
+} from "../../utils/orders.js";
+import {getSwapPathOutputAddresses} from "../../utils/swap/index.js";
+import {MarketFilterLongShortDirection, MarketFilterLongShortItemData} from "../trades/trades.js";
+import {MulticallRequestConfig, MulticallResult} from "../../utils/multicall.js";
+import {getContract} from "../../configs/contracts.js";
+import {ContractsChainId} from "../../configs/chains.js";
 
 export const getOrderExecutionFee = (
   sdk: GmxSdk,
@@ -152,7 +161,7 @@ export function matchByMarket({
 
 export const DEFAULT_COUNT = 1000;
 
-export function buildGetOrdersMulticall(chainId: number, account: string) {
+export function buildGetOrdersMulticall(chainId: ContractsChainId, account: string) {
   return {
     dataStore: {
       contractAddress: getContract(chainId, "DataStore"),
@@ -184,13 +193,42 @@ export function buildGetOrdersMulticall(chainId: number, account: string) {
 export function parseGetOrdersResponse(res: MulticallResult<ReturnType<typeof buildGetOrdersMulticall>>) {
   const count = Number(res.data.dataStore.count.returnValues[0]);
   const orderKeys = res.data.dataStore.keys.returnValues;
-  const orders = res.data.reader.orders.returnValues as any[];
+  const orders = res.data.reader.orders.returnValues as {
+    orderKey: string;
+    order: {
+      addresses: {
+        account: string;
+        receiver: string;
+        cancellationReceiver: string;
+        callbackContract: string;
+        uiFeeReceiver: string;
+        market: string;
+        initialCollateralToken: string;
+        swapPath: string[];
+      };
+      numbers: {
+        orderType: bigint;
+        decreasePositionSwapType: bigint;
+        sizeDeltaUsd: bigint;
+        initialCollateralDeltaAmount: bigint;
+        triggerPrice: bigint;
+        acceptablePrice: bigint;
+        executionFee: bigint;
+        callbackGasLimit: bigint;
+        minOutputAmount: bigint;
+        updatedAtTime: bigint;
+        validFromTime: bigint;
+        srcChainId: bigint;
+      };
+      flags: { isLong: boolean; shouldUnwrapNativeToken: boolean; isFrozen: boolean; autoCancel: boolean };
+      _dataList: string[];
+    };
+  }[];
 
   return {
     count,
-    orders: orders.map((order, i) => {
+    orders: orders.map(({ order }, i) => {
       const key = orderKeys[i];
-      const { data } = order;
 
       const orderData: Order = {
         key,
@@ -211,10 +249,12 @@ export function parseGetOrdersResponse(res: MulticallResult<ReturnType<typeof bu
         isLong: order.flags.isLong as boolean,
         shouldUnwrapNativeToken: order.flags.shouldUnwrapNativeToken as boolean,
         isFrozen: order.flags.isFrozen as boolean,
-        orderType: order.numbers.orderType as OrderType,
-        decreasePositionSwapType: order.numbers.decreasePositionSwapType as DecreasePositionSwapType,
+        orderType: Number(order.numbers.orderType) as OrderType,
+        decreasePositionSwapType: Number(order.numbers.decreasePositionSwapType) as DecreasePositionSwapType,
         autoCancel: order.flags.autoCancel as boolean,
-        data,
+        uiFeeReceiver: order.addresses.uiFeeReceiver as Address,
+        validFromTime: BigInt(order.numbers.validFromTime),
+        data: order._dataList,
       };
 
       return orderData;
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/positions/positions.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/positions/positions.ts
index dcb3c607..576af325 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/positions/positions.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/positions/positions.ts
@@ -1,43 +1,46 @@
-import { zeroAddress, zeroHash } from "viem";
+import {zeroAddress, zeroHash} from "viem";
 
-import { getContract } from "../../configs/contracts.js";
+import {getContract} from "../../configs/contracts.js";
 import {
-  hashedPositionKey,
-  MAX_AUTO_CANCEL_ORDERS_KEY,
-  MIN_COLLATERAL_USD_KEY,
-  MIN_POSITION_SIZE_USD_KEY,
-  uiFeeFactorKey,
+    hashedPositionKey,
+    MAX_AUTO_CANCEL_ORDERS_KEY,
+    MIN_COLLATERAL_USD_KEY,
+    MIN_POSITION_SIZE_USD_KEY,
+    uiFeeFactorKey,
 } from "../../configs/dataStore.js";
-import { ContractMarketPrices, MarketsData, MarketsInfoData } from "../../types/markets.js";
-import { Position, PositionsData, PositionsInfoData } from "../../types/positions.js";
-import { TokensData } from "../../types/tokens.js";
+import {ContractMarketPrices, MarketsData, MarketsInfoData} from "../../types/markets.js";
+import {Position, PositionsData, PositionsInfoData} from "../../types/positions.js";
+import {TokensData} from "../../types/tokens.js";
 import {
-  getContractMarketPrices,
-  getMarketIndexName,
-  getMarketPoolName,
-  getMaxAllowedLeverageByMinCollateralFactor,
+    getContractMarketPrices,
+    getMarketIndexName,
+    getMarketPoolName,
+    getMaxAllowedLeverageByMinCollateralFactor,
 } from "../../utils/markets.js";
-import { getByKey } from "../../utils/objects.js";
+import {getByKey} from "../../utils/objects.js";
 import {
-  getEntryPrice,
-  getLeverage,
-  getLiquidationPrice,
-  getPositionKey,
-  getPositionNetValue,
-  getPositionPnlUsd,
+    getEntryPrice,
+    getLeverage,
+    getLiquidationPrice,
+    getNetPriceImpactDeltaUsdForDecrease,
+    getPositionKey,
+    getPositionNetValue,
+    getPositionPendingFeesUsd,
+    getPositionPnlAfterFees,
+    getPositionPnlUsd,
 } from "../../utils/positions.js";
 
-import { Module } from "../base.js";
+import {Module} from "../base.js";
 
-import { UserReferralInfo } from "../../types/referrals.js";
-import { getPositionFee, getPriceImpactForPosition } from "../../utils/fees/index.js";
-import { basisPointsToFloat, getBasisPoints } from "../../utils/numbers.js";
-import { getPositionPendingFeesUsd } from "../../utils/positions.js";
-import { getMarkPrice } from "../../utils/prices.js";
-import { decodeReferralCode } from "../../utils/referrals.js";
-import { convertToTokenAmount, convertToUsd } from "../../utils/tokens.js";
-import { OrderInfo } from "../../types/orders.js";
-import type { MulticallRequestConfig } from "../../utils/multicall.js";
+import {UserReferralInfo} from "../../types/referrals.js";
+import {getPositionFee} from "../../utils/fees/index.js";
+import {basisPointsToFloat, getBasisPoints} from "../../utils/numbers.js";
+import {getAcceptablePriceInfo, getMarkPrice} from "../../utils/prices.js";
+import {decodeReferralCode} from "../../utils/referrals.js";
+import {convertToTokenAmount, convertToUsd} from "../../utils/tokens.js";
+import {OrderInfo} from "../../types/orders.js";
+import type {MulticallRequestConfig} from "../../utils/multicall.js";
+import {BOTANIX} from "../../configs/chains.js";
 
 type PositionsResult = {
   positionsData?: PositionsData;
@@ -158,7 +161,7 @@ export class Positions extends Module {
     const positions = await this.sdk.executeMulticall(request).then((res) => {
       const positions = res.data.reader.positions.returnValues;
 
-      return positions.reduce((positionsMap: PositionsData, positionInfo) => {
+      return positions.reduce((positionsMap: PositionsData, positionInfo: any) => {
         const { position, fees, basePnlUsd } = positionInfo;
         const { addresses, numbers, flags, data } = position;
         const { account, market: marketAddress, collateralToken: collateralTokenAddress } = addresses;
@@ -182,6 +185,7 @@ export class Positions extends Module {
           collateralAmount: numbers.collateralAmount,
           increasedAtTime: numbers.increasedAtTime,
           decreasedAtTime: numbers.decreasedAtTime,
+          pendingImpactAmount: numbers.pendingImpactAmount,
           isLong: flags.isLong,
           pendingBorrowingFeesUsd: fees.borrowing.borrowingFeeUsd,
           fundingFeeAmount: fees.funding.fundingFeeAmount,
@@ -331,6 +335,15 @@ export class Positions extends Module {
   }
 
   private async getUserRefferalCode() {
+    if (this.chainId === BOTANIX) {
+      return {
+        attachedOnChain: false,
+        userReferralCode: undefined,
+        userReferralCodeString: undefined,
+        referralCodeForTxn: zeroHash,
+      };
+    }
+
     const referralStorageAddress = getContract(this.chainId, "ReferralStorage");
 
     const onChainCode = await this.sdk.executeMulticall({
@@ -531,6 +544,7 @@ export class Positions extends Module {
         marketInfo.longToken.decimals,
         marketInfo.longToken.prices.minPrice
       )!;
+
       const pendingClaimableFundingFeesShortUsd = convertToUsd(
         position.claimableShortTokenAmount,
         marketInfo.shortToken.decimals,
@@ -544,17 +558,21 @@ export class Positions extends Module {
         pendingFundingFeesUsd,
       });
 
-      const closingPriceImpactDeltaUsd = getPriceImpactForPosition(
-        marketInfo,
-        position.sizeInUsd * -1n,
-        position.isLong,
-        { fallbackToZero: true }
-      );
+      const closeAcceptablePriceInfo = marketInfo
+        ? getAcceptablePriceInfo({
+            marketInfo,
+            isIncrease: false,
+            isLimit: false,
+            isLong: position.isLong,
+            indexPrice: getMarkPrice({ prices: indexToken.prices, isLong: position.isLong, isIncrease: false }),
+            sizeDeltaUsd: position.sizeInUsd,
+          })
+        : undefined;
 
       const positionFeeInfo = getPositionFee(
         marketInfo,
         position.sizeInUsd,
-        closingPriceImpactDeltaUsd > 0,
+        closeAcceptablePriceInfo?.balanceWasImproved ?? false,
         userReferralInfo,
         uiFeeFactor
       );
@@ -583,6 +601,17 @@ export class Positions extends Module {
       const pnlPercentage =
         collateralUsd !== undefined && collateralUsd != 0n ? getBasisPoints(pnl, collateralUsd) : 0n;
 
+      const netPriceImapctValues =
+        marketInfo && closeAcceptablePriceInfo
+          ? getNetPriceImpactDeltaUsdForDecrease({
+              marketInfo,
+              sizeInUsd: position.sizeInUsd,
+              pendingImpactAmount: position.pendingImpactAmount,
+              sizeDeltaUsd: position.sizeInUsd,
+              priceImpactDeltaUsd: closeAcceptablePriceInfo.priceImpactDeltaUsd,
+            })
+          : undefined;
+
       const netValue = getPositionNetValue({
         collateralUsd: collateralUsd,
         pnl,
@@ -590,9 +619,20 @@ export class Positions extends Module {
         pendingFundingFeesUsd: pendingFundingFeesUsd,
         closingFeeUsd,
         uiFeeUsd,
+        totalPendingImpactDeltaUsd: netPriceImapctValues?.totalImpactDeltaUsd ?? 0n,
+        priceImpactDiffUsd: netPriceImapctValues?.priceImpactDiffUsd ?? 0n,
+      });
+
+      const pnlAfterFees = getPositionPnlAfterFees({
+        pnl,
+        pendingBorrowingFeesUsd: position.pendingBorrowingFeesUsd,
+        pendingFundingFeesUsd: pendingFundingFeesUsd,
+        closingFeeUsd,
+        uiFeeUsd,
+        totalPendingImpactDeltaUsd: netPriceImapctValues?.totalImpactDeltaUsd ?? 0n,
+        priceImpactDiffUsd: netPriceImapctValues?.priceImpactDiffUsd ?? 0n,
       });
 
-      const pnlAfterFees = pnl - totalPendingFeesUsd - closingFeeUsd - uiFeeUsd;
       const pnlAfterFeesPercentage =
         collateralUsd != 0n ? getBasisPoints(pnlAfterFees, collateralUsd + closingFeeUsd) : 0n;
 
@@ -623,6 +663,7 @@ export class Positions extends Module {
         sizeInTokens: position.sizeInTokens,
         collateralUsd,
         collateralAmount: position.collateralAmount,
+        pendingImpactAmount: position.pendingImpactAmount,
         userReferralInfo,
         minCollateralUsd,
         pendingBorrowingFeesUsd: position.pendingBorrowingFeesUsd,
@@ -658,6 +699,10 @@ export class Positions extends Module {
         pnlAfterFees,
         pnlAfterFeesPercentage,
         netValue,
+        netPriceImapctDeltaUsd: netPriceImapctValues?.totalImpactDeltaUsd ?? 0n,
+        priceImpactDiffUsd: netPriceImapctValues?.priceImpactDiffUsd ?? 0n,
+        pendingImpactUsd: netPriceImapctValues?.proportionalPendingImpactDeltaUsd ?? 0n,
+        closePriceImpactDeltaUsd: closeAcceptablePriceInfo?.priceImpactDeltaUsd ?? 0n,
         closingFeeUsd,
         uiFeeUsd,
         pendingFundingFeesUsd,
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/trades/trades.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/trades/trades.ts
index 29be7663..ac731c52 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/trades/trades.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/trades/trades.ts
@@ -1,18 +1,24 @@
-import { getWrappedToken } from "../../configs/tokens.js";
+import {getWrappedToken} from "../../configs/tokens.js";
 import merge from "lodash/merge.js";
-import { MarketsInfoData } from "../../types/markets.js";
-import { OrderType } from "../../types/orders.js";
-import { Token, TokensData } from "../../types/tokens.js";
-import { PositionTradeAction, RawTradeAction, SwapTradeAction, TradeAction, TradeActionType } from "../../types/tradeHistory.js";
+import {MarketsInfoData} from "../../types/markets.js";
+import {OrderType} from "../../types/orders.js";
+import {TokensData} from "../../types/tokens.js";
+import {PositionTradeAction, TradeAction, TradeActionType} from "../../types/tradeHistory.js";
 import graphqlFetcher from "../../utils/graphqlFetcher.js";
-import { getByKey } from "../../utils/objects.js";
-import { isIncreaseOrderType, isLimitOrderType, isSwapOrderType, isTriggerDecreaseOrderType } from "../../utils/orders.js";
-import { buildFiltersBody, GraphQlFilters } from "../../utils/subgraph.js";
-import { getSwapPathOutputAddresses } from "../../utils/swap/swapStats.js";
-import { parseContractPrice } from "../../utils/tokens.js";
-import { Address, getAddress } from "viem";
-import { Module } from "../base.js";
-import { GmxSdk } from "../../index.js";
+import {
+    isIncreaseOrderType,
+    isLimitOrderType,
+    isSwapOrderType,
+    isTriggerDecreaseOrderType
+} from "../../utils/orders.js";
+import {buildFiltersBody, GraphQlFilters} from "../../utils/subgraph.js";
+import {getSwapPathOutputAddresses} from "../../utils/swap/swapStats.js";
+import {Address} from "viem";
+import {Module} from "../base.js";
+import {GmxSdk} from "../../index.js";
+import {TradeAction as SubsquidTradeAction} from "../../types/subsquid.js";
+import {createRawTradeActionTransformer} from "../../utils/tradeHistory.js";
+
 
 export type MarketFilterLongShortDirection = "long" | "short" | "swap" | "any";
 export type MarketFilterLongShortItemData = {
@@ -100,15 +106,15 @@ export async function fetchTradeActions({
   marketsInfoData: MarketsInfoData | undefined;
   tokensData: TokensData | undefined;
 }): Promise<TradeAction[]> {
-  const endpoint = sdk.config.subgraphUrl;
+  const endpoint = sdk.config.subsquidUrl;
   const chainId = sdk.chainId;
 
   if (!endpoint) {
     return [];
   }
 
-  const skip = pageIndex * pageSize;
-  const first = pageSize;
+  const offset = pageIndex * pageSize;
+  const limit = pageSize;
 
   const nonSwapRelevantDefinedFiltersLowercased: MarketFilterLongShortItemData[] = marketsDirectionsFilter
     .filter((filter) => filter.direction !== "swap" && filter.marketAddress !== "any")
@@ -135,16 +141,14 @@ export async function fetchTradeActions({
   const hasSwapRelevantDefinedMarkets = swapRelevantDefinedMarketsLowercased.length > 0;
 
   const filtersStr = buildFiltersBody({
-    and: [
+    AND: [
       {
-        account: forAllAccounts ? undefined : account!.toLowerCase(),
-        transaction: {
-          timestamp_gte: fromTxTimestamp,
-          timestamp_lte: toTxTimestamp,
-        },
+        account_eq: forAllAccounts ? undefined : account,
+        timestamp_gte: fromTxTimestamp,
+        timestamp_lte: toTxTimestamp,
       },
       {
-        or: !hasPureDirectionFilters
+        OR: !hasPureDirectionFilters
           ? undefined
           : pureDirectionFilters.map((filter) =>
               filter.direction === "swap"
@@ -152,25 +156,25 @@ export async function fetchTradeActions({
                     orderType_in: [OrderType.LimitSwap, OrderType.MarketSwap],
                   }
                 : {
-                    isLong: filter.direction === "long",
+                    isLong_eq: filter.direction === "long",
                     orderType_not_in: [OrderType.LimitSwap, OrderType.MarketSwap],
                   }
             ),
       },
       {
-        or: [
+        OR: [
           // For non-swap orders
           {
-            and: !hasNonSwapRelevantDefinedMarkets
+            AND: !hasNonSwapRelevantDefinedMarkets
               ? undefined
               : [
                   {
                     orderType_not_in: [OrderType.LimitSwap, OrderType.MarketSwap],
                   },
                   {
-                    or: nonSwapRelevantDefinedFiltersLowercased.map((filter) => ({
-                      marketAddress: filter.marketAddress === "any" ? undefined : filter.marketAddress,
-                      isLong: filter.direction === "any" ? undefined : filter.direction === "long",
+                    OR: nonSwapRelevantDefinedFiltersLowercased.map((filter) => ({
+                      marketAddress_eq: filter.marketAddress === "any" ? undefined : filter.marketAddress,
+                      isLong_eq: filter.direction === "any" ? undefined : filter.direction === "long",
                       // Collateral filtering is done outside of graphql on the client
                     })),
                   },
@@ -178,14 +182,14 @@ export async function fetchTradeActions({
           },
           // For defined markets on swap orders
           {
-            and: !hasSwapRelevantDefinedMarkets
+            AND: !hasSwapRelevantDefinedMarkets
               ? undefined
               : [
                   {
                     orderType_in: [OrderType.LimitSwap, OrderType.MarketSwap],
                   },
                   {
-                    or: [
+                    OR: [
                       // Source token is not in swap path so we add it to the or filter
                       {
                         marketAddress_in: swapRelevantDefinedMarketsLowercased,
@@ -201,7 +205,7 @@ export async function fetchTradeActions({
         ],
       },
       {
-        or: orderEventCombinations?.map((combination) => {
+        OR: orderEventCombinations?.map((combination) => {
           let sizeDeltaUsdCondition = {};
 
           if (
@@ -217,8 +221,8 @@ export async function fetchTradeActions({
 
           return merge(
             {
-              eventName: combination.eventName,
-              orderType: combination.orderType,
+              eventName_eq: combination.eventName,
+              orderType_eq: combination.orderType,
             },
             sizeDeltaUsdCondition
           );
@@ -227,7 +231,7 @@ export async function fetchTradeActions({
       {
         // We do not show create liquidation orders in the trade history, thus we filter it out
         // ... && not (liquidation && orderCreated) === ... && (not liquidation || not orderCreated)
-        or: [{ orderType_not: OrderType.Liquidation }, { eventName_not: TradeActionType.OrderCreated }],
+        OR: [{ orderType_not_eq: OrderType.Liquidation }, { eventName_not_eq: TradeActionType.OrderCreated }],
       },
     ],
   });
@@ -236,10 +240,9 @@ export async function fetchTradeActions({
 
   const query = `{
         tradeActions(
-            skip: ${skip},
-            first: ${first},
-            orderBy: transaction__timestamp,
-            orderDirection: desc,
+            offset: ${offset},
+            limit: ${limit},
+            orderBy: transaction_timestamp_DESC,
             ${whereClause}
         ) {
             id
@@ -279,6 +282,7 @@ export async function fetchTradeActions({
 
             reason
             reasonBytes
+            timestamp
 
             transaction {
                 timestamp
@@ -287,7 +291,7 @@ export async function fetchTradeActions({
         }
       }`;
 
-  const result = await graphqlFetcher<{ tradeActions: RawTradeAction[] }>(endpoint, query);
+  const result = await graphqlFetcher<{ tradeActions: SubsquidTradeAction[] }>(endpoint, query);
 
   const rawTradeActions = result?.tradeActions || [];
 
@@ -374,150 +378,3 @@ export async function fetchTradeActions({
 
   return tradeActions;
 }
-
-function createRawTradeActionTransformer(
-  marketsInfoData: MarketsInfoData,
-  wrappedToken: Token,
-  tokensData: TokensData
-): (
-  value: RawTradeAction,
-  index: number,
-  array: RawTradeAction[]
-) => SwapTradeAction | PositionTradeAction | undefined {
-  return (rawAction) => {
-    const orderType = Number(rawAction.orderType);
-
-    if (isSwapOrderType(orderType)) {
-      const initialCollateralTokenAddress = getAddress(rawAction.initialCollateralTokenAddress!);
-      const swapPath = rawAction.swapPath!.map((address) => getAddress(address));
-
-      const swapPathOutputAddresses = getSwapPathOutputAddresses({
-        marketsInfoData,
-        swapPath,
-        initialCollateralAddress: initialCollateralTokenAddress,
-        wrappedNativeTokenAddress: wrappedToken.address,
-        shouldUnwrapNativeToken: rawAction.shouldUnwrapNativeToken!,
-        isIncrease: false,
-      });
-
-      const initialCollateralToken = getByKey(tokensData, initialCollateralTokenAddress)!;
-      const targetCollateralToken = getByKey(tokensData, swapPathOutputAddresses.outTokenAddress)!;
-
-      if (!initialCollateralToken || !targetCollateralToken) {
-        return undefined;
-      }
-
-      const tradeAction: SwapTradeAction = {
-        id: rawAction.id,
-        eventName: rawAction.eventName,
-        account: rawAction.account,
-        swapPath,
-        orderType,
-        orderKey: rawAction.orderKey,
-        initialCollateralTokenAddress: rawAction.initialCollateralTokenAddress!,
-        initialCollateralDeltaAmount: bigNumberify(rawAction.initialCollateralDeltaAmount)!,
-        minOutputAmount: bigNumberify(rawAction.minOutputAmount)!,
-        executionAmountOut: rawAction.executionAmountOut ? bigNumberify(rawAction.executionAmountOut) : undefined,
-        shouldUnwrapNativeToken: rawAction.shouldUnwrapNativeToken!,
-        targetCollateralToken,
-        initialCollateralToken,
-        transaction: rawAction.transaction,
-        reason: rawAction.reason,
-        reasonBytes: rawAction.reasonBytes,
-      };
-
-      return tradeAction;
-    } else {
-      const marketAddress = getAddress(rawAction.marketAddress!);
-      const marketInfo = getByKey(marketsInfoData, marketAddress);
-      const indexToken = marketInfo?.indexToken;
-      const initialCollateralTokenAddress = getAddress(rawAction.initialCollateralTokenAddress!);
-      const swapPath = rawAction.swapPath!.map((address) => getAddress(address));
-      const swapPathOutputAddresses = getSwapPathOutputAddresses({
-        marketsInfoData,
-        swapPath,
-        initialCollateralAddress: initialCollateralTokenAddress,
-        wrappedNativeTokenAddress: wrappedToken.address,
-        shouldUnwrapNativeToken: rawAction.shouldUnwrapNativeToken!,
-        isIncrease: isIncreaseOrderType(rawAction.orderType),
-      });
-      const initialCollateralToken = getByKey(tokensData, initialCollateralTokenAddress);
-      const targetCollateralToken = getByKey(tokensData, swapPathOutputAddresses.outTokenAddress);
-
-      if (!marketInfo || !indexToken || !initialCollateralToken || !targetCollateralToken) {
-        return undefined;
-      }
-
-      const tradeAction: PositionTradeAction = {
-        id: rawAction.id,
-        eventName: rawAction.eventName,
-        account: rawAction.account,
-        marketAddress,
-        marketInfo,
-        indexToken,
-        swapPath,
-        initialCollateralTokenAddress,
-        initialCollateralToken,
-        targetCollateralToken,
-        initialCollateralDeltaAmount: bigNumberify(rawAction.initialCollateralDeltaAmount)!,
-        sizeDeltaUsd: bigNumberify(rawAction.sizeDeltaUsd)!,
-        triggerPrice: rawAction.triggerPrice
-          ? parseContractPrice(bigNumberify(rawAction.triggerPrice)!, indexToken.decimals)
-          : undefined,
-        acceptablePrice: parseContractPrice(bigNumberify(rawAction.acceptablePrice)!, indexToken.decimals),
-        executionPrice: rawAction.executionPrice
-          ? parseContractPrice(bigNumberify(rawAction.executionPrice)!, indexToken.decimals)
-          : undefined,
-        minOutputAmount: bigNumberify(rawAction.minOutputAmount)!,
-
-        collateralTokenPriceMax: rawAction.collateralTokenPriceMax
-          ? parseContractPrice(bigNumberify(rawAction.collateralTokenPriceMax)!, initialCollateralToken.decimals)
-          : undefined,
-
-        collateralTokenPriceMin: rawAction.collateralTokenPriceMin
-          ? parseContractPrice(bigNumberify(rawAction.collateralTokenPriceMin)!, initialCollateralToken.decimals)
-          : undefined,
-
-        indexTokenPriceMin: rawAction.indexTokenPriceMin
-          ? parseContractPrice(BigInt(rawAction.indexTokenPriceMin), indexToken.decimals)
-          : undefined,
-        indexTokenPriceMax: rawAction.indexTokenPriceMax
-          ? parseContractPrice(BigInt(rawAction.indexTokenPriceMax), indexToken.decimals)
-          : undefined,
-
-        orderType,
-        orderKey: rawAction.orderKey,
-        isLong: rawAction.isLong!,
-        pnlUsd: rawAction.pnlUsd ? BigInt(rawAction.pnlUsd) : undefined,
-        basePnlUsd: rawAction.basePnlUsd ? BigInt(rawAction.basePnlUsd) : undefined,
-
-        priceImpactDiffUsd: rawAction.priceImpactDiffUsd ? BigInt(rawAction.priceImpactDiffUsd) : undefined,
-        priceImpactUsd: rawAction.priceImpactUsd ? BigInt(rawAction.priceImpactUsd) : undefined,
-        positionFeeAmount: rawAction.positionFeeAmount ? BigInt(rawAction.positionFeeAmount) : undefined,
-        borrowingFeeAmount: rawAction.borrowingFeeAmount ? BigInt(rawAction.borrowingFeeAmount) : undefined,
-        fundingFeeAmount: rawAction.fundingFeeAmount ? BigInt(rawAction.fundingFeeAmount) : undefined,
-
-        reason: rawAction.reason,
-        reasonBytes: rawAction.reasonBytes,
-
-        transaction: rawAction.transaction,
-        shouldUnwrapNativeToken: rawAction.shouldUnwrapNativeToken!,
-      };
-
-      return tradeAction;
-    }
-  };
-}
-
-export function bigNumberify(n?: bigint | string | null | undefined) {
-  try {
-    if (n === undefined) throw new Error("n is undefined");
-    if (n === null) throw new Error("n is null");
-
-    return BigInt(n);
-  } catch (e) {
-    // eslint-disable-next-line no-console
-    console.error("bigNumberify error", e);
-    return undefined;
-  }
-}
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/utils/utils.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/utils/utils.ts
index deff996d..8e1c38b6 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/utils/utils.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/modules/utils/utils.ts
@@ -2,8 +2,9 @@ import {withRetry} from "viem";
 
 import {
     EXECUTION_FEE_CONFIG_V2,
+    GAS_LIMITS_STATIC_CONFIG,
     GAS_PRICE_PREMIUM_MAP,
-    getChain,
+    getViemChain,
     MAX_PRIORITY_FEE_PER_GAS_MAP
 } from "../../configs/chains.js";
 import {getContract} from "../../configs/contracts.js";
@@ -13,6 +14,7 @@ import {
     ESTIMATED_GAS_FEE_BASE_AMOUNT_V2_1,
     ESTIMATED_GAS_FEE_MULTIPLIER_FACTOR,
     ESTIMATED_GAS_FEE_PER_ORACLE_PRICE,
+    GELATO_RELAY_FEE_MULTIPLIER_FACTOR_KEY,
     GLV_DEPOSIT_GAS_LIMIT,
     GLV_PER_MARKET_GAS_LIMIT,
     GLV_WITHDRAWAL_GAS_LIMIT,
@@ -107,6 +109,10 @@ export class Utils extends Module {
               methodName: "getUint",
               params: [GLV_PER_MARKET_GAS_LIMIT],
             },
+            gelatoRelayFeeMultiplierFactor: {
+              methodName: "getUint",
+              params: [GELATO_RELAY_FEE_MULTIPLIER_FACTOR_KEY],
+            },
           },
         },
       })
@@ -117,6 +123,8 @@ export class Utils extends Module {
           return BigInt(results[key].returnValues[0]);
         }
 
+        const staticGasLimits = GAS_LIMITS_STATIC_CONFIG[this.chainId];
+
         return {
           depositToken: getBigInt("depositToken"),
           withdrawalMultiToken: getBigInt("withdrawalMultiToken"),
@@ -131,10 +139,17 @@ export class Utils extends Module {
           glvDepositGasLimit: getBigInt("glvDepositGasLimit"),
           glvWithdrawalGasLimit: getBigInt("glvWithdrawalGasLimit"),
           glvPerMarketGasLimit: getBigInt("glvPerMarketGasLimit"),
-        };
+          createOrderGasLimit: staticGasLimits.createOrderGasLimit,
+          updateOrderGasLimit: staticGasLimits.updateOrderGasLimit,
+          cancelOrderGasLimit: staticGasLimits.cancelOrderGasLimit,
+          tokenPermitGasLimit: staticGasLimits.tokenPermitGasLimit,
+          gmxAccountCollateralGasLimit: staticGasLimits.gmxAccountCollateralGasLimit,
+          gelatoRelayFeeMultiplierFactor: getBigInt("gelatoRelayFeeMultiplierFactor"),
+        } satisfies GasLimitsConfig;
       });
 
     this._gasLimits = gasLimits;
+
     return gasLimits;
   }
 
@@ -154,10 +169,10 @@ export class Utils extends Module {
 
     switch (tradeFeesType) {
       case "swap": {
-        if (!swapAmounts || !swapAmounts.swapPathStats) return null;
+        if (!swapAmounts?.swapStrategy.swapPathStats) return null;
 
         return estimateExecuteSwapOrderGasLimit(gasLimits, {
-          swapsCount: swapAmounts.swapPathStats.swapPath.length,
+          swapsCount: swapAmounts.swapStrategy.swapPathStats?.swapPath.length,
           callbackGasLimit: 0n,
         });
       }
@@ -165,7 +180,7 @@ export class Utils extends Module {
         if (!increaseAmounts) return null;
 
         return estimateExecuteIncreaseOrderGasLimit(gasLimits, {
-          swapsCount: increaseAmounts.swapPathStats?.swapPath.length,
+          swapsCount: increaseAmounts.swapStrategy.swapPathStats?.swapPath.length,
         });
       }
       case "decrease": {
@@ -229,7 +244,7 @@ export class Utils extends Module {
     const feeData = await withRetry(
       () =>
         this.sdk.publicClient.estimateFeesPerGas({
-          chain: getChain(this.chainId),
+          chain: getViemChain(this.chainId),
           type: "legacy",
         }),
       {
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/prebuilt/hashedKinkModelMarketRatesKeys.json b/src/Managing.Web3Proxy/src/generated/gmxsdk/prebuilt/hashedKinkModelMarketRatesKeys.json
index 3fdec0ca..3057d292 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/prebuilt/hashedKinkModelMarketRatesKeys.json
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/prebuilt/hashedKinkModelMarketRatesKeys.json
@@ -1,4 +1,30 @@
 {
+  "3637": {
+    "0x6682BB60590a045A956541B1433f016Ed22E361d": {
+      "optimalUsageFactorLong": "0xd7900b67e1e881ae7b0c8f93a08255e02561e815da97a3de875ca85cf4b40d1e",
+      "optimalUsageFactorShort": "0x18c06265540d8e6ab5ba16677912db446fd09fb0615edc830ccc15dbc07fcd97",
+      "baseBorrowingFactorLong": "0x9d72c9936d0741b7dd4b7a585a7cf418bd6ea5dae70c3c7caff29c67f7b16926",
+      "baseBorrowingFactorShort": "0x11e7e75d485e3ff9f13227abf344a29d66b7f81819e896b0bf33c6d87d2c37b7",
+      "aboveOptimalUsageBorrowingFactorLong": "0xa42e5c54173d3f51736eb8cbe5f06c36084d30259b7e40d2c1fc70431300d7bd",
+      "aboveOptimalUsageBorrowingFactorShort": "0x861a85c0ae1bfc44aef16c01500ea32341ef8e72fc3103f2e4cac8b0899ab984"
+    },
+    "0x2f95a2529328E427d3204555F164B1102086690E": {
+      "optimalUsageFactorLong": "0x78ca97fbabdfe99f666916132b2200ac92a2a87e4d693fed4b42415c7bb1f83f",
+      "optimalUsageFactorShort": "0x3d54102e9622aa676179f1e51c9880980ca2c907a18e7fa021c4289c7bede161",
+      "baseBorrowingFactorLong": "0x1f9c563f9dd77ab98efdf4d59a9b5288f8e5a68c6ca834d906a9f966c4f0eef3",
+      "baseBorrowingFactorShort": "0x58ea485f2aa0ee5a370c5250a39ada3c2c994e7404158f45eb50f100cf53bec8",
+      "aboveOptimalUsageBorrowingFactorLong": "0x31ae298fedbf23a4328de09720d623dd431df614f39806867dd09b73601216d8",
+      "aboveOptimalUsageBorrowingFactorShort": "0x6daccc95dbd38aa12073d2b7d1439f9897d49cea49ee23a4245722cf76b162da"
+    },
+    "0x6bFDD025827F7CE130BcfC446927AEF34ae2a98d": {
+      "optimalUsageFactorLong": "0xfa69cbf64ee47e4126c036bc70c223c711e39dba98ca9adb5d1114447692007c",
+      "optimalUsageFactorShort": "0xf9c2f103bc3d763b06ac92154847f3915e85a4b03a982ec69effecb40c0ae20f",
+      "baseBorrowingFactorLong": "0x4be52e9d009ab8bdbf6ad5524196e2d08a5e269af99218f8c7c7c9752093692f",
+      "baseBorrowingFactorShort": "0x068ee704d21753b16c63dcee8d3fd81e98e5124de0401ee6f1e0c4ee98938a0d",
+      "aboveOptimalUsageBorrowingFactorLong": "0x11697e736a0b59f616867fbe856c1c44dd826a785c7155fd4c5657ac4a92a7f7",
+      "aboveOptimalUsageBorrowingFactorShort": "0x9e1a14e48896d7b69cbcd1632d3dd4061324a789f9be86617408fe12ec5700e6"
+    }
+  },
   "42161": {
     "0x47c031236e19d024b42f8AE6780E44A573170703": {
       "optimalUsageFactorLong": "0x81cc37ff3833298b6114d8317fd6c5996dc7a8ab53fefd3edb9f415ca4267824",
@@ -647,6 +673,198 @@
       "baseBorrowingFactorShort": "0x4385c8e191a978b34824ae41b408ba588e261054e5945d0e99068ad10b4905ed",
       "aboveOptimalUsageBorrowingFactorLong": "0x2914e46a2e627cc733a945a8eb44ab2ef758f9a6fc35821bec5e340d7e0239b4",
       "aboveOptimalUsageBorrowingFactorShort": "0xe09312ebfcc03606ed101a23c5fe2e9883e431d2787ba65c5a0ae9526b58ce1b"
+    },
+    "0x4D3Eb91efd36C2b74181F34B111bc1E91a0d0cb4": {
+      "optimalUsageFactorLong": "0x2e3f861626c4e7e577efc24e5c1bf68664f67cca423736be0c5cc5bfd2d51490",
+      "optimalUsageFactorShort": "0x6140b20bd94e328307faca8fbb6fcead2c2104a2ef78c533383f36379298cbd2",
+      "baseBorrowingFactorLong": "0xb1a5d5b89f2457ae28d85c819b41f35391063c1f32c19406bf0d5f3697d44af7",
+      "baseBorrowingFactorShort": "0x6b2efc5c2a51a2cb3b50b9a474a578272ceac9dacd7f8a495246541658b004c4",
+      "aboveOptimalUsageBorrowingFactorLong": "0x0364a6542f02b0cf5de96a3f0a0566ee9ac777fdac6302691a0b1296c29edca6",
+      "aboveOptimalUsageBorrowingFactorShort": "0x825303f6ce78aa93bacadc5a8603f840a7e0f0bfdd480164fd9b0f3dfefaf00e"
+    },
+    "0x9e79146b3A022Af44E0708c6794F03Ef798381A5": {
+      "optimalUsageFactorLong": "0x51f1c4be39fa03c2c9fdf3e3faf5acf64fdb3dd69a45e4c809014ea2bb49ee5e",
+      "optimalUsageFactorShort": "0x2a0c242783a92cdcdead09777db7af8c8f4f4cec93e12816e68ccd4d7d8c83de",
+      "baseBorrowingFactorLong": "0xd2648ee5a2446600ca9f877f02a536176854e9dc58f62e816ab1a9f196b5d419",
+      "baseBorrowingFactorShort": "0x208583f32d8a947ce802ada215547db39c83f47b79694bab2a8553af1b011676",
+      "aboveOptimalUsageBorrowingFactorLong": "0x0dd5d847eb76fc4986137f91d409d500b8e9a3e05d0b721e902ed4fe6a42f0d4",
+      "aboveOptimalUsageBorrowingFactorShort": "0xa77bd37d33247f0d86c482b48208711317ee68817a21fc2976bb3e54f2265579"
+    },
+    "0x0e46941F9bfF8d0784BFfa3d0D7883CDb82D7aE7": {
+      "optimalUsageFactorLong": "0x4c401d404a1c1269fb6aa7928ceb1935a9a6f4de7c7e64f214b8a266a662ce30",
+      "optimalUsageFactorShort": "0xa230801e8b702d8b0e96c43f1f55a8b59290c4f8c279f1b7857dd05c580ce343",
+      "baseBorrowingFactorLong": "0x5e5b2f3c0a995b771355f55d7717305c072e7e9590dfbd3974c16abfb106f264",
+      "baseBorrowingFactorShort": "0x4e83186068e01b7963bf06a1db46129a3fc52c0aa2a6cede0f4f7e1cea418635",
+      "aboveOptimalUsageBorrowingFactorLong": "0x20a3640f97b96b9c0822d0dc61ee226a8334e7a5b24626b9a7502097af05a326",
+      "aboveOptimalUsageBorrowingFactorShort": "0x85ef58093c6eaed2811bc1bea92f4a159585f0b24ac6c4346d7d2df8022367b7"
+    },
+    "0x2523B89298908FEf4c5e5bd6F55F20926e22058f": {
+      "optimalUsageFactorLong": "0xa2f32b1482558e0e227f8710d0d95e3109d262f1c202c36290eb7f237196378d",
+      "optimalUsageFactorShort": "0x0bbb61bb560c7a37fa166a538e3bd121d97340e6c337b7b63305e6c970fe003e",
+      "baseBorrowingFactorLong": "0x36448e380d2f15c1f9ebb52be2edf1465cd3bc094f51e820c4edb9739911bdfc",
+      "baseBorrowingFactorShort": "0x3d10551cad9dcb1162fffb36dddb7a9bf732309b035c390903cb6691c5ed2c41",
+      "aboveOptimalUsageBorrowingFactorLong": "0x96c6512b5cf544d92602a6f131b09ce017fa399e19cb1077b5e401ccb288a81d",
+      "aboveOptimalUsageBorrowingFactorShort": "0x89006ab4ceebc6145f5520cd195fd1edc44b69eb84a3b6bc106a423954e3adfd"
+    },
+    "0x7c54D547FAD72f8AFbf6E5b04403A0168b654C6f": {
+      "optimalUsageFactorLong": "0xff18362de8f0fda2252bc409478257cebdfa5ec4b871406f7a505da2c7fe1ab8",
+      "optimalUsageFactorShort": "0x230f71281e768eebd4331bd719291624e543196517749b8d00dba269ce6be195",
+      "baseBorrowingFactorLong": "0xaeef4efa75991b37580a3d0a298c6544ee23646fc1ad2d8c1f1cb423caeaa409",
+      "baseBorrowingFactorShort": "0xe286e4d69b63827eefc1434086a543c85f9531c278e55f0603cf9b54e2c19637",
+      "aboveOptimalUsageBorrowingFactorLong": "0xb656f322337ee629cf453b0fa72ca684db89f8bdcfff5e333842f6e66f5ebbd8",
+      "aboveOptimalUsageBorrowingFactorShort": "0x853644d97900c5164a82701fde817c51a57d31dc222e136c1e2c7d5a948b11fd"
+    },
+    "0x39AC3C494950A4363D739201BA5A0861265C9ae5": {
+      "optimalUsageFactorLong": "0x5be9aa175e2ec6bf9d9508099dc2452f179ea3c74374aaf69b245fadd1fee369",
+      "optimalUsageFactorShort": "0xd2708f5731caffd02de0e20b01a2e089c23ae856702baa71dbc8183da6ebfb76",
+      "baseBorrowingFactorLong": "0x0a4665f7256edc8fbc4dcb890994df31eeacc8d252f39a90f7f85842eeb81ca2",
+      "baseBorrowingFactorShort": "0x9906550d5dc055a64080e0a74a6910eee2bf9e507bf50f7636ae653bc037ba4f",
+      "aboveOptimalUsageBorrowingFactorLong": "0x0eaf5f1d2e29a62d716f417ca4c84c379336f25ed6b72efef91b1192674b1cb4",
+      "aboveOptimalUsageBorrowingFactorShort": "0x90b85d18260e09eff7f3d7f4a3e907cbf476ff493d792f3f33f5926a68cfe584"
+    },
+    "0x4C0Bb704529Fa49A26bD854802d70206982c6f1B": {
+      "optimalUsageFactorLong": "0x6132251ed7cf628c17d1a03b0a42435719110da3d14a57a8db2afe4389bff311",
+      "optimalUsageFactorShort": "0x7efb109390c3e739eeefb62366461b031215a755a797d9a4eb24e228d3e4e9e0",
+      "baseBorrowingFactorLong": "0x6cd904ae4fbfc7bd74ad666b5f8d0bd68e4a723e111e81f6547f0b1eed7bcf37",
+      "baseBorrowingFactorShort": "0x3e5f962e6c670c6bc3f4ca5c95884c3aa47845efc94eecca34b6b7d7fa2a9b18",
+      "aboveOptimalUsageBorrowingFactorLong": "0xa985be98994cbd44fad76d2e48396d307f965b4478976156255e8b3e9281a1da",
+      "aboveOptimalUsageBorrowingFactorShort": "0xa0a5a75cba99e7ca32b5d5039093352f2d0c8002f767391f5c3da1e5eaecd324"
+    },
+    "0x8263bC3766a09f6dD4Bab04b4bf8D45F2B0973FF": {
+      "optimalUsageFactorLong": "0xcf65fa5ca92f31afd04381260c53b010cc82d694441de260d266316133e277c6",
+      "optimalUsageFactorShort": "0xdaa4ae4be02547f5cd1334b974921d1745b0e4602a0318dab8a3c40849527270",
+      "baseBorrowingFactorLong": "0x6e563f6cb443ae4aa74a98c49a7894fd3eca7e3f82060c65296af449c4b84113",
+      "baseBorrowingFactorShort": "0x138821850f50631349f9e3cc0c8217e6276f1f3b457535058614ac811f615eca",
+      "aboveOptimalUsageBorrowingFactorLong": "0x085985feb2950c1b3b6514f8a58b8c3e773fbc14766203c93391f49d0620fd41",
+      "aboveOptimalUsageBorrowingFactorShort": "0x92d93c3132ab787b6ad12fe4de15c8aa7c97979b8b6a89f957fa4d665d388c1b"
+    },
+    "0x40dAEAc02dCf6b3c51F9151f532C21DCEF2F7E63": {
+      "optimalUsageFactorLong": "0x77ee9eabc7612beed8eed57a46e1faef4f44f5c3f217f3f1c5c4240dcd4b0625",
+      "optimalUsageFactorShort": "0x5a32ca8b7f856170e4244c2dd3eca5765be5c943f4ec6e9e7e6cd6eb7a079722",
+      "baseBorrowingFactorLong": "0x47055919ec19eb3179a0c3d99ebda26b229a92a42f898117cc07a477ea59c5f4",
+      "baseBorrowingFactorShort": "0x183a9f2b4a1bd93688af66a5dada4d0444d8e0af19c05e23ce2de5799517876b",
+      "aboveOptimalUsageBorrowingFactorLong": "0x97a0f3257e4c53a716f2aec8482b5493785a94a8cf011e3bbebdafd76adb2d05",
+      "aboveOptimalUsageBorrowingFactorShort": "0x8216510d0019a2ffcff5be1f1dca67a27b6cb630db12580d3dd4df6748134d9a"
+    },
+    "0x672fEA44f4583DdaD620d60C1Ac31021F47558Cb": {
+      "optimalUsageFactorLong": "0xd656b2ed477413b2c7a366b70df31f09e4109d308594488cb6989cdbc00328f2",
+      "optimalUsageFactorShort": "0x00bad40a9c19db8daccf00701b36eee1a7d5decf375b0823786a176283b35f87",
+      "baseBorrowingFactorLong": "0x2235c5b316dbc8b5a48a61ba913c4f60499c8e8fa243b9d7179a29403acd4390",
+      "baseBorrowingFactorShort": "0xadc19abc5e3cdc7393f56e2c6371b32085af2ee78814ea6ebe9e217189a8a403",
+      "aboveOptimalUsageBorrowingFactorLong": "0xf6ec3dd73f1037a6aaea5c3897c01ff2c7d94dddcc3857a35edd9446442ba7e7",
+      "aboveOptimalUsageBorrowingFactorShort": "0x3551da5e79dea5838549ef9dc5016ac92391bc7e4c6b78b7f73eaa27d245a84c"
+    },
+    "0x3B7f4e4Cf2fa43df013d2B32673e6A01d29ab2Ac": {
+      "optimalUsageFactorLong": "0xcfee8f8e2692cdcf11c4af2455157f4f18efa01fc6bbcc049e20ca6dacc43a08",
+      "optimalUsageFactorShort": "0x203a038715927e0274514c0aa40ce6e024bf74b94f53c3965573e9b3b6295f5e",
+      "baseBorrowingFactorLong": "0x58ee17d42d5a0ccc5af26f74eb115dbc916c2b5c20db2ea399569b76760c2a7b",
+      "baseBorrowingFactorShort": "0x774688a2c8f874f84b8fd90662c2ceb45afbae4ece4456e7236ee46b3776fd9c",
+      "aboveOptimalUsageBorrowingFactorLong": "0xcf5c7c02346f62cef2ae4a64c78f732d560894bbdde290e0f685a8bb5b4d0954",
+      "aboveOptimalUsageBorrowingFactorShort": "0xa11f19bc8b03ece53927c2afb04c118fecb0cf5a778800a1f558c06b78605818"
+    },
+    "0xa29FfE4152B65A0347512Ae5c6A4Bbc7a3d6d51B": {
+      "optimalUsageFactorLong": "0xfc5206fdd305807d0ccb94caad764a53a16ce56b164cafa76492b7388c7ccaa8",
+      "optimalUsageFactorShort": "0x809ba85a9b39cb854ee5f2afc302cc9c388767a27517a2e64220e3838bbf6a91",
+      "baseBorrowingFactorLong": "0x795cabccc1302668c7f3941836a98c704b1889e4e657c0e9822c0ca66191febf",
+      "baseBorrowingFactorShort": "0x336c59129d8cf65f2848edfec9c8abac325cb9442d98d4f8dbd9808b78021e4e",
+      "aboveOptimalUsageBorrowingFactorLong": "0x644117c95e31e8d50d65b692d7650ab3b2158da280bc1ebee8070961d2d63f0c",
+      "aboveOptimalUsageBorrowingFactorShort": "0xb8508af8e288565d818d877a974d643efb7165d4c5bf610aaed87b8fcb143291"
+    },
+    "0x9f0849FB830679829d1FB759b11236D375D15C78": {
+      "optimalUsageFactorLong": "0x16f1b35b207465f30a27af5a05c2cbc5950bbc596dc954208f16c2e72ef60d53",
+      "optimalUsageFactorShort": "0x478c3e327487b2ce5ce0fa2c8ef51f52799b9d8be175b50a3fc7309bb0bb7642",
+      "baseBorrowingFactorLong": "0xa118eca252d64e4deacf84e2915c28fc06046c9e0d357461730030ef8749973a",
+      "baseBorrowingFactorShort": "0x39bc784879f3ef9de946a74c4d244136358aa9e71ff024535e8c3a3a427e8c0f",
+      "aboveOptimalUsageBorrowingFactorLong": "0xb9ad121fcf3c1b0db36e6a730321f002b19b8b3d3dc37dc5839f259ffd5b7b8a",
+      "aboveOptimalUsageBorrowingFactorShort": "0xcbf93efdbf556397736088feff0d4bc2b2f049622b72fb832cc7a3623f2f5bbd"
+    },
+    "0x41E3bC5B72384C8B26b559B7d16C2B81Fd36fbA2": {
+      "optimalUsageFactorLong": "0x1049fa537be65f1669e1682815978c5643f4d8f1eb58c5be48cbc35c25470104",
+      "optimalUsageFactorShort": "0x30cce3e5ab653df70bc715d62bfa6224debf9807317d1387cd2707375f8b0e8f",
+      "baseBorrowingFactorLong": "0x23ed6320768672b71a9c233bb992d3476f86816d1f6f635f268d8d3f62de8e81",
+      "baseBorrowingFactorShort": "0xdbadb6c2e4422e23c32b6d1d21ad6a9b1dbe314bc7b920b5871f45ccdb859f86",
+      "aboveOptimalUsageBorrowingFactorLong": "0x77a792e68ad9041d1fec21b18f12b0af5708ccd673ea8669c8ad5c1d996c97ad",
+      "aboveOptimalUsageBorrowingFactorShort": "0xa042c3817a731e8e3c7f7c0c27ac57ad64f1b3f96f5e8f2b61fc59e0dd5dda16"
+    },
+    "0x4024418592450E4d62faB15e2f833FC03A3447dc": {
+      "optimalUsageFactorLong": "0x01cd43d4452a67736816f956f6c327899dcb3e0e21c55fc17c43f3e112fbdbc7",
+      "optimalUsageFactorShort": "0xaf2294097cd7158722c20a8e715a3ae5ffd2fdf9a72437f3137d639aaf88ba5a",
+      "baseBorrowingFactorLong": "0x4f3dcf36557dcf5acfa977979e818c7840b4edaff30feeffb4a9b3e723a7644c",
+      "baseBorrowingFactorShort": "0xd87713e30b629d0a6f5fcbb7c6d4094fa205426156f8dfc9131c4ad171a9a39c",
+      "aboveOptimalUsageBorrowingFactorLong": "0xa9716f0fde044cbd378bf79669bba6e0d4a9b19c769df1b2f24bb99cad7de8af",
+      "aboveOptimalUsageBorrowingFactorShort": "0xddfa24b2645bead3760d8fd6545d5025c315df2a3c41f0906e567a2f79f9eec6"
+    },
+    "0x2a331e51a3D17211852d8625a1029898450e539B": {
+      "optimalUsageFactorLong": "0x2a78441ba23708464d581d9426e221e0aa3a840dd9d13c766d70fc3bac22a10c",
+      "optimalUsageFactorShort": "0x192b0a6717e8cc96105745bb4e0fbb543af27f1c82abed4ad3c733d6edc9ba96",
+      "baseBorrowingFactorLong": "0x74a9054e0b13d192a76e38f6f6ecf312ab45bc316c19f775725de24d0b19706a",
+      "baseBorrowingFactorShort": "0x4cdbd9179e7797cb3e65fb8bcc53e781b35235fe360c6f8b86b049a28533df23",
+      "aboveOptimalUsageBorrowingFactorLong": "0x0efc0133799b04a909a56ee3f5f92b5db33042d8569f2a1426b689e1a325ad52",
+      "aboveOptimalUsageBorrowingFactorShort": "0x4fe44701fa72e8210e4bfd3be170b656a61be4b7fe5ae96608c3fe596bfa1129"
+    },
+    "0x3f649eab7f4CE4945F125939C64429Be2C5d0cB4": {
+      "optimalUsageFactorLong": "0x00bec875815865da5521b2ea0ee0616f66450231a98a55b6ee2b724b454532b4",
+      "optimalUsageFactorShort": "0xacfca85903d763fb52fe1fcfae7f2ed8b2c9fe72280a31e979c0567d0a6a6efb",
+      "baseBorrowingFactorLong": "0x9bc4457049d2f1b3b21b76e15d176270087a35a8e9b87e52ea76f4ef19576b69",
+      "baseBorrowingFactorShort": "0x503e041bfa226bc8a98252380d4c18c1e69d0f6d60224bc1d9f2057cdfd9f6da",
+      "aboveOptimalUsageBorrowingFactorLong": "0x5405a5e90ab4c8c0829d48d8722fe746f93a9f5f7a427ad47af40cc0dc0afc8c",
+      "aboveOptimalUsageBorrowingFactorShort": "0x0fb399f08622627b531460308ec479e4b272d7074e54e3a1b09a72f67af12cf6"
+    },
+    "0xfaEaE570B07618D3F10360608E43c241181c4614": {
+      "optimalUsageFactorLong": "0x840afffe8bb43184814016a015923dc44980d858e358aa503adda7b31c468f1c",
+      "optimalUsageFactorShort": "0x4de43289ffe221b34411fec8755fb4f1c8d1d633f6092a93411d5cbc435f028b",
+      "baseBorrowingFactorLong": "0x04bfe67edff208531e325f267f20d545cc448bdaf5d48e2603f5c90ed674ca5c",
+      "baseBorrowingFactorShort": "0xef2cc5458599f65fc7218057d7d235ebbfb13278739c1e00a8c9e72a04cdb763",
+      "aboveOptimalUsageBorrowingFactorLong": "0x91551ab540048fa5892c9ea76f705ce83d782d9adc2fbbc3dbc0704f24d45136",
+      "aboveOptimalUsageBorrowingFactorShort": "0x39ae0e51cbb91af2399430ab64e4690dcd3c6a5693c849ea0a4b3a42b87617dd"
+    },
+    "0x6EeE8098dBC106aEde99763FA5F955A5bBc42C50": {
+      "optimalUsageFactorLong": "0xc5d3ef57932d40b9ef196a4a57eeae3c1027a32ef7b6a34cf166069979fe4213",
+      "optimalUsageFactorShort": "0x42f11677ada1c42fa727a2ea741dbb6f5b666389aa17ca02adac73c44d3d9a2f",
+      "baseBorrowingFactorLong": "0x1778bc0fad1c076dc361d0f5202dd46515c98bc5436b8a59504340dd36793b21",
+      "baseBorrowingFactorShort": "0x806893df271d661e281f8bc7fcc8f76b34873d4d2dbd5c744e172825170f2cf7",
+      "aboveOptimalUsageBorrowingFactorLong": "0x030d1ce870a32ceba468c3ad1799ba63042f03a68006edf75a9d57e11222edfb",
+      "aboveOptimalUsageBorrowingFactorShort": "0xecf06f84c969631a27bfd2ffef485a24b8ebfd9b96e5012177fd4e90c6404403"
+    },
+    "0xb3588455858a49D3244237CEe00880CcB84b91Dd": {
+      "optimalUsageFactorLong": "0x94c4aa621db98cbda9d6162bb79826bbf4b96cd285eb90464ec1785e169674cb",
+      "optimalUsageFactorShort": "0x80cf5d6b6ee1b3fd0397a7ee9dc2ebbafdf1ac30da22a880755edd7ebd8ec9d5",
+      "baseBorrowingFactorLong": "0x6a3042d283f094247edd39893079e9235de817c338493feef0044e9b8b1dd09b",
+      "baseBorrowingFactorShort": "0x9b9ff5b5a59d8b63d7e8861075c68050677c0302571e4e2e25b514f95b93128b",
+      "aboveOptimalUsageBorrowingFactorLong": "0x07a8457e82e785125d34722525f0e0e685316a513e5ee6f04b498087b8a275d2",
+      "aboveOptimalUsageBorrowingFactorShort": "0x24e05cd21e1f4f1d94567f773480d72250104265a10ad7e481d8cf73b9cc2e5a"
+    },
+    "0xF913B4748031EF569898ED91e5BA0d602bB93298": {
+      "optimalUsageFactorLong": "0x4df8b45feea6d2963f1486e881aca59dcb247f56f3e04845bc08562668d7e3f6",
+      "optimalUsageFactorShort": "0x1564077b0c2d200ac2167eaff02ffb59f62989c06694002b95ea4c486f68bf2e",
+      "baseBorrowingFactorLong": "0x16a3c67f0ea673365b1c4576f7c65f04a31c670bc0b0cd5984899841983818a5",
+      "baseBorrowingFactorShort": "0xbd0c22d6bbb01891a8d5f49e47458bc67a973cf226f93ebb2229a5143f205b26",
+      "aboveOptimalUsageBorrowingFactorLong": "0x42c7e1c1e8383280f2b7b6f41fef279b7de9d6ef844baeacbbc3ad1d67befd59",
+      "aboveOptimalUsageBorrowingFactorShort": "0x0cf0f56a26e557abcba53daa2391caf2ac97116f0289e58fb0b561a1aede0cbe"
+    },
+    "0x4De268aC68477f794C3eAC5A419Cbcffc2cD5e02": {
+      "optimalUsageFactorLong": "0x86d3de0a019f225098a60cdb9d7e21ab24d699cc47e2c31db8d0a5f72b1572a3",
+      "optimalUsageFactorShort": "0x3a604d2a245cee3e332f8c2af4931dc72f924b0d49ea8bd749e38b9c6fc3ae80",
+      "baseBorrowingFactorLong": "0x9818632b65d01ae14408c0e4981045e091d5f425cc05e25eebda63a04377a520",
+      "baseBorrowingFactorShort": "0xbbc7fda5e339cfdee4de6c34c72df7716f622b07f0f91a106dec58918397a91d",
+      "aboveOptimalUsageBorrowingFactorLong": "0x8d2a697a83b4b34e4ff24897e9339767ea6809e0cf6f4a0f72fd4e9c6bb7c76a",
+      "aboveOptimalUsageBorrowingFactorShort": "0x0d9606595ac223589c6c0e6e8b40475bafaa63e12da2980cb4819790d276926c"
+    },
+    "0x947C521E44f727219542B0f91a85182193c1D2ad": {
+      "optimalUsageFactorLong": "0xf3e64603926be37b6b2562d4f3170766259becf591daea808b0bd9886327de90",
+      "optimalUsageFactorShort": "0x929e03c53ef12a6d8478491778b82373ff4e986cd8f45a10446bf8ab82fedd1c",
+      "baseBorrowingFactorLong": "0x951e8fcec3489d892830c6c56301630bc36f14483507ce1d439d5ddd15fe3308",
+      "baseBorrowingFactorShort": "0x090b0040858c9c674a53d140621f9bff7f56a260b54a6de69bc1996ea3df566f",
+      "aboveOptimalUsageBorrowingFactorLong": "0xe88814f2fb3ab07c280f66bd31b9f4aa6540dcf530081f1b747166fd7a329bc9",
+      "aboveOptimalUsageBorrowingFactorShort": "0xbb3838087bd1b2f6534bcb7d72f2bf9bffb871ad3084d9cf413417bd9f332a3c"
+    },
+    "0x2347EbB8645Cc2EA0Ba92D1EC59704031F2fCCf4": {
+      "optimalUsageFactorLong": "0x2c3053226bdfb226d42d53af6eeb4bbac1d17d56798e25a625b7b0a08042a981",
+      "optimalUsageFactorShort": "0x4feddec8819871dd05aa7543a846a90bb1d2657a12665e807a49a13c20aec22e",
+      "baseBorrowingFactorLong": "0x30f0541fc7801155864d3591e006af078f3c9765bfc8e05324be7da9d8b7146e",
+      "baseBorrowingFactorShort": "0x53cfa8c89973d1f35bf07296010c6d6a3e4bbf0ffc6342c484eade343b08afff",
+      "aboveOptimalUsageBorrowingFactorLong": "0x2620c46b82428590d0078686fcde4289794adf54b38673056a5217e06cf0ad9a",
+      "aboveOptimalUsageBorrowingFactorShort": "0x6e33f746e16f3319f9369024021d1582b5cc5849d872deaddffbf6fe4bc4d6bf"
     }
   },
   "43113": {
@@ -939,6 +1157,64 @@
       "baseBorrowingFactorShort": "0x3755d19ffde034f5b43c13d0b7904191836ca26a80930493bba489db125153f9",
       "aboveOptimalUsageBorrowingFactorLong": "0x80a3a0af00d7c7d55e7bfffde6bc8ea69b652dafd94d7ebe4f20b2a4cdb7537b",
       "aboveOptimalUsageBorrowingFactorShort": "0xe08a60ae243116c5d4e8f5c2df48367eb2edac52889485b82e216877ffb4ff34"
+    },
+    "0x94cE6F65188a92F297C7f0A5A7B3cAd9013450F8": {
+      "optimalUsageFactorLong": "0xdad8117f7fee5bcf38f4a80a250f295a804aacddbe6d0aa0f54ed0505ee815f8",
+      "optimalUsageFactorShort": "0xf6cdc9a2c99dfe219352a58f2333c48cc3b3c26c6dea227e6ff149fb94577358",
+      "baseBorrowingFactorLong": "0x6af5259295536b9538c074343abc5a63533f2cf9f25b5fa179d75b636da84737",
+      "baseBorrowingFactorShort": "0x448565c511e8f1589122ba03c1db3da1afa9d89a9036e7d9c55bada44d3d8f43",
+      "aboveOptimalUsageBorrowingFactorLong": "0xa9e22e9d3e4438cd0c056f6f9e39b103e741d9c87a30625643f02ad053731869",
+      "aboveOptimalUsageBorrowingFactorShort": "0x1ecf10a4f1f28b4e3c1f1fae6af7ea5a7e93d90844720b89b38509945c507896"
+    },
+    "0x1cb9932CE322877A2B86489BD1aA3C3CfF879F0d": {
+      "optimalUsageFactorLong": "0xfeb1075a53052e6633557a43a3179d4f1e67a1bc65835090c0782a99157ff15f",
+      "optimalUsageFactorShort": "0x07e0865031240e0e59fa57e199cf9128f507c871b33a59652362b5af659d430a",
+      "baseBorrowingFactorLong": "0x574b6a64053b8229c5bb6979599ea3f5093eabdadbf85ac47b0ba855c87bc9bc",
+      "baseBorrowingFactorShort": "0x61b2bf5ee8c0abafb81996ae64f534c17dc690a453b62cf2151e26e5ec2f8229",
+      "aboveOptimalUsageBorrowingFactorLong": "0xd42c10f47376a3705a0244fba83a2b52714b4742dc4e285b9b0cef38e28ab0cb",
+      "aboveOptimalUsageBorrowingFactorShort": "0x15d1b15dc1999636db607f963394239311b8b4119e830801d9bc28df041d3bbc"
+    }
+  },
+  "421614": {
+    "0x482Df3D320C964808579b585a8AC7Dd5D144eFaF": {
+      "optimalUsageFactorLong": "0x6758150d36bd49f2cf7e45b455012350f4c1146c13bdbd4cdc28ea55cd71e316",
+      "optimalUsageFactorShort": "0x9a7ec04e07d2316bd65469899746e1c285db5bbe3240ef4060e3c11ce8ae4df5",
+      "baseBorrowingFactorLong": "0xb53527bebd470fb83050b3869b09b97e5ebb9fe3f180833281fe71ccaadb200e",
+      "baseBorrowingFactorShort": "0xfcece4d6deca50446c64fa5fa5d2af6f6e49692abe4364f7f58013e80afa0dc4",
+      "aboveOptimalUsageBorrowingFactorLong": "0x3f884f571097eadcba55b27095cdc82ef3dcb2b79e0838e8ee71a01affed0816",
+      "aboveOptimalUsageBorrowingFactorShort": "0xb36cf9dd1ae5b776c21d7b0a6e469614d7067d23fa42751ab174a736afb70629"
+    },
+    "0xBb532Ab4923C23c2bfA455151B14fec177a34C0D": {
+      "optimalUsageFactorLong": "0x75fd219b8629177fb7acf93eaa7fac5870e2cc069e203920a41b4a37aa010f9c",
+      "optimalUsageFactorShort": "0xe454ed049bb948c915476a75b235a24c447372eb2cb7007200012a1052195448",
+      "baseBorrowingFactorLong": "0xafe05d9f07f23a276e58ed97f1a88191d4316b3222c1f214bd3e99511a85c892",
+      "baseBorrowingFactorShort": "0xcabe7245363c65f9bf212740bad39323939ea9d58f253cc03b17fd7f2ca1e83a",
+      "aboveOptimalUsageBorrowingFactorLong": "0xf32454317f5f8ee7728d4dea105693e9e39b19b4873097108c6aa10acc3f5dad",
+      "aboveOptimalUsageBorrowingFactorShort": "0x9d6bfae49b9a43ddd279d371ae2d2411e79cbe4d9cb9df90aa0a8b7b3251f62a"
+    },
+    "0xb6fC4C9eB02C35A134044526C62bb15014Ac0Bcc": {
+      "optimalUsageFactorLong": "0x39d0409d01146b0ba49cfcc3c9b8acf01330e70a1f331c10ab5a1c62dd7d6019",
+      "optimalUsageFactorShort": "0x4a0417fe45068725e2e3cb65912cc361ca6be12a1ea4cf49c72d3cdb9484a098",
+      "baseBorrowingFactorLong": "0x543d708670c459c9f8d99df36fb9bb1439d70254316b5115ab20663c4882f1a1",
+      "baseBorrowingFactorShort": "0x744984e2df298f85753485477cb5391581b19da90c81e982469f960b237f784b",
+      "aboveOptimalUsageBorrowingFactorLong": "0x9cd4468687a60514947b2540388be2b30e0460c34e0918f963f549c378a16cd9",
+      "aboveOptimalUsageBorrowingFactorShort": "0xf09c1ae2f99b6ee3757da419eff4dccc064a486e3fd0e9aa738b6ca32e76bb77"
+    },
+    "0x3A83246bDDD60c4e71c91c10D9A66Fd64399bBCf": {
+      "optimalUsageFactorLong": "0xc51db96778409d633aee5ec25d8fecda981ed0771fe9ea24a6d8f5f6c98418e1",
+      "optimalUsageFactorShort": "0x57dc47eb52a0a422319dd2f0e97b6df1b5d268611c38a0b822cb5b07317331d9",
+      "baseBorrowingFactorLong": "0xfe52fceebf4b2604b07dd8e7e0c6fe439d7b7f1eea5616eb9cf271928a76d817",
+      "baseBorrowingFactorShort": "0xc5c09d7b447503db6827286e552d6fa64e91ea3f8a3d1f71617ce492aabc6a53",
+      "aboveOptimalUsageBorrowingFactorLong": "0x3ee19bd398d803e76c7bffbb1e7300dc675b8cea1e3b39b514164eead7a6b549",
+      "aboveOptimalUsageBorrowingFactorShort": "0xb3a445394f1161006fc1f9159b741726c697158bd79724039c1d9f07033aff9c"
+    },
+    "0xAde9D177B9E060D2064ee9F798125e6539fDaA1c": {
+      "optimalUsageFactorLong": "0x7136f26f09b6e9de850ea3cd43b4f6a60779ff34ba9ac83e30fef73389bf3ba1",
+      "optimalUsageFactorShort": "0x5537de50a15619be6b974fec617f4282f8b82cc29c22479c91e6d8e85de313e7",
+      "baseBorrowingFactorLong": "0x341ce2c61502e18c0a11d0889850a521bfd796e443b84c24aed2a5d1cb4ec3c4",
+      "baseBorrowingFactorShort": "0x08ebdf8759d1b00beab7f018572ca0db3f029ac3f5608c11bd22a65c9e7540ff",
+      "aboveOptimalUsageBorrowingFactorLong": "0xfa8a2b862611b3e908f294a3daad7a493fe2665e5a266b6297b59662b2d487a5",
+      "aboveOptimalUsageBorrowingFactorShort": "0x56ee4e8daf9b4eb0d069222038c5e55ae54264aead84d9499839eef176e12c2a"
     }
   }
 }
\ No newline at end of file
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/prebuilt/hashedMarketConfigKeys.json b/src/Managing.Web3Proxy/src/generated/gmxsdk/prebuilt/hashedMarketConfigKeys.json
index 2b745614..665021d9 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/prebuilt/hashedMarketConfigKeys.json
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/prebuilt/hashedMarketConfigKeys.json
@@ -1,4 +1,174 @@
 {
+  "3637": {
+    "0x6682BB60590a045A956541B1433f016Ed22E361d": {
+      "isDisabled": "0x3d55f7974525cd741933a7186e9a94c1c4487633e482fb2b5d373be0d62ed264",
+      "maxLongPoolAmount": "0x9e6c1bd0ddfc11aeb615ef5bfe45fbff2f7990f19ed2121fca3c337b14a157e0",
+      "maxShortPoolAmount": "0x9e6c1bd0ddfc11aeb615ef5bfe45fbff2f7990f19ed2121fca3c337b14a157e0",
+      "maxLongPoolUsdForDeposit": "0x35fc0eea75eac98f81bada4885b906c3d1712da20eab960d1ed7036a18e9b66b",
+      "maxShortPoolUsdForDeposit": "0x35fc0eea75eac98f81bada4885b906c3d1712da20eab960d1ed7036a18e9b66b",
+      "longPoolAmountAdjustment": "0x2f5eb334e2d63b490428a2c894148cbab55638c28f5139dfcad774e04d99c43e",
+      "shortPoolAmountAdjustment": "0x2f5eb334e2d63b490428a2c894148cbab55638c28f5139dfcad774e04d99c43e",
+      "reserveFactorLong": "0x52cc66676cf0564a00d6381240725a00bea4efc226e693dcbfe56d74fa96c7e1",
+      "reserveFactorShort": "0x6e3893b66c4b4808b05fa668c2798f32edc4272887973f5d74bd095553ddca1b",
+      "openInterestReserveFactorLong": "0x0db424b730817efdd449a3efc33d03f985a9a6068cd24759821702eb87c24333",
+      "openInterestReserveFactorShort": "0xdfd759f163b74b987e08cf287a549abc78ae8ba10ae8e9cc0b9af367eb210963",
+      "maxOpenInterestLong": "0x236abae8e432ea183038102c2503f642e085d216fbe7bd27b8731ba63eb87734",
+      "maxOpenInterestShort": "0xf96ba95eeae1dbf7f8d644feca7088eec422218a82c48a4711f3fd8c0ab5cec0",
+      "minPositionImpactPoolAmount": "0xb80478fd242df48903aab560d5ca3737544b0bb066248ca1bddeaaa3811eb573",
+      "positionImpactPoolDistributionRate": "0x4b780be673ba896e1d434d83567b3baa1c81df5a334b7ca493fcb1544a60792e",
+      "borrowingFactorLong": "0xb2529abec3c904f9807e19969849552af7e4f40b07edc717ccc4df6f003e0b0d",
+      "borrowingFactorShort": "0x2d38837766d17609b901e24027eac88ee7f927f945525aad00054b752f1ac22d",
+      "borrowingExponentFactorLong": "0x6a32ea6e2836d08704af2ff6f2ee51754540285022bc911cb226e4f0af631a6b",
+      "borrowingExponentFactorShort": "0xab8319c244b0f949a90354c2a235caaaef7d9be4c1e394bd333fbee797220cf9",
+      "fundingFactor": "0xc87297974cfce7b9fe4cdbbfb73810b80132272fe7816df6a3f814ebae341ae8",
+      "fundingExponentFactor": "0x234a76ffcb4ccc045707ed3981718440028958d2c24bab91d61f2b09d5138828",
+      "fundingIncreaseFactorPerSecond": "0x63bee042a1ed12be345331348c8061b5fbc8f6971fb5084bb8854314b0dbc179",
+      "fundingDecreaseFactorPerSecond": "0xcef99b035323d48fd79d2555e60b4bf0fe41e8b28b9129705dd64b9b45f4f822",
+      "thresholdForStableFunding": "0xe73182554665812c9c2a31fba3a15ec86b7ad0bbd21f94becd7d69c8ee7c8a34",
+      "thresholdForDecreaseFunding": "0xac8252681b1c7bc56211350e686c8c2bff36313de016de9deac4f8db5b3b2a8d",
+      "minFundingFactorPerSecond": "0x9e341157834bf89fd5572a8c15124cf91e9a7016628be675766cf756ba2e1653",
+      "maxFundingFactorPerSecond": "0xf880113d343712cab3812feabf11130764ad8d4ce146fcbff76f6351565d2f17",
+      "maxPnlFactorForTradersLong": "0x18de6c5527ecbd4cdcb5e91185c0b31d6a725508c3f6c07d1104e3d30618bce6",
+      "maxPnlFactorForTradersShort": "0xdc6d824c4b03495ea4fd0d98b1f6a57069b5ad662490a91d6f44166e0d33c48d",
+      "positionFeeFactorForBalanceWasImproved": "0xf9d4c5d5fa290d04bf7b517af61f419cc12f0c591c15f8a0956cbd3fc5ff6bb0",
+      "positionFeeFactorForBalanceWasNotImproved": "0xfd0c7ba47ba7bdd1f03ab209f90075b4b97bd978f952e1f296658e93010823fa",
+      "positionImpactFactorPositive": "0xa4239fa93c7d5c36884e2bfeb9fbfbaec17026758f959bafd260799080ae5541",
+      "positionImpactFactorNegative": "0x19cfb0f7abb434cc833aa334e452092610e3ce15814c4458fcaa27bfdb521f16",
+      "maxPositionImpactFactorPositive": "0xfc5bed622848c4e3e455c308358b9909d5c8b565bebb2874dffd1d4f54eaad2b",
+      "maxPositionImpactFactorNegative": "0x6be447408c855216316c492f3f14b036eea188f1b5e003014c0dcd607382cc04",
+      "maxPositionImpactFactorForLiquidations": "0xcb99d885f7f3f027e0358eb5ec14e6191d1138e3fbdef65a26ed61fb60102f20",
+      "maxLendableImpactFactor": "0xb3b4d74b781ec6f82e806ecd6ce4cb612a17981e3f5a33ebba331f9b374305d3",
+      "maxLendableImpactFactorForWithdrawals": "0x70a96897ef7c782fa079c3c699e0db2961876bda507b913949cda60d449094ba",
+      "maxLendableImpactUsd": "0xf5cfdf88e82055ee2d11fe3022611436d86010b01c8535d97fa35e312d9b17a4",
+      "lentPositionImpactPoolAmount": "0xa9a8e06c724cdb1ec3731dd2bb477864ab9cd6b77a38087e2bedae1678a9354e",
+      "minCollateralFactor": "0x7ed8bbc84a504f7593aeb499af806615332528c198809a44c6e5dba3e0d72e88",
+      "minCollateralFactorForLiquidation": "0x4ad6ed9b76315a721ed0263f8e550ae6e6dc5ed2bc623569492a2d94a64b0083",
+      "minCollateralFactorForOpenInterestLong": "0xf6af02901769f5d0431c90ada09d6c367624e1076786532fd2ce8e6d717667a2",
+      "minCollateralFactorForOpenInterestShort": "0xaa5c6a876f5b9214f7f2ab110afac5d785b3fe106ac7cd7a0d18984414c5b6d6",
+      "positionImpactExponentFactor": "0xc803b8cb75cba8e65bcdb755850a3b00ed19f35a17433db4d7b00c0ff8d3c3c6",
+      "swapFeeFactorForBalanceWasImproved": "0xd2f7a87d5d57a855fe4a2f329dc1e09ace6cb08c7e2836429f1d102e810972f0",
+      "swapFeeFactorForBalanceWasNotImproved": "0x08f90c2709ec73ef9e0fcb703ea79aba37782b5569c8d8382a4028b876a4baf6",
+      "atomicSwapFeeFactor": "0xd150b7f649c4be53a26b4b617b831c4f675acdd63f8b8974388503c3560ddb6d",
+      "swapImpactFactorPositive": "0xa3eb1cf6b16b64b67753729439ad7f9a154facab21aaa09cadea6e51ed69fe47",
+      "swapImpactFactorNegative": "0x96fdadeb1e61115c586f2886fa40f103f462d1a508917578820872f807d214bf",
+      "swapImpactExponentFactor": "0xb4bf08b3260bb5825adc61b0687ebe04c39f9e2991a2019fac11bdd22a3a6de9",
+      "virtualMarketId": "0x35d3376aa74136175cfddaef4f2f591d8e9f39213a61994f9a00549c6bc04520",
+      "virtualLongTokenId": "0xe47cf033d5b118f5fcbd7eac09913b24cfc4b2782f90e71a8dd0fe7aa4f92e7d",
+      "virtualShortTokenId": "0xe47cf033d5b118f5fcbd7eac09913b24cfc4b2782f90e71a8dd0fe7aa4f92e7d"
+    },
+    "0x2f95a2529328E427d3204555F164B1102086690E": {
+      "isDisabled": "0xa5d68e9ca1430de8b7547d8e76a8af2263443d58c5268fc5d7951d7a2d017aa9",
+      "maxLongPoolAmount": "0x0df5109e027347751ec75740cad914fcdf4f56c99957efd894fe565cd5540653",
+      "maxShortPoolAmount": "0xd197e9ffcc4bb7ad241307d84d97e23ea8f99db8e75555da273eb557038ca7e9",
+      "maxLongPoolUsdForDeposit": "0x3808bc29403b6ac98cc711a3b18834b556e3d49c9ede22acb6b6f8a4c6058cc4",
+      "maxShortPoolUsdForDeposit": "0x46cff86409ac994cffb17f34dd0e50e4a44f3b908c1bad57c4379cea5228e60d",
+      "longPoolAmountAdjustment": "0x6218a389d661d40a1212995e02d62c02b9d6a8fb1791155296f35a164cabc776",
+      "shortPoolAmountAdjustment": "0x3bcf69f3d14fa4819af04851d9e4a3e848715863cb046d7a2b21f6e256618ad3",
+      "reserveFactorLong": "0xaea7150d6795f993986bba93c83082900730d0f68f967ddc1a961d675ad9359e",
+      "reserveFactorShort": "0xee715188057a7239a71c0970438bc6ce3ba2b03dc0b6c89ca2ff3874f6853db2",
+      "openInterestReserveFactorLong": "0x5aed369e56460e85709c8498f42b96e876384d17830c4a087717356197863a9f",
+      "openInterestReserveFactorShort": "0x1e7e067a5a1c22a74730b008f74958610ff64f6c5db6a3b5c267caba1383645c",
+      "maxOpenInterestLong": "0x9af6755ebf3446860a63e123b5cd1fc40f12d12f4588c4672f31119d9515fd6b",
+      "maxOpenInterestShort": "0x474450c9bf48c6bb8dfa3bd2785c1a891a9a2a8321ee156863dd861952d907f8",
+      "minPositionImpactPoolAmount": "0x32f12883f34ccae3cefd4d0064ed2d0413c6b2f45d928ef0c1a86d266fd8c723",
+      "positionImpactPoolDistributionRate": "0x2f4cf8e502a7d3ee91e7339b6bb751b9c2dd85792a1d0d04e822151cee52df89",
+      "borrowingFactorLong": "0x1df1061eabdf79ac4a85e9c4997260f09ac38831046818cdd3352b5b401cc1b9",
+      "borrowingFactorShort": "0x528dc382b47150767d36ada5582539d0b293e30eab97ce8212823b3daf77c56f",
+      "borrowingExponentFactorLong": "0xce4946aa505a4ce985f7d1d5f2edbca8fef5d790a280ba87bec5e400dc9cfc65",
+      "borrowingExponentFactorShort": "0xf9d26bf3021b500d8c006928c0d30388bcd31085af2d269d82daf2bec82ea93c",
+      "fundingFactor": "0x7c51fd945ceb3fa8ad0deaacda576e02cf889091a3428585c6193fecb4994059",
+      "fundingExponentFactor": "0xcba0a23da2d9a222ad306fdd480a6a7bbb39519f2ef34edfa8ca456e65b98037",
+      "fundingIncreaseFactorPerSecond": "0xcece4296349961be633a61514fac255232e537e5cd1dc0be55ec3bc2148b6ac9",
+      "fundingDecreaseFactorPerSecond": "0x4a842021359b25eb1d12b9d4f68de248662e025046591360dffa524b66096b9e",
+      "thresholdForStableFunding": "0xc7cd91e39df08bf4d63f8b3909989bf226246c9fbafff22455dd4c20423be21d",
+      "thresholdForDecreaseFunding": "0xf0089038c3ef050413706ae6d104bf5ae69baf83573ae6e041d6dcfcf066f84a",
+      "minFundingFactorPerSecond": "0x75263e6f913ee229cf0afe08f3a1c64e725c5d2ebcb2c908bbb3d35ba39d47ba",
+      "maxFundingFactorPerSecond": "0xfcfc49fdb6d57ddb08658d6d6d25c53a4f3d500e69c6e6049722b593ac53f76d",
+      "maxPnlFactorForTradersLong": "0x6d7460d4543897cfb4373a1d5eaeec93a5032f39f573a936a205a6fbd6594ca4",
+      "maxPnlFactorForTradersShort": "0x58542f1aec8f133258f6c8474548a8812815c7d182f79962a59893ae18b38c54",
+      "positionFeeFactorForBalanceWasImproved": "0x4af350796a03809751c38802108bc15fb788c0233254797527d79743603199fa",
+      "positionFeeFactorForBalanceWasNotImproved": "0x1e56383917330162ee938d9d6e4567c417bcbb84e75ef46a71f07c2e2994d810",
+      "positionImpactFactorPositive": "0x8301e78d67eae4dcd2dfda129a7805f3bddeba3b2ac08087241568595926eb1c",
+      "positionImpactFactorNegative": "0x7f8eab1f73f4ef7822d1b98fdb0e8ab427f134e2cfd8741e6ef4dc9ca9c6b621",
+      "maxPositionImpactFactorPositive": "0xc646aeff6a40d8e58e806be1d4cb09a381114176f0d41d24c0c84bd48985aeab",
+      "maxPositionImpactFactorNegative": "0xaba0b2684cc102be8fd5f7b30a5a6145685486fcf0716a940f38a819b5e4ef05",
+      "maxPositionImpactFactorForLiquidations": "0xce239b525e44abc42127078a80acc0ca884808425048ab0d2121cebe16e7f98c",
+      "maxLendableImpactFactor": "0x658bbfa2b1b2de1d796e9f42065f3fa4f04f40c1c13f9dd7ba9b31fd45f77409",
+      "maxLendableImpactFactorForWithdrawals": "0xa54e8211f80772d6b427270405b6196679ec52fddffd0b5bc94e3b91a7e8b0ae",
+      "maxLendableImpactUsd": "0xcd2081c201e37d58d61de758812d8b5c9bb64461b216e162c2dc412c128f6a73",
+      "lentPositionImpactPoolAmount": "0x09e59e71260c00a444e1d9c964c22fb3ac89e8181d66b479468b235b3a12408f",
+      "minCollateralFactor": "0xbd15bc48a477042fe084c278c9596a903cb537c13f134405e2e59ca977784a0d",
+      "minCollateralFactorForLiquidation": "0x41a57a040d3da82057a2affe225c24c19c04b76c3e7fe0fe5043304ce5ceab11",
+      "minCollateralFactorForOpenInterestLong": "0x9d952e960da486bb07fd5da270a9f38c80dd0c394d4fb940d08357e82f052e73",
+      "minCollateralFactorForOpenInterestShort": "0xc4f39f26f1ebe2c2b425c07a1bd72b91ec14e54bdff50e69cd84cb57cfe9964f",
+      "positionImpactExponentFactor": "0xb3eecb6e2939f73b7f6ce67479385071d99057835f8b6d5cff1255c57424cbf0",
+      "swapFeeFactorForBalanceWasImproved": "0x4bb062bfb969a41fb8ac9a3338dcca06a312d60aa511535de9b290de56008e6d",
+      "swapFeeFactorForBalanceWasNotImproved": "0x4ea0ffd481b6caa50138a2c69d320b236cadb1c69536683ef92e93454acaba84",
+      "atomicSwapFeeFactor": "0xd7a0acca1804516a01dd5e0058950cb3911bed3405408adeb025867ccecf1da7",
+      "swapImpactFactorPositive": "0x849e771df499463b3a5aa83b5bc195e882c5a28bf0ec0d3f060d82ddb3fc2024",
+      "swapImpactFactorNegative": "0xaca989b67d45cf4d4a0e9d12ad35b0e21a61196eff7882388a0d164c646c9499",
+      "swapImpactExponentFactor": "0x20c976853f23f3c0844cbee8733addcad9a4e2d8a57dc7729ef21eee841a1266",
+      "virtualMarketId": "0x3a05f8c8f61bf8c5c62929f1d68a9975fdaf88e589d39e6c70bdba44933c7ca5",
+      "virtualLongTokenId": "0xe47cf033d5b118f5fcbd7eac09913b24cfc4b2782f90e71a8dd0fe7aa4f92e7d",
+      "virtualShortTokenId": "0x7bb231dec6009cf7c97d392e1a14075f34e82077fd9c20cab34ffae7bd46e869"
+    },
+    "0x6bFDD025827F7CE130BcfC446927AEF34ae2a98d": {
+      "isDisabled": "0x8e24e1778db0501560129a065bfc40411bbf47fb2ba51b7e8f7c3d5318dc0f48",
+      "maxLongPoolAmount": "0xeb9c4d6e6bc4ff040d5c6bebb881b52ed810f95c7bd1a4b1363f630d7f077474",
+      "maxShortPoolAmount": "0xeb9c4d6e6bc4ff040d5c6bebb881b52ed810f95c7bd1a4b1363f630d7f077474",
+      "maxLongPoolUsdForDeposit": "0xb1999c69ae4c9c835bf4f561503b6fb611e2891fe5a8d6b07c24be0dcbfbfd90",
+      "maxShortPoolUsdForDeposit": "0xb1999c69ae4c9c835bf4f561503b6fb611e2891fe5a8d6b07c24be0dcbfbfd90",
+      "longPoolAmountAdjustment": "0x698b22439d75a4a4a632f465c8e8acf37fc4052fd4b5726e631c1d3ed61c8107",
+      "shortPoolAmountAdjustment": "0x698b22439d75a4a4a632f465c8e8acf37fc4052fd4b5726e631c1d3ed61c8107",
+      "reserveFactorLong": "0x0d708f32e50b1b8f86c6162d0c66137e969740b638eae5bc2b613f569e798e37",
+      "reserveFactorShort": "0x0910db514f13e6b1b5c53c5536c1f8986d7a1548ce6c3aedf3786ab38ccb9b30",
+      "openInterestReserveFactorLong": "0x9a6ededc474e2f41c503979285269cc1fea055963819e9cfdfee91076cf14116",
+      "openInterestReserveFactorShort": "0x978a526cf86c6d5fdba4297e740224872fc82e99203ca30ab29daa2060fdc225",
+      "maxOpenInterestLong": "0xad0523af0abe36bf0e738ecb9e1a4892caddbdcb48181f40991c160ab9e99fa4",
+      "maxOpenInterestShort": "0xcbf662387e781fff4400a94d1bcce331a086840205ee4480ae74ac276cccebd0",
+      "minPositionImpactPoolAmount": "0xcc62c4e8b62f748f4d160ec9e54e8b52ef0360065f1ae9ce75889df394f81cf1",
+      "positionImpactPoolDistributionRate": "0x22527ef2b0465bfab18efe67469e9f4a8b6f648eef8b73842783750b2a91da28",
+      "borrowingFactorLong": "0xe59b8b5526a52391872539001bd3df495284c8810b11ae8e88b325ab48581630",
+      "borrowingFactorShort": "0x0fd312459faed9817a5a2ad8922ea5e28b39cefb756bc7d0b93194cbf2421c0d",
+      "borrowingExponentFactorLong": "0x0439e6d4b77e2a7da906a34066bbc58a7f88bec12f95fab999f8a39d43f26ad6",
+      "borrowingExponentFactorShort": "0xc04eda617536537b4201f88658001a3d60e8a7406863f1e8223476e9343cf2d3",
+      "fundingFactor": "0xdbccbf67cbda1758a7eba355507049504c700df008c728bce5b6429ab47c1410",
+      "fundingExponentFactor": "0x870d5ae9876ec1fd806630c5eeae64c6c8afb813b09aaad24aa1590ae2cad87c",
+      "fundingIncreaseFactorPerSecond": "0xb4e9321f679bba9ff00e3232a142d3d0266adc9a2e1c3318aed0af27f0ef531e",
+      "fundingDecreaseFactorPerSecond": "0xb234ca152920d723b1a3089b55ed4bfa8e4171d402e294fe2cc7a0740a1668fc",
+      "thresholdForStableFunding": "0x1c3ff30d5d55d4a94959c55e8f29137f683b31b2c57491642d1cf7002e7e038e",
+      "thresholdForDecreaseFunding": "0xe16d00fd817bfc3df793a4968857a239059f9e13b3405146492a4a3319aa27b3",
+      "minFundingFactorPerSecond": "0x24fa40f0203d3ebef32afdfca510fdd2e50b02d478eec7fda263ab6542ab56e0",
+      "maxFundingFactorPerSecond": "0x5a6134016c035bfffcb21fc2809587b0fa5b3e556162e82a535b056e6ea54b68",
+      "maxPnlFactorForTradersLong": "0x63eeece3bf80287fa9fb7d6e04e1d79ec8dd3f1df5f2c6cf7f3cd7a0fbb13834",
+      "maxPnlFactorForTradersShort": "0x1e4dd44f3f0459fe502755579c34b9494e68d7e023663955e9354bc25aa48364",
+      "positionFeeFactorForBalanceWasImproved": "0xd98fade7af9578cbd174c2f64055ede1559e56298e99e2104e00f1453893fb72",
+      "positionFeeFactorForBalanceWasNotImproved": "0xa383623178ff731293ce6eac7671a17ff11cf83e6642b2786af012c95f92db50",
+      "positionImpactFactorPositive": "0xce514a8e429c0d44bfff47cea0d289e9e760b1b28dc193749fda6e8506f25e3c",
+      "positionImpactFactorNegative": "0x5f630a7956732b0817c7986736e0ba662952a3e06ab6538148b76cb32a4bb5a3",
+      "maxPositionImpactFactorPositive": "0x6300b13437d9a0d96a62ba0da66443df91dd794220546cdc550eb60beb03c826",
+      "maxPositionImpactFactorNegative": "0xff404de67c0b942e79e928e22942dd79b5600bf92ac747ccf35cc81e64f4f516",
+      "maxPositionImpactFactorForLiquidations": "0xc9c06eed1436e553e6cc768636d82c351b67462238586458aeb0593e58b83480",
+      "maxLendableImpactFactor": "0x00f7e298035fd0489e5684f68edd8007a30c90cf845dd4414d315179a740dbf7",
+      "maxLendableImpactFactorForWithdrawals": "0x6bb138b1f713ee7af70636d267357ca61715b92e2872c36129ddf72c692aa0a3",
+      "maxLendableImpactUsd": "0x838407f1b29bc14b64743ad319ba863818b6030de20b716eef108b01b80325d7",
+      "lentPositionImpactPoolAmount": "0x442013a39a11f2dffdc8e5c62979abc7555481843ff3f7fe8b8a19daabdeaa8a",
+      "minCollateralFactor": "0xcd93d636a3d94818a19e2935b5f42cc4bae73e41c1bd9187dde1fec46924a6b4",
+      "minCollateralFactorForLiquidation": "0x3e41b2e14a4c728e9642f31e79846e7deb22a24feae6ccf6dc92f1fc0c5e859a",
+      "minCollateralFactorForOpenInterestLong": "0x223b38a763d5c6d1491fd45fabecfd4c04b4f8f61778d8ceced8f12921458b9c",
+      "minCollateralFactorForOpenInterestShort": "0x23b2ddf33c216cd62a8f20e0f3bdf3462bc508bf83ccf6ffcd1e1da2fa441835",
+      "positionImpactExponentFactor": "0x822d156e2f4eac206a436a3826ef14b7e28f80a6b797cdcf2e48700518f3cb5d",
+      "swapFeeFactorForBalanceWasImproved": "0x898c067070bed020aa6a881338f66cf7a27aafaaec39fdf10a667a124e9c00fb",
+      "swapFeeFactorForBalanceWasNotImproved": "0xd27b69dce975cffcfbd239a58f7e1865719df4b5eb74c074a750e6459dfc057d",
+      "atomicSwapFeeFactor": "0xb7b0fd446d2505bb7aaceb2616f7d4766db720c6f938bf6b0e7b923b13b7c120",
+      "swapImpactFactorPositive": "0x257d59b0ff05ca7063136a8bab2b182646d022866c6bb60bf5e1a951f56a4f33",
+      "swapImpactFactorNegative": "0x225da45bd850b96bbe246e4f7f53ed51dccb165b1d1a16d2c4495d2bf1c01cbc",
+      "swapImpactExponentFactor": "0xeb7228e9a1df1390c683ceb4a31577ee3381b679d41d04220e18364c641c24f2",
+      "virtualMarketId": "0xb2c10f2870b97107ac5c5ab983e9238eb8cd9447c1aee87550b62df0406414ce",
+      "virtualLongTokenId": "0xad11454a7b68db8683667df39c97a96eeae88909e5fb849428193697b0dc2492",
+      "virtualShortTokenId": "0xad11454a7b68db8683667df39c97a96eeae88909e5fb849428193697b0dc2492"
+    }
+  },
   "42161": {
     "0x47c031236e19d024b42f8AE6780E44A573170703": {
       "isDisabled": "0xe8b3327a4f36a032e9c4b5c62bd478f8f7dcb358be17e031c08af181054f89e9",
@@ -30,19 +200,25 @@
       "maxFundingFactorPerSecond": "0x4f7dc082dba2aa22249007c05bb4928623521833aa4d2993e150a90fbfa114e3",
       "maxPnlFactorForTradersLong": "0xaa8e9afe1a8ae000f057254aec33b0b038be8079bfcb184ea356dc917326331a",
       "maxPnlFactorForTradersShort": "0xfa31ea001f0ed9b3fa3d2f1deea9bf79493c211600b8f203f50dd95591e516da",
-      "positionFeeFactorForPositiveImpact": "0x4b9bdba3ff745320751079b586d3c4f84cf87f7c3e79e39f1158b174c405cf67",
-      "positionFeeFactorForNegativeImpact": "0xdd207fe702bdff93bb945786cd5d98c3259d3dbd7cf37c63c161714e938ba434",
+      "positionFeeFactorForBalanceWasImproved": "0x4b9bdba3ff745320751079b586d3c4f84cf87f7c3e79e39f1158b174c405cf67",
+      "positionFeeFactorForBalanceWasNotImproved": "0xdd207fe702bdff93bb945786cd5d98c3259d3dbd7cf37c63c161714e938ba434",
       "positionImpactFactorPositive": "0x57f9be924ba0f2c763e255396dd8fdd27b3ff06fcde5fee6018b4ed0292eae0a",
       "positionImpactFactorNegative": "0x3b778e8ac16a3dc330bcceed5db97c4b853b0a696209858f5dd19591a1b3566e",
       "maxPositionImpactFactorPositive": "0x825201d62a913028fa553544c19e6e9e45885502ad94b3e9ccb79e2911daf669",
       "maxPositionImpactFactorNegative": "0xa0145413fea58392aad72c6aaba18435a1b6e00ff9346d8418c207d8b3f0ad1d",
       "maxPositionImpactFactorForLiquidations": "0xb7ab4d8339ba5934253d04b55d4141017d73b9801df9a8810ea10d1c3ea3fc6f",
+      "maxLendableImpactFactor": "0x0585fc9618ad8521b5d612e41c802de36cb4bbf6e8313771e290c791ad3fe68a",
+      "maxLendableImpactFactorForWithdrawals": "0xe44a4f4906ef59a042e098c6578cde4b0d1b58c73f98ec0779b71d31fbf6d9e5",
+      "maxLendableImpactUsd": "0x728ec84ffba417f5cd111b992612c69bee78f19ac678b1584aae070e63f455a7",
+      "lentPositionImpactPoolAmount": "0x0d4630d7cd67859e7c9d3f814f184368775b4f00da40372c8e9dc1217cda0e41",
       "minCollateralFactor": "0x0edf8a0fa860b71e689cfeb511c6b83c96d23eaf71c6f757184d23954fcb3169",
+      "minCollateralFactorForLiquidation": "0x9c713920b491455ee33d87a6d12394a42e83d5f426958697dc08a318be13ed91",
       "minCollateralFactorForOpenInterestLong": "0x18ab1bf4fdef11804a1212c94ba4ed35498ef5942b3d385fc9c33f933f17f60d",
       "minCollateralFactorForOpenInterestShort": "0xf5cca0ad2e4b2341858ed82455e0d4e3e2dc289d93124403d67c010ca53b62de",
       "positionImpactExponentFactor": "0xbe60fcfd99ab63b9f7c2a82da310aa88958ee0146cbc9ea008d8cc16a97ac70f",
-      "swapFeeFactorForPositiveImpact": "0x695ec0e29327f505d4955e89ec25f98741aedf22d209dbc35e1d2d61e683877c",
-      "swapFeeFactorForNegativeImpact": "0x6805e3bd65fab2c6cda687df591a5e9011a99df2ff0aa98287114c693ef8583e",
+      "swapFeeFactorForBalanceWasImproved": "0x695ec0e29327f505d4955e89ec25f98741aedf22d209dbc35e1d2d61e683877c",
+      "swapFeeFactorForBalanceWasNotImproved": "0x6805e3bd65fab2c6cda687df591a5e9011a99df2ff0aa98287114c693ef8583e",
+      "atomicSwapFeeFactor": "0xc125515896b48c72fad34d60a7735c27394bbfda809bac0461966a907a9dbabb",
       "swapImpactFactorPositive": "0x79d8fe854154b43d003a20314c803b78ec01391248008659c0c8e998e866d7d7",
       "swapImpactFactorNegative": "0xe8438cfb97aef79fdebd4e948dd086e7c042ae7b47a2414454f6b691ebcc2419",
       "swapImpactExponentFactor": "0xf64c72f0c430da1f9096daec486ac3ba00752a0b600ce602ae5bd0a62c004145",
@@ -80,19 +256,25 @@
       "maxFundingFactorPerSecond": "0x424c5a83737ee1e6ae9a863e64a6772ad7d591da777c4774b2484370d927b97a",
       "maxPnlFactorForTradersLong": "0x04e55b2a6b73d4cb774accdc2d7f0de0f4aa8a8ae6a084be73a43ca8f17f3586",
       "maxPnlFactorForTradersShort": "0x02badce9cdb1639287015c8989426be5963e2b0c8a41abd9723284ebff7f2e9e",
-      "positionFeeFactorForPositiveImpact": "0x914f66951bf2600e37ce4f2e2fd45983c6d842e40cda838267764e38fbad3594",
-      "positionFeeFactorForNegativeImpact": "0xe1a9164e4ffd3e27713953d91592d29e5e51e16c1df48725a919fa8785b184af",
+      "positionFeeFactorForBalanceWasImproved": "0x914f66951bf2600e37ce4f2e2fd45983c6d842e40cda838267764e38fbad3594",
+      "positionFeeFactorForBalanceWasNotImproved": "0xe1a9164e4ffd3e27713953d91592d29e5e51e16c1df48725a919fa8785b184af",
       "positionImpactFactorPositive": "0xb2d34408902891f7a1ffb5a66609a793e142ed6dffc6d7c0c8b9b9bc6d6dd380",
       "positionImpactFactorNegative": "0x68cc8c831904230bbfe2ba8d3ee911509896dac5b48cc45c1323718a54fb4016",
       "maxPositionImpactFactorPositive": "0xc230e1e4d328166be2c9c1e775203c706519bd3f17777d460f0bd159e2680920",
       "maxPositionImpactFactorNegative": "0xf0304143d99ab54dd4a90b22df08fec271f1c69fc31cdcbdbcaaf2f3f9abbe90",
       "maxPositionImpactFactorForLiquidations": "0x2d8a11f53ea0e4da886046922afbdaf2f98111c2c3617ce8d53320e5368ece53",
+      "maxLendableImpactFactor": "0x4112eb8d7aed1bb72e882220f586aaac2019f97fbf59808eaf687468dc13737c",
+      "maxLendableImpactFactorForWithdrawals": "0xeed571225e3a9bdef852f7b8b0ffaea55a32d3ca54cfdac61584c70c4d4cc016",
+      "maxLendableImpactUsd": "0xb8f98bea93a1cea67ff9bd16f527fa76903a2cc5898a48a5e98cd3d6194f5cad",
+      "lentPositionImpactPoolAmount": "0x94f7c35748bbd731455c2f94c52f99bffd762f5d4169361b85d14e2ec6cb95b5",
       "minCollateralFactor": "0xcf1cefe1a11576531900922002113a6cf623823d2c813a4534c5d181976450ae",
+      "minCollateralFactorForLiquidation": "0xefc3fc73b918e0aa9a9a9f306393b25a2919aad551cbd5c5535834b6ea9d9934",
       "minCollateralFactorForOpenInterestLong": "0xbcf38cdb77fa9cb02787c89b5b616dc4d91337a400795d617a2580ae49a6e209",
       "minCollateralFactorForOpenInterestShort": "0x635ce4b3864fcc94a0eb30789ab0eedb1724ed4bb51ebad2fa2e9a2bc051f60a",
       "positionImpactExponentFactor": "0xd3fb6cf1d6db9b533ada6f4f3e7f52adf7fa871788e67b80e7ae6e63811017e5",
-      "swapFeeFactorForPositiveImpact": "0xd795542d99d4dc3faa6f4e4a11da9347d4f58fcfce910ccd9878f8fd79234324",
-      "swapFeeFactorForNegativeImpact": "0x4a0e3a43fc8a8e48629f6d4e1c0c1ae7098a35d9834cd0c13446fc2b802a24a7",
+      "swapFeeFactorForBalanceWasImproved": "0xd795542d99d4dc3faa6f4e4a11da9347d4f58fcfce910ccd9878f8fd79234324",
+      "swapFeeFactorForBalanceWasNotImproved": "0x4a0e3a43fc8a8e48629f6d4e1c0c1ae7098a35d9834cd0c13446fc2b802a24a7",
+      "atomicSwapFeeFactor": "0xe9ea68981039e8c7bdda3234e3fc66eccc1b21bb30ec5c053662a442b6b38958",
       "swapImpactFactorPositive": "0x801066104b68a8504d32a319a865f5010a763e0b3f4372e0b03f3fe87ab77eb7",
       "swapImpactFactorNegative": "0x1a282191426197cc0dacd8fdca48acc252d354470638b44ca410893f9bc8d576",
       "swapImpactExponentFactor": "0x62f7b6ed5b17f35d4d42eb6abcaa00b07af41f4694af6f491f9bb5b31911af3e",
@@ -130,19 +312,25 @@
       "maxFundingFactorPerSecond": "0xf9eebd782b6379771362c4bac105681bfa6f503b704718bcad8352c0de19f688",
       "maxPnlFactorForTradersLong": "0x4ad6b8b2ba952450663a8d5bf31ee14ed32607a478d6cd7294fe55a4a4ef90d2",
       "maxPnlFactorForTradersShort": "0x6c1fad48bb23f5fbd6f258f605f43fb3ced23cc7af730b7a7b4e8f05687c6939",
-      "positionFeeFactorForPositiveImpact": "0x0a91a7ca843ae3371debc48312c71f1ed0ae40a087d2626c6c43fd86002de08c",
-      "positionFeeFactorForNegativeImpact": "0x8e901273173d5fd00df54a257dc627db643127f496f5e187609a3210ba484b27",
+      "positionFeeFactorForBalanceWasImproved": "0x0a91a7ca843ae3371debc48312c71f1ed0ae40a087d2626c6c43fd86002de08c",
+      "positionFeeFactorForBalanceWasNotImproved": "0x8e901273173d5fd00df54a257dc627db643127f496f5e187609a3210ba484b27",
       "positionImpactFactorPositive": "0x0c641238e5258665a42ece9c3874c8c5e0d627522aaf8c60cf0bbc5e64c5c5d8",
       "positionImpactFactorNegative": "0xc4bfa605ffb9f50e0f18e0399ccdac8f6fe971a739a91a6a726517653177e0e7",
       "maxPositionImpactFactorPositive": "0xef102c726b741df58e10ba28b7f783ebaa6c2076f27b615f9d21a4edfba791c1",
       "maxPositionImpactFactorNegative": "0x98bec1ab62f465a2a83119494f5f21c753b0527908dc422f67220e613c532771",
       "maxPositionImpactFactorForLiquidations": "0x5fbccb68c5d1de0fd2d39c7a60110688e10a969992910911b5a7ff5461a7fddd",
+      "maxLendableImpactFactor": "0x93de0069d2725e09bf4c058941d76e098ccc24e408c20d09e981af35375bf806",
+      "maxLendableImpactFactorForWithdrawals": "0xaf9aa8b02ddbf97ce8464ba2de02f40ad91ee33358d46ec67f08f2aadf3377dd",
+      "maxLendableImpactUsd": "0x80be7e0fa9db2f39a0b71c58828c1c43984f5794d61afab943e2f3882d718cee",
+      "lentPositionImpactPoolAmount": "0x1f0483a8730089f19663b082cb3b071d32c7ae51972a1c164107d45956ba4e1d",
       "minCollateralFactor": "0x832e125ad1a59ec76a096a906db0abca415fae50215a04713ba7d26b806170d7",
+      "minCollateralFactorForLiquidation": "0xb5942ec068620932b817a6dfdc8481a8d8f06dc0563a60f643926b6a103c672f",
       "minCollateralFactorForOpenInterestLong": "0x47ece80b5a8441270dc51b704ac241ee205157d6e79a17ec9a7a78d5a1c405cc",
       "minCollateralFactorForOpenInterestShort": "0x3ac33ae245dfa87c5023e2ada76a30d63b5d4a462868f2df4cf285c450c055bb",
       "positionImpactExponentFactor": "0x8185adf991484ed9941b9d357c45b4aaa04298bf56481c3ac20410b14c6e0426",
-      "swapFeeFactorForPositiveImpact": "0x67a550e4fa661b4a6f6f7a4f2f276a0dac54970e784fe703031ee403f04b4665",
-      "swapFeeFactorForNegativeImpact": "0x5f0f923b62e09d2ebb7df2b4b505d5eb8843b57816cb1fc36090965cfa939bfd",
+      "swapFeeFactorForBalanceWasImproved": "0x67a550e4fa661b4a6f6f7a4f2f276a0dac54970e784fe703031ee403f04b4665",
+      "swapFeeFactorForBalanceWasNotImproved": "0x5f0f923b62e09d2ebb7df2b4b505d5eb8843b57816cb1fc36090965cfa939bfd",
+      "atomicSwapFeeFactor": "0x10d37a7e8e1567aad34f48c74ecd3ed0100bc2bb6f7248f5bbd6a3be6c10fe2d",
       "swapImpactFactorPositive": "0x0538cdd47f4c430b1fcb396d2d4b81d55cc0fb604620d2cc1d1092d9a3d13b4a",
       "swapImpactFactorNegative": "0x7eb5c1dc27cc686df401fe1cc4a36537b363bfaa4d94f77d6fe72fd5ede61d08",
       "swapImpactExponentFactor": "0x7e561221c0f8fa07e9ca813aca94becde6d2fc0feacd84f50cadde2b177a4310",
@@ -180,19 +368,25 @@
       "maxFundingFactorPerSecond": "0xd84ef4cc15df47ff3afd13c9d28e9a859dbabf200c94bcd0206c29b95f24e436",
       "maxPnlFactorForTradersLong": "0x72419a34e63cbfb23ab394e4439234ac97ea134e828df7be5bfb5df3ec881fb4",
       "maxPnlFactorForTradersShort": "0xa6300cb5902ed56008bca5c8649dc25ae7b7f119a00b42fa383e2d76f5ae5cb1",
-      "positionFeeFactorForPositiveImpact": "0xc2e64a5a0c61ef9bb36e3f5d49f7ae23191b915b9b453689a7abd06820fb9b6a",
-      "positionFeeFactorForNegativeImpact": "0xa6be8c7c302085742a3296b00ad87b973361d8a174bb7d30ffbf88e4c6f4d8cf",
+      "positionFeeFactorForBalanceWasImproved": "0xc2e64a5a0c61ef9bb36e3f5d49f7ae23191b915b9b453689a7abd06820fb9b6a",
+      "positionFeeFactorForBalanceWasNotImproved": "0xa6be8c7c302085742a3296b00ad87b973361d8a174bb7d30ffbf88e4c6f4d8cf",
       "positionImpactFactorPositive": "0x04bcbebc64b09778830c1b12d8c1b2d32504c94d71d5f64f2d547d6fe1ed4ff0",
       "positionImpactFactorNegative": "0x0c00767fffed8b00ff6d17106121d436ec02b7ff6c01968d8aecb9d29972e75a",
       "maxPositionImpactFactorPositive": "0x10951da02818a2ad689fc04ff3ca1935a2bd85a7023d53189f9f2526c1ad19df",
       "maxPositionImpactFactorNegative": "0x789029ddd96ed090034a9b9f30b7b5b6c658b3b2c03c3d8e8b99087572e6c29f",
       "maxPositionImpactFactorForLiquidations": "0xe67bb29085a2c9505c14cb22b778ffd89bab7484bcf0142d4b8f0d94823fe8b8",
+      "maxLendableImpactFactor": "0xf1cddf409a74490b6b9b71da45699a2664842cb2095addd15856e5ca4488e749",
+      "maxLendableImpactFactorForWithdrawals": "0x996605603a143fcffe8d5a8a49d57f3b166610dbc943f4e4504b16c5af6e6da8",
+      "maxLendableImpactUsd": "0x98840a7c390a3d473387dba2f260538403d20a4302fb5208143594a82858305c",
+      "lentPositionImpactPoolAmount": "0xc65ef81ed98cb824f6d29e22e0d433409224dbeb6a8fd2da59ceae6496c906a8",
       "minCollateralFactor": "0x25ca6ce85c0568d84138f6b3264fedf1668f1ddfc320f7ba409d3d6019411833",
+      "minCollateralFactorForLiquidation": "0xa7a3d6ff9c0a71648dc0e6cf384fa77bd83e4b2ff8395f57d3c34f2b36367977",
       "minCollateralFactorForOpenInterestLong": "0x3c2241385fd888324a03ea03eb3606df19e300ae2c3cf2dcafbe2d235a04b676",
       "minCollateralFactorForOpenInterestShort": "0xeca78003c8f185c46542ba76034dd77edf8c1cee1a710cc59fde908d5b92f309",
       "positionImpactExponentFactor": "0xf1f5a97e4945291c333c8857cc08ec673be5b6c9cde98be1ad86931599685acc",
-      "swapFeeFactorForPositiveImpact": "0x6a1d8e63575704359c436b79657db011d72a92f67f1bd5e14afb57e9a2912498",
-      "swapFeeFactorForNegativeImpact": "0xaf4fad6d380803699ec362dd04941db2d6c038f504ad922664c8f9d1a4ef7160",
+      "swapFeeFactorForBalanceWasImproved": "0x6a1d8e63575704359c436b79657db011d72a92f67f1bd5e14afb57e9a2912498",
+      "swapFeeFactorForBalanceWasNotImproved": "0xaf4fad6d380803699ec362dd04941db2d6c038f504ad922664c8f9d1a4ef7160",
+      "atomicSwapFeeFactor": "0x25494613773e872f0f6580192c653bd12541ec9658a7c4afbc1ff86518cc6ef1",
       "swapImpactFactorPositive": "0x5d50cff84fe2d5abc20ecbe3156a438d1b3479175f4748dae1d121887ed30eec",
       "swapImpactFactorNegative": "0xb9cc0f62898c08c383e014640b673a6cecc479fa1080544ea3250f029f3c304c",
       "swapImpactExponentFactor": "0xc7bcb77b7806e06a50ec6ba4bf17541c63b0577ef3d18018f96e5e74d2bd7619",
@@ -230,19 +424,25 @@
       "maxFundingFactorPerSecond": "0xb67c5c79dea1409495a4296882f29f55711c3613b3962c49406e76fb41cb3bd2",
       "maxPnlFactorForTradersLong": "0xa5a61d7f4a7f07641ab50335ad1305741802139fe956021e15cc7d9bc7be8d7f",
       "maxPnlFactorForTradersShort": "0xd493bce0cc5d3d5c297296e7eabc2585c31272109c39bbb39cabbfbe0030600d",
-      "positionFeeFactorForPositiveImpact": "0xff452922f847142c79ed67c6b9f0f1f57d703384dacf714a43ea097072f341c1",
-      "positionFeeFactorForNegativeImpact": "0x7e7eac91fdbffd192d12b66d7d34f83b12ca2709d7f6cea208e64c3b7905560a",
+      "positionFeeFactorForBalanceWasImproved": "0xff452922f847142c79ed67c6b9f0f1f57d703384dacf714a43ea097072f341c1",
+      "positionFeeFactorForBalanceWasNotImproved": "0x7e7eac91fdbffd192d12b66d7d34f83b12ca2709d7f6cea208e64c3b7905560a",
       "positionImpactFactorPositive": "0x04a7dc43056b287535c2fddccef2e0b361e2fc841de23ce8e630db13d4e3cabe",
       "positionImpactFactorNegative": "0xd1fa1ed0858635234f05b957d0f102dcdcff2d59307f5b378d07c404c515be22",
       "maxPositionImpactFactorPositive": "0x35e161be38af516eabcc7215e158450e46aa9123dfd22a127a3a22717f68e412",
       "maxPositionImpactFactorNegative": "0xad122e0fa63007cec09c08f304aa598044be6f5191018370739bc16a9c439816",
       "maxPositionImpactFactorForLiquidations": "0x1a5334adfb5b61b4aa80163c205dda0a875dea3d2db2fe0850b7b0614f31cdbd",
+      "maxLendableImpactFactor": "0xd98beda89a305501d34136119ca30e1ca2b5b2f434e35296cdb5561208c5b4bf",
+      "maxLendableImpactFactorForWithdrawals": "0x76da0d9c850d2920a310f5aa18b371ca8d2a90b38815cfe6ba6456cdb5c85d50",
+      "maxLendableImpactUsd": "0x8237ec27bdb004d4107c6c6b79c9041a2c4a937dd1252e13d5477a27d2e29eda",
+      "lentPositionImpactPoolAmount": "0x29633419e1322cedab43c68d3d50aa905f37ab8ff6adf3af34e2543c38129de9",
       "minCollateralFactor": "0x2bcb8363ff421d07360a2a95773d3f7b64319b6bc58f328c6c734e090562cdc1",
+      "minCollateralFactorForLiquidation": "0xf28436ee632c09e66f86fd35aaa5d18095399b9108d4ba85c8525a3072af2568",
       "minCollateralFactorForOpenInterestLong": "0x7f97bdae1ee1c0424ccd6dc21526e5ef1e0cb581856d3c0b3279c518b2b140f6",
       "minCollateralFactorForOpenInterestShort": "0xa370583d9939495b60095d94f3906c9b15ba4e7a3d7422210d6f541c426d4010",
       "positionImpactExponentFactor": "0xe33c49e3c7a970aa64a71f22c589f0436ff537390a61d71088600b2f1fe24fb6",
-      "swapFeeFactorForPositiveImpact": "0x1dbf6ea5c40ddb4981c0c991291ebcfe9ca18da36b55476f46c07db6f9d4d796",
-      "swapFeeFactorForNegativeImpact": "0xbdfacc5a3aafccef508a92c25358d876d54cab9266f562bfeb0f075011400b5f",
+      "swapFeeFactorForBalanceWasImproved": "0x1dbf6ea5c40ddb4981c0c991291ebcfe9ca18da36b55476f46c07db6f9d4d796",
+      "swapFeeFactorForBalanceWasNotImproved": "0xbdfacc5a3aafccef508a92c25358d876d54cab9266f562bfeb0f075011400b5f",
+      "atomicSwapFeeFactor": "0x2fa11c68d618568b2ec47f2af07043ea0617b92ffb1b3392c5686ba9a063a7f5",
       "swapImpactFactorPositive": "0xa24690e158bd6148dd1ee7619d26d4db4c22e063bf7fbc4849b248713ecc4be6",
       "swapImpactFactorNegative": "0xea3e78f194aabd8ee877feb4dd76f0f10e28e5375fe88a39575480d27d265afd",
       "swapImpactExponentFactor": "0x708c76a038fd213a993b7643df04ab046fa1987cbe5d0d428475cffb4c1147dd",
@@ -280,19 +480,25 @@
       "maxFundingFactorPerSecond": "0x5c35b3218147478cc4180f5aa2855d0f28596ba4441f9d2e8d209ae71eeccd89",
       "maxPnlFactorForTradersLong": "0x62b1329a211b95ce1332d70babea14c068cd8ba5a664cd92aefa4dfcaa4f167a",
       "maxPnlFactorForTradersShort": "0x974b387f81e50088e3c3ac618012d346cc44ada48d7755853beaf23ab5cf13d7",
-      "positionFeeFactorForPositiveImpact": "0xb1bf22ec2a6afd7bcc3c9005e3c3c2487c8dae699c0f4ef601cd0bf2ec00b0fb",
-      "positionFeeFactorForNegativeImpact": "0x491eab7041f5a8e59a24551f5f7c7f88554dfc7d8aa1cc32dc8447d4e0a3433d",
+      "positionFeeFactorForBalanceWasImproved": "0xb1bf22ec2a6afd7bcc3c9005e3c3c2487c8dae699c0f4ef601cd0bf2ec00b0fb",
+      "positionFeeFactorForBalanceWasNotImproved": "0x491eab7041f5a8e59a24551f5f7c7f88554dfc7d8aa1cc32dc8447d4e0a3433d",
       "positionImpactFactorPositive": "0x058ef893f1d5f6ef1fc9eafb5b98f219ba86fe1ff1732bd8e621ed9314b04c2f",
       "positionImpactFactorNegative": "0xc3dd689dd953a4ead23ac3691cce97602c03ec497d0b618b927045ee6b05ec94",
       "maxPositionImpactFactorPositive": "0x76f07a9c4842e03295e606a17118aa7055df974c7e8119e90c54366f8438c824",
       "maxPositionImpactFactorNegative": "0xa90e6926653827715ada027f4112fe7c882a3ccaf37c922462d40fa4ea8d03ab",
       "maxPositionImpactFactorForLiquidations": "0x41af16a1d0ba06020391564578914ec605001bc8ed683269ff1c10ecde331864",
+      "maxLendableImpactFactor": "0xab56d4d760405991ddef068434a5d406ba016e6d8146fc4902e4e0d598b4880f",
+      "maxLendableImpactFactorForWithdrawals": "0x4ee32ae87de6b8212db46ab2f997b72a42a3c045b784611792cb3b3abcc09ef5",
+      "maxLendableImpactUsd": "0xf795ef00b0e40b4c87bb36bc3cb5d3bba6e56a2579c1d175c4b5cf66b0ccf2ed",
+      "lentPositionImpactPoolAmount": "0x1e85f0f543912b7ecf686ead9f1409fb5756f6a5a58d68e96c143a932a4cbb7b",
       "minCollateralFactor": "0x47e6ae06f279a68f0ca067d5a30ed3650bb14114110b8ee80883b47804ef6a3b",
+      "minCollateralFactorForLiquidation": "0xc256c83913d960d9206dcc2892b610d70f1215a7c0dca18cbf2a253a86a4e27b",
       "minCollateralFactorForOpenInterestLong": "0x2baf62173b9765c40d17461b94ede9de9288eaceb9bea879a93916d6fbc22a19",
       "minCollateralFactorForOpenInterestShort": "0x2d87dc943787f13f340d4ca58bc57c9779423fb4b7a25951482d25d8cedc88ed",
       "positionImpactExponentFactor": "0x255ba96b3ea4034ce13d81ee90f50b43d11aa4cf3d7f6cf6e214708c8cfcdd02",
-      "swapFeeFactorForPositiveImpact": "0x3de65a272685fe435c3bf061d018861d43e0981580e7f7fbbee8322549a24448",
-      "swapFeeFactorForNegativeImpact": "0x16ac4a989200e46829ff7e2a35892009f28622ddbe6474b3bcbf0be26843bc8a",
+      "swapFeeFactorForBalanceWasImproved": "0x3de65a272685fe435c3bf061d018861d43e0981580e7f7fbbee8322549a24448",
+      "swapFeeFactorForBalanceWasNotImproved": "0x16ac4a989200e46829ff7e2a35892009f28622ddbe6474b3bcbf0be26843bc8a",
+      "atomicSwapFeeFactor": "0x921b5c21abfe7c96a3983ee5dc525afa485a1a3d75e2622780e5fd988ed51039",
       "swapImpactFactorPositive": "0xdd0713bd8c7d7d813cf41f2134c5c4171d1dd731b92f992bca75cee16f113bbf",
       "swapImpactFactorNegative": "0x2c1ef24611bfb6198a766b0251729bb7dac63eadd6743ed5585dcfba706d2b58",
       "swapImpactExponentFactor": "0x83731a2fa9b0d93a6a58adff585bfc0f336a70bb3a85535745a1d35ca14c41f4",
@@ -330,19 +536,25 @@
       "maxFundingFactorPerSecond": "0x1ef61f8f945d86cd58ef7e1e4bc7729da62fef5ec14affddbba24e7fd1c961bf",
       "maxPnlFactorForTradersLong": "0xef8aaa370644aaf3abf0f745c8d419b4e8b022fa74bd591331b9049f01a776a5",
       "maxPnlFactorForTradersShort": "0xa0ddc4194a3ed609bab97fffba907154c8b2fab359f5339b564c416dd307fdfc",
-      "positionFeeFactorForPositiveImpact": "0xe0a8dfbd751b5d5206a4421add9c6138627ad8b1dd6c33c53e903e54a873d6bd",
-      "positionFeeFactorForNegativeImpact": "0xb1d9a20a9576c7c8e95d076152d6b7471f325274e27944234317d1655b9a7c68",
+      "positionFeeFactorForBalanceWasImproved": "0xe0a8dfbd751b5d5206a4421add9c6138627ad8b1dd6c33c53e903e54a873d6bd",
+      "positionFeeFactorForBalanceWasNotImproved": "0xb1d9a20a9576c7c8e95d076152d6b7471f325274e27944234317d1655b9a7c68",
       "positionImpactFactorPositive": "0xa72f633da73261095054c3c45e61c545b71b34515676776202071552eb46744e",
       "positionImpactFactorNegative": "0x06aa2f3ce1399efdc7ced916c85dab36fdb5f78075b6ffa4cad253f726e194e1",
       "maxPositionImpactFactorPositive": "0x5c9741051d509ce2c9f6984c4c7f98516b2cbf91e1342f56f0e1b5d40056b688",
       "maxPositionImpactFactorNegative": "0xc5e52b000c6cf276f134adfe885de18e057f3c5f68a128cd952aae394b3c11cf",
       "maxPositionImpactFactorForLiquidations": "0xe124a4a1a960aab0503ef70a732184bbc30732fd4697eb1ce4d4463f3a25c509",
+      "maxLendableImpactFactor": "0xb3c4274beae095399cacdb1878d1c016eed094b245bbc1fa72b69721f8a4e7d7",
+      "maxLendableImpactFactorForWithdrawals": "0x37e67266b53cbe2d3941590fc1b3d26a20850d5c2236ea80b98ccf17bd696c64",
+      "maxLendableImpactUsd": "0x84ace13dc5d67763acb52f7555c4393f595076dc9ea38d5d1a5457fabe6a7ca6",
+      "lentPositionImpactPoolAmount": "0x5a5ad8ffd0624583964edb52b4ca5302dd7852a311d0d00268aa3812e0347830",
       "minCollateralFactor": "0x96dbb6d13d7c6ad973f98461378032ffcf09dcfff780a087bfb18e8b2345b446",
+      "minCollateralFactorForLiquidation": "0xdc1582e6529d9cc8f1962399984c6069dcaa98f558366ed6c054c2b725b86eb7",
       "minCollateralFactorForOpenInterestLong": "0x55f19e1cb6994dac8de0f0595716c8ce1c98c4a0fe7ab84d94a2581a2857ef77",
       "minCollateralFactorForOpenInterestShort": "0x661c2ecf5182f780d9b14cd701f17b54d2fec0a3c78259175f382a53aaa17c85",
       "positionImpactExponentFactor": "0x9c4e91c06294bf042d7bf732cb8ef8eacbc2b113523e0a3d00ca94d3baee95b5",
-      "swapFeeFactorForPositiveImpact": "0x1e388b1aefe26c7999b5916b8d315dc220aab3bd1abf69d022fb2ca798af1d87",
-      "swapFeeFactorForNegativeImpact": "0x42455fb0390e5144cf404e735d539d273f23e0599527cd4cfbea64781471c11b",
+      "swapFeeFactorForBalanceWasImproved": "0x1e388b1aefe26c7999b5916b8d315dc220aab3bd1abf69d022fb2ca798af1d87",
+      "swapFeeFactorForBalanceWasNotImproved": "0x42455fb0390e5144cf404e735d539d273f23e0599527cd4cfbea64781471c11b",
+      "atomicSwapFeeFactor": "0x142a11abfeb0ce942f834c8c1824cd4f4054f9c895ecd8cd620997fc38524384",
       "swapImpactFactorPositive": "0x8879db97a79f1b27c0eaf1b7e8326ca6b02dde9dab4a136bf6de2ae5bc87eb43",
       "swapImpactFactorNegative": "0x267ab1bdc0e337337fb57913abbc1774c61393c941ec14405210702c243dd087",
       "swapImpactExponentFactor": "0x42417562a37eef95c1e2ebc561a16eb5d2719490bbc0c214707c278411bdee69",
@@ -380,19 +592,25 @@
       "maxFundingFactorPerSecond": "0x80fbfee732d414f7e197bd2dca60406b5443b01a07b4bcdb3e9c79809d5b1c98",
       "maxPnlFactorForTradersLong": "0x0d971c00493d5db7d3270c7a8cfa9cc7aa0a99e5005fb913d5dc26b445f551f7",
       "maxPnlFactorForTradersShort": "0xf9a064f376e3c391caabd7d692c3e5e5c601ac3a9ebd1d2c105ef84117e3588b",
-      "positionFeeFactorForPositiveImpact": "0x57a019d7c544d1c83cd3118bf0c636b2e212af7f8c5c1e1ad5267adf98f3bbd6",
-      "positionFeeFactorForNegativeImpact": "0x99694bed9c85088df5242e4cfb72caecd4c1cb1870445956483f383b2ad6a5c0",
+      "positionFeeFactorForBalanceWasImproved": "0x57a019d7c544d1c83cd3118bf0c636b2e212af7f8c5c1e1ad5267adf98f3bbd6",
+      "positionFeeFactorForBalanceWasNotImproved": "0x99694bed9c85088df5242e4cfb72caecd4c1cb1870445956483f383b2ad6a5c0",
       "positionImpactFactorPositive": "0x48e76a2a5d0acb603c2113e72183f2ff900dad314753ccd89847cbb3ab21a522",
       "positionImpactFactorNegative": "0x2892774a5b56d753852b4a0f3bfb467e3a8ec009f9363ea1e87a1fb0be8949eb",
       "maxPositionImpactFactorPositive": "0x2ff3590362f429c9e9fed9dbdd6d9b7af0fadc3db5958cbdad4915effd446ab5",
       "maxPositionImpactFactorNegative": "0xc5700a9f0f48d7f11ad44433d1848041e475133baa14ceabfd308aa05291380c",
       "maxPositionImpactFactorForLiquidations": "0x95b07614a06ac0a81e49b6e02b6b5be9ff94bec514e0e62042c8e1f5c1429733",
+      "maxLendableImpactFactor": "0x62fff146684d5367acfd3186d198f360d343641ec714f75bbfe1da5d15cc2d1a",
+      "maxLendableImpactFactorForWithdrawals": "0xb7655a124cfb3abd74e70cc7eb1e86ef590f4256be7b19dfa5a16a13a0853875",
+      "maxLendableImpactUsd": "0xb2b39807618c901e81778682b8c1784c922b07d57729cafc0f85fc55e6e17b74",
+      "lentPositionImpactPoolAmount": "0x3b7935cb9f25478bed786cbbc2db533c3f370637796f07b4d7b2776b12e10fa4",
       "minCollateralFactor": "0xda500b491a746b24ab50e0b8b019f220ead47914b3745a2a7e7fdbd254e98380",
+      "minCollateralFactorForLiquidation": "0x34f110ea583e9f5ddde6db52500fdfa0f533d4289608e8385d6e8eb52b6ccc43",
       "minCollateralFactorForOpenInterestLong": "0x766fd0d002f43488d55b72193e9da1714d44851b4eb0e813cc8d280bef17a17e",
       "minCollateralFactorForOpenInterestShort": "0xd7db435910f38921a33518f369da861bc79b935c47e55310cda4cac15d5e8817",
       "positionImpactExponentFactor": "0x2efcc03e271bba8971dffc9f4ceb1afc8fc3c3c21d00a7c3b55ce76374ad79d8",
-      "swapFeeFactorForPositiveImpact": "0x33809fa251f2a79834e55024e55c4f8108575f4de5b2cb36a20328e5ab447533",
-      "swapFeeFactorForNegativeImpact": "0x2cedab9e26e3f9beb8d6b7ed636b6bafb5c22480925bba846038f0c06b622eaa",
+      "swapFeeFactorForBalanceWasImproved": "0x33809fa251f2a79834e55024e55c4f8108575f4de5b2cb36a20328e5ab447533",
+      "swapFeeFactorForBalanceWasNotImproved": "0x2cedab9e26e3f9beb8d6b7ed636b6bafb5c22480925bba846038f0c06b622eaa",
+      "atomicSwapFeeFactor": "0x2e955a1d4b845ed986f466bb7d4be7403cef7c3ef1da3cd000250bbb251d2bf9",
       "swapImpactFactorPositive": "0xb63747d677b3f4894bf83370aa290ba493a3279ab6c71e8f627d6a19200fd0c1",
       "swapImpactFactorNegative": "0x6db11718caa3c178b5c71b0ebb38438e678887ee9808ee5fff12f45dff61f523",
       "swapImpactExponentFactor": "0xecb5d9ab804ddb4babf57af0763d13484ab59dc753b190aed034545d261dad6b",
@@ -430,19 +648,25 @@
       "maxFundingFactorPerSecond": "0xe7a76386a66a7510ccb548446cb42001ef38df88ed137941f22f742a80662a9f",
       "maxPnlFactorForTradersLong": "0xd5f058fb977929295998ca0eff3c526b05bc44fad34dd48f5067d6d63b7eae2c",
       "maxPnlFactorForTradersShort": "0x50c66a2e6ed8488a2a6ba5ada5720a9475a809201089d4fc87977b851c382866",
-      "positionFeeFactorForPositiveImpact": "0x52f8b77c96eee555524449d744f3f6c6ab77a4f26db48d6df363a32fba500e11",
-      "positionFeeFactorForNegativeImpact": "0xe4b8f5be03631cd111cafc0ac01dc8a8ab8f8ffc65b2a47287e8f9cf72b9c39d",
+      "positionFeeFactorForBalanceWasImproved": "0x52f8b77c96eee555524449d744f3f6c6ab77a4f26db48d6df363a32fba500e11",
+      "positionFeeFactorForBalanceWasNotImproved": "0xe4b8f5be03631cd111cafc0ac01dc8a8ab8f8ffc65b2a47287e8f9cf72b9c39d",
       "positionImpactFactorPositive": "0x4c9c2a48ed819ebea8ffdd30af8644af6bca85d2a73c6212b3e116d565ea6f1a",
       "positionImpactFactorNegative": "0x14770004251515604996859abeaefb248ed77bac98b0182e5d0de798e73a9880",
       "maxPositionImpactFactorPositive": "0x3bd8a0156fa25ff8ede082290885def48ebc2b978d3d3bb634261bbd940aa8ee",
       "maxPositionImpactFactorNegative": "0x01d477fd068479d04cb497540a393c8b5ef72afcc50e7b820000f5d863d185b0",
       "maxPositionImpactFactorForLiquidations": "0x4ec66905f0f5391fc597d1928fcb5b1785f5ff1c58238c67026b62121f2c02ce",
+      "maxLendableImpactFactor": "0x3a9c470b53c165ab932328154f9874548715861c6460f805ee9a4a80a8fea78b",
+      "maxLendableImpactFactorForWithdrawals": "0x9fad6c729230ce1e718f2c8d59dc4d4b71cabdc42bdc9671eb9f3a657c96a76c",
+      "maxLendableImpactUsd": "0x9862560ef3b5dac5ce2b74ef17a25dbe09eb8a96671a982b6a965c5269d3cd45",
+      "lentPositionImpactPoolAmount": "0x9d097f5509c3c67bdeed446ec4598dac8db0935f13a8c9023bb1eb6baf52dca7",
       "minCollateralFactor": "0x0319e091a3ec1a799e073a0b7936f425076d1918f56c3ebca0a61a077925d1a7",
+      "minCollateralFactorForLiquidation": "0x44c72c9b6faaa5a6a01ee3029c34a5998526cf5d06621babe61728a74452cc9c",
       "minCollateralFactorForOpenInterestLong": "0x534530389b87caf5d983a7e0e861fa8081b2a7a13384cf923705a64a186c5230",
       "minCollateralFactorForOpenInterestShort": "0xe5b9a75cc9c16a9e118200b3e6bd4b4a4a3849781b494af86fd3b61368f3a9ef",
       "positionImpactExponentFactor": "0x2f3fcc42ff0aebd5654ab91b39ee87bf3782130d659ee6dcb17bfd46609a202b",
-      "swapFeeFactorForPositiveImpact": "0x76240fbd6e985d59376b17429e35328adb92d235eaed290e881d2905f4fee93c",
-      "swapFeeFactorForNegativeImpact": "0x98d812495968f772c1430ad5bda82be56209a512f5038e644d21baa4649258b7",
+      "swapFeeFactorForBalanceWasImproved": "0x76240fbd6e985d59376b17429e35328adb92d235eaed290e881d2905f4fee93c",
+      "swapFeeFactorForBalanceWasNotImproved": "0x98d812495968f772c1430ad5bda82be56209a512f5038e644d21baa4649258b7",
+      "atomicSwapFeeFactor": "0x5f7d86e6dc36460d2f9ad7dd34579a510203f38e3b7fad173fd2e07d1a930cfc",
       "swapImpactFactorPositive": "0x322d07f82afd4f2749d56278757d206f52add338aa5bc9359b259a5ddef4e514",
       "swapImpactFactorNegative": "0xe765a130a8cb9790e3c622efbb5422a8fd76ba0ed4a41840a89b667104954b19",
       "swapImpactExponentFactor": "0x4f3835c05f851e1cdbc009ca97f15327ab116a04ddef47c133d035ef3f3fc8fd",
@@ -480,19 +704,25 @@
       "maxFundingFactorPerSecond": "0x99b8fb43ab749f6efe10459bf77c6e6d1cc46a02d8556deaae37bfce7e310fed",
       "maxPnlFactorForTradersLong": "0xe819b259874d89abd8406b4d8b5e978103e20599ce37ae5e6fcf35aadd672806",
       "maxPnlFactorForTradersShort": "0xc08bed49b3149d637af537bd879916ad2179e5f790c6a4d9fa254f70468f8c54",
-      "positionFeeFactorForPositiveImpact": "0xa33ef0e7e5737b815d4ee3818c9dda824c74ca1c0010ceca073401987419dd6e",
-      "positionFeeFactorForNegativeImpact": "0xbaa718f209c80155d83205a86874b4ec814ad173901eb25ef539652c4c0f7102",
+      "positionFeeFactorForBalanceWasImproved": "0xa33ef0e7e5737b815d4ee3818c9dda824c74ca1c0010ceca073401987419dd6e",
+      "positionFeeFactorForBalanceWasNotImproved": "0xbaa718f209c80155d83205a86874b4ec814ad173901eb25ef539652c4c0f7102",
       "positionImpactFactorPositive": "0x01e45a73c87ea6a24bd3e4b646a8fb50e525994b47b2e071688832b3db9a36a3",
       "positionImpactFactorNegative": "0x0eb07128e77ab3ed0303be75bf40e58de698d31f3587002010201f1f87383ba8",
       "maxPositionImpactFactorPositive": "0x3aaa745ed518dd8c579ee6533f0abc0f71f0b5856a057d7cdb74765251b41f7c",
       "maxPositionImpactFactorNegative": "0x28706d4a1fdc22299d49f2506ff82c9d9acc08e657e2d01a527678b6c6762247",
       "maxPositionImpactFactorForLiquidations": "0x15bcf662fdf9b8cd990c2b62c63190df2eb471bed3de8b9252a8d9f1d25fe9df",
+      "maxLendableImpactFactor": "0xc6fe342f7964206bc124b771ff423c0ea289d1bb7de474110589adeffee82944",
+      "maxLendableImpactFactorForWithdrawals": "0x2870d8d25ffee717545ddf07c91cf6fd196b65e8f90c3ef166432c3fc0822382",
+      "maxLendableImpactUsd": "0xfcadfede8ed4a86ac6707ff911ab8013568d1a6aafc8533f4414ac34eab356b6",
+      "lentPositionImpactPoolAmount": "0xf4aec56aee11b79d98c7f6d4a454ba0e56205a687bd987c3826f0e97fd58be46",
       "minCollateralFactor": "0xff3a85b820937ac9b174e1f49510b221d1e2eccc89cbdb68794b1e04f82c5e1e",
+      "minCollateralFactorForLiquidation": "0x04392113bc40d454de730f577ae537fe8a7a03c8699523dd377868df099dd735",
       "minCollateralFactorForOpenInterestLong": "0xce841b0d0a75f7f23b3068a8731d79d46ffd5224bf752b82c99278c615ce9610",
       "minCollateralFactorForOpenInterestShort": "0x095df3a0a35194c30b382a21aa95ff97440c497a9fa7308d9046a7c6a830a077",
       "positionImpactExponentFactor": "0xa776cf8b6750764a7baceb04c49b3e8316f86ba63007da12ce39fac78ce94815",
-      "swapFeeFactorForPositiveImpact": "0xa5c03fcca15132bd6eaab72fcb0be1671560cbff2bb1216ba7a680423f852cc5",
-      "swapFeeFactorForNegativeImpact": "0xad609e8a1ec4b62de757f26762513889a12b50c490a2c972b4cffdab526ce5b1",
+      "swapFeeFactorForBalanceWasImproved": "0xa5c03fcca15132bd6eaab72fcb0be1671560cbff2bb1216ba7a680423f852cc5",
+      "swapFeeFactorForBalanceWasNotImproved": "0xad609e8a1ec4b62de757f26762513889a12b50c490a2c972b4cffdab526ce5b1",
+      "atomicSwapFeeFactor": "0x21912c9b2d2663de7ed5f3dba461a5b257e5c2aec9f3f7d0ee25da86d40ef075",
       "swapImpactFactorPositive": "0x40780b4dfe67cb9032a30a9ae910a8e63c568c0bfcfbac6962149a0480760e02",
       "swapImpactFactorNegative": "0x981313e20ad119ffd4e7297d65ac074bda816af74f76dc5ebef3a288ea0420c6",
       "swapImpactExponentFactor": "0x3a49bd6e93391cdc99dfea5cfd912c9e3cb54ae1dcd9c56801924b4db11e9b9e",
@@ -530,19 +760,25 @@
       "maxFundingFactorPerSecond": "0x8b5935796ab74f3629e2ecb0efb2aaa95ec6c22cac58d7d2549715ec3b637f02",
       "maxPnlFactorForTradersLong": "0xdbff4e5388b3cadab3adb3cbea18328ab85615d1d33540f1daa3637191bd2a7a",
       "maxPnlFactorForTradersShort": "0x25e92f539fa9d6181cb3175d855b0e3db892f87e7cf44683c2bd88c3987151f1",
-      "positionFeeFactorForPositiveImpact": "0x75342f90740d718e915d25876def103e0aadb790eeec0e51cf80a0164fdb998d",
-      "positionFeeFactorForNegativeImpact": "0xa3181a5fa6716d137684451c14456bd1e089a30d7e4195041e1d03c5877fbdb1",
+      "positionFeeFactorForBalanceWasImproved": "0x75342f90740d718e915d25876def103e0aadb790eeec0e51cf80a0164fdb998d",
+      "positionFeeFactorForBalanceWasNotImproved": "0xa3181a5fa6716d137684451c14456bd1e089a30d7e4195041e1d03c5877fbdb1",
       "positionImpactFactorPositive": "0xfaf02c5d36cb1652804abd1004a4a3cc59b1d9639b6451440e856c507ca45e8e",
       "positionImpactFactorNegative": "0x68e601b74c240b88ff66adfef9b198da08f6b4eb2f6bbc5745217e2ee220c74c",
       "maxPositionImpactFactorPositive": "0x55682cadf8c0c42f07f7537e036888e6509b4c1fefbe791f8806c0122464065c",
       "maxPositionImpactFactorNegative": "0xcc4ecb935ca3ee301c72b4a0a5a2e0ec012bb977e18988abbf65ec31dacfb01d",
       "maxPositionImpactFactorForLiquidations": "0x53e40c837b0c78b8e732b33a14b1a71eafb92ad162e389509adf12d012804445",
+      "maxLendableImpactFactor": "0x8b638a3a6144458459f5ae1ded90a00fd71368b16e55375547465bc1c64dd948",
+      "maxLendableImpactFactorForWithdrawals": "0xfdae05a2ec9ea4f7ebd165c878f4ed38f7241ad080746ac736ed1fd290f88f44",
+      "maxLendableImpactUsd": "0xe70223bfaf4074aff312a883325204bd961829e8cc013550374a8ff390d757a6",
+      "lentPositionImpactPoolAmount": "0xff73e8c386163960756bf4028b8fad2438daf59d62a27b8ec82f8df3bd90bd7d",
       "minCollateralFactor": "0x19551441f4fad115496cad924a5234a7c54fdfb4c8a1488f93b7bbd6b0ecedc1",
+      "minCollateralFactorForLiquidation": "0xdfc2ee462858568defefb730ffe6b557448fd43946f479e841fb1d8a07246f89",
       "minCollateralFactorForOpenInterestLong": "0x2236f68da88942f622d2e117770f8f2147a2e26a5ae248e7facaed024241fff9",
       "minCollateralFactorForOpenInterestShort": "0x97b31e77e2349e5ca9393f9b039ae4c6e08b561674013325694aee511fa70f4d",
       "positionImpactExponentFactor": "0xd29cc14774ff37425210a4b4982d64598d960517246358ca6ae31e8278b88171",
-      "swapFeeFactorForPositiveImpact": "0x2453b281ca272f6b3c4aabcc06da5f61a03fde91143ecbb636906d8760751038",
-      "swapFeeFactorForNegativeImpact": "0x43fdf293b2369b23c689953b361e57206f130569d07cdec5b02a91f7db302988",
+      "swapFeeFactorForBalanceWasImproved": "0x2453b281ca272f6b3c4aabcc06da5f61a03fde91143ecbb636906d8760751038",
+      "swapFeeFactorForBalanceWasNotImproved": "0x43fdf293b2369b23c689953b361e57206f130569d07cdec5b02a91f7db302988",
+      "atomicSwapFeeFactor": "0x7dfd70277f86278a779644d88083c0680c47bb02f02bdc9161268e2c24f8d092",
       "swapImpactFactorPositive": "0x6e872e48337e83b9b0974c98123f42c6c42133a809dda28947e45044fef0d763",
       "swapImpactFactorNegative": "0x7f74925d83c9749b52d3c463b52f75f56d3df222aa8091d320be024fcc136ab5",
       "swapImpactExponentFactor": "0x93ac087aef99ee1d1d4337027e16e9f34e2b3e95b449f6e1afd4969af2b95d99",
@@ -580,19 +816,25 @@
       "maxFundingFactorPerSecond": "0x77905364bba50c4f33e22bccadbd317691a1c22b10fb45c5dc8c32129526044b",
       "maxPnlFactorForTradersLong": "0x9dfce95f35750ed7989c98bc3fa7b9ffdc4d923342b99b475bd1a68dd2bea55f",
       "maxPnlFactorForTradersShort": "0x3f7a7d4fa7b04934a74b5c4fe364e15ec7f182a731e00665a8087943d90d8ef3",
-      "positionFeeFactorForPositiveImpact": "0x2afa6ab01eaffdcdce3de67ca9408d171dca6f345e4a933977f017c3f935a150",
-      "positionFeeFactorForNegativeImpact": "0x16a9815fd641b782481c256ae44f741d91f98e60f198e6f67711c2f872654659",
+      "positionFeeFactorForBalanceWasImproved": "0x2afa6ab01eaffdcdce3de67ca9408d171dca6f345e4a933977f017c3f935a150",
+      "positionFeeFactorForBalanceWasNotImproved": "0x16a9815fd641b782481c256ae44f741d91f98e60f198e6f67711c2f872654659",
       "positionImpactFactorPositive": "0x163076b9dd0072442b9329b1e08c52eaf7f5d809f427178601592806a5200645",
       "positionImpactFactorNegative": "0xc27bde803397efc87d5d72964b6602262a80df80f9793084055ef0d6dd08b1af",
       "maxPositionImpactFactorPositive": "0x1c69876249545cf8f840054e487971e4faa2bf1574ac216060f5367e8fc4a611",
       "maxPositionImpactFactorNegative": "0xc6af5f36195b175198abc4774b59c643fd769f4e2c9e249c1e3006b88b70fa9e",
       "maxPositionImpactFactorForLiquidations": "0xbf51cc5c91b13d3465f57f3e9c7b3d9a464a01ad65b0cd7a784fd2d83ccb7051",
+      "maxLendableImpactFactor": "0xf8570b1f7724a306cad7e751facf358775d2836bdb89a795e7cf10e9e5d300c4",
+      "maxLendableImpactFactorForWithdrawals": "0x8d6265e42640b0ac32cc3f53e56a5c09e3a813d783e81ac771a2a059cf5853a1",
+      "maxLendableImpactUsd": "0xe51022439894366b3a6e88867c5b10c08d7f7ff243117df10e59009a28aaf91d",
+      "lentPositionImpactPoolAmount": "0x38e5c5fb9fdd6a81cf67e9c963912c548f1c8b75cb9f3049dc6d67109bce6860",
       "minCollateralFactor": "0x7cc57d46d5ff50a03e5a0f29242e18131d031794b2629b7f6398de7841588dbc",
+      "minCollateralFactorForLiquidation": "0x72e936023ba9fcbaf12a7120e82d41da53972b921ffd5dd1ad50ac1ae93bb900",
       "minCollateralFactorForOpenInterestLong": "0xc91baace01ed132d5a1f539fb6ddacfa913f012c6d706993f1f9d21e28646417",
       "minCollateralFactorForOpenInterestShort": "0x42ab637ba5ede5ce450b490c92fd5308a4b63d814d521886092107e000564243",
       "positionImpactExponentFactor": "0xfbaadfdbb5b204e122e8a78505941f01262e57d5b600482db442a452bdf0c5e4",
-      "swapFeeFactorForPositiveImpact": "0x13c0be771ab61c6f159c7b5afdf946b2e46e53aafb8881484d71a028dd441160",
-      "swapFeeFactorForNegativeImpact": "0x7b665b4b365ff791322993f71e61afeba792f6ccb7a2f5f2163825643637c897",
+      "swapFeeFactorForBalanceWasImproved": "0x13c0be771ab61c6f159c7b5afdf946b2e46e53aafb8881484d71a028dd441160",
+      "swapFeeFactorForBalanceWasNotImproved": "0x7b665b4b365ff791322993f71e61afeba792f6ccb7a2f5f2163825643637c897",
+      "atomicSwapFeeFactor": "0x1509233a29eaeb1b61f20040be4dd415f027c0b543b6222075a8c10f6a3546c1",
       "swapImpactFactorPositive": "0x6d7c56088daa2bea15028f86d6f54e24a63768356083dce669015965c9f5b873",
       "swapImpactFactorNegative": "0x3b2c183b4353852490404ae6be59826b51e24517576e18db1483a6c593a1a99a",
       "swapImpactExponentFactor": "0xde8e209ca4616ee04606284a891e35dc078488672e5a98b257aaef147e46b5cd",
@@ -630,19 +872,25 @@
       "maxFundingFactorPerSecond": "0xfaa2e2d54bd6c23be91d8e5c47cb3ae9d9fec59b9aa8290ef792420f15b2469c",
       "maxPnlFactorForTradersLong": "0x85ec736c56013977c51d5e19da50497a732239f0fca988471f4e0a3066fca75b",
       "maxPnlFactorForTradersShort": "0x8edb1f5246ad1af8d59a7ad26d8f41fe7dd2a1813a1569cdcfe40851df6ea6cf",
-      "positionFeeFactorForPositiveImpact": "0x529d29c9843efe4be2f9872d2e78fcf6e0440a13d77141765380fc76817f5c87",
-      "positionFeeFactorForNegativeImpact": "0x8e3f4978a3cf5cce73d79ff5773e2edb617da3267e8017ac64dfb274f7742094",
+      "positionFeeFactorForBalanceWasImproved": "0x529d29c9843efe4be2f9872d2e78fcf6e0440a13d77141765380fc76817f5c87",
+      "positionFeeFactorForBalanceWasNotImproved": "0x8e3f4978a3cf5cce73d79ff5773e2edb617da3267e8017ac64dfb274f7742094",
       "positionImpactFactorPositive": "0x84bf3fb933429f4de132e3c58aff52a078506381c7f24020b466fccf28905941",
       "positionImpactFactorNegative": "0xf54c7c49ce94e0c61f7c5038863aff7eb4a7aa1a1097acf42851ffe9350bb0a5",
       "maxPositionImpactFactorPositive": "0x8fba80b3646c853ff0999394fbddf236bfdb72482b4fb1dadf6fbc81caa1b9f8",
       "maxPositionImpactFactorNegative": "0x12ba189cc009055d7cb1907f44c8b32ba8b8c6a8f0359713a84ba3179420f542",
       "maxPositionImpactFactorForLiquidations": "0xf630085ecccd08f436223030db10c9c8bbbf96d9b8e0dfdf97d02c978c024b14",
+      "maxLendableImpactFactor": "0xf403c0635696149bfb203b07cf6aa938a603884ce708fe342d0c95bb9c77f6c0",
+      "maxLendableImpactFactorForWithdrawals": "0x9f4f21d5d90fb9137601d9e8f67d52fc46912abe323569b8717ded1b8ca4dea4",
+      "maxLendableImpactUsd": "0x3facc7f4177d656a98252b3d56766e2797a66c79f6d86c6bcbf3d661dd49659d",
+      "lentPositionImpactPoolAmount": "0x5e1acb7b2b0e3a0aae60283a53fd1869b55460eb4c7a6874a69028084749c9e9",
       "minCollateralFactor": "0x44d3450628900783da0a74bb9d83b0bca2ff8504e6c4d420a2c5480085883855",
+      "minCollateralFactorForLiquidation": "0x045488831e4d7b120737807287cdd91326b56a531a357dfc178b1e621a073fda",
       "minCollateralFactorForOpenInterestLong": "0x95ed56a404dad3b4f299ec1ce25cef2de1a828458f02787a404fff019baaafa4",
       "minCollateralFactorForOpenInterestShort": "0x8f5bb4ea781f12eefd8cc65f9cbe17af85a9e315fef4cc50fe63e7471af42531",
       "positionImpactExponentFactor": "0x2ad9516b4cf9062372bbb664ccbba50dff378bedfb8e9defbdc4eadab8306d1d",
-      "swapFeeFactorForPositiveImpact": "0xcd711380dcd676e0544ad089e8c882686c308f656fa651d48a0747b7f70fd564",
-      "swapFeeFactorForNegativeImpact": "0xfeadc380b20cab88593bd96433d4b0ee08368051055dfcfbfcc594a02a98cf08",
+      "swapFeeFactorForBalanceWasImproved": "0xcd711380dcd676e0544ad089e8c882686c308f656fa651d48a0747b7f70fd564",
+      "swapFeeFactorForBalanceWasNotImproved": "0xfeadc380b20cab88593bd96433d4b0ee08368051055dfcfbfcc594a02a98cf08",
+      "atomicSwapFeeFactor": "0xe7e08dc2e46bdec6bdb17e9860d93dbd8ec4c73bfc46e0fd78170aa3c5bd33de",
       "swapImpactFactorPositive": "0x737c7f824ed4b98d1e563da86dd27bc6555ef0c5e3a7735a9d2efad4b87dddc1",
       "swapImpactFactorNegative": "0x71533255ae7a74548b062c095bfbf28d36199e44d3481ed295bc9075f5137ef7",
       "swapImpactExponentFactor": "0x1a4ce691b5691f71e7bee1bc45b36e300e1549a3ee40a24945c65d0146428e30",
@@ -680,19 +928,25 @@
       "maxFundingFactorPerSecond": "0xc3d8ca914f0cc679122fb0f2cf851dd828b598d7d60d3b5fcc56ed86d8cc33fa",
       "maxPnlFactorForTradersLong": "0xea0ab7ba61168c2bee279288a503df6416568c2bbabfa80fe953fe824954d628",
       "maxPnlFactorForTradersShort": "0xab9ca42c0baf668370ea036fec734f4badac8b93f7d98bf8aca0c7bc53e3a100",
-      "positionFeeFactorForPositiveImpact": "0xe5e2c324445803bae980161bc19f60163527312fb3ba12a69c42ac9d2d1ce824",
-      "positionFeeFactorForNegativeImpact": "0x3c8892db6ea33607529e998daf052e2d7631399762ee3d4ed1dc0ef43290fa54",
+      "positionFeeFactorForBalanceWasImproved": "0xe5e2c324445803bae980161bc19f60163527312fb3ba12a69c42ac9d2d1ce824",
+      "positionFeeFactorForBalanceWasNotImproved": "0x3c8892db6ea33607529e998daf052e2d7631399762ee3d4ed1dc0ef43290fa54",
       "positionImpactFactorPositive": "0x3bea7fd67f7eb844908e5e28482f18674e6bba80493bcac40694608c91afb23a",
       "positionImpactFactorNegative": "0xe6d8bca55d639e4693467c4031793f201d42fb885127ca38006b4948dd7af1e0",
       "maxPositionImpactFactorPositive": "0x4263f2ff7af12d6564bab215180503848e8bbaae4bf39c4e6e4e5d73b9a8add3",
       "maxPositionImpactFactorNegative": "0xf398b3bf767ae253c3dcace78389d530c601ae67be971378528e0b5a0bf2164d",
       "maxPositionImpactFactorForLiquidations": "0x8fe8d9a666bd04e67d114209c1926e70a58a132db2beeed4177f31ae9d0318c3",
+      "maxLendableImpactFactor": "0x1749895678e38a3343c373c2d2c043ee94127a7fa863488817f099d6ff98760a",
+      "maxLendableImpactFactorForWithdrawals": "0x3a41d7ec40650324eb9ffdc44c4cdebda6d53a5383a74f986d3d0cbb6819de34",
+      "maxLendableImpactUsd": "0xfabf16315fd84c105d19c87edd5186946f5a33dbd327d2c3ec395a67ac401043",
+      "lentPositionImpactPoolAmount": "0x62da073ddbddfeaf8aeef839b7d6134b84491635b7915b1426c5ff8720519e2e",
       "minCollateralFactor": "0x6a8d715582ce7a436f0926fce0f99d60dd260a473e14babbb4560315a488cc1f",
+      "minCollateralFactorForLiquidation": "0xd0362b4c48dedbb4f87db87c773b0f4329525d6197ab8617c15dd6e4668d3264",
       "minCollateralFactorForOpenInterestLong": "0x6d844c42863e83e23fa960ab45a1a5696e1be08fa1e4e772366172c0ac93229f",
       "minCollateralFactorForOpenInterestShort": "0x47f7b3459fe7e68075e8c6444215e21468de24ee4f0fdb3ddc04af016f6755b4",
       "positionImpactExponentFactor": "0x6193f8d462c3326bc8cb666374837667c596f93cd996cffbd81668a636843061",
-      "swapFeeFactorForPositiveImpact": "0x2fc46450b98092e9b66e0bf7696ce02d4c833be88de497cfb915d3f39e3812ec",
-      "swapFeeFactorForNegativeImpact": "0xb37a74e4f029bbab4db5c9a9bf086565143dc8e25ac8cd13909d079fb770d4c6",
+      "swapFeeFactorForBalanceWasImproved": "0x2fc46450b98092e9b66e0bf7696ce02d4c833be88de497cfb915d3f39e3812ec",
+      "swapFeeFactorForBalanceWasNotImproved": "0xb37a74e4f029bbab4db5c9a9bf086565143dc8e25ac8cd13909d079fb770d4c6",
+      "atomicSwapFeeFactor": "0xfdf1e814ffbae35f4df6a90a4d167e0a998a23174ca373a153e356504f28e7ae",
       "swapImpactFactorPositive": "0x027553df27e8e9b5a65bebc5f963f76e85ff58fb8d9c1ae933ca099379ca4b60",
       "swapImpactFactorNegative": "0xb75f6793ffd5ebc77458bcfe941d32c2939bfde678876cb5795ef174242a34fd",
       "swapImpactExponentFactor": "0x3db9029b93780175fc0b831246129f3a2dd55c2f32d7f03ec0802bcd1e83a748",
@@ -730,19 +984,25 @@
       "maxFundingFactorPerSecond": "0x55069748b013aeafed958fcb91ec1fd542ea8544b742f6eb55c55776ac9f35dd",
       "maxPnlFactorForTradersLong": "0x8eb7ba2e0073ed92d420187aebffc7b087a92b226be547ff071f08274a0a4bfd",
       "maxPnlFactorForTradersShort": "0xd16159783f2f3480377b1016b40459ce05c08c5dba1055f792df1a4244251f45",
-      "positionFeeFactorForPositiveImpact": "0x0c5805974efe868ce0ca027b4a7633ad68158550b1bb97bc30278ebbf228c14d",
-      "positionFeeFactorForNegativeImpact": "0xdb16d4b4d8013bcc93d01321c277effb94bf6b8550cc8344b7b66819a29638fb",
+      "positionFeeFactorForBalanceWasImproved": "0x0c5805974efe868ce0ca027b4a7633ad68158550b1bb97bc30278ebbf228c14d",
+      "positionFeeFactorForBalanceWasNotImproved": "0xdb16d4b4d8013bcc93d01321c277effb94bf6b8550cc8344b7b66819a29638fb",
       "positionImpactFactorPositive": "0xb11d8986c9d5f1ddb9a54c87c508436447121d439f07f9095a366cc5cc07527d",
       "positionImpactFactorNegative": "0x37dbbde80316028bcc42ab769e2d1dea559042641b0ef5e7e8b2c9bbdc92d21a",
       "maxPositionImpactFactorPositive": "0xc48d8c6bc423b09532b41f9989b3379cf2f045332ff8653091fe4d7269132d16",
       "maxPositionImpactFactorNegative": "0x56c740c2ca614eab1d549b7bb7a4f6288cf040a585c97ec247670cc345d4ec91",
       "maxPositionImpactFactorForLiquidations": "0x73aac72421893e1c0d682fad9aed3749e082ff69084394c9acc9b4ed0a0cc3b1",
+      "maxLendableImpactFactor": "0xde1ba05fe687e529a6a0c58d2100de1139ad4928b37e52862c8d1ebdb22a1a61",
+      "maxLendableImpactFactorForWithdrawals": "0xee346d2edd361d19d698b4dd0789969a134d4ed19a464cd4201596b74ce53fed",
+      "maxLendableImpactUsd": "0xcfce9499d841b6c0e363c365ac82b6f7a3da5f3af87fcddff222e8582f34d63d",
+      "lentPositionImpactPoolAmount": "0x4454cc660ad883b095ddc9c0857ae37b951ea31b82b25bf07708c2525e7300f2",
       "minCollateralFactor": "0x5b9cbe70edfdfea83201f44a0f1c912fb82a4a1ee106f9a3842bb29cb5301035",
+      "minCollateralFactorForLiquidation": "0x71ff8d76e7fc434950cad2cccf97e7b7ba4f414cbf807094440bd8599e6a61d6",
       "minCollateralFactorForOpenInterestLong": "0x2a50bf17c53f122cad04b207535a3c74b062687e8c8f8657ea2f927b501c1062",
       "minCollateralFactorForOpenInterestShort": "0xff365ea9e77f3aff0dea18e392461b9ca0e3b42051708fa32969f77d5ca76b87",
       "positionImpactExponentFactor": "0xd0d2c3fbe177c70b48f1f2866e4a15ccedeae13f3e7c96726a6e367325a045dd",
-      "swapFeeFactorForPositiveImpact": "0xf9e19bb3189d432360663917ab7316f9eb15e32ca0fc81158e76cdcd51084b52",
-      "swapFeeFactorForNegativeImpact": "0xe5f10a8eee33843ebf12cef81e4141d649bfb8c2584c80c0fc1e71d1e32d0d0e",
+      "swapFeeFactorForBalanceWasImproved": "0xf9e19bb3189d432360663917ab7316f9eb15e32ca0fc81158e76cdcd51084b52",
+      "swapFeeFactorForBalanceWasNotImproved": "0xe5f10a8eee33843ebf12cef81e4141d649bfb8c2584c80c0fc1e71d1e32d0d0e",
+      "atomicSwapFeeFactor": "0x6f191cb60f240eb255b18e35b30e69a2555b7cd004db58df4413f6ce73989ac1",
       "swapImpactFactorPositive": "0x51f43de19f522a77191e09d4d845cabc4a6b411ed843bd7333c97c0dd2a1e99d",
       "swapImpactFactorNegative": "0xdb943b0a66e6c7d34998c8e3ff6ce90d1f79df2b550aac083000d80ca80b1277",
       "swapImpactExponentFactor": "0xb4650d732840a970384403281dae1ab9569caa614bb95e82e845e5dbdec3f3ae",
@@ -780,19 +1040,25 @@
       "maxFundingFactorPerSecond": "0x62aa103c40f4782518c92f328ea7e13953221a344bbe17e1182069e74bdccd43",
       "maxPnlFactorForTradersLong": "0x5c46a769b0e6fc8e1900598d8b17673417a9f295712f0839f2ba621fdaaa1420",
       "maxPnlFactorForTradersShort": "0x3157f0b83f7f288d4345b32021f8625dd0211a0bb3a856869d8449883481df51",
-      "positionFeeFactorForPositiveImpact": "0x8e1966a3f947cb6695cd3294ede56aa8667a859843a47c8a1dfa15355ae302bd",
-      "positionFeeFactorForNegativeImpact": "0x3d52d46103b4fd7fe8a8d527bf5a484d3950554a42a2879766c90dcaf48541a1",
+      "positionFeeFactorForBalanceWasImproved": "0x8e1966a3f947cb6695cd3294ede56aa8667a859843a47c8a1dfa15355ae302bd",
+      "positionFeeFactorForBalanceWasNotImproved": "0x3d52d46103b4fd7fe8a8d527bf5a484d3950554a42a2879766c90dcaf48541a1",
       "positionImpactFactorPositive": "0x7938767f73461676c26d5a862999ac1f38ce4efa8b026f6ac6b1e8df69c4a8f7",
       "positionImpactFactorNegative": "0x9028c1019ee95416ba45534f1a394daea60dc7fdd77b5320961b263773789bb5",
       "maxPositionImpactFactorPositive": "0x8cc0069408f08a8a1e914d23f0bd90ab2edd81dcb73ba80808c1cb161d7f866b",
       "maxPositionImpactFactorNegative": "0x8326d13e731e4a06711e304528185e6df2a513e097f53a509c44e802ebc0c816",
       "maxPositionImpactFactorForLiquidations": "0x3ffd3e2d8443b5c30958a5bac0fdf3d6c024ea77777f91dea6aeaeff923797cf",
+      "maxLendableImpactFactor": "0x04ebe570057f2180ebd8a9974508c054a9ce74f674831b8416c93266451a1283",
+      "maxLendableImpactFactorForWithdrawals": "0x6deeca3b9918df157ac6b79b200ae21f3325e0d5f776ed8cd20b4a84d38fea1e",
+      "maxLendableImpactUsd": "0x8d8d59ace8460900776b284975c4d174a52b808a53c04a79828065217ed88e0d",
+      "lentPositionImpactPoolAmount": "0x3ac5b008a4a45cde1635b3032377df6d75074abf6c7d9a80b4b93fdf82711019",
       "minCollateralFactor": "0x69a941e84ede0f13d1c7a57eb687f63ce8927eeef908b0e1e8dc22f9fda6c050",
+      "minCollateralFactorForLiquidation": "0x5cbd1eda2c597db32bc6c3e5e9098bc9dbf2442d0956252f63722275452b0da7",
       "minCollateralFactorForOpenInterestLong": "0x9a7f1df75521d5245272629ae3d633c5b1df32b56dbfb7bcb79f6ed1783f3207",
       "minCollateralFactorForOpenInterestShort": "0xa3964e38e2bfad919081510f192eb40d3c12b8102f229d74230e94476af37ba5",
       "positionImpactExponentFactor": "0xc59aff205787697cfac1654c750728376206127692ee4e7134bb41d79217bcb6",
-      "swapFeeFactorForPositiveImpact": "0x3364c0f9fc9f8bb96a1008c317d26b51f20c5ea1d1130799e4662d8c4a7bf3b9",
-      "swapFeeFactorForNegativeImpact": "0x305d6a42c6ccdab58c16ec512fc0b9394bf2dbdf82516c15d09cdcb76085e4b2",
+      "swapFeeFactorForBalanceWasImproved": "0x3364c0f9fc9f8bb96a1008c317d26b51f20c5ea1d1130799e4662d8c4a7bf3b9",
+      "swapFeeFactorForBalanceWasNotImproved": "0x305d6a42c6ccdab58c16ec512fc0b9394bf2dbdf82516c15d09cdcb76085e4b2",
+      "atomicSwapFeeFactor": "0xa911e8a22efd7c8716579f5327ca2b5363b5957bee2a2ac32ebc7b04a009c024",
       "swapImpactFactorPositive": "0x6ca9dab5d892a8a0c799579aad85021f29ddde1c808da563752093e0ddf2d4c7",
       "swapImpactFactorNegative": "0x0a2d863399db84d689cfdc9148b1a486ad96583764fdf636a66862500cc51b96",
       "swapImpactExponentFactor": "0x081a97750956cc6250ce06858d4427b11c1f050d0dacb64792d92f18f66a8da9",
@@ -830,19 +1096,25 @@
       "maxFundingFactorPerSecond": "0x2e363ac3de945f9e347a42944c7ddc509c53f8ce07b05316181a4834368d4af7",
       "maxPnlFactorForTradersLong": "0xc2b6ba297e2818e9751c3039ff2071b2ae3b4d72dee96205fd6c62cc9545a5ab",
       "maxPnlFactorForTradersShort": "0xa7db2c7ecf2ff216c4276556a88d852ea7296c5da8839673baa4f00f17e708c1",
-      "positionFeeFactorForPositiveImpact": "0xd777c5b4d55d87e7a3876930db0af4b021a643cfa9070d896e77bda6b5681d6a",
-      "positionFeeFactorForNegativeImpact": "0xa94fd16219d3c4b400807acb21ef6ac91bb6f1870bca3cb5ba5a19dc4f6e6c9c",
+      "positionFeeFactorForBalanceWasImproved": "0xd777c5b4d55d87e7a3876930db0af4b021a643cfa9070d896e77bda6b5681d6a",
+      "positionFeeFactorForBalanceWasNotImproved": "0xa94fd16219d3c4b400807acb21ef6ac91bb6f1870bca3cb5ba5a19dc4f6e6c9c",
       "positionImpactFactorPositive": "0x644525ed476f4be317620be6a478b562b0de82d724dbced4b69c638ebdfdec79",
       "positionImpactFactorNegative": "0x1d5d8012f2837929e603657bc2d70a612947a3a1926d332e48e709b209d90f9d",
       "maxPositionImpactFactorPositive": "0x5319f499876d4621e715dc632e7d7cb3933dc765ea1acf8d430e17a55393e986",
       "maxPositionImpactFactorNegative": "0x7e416f0acea3cc9622087968a015c15cf9a9039935214cbd69d6e7a2059f93fc",
       "maxPositionImpactFactorForLiquidations": "0x1763e966632029c1f297e56d1a17944619af4ac6276c6f897ecd10bedd501f28",
+      "maxLendableImpactFactor": "0xebef0970db3654b327983d90211b1d5835ca7aba423825a79892ebc3830b8290",
+      "maxLendableImpactFactorForWithdrawals": "0x94f2a84873648f9fdb79ac47c08980d65bc572ac20486f76d6aff0d08b39e68e",
+      "maxLendableImpactUsd": "0x5b357ad4bb38a6e6c6bb0046dbff6dd7e04211880474c6776313374c3801b90e",
+      "lentPositionImpactPoolAmount": "0x82ab418657d08d9c6646d415bbf1151bf53f6fdf275d3d8e50e6a373504e3ccc",
       "minCollateralFactor": "0x658da6dd132bb7e1756b246c646e4f3681462f841ea26f37d83a1bc7a7c640af",
+      "minCollateralFactorForLiquidation": "0x3f735896b5ad89fc720a25fd616b3c729789db640f8a0620238eefaf2fc2de7c",
       "minCollateralFactorForOpenInterestLong": "0x5b29bc756da04509ebef8e49358a85e1b080ee9d9b19f646413c7ec366643c4f",
       "minCollateralFactorForOpenInterestShort": "0xc386fa4fcdecdfd9ac1d63b2d86d391f4676ced1e3ddb89d47bbb629bfcbde6e",
       "positionImpactExponentFactor": "0x2214e49931ae131c89d827b277789c69bccf736319f9448888c99ff753982a5f",
-      "swapFeeFactorForPositiveImpact": "0xcf099a51e285d31b3ded24bb284f311662deae9715dff06251f99a1a623a7c01",
-      "swapFeeFactorForNegativeImpact": "0x54f7ac0acaf50fddc48a4d1687ef164394bd31f48441c86b9fea6d348f7d83c8",
+      "swapFeeFactorForBalanceWasImproved": "0xcf099a51e285d31b3ded24bb284f311662deae9715dff06251f99a1a623a7c01",
+      "swapFeeFactorForBalanceWasNotImproved": "0x54f7ac0acaf50fddc48a4d1687ef164394bd31f48441c86b9fea6d348f7d83c8",
+      "atomicSwapFeeFactor": "0x16e598fd74c94ad3c757bdf8764ccf02388d376df4d70c59d9e7e5b05a8dc129",
       "swapImpactFactorPositive": "0x004df3c0dc3d5b0aef8045ddf6c7170646212a2708d9c8efd90d42aa68887f7c",
       "swapImpactFactorNegative": "0xddc46fbfef1ad897fbe83b4250c0e21dc33408f6035ed37f98b4349cac818569",
       "swapImpactExponentFactor": "0x923471186f28cf538007fd535bdbd75f7378d1331f6d07cd2a40276153e34550",
@@ -880,19 +1152,25 @@
       "maxFundingFactorPerSecond": "0x600ebc560d5b1d959a5561e38cfc1e6fbafa3f74e4b84d3c77c000003913420f",
       "maxPnlFactorForTradersLong": "0x48fbe5087841455da95914af5afadfdb9bff2c13381ddd257abb5a01860d302e",
       "maxPnlFactorForTradersShort": "0x22cd9499d49aeaa2f91b64be08489a3ce928b8022d46363d16d60d459b0d7f94",
-      "positionFeeFactorForPositiveImpact": "0x97c1a448f396a50ccc22e2ea500e54434962a5249dc5a661d06658985ae59383",
-      "positionFeeFactorForNegativeImpact": "0xddf9c6e8a3146f2034501e798506b8a353893e80b3de3748c74b87532f824982",
+      "positionFeeFactorForBalanceWasImproved": "0x97c1a448f396a50ccc22e2ea500e54434962a5249dc5a661d06658985ae59383",
+      "positionFeeFactorForBalanceWasNotImproved": "0xddf9c6e8a3146f2034501e798506b8a353893e80b3de3748c74b87532f824982",
       "positionImpactFactorPositive": "0xb906177bd22906fb4855b38744d7322883feb6e061495886d5c12d0b8f810ccf",
       "positionImpactFactorNegative": "0xc75f07b39b2aaf3050d588849ef734198cff5801bfa21c4559b08a95e281f72d",
       "maxPositionImpactFactorPositive": "0xe38a3799bc01e41c85e5fd8df2d75f32af5e85731835f96bec4cc30adab2fe75",
       "maxPositionImpactFactorNegative": "0x409c6508fd9685bb329819c23f0ec5e609025de5ee993837362348919dfb86b3",
       "maxPositionImpactFactorForLiquidations": "0x49704998ebf84402cb8e86f8e617cfc500631b77d9589d637e25350c84582f29",
+      "maxLendableImpactFactor": "0x1c73ec35a26f4307497d8cf7691e2b2af2c1d8d575d497ee365bd1aeee24d11b",
+      "maxLendableImpactFactorForWithdrawals": "0xe747a8862385c810a6a424472e69c7774549bbbf532d91c87861d0ac1bcb93df",
+      "maxLendableImpactUsd": "0xa9b9ec70460741f91d78a921f8aabbdb18ece7faefbc2934034a21ce9f38b78b",
+      "lentPositionImpactPoolAmount": "0x1e63a813f114a0e36791d2cf3cb9c8ba278c895facd33bf82652b841c163964f",
       "minCollateralFactor": "0x99b3701cc7c1265785f49ccd881b41099fbe598b8eec779a1cb9f9d0ab47c538",
+      "minCollateralFactorForLiquidation": "0xa3555afc1b6acabe022942d56a72327d65daf86bf7eec60ebd84645c8793ad58",
       "minCollateralFactorForOpenInterestLong": "0xc711c4d6d1307e7c53adb1d3e70e48374818834facdddda9f3aa07ab3b84b6eb",
       "minCollateralFactorForOpenInterestShort": "0x43728b39e120b4a41ea9f74f87206a5de82c1fd6020b9c20e8a12becd690628a",
       "positionImpactExponentFactor": "0x58ff383b5858a0568214aa46f74f6c6acda40c2de4e119a9fc703e6e9f883533",
-      "swapFeeFactorForPositiveImpact": "0xc88b708cf46980ee7b53f2d31c02cae3f4097451afe3d262d1ae325896e2fb2f",
-      "swapFeeFactorForNegativeImpact": "0xae26f90162d5a9dd0c751088ef6e3d8ad0a4e4d4296c92959aecebe6eba55438",
+      "swapFeeFactorForBalanceWasImproved": "0xc88b708cf46980ee7b53f2d31c02cae3f4097451afe3d262d1ae325896e2fb2f",
+      "swapFeeFactorForBalanceWasNotImproved": "0xae26f90162d5a9dd0c751088ef6e3d8ad0a4e4d4296c92959aecebe6eba55438",
+      "atomicSwapFeeFactor": "0x5671a7614ebe14a1898c515d300b8190920c147b248e214499e630554e877391",
       "swapImpactFactorPositive": "0x9afe4fd264c1db9a7311ade7ccd92b9901cda321ff91dc4a544e60e9aefdd403",
       "swapImpactFactorNegative": "0x24b8ea4213ef6ea1381eef1d22c8be6e6a2776542043f94cd0b75451e722acc3",
       "swapImpactExponentFactor": "0x4436d7db87e33e8caf71800781dfda7be283203615038a5bc6bad07cdfa8ddeb",
@@ -930,19 +1208,25 @@
       "maxFundingFactorPerSecond": "0x791b8aacf46146f2c630c31e87150454705394d0ddee283d9a218093004c4991",
       "maxPnlFactorForTradersLong": "0x61205f138d458d410fb24113fddaf8bfb906c41a5bd1243e09a60bd3fa95e6ad",
       "maxPnlFactorForTradersShort": "0xef08c3656d3ce51df1b75f08a987d879463632460692bcda68e4ef17ebac29c7",
-      "positionFeeFactorForPositiveImpact": "0x55eb1bd845d62653b5e99b5862c3604b078e1609942fddc47148214a9f1b6c98",
-      "positionFeeFactorForNegativeImpact": "0xeab5b72f46abf95fba34f585b311a74eb14eb8c40d3030aa04e806881a5338f3",
+      "positionFeeFactorForBalanceWasImproved": "0x55eb1bd845d62653b5e99b5862c3604b078e1609942fddc47148214a9f1b6c98",
+      "positionFeeFactorForBalanceWasNotImproved": "0xeab5b72f46abf95fba34f585b311a74eb14eb8c40d3030aa04e806881a5338f3",
       "positionImpactFactorPositive": "0x5639f816f2049a823282162b24c26bccad96430b6cc80cfd802a6e0a4daa48e8",
       "positionImpactFactorNegative": "0x64b33aa4893fc85aeec723156a0fc0c151ec4e7d9e8c3f2f3225e52cdc6f5453",
       "maxPositionImpactFactorPositive": "0xebacab0fccc785fffddf4ce399ec5f857e302fa137d3b3443f5a3153b5d925b1",
       "maxPositionImpactFactorNegative": "0x0a64b1059a69b7fb1f5738256b5d1009c654a0343331b552b0946bce23fa5abb",
       "maxPositionImpactFactorForLiquidations": "0x9f5eb4d0a87742d78eb809fd1c85d378f22e830e2155e4c130147b107606db2c",
+      "maxLendableImpactFactor": "0xfbe064e19c3e25cc5bfd9034893728a86c34fe48c285de49de11478c9763c2c2",
+      "maxLendableImpactFactorForWithdrawals": "0x6f18cbb5bc5d13d823dfa54644e3830fa136f22c5249c629344ce22761600d77",
+      "maxLendableImpactUsd": "0x760f274dbc4197734350f453e31e52e0f92218688034645fd667c249904ce555",
+      "lentPositionImpactPoolAmount": "0xf1161f028f91a3ff65d2ed847183aaaee60d6601e3dcf8eb35b30636a1dfadbf",
       "minCollateralFactor": "0x505fc7c1a1954b72fd3b5f7f9b5250661340b75ce9e9044e6dd11c8da2d692db",
+      "minCollateralFactorForLiquidation": "0xf2a71a4e761efd126653b700f3f521749f94b22a97852ad66374cdd674e545c9",
       "minCollateralFactorForOpenInterestLong": "0x7be7f22de8ae3c36d8218b44d06c5a126ea07b5bf1176ff4e90c34ccdae32302",
       "minCollateralFactorForOpenInterestShort": "0x49034ddfa16113a80d2c700f7fa75fee26f684beec367e2c7d7e4f3f08320bb8",
       "positionImpactExponentFactor": "0xd0316ba8768fcb3880ea8519def956514eb9bc7d1cd1d9805bc936e379eb8610",
-      "swapFeeFactorForPositiveImpact": "0x3097eb783f61d26eb308b82a5f390ad8a3b17605c548f16f6c22a9e4a9d4fdfc",
-      "swapFeeFactorForNegativeImpact": "0x8439bc00c0643f5214a648849ed64fad4e16c6fdaa17c415cec3232757a71e70",
+      "swapFeeFactorForBalanceWasImproved": "0x3097eb783f61d26eb308b82a5f390ad8a3b17605c548f16f6c22a9e4a9d4fdfc",
+      "swapFeeFactorForBalanceWasNotImproved": "0x8439bc00c0643f5214a648849ed64fad4e16c6fdaa17c415cec3232757a71e70",
+      "atomicSwapFeeFactor": "0x5c32414b2d8daead8b548e58f19445b0a6fa9c0ab06c88a953caa92b0e0e09eb",
       "swapImpactFactorPositive": "0xcc58aaa5866cf4113e41fc4df9e5ee80b1d697ae5449bb1aada134f5eb228cbf",
       "swapImpactFactorNegative": "0x02fcf4c3f06217571778935d3f7e97c3e8d72c50baa6e937265d4b9d3cb65b37",
       "swapImpactExponentFactor": "0x68b31e362df2067ef9092172713fce629e43c8fb3ae7c604fda0e6ba18967a4f",
@@ -980,19 +1264,25 @@
       "maxFundingFactorPerSecond": "0x0a6526a497e4489cf4be22651eccc3b5071dc85cdaf2db76ebbee48f55fe4b44",
       "maxPnlFactorForTradersLong": "0x9ddabf7f3e53a1821379516b58312039c6eb26b81ee291c1252ef022bc03dc64",
       "maxPnlFactorForTradersShort": "0xbd9f0a0545529a2ddc6068c9d4d8c38529cab28e6dbea62d20017cdf93bba76f",
-      "positionFeeFactorForPositiveImpact": "0x483710f439356b530fcbd39fe35dca94e09ae68f9b42137c2426b15c7eecab44",
-      "positionFeeFactorForNegativeImpact": "0x9fcbf5b6ce818dc0a039fe77c3344216992a26473d6aa52571b5f9b1ebdd29f6",
+      "positionFeeFactorForBalanceWasImproved": "0x483710f439356b530fcbd39fe35dca94e09ae68f9b42137c2426b15c7eecab44",
+      "positionFeeFactorForBalanceWasNotImproved": "0x9fcbf5b6ce818dc0a039fe77c3344216992a26473d6aa52571b5f9b1ebdd29f6",
       "positionImpactFactorPositive": "0x6e0611944f4603e4b3eb24878be8b06c454f0d32cdbd115b6989ce8666412b9f",
       "positionImpactFactorNegative": "0x6e3f4836d516e2b3c7d97f4eb14b647210743805f6625f18dc048184d42f3236",
       "maxPositionImpactFactorPositive": "0xa49f2ccad33245c6c3e4e65abbc1b574fb1b260c790a598aa1607b7916af939b",
       "maxPositionImpactFactorNegative": "0x1264f0fe836dba8344c27cfd30a27687f01ede436cbcb88905f3d099866aa385",
       "maxPositionImpactFactorForLiquidations": "0x3bee549827b24a6c7258484153433d3e8975a38058ca8301a06274c57c12febb",
+      "maxLendableImpactFactor": "0xa75bce095842fe06e45af063eb831699f32ddf980e20fcfc902ca2631ca02613",
+      "maxLendableImpactFactorForWithdrawals": "0x31db483709baba5a5308053acd07bf2634f332731b317661879c618d0f5c602a",
+      "maxLendableImpactUsd": "0x29e9b1977298989ed1a7683018b65cb8acbcc60e5192fd76c1059701b553e10a",
+      "lentPositionImpactPoolAmount": "0x3c32fa51b15bd069ea7b9492ae965d188a2b02920e70ab1a161dea34f0f3ad41",
       "minCollateralFactor": "0x23996b6d9b7a115e3ce89b84c1fb992e361ab8b7d0eee682f20dee97ec68ffe1",
+      "minCollateralFactorForLiquidation": "0x7c2459f97adc8e43337e81a934c826ed807ff31274e3f0092cc5677aa9ff20d2",
       "minCollateralFactorForOpenInterestLong": "0x35859412d8490a4c126fe4f1bfc34c55cb8fe37dfa500acd3c8b86af666c5ec3",
       "minCollateralFactorForOpenInterestShort": "0x9fbb1a4f2cee065baea2f8cc6c37830cef07cbbc7a5c433a7a525949f5ecebd1",
       "positionImpactExponentFactor": "0xb6bff386e5ea9af0e6720bebfdd73d88abd8d3028c1819942bcee244f2ca9405",
-      "swapFeeFactorForPositiveImpact": "0xaaf64b979df9faef0f42c389d81152da8e9d914ed4fae4f41a31ef0f70334eb0",
-      "swapFeeFactorForNegativeImpact": "0xbe982294c986c3affb4919d120c418c791a8602c614700dc2bb0ca07815e6ed0",
+      "swapFeeFactorForBalanceWasImproved": "0xaaf64b979df9faef0f42c389d81152da8e9d914ed4fae4f41a31ef0f70334eb0",
+      "swapFeeFactorForBalanceWasNotImproved": "0xbe982294c986c3affb4919d120c418c791a8602c614700dc2bb0ca07815e6ed0",
+      "atomicSwapFeeFactor": "0xf53ef4c33158142d328bfc7c66ddd8ddda3b43d1f6a9ebcdf63a7e2a1d439ca1",
       "swapImpactFactorPositive": "0x9fd271446b4cb4dabfda536750bd6f93b58bfb591131e601bae3c640d9609b2a",
       "swapImpactFactorNegative": "0x4a7f2a5421a3eb1067a7e45de84e107fc455e79cfbf6236aa396f99272cfe4b0",
       "swapImpactExponentFactor": "0x4ddfcb88742329060e7fae862f0bd237355ac1d858fc4be4928caa94ceef9abd",
@@ -1030,19 +1320,25 @@
       "maxFundingFactorPerSecond": "0x5b6b8bfa2a902a4700b5a546209cb4097cb278eaffa6c775832110dec862dd16",
       "maxPnlFactorForTradersLong": "0x7e878f228e830c2c29edf1cebd86787df291d03924e2681eb9192db2925e2576",
       "maxPnlFactorForTradersShort": "0x13a5a683a8052446dd311ec4c4a537be6c046a45cdf374b87ecbd3663196e07c",
-      "positionFeeFactorForPositiveImpact": "0x546c33b1dba15b428da83872dde33a920eb215ff6f219683cd72ba4a26d5c533",
-      "positionFeeFactorForNegativeImpact": "0x8d6b3bf9f919ba71b67feb739447c6b300ac0f9f79068132584ce16c2a1e0fda",
+      "positionFeeFactorForBalanceWasImproved": "0x546c33b1dba15b428da83872dde33a920eb215ff6f219683cd72ba4a26d5c533",
+      "positionFeeFactorForBalanceWasNotImproved": "0x8d6b3bf9f919ba71b67feb739447c6b300ac0f9f79068132584ce16c2a1e0fda",
       "positionImpactFactorPositive": "0x799fd72dcd8bc0b912b482f186a074b67fdab11aec58c5fc3c09a5ab601bfe4d",
       "positionImpactFactorNegative": "0xc35bd69b22ba7b4339033e97d3d4ad5735fbb434b54e10be44bac834d63d4ca6",
       "maxPositionImpactFactorPositive": "0xe2991c2345da0cfdfd5b8ec9e7676658276be8890053e15fcccb194d3bf7e12b",
       "maxPositionImpactFactorNegative": "0xe113eb600d7bbf5d1eecc81235c5881d5d33afb2f11d9ec2a2be8028b471a17b",
       "maxPositionImpactFactorForLiquidations": "0x5837f920215e0e61cea98ec67e54f88ea6b2c37942ce77134be57426826ea24e",
+      "maxLendableImpactFactor": "0xd6ed141e8b8c6e2661ae4c99f03c1a2ee9ad0e40c565c5425075c5e1deb120a7",
+      "maxLendableImpactFactorForWithdrawals": "0xb6877a6bd2fa681248dd21765f9e70148c4a9d8828b25b28477a2b545880afd8",
+      "maxLendableImpactUsd": "0x46ef0d545d15cab8085e3b3fa590e5f0cd1dbe97e8f24becb729ed6174433f85",
+      "lentPositionImpactPoolAmount": "0xb1ffe51e28a73953e596bb398eb721fbaa5e76baa0daf35ed61480cb11298899",
       "minCollateralFactor": "0x36ab3e3013ad52ba6a0d8f4a0453b7102f49cac48a2a11fa6c73dbe0aefe816f",
+      "minCollateralFactorForLiquidation": "0x5bfcbab875f4417b539e955ceac950cd006a69b7f451081607ba40e7fbb369dc",
       "minCollateralFactorForOpenInterestLong": "0xb53e1f7357d8985ac911799567e535ae47b4b735a3aa570d896d2675c5ebb6d9",
       "minCollateralFactorForOpenInterestShort": "0x24518edda98ceefe82f1204ce0f521627a009586216d80895e53abfe2ecf184a",
       "positionImpactExponentFactor": "0xd0f2eee3c7933f4cd4be61e89645e29cc81fe2e6b8182b4622055eda40e77d48",
-      "swapFeeFactorForPositiveImpact": "0x95cc059a74ab0cc2d211ba23f2332e2b506142a89fddc54e2006bc3f35931464",
-      "swapFeeFactorForNegativeImpact": "0x4771d81fc424f4ad1751f397a8bf3cccc268f477d6a35c745a0e9d1841e1027b",
+      "swapFeeFactorForBalanceWasImproved": "0x95cc059a74ab0cc2d211ba23f2332e2b506142a89fddc54e2006bc3f35931464",
+      "swapFeeFactorForBalanceWasNotImproved": "0x4771d81fc424f4ad1751f397a8bf3cccc268f477d6a35c745a0e9d1841e1027b",
+      "atomicSwapFeeFactor": "0x121d44595c73c7cf96dbeb5db9d1e30a4f96ace8ca98fc55606bb043dab27176",
       "swapImpactFactorPositive": "0xb5f17a97f65ee498fdac7f1788550bbd6a729107081de95c3890c697fe931481",
       "swapImpactFactorNegative": "0xddcb4f9e4b88feb61b957dbc5dc0bd03435c471d8ab9c3c985699b0cad17ffc2",
       "swapImpactExponentFactor": "0x83899b2c9cd5391747c3988b8797dda3e5f3189c446c3f43746edd33e6e4bd1c",
@@ -1080,19 +1376,25 @@
       "maxFundingFactorPerSecond": "0x6c5d09a30a097dc3ce6bc2bdf3ae5515da61cf6eee5ffe30776669db8d0299ff",
       "maxPnlFactorForTradersLong": "0xa4856280b896701f3961e30b5ae67819ccfb3ecfcc1b02b51a279498566bab2a",
       "maxPnlFactorForTradersShort": "0x9261ef9a90b9f9785f18258aee39f431e7af66971ce7628b37dd197d93bde9dd",
-      "positionFeeFactorForPositiveImpact": "0x98853d8dfbb87c8e9d5e028e404924d8e05219c0b47225b2044b7e7877f7a173",
-      "positionFeeFactorForNegativeImpact": "0x37f06a157c23a33de4ca7196216ce1915ec1a3cc92d0a99ad8546b9ec307ccd9",
+      "positionFeeFactorForBalanceWasImproved": "0x98853d8dfbb87c8e9d5e028e404924d8e05219c0b47225b2044b7e7877f7a173",
+      "positionFeeFactorForBalanceWasNotImproved": "0x37f06a157c23a33de4ca7196216ce1915ec1a3cc92d0a99ad8546b9ec307ccd9",
       "positionImpactFactorPositive": "0x548ce19161df3c4381f589d02db21974b0760e345caad0f3d209d39e87ef0e93",
       "positionImpactFactorNegative": "0x7f948d551673d7db11bc768d5e619644ad8fcd7d3b5ea979802542bef58c1ac2",
       "maxPositionImpactFactorPositive": "0xcc90fb298e671c27c085ae0f7416295fadedbd92249139252ddc869a5ca25dc7",
       "maxPositionImpactFactorNegative": "0x08e3b3b485b631d3a46abbc16ece5d6f745d41def3f018df49b7c4943d4a15e0",
       "maxPositionImpactFactorForLiquidations": "0x52ac32768630686448d7056b478dbb59679a30728f24b36d590687f6188e1491",
+      "maxLendableImpactFactor": "0x1377b71f205affe712d85cc326a1813712cb326b30389154258cad6dad05449f",
+      "maxLendableImpactFactorForWithdrawals": "0x12e5f81e5061c091fe8da4eb9fc0578d98e6295028fb78b95908fddd566f75a0",
+      "maxLendableImpactUsd": "0x40eac551dff2fa3fd0b390d4fe083c05fde69ac07714f4c3b7b7effde854972e",
+      "lentPositionImpactPoolAmount": "0x5e10504e2df2f7b9e0d4f93203ac210d795d5515f628c4a893ddd59c87b9d7ba",
       "minCollateralFactor": "0xb763d546f4c43a22e39e6d544d2a097e2b739449ac8125be625ca1b3edb6c7e6",
+      "minCollateralFactorForLiquidation": "0x58a728580355a6c6f82d3091d369b941e0376ff8b3d79274d71ad1d29d0748e2",
       "minCollateralFactorForOpenInterestLong": "0x4279cffcd52e0915df8447175e708381712393531426166172e9a466f544ea6e",
       "minCollateralFactorForOpenInterestShort": "0xa7dd5e63b8b99bbd36c61b26e144889399099bdc86c904aa8dcf3d53670a8806",
       "positionImpactExponentFactor": "0x3a2cd4a711e8cba8017733aa537e32ebfd2e5fa858bf0a773a3967ca2f7b30b0",
-      "swapFeeFactorForPositiveImpact": "0x4965fc8a21524ad70b41143626dd638286b9b42ceaa02dbb9bc821f614cf9fdf",
-      "swapFeeFactorForNegativeImpact": "0xf890051400774cc25b9f4e404ba50d42ebd497e3b1c8b9541fa1da94174e71c2",
+      "swapFeeFactorForBalanceWasImproved": "0x4965fc8a21524ad70b41143626dd638286b9b42ceaa02dbb9bc821f614cf9fdf",
+      "swapFeeFactorForBalanceWasNotImproved": "0xf890051400774cc25b9f4e404ba50d42ebd497e3b1c8b9541fa1da94174e71c2",
+      "atomicSwapFeeFactor": "0xcfb92ad1dd016d2ee0067cd81c7dc4c64f292f95f56158b5ab39d25a80821d77",
       "swapImpactFactorPositive": "0xa6399402207293d84fc48222f3238feae062d86e26e725edaca06fab54bf2e4b",
       "swapImpactFactorNegative": "0x8c3bbbb69bd132cae186a17c0f17fec773e3b7d2ef52c639a31ce3ecc4bba196",
       "swapImpactExponentFactor": "0x9a72811ae0698e31c2231403ff4e3263f7a83255c3ebd61ff1a9e6c90a5014fc",
@@ -1130,19 +1432,25 @@
       "maxFundingFactorPerSecond": "0x3835500eefeba57cbe50ccb407e19aaec2f84810d63c5390fd9e7b6754d9166e",
       "maxPnlFactorForTradersLong": "0x1383fddcb6581558336fbc217cfc3db183cd69fb3e7cdac5fdf5ddafcfe3c75e",
       "maxPnlFactorForTradersShort": "0x71d36d7c6a247209ce0590c54c0d14752956059486987fc5161b7bec6739c8b3",
-      "positionFeeFactorForPositiveImpact": "0x2708cfa61a406341dc08ec540f21a474d06cc5091f45dad2888452f9619320f1",
-      "positionFeeFactorForNegativeImpact": "0x3596e5879e782fc01324e6c9391e2fe90856824c369c31b33c23987e61304bb7",
+      "positionFeeFactorForBalanceWasImproved": "0x2708cfa61a406341dc08ec540f21a474d06cc5091f45dad2888452f9619320f1",
+      "positionFeeFactorForBalanceWasNotImproved": "0x3596e5879e782fc01324e6c9391e2fe90856824c369c31b33c23987e61304bb7",
       "positionImpactFactorPositive": "0x5871f75e257b7d79f48e659a4c02d14ddd0b8baca3c4a1583219d85f177c5268",
       "positionImpactFactorNegative": "0x46340a568baf8d8bdd7d3198bfd3d4327a7532eac8a249a7cd6fe33cc05a86ea",
       "maxPositionImpactFactorPositive": "0x19d692d2b95d1189dba6f596c97673a944821958599797b977eb5408ce276ba3",
       "maxPositionImpactFactorNegative": "0x36ed3cee02b2c2f532d0985c0ea3f92ed5e980ce06a1116a0b6f2f65fa0de69d",
       "maxPositionImpactFactorForLiquidations": "0xc7ca98bf7ac93f2ca8dc4a8a99e99194279493898e08ebf4b7e8f6cfe0452d7c",
+      "maxLendableImpactFactor": "0x186d29173beb29e46af8507ad99c5439541dde2f0ee0c5daaa001ff1522560f4",
+      "maxLendableImpactFactorForWithdrawals": "0xe646136991d826f11c1fd55ac36d40ea073be24c6353d193a821948bb77807cf",
+      "maxLendableImpactUsd": "0xc2038495be0ecd8d1bda4b8095be40012716d2c89bd121fa47fb714fd43a3ff4",
+      "lentPositionImpactPoolAmount": "0x86993b1b8299f1d667b8e7cf1df927971d6ab63c3001caef307649681d3c52b9",
       "minCollateralFactor": "0x1cddd19b6c5ab7bac13bca435de5c29b7eb8b6d8f63653990ca7d124b6630211",
+      "minCollateralFactorForLiquidation": "0x59c09f1291f52daa4c169c57c3226ef99241adaf315a955970e8f7c25f3735a2",
       "minCollateralFactorForOpenInterestLong": "0xf62a2cd524471634da150460345daeb42bcc47fc9a8b5ea5b1a581013edfef77",
       "minCollateralFactorForOpenInterestShort": "0xd9b39ffa382462e2b24dd0ebd1c3baec3d78c5ade8d4cbee813c5b8a51baeb20",
       "positionImpactExponentFactor": "0xa2af6371bc1aeebd6802ac29ccd755b5ab13703022b5b772111b4e555273e745",
-      "swapFeeFactorForPositiveImpact": "0xa08dd6fcd6029bc48ce2addf2868af78d216638205a73838668634ca2a4981b7",
-      "swapFeeFactorForNegativeImpact": "0xc9bbb4bcd2036e8e18f3fd37c85140389749faa6bb95005ded218d00ab217029",
+      "swapFeeFactorForBalanceWasImproved": "0xa08dd6fcd6029bc48ce2addf2868af78d216638205a73838668634ca2a4981b7",
+      "swapFeeFactorForBalanceWasNotImproved": "0xc9bbb4bcd2036e8e18f3fd37c85140389749faa6bb95005ded218d00ab217029",
+      "atomicSwapFeeFactor": "0xf8346cdca37cb62bdba7aa727ef4a442631ad1e0b5043132b92388fddf5aec81",
       "swapImpactFactorPositive": "0x9f5c1ba768149251f1ac9bbe83db59ca66c5bc1dac404af7fe71e644dfe9cbb7",
       "swapImpactFactorNegative": "0xded0c3d499ee81a6f139dbbbafd11a57b4b0d741c4deed0eb81b462952739816",
       "swapImpactExponentFactor": "0xcb33824480bc1af4edb3a02742e93fc84d154d007addbabbf9515e6b900085c3",
@@ -1180,19 +1488,25 @@
       "maxFundingFactorPerSecond": "0x0bf8542c05326ad5f245f8ba4f53a5413526ee86b08ab300cbcfa53c8f7e75bd",
       "maxPnlFactorForTradersLong": "0x7e1a7f613272fff1571d4406fb4f7943444c3fe98768f85cdaf2742879ff334f",
       "maxPnlFactorForTradersShort": "0x20c8ff6d63e62ce262a9cd193aaa60b95cf9ddbe860ab71336988a646baf26e0",
-      "positionFeeFactorForPositiveImpact": "0xc7f070dd821b1624b6a2929d567327bb3867502d02dcd2e71065cdd41ee23cf3",
-      "positionFeeFactorForNegativeImpact": "0xd5c959261e7a34eddeae5b309b1cca01ca260753eb2124ca19d3ed308287e0a5",
+      "positionFeeFactorForBalanceWasImproved": "0xc7f070dd821b1624b6a2929d567327bb3867502d02dcd2e71065cdd41ee23cf3",
+      "positionFeeFactorForBalanceWasNotImproved": "0xd5c959261e7a34eddeae5b309b1cca01ca260753eb2124ca19d3ed308287e0a5",
       "positionImpactFactorPositive": "0x24d1fea37d4c67a275c1d219f987fdd8716789d24675e2a5d1c83afa319a327d",
       "positionImpactFactorNegative": "0x80a256eee5da715b887d848baaf967bb8f7f9082d982e4678f4ce3cb6130d7b0",
       "maxPositionImpactFactorPositive": "0x6823916303f2ab71c4c0c51d8ebe85bd81c3e041feeead165128a864338a7e2b",
       "maxPositionImpactFactorNegative": "0xbea9f39702340352b6210661276d0196a3d4f0f52787211fdf3b2aa7e428ea83",
       "maxPositionImpactFactorForLiquidations": "0x21fe4ef5e0d11726ac12f09444f2a2a5296577de3e50ecaf41f28796c2f315ed",
+      "maxLendableImpactFactor": "0x893c92528968bfdcb2a8db3a3fd0d59a0469784a6a49c05e26bbf0696d241251",
+      "maxLendableImpactFactorForWithdrawals": "0x7d85b777c2461c1a7e4da064d63497d13736603dd9f5325cf60cc03e87e4e1d3",
+      "maxLendableImpactUsd": "0x8a0266bb93a239abfff419f4b80eb82e728536bd984d277b856de7864bb9ace1",
+      "lentPositionImpactPoolAmount": "0x046561480a0472652830888bd731acf65628b4a2dff051f19d7dbc909088b582",
       "minCollateralFactor": "0xcc59cb6b61c7943f711dc18dfc2fa4726e3e0e23320769e9599a2362835575cd",
+      "minCollateralFactorForLiquidation": "0x917066ba7cd6f4221b0632336d34aded85c1e557fa3093cc7014cb86885d30fc",
       "minCollateralFactorForOpenInterestLong": "0xd0b617f09379ad18f7bc551443b94d4b5c55e0023fb79c7165eec37289860743",
       "minCollateralFactorForOpenInterestShort": "0x45b9bea14109e02351108100e302342f22e4658eb48584be5fe6b4d585dfe27d",
       "positionImpactExponentFactor": "0x751f7109c025778b3f40dbc637af12a93d5a0c622c49f4115dc80f784b299eb7",
-      "swapFeeFactorForPositiveImpact": "0x83492ab5df99806cdbd8314795b516b6a9782b0942161be4f1af9bca88951ac1",
-      "swapFeeFactorForNegativeImpact": "0x63766eeca2ae5b09a2e0eb72120df5dbe6a8875527d67cd7b45ef9aba940e951",
+      "swapFeeFactorForBalanceWasImproved": "0x83492ab5df99806cdbd8314795b516b6a9782b0942161be4f1af9bca88951ac1",
+      "swapFeeFactorForBalanceWasNotImproved": "0x63766eeca2ae5b09a2e0eb72120df5dbe6a8875527d67cd7b45ef9aba940e951",
+      "atomicSwapFeeFactor": "0x8e88387d1a012a6f06628e8788e16bad6616eb06ba1404096c0c11a9bccea974",
       "swapImpactFactorPositive": "0x5a6f6f80c4a3e8d65986a384398e538c8faf9088f78210ea7b4f0f390633a51d",
       "swapImpactFactorNegative": "0x8f02874c8602664244cb90ca2139b5ba51aa0d59bd1479b6b94603a7cce88086",
       "swapImpactExponentFactor": "0x8ed2859874287cb901256ffbfb84ae0f23e82f31893202aa1d67db64e2b63a63",
@@ -1230,19 +1544,25 @@
       "maxFundingFactorPerSecond": "0x1da7debb0b6df3807925c7cbebd7dbc68d0ee443039816f3a8fd68c1f747b861",
       "maxPnlFactorForTradersLong": "0x7cfde814ebf3d1250c0842f9cdb144ced475a1dd2822a2c51c668916a60b5e4d",
       "maxPnlFactorForTradersShort": "0x69c09c494cb8be5ceec8b05f2fe89d979733230188b1fad94a8ecaeb1b277a3b",
-      "positionFeeFactorForPositiveImpact": "0xdf5425159f0f0d87b1f2539ee40a039a381156da40713f7016b06cf7a4b16b15",
-      "positionFeeFactorForNegativeImpact": "0x654dfb3012335aec94c961545f0be05714f87c533d86962a9ea736f56124362a",
+      "positionFeeFactorForBalanceWasImproved": "0xdf5425159f0f0d87b1f2539ee40a039a381156da40713f7016b06cf7a4b16b15",
+      "positionFeeFactorForBalanceWasNotImproved": "0x654dfb3012335aec94c961545f0be05714f87c533d86962a9ea736f56124362a",
       "positionImpactFactorPositive": "0x95058468ab52487db6520bc0a691ebe5ca226682fc034aca2f4291925890f7de",
       "positionImpactFactorNegative": "0x141ad82e988c1652d94c149e0ffc2b2f296d8226f0804545b9b2f30f3a3e50ae",
       "maxPositionImpactFactorPositive": "0xe74534e23b02234d9c1b63786b1e0595a47d733a393bb45daaff8b82dc4937d4",
       "maxPositionImpactFactorNegative": "0xe75fecd581da9d267408fb6b502d011f69de3d9d39119b2ab286e8856516bc22",
       "maxPositionImpactFactorForLiquidations": "0x631fd71c9b5735e3fe95e1cacc9080c5cf9a54e0785e4f57040a029e36e71131",
+      "maxLendableImpactFactor": "0x5c1355c208968eb059ad9b5206638c84d384a7bd050a8a5bd779d176eb061ed1",
+      "maxLendableImpactFactorForWithdrawals": "0xaabc0fbaf18db25648fee631c4ed2517dd0441bda5c364f31c021fc0d69f7e34",
+      "maxLendableImpactUsd": "0x1583168790a4d36c333daa89d68788c041ea06b9d22f8175f90f241efee55e71",
+      "lentPositionImpactPoolAmount": "0x0e13f064d811c29ca1726ac1b6088563060aeb7e1dfe8b4dbf01b596621e16c5",
       "minCollateralFactor": "0xc887506d87b14983ab7ed186f9178fed3a134abbbe8245a13be07e42e313249e",
+      "minCollateralFactorForLiquidation": "0x306a88af5ce2a5f6da2d23fa1fc4da931f660d33ff5b01adb996552ee7a1d8bf",
       "minCollateralFactorForOpenInterestLong": "0x974698c39aecd68284a0766fb070354eb0cc788557c000717eb1187a717a465e",
       "minCollateralFactorForOpenInterestShort": "0x2cbcfa8219414a67ac30cbf47e0c87e3f98fa566922e42b7109f5148feb792a0",
       "positionImpactExponentFactor": "0x8799f37db27fe4c64571774da8d11bb61b5a5b914a054aa230e26e58f694148e",
-      "swapFeeFactorForPositiveImpact": "0x6141d666bb9b2a68a9749663d3c3dab876615cb1c1c19cd40b04bc1c90e89109",
-      "swapFeeFactorForNegativeImpact": "0x154777b0009efb8b45f129e93dd06b79d93a034e74db99ee4c7f53fd6bb1064c",
+      "swapFeeFactorForBalanceWasImproved": "0x6141d666bb9b2a68a9749663d3c3dab876615cb1c1c19cd40b04bc1c90e89109",
+      "swapFeeFactorForBalanceWasNotImproved": "0x154777b0009efb8b45f129e93dd06b79d93a034e74db99ee4c7f53fd6bb1064c",
+      "atomicSwapFeeFactor": "0x896ab2b294e8a2d39a9c6be1b2d256a79d7f6b414e42c5e79f5d364db730dc8b",
       "swapImpactFactorPositive": "0x461e2c7445b7c5765c40de6c216908f8dae1dd7515416d2b39d09c59c9410f9c",
       "swapImpactFactorNegative": "0x844b935996c3559c7315004f459033cb6b4daba806b740a81bd8e9bee4d5f47a",
       "swapImpactExponentFactor": "0x1cef00edb03ed714041d7451cc3bd97b04dc3b8f965505a3e78e9f1a5dea6179",
@@ -1280,19 +1600,25 @@
       "maxFundingFactorPerSecond": "0xa86190d0831a71843286266b26bb09d290e7274457d4c6884dcc1ce7af8b75d5",
       "maxPnlFactorForTradersLong": "0xae6a9602886e00e8f9cc9fae500cea6315539ce497876e3d8c68a7c2bce8ff83",
       "maxPnlFactorForTradersShort": "0x7e0d5ffba6ead92454e3b86bdf9a7e5f05b90fe3f4191b817c4f1a5a88f31e19",
-      "positionFeeFactorForPositiveImpact": "0xb12a559764e28d5b6e2828f2dafd4ec774c41481df3dc7a8b1d01051025775af",
-      "positionFeeFactorForNegativeImpact": "0xe6787e7aff99034a0a90b9df8364057d42c7f114ef414a94b798cf7d9fb3499b",
+      "positionFeeFactorForBalanceWasImproved": "0xb12a559764e28d5b6e2828f2dafd4ec774c41481df3dc7a8b1d01051025775af",
+      "positionFeeFactorForBalanceWasNotImproved": "0xe6787e7aff99034a0a90b9df8364057d42c7f114ef414a94b798cf7d9fb3499b",
       "positionImpactFactorPositive": "0x6f738a6e9c2976fa3398260c2678ceeebbc372c8740bca3d419def2cdd72d7fe",
       "positionImpactFactorNegative": "0x042414808b145a04357da24216c441d4cb1866192323c65253d7d5d7ae5b16e6",
       "maxPositionImpactFactorPositive": "0x417f05c74dda8045134d4ea5faa8558b54bd35e13417dad8988bac462d511986",
       "maxPositionImpactFactorNegative": "0x8ca16c9c73994cd267eff2951818721a251b0c048efd9f87e97dee49a7b4960d",
       "maxPositionImpactFactorForLiquidations": "0x0d1c038bdc72efeda626efe5e534102d4a9b352b46a778ae44aca00da277fde1",
+      "maxLendableImpactFactor": "0xe673faf468e6416b8c56ac71f23fdd068a2338d118d006721482a7ea1dda1206",
+      "maxLendableImpactFactorForWithdrawals": "0xe73a020ca1218e9283b00c7c0667640c24988729c31c72ae05f74ab52aff1bbb",
+      "maxLendableImpactUsd": "0xe8b581b93595f7d71c84dabb879ee50a8ef943c07755fbe6ed96a27d9419b169",
+      "lentPositionImpactPoolAmount": "0x0c3be9a030ff7b1218f36ddd6d2be296a046c03a579df55a6d1f9ab9431299b6",
       "minCollateralFactor": "0x306c4d11774ba8acc5857bc2b9eed4e6f4eaebd78ca19cc36c9e7543ee4e2baa",
+      "minCollateralFactorForLiquidation": "0xf999a6e4677e32df80732fac308066abf0b941fa1b8de71fa6ca65c62766fe19",
       "minCollateralFactorForOpenInterestLong": "0x1a91d60f924b7371fe96dc19aec25c04a3c778b64b02909898c8ba552f8f8d74",
       "minCollateralFactorForOpenInterestShort": "0x64a53510be4bbae7a856bad32346bdf81c3f6d8895c5cdb6d9b4c3061c7113d3",
       "positionImpactExponentFactor": "0x8ccbfcefe45e6333409c1703e2b19a344996c8805280f1a49c6922a10509a67e",
-      "swapFeeFactorForPositiveImpact": "0x1590ee2481a3040cb0d23eb50d8e5f03df05af2a0adb6647b64d9dd18409e4bf",
-      "swapFeeFactorForNegativeImpact": "0x9ef8535355d5ea75d57b8faa5093312c6a291fecf76f923fd04bbd8cf9461f0a",
+      "swapFeeFactorForBalanceWasImproved": "0x1590ee2481a3040cb0d23eb50d8e5f03df05af2a0adb6647b64d9dd18409e4bf",
+      "swapFeeFactorForBalanceWasNotImproved": "0x9ef8535355d5ea75d57b8faa5093312c6a291fecf76f923fd04bbd8cf9461f0a",
+      "atomicSwapFeeFactor": "0xc3292e50be21e9087d06b18f3b871f63e311e17c7d06deacbb676bbe7ef65890",
       "swapImpactFactorPositive": "0x3ce367a95fad78d15965cfa917ca6137f707a3d77022ba1f643a316323402f4b",
       "swapImpactFactorNegative": "0x4cbf632cb133bbcc438fd421654e7dae88fa165ba171fd6e6044c505eb728017",
       "swapImpactExponentFactor": "0xe7d7639aef796eab87ec1ac108ef4ae5de1a5f867b9624bde199f46297b78a32",
@@ -1330,19 +1656,25 @@
       "maxFundingFactorPerSecond": "0xa5f8602de310b7ef0eac8c0b938744a9c6b0127e0d806d7f8f0b58b6318614d5",
       "maxPnlFactorForTradersLong": "0x10c8eb29dea6e099e25573dccff9650d218c309953f6ba9b03690e8cfdd66b5b",
       "maxPnlFactorForTradersShort": "0xeca0d151e83f98ef5e12410b0a2d223e29cc7d97f228f9d63edb1a90d9467696",
-      "positionFeeFactorForPositiveImpact": "0x10d2a12dc0ae3d3ebf4846a7fbe21f4c46517ee74bdd7c6fd72417e75ec1caaf",
-      "positionFeeFactorForNegativeImpact": "0x611c3bc2e992fc865409dc0b81a02796f19cf207d98a8636ba04889156767b3c",
+      "positionFeeFactorForBalanceWasImproved": "0x10d2a12dc0ae3d3ebf4846a7fbe21f4c46517ee74bdd7c6fd72417e75ec1caaf",
+      "positionFeeFactorForBalanceWasNotImproved": "0x611c3bc2e992fc865409dc0b81a02796f19cf207d98a8636ba04889156767b3c",
       "positionImpactFactorPositive": "0xe26bfc6ea0695527daaf43790b252c6cd520b6f041d52b89fa1765e332b0a2ba",
       "positionImpactFactorNegative": "0x29078683fd16217f167c57ce10332c45b25a7e2a42b7e317f4993cdd182ee4f0",
       "maxPositionImpactFactorPositive": "0x92c555de2df6a801fca90169a37445fa9e1b6127ad2b24e9aae09e610daa64d8",
       "maxPositionImpactFactorNegative": "0x836e6ed579eef0ce940ce76d025708ed4872eb6897ffdbecbaeba7d3a54e5a90",
       "maxPositionImpactFactorForLiquidations": "0x52fb95366a88cf85b51d86af2a6aaca9b2a742d85554af7cbe67a75a2a683f1c",
+      "maxLendableImpactFactor": "0x50bd4bfb7307a385bd505be86ebdd20719b391325c8092ec079e46e0b391d514",
+      "maxLendableImpactFactorForWithdrawals": "0xdd7e3e401c46e60998a084f097c1db69203022f848eb4c0b2699bb9925b7572b",
+      "maxLendableImpactUsd": "0x5fbd94369fc89ae1535ac8c26187fd9566d8bff81ec7c12e8bb0a71480eaa81a",
+      "lentPositionImpactPoolAmount": "0xf4dc83edc0a9cbf135ec125b0a2260e5459b43740e5ced199393dc08094fa0e2",
       "minCollateralFactor": "0xf222dcd515762a01b5dcd95d0d7bf6220adebaeeca37241b2334aec31858d008",
+      "minCollateralFactorForLiquidation": "0x9a80dc36f347f59c5ebe196f2c8ec5e2915f9143d378ee582a5421ce121bb69e",
       "minCollateralFactorForOpenInterestLong": "0x159b5efb14ba5fdf82eb9483ce36a5cc511603ddc0851867d2f62e061a1eb5a5",
       "minCollateralFactorForOpenInterestShort": "0x5ea79f8f1091195b3a4b2e7b906f73a855a4677d85a563c73c636da18a4c3b61",
       "positionImpactExponentFactor": "0x5de08cfc1c45dc70944717fb92318d5f3f66c26fc83ad52ac82277eb036d81db",
-      "swapFeeFactorForPositiveImpact": "0x8039a612505e93d3b3b411b3e667f13e1a54b0d830e9dcc16cb41d838b85c6bd",
-      "swapFeeFactorForNegativeImpact": "0x07bcac70080ce14495a72e4e38fcbf3cf15913013379a12d4cab5ac6c741851d",
+      "swapFeeFactorForBalanceWasImproved": "0x8039a612505e93d3b3b411b3e667f13e1a54b0d830e9dcc16cb41d838b85c6bd",
+      "swapFeeFactorForBalanceWasNotImproved": "0x07bcac70080ce14495a72e4e38fcbf3cf15913013379a12d4cab5ac6c741851d",
+      "atomicSwapFeeFactor": "0xe3c7dc581d6b949ca503f256de43caf8a5615491c7b5750fd52d054c50989417",
       "swapImpactFactorPositive": "0x16e0ad50beb175b5eb950fb44fac610b3289a7a74fe8a788d974cf667cb024a9",
       "swapImpactFactorNegative": "0xf4d68d4587e30f6e4d7a9ee6eb78d8d4c1c05ace6f9bafd291483c9ce9eb1bb7",
       "swapImpactExponentFactor": "0x97d1c1c0f5ad236f5f1edac5fdf95bce3537739693abc65a09ed0a3dcf34498d",
@@ -1380,19 +1712,25 @@
       "maxFundingFactorPerSecond": "0x33a776a9e8fdf2baa5a32b016dd8e6a333cf2e461554870d0c06cfc1f15bce5a",
       "maxPnlFactorForTradersLong": "0x7b53f5192016caedcfe36d2c9283142ab453a038f9f58d3b6956a3d4e5b9723b",
       "maxPnlFactorForTradersShort": "0x2fb89797b374a76143438b2cec9ffb464bfc30d36738dcd9fed215190b5d6323",
-      "positionFeeFactorForPositiveImpact": "0xf3bf654aaa18bed4473e41fbf07fda8631a7c410c2e3f63a85158e40cc7d9b7a",
-      "positionFeeFactorForNegativeImpact": "0xe348ca82ff412191d0856eab30d838889649105a16951e03680ecbc33572fba5",
+      "positionFeeFactorForBalanceWasImproved": "0xf3bf654aaa18bed4473e41fbf07fda8631a7c410c2e3f63a85158e40cc7d9b7a",
+      "positionFeeFactorForBalanceWasNotImproved": "0xe348ca82ff412191d0856eab30d838889649105a16951e03680ecbc33572fba5",
       "positionImpactFactorPositive": "0x1db5aaa72739243e2cd7cbb59e13526bb779b6513f648c3be647a3945ee0b6ff",
       "positionImpactFactorNegative": "0x9f4b1c96ad48b04dcb2e090029b07fa05c74137e2b3264b5b31b659c69c194de",
       "maxPositionImpactFactorPositive": "0x054407c473f235dea7a7f175def0de1c030b1617f399a34315331710b5dc0c72",
       "maxPositionImpactFactorNegative": "0x7a7bd10cbcf566e8e80449dbcb0b9461c37aa3ca35e289a7f2777b1cf04b2a68",
       "maxPositionImpactFactorForLiquidations": "0x5c8317b7e68038721e2b6020e3d99c388914cf6acf570fde1ceacc34bc2abef4",
+      "maxLendableImpactFactor": "0x0eafdffb45f992eecaba504f59d5b5274c6097c4755e607272d17d0b7526da97",
+      "maxLendableImpactFactorForWithdrawals": "0x7b9e2471dc5e5527de90ac527bcb204e159a4e800416d8f50b202df161e71e1e",
+      "maxLendableImpactUsd": "0x5e1be6e2cd707a9073c0528e7bb5f4878fdae6b4fdaae7b22e7757c70ba1d508",
+      "lentPositionImpactPoolAmount": "0x314032f20c89ed75de8135a3261e61d7461883f9743ee1a68c8b38f18e256250",
       "minCollateralFactor": "0x37c9327170636d2644b4aef9428093a4b840396c017062d69214990437f11295",
+      "minCollateralFactorForLiquidation": "0x6427bd32e101cea4a95641d89d9c833ff5045eec210d362d5a271894653c6bfb",
       "minCollateralFactorForOpenInterestLong": "0x3037baca9542bb9bf19e795a3ea8588f62fd7aa7f391835394eb39113b24f199",
       "minCollateralFactorForOpenInterestShort": "0xdb99a450e0b3214c2eac3f7523de613aab2352d659dae70c2a748d158dcb92f7",
       "positionImpactExponentFactor": "0x24d3d26a6be3949ac749df173c37d80cf593084309fc6214c3f2b987b8b5bf3a",
-      "swapFeeFactorForPositiveImpact": "0xea7cc342e21f8f0d3929c81522fc565f43b539e5cdcd8b06e27fd147f5ea8122",
-      "swapFeeFactorForNegativeImpact": "0x293b0ec6f9d1dfd04f394f6a2ac44c3c5dc6390cc10d3cdf91808e413ca6cad7",
+      "swapFeeFactorForBalanceWasImproved": "0xea7cc342e21f8f0d3929c81522fc565f43b539e5cdcd8b06e27fd147f5ea8122",
+      "swapFeeFactorForBalanceWasNotImproved": "0x293b0ec6f9d1dfd04f394f6a2ac44c3c5dc6390cc10d3cdf91808e413ca6cad7",
+      "atomicSwapFeeFactor": "0x4b45a7b2d6be1622e1f2aa8ea096a9dc8b58452956fac9b4ab17829876da0f17",
       "swapImpactFactorPositive": "0x43815a7794b4f7f293baf4954ce22899083f202f8bacb7c6318febdd200c8647",
       "swapImpactFactorNegative": "0x1b4e062640c62d2ea26baac2c515da1c438db5cdde51ce3b7e87c389c4588648",
       "swapImpactExponentFactor": "0xec66bc2197cd85704c758f3f88d82b4e96952086421a0744e4e4bee8043d6b17",
@@ -1430,19 +1768,25 @@
       "maxFundingFactorPerSecond": "0xa9ef8b74a174c9e223b7d703e4ecd5529724a3ed601cb05ad3972d69abd47b9e",
       "maxPnlFactorForTradersLong": "0x5a378457c164946c52e07daa0bd710b55462b6c1166b1f9db12dc0cf90f0b09d",
       "maxPnlFactorForTradersShort": "0xfa1252240c112896c95967a9f25716248b91106fa011dc48460dc122f7a01a8f",
-      "positionFeeFactorForPositiveImpact": "0x7ad381a480212f1a2cd99216ab2fd20d2d3278de35a579524373361be43b638b",
-      "positionFeeFactorForNegativeImpact": "0x7d17a4ff2eaec3da855d96f23a19e78ee118553b7ec5e877fd6ba2ecdeb70a38",
+      "positionFeeFactorForBalanceWasImproved": "0x7ad381a480212f1a2cd99216ab2fd20d2d3278de35a579524373361be43b638b",
+      "positionFeeFactorForBalanceWasNotImproved": "0x7d17a4ff2eaec3da855d96f23a19e78ee118553b7ec5e877fd6ba2ecdeb70a38",
       "positionImpactFactorPositive": "0xc762ad5da3a0eff95f66232719c3912fc2f2ac454f86df09fcee9ccc1125906e",
       "positionImpactFactorNegative": "0xdeaa0bb6c0dd14655f2b47aa4e7fbd84a48891105499b6d39ccac6773de55908",
       "maxPositionImpactFactorPositive": "0x5d881863abefde1acac40bd9a69e9985a6946e409beee4bc2b1c250afcac9c0f",
       "maxPositionImpactFactorNegative": "0x4d5ed30598d7ad750ac5cbb67c1cc9f880103986f5778a65104f0c0a2feb5b0e",
       "maxPositionImpactFactorForLiquidations": "0x39c2c99bcc2c851bd93b362e0d6854420c9d73c24c2a64655fe575897284a5af",
+      "maxLendableImpactFactor": "0xafebff4ab40589e68a893108e1eca470ee021f6cf38fac40a564a47689a60145",
+      "maxLendableImpactFactorForWithdrawals": "0xe44b633524783518c74f5a088a5934399ae847c0dbc9d804dd6f1e2b0cca9771",
+      "maxLendableImpactUsd": "0x821fde56a37c89cb5a9277f0897836a1cae8b3a61c46528261926617d51fdc25",
+      "lentPositionImpactPoolAmount": "0xf145257db0baa708476a01d3fbbcc2016a88081a4083d76641ec44a11cefbfbd",
       "minCollateralFactor": "0x26cf36b642d845e4537b703e1988ec4f179852681fa1da1da83f0c4f07aaa277",
+      "minCollateralFactorForLiquidation": "0x6af824714604d471f55475449bcebc7aa7b3aca42f27ceba6c7d803506af84c3",
       "minCollateralFactorForOpenInterestLong": "0x093de38ced41ca0b1ed4b1125b61d2b919957df4784cfd03a2bec7169efe69d4",
       "minCollateralFactorForOpenInterestShort": "0x26036e46776ea0eb1742bf11074ac5e347c4a16656bffb61ea87249d85908f71",
       "positionImpactExponentFactor": "0x5c860ae9aabebb3cbd58b3aef502c6e8d7de7ee9352d4287a53912877b065f6d",
-      "swapFeeFactorForPositiveImpact": "0x83f7fd8f66ad11eaec868ce47d0d0f0541d3c5b97db7510c6a5221f3d7742049",
-      "swapFeeFactorForNegativeImpact": "0xd55ebff53d86bd23cf89b366ce663d0666ff69f0b57bca785f06f9a8241278b7",
+      "swapFeeFactorForBalanceWasImproved": "0x83f7fd8f66ad11eaec868ce47d0d0f0541d3c5b97db7510c6a5221f3d7742049",
+      "swapFeeFactorForBalanceWasNotImproved": "0xd55ebff53d86bd23cf89b366ce663d0666ff69f0b57bca785f06f9a8241278b7",
+      "atomicSwapFeeFactor": "0x2c55e0139a71c101d54a4a5c27d08df124018ba5e5a018b86f0d305d6d122b65",
       "swapImpactFactorPositive": "0x554aa25ead86224ab91bef3c3666a62e090f2ff373660d1ad93b5bce40d86280",
       "swapImpactFactorNegative": "0xa635d2782a0a1a49d0f0109507ad9f758eb8d886465a59b2a6aa4a0d4402b411",
       "swapImpactExponentFactor": "0x99ae407ca0909a5ede62cf8e5e0cd01c88b10c8bcc977c6be4c60124609ec505",
@@ -1480,19 +1824,25 @@
       "maxFundingFactorPerSecond": "0xaea060ad5c01b6855a8ba41c879877ad9e7c0d89d22c24b2d808dfca154c3192",
       "maxPnlFactorForTradersLong": "0x0cca8f43022acf6faf517d0057db8de6c50145c84c4c178375f32c525504e162",
       "maxPnlFactorForTradersShort": "0xa5db5e8014020874226641a8db0eb55033824863e8c3218a983672ff9962d866",
-      "positionFeeFactorForPositiveImpact": "0x4a1f770da272d53d04cf31e8c4a04ef9fe459681c1ec5278abb1fab151d7ec92",
-      "positionFeeFactorForNegativeImpact": "0x8f7d93c1516186baf16daaaed34af81384d055695f0fc0c143cbee3bbd8e73ec",
+      "positionFeeFactorForBalanceWasImproved": "0x4a1f770da272d53d04cf31e8c4a04ef9fe459681c1ec5278abb1fab151d7ec92",
+      "positionFeeFactorForBalanceWasNotImproved": "0x8f7d93c1516186baf16daaaed34af81384d055695f0fc0c143cbee3bbd8e73ec",
       "positionImpactFactorPositive": "0xe30ca65f7576e63a00ad697a68075c47c69ba27e489fafd76ff29fb752b6a091",
       "positionImpactFactorNegative": "0xb375b763eff4f0763ada21285731c4887d417d372dd7464b74a29c8bc3fdf350",
       "maxPositionImpactFactorPositive": "0xfe35d1068a4bf727664f3683964a8585efa69f42b3fa05eb9bf95678e5fd0e9e",
       "maxPositionImpactFactorNegative": "0x8559fb313fda3675ef298adde1583c8eed97bc729c3f1797b4238c7e0b169ec8",
       "maxPositionImpactFactorForLiquidations": "0xf224c1634c4a4f1e74b27f1f86b940b3848610a8742fe6e05a979282184a8320",
+      "maxLendableImpactFactor": "0x4cb347550b736035c5556779419d724c8c41b3e914a948e225c03ae1f7b99715",
+      "maxLendableImpactFactorForWithdrawals": "0x96916ca557ff5867c9842839682a863984bb584c9cc3b81e67d5c89d65791417",
+      "maxLendableImpactUsd": "0x90c4b4a43e31fb0fda3a72f64fe6f592493a7ec4ce8713ddb9a904bde23095ba",
+      "lentPositionImpactPoolAmount": "0x6c5cfd677c3223f1e3aa3be0c4392eb8103e0107434cba35aca561e4061b3764",
       "minCollateralFactor": "0x9796d33d6fd886b0f785e0e524e2b25f1e7c291b682ece47fe5ae62611e448cc",
+      "minCollateralFactorForLiquidation": "0x3393a73bc28e5c25db9ac6cb5d316468446a57bc0eab962823b7b1e58e0205ed",
       "minCollateralFactorForOpenInterestLong": "0x1677f8025e1e4279b5a1db64264a79835c58c80818191018a56890aa23e9416d",
       "minCollateralFactorForOpenInterestShort": "0xc62d3cca1c3f6cf4e2770239bc3db387c22a0874a46b28bd8d86bea5d0fd882b",
       "positionImpactExponentFactor": "0x8d37091394262b6981015a549871fe3c908943afaa10321a82aabd7fdca918d3",
-      "swapFeeFactorForPositiveImpact": "0x5cb96b68635c2011b20c1a103f94a8fae1fd3a1a31f929db520a540f3521a224",
-      "swapFeeFactorForNegativeImpact": "0x3af0747e232c7341bb056cedc52a023be289515396288b8bea2867bd132efe38",
+      "swapFeeFactorForBalanceWasImproved": "0x5cb96b68635c2011b20c1a103f94a8fae1fd3a1a31f929db520a540f3521a224",
+      "swapFeeFactorForBalanceWasNotImproved": "0x3af0747e232c7341bb056cedc52a023be289515396288b8bea2867bd132efe38",
+      "atomicSwapFeeFactor": "0xdc378c54100ad2d83cfd42eb62e50eca23df736d38d7ebaf9d4567b5f9905a70",
       "swapImpactFactorPositive": "0x7c0dcaa54ea81581befa553bf6ad5d1ed18aa7ad80bd7b80fcd6ef9b1615bd43",
       "swapImpactFactorNegative": "0xd9536a29966ec9255729ded57ca8f7dddb0c0b9af89354db014171689595efc0",
       "swapImpactExponentFactor": "0xc0af564625767bd4c8d5c3450753dfc573b1e93682d4989afd2f90ef459922e1",
@@ -1530,19 +1880,25 @@
       "maxFundingFactorPerSecond": "0x34406dae1f399278c36439e30610303e8881eb0c1eb42c6865deeba2e1ca66a8",
       "maxPnlFactorForTradersLong": "0x91f778de8f64270aac0b40bb44479cf9a7d2aefb2acabefea02adfa91b4ac80b",
       "maxPnlFactorForTradersShort": "0x795d4f86e291bed384ac47280b3905bab11d4b622389f9abd295265a4cb3b9bc",
-      "positionFeeFactorForPositiveImpact": "0xf140e4b048ebb70318a767afaf2861c9824c804046133fe53a8c28fd95abc1ac",
-      "positionFeeFactorForNegativeImpact": "0xae6cc55956556a8a91c679697b2fdc574ba1119a77475d516a526734dff64e36",
+      "positionFeeFactorForBalanceWasImproved": "0xf140e4b048ebb70318a767afaf2861c9824c804046133fe53a8c28fd95abc1ac",
+      "positionFeeFactorForBalanceWasNotImproved": "0xae6cc55956556a8a91c679697b2fdc574ba1119a77475d516a526734dff64e36",
       "positionImpactFactorPositive": "0xb5896aa101e635b6dd6b537b9cc24882580b95e8c282a544938c78a62ebc3185",
       "positionImpactFactorNegative": "0x673862b9af47f7a839c274fe6743e7836f5ccdd9e426777a733b88fa9e38b2e9",
       "maxPositionImpactFactorPositive": "0x83cfcad7830ac109e2d615c46c7061e128c7ecedbaa7b2eaa0f9c37fc1685633",
       "maxPositionImpactFactorNegative": "0xdb820abf9ef22cfc064719c1e3f14e54fe667051dd75f879853d5b9181d866ba",
       "maxPositionImpactFactorForLiquidations": "0x287b8c27f13d7884cb5147e3748649d0fa2072aad502b1a578d4927b4d908e98",
+      "maxLendableImpactFactor": "0xa384ae723aebe010b544d776903a19dbdf526c96a6269378389805872b13077e",
+      "maxLendableImpactFactorForWithdrawals": "0xc42aa701db13972c5846ace00f090eca1caec9e2fe83498a10ca01c637a48878",
+      "maxLendableImpactUsd": "0xb082c68f34392068dec1fd23f594d0e9232e6a4cafd65ace1fff7de68254942a",
+      "lentPositionImpactPoolAmount": "0x165c2b3fd05d13c4760d6604eb6121b5e2903cc7b201e08a8cc38e3bf2430638",
       "minCollateralFactor": "0xdfe35a4a7d6fcea0730ea6a1d1296f1e1186dcdab4fec5c377a43ce80f26992b",
+      "minCollateralFactorForLiquidation": "0x70b5c091c0658a67df16c7e57093a054c69c4e6d02e411141176276f33a3517f",
       "minCollateralFactorForOpenInterestLong": "0x28e3fb3d6672b82c0d07651dc08f2dc5b1a60a464edcc11c4ea8b5e0421cb3e7",
       "minCollateralFactorForOpenInterestShort": "0x85d241676b23e38f5edd65fff0fbaf35ab45a4c062d5971bd99d31a6cff3be9a",
       "positionImpactExponentFactor": "0x4fcc2ef0a8e8cbd0a35c3560320662a39b102617306b41d31e0db602ccbdca2e",
-      "swapFeeFactorForPositiveImpact": "0x762f094bbedc499cfb8ab344894a1337fa2827d9ca29c1652ef501a23a5796de",
-      "swapFeeFactorForNegativeImpact": "0xb98d0057d669fde48bf1bfc5fc807f6783d140cce36c5c796f0c9d1f957924c8",
+      "swapFeeFactorForBalanceWasImproved": "0x762f094bbedc499cfb8ab344894a1337fa2827d9ca29c1652ef501a23a5796de",
+      "swapFeeFactorForBalanceWasNotImproved": "0xb98d0057d669fde48bf1bfc5fc807f6783d140cce36c5c796f0c9d1f957924c8",
+      "atomicSwapFeeFactor": "0x31cf5da07077e68eb185b9d1b8716f538cf11fa63e92e22919c55fcc93cae57c",
       "swapImpactFactorPositive": "0x609b62f795290278ccdd73a7134158fd53801275c79a62f4741c967904d3bbd6",
       "swapImpactFactorNegative": "0xd1aa256ef61e9f42f8c1ea56925edaaab20bf4c9c894a1769748459cdc9f1a13",
       "swapImpactExponentFactor": "0x4b108c71c95fe54771a329eb035d3e8270d64ea5b79e3ddeb1bdf9d208a39ad6",
@@ -1580,19 +1936,25 @@
       "maxFundingFactorPerSecond": "0xc8050137da6a9f433046c4b36fbf2bc953dceba773ef1225633240d2d85c0a8d",
       "maxPnlFactorForTradersLong": "0xca07f7c616ab6f9805c6e8073e3b8774cba4deab4083dae0fdc4534f8564b643",
       "maxPnlFactorForTradersShort": "0xa7b778271fee1571b28cb6708c350cabaa3ed6ef606b0cbff46697782a9bd25b",
-      "positionFeeFactorForPositiveImpact": "0xe59160e09d9e46a995adb177032b42fc9903f8c1a9be530e9399f9663268e619",
-      "positionFeeFactorForNegativeImpact": "0x53d747159802d68a32d22fc72977cd9444145e25509d61bbb7bae73a62b076fd",
+      "positionFeeFactorForBalanceWasImproved": "0xe59160e09d9e46a995adb177032b42fc9903f8c1a9be530e9399f9663268e619",
+      "positionFeeFactorForBalanceWasNotImproved": "0x53d747159802d68a32d22fc72977cd9444145e25509d61bbb7bae73a62b076fd",
       "positionImpactFactorPositive": "0x855cd8b64b05e4e41158e5a1b01a07c030cf28d5023707edf00319f7b34acc35",
       "positionImpactFactorNegative": "0x2300b73380f1ea8b3fcc88f736adbcc7196d4e5cb58d48e6aa23fdeb13056564",
       "maxPositionImpactFactorPositive": "0xed918a7f0b5755162e808591716e05d3b487c7039d952e15ac9acd2a92c961c6",
       "maxPositionImpactFactorNegative": "0x4e865b46729b1650053cd17db3a4367ab0184d8d12518ac0a29217034b6c2950",
       "maxPositionImpactFactorForLiquidations": "0xa9251e003d2653e3c04825e915d3cc179577d520b90c0214fd4f656c94ea579f",
+      "maxLendableImpactFactor": "0xf44d56ce7e139490f7b7a4310497c507fcd82e006e6b7b93f2de4ee91278b911",
+      "maxLendableImpactFactorForWithdrawals": "0x229e5e1def9c9266dd5c3e7d22f10393319821c27fe674770002dfdb9dd30c3a",
+      "maxLendableImpactUsd": "0x476dabd1519700890e85a295007d0980df5d982e1e43daa18ebd3fdf91b32a5d",
+      "lentPositionImpactPoolAmount": "0x6df11507fb2833373189cd5b17663ad050e5e845540f143e3d69bedcbc2a89fa",
       "minCollateralFactor": "0x71a615ceb63b3067aa53360b743986465151e56e727f6963baeb6f4a25483e6f",
+      "minCollateralFactorForLiquidation": "0xb0d9ffa1e7e99f2fcef00b4b23323d9b2d060bab7c552c2e7e56c32a638309e7",
       "minCollateralFactorForOpenInterestLong": "0x5b602b41a9133139c01e6d0627ad253da782dfa70d615dea06e636974c0d2190",
       "minCollateralFactorForOpenInterestShort": "0xb184fd747edc421383cd0ef45d3eca4c4551ef1be063daa0f93b350e0ca63299",
       "positionImpactExponentFactor": "0x56936ed105ce2e078a8a02d6d884ec7ca0971f6e5bb24cd79e1a74c33be26c37",
-      "swapFeeFactorForPositiveImpact": "0x0c2a02cb5d4ca72eb638bbc23178fbd9ef50fcad6ed4563b43600dbdc7f69874",
-      "swapFeeFactorForNegativeImpact": "0x6ad012eb794a17a8ffcf7423e99c003381fe99e2f8a45ee381645195a360a090",
+      "swapFeeFactorForBalanceWasImproved": "0x0c2a02cb5d4ca72eb638bbc23178fbd9ef50fcad6ed4563b43600dbdc7f69874",
+      "swapFeeFactorForBalanceWasNotImproved": "0x6ad012eb794a17a8ffcf7423e99c003381fe99e2f8a45ee381645195a360a090",
+      "atomicSwapFeeFactor": "0xd90a7caf21cfec07cbb77bda9745cb5a367f9f089333ca34ea7124a53d1b611b",
       "swapImpactFactorPositive": "0xf173e2084eda5671a0f4ea671bd7f0837776cdeda6178d17d5926537f468c7c3",
       "swapImpactFactorNegative": "0xb792682cfb2272eee71294b3bed2d420d96f3b838650917f08eeaf20c6861eb6",
       "swapImpactExponentFactor": "0x79ed42232c53bf8b095cbc2384a5205b686c5a13b1b9c7ae12b224621296f95f",
@@ -1630,19 +1992,25 @@
       "maxFundingFactorPerSecond": "0xc73d22835ccf44694188b7d84e65857850e9346bed1c61a7c0a44d52fa26b2b3",
       "maxPnlFactorForTradersLong": "0x3435ce1dc9ba5d1ad05c18a88bf1506c3e19fd9e5112f612b1a6c973c8ea3fde",
       "maxPnlFactorForTradersShort": "0xf8400e70e5699ced498165dbcd4f673a2ceac4a31bbcb00a04a51ac0ee607390",
-      "positionFeeFactorForPositiveImpact": "0x1ff672b4479b096ec040e2f446a621d71be58dbbbe1f19af6cba6b4f719c9e5c",
-      "positionFeeFactorForNegativeImpact": "0x9f7bbc000233b9646d97ae3bb79a70b2ef9ffc4b4dad350a64f0662d8a3e0773",
+      "positionFeeFactorForBalanceWasImproved": "0x1ff672b4479b096ec040e2f446a621d71be58dbbbe1f19af6cba6b4f719c9e5c",
+      "positionFeeFactorForBalanceWasNotImproved": "0x9f7bbc000233b9646d97ae3bb79a70b2ef9ffc4b4dad350a64f0662d8a3e0773",
       "positionImpactFactorPositive": "0x592471e23e8877fed51e465f6b98a83185d15c69346222166e9e70112a399da6",
       "positionImpactFactorNegative": "0x172259f1b039320c8dbe0337fc3c4669009ea3e33fbed0f1f72de64834abefc1",
       "maxPositionImpactFactorPositive": "0x7ad9019e284cfbcafb6a562e8c38d38afbf8ceb039fabbda946ab2c4016f27f7",
       "maxPositionImpactFactorNegative": "0x7cd82495926051f9036de5ae9a571872375dba1755c20cb061227c8c7cfe1396",
       "maxPositionImpactFactorForLiquidations": "0x990890ecc20200de9a1bd87598b95848787445930857aef49c72aab7ba037e97",
+      "maxLendableImpactFactor": "0xc20b6cbf996644c2edfbc13175a89c561b9a6eede297cf186e514e71d47fedc9",
+      "maxLendableImpactFactorForWithdrawals": "0xf4d8ec3322874c694e3e3a263efee74d7d2d26289153ea6359ffa0a99b2d79fa",
+      "maxLendableImpactUsd": "0x07ec6051ce67255d5560112358474ea5d701dfbe4a2e70245dbe06b842e552f2",
+      "lentPositionImpactPoolAmount": "0x65341f28ad76202a7d9e80d060cebb19ace428b91df9a33bf46d81fee7d52d5e",
       "minCollateralFactor": "0xc3e99d30df1bb7237cf5b6a371f53440e558f68381ad34cd7a39c8083f6835f3",
+      "minCollateralFactorForLiquidation": "0x2a0767e62c001f898fd730979111f1910f5191d8fad78cce263bdf4caa573131",
       "minCollateralFactorForOpenInterestLong": "0xa9b976f225b7a1d9aa149a1674b712b8da2245e1d36f7e336a96c3794de912cc",
       "minCollateralFactorForOpenInterestShort": "0x67fcd6cd3ab04ad285b2a1bb5393df7d7e368846bc8c2654c872e61cbdadb18d",
       "positionImpactExponentFactor": "0x6fe9d3e57df23a89ed73e33f91d91d31fd23406654cf3de63dedfb6568389941",
-      "swapFeeFactorForPositiveImpact": "0xc1d2acd5c88eedc10e84ea9905b6cee5274b2e01c1325a574170d39a27a28603",
-      "swapFeeFactorForNegativeImpact": "0x9eb334e661c82faf90d0bfabbd8831d8bbfffc2a15d5caf6a53bea1a52a11f2a",
+      "swapFeeFactorForBalanceWasImproved": "0xc1d2acd5c88eedc10e84ea9905b6cee5274b2e01c1325a574170d39a27a28603",
+      "swapFeeFactorForBalanceWasNotImproved": "0x9eb334e661c82faf90d0bfabbd8831d8bbfffc2a15d5caf6a53bea1a52a11f2a",
+      "atomicSwapFeeFactor": "0xa517d70cfd722c6194d5cf52f6f06947406e1a79aa6ee92031a9924894d5c0e0",
       "swapImpactFactorPositive": "0x995b47106472df08b1d99bfcdf5a5c58a22fd505cb0454ba3c65d25836e5e383",
       "swapImpactFactorNegative": "0x6fde49ded6431284fad0ab80a5d2bb9e23bc71bdb6768018feb1d0d92cea86f9",
       "swapImpactExponentFactor": "0xe7230f74591696274ab9b6e56d5f6a7da17e29e6a1e6df2ade2e8e6837d6cb0f",
@@ -1680,19 +2048,25 @@
       "maxFundingFactorPerSecond": "0xbdcdf2207e1ed7bbf132ff481b5821964c764f82b9a0d3710cb1c3e2ebfacab8",
       "maxPnlFactorForTradersLong": "0x1e9639bf478f9c1c6e3f2c86487f1d095e877143acfa2abec4d8e529c16ddfdc",
       "maxPnlFactorForTradersShort": "0x9e2ccf0a5e3d1e61b01dab339e6b8e898fec0c99aa7f3eb9357c92c3a1973226",
-      "positionFeeFactorForPositiveImpact": "0xf07887eec3f30afc0147d9f489b64d03f360068f48998d05a9ccb06187b6be07",
-      "positionFeeFactorForNegativeImpact": "0x0f7f470662d96642b2c2c82cccde4267736d60b558afaf66fbe7ab57ba67cee0",
+      "positionFeeFactorForBalanceWasImproved": "0xf07887eec3f30afc0147d9f489b64d03f360068f48998d05a9ccb06187b6be07",
+      "positionFeeFactorForBalanceWasNotImproved": "0x0f7f470662d96642b2c2c82cccde4267736d60b558afaf66fbe7ab57ba67cee0",
       "positionImpactFactorPositive": "0xb9b5fcedd5c91a9d3c5c40a7a7a065885bd09fcb02181cad7b8c323c373875db",
       "positionImpactFactorNegative": "0x2ad2b91e53b4a3a925e04f8c6d6eab8bbd1e770f8354fe3518d501bb86115c20",
       "maxPositionImpactFactorPositive": "0x19b6035bb9a91088962ca09e26b08a5bf95d95b97c90f4f98ce550cb3e280d23",
       "maxPositionImpactFactorNegative": "0xf37ffd53b8ec3da5920c7e9003549490450e14e5f51725b0629e5dd81b4516a5",
       "maxPositionImpactFactorForLiquidations": "0x768e1e0b9c1bee456110ec4ba84080574645b213cf3551ac1d0146c3fcf1ae78",
+      "maxLendableImpactFactor": "0xdf991481ba292a004f06af191f9ebb817694b2e7b12bfe21dc145fe72b321dd6",
+      "maxLendableImpactFactorForWithdrawals": "0x264dd9fe7edc154fc6ceeb16f6691474d0bbd1150ce2781e268f416b7737040c",
+      "maxLendableImpactUsd": "0x05dac597c6a585a40b6fd862a6ca41af6a8802157b0ff18cd2dd20bd349871e1",
+      "lentPositionImpactPoolAmount": "0x91fe0550c90f1066419d94226afba5d1b82139e28894200654faa3d5ff7f78cb",
       "minCollateralFactor": "0x063c26170386b99ed813e28bbc466b472d58fbc4c565896708a259e15c426026",
+      "minCollateralFactorForLiquidation": "0x184f66f184f238b6d676e9de3e79ca166004e6e66c6ef5e51ee3ead951e11a5d",
       "minCollateralFactorForOpenInterestLong": "0x49b7345940105477f772afb7f563688a99053ca3edca50f043ea031ef1bfa630",
       "minCollateralFactorForOpenInterestShort": "0xafcbb8875e23ba9ea3aea7c817003ce9fd6c9f7e3a7397dc9d355d7030c1c6b9",
       "positionImpactExponentFactor": "0x0e24bdb43d7906365809d9ad11ddd0a0b2d13541544125fd45e8f3e772df585a",
-      "swapFeeFactorForPositiveImpact": "0x48cff709ea1bc1d7c25bbd8a21ec36fb0103a61fea7b2d79e71443214893b878",
-      "swapFeeFactorForNegativeImpact": "0x0404920bfb8782dd3c3ca6bfaf367ed5b12377e0ed5cc20539714b87331a1e35",
+      "swapFeeFactorForBalanceWasImproved": "0x48cff709ea1bc1d7c25bbd8a21ec36fb0103a61fea7b2d79e71443214893b878",
+      "swapFeeFactorForBalanceWasNotImproved": "0x0404920bfb8782dd3c3ca6bfaf367ed5b12377e0ed5cc20539714b87331a1e35",
+      "atomicSwapFeeFactor": "0x9eada6b539ee0375006e15e7e12028007d7ce834db4e1d6624ed151abb77b704",
       "swapImpactFactorPositive": "0x19e448c0928954fcb9a9cabbcf59f3132cc20f890325d3b12a4c7e8cda0fc283",
       "swapImpactFactorNegative": "0x6a0d172623fbdc523516101821ee8863144416e7dd357b967bc205842b287bcf",
       "swapImpactExponentFactor": "0xfeccfd7ff923ae1f8ec494e1b6701a513a7d9c47b645572d323b17a79e0f4bc5",
@@ -1730,19 +2104,25 @@
       "maxFundingFactorPerSecond": "0x231ae23473685d04ef11c3f42aa7abc80bda19111e19f8af81a16565c0d341fc",
       "maxPnlFactorForTradersLong": "0x0e6ee86e4636087f668e859c1446bbdb621df2e89db4c80682767bd8c3f4a2e0",
       "maxPnlFactorForTradersShort": "0x758917d8b45db106bfde22a64cb91efadb0e76531160f2e79daa9da99961bbf2",
-      "positionFeeFactorForPositiveImpact": "0x493d7cf32315ed2576fdb6556232938b3ba4d8fc4c7c129f795f312aaedf1e99",
-      "positionFeeFactorForNegativeImpact": "0x0f09eb3de794846219c162423714c95efcb52241bf3495ba262a8b65a5f15077",
+      "positionFeeFactorForBalanceWasImproved": "0x493d7cf32315ed2576fdb6556232938b3ba4d8fc4c7c129f795f312aaedf1e99",
+      "positionFeeFactorForBalanceWasNotImproved": "0x0f09eb3de794846219c162423714c95efcb52241bf3495ba262a8b65a5f15077",
       "positionImpactFactorPositive": "0x40cff93be7a95242a1789f12175aef67bc23fcc2daeab8753ea2bb08fed670f6",
       "positionImpactFactorNegative": "0xf54c1402f09610ae072a8746966b94006d7c7a1de7eb44f47b7eb29fbaef02ec",
       "maxPositionImpactFactorPositive": "0x786d142f5056003f1e7cd12b82c7954ac0f65b0ddeee41aaab69846be14ba1be",
       "maxPositionImpactFactorNegative": "0xbd154e1d9827e166d594ccb658c4b5babe79cdbcf980e65cd25c661aa87071dd",
       "maxPositionImpactFactorForLiquidations": "0x10f4c29b08a9a5521940a0f61df0361c0a98e01e3be448bfc8a877fed3e66a67",
+      "maxLendableImpactFactor": "0xdff7d16f81d953b578a822edaabed7fb5ff494ea6094374791de6d5cb13773d0",
+      "maxLendableImpactFactorForWithdrawals": "0x4da16212d85f59f9b6708a03c1d3e84f5c264b72ccf4f9c364d6b4ac9f592650",
+      "maxLendableImpactUsd": "0x3eb8c05030e5c10e984bd45d2f23868fc2c4569788bad788ff4b540ee1e65f63",
+      "lentPositionImpactPoolAmount": "0x549e6fd0cf6e4d3901590baf980d1f657669a7cc8893469ddab2cf0679830645",
       "minCollateralFactor": "0xb30c0c9c615ca78136924ffcfd347ccbcfbd07cfbb066331490e171eb1a0a98f",
+      "minCollateralFactorForLiquidation": "0x716807f898c897a453ca05d0f2aa6ddcca6f7db64055b57f81c8e41ea7848fa3",
       "minCollateralFactorForOpenInterestLong": "0xffea67e6c99a9d19d8e0fc2310bfa16b75cdc3634fa319d67a8ddedd5aaaab29",
       "minCollateralFactorForOpenInterestShort": "0x5b380cc5290171b8adb5730fc97eeaa8eb027e04035944e2ee6dd395cc26143f",
       "positionImpactExponentFactor": "0xc883aaf52b8c7712b5e3de31516b99dddb2d07514d55d14f1a8ccde642ac9ffa",
-      "swapFeeFactorForPositiveImpact": "0x54ed8f84ebf52a26785f7383623bfeea82c8602db2cec9305c72de8bb57c9880",
-      "swapFeeFactorForNegativeImpact": "0x69273f9d47ea8b35c92c122a3100ed560284f8f1dd8a75144f5b184e13f2f88a",
+      "swapFeeFactorForBalanceWasImproved": "0x54ed8f84ebf52a26785f7383623bfeea82c8602db2cec9305c72de8bb57c9880",
+      "swapFeeFactorForBalanceWasNotImproved": "0x69273f9d47ea8b35c92c122a3100ed560284f8f1dd8a75144f5b184e13f2f88a",
+      "atomicSwapFeeFactor": "0xb3f675c4eda79a6a026b5204f3291148c4fd7aa5b441661d8c5b218f4f77689a",
       "swapImpactFactorPositive": "0xff7b5bd53c1fed235757a116187bd94c2bfcc5dccf9c79d3afb485782a5a86e8",
       "swapImpactFactorNegative": "0x2349db6b6cb6bc3749db19a55dfa7795476c7bfbb8ee0474769e5537adc48653",
       "swapImpactExponentFactor": "0x88a425e4fb5c7e4b0d858949061fe36dc6212bdee8d5e60a704ff90577560e5e",
@@ -1780,19 +2160,25 @@
       "maxFundingFactorPerSecond": "0x6dd09fe578a0d2f802a55247f16e453c5e0975fe31470136c13f70b57707b47c",
       "maxPnlFactorForTradersLong": "0x8e310d1456f3e834278f007a80efac7013d816f68aca59d6a478e049914ca1f9",
       "maxPnlFactorForTradersShort": "0x1f09ebbd17b78d190303bc6331e789197fe9b781c767d947eefba5904256e90e",
-      "positionFeeFactorForPositiveImpact": "0x5c0d2e79c65ad90be3dfb25475dbecdf197f86d6d288318a16ed53493201ba7c",
-      "positionFeeFactorForNegativeImpact": "0x2705f2437c8e5e3bdfe0663ff0e749ea4d73671b89d2ec3e72626200b6b75c2a",
+      "positionFeeFactorForBalanceWasImproved": "0x5c0d2e79c65ad90be3dfb25475dbecdf197f86d6d288318a16ed53493201ba7c",
+      "positionFeeFactorForBalanceWasNotImproved": "0x2705f2437c8e5e3bdfe0663ff0e749ea4d73671b89d2ec3e72626200b6b75c2a",
       "positionImpactFactorPositive": "0x9f78a2142db60a7d5eab84476a06f69252bb6e21e4b0fce2de8145e5b8765509",
       "positionImpactFactorNegative": "0xf9f25ffd4b9320df0e661297bad0f80ce9ec7d0f2c672f70d8376da8e2bcdfcd",
       "maxPositionImpactFactorPositive": "0x554195019be19dded2deebdf7bba714dedc29cf6194613468be1447e51a8aa7a",
       "maxPositionImpactFactorNegative": "0x0c49426f88135deb7578441b1a06e9cd0458f2610f844a0e06ee61e846cfca66",
       "maxPositionImpactFactorForLiquidations": "0x8d46a381a9692d246102e90ea5b4f53000b4f9407ec0d053e82d3a9ab324cecd",
+      "maxLendableImpactFactor": "0x79f4de524adfca59337487db23a19d9ce11471b5f0acaca903475028621ef792",
+      "maxLendableImpactFactorForWithdrawals": "0x943db693f24a5f67f6db804d36870b3f62823d87ee12f99076a832c8a6814aad",
+      "maxLendableImpactUsd": "0xf4158b055f1f0f76b4688b6f31e847b863fc03b6dae2bf72fb6d6a2c0bd98b5d",
+      "lentPositionImpactPoolAmount": "0xdd99060f77d0633a2efd4afbb52b296a9fd0cc02456405b653b0c1a4c70f5bd0",
       "minCollateralFactor": "0xaf529b6d8c16416ab7e8dea0fee2c88b02a2582e96fd786c3c4aa1b6dd7ab315",
+      "minCollateralFactorForLiquidation": "0x3bb903a46ad84ce28b36d1c2d16311120b9390829b2edb3e8495b0ef53784c01",
       "minCollateralFactorForOpenInterestLong": "0x4d83d368f9ff304adca7477a95605fca7d41bd25fb35ffdba3dc61e7bff2a83b",
       "minCollateralFactorForOpenInterestShort": "0x62e8fc9c6e9f155895f43e9edcf84239b180c4e9737887a8b86545ada24195c0",
       "positionImpactExponentFactor": "0xc2b2c25918334d3d885588d558503500beb43b71d72e9cb05e3e2b86e5bca6e5",
-      "swapFeeFactorForPositiveImpact": "0x4fb41fdd043a724e464d95478c74670b21d3a4ea15c7c2e96269b41df178abc6",
-      "swapFeeFactorForNegativeImpact": "0xfbaf2e48e418c8af4d690859073a3a79040c63c1f4b4cd1c41bae9a5787190ec",
+      "swapFeeFactorForBalanceWasImproved": "0x4fb41fdd043a724e464d95478c74670b21d3a4ea15c7c2e96269b41df178abc6",
+      "swapFeeFactorForBalanceWasNotImproved": "0xfbaf2e48e418c8af4d690859073a3a79040c63c1f4b4cd1c41bae9a5787190ec",
+      "atomicSwapFeeFactor": "0x7fd3db35948558ae1c117892536d43456b15a2bc8f4bdedf385a8de5ba9ae99c",
       "swapImpactFactorPositive": "0x7459c01ebffc50f3aea8bf2ef8ab6cf36d2b2e7398811e79ae65b427c7a4cc45",
       "swapImpactFactorNegative": "0x42f1b2dcd3ff9e25ca0ea9e9ae7ce948a668d2ac2ab3d078020a55ef96400ce5",
       "swapImpactExponentFactor": "0x0836eed83cef2717c66ecd1b31f6d02efa3ddb2278915485d1c5f71f220a1928",
@@ -1830,19 +2216,25 @@
       "maxFundingFactorPerSecond": "0xbb71ae099045fbdabdb856feee219f73d825249c1e141e62e4d6c8311d96850e",
       "maxPnlFactorForTradersLong": "0x2cadfcd4e17d654ada050a5d994209e709d70637f6fea841b8c6dc6fa6b7dda1",
       "maxPnlFactorForTradersShort": "0xa9d11314eb3f8f6667b2ce35bf54ba6007ef811471a03c2812901fc845968cb1",
-      "positionFeeFactorForPositiveImpact": "0x6a8195663337d4db3cb56a6f8702a7aeb0b9a25864376dfa9727b59bf15fa1a0",
-      "positionFeeFactorForNegativeImpact": "0xd732b50d5a27eeeb3c9f13320266b5c0f48a4cf28bd08ee3341e5d17ef6a57a2",
+      "positionFeeFactorForBalanceWasImproved": "0x6a8195663337d4db3cb56a6f8702a7aeb0b9a25864376dfa9727b59bf15fa1a0",
+      "positionFeeFactorForBalanceWasNotImproved": "0xd732b50d5a27eeeb3c9f13320266b5c0f48a4cf28bd08ee3341e5d17ef6a57a2",
       "positionImpactFactorPositive": "0x99695421d96317555b37f315cdf03725584fda95559fb3c6d3adca06c38d23de",
       "positionImpactFactorNegative": "0xc4c5609be5dd555ca967fe416a04fd54438a86edd4f859a111207dfc9ec9ed1e",
       "maxPositionImpactFactorPositive": "0xb24b2729d4b986448d34d3161d59c59e280251393ce4262181a2bf7b70e645a4",
       "maxPositionImpactFactorNegative": "0x093f21e9a0ab2debd31074f3e73a51eae6adb17095a69777b31fbf09ee66794b",
       "maxPositionImpactFactorForLiquidations": "0x6e206fd42772e8fe8a8835b6306583de3b225215da66ffddfff05e9fb823a8e4",
+      "maxLendableImpactFactor": "0x85aa7cfb347e01586d92dca985ea1a0e36b50a35e5c25d595b708f4fe001dd61",
+      "maxLendableImpactFactorForWithdrawals": "0x092a2d629322699c7ec10fde7e4c4064effacd509bb1a530cb300df8f2ec999a",
+      "maxLendableImpactUsd": "0xb3f6e2c9d5a0c535e6114a8218f072fe191dddc6b2197df078e7a4e1ac504fbf",
+      "lentPositionImpactPoolAmount": "0xfe76998dd2b774c72072da177dc87bdaf48671b71fb209e11388fae61aba029f",
       "minCollateralFactor": "0xde8e2683a32db2582bae01bac254fc9ffdf847f49c73f8e40d70831d516a0d63",
+      "minCollateralFactorForLiquidation": "0x1c9315aa7049bbb5d2b8bc32ed041d6e07526fc71e2658d12fc64700ba0a85cc",
       "minCollateralFactorForOpenInterestLong": "0x2352a72b34e744b19d46183f2e17312f8c6d8e6e55ee031745c01426f29f46ec",
       "minCollateralFactorForOpenInterestShort": "0xcb4811e66720bbc8c900831dbe35327485a8fa6aa48d94e28be4ad20e7cfeb05",
       "positionImpactExponentFactor": "0x335695a5a27844054e1229edd8c203f61834fdae52a2761be583d5a8b2d87f5f",
-      "swapFeeFactorForPositiveImpact": "0x0dbec8f5dddc19030eadf103f8d951bb8a586ec11a30f86b8fdf75d565d9ac58",
-      "swapFeeFactorForNegativeImpact": "0x59d63cc7ab7a3dff92097678f7a98e7f1a3cf7a97616b312e871fc39bcf673df",
+      "swapFeeFactorForBalanceWasImproved": "0x0dbec8f5dddc19030eadf103f8d951bb8a586ec11a30f86b8fdf75d565d9ac58",
+      "swapFeeFactorForBalanceWasNotImproved": "0x59d63cc7ab7a3dff92097678f7a98e7f1a3cf7a97616b312e871fc39bcf673df",
+      "atomicSwapFeeFactor": "0x85a84c358cc5dfa7d09a8dabc2856e21e985b799c3eeb59371c15d87a4517059",
       "swapImpactFactorPositive": "0x461a95b066cf6086852497f137b3ea75bd3ffec0796c7d9400c8e5a92037d7cc",
       "swapImpactFactorNegative": "0x499433d197d5305ea41dc1d247e491dd6975ce88fab6979e485537a86d043d6d",
       "swapImpactExponentFactor": "0xe10b5f823fb387f827b6a600f049a9804073a2b410ad2d1789dee8f418388267",
@@ -1880,19 +2272,25 @@
       "maxFundingFactorPerSecond": "0xcf7b665da2d105bcb27781fe68c363db8732c0794e0df27ca9c2bcb907990433",
       "maxPnlFactorForTradersLong": "0x284fd994c8c1361d712bbfe0bef917ebe7486477cda2bb8c3d17ced46552f834",
       "maxPnlFactorForTradersShort": "0x3a1cca2b9c435bad26e1ff77b841a349feaabd02386f9e7b2d58a14b3c69aa1b",
-      "positionFeeFactorForPositiveImpact": "0xe21f27a70af775536902487c5ce88233c67cf0c743555b8490ef2483150513ba",
-      "positionFeeFactorForNegativeImpact": "0xa665c582bf2cd99dc19fb0302fad3c4ed2ed0e7423e288d22ff13816351a93a0",
+      "positionFeeFactorForBalanceWasImproved": "0xe21f27a70af775536902487c5ce88233c67cf0c743555b8490ef2483150513ba",
+      "positionFeeFactorForBalanceWasNotImproved": "0xa665c582bf2cd99dc19fb0302fad3c4ed2ed0e7423e288d22ff13816351a93a0",
       "positionImpactFactorPositive": "0x32beb3676955e674bfa936e22b7e4c93a75a451387f996c4248243cbe1d323c5",
       "positionImpactFactorNegative": "0x0b90f13784d0f8129e986101813c02d873aff0fd427569138444995f46e6e662",
       "maxPositionImpactFactorPositive": "0x19a1bd926c6151f48a05d3aac08ff880ab7bc87a6ed2b5292569196a64c4a525",
       "maxPositionImpactFactorNegative": "0x431d4f40d2fffb4de5d661edcbc6b0e6554964ec51cff739f127f68ded07377d",
       "maxPositionImpactFactorForLiquidations": "0x561b7c6b780552b688ab9f8e3bc96dbcc018702e3caff500fe80d5ffa9d62de3",
+      "maxLendableImpactFactor": "0xb04fe6a6c1deeac6f2a338514cd89d6c5c9e2c9486abb7be28cbc3412319e88d",
+      "maxLendableImpactFactorForWithdrawals": "0x0a0a26cb36e51ab9db31acafc82145edd6fe873661f62d861ccb84c15eed6e2a",
+      "maxLendableImpactUsd": "0x7bf131701265e68dea800bb92e5b2925a107dbd666d437e2cba416a10a63aea1",
+      "lentPositionImpactPoolAmount": "0x644139f34b3bd6c2ce0b14473ad054a9c728a84e61c95bb946a447cd310648d0",
       "minCollateralFactor": "0xe12f227cd7530228e3e5fd17cc6e483d16da92b2a84c0e5ff1da9e812a5b165f",
+      "minCollateralFactorForLiquidation": "0x5424fa2cdf22e059599b3129445bc0af41411203cd1c67432b1676ab75977d3f",
       "minCollateralFactorForOpenInterestLong": "0x17278babb19736222b2d9de676d18653ddf62c086d3665741aea4e5073e56fc6",
       "minCollateralFactorForOpenInterestShort": "0xd5a1fad8da19fe7337b65624c25c09577ce75115b54770ff38ef6bb95dda326c",
       "positionImpactExponentFactor": "0x804b39a27e2dd8f1ff7b9c8b9e8c617f279de79423a04c8fa048b1a7d04e0a87",
-      "swapFeeFactorForPositiveImpact": "0x19c203129972249281a0b60e7b622a8d66a1d7bf798dc42ac056684d96e71805",
-      "swapFeeFactorForNegativeImpact": "0x323d04891a07265a4b585037fdbdb85d79170c22cd5f34dc3864039d93a1a6c0",
+      "swapFeeFactorForBalanceWasImproved": "0x19c203129972249281a0b60e7b622a8d66a1d7bf798dc42ac056684d96e71805",
+      "swapFeeFactorForBalanceWasNotImproved": "0x323d04891a07265a4b585037fdbdb85d79170c22cd5f34dc3864039d93a1a6c0",
+      "atomicSwapFeeFactor": "0xcf9a0b348c47c4c56342906d69d1ee4c2fc385c51a90629ff71a814173c6984f",
       "swapImpactFactorPositive": "0xa71869892b9b6533e98daebca840e5d5536dc60b02f242dd2aa099f47e3a36bb",
       "swapImpactFactorNegative": "0x4179e67be0eb7afc3c56a4d16854b7b691f85c5592c3c13c743bbfe2e519a76c",
       "swapImpactExponentFactor": "0x399b4895a6bb319b3a1df26d56ff6b188547f4da5697c2a2d3109186c8d50962",
@@ -1930,19 +2328,25 @@
       "maxFundingFactorPerSecond": "0x236ef1bb27f759ec8f3561653ffe9db18a8bd37b5414d803ea24ffef8db7e1f6",
       "maxPnlFactorForTradersLong": "0x28c6560a3d84672c3d84081988ff32450a9f1b417062644ea4ae62ea4ddfbe59",
       "maxPnlFactorForTradersShort": "0x727dddeb2f67de8636f5e9dcc0dfab740c594b2c6464457e3ee6ac5e05c155c8",
-      "positionFeeFactorForPositiveImpact": "0xb8130da30b2d52f0da6b00cca4d6e27796e8e29cc770424d81830d468f6e46ab",
-      "positionFeeFactorForNegativeImpact": "0x86619920b9bd2a757bdb46082f9e7814b07b346b85ec327426e81ed2b98c9512",
+      "positionFeeFactorForBalanceWasImproved": "0xb8130da30b2d52f0da6b00cca4d6e27796e8e29cc770424d81830d468f6e46ab",
+      "positionFeeFactorForBalanceWasNotImproved": "0x86619920b9bd2a757bdb46082f9e7814b07b346b85ec327426e81ed2b98c9512",
       "positionImpactFactorPositive": "0xe9a08eac13757d3e3c9ec273c660957e20735fe6b0fbb100efa42fd2dc103e03",
       "positionImpactFactorNegative": "0xe3a1c8fa81526ad49a0e29a269d6322584f06fc8360bdeffeac122ce5bd71412",
       "maxPositionImpactFactorPositive": "0xc5830d4233c3c4b40396b597456329984dd1fa00d54ccc6a0ff3ed8ad24318ed",
       "maxPositionImpactFactorNegative": "0xeac0372e3d88ea3b6591a48a239ca5cd3bec458c763374376558ae8de853c342",
       "maxPositionImpactFactorForLiquidations": "0xdc60fe72bf55e425533f747c6952ba5d44777e6d701caf52570b3b72f481bc77",
+      "maxLendableImpactFactor": "0xac8263f8aad77e8440d7519e2ccb1bc6df8c27e3cd335fc293090929e8ccd9d4",
+      "maxLendableImpactFactorForWithdrawals": "0x4c498f0497fb8a82fb336a222ead9d6cd2dc6538bef226bbd9ea604d60745b63",
+      "maxLendableImpactUsd": "0xa40dd2d46fe34bb43d4cd0f4e47af87dd9e8416f5eaccf9b2ee8766839ed8715",
+      "lentPositionImpactPoolAmount": "0x38fb5105ed878c704c1bb0b5a6a2d3445010eb2796f43f9b22178bf5a1f0d980",
       "minCollateralFactor": "0xd1a9d8c3945e025659b09a50bbdf19d4b9a115dadcc662b86b59a61af9e795ce",
+      "minCollateralFactorForLiquidation": "0xf753b5b18d0dd10ddf23bdd1059939f3879247e5f5e1c6b0352cb01bcf4cf5e2",
       "minCollateralFactorForOpenInterestLong": "0xbf0cbbcddabe14afa33f3d923e06fc7c713ad118078f7e77f3d2bb9a8d648619",
       "minCollateralFactorForOpenInterestShort": "0xd54c4e668acaeb80926b6c76790870e89a47e80823955189e02c504021ada729",
       "positionImpactExponentFactor": "0x0d0b5deb037a6e299a4f6746578fb10d363fcdbb8f713c4194e64cb0344002b0",
-      "swapFeeFactorForPositiveImpact": "0xa766d46faa67189be6ffb6615e6ea31a5f403e8ece029a45b4cd3eeb08cbe02c",
-      "swapFeeFactorForNegativeImpact": "0xab3e9d384304687b4fcfaf1fa93376f0f72ba120fc0511f2d7f009e7e46622f2",
+      "swapFeeFactorForBalanceWasImproved": "0xa766d46faa67189be6ffb6615e6ea31a5f403e8ece029a45b4cd3eeb08cbe02c",
+      "swapFeeFactorForBalanceWasNotImproved": "0xab3e9d384304687b4fcfaf1fa93376f0f72ba120fc0511f2d7f009e7e46622f2",
+      "atomicSwapFeeFactor": "0x7c769c06dc7c6a4ac6f4e0848dbaf356ad5fc344dd59201cc5f9970f51f7a105",
       "swapImpactFactorPositive": "0x13eda227af6bd9bd0817e3771f202173a24574f81d1ae84a0b394fcf675dfa8e",
       "swapImpactFactorNegative": "0xd5d924bf90f87618ba23759e1df30db025573ec12a4af3940533c4f03cad76ad",
       "swapImpactExponentFactor": "0x8b1b0e78966a367740b4f1d102a9188442fa9a450eb815d28cd384b8e0616ae2",
@@ -1980,19 +2384,25 @@
       "maxFundingFactorPerSecond": "0x2d6fd46347386695821f8183b44b3c52e4adb3e05d21baed6c3ee136c929634a",
       "maxPnlFactorForTradersLong": "0x42206deb102983b56125efa6b7a1a9a91c9718f60f6c08ed39086d427a01c070",
       "maxPnlFactorForTradersShort": "0x5d6715d11e8d236acf70c9866d3d10e50d66db002aa8af4daf308319e839c55a",
-      "positionFeeFactorForPositiveImpact": "0xe6e6eeaa3e7c8031ae37ee72d1fffa975b364d1c44f948e43af20211f346eafe",
-      "positionFeeFactorForNegativeImpact": "0x4f59fabf762b3e86dd3205e0f99ca9b63b08c14c90e0d50bef53f10df085a060",
+      "positionFeeFactorForBalanceWasImproved": "0xe6e6eeaa3e7c8031ae37ee72d1fffa975b364d1c44f948e43af20211f346eafe",
+      "positionFeeFactorForBalanceWasNotImproved": "0x4f59fabf762b3e86dd3205e0f99ca9b63b08c14c90e0d50bef53f10df085a060",
       "positionImpactFactorPositive": "0xd38ee3b78399bc9248c38814306468884b4fc7516eeec324cd19733ceefc652a",
       "positionImpactFactorNegative": "0x6ec836bdd3077fc5d55b47e37b5adb4451d7a355521c503092cfd8ab8860c6f4",
       "maxPositionImpactFactorPositive": "0x2d159b4e62a983c5c028f2c9257af7d9dc7813e54bb7ec68cb5abe37af1f8509",
       "maxPositionImpactFactorNegative": "0xb09e57cdc10afaa5d73dcb0b84982faf2bb6fcc8ffce9dc77c3a70668dfe917a",
       "maxPositionImpactFactorForLiquidations": "0x264ca4cdc35dd30b69ff7cb46b77b8e60659253ac3c1486a85acce86d758ad6d",
+      "maxLendableImpactFactor": "0xe71b2fe24fcb64b2aee6954430f838ba6446c64f61ce8df03ba35e2aeff60031",
+      "maxLendableImpactFactorForWithdrawals": "0xd00738ffc5c7205a5e40a094b0e53fc88107dba7dc1460e648c58d97d61474dd",
+      "maxLendableImpactUsd": "0x0df0549faf708fc4ac7c15268724150a810bd639c2503a582946fccd53ac76bb",
+      "lentPositionImpactPoolAmount": "0x16810e11234a60e065de1af42a4b98ccd19642a8c17d5b226e8c8293ac7f985d",
       "minCollateralFactor": "0xeda57e7c9f036aced07cbf0300755e5a198f5b38b8f38709a4b3db66c6614d70",
+      "minCollateralFactorForLiquidation": "0xaab69b6b17ca07fc7c5e074a238946779c61ba7b06c80ab5ae092d0fa14f5d04",
       "minCollateralFactorForOpenInterestLong": "0x4e55b36b90bb86b6c710c7a94743860cf086374614e1de9788b5d60f6f2af678",
       "minCollateralFactorForOpenInterestShort": "0x0c8510fa2a221d973bba3edcb9353a25738e7d0e3a217a5618077208ed4df0da",
       "positionImpactExponentFactor": "0x142524c8e6b264412253aab7e884fea1fcf5610232b882cebb399d9d5a20adfe",
-      "swapFeeFactorForPositiveImpact": "0x8882eb6d03e0ebad72e73c10506efbfb2062a15fb87ef045b2a5da71e2807ce0",
-      "swapFeeFactorForNegativeImpact": "0xf572e75310cd3f77b9a3f87cf5815f0a95e7c97841906d11ece78caf827475b3",
+      "swapFeeFactorForBalanceWasImproved": "0x8882eb6d03e0ebad72e73c10506efbfb2062a15fb87ef045b2a5da71e2807ce0",
+      "swapFeeFactorForBalanceWasNotImproved": "0xf572e75310cd3f77b9a3f87cf5815f0a95e7c97841906d11ece78caf827475b3",
+      "atomicSwapFeeFactor": "0xc9ba772087f3c8e13388048b4fa1b89c1f85215090717860d20c0b6fd5864356",
       "swapImpactFactorPositive": "0x2c164a61e689a8a81aeda0f29bff44d8a7f2d8895878c64b4e41c5aab8c4389d",
       "swapImpactFactorNegative": "0xb88ad88aaa77586d993ed016bbee3584738069ab1f80fc3f7d9a8544cd6b6916",
       "swapImpactExponentFactor": "0x6f7ac0f128733366619afcddeca36ec6a2da3b379f9938024da379e0be8c1fbb",
@@ -2030,19 +2440,25 @@
       "maxFundingFactorPerSecond": "0xc054005cc2f37c32e1ef3b76b389a7ee9bf66a860b8b46bb02614b59630502c2",
       "maxPnlFactorForTradersLong": "0xa94654778e8d045b745c37d4949fca238c14141ffb3f39955f72692d7723420a",
       "maxPnlFactorForTradersShort": "0xc353eb203a1beb0be8441b249a43981a15bd0a6841bab87b3ca6fb9ca1228935",
-      "positionFeeFactorForPositiveImpact": "0x797f04bc0775c8db2983c4b6a39a9ff455e6074fa15d697b497ed9a0323bdbb1",
-      "positionFeeFactorForNegativeImpact": "0xd714718d551b78772cb65cfe1a4c6f8bb77cc66af359c92adf8568ff6a15f033",
+      "positionFeeFactorForBalanceWasImproved": "0x797f04bc0775c8db2983c4b6a39a9ff455e6074fa15d697b497ed9a0323bdbb1",
+      "positionFeeFactorForBalanceWasNotImproved": "0xd714718d551b78772cb65cfe1a4c6f8bb77cc66af359c92adf8568ff6a15f033",
       "positionImpactFactorPositive": "0x3c21979d6fa1a52812bbea6ed9c4e45edc07fb528d1288d8dc454da59655d385",
       "positionImpactFactorNegative": "0x9add40936e4063e215522e32a8ae7847e0db2e8b27b4db0284f3f3f9401b808b",
       "maxPositionImpactFactorPositive": "0xac08965b798a991c076440d2e2678d2e18bf6a22c4a1b7323eefbd345cbf2ddb",
       "maxPositionImpactFactorNegative": "0x8e393b5ffccbfaaf16c5ae93cd98901ec890efb2554a03fb723c082280ab2991",
       "maxPositionImpactFactorForLiquidations": "0xdcab036d83ec75c77aac09db90596f2b3ad8bb2fa8f908917acff8c9c702822d",
+      "maxLendableImpactFactor": "0xa4f62f601d3256e54696361f07a5311f84a99bad5aab511eaec3462fcd04a27f",
+      "maxLendableImpactFactorForWithdrawals": "0x2e7060aa7c0e96af71f094bc2fdee585d9fb1cc58bd9d06616040b634f612a5c",
+      "maxLendableImpactUsd": "0xb6636bd7d6c845b8e827c4737a6046dcc18f33ca9fc08e3e632b4fc0f6d298aa",
+      "lentPositionImpactPoolAmount": "0x2b7d8014d69c6256c58ca4cc371bf72964cdd024778fd12f492d23f7accf43b7",
       "minCollateralFactor": "0x77bde089799540169026c8dd1d4ae2e2128599fd8b9e31446c4dcc83bb9c23e7",
+      "minCollateralFactorForLiquidation": "0x07395d2acf2523661f22bac10669c8a51ca55b1618d2d5d8f9e293fce20539de",
       "minCollateralFactorForOpenInterestLong": "0x36e72daab303600b4522ff9c0d0bb9a1eaf31c1cce97b8ae17084f0ebefe5924",
       "minCollateralFactorForOpenInterestShort": "0x93a0ba9c685fab64917a6ab1a5e27dff7537836ea12f0c7645c76abd965d21e4",
       "positionImpactExponentFactor": "0x78b509b0ba1718dc95363e99b4b27fbc80a15ff26f4c7af4d09bff22b4708a36",
-      "swapFeeFactorForPositiveImpact": "0x1bb948b925f5b0890197e4a96a36efa3405166da0bb37057376b1c9afc67a1f9",
-      "swapFeeFactorForNegativeImpact": "0x3936d99bd3d40af388a17a62030f9472559e4073150a3b7df3e29aa7b5652a9c",
+      "swapFeeFactorForBalanceWasImproved": "0x1bb948b925f5b0890197e4a96a36efa3405166da0bb37057376b1c9afc67a1f9",
+      "swapFeeFactorForBalanceWasNotImproved": "0x3936d99bd3d40af388a17a62030f9472559e4073150a3b7df3e29aa7b5652a9c",
+      "atomicSwapFeeFactor": "0xc1251742314a5c7bbc29fc0d0ae9f882f422cfbefa2b4cef4b1094e2ee40240d",
       "swapImpactFactorPositive": "0x43fd312437e0556e2d89f99e604d50d1ed9c4b02d4e9804bf69d8c71c1ff2928",
       "swapImpactFactorNegative": "0xe5ea472c4d680fd020ee7c372c33683a5739fb3822fe39d969f07cbe4167bd0d",
       "swapImpactExponentFactor": "0xdde80356bdb18a6e5cf7fe6659145d4e2236f7615e6934e10bca1ea8e618158e",
@@ -2080,19 +2496,25 @@
       "maxFundingFactorPerSecond": "0x7c7d2c063e2459eab3f0b4617d9a10deef46d0b92fd039e83e83ab508de22dbb",
       "maxPnlFactorForTradersLong": "0x88880540378c25ab3984cf20f61798200656efa0a6df24c9848bbb980be23a17",
       "maxPnlFactorForTradersShort": "0x7c292ade526b200d6dab2668fd249b4e1c8462c4fee902f3d8b5dd10438a0297",
-      "positionFeeFactorForPositiveImpact": "0x60b0929e249f03887b7653b500ef4fd2f72f5338f946b5a9b4243ffbde989eb7",
-      "positionFeeFactorForNegativeImpact": "0x2b9925b6789771e207b9223ca7476cc9fbc5b742a243e5b7cb4e836a20817807",
+      "positionFeeFactorForBalanceWasImproved": "0x60b0929e249f03887b7653b500ef4fd2f72f5338f946b5a9b4243ffbde989eb7",
+      "positionFeeFactorForBalanceWasNotImproved": "0x2b9925b6789771e207b9223ca7476cc9fbc5b742a243e5b7cb4e836a20817807",
       "positionImpactFactorPositive": "0x2758725c04034379168a8d828ed91d9d3e855a2d10aff4dd54326b154d640a15",
       "positionImpactFactorNegative": "0x51783acf88ad8bb641add39a04bea27fe7715c01fa0ebdbe7ef3f72d473e2fc5",
       "maxPositionImpactFactorPositive": "0x8c12b034ee8ad6fc1164338e82528933622843f83631cef944038173ec07125f",
       "maxPositionImpactFactorNegative": "0x812b06e8a9ae30129f248baa9f7e032708f037b1138d7f487060bca9cb4287f6",
       "maxPositionImpactFactorForLiquidations": "0xf129060dfcad1deca65540e0b1641443a5f0fcec26235aa946eacb088c0eadf2",
+      "maxLendableImpactFactor": "0x2e64eee7491505d680b57c4c65166533cc03a150e3aaa4f6b886de62ca91baad",
+      "maxLendableImpactFactorForWithdrawals": "0xb16b9e1df74cf0b2170913a3fbe6983fdad89a333d154b095e3e2f0666b7d8cb",
+      "maxLendableImpactUsd": "0xd351d973906e71859bd3af9cf85c2cce74231224edd2c67726a5a3bd39e7dd30",
+      "lentPositionImpactPoolAmount": "0xf3e0a20ec0adccb47462bb3c3e5755187c6988471571b3812959c46e0fac1440",
       "minCollateralFactor": "0x64c28b87c54a43b52e4e78491ecc0749386e5fa99986c78e5855e4e0039fdd01",
+      "minCollateralFactorForLiquidation": "0x80c09ef7c9fd9bd8cfac4a4dfea9a09e895612ea378f41668a753350c6932f69",
       "minCollateralFactorForOpenInterestLong": "0xb1f9e034cd8013cd53cef9f0bdec7c7bdbc4db862e555e88eb9d1cf5e6511956",
       "minCollateralFactorForOpenInterestShort": "0x20b6d2f9b79b868e1524b9e961bab3641f9f799c6d97d63911dea52d70c5cada",
       "positionImpactExponentFactor": "0x9f1b87272507fe9ec122c5535383fff447e2ebf7c92121965b17bf0f4184fd41",
-      "swapFeeFactorForPositiveImpact": "0xadd2c67471f951b61e2eff6f7decbdf8c2ef20f48059afcbdea87d9a435d01c5",
-      "swapFeeFactorForNegativeImpact": "0x31edee4dfd4291a0492f60b88b76f2f0752edfe619e20e30710894daac78e1ca",
+      "swapFeeFactorForBalanceWasImproved": "0xadd2c67471f951b61e2eff6f7decbdf8c2ef20f48059afcbdea87d9a435d01c5",
+      "swapFeeFactorForBalanceWasNotImproved": "0x31edee4dfd4291a0492f60b88b76f2f0752edfe619e20e30710894daac78e1ca",
+      "atomicSwapFeeFactor": "0xaa1e103bf62db569d5534ff50ca53b37314f09c697813b0f9d753cebcb252601",
       "swapImpactFactorPositive": "0x36e871427ac1ce490403c9351e871024aaee072fa90fafeea3a09ee1296c5100",
       "swapImpactFactorNegative": "0x6a34903a427c705b14eebd04e3d807ce9465c22b28c84ae75b83b142bc0e34ab",
       "swapImpactExponentFactor": "0xe04a2a7a7efdaea4326561690e5a525f60dff65d3aadb010dd528ccb6a083752",
@@ -2130,19 +2552,25 @@
       "maxFundingFactorPerSecond": "0xbc1f8614236a23d18e95db9ce4af307af690e5ab8206ffea12ca642c6cd6dea7",
       "maxPnlFactorForTradersLong": "0xcbb5ee9549df2459619925fd79c95020edd6b39393c707c37ca096d31570720a",
       "maxPnlFactorForTradersShort": "0x4e7efb010dd37130af7c8133f32a850a2390afd139b7893e47fb75df081b7eea",
-      "positionFeeFactorForPositiveImpact": "0xb65ad101925e7990ccca3a06feb91cffe0d80cbcb201841f6b5b7ca816079b4e",
-      "positionFeeFactorForNegativeImpact": "0xef6385c6a2f181806f748dd22a2c0ccc32882d9fb08e7747514a1b41929100fa",
+      "positionFeeFactorForBalanceWasImproved": "0xb65ad101925e7990ccca3a06feb91cffe0d80cbcb201841f6b5b7ca816079b4e",
+      "positionFeeFactorForBalanceWasNotImproved": "0xef6385c6a2f181806f748dd22a2c0ccc32882d9fb08e7747514a1b41929100fa",
       "positionImpactFactorPositive": "0xc2acf82f196514ddbcfb4250e4aaf2765fb3fda2f0e09da76e552cef2f83a8fa",
       "positionImpactFactorNegative": "0x78bf708597d31ecf8d57abcec8dabfa5c0d21147ac154d5d288f5c20f5f220c6",
       "maxPositionImpactFactorPositive": "0xb0a73010ecdba53705c694d2f936d18e4a05df0f17c700bdace6271ca813c9a3",
       "maxPositionImpactFactorNegative": "0xd5e633acde47db2e2ffff00c56aa46345ef121f1a456f1d77b79706719b2c3f6",
       "maxPositionImpactFactorForLiquidations": "0xb9f158697849b94901cc34c765b0796456aef9657a895abbbc4da40e752e6e89",
+      "maxLendableImpactFactor": "0xae87f11395854df27730c03627fe9fa049226d435b0408025dcfb489fcf06a0c",
+      "maxLendableImpactFactorForWithdrawals": "0xd43e4b0d9ebf88c4144b022f8d3241dab3b5c39e4351eee9674cc079ed8df106",
+      "maxLendableImpactUsd": "0xf45c560e511f5fe46d095ba361ff156cb4a0f51a14bc5edd67ef771816704a80",
+      "lentPositionImpactPoolAmount": "0xa6fcea5015ef7382e3050920351cada8e11a61c54a083e02e1c63bcc19f3ce09",
       "minCollateralFactor": "0xe987e328f86edb1ddbe92a10a5a8ed7cc9e27012a3f8eacabb95015d8d4a5029",
+      "minCollateralFactorForLiquidation": "0xa872cd93df49b89091c0c052b1f9816b051bc3c837802ad34c28a32716a65cf2",
       "minCollateralFactorForOpenInterestLong": "0x43fd25f73c5ad7cfa51e170a8e62c4b5267f167b881d77c8db40d0fff9b0cbfd",
       "minCollateralFactorForOpenInterestShort": "0xbe919143794d2b200798bb5ce729615b2c0da3f4918a5928f7020ea6fd19899d",
       "positionImpactExponentFactor": "0x68e38c9e7e097fb2dca604ab440cc4c81ec75b7cb19de8a626c93bd00019e02e",
-      "swapFeeFactorForPositiveImpact": "0xed597aacfcc0d2c97088b29821bc7c5481db8decbdc266300b3998ae014dba2c",
-      "swapFeeFactorForNegativeImpact": "0x605173de6a0cb1f167f584339ff5b46851ceff4ddd725a1db918231f9912a43b",
+      "swapFeeFactorForBalanceWasImproved": "0xed597aacfcc0d2c97088b29821bc7c5481db8decbdc266300b3998ae014dba2c",
+      "swapFeeFactorForBalanceWasNotImproved": "0x605173de6a0cb1f167f584339ff5b46851ceff4ddd725a1db918231f9912a43b",
+      "atomicSwapFeeFactor": "0x572c7a723c1c49a0e78bd8ffa219de256d375f1098f3accf55ca7c0d303d141e",
       "swapImpactFactorPositive": "0x208c6acc0507566d2cb55884616eee785678beeba5542607b18d32de7007639e",
       "swapImpactFactorNegative": "0xbc075ce4fb66dc695cd10edf51e201ae23591004d823be69ee8ad5ab0ccf87f5",
       "swapImpactExponentFactor": "0x446d2f81a872accc792188ba237193feef42d1f282e2b7ac0ea9660566f370f8",
@@ -2180,19 +2608,25 @@
       "maxFundingFactorPerSecond": "0x5d86ad2a0ee3b0f58abf8bb7c1aa17dc35b005d746a5b027877a3d0ef626ee1c",
       "maxPnlFactorForTradersLong": "0x23941bc4b4dbc0978d113bb410060704c55e1a0adb646b54e5a3de1c46715451",
       "maxPnlFactorForTradersShort": "0xa854cfc761aecf46ad9aba88804d4ea337d88de6716e057ee78c6774832fd66a",
-      "positionFeeFactorForPositiveImpact": "0x8feb0270a20287d1a5124b49803492bfae97c6b5638dc765bbf3114a5439b54a",
-      "positionFeeFactorForNegativeImpact": "0xf4fd4b73132ab0990fec091ab4316539ebc88b4981c0449fdb89f91d0cb90b49",
+      "positionFeeFactorForBalanceWasImproved": "0x8feb0270a20287d1a5124b49803492bfae97c6b5638dc765bbf3114a5439b54a",
+      "positionFeeFactorForBalanceWasNotImproved": "0xf4fd4b73132ab0990fec091ab4316539ebc88b4981c0449fdb89f91d0cb90b49",
       "positionImpactFactorPositive": "0x495905a35817f5fff10ae3f21225d5e5522efded696273bf51f1669dd880ca91",
       "positionImpactFactorNegative": "0xd9f43c76d06fc8135a75b267ffb77032a20aed233064fe4a1cdace0201339441",
       "maxPositionImpactFactorPositive": "0x01e8f1ec1cca444aff7fb4841c5e04551eca12a3e3f40d802057aea21b946eec",
       "maxPositionImpactFactorNegative": "0x428bc3887bc7489c9485260579d0e0763d783139851ee3f18a14d55cc74cec96",
       "maxPositionImpactFactorForLiquidations": "0x309b153983005d88ec9b50ee2d382f58b3d94dbf502ebac9a1df9200f806f7a4",
+      "maxLendableImpactFactor": "0xabeef6af10a3f56b35364626ee2ce74ac4b2fc5e5c73249ff5d2821ee2b4389c",
+      "maxLendableImpactFactorForWithdrawals": "0x99773bf20f3592fbba4ae7d96470d273aedbbc7be2a59f8e0b937733aaa35bfa",
+      "maxLendableImpactUsd": "0x45a363babd50926907d227376a252d13abf447ed356916cbfcae1ad20d79a858",
+      "lentPositionImpactPoolAmount": "0x9b5e96a39a758cf2b91a6c525554121f2b13bf3b7d3f84ceac955336851faeac",
       "minCollateralFactor": "0x4f281cdc49e1f75ea1a028c8c23e00c1331011026e794caf8547cdcfc8afbdd6",
+      "minCollateralFactorForLiquidation": "0x17804f6665dca57aaf8fefd6e6134d40f30afe8dae60b79da13190d4ca798641",
       "minCollateralFactorForOpenInterestLong": "0xb41bba385bea8b61ee3a31a77f9b22ca93ddd1ddd4c0b2122a1479c41245a918",
       "minCollateralFactorForOpenInterestShort": "0xa3cfc4f602f38bf736284ff16d11b328ba89cdf571d87a27d801101fe18a89d3",
       "positionImpactExponentFactor": "0x4717cfc01a1a24ef675701768beb7343fad800404065332a016f33c3fec290d8",
-      "swapFeeFactorForPositiveImpact": "0x712f5742039b496858cdc383ea6f4f6db9dafd98bd4bc0682e8bec1036758869",
-      "swapFeeFactorForNegativeImpact": "0x39ff0ec8537e6c67dc3aeb20d22f14835a509939dd4c2535b1d83677bdb58dfd",
+      "swapFeeFactorForBalanceWasImproved": "0x712f5742039b496858cdc383ea6f4f6db9dafd98bd4bc0682e8bec1036758869",
+      "swapFeeFactorForBalanceWasNotImproved": "0x39ff0ec8537e6c67dc3aeb20d22f14835a509939dd4c2535b1d83677bdb58dfd",
+      "atomicSwapFeeFactor": "0x70b27f118f4f8264a881ff28afcf50d90a22ddd062536d52cfc0c09831ce599d",
       "swapImpactFactorPositive": "0xf36010feb1e7e5bf88eba48c62b7cdc9a00bbd23007f4afb33cc373619624b2c",
       "swapImpactFactorNegative": "0xfb915dffefd667c9f6211dad9e8b7236026971701504f4c5b591c964d750c9aa",
       "swapImpactExponentFactor": "0x368c32963de4e32ea01c9f7356e2a1ad5fe2fc223d6a5d0ae3e497e8928dc90b",
@@ -2230,19 +2664,25 @@
       "maxFundingFactorPerSecond": "0x2f69beeaf53db976baa8d119d7c271708c4813cf85476d76004568544ef32779",
       "maxPnlFactorForTradersLong": "0xa2800b3ce78a5d0389732d81038e88feff40e3bd49f09ffee56811f40ee38803",
       "maxPnlFactorForTradersShort": "0x1450231125af74d89355c10b08e1244c6930ae82e7c6a43f541a02c87e85b32c",
-      "positionFeeFactorForPositiveImpact": "0xbc139966b077397a4c0f20ac3b08651b6c91952888bf60fc6b03879a297c4b4a",
-      "positionFeeFactorForNegativeImpact": "0x4dd266ff9795afbab0849ca9b10a61a56f7b9b3df788cdd4a427a615d9ef59e8",
+      "positionFeeFactorForBalanceWasImproved": "0xbc139966b077397a4c0f20ac3b08651b6c91952888bf60fc6b03879a297c4b4a",
+      "positionFeeFactorForBalanceWasNotImproved": "0x4dd266ff9795afbab0849ca9b10a61a56f7b9b3df788cdd4a427a615d9ef59e8",
       "positionImpactFactorPositive": "0xb5dfa58ab68838cfab396a23a6458a19b08332f7a04cebb1c6f71f2821947e9a",
       "positionImpactFactorNegative": "0x56823d6116f0891a5d4838c542ef05dc745c9ae5c68f9a99f22a8b55b4d230f7",
       "maxPositionImpactFactorPositive": "0x1ceebfd867b9918efbe8423ec199d06ce78ca441d305aa9662d3764ab7a9faf5",
       "maxPositionImpactFactorNegative": "0xcf7ee5b0a80d4662ffda30f4d157d17612195104d15bb91bee6de03ae3e3599e",
       "maxPositionImpactFactorForLiquidations": "0x930f7239b83bc0b01c885d62e1739adb7f47483b2f95d68cb6ae0586991421d0",
+      "maxLendableImpactFactor": "0x761ab4d85c8d02769f1892e9544527e03bf6c30f447f04de8536fe2f3c8700a1",
+      "maxLendableImpactFactorForWithdrawals": "0x760851489978dd8127b1ee813fc067383fa463de207a6ba4fae5d02888dc1d65",
+      "maxLendableImpactUsd": "0x3fa3b2f9d004c88d67722537d6e17392f8c8dbb12709f592ff982371c6bcd483",
+      "lentPositionImpactPoolAmount": "0xed9d636ee89e792a0f7c913aa64beee264ab111f8afcd74b702e155b11507bae",
       "minCollateralFactor": "0x6e2e2d9c129dee202f1002e2c7b8fa62b854c04ed92b2e84ccc8d7874d1d2b82",
+      "minCollateralFactorForLiquidation": "0xe95b93b905611839520fd90f7f70626dda38eac36b11245e48bd0013c4a96ca8",
       "minCollateralFactorForOpenInterestLong": "0xc777cb82bf5fcf2085423ebb02d83a2e797ee69fe92e28bb541585d6d3ef9776",
       "minCollateralFactorForOpenInterestShort": "0xea1786adf77d76ecc08ae1ddfb961397bbf8037fcc1f39f407ca682bd0cd31d2",
       "positionImpactExponentFactor": "0x9fb394e7a8ca562a80c61ff34aafa3780f223eae1c7bab55bdd65f3e74d7c10d",
-      "swapFeeFactorForPositiveImpact": "0x8fe25e4cd1a3645c942c5754cb52f61d884f867f40c795ac14d8c0c4cb5a58f0",
-      "swapFeeFactorForNegativeImpact": "0xfe43f1671a9753bc846216959f80192c4bd06d228525f64f1bb0ec0b21616e08",
+      "swapFeeFactorForBalanceWasImproved": "0x8fe25e4cd1a3645c942c5754cb52f61d884f867f40c795ac14d8c0c4cb5a58f0",
+      "swapFeeFactorForBalanceWasNotImproved": "0xfe43f1671a9753bc846216959f80192c4bd06d228525f64f1bb0ec0b21616e08",
+      "atomicSwapFeeFactor": "0x98488815b3e5a70a0181740e0bd65220f81a07d1c039b338bbe14abe54844499",
       "swapImpactFactorPositive": "0x79e2b21fccda79427457db054b84bc2dd39d6e71e802603330463debd9e2cf2e",
       "swapImpactFactorNegative": "0x3fb93539d5a21b0bfb035b684c90c976559174c5b3cb61a31eda7052cd0a8df8",
       "swapImpactExponentFactor": "0x9545c1fa52965fed0922740abce09210eaf7584507acee7bb1360a4d9e1f2ed0",
@@ -2280,19 +2720,25 @@
       "maxFundingFactorPerSecond": "0xc99b408fa3abdf793c7508311103c10f75b6459450a8f7ba205fbc854f11848e",
       "maxPnlFactorForTradersLong": "0xdec4bd5c55d0af82123c937bd7b6f886e517f0c7e1c940459a068e346a47fa1a",
       "maxPnlFactorForTradersShort": "0x99a75d71a9aa0d00fde825a755f89eea3f4fb0c905591fdfe52f37099e98c49e",
-      "positionFeeFactorForPositiveImpact": "0xdde7cf99fc26d3c9e7e5ae67f7558d1d21fabe5b5881f645ecd574acbc1e999e",
-      "positionFeeFactorForNegativeImpact": "0x5c6320bcdc9efacd98b6a01febab34934936dd529ac3c8158b58232b6692cdba",
+      "positionFeeFactorForBalanceWasImproved": "0xdde7cf99fc26d3c9e7e5ae67f7558d1d21fabe5b5881f645ecd574acbc1e999e",
+      "positionFeeFactorForBalanceWasNotImproved": "0x5c6320bcdc9efacd98b6a01febab34934936dd529ac3c8158b58232b6692cdba",
       "positionImpactFactorPositive": "0x12350a6709e67181b6145c62f115ee66069858250ea4eb2b0dec9ee9da2f1a49",
       "positionImpactFactorNegative": "0xc7c8e8dd75f9b18d858379050bfcddc53b2f2d1f7092df2a35e079bc529dfb85",
       "maxPositionImpactFactorPositive": "0x66f52be66a69bc53a3985ef3c01c7c7906e8b0ab5b51f155f5fb827401b8c716",
       "maxPositionImpactFactorNegative": "0x3ffb5d3349a72f3953a21481cbed2007a44e98153f737f733789c1fc3db6109b",
       "maxPositionImpactFactorForLiquidations": "0x47b22aaab270336bca023ac06e6b5231bbb44f56716a9387e91e99241870f616",
+      "maxLendableImpactFactor": "0x8f2d0ed4f96fe24ed2d9c8dd642fb1acfc10a5567e47c4787f50deef6de62e22",
+      "maxLendableImpactFactorForWithdrawals": "0x2ba1e6446967b1ea874ebf51400cc46af88e33787ed9d452ff0bd45e47e3e0d9",
+      "maxLendableImpactUsd": "0x2997295762567bfb9f36140349930ff5febba89eb2aae6d21e157d82bd601168",
+      "lentPositionImpactPoolAmount": "0xae71a7ae57b6453066097069e546d52946ced985ef929af81540698680327d02",
       "minCollateralFactor": "0xc27860b61b54460909bb28e4c88e66aa1d27de104b8b444fba674362795a4068",
+      "minCollateralFactorForLiquidation": "0xefd57fd6c01e403503503b2f4e057243ce629c1fbb965350bc5b699db54e3515",
       "minCollateralFactorForOpenInterestLong": "0x3e352a600ba2709aa41ad9fe571943bf3119a5d4e2ed56b8d9c26f6b61c24df4",
       "minCollateralFactorForOpenInterestShort": "0x74cd50f69586972d5835b60030fc59197abcd83dc5ed4952cf7211769bf9303c",
       "positionImpactExponentFactor": "0x5be4f5dd05e107edd86e920723f94647246b593d1e08b704e42721024d182c3c",
-      "swapFeeFactorForPositiveImpact": "0xb7614344f2d22e57b6d2476711c7aad17d112f92c7f0b87606553bffaa0e7588",
-      "swapFeeFactorForNegativeImpact": "0x3c744c1515881778c9d315637561923c3d185bb0922e2816b2672425cf9c942f",
+      "swapFeeFactorForBalanceWasImproved": "0xb7614344f2d22e57b6d2476711c7aad17d112f92c7f0b87606553bffaa0e7588",
+      "swapFeeFactorForBalanceWasNotImproved": "0x3c744c1515881778c9d315637561923c3d185bb0922e2816b2672425cf9c942f",
+      "atomicSwapFeeFactor": "0xb1d430a0cefc57e981a25023afc486a84ea4adff0e5dc45ed25b930df872e0c6",
       "swapImpactFactorPositive": "0x88f491f2b910faaca2409fa56898c9873596d94f61459a799f22aed18c3f0024",
       "swapImpactFactorNegative": "0x063d716f2663e42baa3255283db6cadd96bc6e066eea5397683e050758613f72",
       "swapImpactExponentFactor": "0xe15802d95e8f9fcde01134de2f73e873fd63c2038546f54c4734358dbf9d24df",
@@ -2330,19 +2776,25 @@
       "maxFundingFactorPerSecond": "0xe567c9d6c7b881eadf4a419a3f7a800435fac673e27db053fda52f9513755994",
       "maxPnlFactorForTradersLong": "0x9cbacb634cf93a6fa613b31a68ce1ded9aca5143679ab689a82e9bbfc7c8783b",
       "maxPnlFactorForTradersShort": "0x8de9a79752873cb14006e67313ab378ec606bb658c2d296b165bf145345a2593",
-      "positionFeeFactorForPositiveImpact": "0x8e33a75ecab6ae62818b3a34b74cecec08237ff1bdee24a6df2afee80d3cf513",
-      "positionFeeFactorForNegativeImpact": "0x5fc7dc3aabe90cf80ba4506802d75ca1fb6af53d099cd8d4526168b0ccd7db5a",
+      "positionFeeFactorForBalanceWasImproved": "0x8e33a75ecab6ae62818b3a34b74cecec08237ff1bdee24a6df2afee80d3cf513",
+      "positionFeeFactorForBalanceWasNotImproved": "0x5fc7dc3aabe90cf80ba4506802d75ca1fb6af53d099cd8d4526168b0ccd7db5a",
       "positionImpactFactorPositive": "0xfc9f106532cffec12b6d284757fb145910b0ec592a415c981d5fe42f068d661e",
       "positionImpactFactorNegative": "0x6db1edf5d6b901c21934667c8dbbfe802f182c1572aec99759ea829a18554844",
       "maxPositionImpactFactorPositive": "0xcdbb8852bd100d2a2c9e96c3df6c8a3a1fa5166d2b0e6c0a026ff47efdfcec3d",
       "maxPositionImpactFactorNegative": "0x02b2d57b10ba38e67b996de41580805338380c5a38991b67cca1d5cd26ae8245",
       "maxPositionImpactFactorForLiquidations": "0x60a9b69a9726114c020d44750e3d51dfa117631eef925c2e5bb7d90a8bf0f16d",
+      "maxLendableImpactFactor": "0x280acb1c344ac555de42d4466eff401fd585fa62c27a0d1e3bf74c6a52e90731",
+      "maxLendableImpactFactorForWithdrawals": "0xce052928845fde42d14590daf8b4b29cec8ba7f4ef1fc3767ec4c2c8882aa57a",
+      "maxLendableImpactUsd": "0x32a2ddb5e22d3feceeffa3c959588640a038d3fcf8e70f27b9903c36ba56ada9",
+      "lentPositionImpactPoolAmount": "0x0fdf775c457064438c45c88dec178fa52e3bf0795d656abbd58d0f978044d177",
       "minCollateralFactor": "0xaf43ec1b76b9c6c2c5167932b08308377bec48ef36aee9e4f40bf44013315ea6",
+      "minCollateralFactorForLiquidation": "0x751618cd5038dcbf1a35c7b6a4fad895b25d3c85860a57fd5e6f5f677ec85bba",
       "minCollateralFactorForOpenInterestLong": "0x1b990975b2ec9cb3d7800bdcf4c2483ad891a580d9bb318b533b40c52c2f9ba8",
       "minCollateralFactorForOpenInterestShort": "0xa7ab6290b680865cdb9d52ee69ecbff08162372ac6787a60fa23c1576752b9ef",
       "positionImpactExponentFactor": "0x4e8013515d6c6158dbe6773d5523bd3aa689ceca388b13daebe66b8535a1141d",
-      "swapFeeFactorForPositiveImpact": "0xe7891c63da843b7666b5eb17a233335244d607ef5e28491ff80a739409753cc1",
-      "swapFeeFactorForNegativeImpact": "0xff76682edc62a55d824fb3027104a8eeefc1aedcefe710468bda4a16e940df65",
+      "swapFeeFactorForBalanceWasImproved": "0xe7891c63da843b7666b5eb17a233335244d607ef5e28491ff80a739409753cc1",
+      "swapFeeFactorForBalanceWasNotImproved": "0xff76682edc62a55d824fb3027104a8eeefc1aedcefe710468bda4a16e940df65",
+      "atomicSwapFeeFactor": "0x53fb9a87309e0503a17a7cb3eb74b75cde5bd7b36a87ca33a03323ea8fed03ea",
       "swapImpactFactorPositive": "0x914773be0246bae3852f2415f162581641c3fcbff05d9f9968dc8831bf8182c0",
       "swapImpactFactorNegative": "0x736841319b2b2e9d22670e879ec64651e9e2ffd751de069908bc1edbedd8d0d7",
       "swapImpactExponentFactor": "0x0ce9dd673cc4800b8a6664251479bcb647068469074cbb7839160b995624bab2",
@@ -2380,19 +2832,25 @@
       "maxFundingFactorPerSecond": "0xaeb94b425d4f56f779214c9f9e87c4ee626cc51a74837db1a49b47432059c161",
       "maxPnlFactorForTradersLong": "0x1faad52e65ed438f621fcc8af05068c362aa4ff4c660f93606ad9fa95d5aa83d",
       "maxPnlFactorForTradersShort": "0x23729526acd13b670a94585d21a25c4293bb7b5fb8f1ebedb8af840b2d984b4b",
-      "positionFeeFactorForPositiveImpact": "0x25c6091da422459bf8e56ea2176383d6a14ab920c5a588df462db76cf3da7d69",
-      "positionFeeFactorForNegativeImpact": "0xe8c215ead248d58af1e22f00e423ada0096f747e49179f83f4c8bcdf9bb010d7",
+      "positionFeeFactorForBalanceWasImproved": "0x25c6091da422459bf8e56ea2176383d6a14ab920c5a588df462db76cf3da7d69",
+      "positionFeeFactorForBalanceWasNotImproved": "0xe8c215ead248d58af1e22f00e423ada0096f747e49179f83f4c8bcdf9bb010d7",
       "positionImpactFactorPositive": "0x2511daf43d5a9e3063f5e74f46def864a7d94cac6b5430bde3553e0bf2f920d9",
       "positionImpactFactorNegative": "0xd994d099044c3dff63fb5cd824e94e19ed41dbf6d984c2635aa607257de07f56",
       "maxPositionImpactFactorPositive": "0xb6030074cf76d818b5e23fff7d930392bdfaff530804a4c269f43ea0c743bdcb",
       "maxPositionImpactFactorNegative": "0xf788cd2f0dbfdde4498546dbbf8ae4c3d7f72390ee8ea10079f0a24b88ecf064",
       "maxPositionImpactFactorForLiquidations": "0xd9d7a07c1d5606567f0366e489c3262b466af8fe55e8608cf926ee705da17b6f",
+      "maxLendableImpactFactor": "0x9bde08cd019f4d098e8014d5b59827bf15a02053eb110a570e17724780fef0ec",
+      "maxLendableImpactFactorForWithdrawals": "0x6e3e2275f3536b7802157f33a7463a6e30962c362542dd877c9c77b3b035535b",
+      "maxLendableImpactUsd": "0x7b3e8843f6bf26cb9724c627ea4e654dc7617e1582e78ce5405bffa27e3a4793",
+      "lentPositionImpactPoolAmount": "0x6e619860837358f304e18598e71571c6e17424b2afe08d0a9a1ae922a4d0651e",
       "minCollateralFactor": "0xacfac03e8ca9bc9ba4e4139fb22189ce60223a4acf5fcb1c52fe6f5720c8285c",
+      "minCollateralFactorForLiquidation": "0x0e0c4eca25323de2ad594c25be09587a84873207c577ed3466d2c25c5c588307",
       "minCollateralFactorForOpenInterestLong": "0x7aba0e66c4752d2788a33b21c7156bee0a7e7db1ddec971a23e4745cb4af6a44",
       "minCollateralFactorForOpenInterestShort": "0x7877dc6df20ea3c1896337e048ee1dad2b313d2753a43186a3d574f71f06069c",
       "positionImpactExponentFactor": "0x15f86469a0ce25e4d194855ed6445f3c23aea50cb148f365967050da0ce93cde",
-      "swapFeeFactorForPositiveImpact": "0x4db5b6b4f93926225227f3e2887f72c9730b813d441fe6ce335cacd22f2461d4",
-      "swapFeeFactorForNegativeImpact": "0xac158b78400849537bf0f83aade16c435943f4194a4767e602aca8c41e366e77",
+      "swapFeeFactorForBalanceWasImproved": "0x4db5b6b4f93926225227f3e2887f72c9730b813d441fe6ce335cacd22f2461d4",
+      "swapFeeFactorForBalanceWasNotImproved": "0xac158b78400849537bf0f83aade16c435943f4194a4767e602aca8c41e366e77",
+      "atomicSwapFeeFactor": "0x8dc037ec9bd8964e45b14319b948aa9956a0c8db71bd5a78d1d06130e76ebae5",
       "swapImpactFactorPositive": "0xa3b7813df6db3b7ed3edef24c4e1955bd5e9062c80ff1abdb528cd2c550e8abd",
       "swapImpactFactorNegative": "0xa77511e977f042648b2b03ea93d721a59db658e5437b141a25987849ea22dea2",
       "swapImpactExponentFactor": "0x348400b3425cec4370585aa38a068c75cbe896bc7a7865020fdacf3cc64bff80",
@@ -2430,19 +2888,25 @@
       "maxFundingFactorPerSecond": "0xa738498ce60a1e9fb8a472d19570e7f4d00f74c31c36a97b171f906801db7c7b",
       "maxPnlFactorForTradersLong": "0x47aed923299f3fc09a40d6edc10f33df888b0ad47bfb0310fc4c733d2ca23d69",
       "maxPnlFactorForTradersShort": "0x5869feb1e30115c20d820201f07c0022f6c4fc17de5dbe34fc6068e433873514",
-      "positionFeeFactorForPositiveImpact": "0x89539fbe79008640ad6cb051248458e02b54818bb63a2d7ebb190095335b23da",
-      "positionFeeFactorForNegativeImpact": "0xf21f4e2bdd357839c21dcf6d38fc0acc4342a53b79215e4658eae1d6cd4c775b",
+      "positionFeeFactorForBalanceWasImproved": "0x89539fbe79008640ad6cb051248458e02b54818bb63a2d7ebb190095335b23da",
+      "positionFeeFactorForBalanceWasNotImproved": "0xf21f4e2bdd357839c21dcf6d38fc0acc4342a53b79215e4658eae1d6cd4c775b",
       "positionImpactFactorPositive": "0xd28bfb3ca08c7494e67067bf0119c7bdba424b1387c306a28aff5dda8b377789",
       "positionImpactFactorNegative": "0x39f461176d6cc8c5c445eea54a55500c067e773445570b228b27e5493c720160",
       "maxPositionImpactFactorPositive": "0x985ded2301ade7f01d33f689a689b151bc07de2912a960554b32ff02786eaeb3",
       "maxPositionImpactFactorNegative": "0x9f08921887c462f296204ce4faf11345ac3175e596f6d544cc8b93fef3d4d0a2",
       "maxPositionImpactFactorForLiquidations": "0xa7b0973d0ec6caacca6e19044c9914fa639d36bc97ce2751e18c9ec3328bee16",
+      "maxLendableImpactFactor": "0x5073ac467dc2c2772cef5a355213369d78663bf0cb05153167e39db26e383c48",
+      "maxLendableImpactFactorForWithdrawals": "0xea083ff57c4f2b40a56513c09f35108e64c3c8a55d5b9c85b4e8c5162d846020",
+      "maxLendableImpactUsd": "0x823fee4780ac0aacc1528039fc1ae323c007c04cb5f641d08bf1e7d97fe04bc9",
+      "lentPositionImpactPoolAmount": "0x68e07e3ff441ee9303817bbae7608d4ed52d779dfe1699b57d1f994866445222",
       "minCollateralFactor": "0x6dc630ed9d38eb4d509bd15a962a8f3f3e85c305ed38bd87b5a691f8e80c6718",
+      "minCollateralFactorForLiquidation": "0x5e72cbdf15c7c2759bcf483ad4e11e757e1be816fb2cfb21d0a451017677e93f",
       "minCollateralFactorForOpenInterestLong": "0xe92ef25b6ac87cf0fe6420ff0b94dedb1dbcb99afdf6c01f4b0db2532a75bcfe",
       "minCollateralFactorForOpenInterestShort": "0xb35e315882bf52eca4d8f8a1c1d0d0e47e8bf6d2e607efee31f62929e397ad33",
       "positionImpactExponentFactor": "0xfd23c3422c995f8918ebd2dd7c73eeeff142ce0c12d07195868aa9d28d66cacf",
-      "swapFeeFactorForPositiveImpact": "0xcb64f5f3f45dc3723f11856db5925f30725fccf1bc1b2a79a60b5604b7b28fd6",
-      "swapFeeFactorForNegativeImpact": "0x440a1479e78766ccba8b1bda85ea239877dfbb362fc1ca7e790944538d1b11f5",
+      "swapFeeFactorForBalanceWasImproved": "0xcb64f5f3f45dc3723f11856db5925f30725fccf1bc1b2a79a60b5604b7b28fd6",
+      "swapFeeFactorForBalanceWasNotImproved": "0x440a1479e78766ccba8b1bda85ea239877dfbb362fc1ca7e790944538d1b11f5",
+      "atomicSwapFeeFactor": "0xbdd876ef95fe02c21b1be1058a8d1de9fdf924a675eec857ed69c3a03f82231e",
       "swapImpactFactorPositive": "0x45a4bf705485557d4d27f88259722f6f264abf19c6067e7e7c80cdc45091f812",
       "swapImpactFactorNegative": "0x102f11c727669364e295911cf2eeec0f717be0aa5c2954b9271ab9f497dd878a",
       "swapImpactExponentFactor": "0x56ad8a94a99b9fb545af26dc677d20f81628bfe1973d7899ac0b1a7838db010a",
@@ -2480,19 +2944,25 @@
       "maxFundingFactorPerSecond": "0xeb92533e6e161f74bf676c89ee359ec5c068d6c778fdb591257e578e71d2454c",
       "maxPnlFactorForTradersLong": "0x1a2f6559d9f91c12210d3b6aff192fadd82f4cc3d8b2909e8c279bb5f36331ca",
       "maxPnlFactorForTradersShort": "0x5bcc0c5f30cd53d5ed94d21c9caca0f4759ba82e89ae1dd7338d58ba3c46b0cf",
-      "positionFeeFactorForPositiveImpact": "0x69452664e040373e176a46455a6c69626760edcf593b9748b6e49fcdb9207a89",
-      "positionFeeFactorForNegativeImpact": "0x821b76dbcb68243ea72fd9f2f17fe6b225854dda300a06e396d151a436a4bfb5",
+      "positionFeeFactorForBalanceWasImproved": "0x69452664e040373e176a46455a6c69626760edcf593b9748b6e49fcdb9207a89",
+      "positionFeeFactorForBalanceWasNotImproved": "0x821b76dbcb68243ea72fd9f2f17fe6b225854dda300a06e396d151a436a4bfb5",
       "positionImpactFactorPositive": "0x2478343077084acd3c7216ac2b5c943c00327604671cda4c7972e45006652fc9",
       "positionImpactFactorNegative": "0x6cf62baa4a882cd293413510ffd531011af5693c6d0581ea345c50272f78bfe8",
       "maxPositionImpactFactorPositive": "0xd17fe776c6710be10212b8230e5bc255c13cc6af2b50cac277a13f8c4d6cd675",
       "maxPositionImpactFactorNegative": "0x9516040fbf31d98a9814482b56244c126fbf03066c9b2d2c2f8a456b1453fd77",
       "maxPositionImpactFactorForLiquidations": "0x3e8a22ffba6968744d62efd7de40d2472b6624acad87770d5dd4ef10357b4555",
+      "maxLendableImpactFactor": "0x1b745ff1648a88505d8071fd9f56d0ac11fad07ea60590542c7b725466cab15e",
+      "maxLendableImpactFactorForWithdrawals": "0x13e180d1a458621dc1a012653d5c163bfc736196ab576bd438f57fe9ad4936d7",
+      "maxLendableImpactUsd": "0xe4bbdea4d6f47bfe9357d37aee197ecc5b66673f6c585cb4cc723a12dd0557dd",
+      "lentPositionImpactPoolAmount": "0xea50da76a92602c6f9614ea72225692565cba936381d848c8c6ad83e2bde49ba",
       "minCollateralFactor": "0xde6358bbb99972ed5e13eab04486dbe4a4fc8610e3b7c77b120e6bd807cd78b4",
+      "minCollateralFactorForLiquidation": "0xb62e8ac26d1c39798214c05ecd3b4d2dc5d3af8866088b3f315949b47730a843",
       "minCollateralFactorForOpenInterestLong": "0xe51ceab2786b6da44608fcf1c9da64d1760bf55d57ff7ea1f9376b82886cbb20",
       "minCollateralFactorForOpenInterestShort": "0xb0560b186b7882b503fcbe17a89c5103ccfa322beb5d1f323dc56c929db3ab3e",
       "positionImpactExponentFactor": "0xb5eece59faa64c0cdbc8ee882453fb67959494a8c73137a924d203b375a1468e",
-      "swapFeeFactorForPositiveImpact": "0xbee33858c2f53747681135515053cc556c047320c641ae43bf2ff98c77b29113",
-      "swapFeeFactorForNegativeImpact": "0x0bfde157fd2ee3277abf7b7ff6c1c7fab4f935d0af6f51626219ff39a43792c2",
+      "swapFeeFactorForBalanceWasImproved": "0xbee33858c2f53747681135515053cc556c047320c641ae43bf2ff98c77b29113",
+      "swapFeeFactorForBalanceWasNotImproved": "0x0bfde157fd2ee3277abf7b7ff6c1c7fab4f935d0af6f51626219ff39a43792c2",
+      "atomicSwapFeeFactor": "0xd73ce0d7096bf317aa16e7d1245e8e75965719f1f557bad58a9c567a6b75bd19",
       "swapImpactFactorPositive": "0xd4a5ae415f77d62783af1a2f28e78949cc864fd201805dbe149f5ba71a7bb5f0",
       "swapImpactFactorNegative": "0xfca9588687c74abf7fbde4beebb4a829136a5a82f3f370b2de4e0c73e1579aac",
       "swapImpactExponentFactor": "0xcc0d3d97121bf02f0c85acadcb5e1374d48fc36af6657caa2fc4147b1cc61ff5",
@@ -2530,19 +3000,25 @@
       "maxFundingFactorPerSecond": "0x5a28cc017bae74342dc55e0306a1689f0ebd446d7a5fd1e4f69c62e6bb7d1e45",
       "maxPnlFactorForTradersLong": "0x7ee64b10ca3672add3b5595621a0a85b1464e5baa88109cf21dd92d2de7b37f1",
       "maxPnlFactorForTradersShort": "0x44444fe884bda49dea6f16541f03a6f19bc4816a798201061bcc080868400340",
-      "positionFeeFactorForPositiveImpact": "0x4213ddb8b15cfe22e449464885b90c34587d1348102935814128d4f93564924d",
-      "positionFeeFactorForNegativeImpact": "0x24284ef4308f320d77eabb3547f89f1511230c1f7623cd72bcc5ce402ead1526",
+      "positionFeeFactorForBalanceWasImproved": "0x4213ddb8b15cfe22e449464885b90c34587d1348102935814128d4f93564924d",
+      "positionFeeFactorForBalanceWasNotImproved": "0x24284ef4308f320d77eabb3547f89f1511230c1f7623cd72bcc5ce402ead1526",
       "positionImpactFactorPositive": "0x7f3f29d1890b46600da48478685b3d055d9a4d094541f910d3c572bd6ffbcd18",
       "positionImpactFactorNegative": "0x05fc07d81775825dd074d3658bb264d33c01c3ca320ebb478359e5d42f42e10d",
       "maxPositionImpactFactorPositive": "0xf859b25857e23b61ee284c499197fb6f73683db766cd2b2637edd28191f7e629",
       "maxPositionImpactFactorNegative": "0x0e36c4bf7768cf3820f171278211a65d274cc60972a4f72ea6c28f3836763f53",
       "maxPositionImpactFactorForLiquidations": "0xf74bf32733bb1d7982b56ad9de64a3908e498950b3f5dfc5014b11b0a824c574",
+      "maxLendableImpactFactor": "0x4e8f427a15641a64d02c069e41212d767f084cf5beb7cdeee73087b51caa18d3",
+      "maxLendableImpactFactorForWithdrawals": "0x88f85dfc2b759826e747760206e5bb4ace1299758e3b3bd5627bf8306211d108",
+      "maxLendableImpactUsd": "0x7a6801727c0d162294cc14fa0727bf7580c8c9ad479bd4c1f1725b4d6c6641f2",
+      "lentPositionImpactPoolAmount": "0x3beb34e325a0559ba81778d8f79289d78330d8ee206d1dcb858d5cf69e152e2d",
       "minCollateralFactor": "0xa8f02a22712a973ce74cc208414ed1f87bff38cccb528fe8aa5dfaaac33387ff",
+      "minCollateralFactorForLiquidation": "0x4d588606a1bcba8846d247f4195a5ef8db551e3172b7588dda7a762c4b02dc5c",
       "minCollateralFactorForOpenInterestLong": "0xf326ae64850d57c362abbe3e1a2223c94f4a69b17e96139800b5016fe434d4ba",
       "minCollateralFactorForOpenInterestShort": "0x1140f50b1bdc82bc058279354f46501bfbec07ddf4351360e7fa48c5b974f4f5",
       "positionImpactExponentFactor": "0x024d5e4b55579b3102b32e4abfad4d3ea602e20e4ee9e2f3c8b64f3724f0f580",
-      "swapFeeFactorForPositiveImpact": "0xa18cd10451678dd24a842554853984bdea8ee65419c7424c47fbdacee4ada0d4",
-      "swapFeeFactorForNegativeImpact": "0xb49a685327e0d1c29eec16feea9c99a0d4d0b5e7ed7de8c46fb83c37ab54cedc",
+      "swapFeeFactorForBalanceWasImproved": "0xa18cd10451678dd24a842554853984bdea8ee65419c7424c47fbdacee4ada0d4",
+      "swapFeeFactorForBalanceWasNotImproved": "0xb49a685327e0d1c29eec16feea9c99a0d4d0b5e7ed7de8c46fb83c37ab54cedc",
+      "atomicSwapFeeFactor": "0xfbff4d8c9a7c549991c154234f48ef32736e27536dc2cc91124e03e3f1ee71ec",
       "swapImpactFactorPositive": "0x04d496484fc2cfc2e5031d2700045b81467c218ed0e70e99c4c5964389cd3fe2",
       "swapImpactFactorNegative": "0xc7bdfaea94692f0b55dbdaafc9983db489cbc376bf88b3776f57f175713b2ed7",
       "swapImpactExponentFactor": "0x18b3c48e49fb23c5a671425c0b1af3954268b0036dc606c5226b29e608b09f8d",
@@ -2580,19 +3056,25 @@
       "maxFundingFactorPerSecond": "0x2dd5ac4c1223f9d1263588914bea5e89f3e0e779408819eb63989dba9e247547",
       "maxPnlFactorForTradersLong": "0x247c69fdf78c9dfad71d03fc086389723570353fbc52843b757c314410b003a3",
       "maxPnlFactorForTradersShort": "0x7cc5c8fcda211a9b92cd626a408e3fbc393f0c4ea81281a504770dbe89999911",
-      "positionFeeFactorForPositiveImpact": "0x9f42b71783cc6ced4d228c3a1cdb3ee53eb1c3934339f151155df532bb4d1a2b",
-      "positionFeeFactorForNegativeImpact": "0xf9f088871c68a5c744fa762744110706e273b6e17c512b9c7c683fe3dc9064c1",
+      "positionFeeFactorForBalanceWasImproved": "0x9f42b71783cc6ced4d228c3a1cdb3ee53eb1c3934339f151155df532bb4d1a2b",
+      "positionFeeFactorForBalanceWasNotImproved": "0xf9f088871c68a5c744fa762744110706e273b6e17c512b9c7c683fe3dc9064c1",
       "positionImpactFactorPositive": "0x10eb2d755e495c24fcd89f3a54b10d05972c0f759d2424c2d6fab44d8cb6e626",
       "positionImpactFactorNegative": "0x48e3f3213c6b90f6705565760463eee86b3cb17c6607f33593ae8eee66567f8f",
       "maxPositionImpactFactorPositive": "0xe24fe8e0a7bf583053b0850fa5a89ae870e0f4c7f1056a941f3c5119e9b626de",
       "maxPositionImpactFactorNegative": "0xea48c7733e09bd6c42892be2c6c63cc52eddf6bd2414e6454843803c853b8a98",
       "maxPositionImpactFactorForLiquidations": "0x1047ffbe213559d8d5e64a95f8b790cf9b5f58837998080930284ebe9d5d167e",
+      "maxLendableImpactFactor": "0x910deff99a9c7c4041bcbe7140c4fbc75eb27109d1643f2ac719094e026cce79",
+      "maxLendableImpactFactorForWithdrawals": "0xd4689134121be2f40b99593ec0c6cfb536e1c4472ab5f317b4e3de13fff577f3",
+      "maxLendableImpactUsd": "0x228ccbaab0faf5b2247fc5c7bb3bdf152ea87deef6a048ee3d574242d15823ed",
+      "lentPositionImpactPoolAmount": "0x1f58ff2d1f061a9d3a0c9565f5ece4f09b6f5e0fd60e8d9b97aeec70eaea0628",
       "minCollateralFactor": "0x381baf1ffa3e7466635bafa799da30f2b9b7d274d6c5373aed1627655f1c84cc",
+      "minCollateralFactorForLiquidation": "0x09f7ab7442e66755f5bfd66d2e3eb08ec1ce60a9fe6f6369b638528f70c6e25f",
       "minCollateralFactorForOpenInterestLong": "0x7c973b82d160218ec7405501b5ddc34bb772866294bff340a0046a665e2247d3",
       "minCollateralFactorForOpenInterestShort": "0xd3f8f45c87c1735b5bd16535061d0f4515b1e7f673b9877125011e406f02c6ee",
       "positionImpactExponentFactor": "0x2987c92bacb9397e9b34e5f025f773730c282ee0ee4d7af7955d65f401508660",
-      "swapFeeFactorForPositiveImpact": "0x588f3720f115097a80ad6bce732ba1b277c43fd71d9bd09abb31b5ec5ecc4244",
-      "swapFeeFactorForNegativeImpact": "0xcac53996c0bcd4b4376d5cca41f5ec9258a4d089c1b0362ece54643a97a16547",
+      "swapFeeFactorForBalanceWasImproved": "0x588f3720f115097a80ad6bce732ba1b277c43fd71d9bd09abb31b5ec5ecc4244",
+      "swapFeeFactorForBalanceWasNotImproved": "0xcac53996c0bcd4b4376d5cca41f5ec9258a4d089c1b0362ece54643a97a16547",
+      "atomicSwapFeeFactor": "0xcf6703dd9a4ed9e9beeb69c09936e37c791dc0114c3fa334fad308359fdcc2d9",
       "swapImpactFactorPositive": "0x2a5710804a712f5b0eb07536474d337dc633791ed8ab8adf49ade86114305f9d",
       "swapImpactFactorNegative": "0xbc15a6da3861fdc596e77225e3d77376b10df0f3f60809dee735fa659a3a094f",
       "swapImpactExponentFactor": "0xe14778e61202b7041ed3f62be736053b6b0bb768dbe225f6b6593f8d04c89c97",
@@ -2630,19 +3112,25 @@
       "maxFundingFactorPerSecond": "0x3f5f9c81a311ffb195588d8d2a1406b6be0843e754ead6c42d4e3a9a228958d0",
       "maxPnlFactorForTradersLong": "0x50f46e76f53049cbfac213b70bbaa631e0b7f6ec49d7e8f4ceb2ae193c7e6686",
       "maxPnlFactorForTradersShort": "0x90d010e60b9c6c085d351ee1bb8b290ccae5fbf0f488a39c8425d8996cc7b7b0",
-      "positionFeeFactorForPositiveImpact": "0x3a1710a087639aa8cd40aa7622d69edc8b5aeda3d09b2050db1191033990a818",
-      "positionFeeFactorForNegativeImpact": "0x3def1740be201793d19f1907d81f57467fe3358a18a0f657b2c26dbb7633a398",
+      "positionFeeFactorForBalanceWasImproved": "0x3a1710a087639aa8cd40aa7622d69edc8b5aeda3d09b2050db1191033990a818",
+      "positionFeeFactorForBalanceWasNotImproved": "0x3def1740be201793d19f1907d81f57467fe3358a18a0f657b2c26dbb7633a398",
       "positionImpactFactorPositive": "0x55ade57dff077ae0cfbc8e7e87dac0abee5631f5854005f418ee719fcd9a1de4",
       "positionImpactFactorNegative": "0x1574bbdec27482f6cd0b9503c89d23f2ffb3fa62ea5c2409cc0f453213464031",
       "maxPositionImpactFactorPositive": "0x9e02885d6622621808b0428cad1e6f86b729d3743d3f4917ca6887d62137b8a9",
       "maxPositionImpactFactorNegative": "0x5fcadf11f64a3fd603c4947b84d914fcf8213538b9a8108cb154f3826d849cb8",
       "maxPositionImpactFactorForLiquidations": "0x6215ceff639dd1317d038fbaaef7e547ab0a4bcc7797721073a0d8aa4787df86",
+      "maxLendableImpactFactor": "0xdaaf876a03460b3249d6fed5b583e70757f5483e9fa0198c32ccb8a3a959750f",
+      "maxLendableImpactFactorForWithdrawals": "0x33df74336a7404127079f5c81aa656bce170179bba7b35e9563f727c6859bdcc",
+      "maxLendableImpactUsd": "0x3101e2eeb89e61a703e9aa3a52542bd271dcf019a3025afc14196a278393fd9a",
+      "lentPositionImpactPoolAmount": "0xdde34cc0979d43c77785df3be9a3547fe1ab41cac5d582ef9d999bcb1dfab87a",
       "minCollateralFactor": "0x20d8ab78d0283316afeab33bf731344b07da86f7203514d76ee23baee753707e",
+      "minCollateralFactorForLiquidation": "0x4678d0672e6f710a1b949e87f9d131a666582b002ba33e4611370cb314c4fbbe",
       "minCollateralFactorForOpenInterestLong": "0xb67d83d1aa168418e39a9e63db05fc226ef950870c88cef6489ba60614555ec3",
       "minCollateralFactorForOpenInterestShort": "0x3fa9ef62043d4b2c98b738e3e792a2cd7dfa6a906403619d068417f199d3e51d",
       "positionImpactExponentFactor": "0xf40ffc6279286522266a0f262193cd2f2e3ab58182dd4ac525ffa47de5d45fac",
-      "swapFeeFactorForPositiveImpact": "0x5e06aa364ca3ec60ae841d9563ab289f341be788b71e1195751a1f5a6608d83f",
-      "swapFeeFactorForNegativeImpact": "0x379a330b77e5901172434cb0ea61bccadbe9ccddbe4c4b44574312ca7e8f9cf4",
+      "swapFeeFactorForBalanceWasImproved": "0x5e06aa364ca3ec60ae841d9563ab289f341be788b71e1195751a1f5a6608d83f",
+      "swapFeeFactorForBalanceWasNotImproved": "0x379a330b77e5901172434cb0ea61bccadbe9ccddbe4c4b44574312ca7e8f9cf4",
+      "atomicSwapFeeFactor": "0x2caf89716bc0a40f6c0098a2797798ec47de5f269eed4bb0766c6a14e1a80180",
       "swapImpactFactorPositive": "0x4dfff87fbccb5b88103d2c18923fe113cabf5ea0683519bdf5aaa014901e5485",
       "swapImpactFactorNegative": "0x948eb486fa79aecc31b6f33201e895a7a280dd196b0d44d58826f51052959432",
       "swapImpactExponentFactor": "0x473b14d18453e5f6b724e70e5f3d9a89099d805d920a15c6bc678e9d4432d1f0",
@@ -2680,19 +3168,25 @@
       "maxFundingFactorPerSecond": "0x4ee72ac3d07cc7996644888cd430c9b2af6663ade143269b0f163c30e60711b1",
       "maxPnlFactorForTradersLong": "0x2007ac1281a64c05a58188dcc4746347dc8baf24093eae44e9d0adf74e2aa161",
       "maxPnlFactorForTradersShort": "0x258ea651931bbfbd89ab1b0c50961f9af713c552128cd62335d38f7454fb3e7c",
-      "positionFeeFactorForPositiveImpact": "0x7f6b38e2af31f0e1d6193d5cafffacbf10ce3c9e34654d9a6d8e012c3d23dae1",
-      "positionFeeFactorForNegativeImpact": "0x9ee47e77eb16355b9e0f26f0b3d35d3007c23828886d90fbbfef792d34c83613",
+      "positionFeeFactorForBalanceWasImproved": "0x7f6b38e2af31f0e1d6193d5cafffacbf10ce3c9e34654d9a6d8e012c3d23dae1",
+      "positionFeeFactorForBalanceWasNotImproved": "0x9ee47e77eb16355b9e0f26f0b3d35d3007c23828886d90fbbfef792d34c83613",
       "positionImpactFactorPositive": "0xa6b8dc22fae5a3a3d30c9dc1fc679924822f3ce06151f15e5a699d28f4c5090a",
       "positionImpactFactorNegative": "0x2b7ab6b910c3fd27027b1fe63a7d384342777c75bfa768d924743b609662362c",
       "maxPositionImpactFactorPositive": "0x68831a394cdb16c32bf312f5c948d383c58754a438caaaf51383d97ab6c97e4d",
       "maxPositionImpactFactorNegative": "0x18e0e262a34ad1142f0be76b66ed8c655241d4b2d0e4f2d453b1fe347d1b21c7",
       "maxPositionImpactFactorForLiquidations": "0x190906736b8dfbfb8905e01464105472a332ab43303122acea7d280f99a89e58",
+      "maxLendableImpactFactor": "0x81e057e65b35d424b515c9d77bf4026c3427d140b9419c6200ba809dd4f2f419",
+      "maxLendableImpactFactorForWithdrawals": "0x906e115c1e1eb40ac022f964967ddeeba02b0c78951d5e016a2286fe6a611cd1",
+      "maxLendableImpactUsd": "0x31d2e65ebed0c8f9c4a1c7647640fcb6cd873429e923ab11432bad93b9f5098b",
+      "lentPositionImpactPoolAmount": "0xe4484870a22e98ab6bc91ffea8cc17b8e03faee4c909bf126db859dde45bcacf",
       "minCollateralFactor": "0x464c137d7e96e96fcec38af328f9f2e20e1ec3ca751b7e347850ba39d3c519c2",
+      "minCollateralFactorForLiquidation": "0x63f56c8c49720b8c624535a0612b2838aa6c2fd809d28660be826e5593a84ab5",
       "minCollateralFactorForOpenInterestLong": "0xac1d1a8dd04b4b1ce72264801861bb8c24d7085a54a992bd00af1c678dab9606",
       "minCollateralFactorForOpenInterestShort": "0xeb291f3c33fe4214bc3c2127cb7b4e5531517e60b055d0cef9f35e20144b85ad",
       "positionImpactExponentFactor": "0xe2a98a7ee53e527429ff24a4bc99e39428f49da9eb48d9cce1b3814e1fe30893",
-      "swapFeeFactorForPositiveImpact": "0x7c8c38c435c69d053cda438aec9ba9b3b04cbed369c8ebf00855a4e5fe237e1c",
-      "swapFeeFactorForNegativeImpact": "0x520be5e89bd1667cf2473019ce4efe8c6c8844418027fbdb89c72725fc7c87f6",
+      "swapFeeFactorForBalanceWasImproved": "0x7c8c38c435c69d053cda438aec9ba9b3b04cbed369c8ebf00855a4e5fe237e1c",
+      "swapFeeFactorForBalanceWasNotImproved": "0x520be5e89bd1667cf2473019ce4efe8c6c8844418027fbdb89c72725fc7c87f6",
+      "atomicSwapFeeFactor": "0xb649f84aef632b821933f087fdf47095e2959db56fff928b569c0034c646a71e",
       "swapImpactFactorPositive": "0x5c8a37f30c9ecc13ee46d77b70d4331b6132fc1d387d3d6c8b4874daa9e45ee3",
       "swapImpactFactorNegative": "0x728f7a1b5e5c7393136e513b4f434934682e69750993b9eda930b21a7aced4f7",
       "swapImpactExponentFactor": "0x03c6473283fff9db0ddb65c7c99aef8132d1fb0ec5ec7bc0b2438ccf1f74345d",
@@ -2730,19 +3224,25 @@
       "maxFundingFactorPerSecond": "0xb00a848de94a4e84ad04a054b52b29dbeecffdded85d5bfe0937842fa610f9c4",
       "maxPnlFactorForTradersLong": "0x09bf3a2601ed70a79d530344658e77d36302a0255588684fb388734a57452389",
       "maxPnlFactorForTradersShort": "0x3cd79d723dadb79c31c7239fed102b724ce23ffe698a6df53486cfcf2bc4e980",
-      "positionFeeFactorForPositiveImpact": "0x8d56dcf0c488d0b86f23175f78a65a0c4b91eb4c7781b4f4c0c475159b64324d",
-      "positionFeeFactorForNegativeImpact": "0xd1af617cd6a3e2647dc6d7425372ea0a453f414ae9e49b372f3b1cb97cfff5b8",
+      "positionFeeFactorForBalanceWasImproved": "0x8d56dcf0c488d0b86f23175f78a65a0c4b91eb4c7781b4f4c0c475159b64324d",
+      "positionFeeFactorForBalanceWasNotImproved": "0xd1af617cd6a3e2647dc6d7425372ea0a453f414ae9e49b372f3b1cb97cfff5b8",
       "positionImpactFactorPositive": "0x56832fc87dbbbc799267fec5d6f05ef0d548d625dfb016efc230a8ff62dba3c3",
       "positionImpactFactorNegative": "0x75fc8c5f45563729360cb9c59219ae3a7ba5e7fa35881282062efd1bda8ffa22",
       "maxPositionImpactFactorPositive": "0x4830dab4380c54ddb0ef53e357ed6fa3a58a90317544a59a3a4672828f16a9c6",
       "maxPositionImpactFactorNegative": "0x84a8dab8863b30af4f8f17deeb4e8e04e13f946d4486fa1865ac74974b5ad824",
       "maxPositionImpactFactorForLiquidations": "0x2a86139fe39821bccc6fd82f93be035edc70f4cb61cdae30917956b8ffce8243",
+      "maxLendableImpactFactor": "0x7b2838de670aaddf75fc39a8e07ebb8b9ee6df9ff61c2818e8aea056458b8ba8",
+      "maxLendableImpactFactorForWithdrawals": "0x6ff0d20259999b453cd3b269bd10324de0c37d28038acbbf876429482dc00a97",
+      "maxLendableImpactUsd": "0x8a6e25ea26a52c10705407eb6152e0047ebf18a901143d38d52873163db1a069",
+      "lentPositionImpactPoolAmount": "0x85c402443e027e0899d4cc1f1a5da2f11c01067263bc00bc9ccbb1a605e83cfa",
       "minCollateralFactor": "0x68a19f588c4ad0d3e1ee1c870ff0c3d4600a57e7be82732621425395992cbde1",
+      "minCollateralFactorForLiquidation": "0x7bfa38b3b418ccf0e7148ef4f83761ef84dfac2ede0009121e61a79cca9a8869",
       "minCollateralFactorForOpenInterestLong": "0x3b95e2164fa00e54a136f46ac7791ab382b33ca305385943a18908b26110b691",
       "minCollateralFactorForOpenInterestShort": "0x92f543ff91b7e17ebe09b0a5632ba8fe800907683b0400e11b507585b22485dc",
       "positionImpactExponentFactor": "0x0fff84ee08b85a7dc2f7064113bb23bba06f731bfb6fcaf0b0924fdb86198310",
-      "swapFeeFactorForPositiveImpact": "0x10a5906caf61db02617a22f487386bcaa73018c7170652ac5f829a8d9fc61204",
-      "swapFeeFactorForNegativeImpact": "0xd9cfb7f87d3d639a348d35889198ee8deab2cf9d84a50e57dda704d84fd6e960",
+      "swapFeeFactorForBalanceWasImproved": "0x10a5906caf61db02617a22f487386bcaa73018c7170652ac5f829a8d9fc61204",
+      "swapFeeFactorForBalanceWasNotImproved": "0xd9cfb7f87d3d639a348d35889198ee8deab2cf9d84a50e57dda704d84fd6e960",
+      "atomicSwapFeeFactor": "0x061c448fae50d49a8f50a8d32e134e7649e6a815cc71e5341389655a702cf9a1",
       "swapImpactFactorPositive": "0x1ca2c01d2280bd5ce2953044135a4ac1612cbc1e51eb4789094d5277695ea547",
       "swapImpactFactorNegative": "0x12d72f558e812074fe92ca12d0b09ec2fce12f75ad277ade95bb96d90d0d5feb",
       "swapImpactExponentFactor": "0xffff85ac1f617e96d26113e10310a0d3c45e80b4eddf6522fe7c3ffaa18483a5",
@@ -2780,19 +3280,25 @@
       "maxFundingFactorPerSecond": "0x1221c040547c0b2c832ae1ae21ea71b6cfe703bbcce79da15d6bfb97b8fce14d",
       "maxPnlFactorForTradersLong": "0xd0c316afb75722d83ac95f036d09c9c42e2875fd6ea447493e057d14d21cfc83",
       "maxPnlFactorForTradersShort": "0x556e053b351738204ceb961c323050c2dcb5b167160fbec74dcef7ac665ce1a8",
-      "positionFeeFactorForPositiveImpact": "0xaccd9226cb98a1157f4dd7aaa3bca3867c8711717f02e1024679623e69ef1267",
-      "positionFeeFactorForNegativeImpact": "0x1b389553bcb979e53eefe32cf5b32de096277c55c6a9fb516e998e1d29483f8d",
+      "positionFeeFactorForBalanceWasImproved": "0xaccd9226cb98a1157f4dd7aaa3bca3867c8711717f02e1024679623e69ef1267",
+      "positionFeeFactorForBalanceWasNotImproved": "0x1b389553bcb979e53eefe32cf5b32de096277c55c6a9fb516e998e1d29483f8d",
       "positionImpactFactorPositive": "0xafeb1e085d75e737b9082bafa645b5ff9d88c86101ce1eb9bf53086eda79fce4",
       "positionImpactFactorNegative": "0xeeb2de5e802c7deefc7506ee2ed78ef90c42f81562339b7ac4dbf9989c8c66f6",
       "maxPositionImpactFactorPositive": "0x951fa1a7252ce2217d6e71fdf8b445f94f389b7b73ecf1297df051acf958fbc3",
       "maxPositionImpactFactorNegative": "0xe7b058ca894961f4f40dc9e2566920dfce773f64c438b5d415c1176f92a8b4bd",
       "maxPositionImpactFactorForLiquidations": "0x6aac356dc62435be1465f2f736baa23e6ee3db9636a0dadfa42494493729693f",
+      "maxLendableImpactFactor": "0xd8bd66997d12ba501a38b32b2d8f229fc3de3d67c9244a6153ab1183468f20c7",
+      "maxLendableImpactFactorForWithdrawals": "0x519789779c6ac9e09dac42534471068f2f66ba3af0bf3e9bbcc7f5dcb8723c1f",
+      "maxLendableImpactUsd": "0x67d08113992d07e0d31c1d901044d8106805e2b0a9dad9bf7bc799ef06417e53",
+      "lentPositionImpactPoolAmount": "0xb9f3834e621a32b9f4c7d0935a0df69c6c0e74699f08124b521a99bd395a6ea4",
       "minCollateralFactor": "0xf57f95847b05863e3bb30297592097fcf7c8b2a2e25dec83ec531b914747bb4b",
+      "minCollateralFactorForLiquidation": "0xda84c5039b11ba8791d306f10ba8eb5897908ddfb3553dd90ae15b19a34558ea",
       "minCollateralFactorForOpenInterestLong": "0x7ee7a2ce8cf97ae51b250ef153c4e47b752fe2a51865364cd7e5e0d96213560a",
       "minCollateralFactorForOpenInterestShort": "0x038f5c86febee95ef8fa08667309942a2242cce1fd1b73e5c9f889fb199e8bc5",
       "positionImpactExponentFactor": "0xf20108440f12472008e2502eb559780bec72ab8a376f5f4ce9d978642f37134f",
-      "swapFeeFactorForPositiveImpact": "0xa3be727905b20731888cc2db25d31e4e8a41bbeaedb036c2aeb9570b03eade4a",
-      "swapFeeFactorForNegativeImpact": "0x73f6253a8128c8d5eb5486d65b6bbef9e92a29d142827a94e16d7c1e0d1c8c78",
+      "swapFeeFactorForBalanceWasImproved": "0xa3be727905b20731888cc2db25d31e4e8a41bbeaedb036c2aeb9570b03eade4a",
+      "swapFeeFactorForBalanceWasNotImproved": "0x73f6253a8128c8d5eb5486d65b6bbef9e92a29d142827a94e16d7c1e0d1c8c78",
+      "atomicSwapFeeFactor": "0x69b16fd7680e79a4444e31dc65f69ef65097908b8c7d378fcae8e1fd420204e7",
       "swapImpactFactorPositive": "0x21b32f554b31bdc78df56611840c5b22c3f83e6cf98ccfa40a961b576bb8f27a",
       "swapImpactFactorNegative": "0xc2d2bcf31bf9a8344f5325216298aad7e5db29a9da562598e268aa22650ac8ae",
       "swapImpactExponentFactor": "0xf370325fe03991f22b1bde52e04e37ce1e1f4889f89a8f7de3bc014392280388",
@@ -2830,19 +3336,25 @@
       "maxFundingFactorPerSecond": "0xa716fed1ac79547e9a76aeacfac182f569aa0051b9adce527be60494b1970788",
       "maxPnlFactorForTradersLong": "0xebab50cf54031c7f5a039b99599bd02c6ce508826096b21939bdd5404531adac",
       "maxPnlFactorForTradersShort": "0x739d43d5c438663669936efa064b6da0f27b4cba3025b28bc441d48f9ab5a4bf",
-      "positionFeeFactorForPositiveImpact": "0xcb5daf2eecf37ca9cfb7d2b481dd87a9f2ce982e0f9246e6343002ad028cee96",
-      "positionFeeFactorForNegativeImpact": "0xfa33e9a8d5a686dbe77ec54459519c9f4eb83f3e948e4494952afedc0bbf5905",
+      "positionFeeFactorForBalanceWasImproved": "0xcb5daf2eecf37ca9cfb7d2b481dd87a9f2ce982e0f9246e6343002ad028cee96",
+      "positionFeeFactorForBalanceWasNotImproved": "0xfa33e9a8d5a686dbe77ec54459519c9f4eb83f3e948e4494952afedc0bbf5905",
       "positionImpactFactorPositive": "0x660dafad2e4c7acef21088d044cb91771c793f9ec1ab1ecc89905e726a703017",
       "positionImpactFactorNegative": "0xd5146ea76962da49c37a3cf7cb089ff75f8ac2593f10c4acddabb68005b6e686",
       "maxPositionImpactFactorPositive": "0xdd5137f15d530282126920738b90327f8b0900665509f7244b3f790125559213",
       "maxPositionImpactFactorNegative": "0x2240a4aec542c64a8ce2af813d9ffcce8a3cb53c501e67bb56c19e292105d1ec",
       "maxPositionImpactFactorForLiquidations": "0xa4fe55cb4ba68ec434258ec31884b8f617ae8d1c8f6d0fff7fd9ddb535812722",
+      "maxLendableImpactFactor": "0xaceaa6ad7a40f895b33159fef9d68e6541bae7e2809915eba26d0866ad3a3c7e",
+      "maxLendableImpactFactorForWithdrawals": "0x5dfd61350cb491e144e2503d41570158cb53a420b25d81a1a3c085595ab3ebce",
+      "maxLendableImpactUsd": "0x1a15338129bd487248d0aed2daa8622bd892913b84243c6f2d80e4be9722ea85",
+      "lentPositionImpactPoolAmount": "0x6ba48a6c4030c524de2c59cfbe6b64fee861b42666ad0b6785dc99cb05922fdb",
       "minCollateralFactor": "0x876a4e9018e1ba1655bb96f13e4ca16365b7a5ad565f3f2005205f84cc1df97f",
+      "minCollateralFactorForLiquidation": "0x46faae59a599d91c70cf77626c8a6d97ddf7017fec20821a1d6cdbaa485a9178",
       "minCollateralFactorForOpenInterestLong": "0xdbe85b764eb648e48f9fc7ee2ca91b67515bd3c9e5093fc110b0db61825fc00b",
       "minCollateralFactorForOpenInterestShort": "0x90d4beb803fbe580d51f0aef508be25221595bad32eead1bbf3c93bd37e876e2",
       "positionImpactExponentFactor": "0x1a0c0dc2b23888100da389151b52c1ce3fc7b82e3e5347ff425be72c6fa91b05",
-      "swapFeeFactorForPositiveImpact": "0x18e4dfabef67599963a713e17ab75a97ae9a856c7f928a774b55a854d2e8271c",
-      "swapFeeFactorForNegativeImpact": "0xbcd1f183a9fef531ff9db7158ef135533c7dad2c76a4539fa8ffb261613b5941",
+      "swapFeeFactorForBalanceWasImproved": "0x18e4dfabef67599963a713e17ab75a97ae9a856c7f928a774b55a854d2e8271c",
+      "swapFeeFactorForBalanceWasNotImproved": "0xbcd1f183a9fef531ff9db7158ef135533c7dad2c76a4539fa8ffb261613b5941",
+      "atomicSwapFeeFactor": "0xa80450c5250a5e1c80e3ce7ff5da3a8ad5b40b0206abfcc350e25b68fa9f96a4",
       "swapImpactFactorPositive": "0x8678662699138feac68d6aaeb7318df4d064532ecb21d27591c5329cd16e1df5",
       "swapImpactFactorNegative": "0x37fb6cda1dbc827e2bed64832211f7e3b22fd76d68eafc898864d33e3d28f7d7",
       "swapImpactExponentFactor": "0x3407b3ef7c9e1614bff78ffb8563587f128252bad9a1e0549e50a5f85963b51a",
@@ -2880,19 +3392,25 @@
       "maxFundingFactorPerSecond": "0x5d7e2d74fcbc72cc8ac54171254ef83eeaa67ea9384263799cefc2dea798ff7e",
       "maxPnlFactorForTradersLong": "0x2dd25d7a9185ab192d7157198769a10d3bc22b4adf53a49989ff8b5cc9f22f5c",
       "maxPnlFactorForTradersShort": "0x894227f8a19303a369a7d58c20474e716b64d037c5344c283486f994ef540be3",
-      "positionFeeFactorForPositiveImpact": "0x8de3360a74370e5a1deb4c0584cd2b2a8f370807bca4a40dd63c6bd13677e148",
-      "positionFeeFactorForNegativeImpact": "0x24abce2c1fa286b1f26e955d5c9f81027f81a3e969fe6ac068954c5c7020d495",
+      "positionFeeFactorForBalanceWasImproved": "0x8de3360a74370e5a1deb4c0584cd2b2a8f370807bca4a40dd63c6bd13677e148",
+      "positionFeeFactorForBalanceWasNotImproved": "0x24abce2c1fa286b1f26e955d5c9f81027f81a3e969fe6ac068954c5c7020d495",
       "positionImpactFactorPositive": "0xf0377e82644972b454a3b5daed12bd739ac82c6c2cb07157150bd15940e0fb31",
       "positionImpactFactorNegative": "0x240cdb280108e1b493cfa7a4cb0e18c8b7958c63eaaebe43f11044f3799ff0d7",
       "maxPositionImpactFactorPositive": "0x16df3f537a8c0c960d6eb333e2954d65c3ca572a594869e3d2e770d2ea872c69",
       "maxPositionImpactFactorNegative": "0xf73adfe3484d77447f9965114289574d908d3939379f298a8b6c60c3391f4a70",
       "maxPositionImpactFactorForLiquidations": "0x603199403c207ee830b69e57605b19208e115487aaea260ba310330df2976383",
+      "maxLendableImpactFactor": "0xc27401710cef786e506dc79ea1f00389be98e1816acb10be44c34bb83432e01c",
+      "maxLendableImpactFactorForWithdrawals": "0xad60473e5dec097f1450caba4b97a0d3c5ce91549067ae465f31c08914b1d28a",
+      "maxLendableImpactUsd": "0x503a20bd9e89616ebb0c2f629d49ae2fb07d4552848f62dba0befbc3cfd339f5",
+      "lentPositionImpactPoolAmount": "0xdb09e993c789c1053a7d8d177123604ed860d7331a10cb8fb2e6f0be9f47fb8c",
       "minCollateralFactor": "0xf8b84b1cf5ca5b669e90e9fa97bc22a784f39654433ffaf839591bbb9fba803d",
+      "minCollateralFactorForLiquidation": "0xdccb44a6021a756a790c10935251bd0bc376b3969322208dc9af6c87e11f56b8",
       "minCollateralFactorForOpenInterestLong": "0x74c0a14f2a215ff8ff5908b12fbaa3065d35c06a533007ed5e577223ebf46e4b",
       "minCollateralFactorForOpenInterestShort": "0x94f50bb5bf06625aa0686259c5aaef25ec277ae0d18952431e8a79c424b16c4c",
       "positionImpactExponentFactor": "0x19d95eb25a54270fdff0e791d1ebdbd32acf1ee56f11502fa019a1fad987c154",
-      "swapFeeFactorForPositiveImpact": "0x0b4f9aafd26ffb34fa8ed5f7ac3afcaa2fa8eb3bc6674abf977dcc940b58fef3",
-      "swapFeeFactorForNegativeImpact": "0xd57dd2fb2b0d6bf254f2c7ce4bc34f29a69d0274fdba121d2678558e6aec1ae0",
+      "swapFeeFactorForBalanceWasImproved": "0x0b4f9aafd26ffb34fa8ed5f7ac3afcaa2fa8eb3bc6674abf977dcc940b58fef3",
+      "swapFeeFactorForBalanceWasNotImproved": "0xd57dd2fb2b0d6bf254f2c7ce4bc34f29a69d0274fdba121d2678558e6aec1ae0",
+      "atomicSwapFeeFactor": "0x7e9b13adb16b9ae09bd6f2530cfe171baf41e3e8e18c3fbe63b818aa15cf5f1e",
       "swapImpactFactorPositive": "0xe3b67132e0f4393269e4b1a857cf64173c3f439061273ecf56a280f4c93de89a",
       "swapImpactFactorNegative": "0xbb17be4a833e071fcd118fd099e5441fa4853dd41297654cc57483bad2c4ad04",
       "swapImpactExponentFactor": "0x4583b3c42805ca8a4569db7f9c7e4f9c2afc4a1029672b2c9f1947794f2ea2b5",
@@ -2930,19 +3448,25 @@
       "maxFundingFactorPerSecond": "0xefc3b2ab35080c2dbd038bc152b9a74d5c3b8bdd2fc6bf5dfa1f31e8caa7e985",
       "maxPnlFactorForTradersLong": "0xe75fffd4d448c87a46cca3a9b7098d406e8f3bc9bf311da298a989b6d7d7976d",
       "maxPnlFactorForTradersShort": "0x6c91f5580ab490648e285bdbf7a64d395f922610dbeb6bd3476696c0ffe94b74",
-      "positionFeeFactorForPositiveImpact": "0x246b89f9c45166ddd8149156fc0378e4a85ba91a41847d89e589c775b613f608",
-      "positionFeeFactorForNegativeImpact": "0x2fdd80b2d1a7b2ba121fcc94d39910377653574bb900257f8f16822f91cf36ea",
+      "positionFeeFactorForBalanceWasImproved": "0x246b89f9c45166ddd8149156fc0378e4a85ba91a41847d89e589c775b613f608",
+      "positionFeeFactorForBalanceWasNotImproved": "0x2fdd80b2d1a7b2ba121fcc94d39910377653574bb900257f8f16822f91cf36ea",
       "positionImpactFactorPositive": "0x2a0b4b3beab009559d0ba4e7ebc3ce46814186fa089bceee28a8cabb128b8734",
       "positionImpactFactorNegative": "0xee45a29138dcd27cec55588b13a476457b6f59098697700e870f332212b00ccf",
       "maxPositionImpactFactorPositive": "0x96f96a3dcbac9181d1291533d01cfb863334e4841412fd3bbb89fc252fca1590",
       "maxPositionImpactFactorNegative": "0xd2ec0dd1d422983089f9f513b3ee1983a2771a7d3420becdffb6ecbb6b07e82d",
       "maxPositionImpactFactorForLiquidations": "0xab08f01b9295494f0d6e576dce047ae84eee136a8c3b2c5302812a75c65b018b",
+      "maxLendableImpactFactor": "0xa8f2560e946160759082aaa313cd2c092a0b062e95cc01a2070211a0e9199cf2",
+      "maxLendableImpactFactorForWithdrawals": "0x4a5efe9a5faf160836b4b55a024b41157e0be5a5fd38f96fd854fbf79d809d4f",
+      "maxLendableImpactUsd": "0x70d4966337c2ecb624614d2358cb2865b871651eb6eda2f17d2fcfa80341f90b",
+      "lentPositionImpactPoolAmount": "0xade099a38978b6d93e15dd49561d7f04cded44421f1cadf603ed6359df468c99",
       "minCollateralFactor": "0xe9bee751eeaee778244a0b05e5dea9741d42b8f60a6527812d559db10378364c",
+      "minCollateralFactorForLiquidation": "0xf8251492b7b09de9de757e6c12b0417e0e8afc7471ea341141af2c59de187e55",
       "minCollateralFactorForOpenInterestLong": "0xa588997b3b52f45c5ae3dd23491184ecdd8c73a4a3ad208d2d9b4b83d653cf2e",
       "minCollateralFactorForOpenInterestShort": "0x5b71809f9c6cc7c5456b1a517e15e37bb710f1e8f8178edc89be82aa6922432a",
       "positionImpactExponentFactor": "0xd6579b433a10d66cea53361ab3fd4b674bc36ae60752875ea1bb45c8bb96460b",
-      "swapFeeFactorForPositiveImpact": "0x02db1c795da4d08231be629c36bdd0b0300c763404833b049786d618d4c5cb3b",
-      "swapFeeFactorForNegativeImpact": "0xafc8b06e138caf77b195ea98c6b1454b3d1a80d39a3225b2ccb155c31a8562d8",
+      "swapFeeFactorForBalanceWasImproved": "0x02db1c795da4d08231be629c36bdd0b0300c763404833b049786d618d4c5cb3b",
+      "swapFeeFactorForBalanceWasNotImproved": "0xafc8b06e138caf77b195ea98c6b1454b3d1a80d39a3225b2ccb155c31a8562d8",
+      "atomicSwapFeeFactor": "0x7b40bd1154f0c0b63a4a7e8d0b508e5ed5e8b6f36a99fa352b3d24383cce2d18",
       "swapImpactFactorPositive": "0xd8dccee431a28e96dad6b7fe8268ab59607042762992a7833e78b16764e5239b",
       "swapImpactFactorNegative": "0xbeadf9c02cf8cffd063af197414f3af86d3691554a06b63f4130db8e86501697",
       "swapImpactExponentFactor": "0x0d4f19104c2224d407664311bd165f0ca2089868a3cb81583973aba03af74014",
@@ -2980,19 +3504,25 @@
       "maxFundingFactorPerSecond": "0x571381c79d99d2433da47300740ac2cf56d5f573288d81765d1dcfe1d5509f98",
       "maxPnlFactorForTradersLong": "0x1bc7dcf41411799ea846b1e435d7207e87bd8470d6bcabf006e773c3ccf650b1",
       "maxPnlFactorForTradersShort": "0xa10652486af799bdf9fc52fcd7b78bd2edeae561dbd6921f1f3f01b5a14944bb",
-      "positionFeeFactorForPositiveImpact": "0x485e5ba479fe14d7297e82caa9a6dfebdd1090537a5f3ebc8595a0a0a3e24143",
-      "positionFeeFactorForNegativeImpact": "0x85691dbbbd49dbc8267640716d91d7101c592ba4e5af6e7309067de0bfd2a092",
+      "positionFeeFactorForBalanceWasImproved": "0x485e5ba479fe14d7297e82caa9a6dfebdd1090537a5f3ebc8595a0a0a3e24143",
+      "positionFeeFactorForBalanceWasNotImproved": "0x85691dbbbd49dbc8267640716d91d7101c592ba4e5af6e7309067de0bfd2a092",
       "positionImpactFactorPositive": "0xd807ea14f321cb31d2d947d5ff941382054f9569c4bc7424ea5fb53b7691c4ec",
       "positionImpactFactorNegative": "0x3163150b4a2ddbfc6e2d00a08e2d3db1f1a08878af03cc5f906e4876b7d9412a",
       "maxPositionImpactFactorPositive": "0x82fd63cb2e91678055b06933cdfb846823e9c3b1481501047881465cb095afc2",
       "maxPositionImpactFactorNegative": "0x300e239bc48235396d1fd413d2c8ac9564271f998a2d6d8c76168d4a1a33b3d4",
       "maxPositionImpactFactorForLiquidations": "0x81f46680fdbbaf55d36de372843c18dd236a048355c44468a8e675fb7ef344eb",
+      "maxLendableImpactFactor": "0x6597b060c7043b7ffaf7cb3d929817b3f45c47e81f83b063090d41c1e1e93e75",
+      "maxLendableImpactFactorForWithdrawals": "0x4ffbbfe4b22be85287e38705df449305a9d176cd27e7459cd05d6c3e99443dfa",
+      "maxLendableImpactUsd": "0xd43a5d0f9ad8d80a0df71a21de112f24c8c4b72c397f5e3593fbaede2c1619e2",
+      "lentPositionImpactPoolAmount": "0x82e1b538ca1b185d0b3e0549cd04f483b89663c7b99e60799b9c8ded2ece36d1",
       "minCollateralFactor": "0xe62544109042c59f4f79a7aaa8e44233eb129115b7b113a691ecfe81d6cc82ed",
+      "minCollateralFactorForLiquidation": "0xda36895ddb7fc90ac64dc9ca121874177903db68868ec4aca2e26c9877083fd1",
       "minCollateralFactorForOpenInterestLong": "0x23d5a4de10d52ac5736f00723cb93b596ccb210a54534daf46984afe304838d6",
       "minCollateralFactorForOpenInterestShort": "0x1a58e0ba8fc5c636b76d61a8c60ec71c99b9f3745706c79766c8cf0dcafed224",
       "positionImpactExponentFactor": "0xb9cae052e8bfcce30a99ba0cc4f0812cb630723820d72a1110b112396114aa81",
-      "swapFeeFactorForPositiveImpact": "0x49b65dbdf43ce39b69e841c6230ae6627ceacc9334c4d819b206a8b0ef2d8e6f",
-      "swapFeeFactorForNegativeImpact": "0xf2ba731e689b507ae2035884b13ec6c67d222f165fba0061d615a11954f6e421",
+      "swapFeeFactorForBalanceWasImproved": "0x49b65dbdf43ce39b69e841c6230ae6627ceacc9334c4d819b206a8b0ef2d8e6f",
+      "swapFeeFactorForBalanceWasNotImproved": "0xf2ba731e689b507ae2035884b13ec6c67d222f165fba0061d615a11954f6e421",
+      "atomicSwapFeeFactor": "0xa31641fa0e5934a15bde4d72e8cef277ea19728e3d27bbff3839f1b2292adfd5",
       "swapImpactFactorPositive": "0x9978b4eb0dfa425718a72f52aee70a622401b0ea0398043e50e286fade3369df",
       "swapImpactFactorNegative": "0xe602c87380a47190b95ca4de2c92202818d7e26fa1ca73c8e1005fe7f1d2ce7c",
       "swapImpactExponentFactor": "0x481f384180edf110580d4f79f24c4799599a39b2213198381bbe972e1d64d8a8",
@@ -3030,19 +3560,25 @@
       "maxFundingFactorPerSecond": "0x958ff648969e44b4659d79a393f28042f97cfcfdc8fc698c9010fa1da452fd3f",
       "maxPnlFactorForTradersLong": "0xd8ccd387611f6b39a5f16eb0f13c0835179bf58208af7938f7a6ea98ffcfbfae",
       "maxPnlFactorForTradersShort": "0x626e1b71533247a7b932b107904f1433bbc09b1de4bbd51932958fa8d444f613",
-      "positionFeeFactorForPositiveImpact": "0x3ba3e82158ca7a20ec5ac93874ab157c9467cb8ff224e0b0a1b7e1e2dc21f874",
-      "positionFeeFactorForNegativeImpact": "0x699524c62e892e3db59c9a3c858ed04d9f514dcb47513187c9aad9ae3815269c",
+      "positionFeeFactorForBalanceWasImproved": "0x3ba3e82158ca7a20ec5ac93874ab157c9467cb8ff224e0b0a1b7e1e2dc21f874",
+      "positionFeeFactorForBalanceWasNotImproved": "0x699524c62e892e3db59c9a3c858ed04d9f514dcb47513187c9aad9ae3815269c",
       "positionImpactFactorPositive": "0xdc6271c18394b8a7062c7e9b84361c35e34e920fac4f7e13f9ef1a4595aebb9b",
       "positionImpactFactorNegative": "0x156aa170f4820ef2479670eb20af8fc7ea2e5491f603493dbc2b9070cc948e52",
       "maxPositionImpactFactorPositive": "0xeca13146281a419baa821b94f4498cbc4276ff0992e34aa2737f8fb79b508223",
       "maxPositionImpactFactorNegative": "0x7c36e7cd53d579958cb553bb9fd79face0c9a226720cf88b05c3620ad9c54dda",
       "maxPositionImpactFactorForLiquidations": "0xe1b63d9189f4f9f092128feec975a80cc218a5078db1338445d96c1bf9db4526",
+      "maxLendableImpactFactor": "0x931757e2340ad964545999c2359c1e5034f1254c4a5ee40fbf9a9102bbc1e89b",
+      "maxLendableImpactFactorForWithdrawals": "0x100160edcd2bfedde8802fce2c9f72bfc6c51761e924993cda9f3b3defc0aa32",
+      "maxLendableImpactUsd": "0x3be800af705a3107131e9f2e966fe51e48125a537594aee72f16eba592138a8c",
+      "lentPositionImpactPoolAmount": "0x7720f3c426ac4cf7ddd9a6c889d503d351ad6d7caba452ad52abf2f05bff0e27",
       "minCollateralFactor": "0xc119284ca99194e4d943a6af90e4dd7fb4bb14b050a974fb83142774cba81786",
+      "minCollateralFactorForLiquidation": "0x4e67474f7d9ec9e7dfccdebd0892b8f96bc85a36a16a90e6c8e1a54e85c4817d",
       "minCollateralFactorForOpenInterestLong": "0xdc7d2b11c98f133ad856f4e38b92fae525d6a2ae80ceeb3b420e240dfad9849a",
       "minCollateralFactorForOpenInterestShort": "0x5c5f8d9af53545a1214654f78ad1e9a6ab37aecd5469c2e5c4cbcf8cd2e63551",
       "positionImpactExponentFactor": "0xcc823670635973134c5087c8d47979affcca515532603cc92ebc945c51ed08c4",
-      "swapFeeFactorForPositiveImpact": "0x014fda6121726da59e193a952cc3a1cfd31b925febc198a559b2cc1e4d27f819",
-      "swapFeeFactorForNegativeImpact": "0x1a0c447e52ff673b57162b390edd27e8040ee4be5e52ea646e13630bf98457ba",
+      "swapFeeFactorForBalanceWasImproved": "0x014fda6121726da59e193a952cc3a1cfd31b925febc198a559b2cc1e4d27f819",
+      "swapFeeFactorForBalanceWasNotImproved": "0x1a0c447e52ff673b57162b390edd27e8040ee4be5e52ea646e13630bf98457ba",
+      "atomicSwapFeeFactor": "0xe7b3759bff35df68019e544ae31cdc1a6e3cd561db220208b66e655b27d1c681",
       "swapImpactFactorPositive": "0x2f10e629b89a4e353d8d563afb62870a006f03e0cbd77759101e3e646d7f9631",
       "swapImpactFactorNegative": "0xe6988279f833b1014b0483425d0eb061c1b244073b18b54d1eebf3a9de1f75cb",
       "swapImpactExponentFactor": "0xd4eea362f0a2ac992a6ede6c2defb41e3416cef42c033d97ff2ac8b70db7e3b5",
@@ -3080,19 +3616,25 @@
       "maxFundingFactorPerSecond": "0x2ad9d83577d571a8ce3521912811bf5b7c2770021a2c8af368fe8848a1bc4395",
       "maxPnlFactorForTradersLong": "0x0f01b59ae43dd839e912fd5b24f5406c50afa7c2c37fce4f2268023e9c569959",
       "maxPnlFactorForTradersShort": "0x46626df8db05a87d31252ce589cf2d44633ae1b0a2593ff6e43642ac83380acf",
-      "positionFeeFactorForPositiveImpact": "0xa17412d9fb8836576acf564f6b7d917e2523edc2b22e54160bf847b075938f12",
-      "positionFeeFactorForNegativeImpact": "0xa283b96249bd91fa6bf8027982b11be3b157850d5a7a9409a1bd92993b352d34",
+      "positionFeeFactorForBalanceWasImproved": "0xa17412d9fb8836576acf564f6b7d917e2523edc2b22e54160bf847b075938f12",
+      "positionFeeFactorForBalanceWasNotImproved": "0xa283b96249bd91fa6bf8027982b11be3b157850d5a7a9409a1bd92993b352d34",
       "positionImpactFactorPositive": "0x98286b1d1ff96f67cba51e90d3335fa9395fbffee6ea6d6188f2f4d785fa5730",
       "positionImpactFactorNegative": "0x8a2e5ca0fcd5b03675d20b12386f3b185a06f71604235ef8d305d427e65161cf",
       "maxPositionImpactFactorPositive": "0xc81436f5558cb283c8c590d8b08d2685f138a0a10bf14cf46e547a0bda68720b",
       "maxPositionImpactFactorNegative": "0xb375a902c092145cac64c3a449027132cd12c0e9cef6b72d54024276ab1fd84b",
       "maxPositionImpactFactorForLiquidations": "0xfd8dcd34d1379f246478a28f69d7ffb710935582517b883cc2114ccd8e574e5e",
+      "maxLendableImpactFactor": "0x9a3bf9c78080a358487159a8b6e44275cf31d3137a1097c7d64622757e25d32a",
+      "maxLendableImpactFactorForWithdrawals": "0xa295945573837b377763d6f09ac4ce18ec3eb2557e4292b645d37104a4501184",
+      "maxLendableImpactUsd": "0x03e814c56af2eac103ecfc5e34c139e8bb79c7e6c3e4f00b8173368e6ee22342",
+      "lentPositionImpactPoolAmount": "0x7d30fd1aa9dff7273c9a6073d15e5d3e37037dccbf4862050cad961a4288dcbe",
       "minCollateralFactor": "0xc3b683211f897fd3d5139249aff11aa9339db2b59342fb4dde8b9f241ac744b7",
+      "minCollateralFactorForLiquidation": "0xa4dcc59c9562a3cdb7480e3bbd33b15e0a7272ccf9d3d453df784176ac492b18",
       "minCollateralFactorForOpenInterestLong": "0x632d6bc9d36199ead3660e1d54803d97147abc31e2cac1b18dd386d250f44a2a",
       "minCollateralFactorForOpenInterestShort": "0x03289b688ce32f30e096f9f305f6f1e4d654785db89ccc5a81812876233e02ab",
       "positionImpactExponentFactor": "0x6af5e63b59afc60c71a45a325ded80a245d81947f6c9a9bff20d5f97e402fbc8",
-      "swapFeeFactorForPositiveImpact": "0x4f5ebafeb87725474637f4b264962f556c830765f047576f68ff7e5dde5ba384",
-      "swapFeeFactorForNegativeImpact": "0xec05b3db52f1252fa492f3bfd694cbe7c6b86bfba73abfea88f0a55026e61f3c",
+      "swapFeeFactorForBalanceWasImproved": "0x4f5ebafeb87725474637f4b264962f556c830765f047576f68ff7e5dde5ba384",
+      "swapFeeFactorForBalanceWasNotImproved": "0xec05b3db52f1252fa492f3bfd694cbe7c6b86bfba73abfea88f0a55026e61f3c",
+      "atomicSwapFeeFactor": "0x7d5cd589e9c54faead67eea92b39d394d3dee91b21670112950f08cbc2cee5f5",
       "swapImpactFactorPositive": "0x40d4a5c09e6e2f7d78e3dccf44cdd2813b205c5f57942264bda60aee2add42db",
       "swapImpactFactorNegative": "0x60918f5a146bcc03569cbf6e35e786a85e270d98a4db0043a431be58ecb5a3fc",
       "swapImpactExponentFactor": "0x5c57dc3f5ad0d71a0263608d9d0eb53f3b54328e7d41e272393409353c21bc90",
@@ -3130,19 +3672,25 @@
       "maxFundingFactorPerSecond": "0xb8b59b8e83c4387f3137e1d93b17e05ebb5ee09657a23e38be51a0b166871b30",
       "maxPnlFactorForTradersLong": "0x0db2cfd5722d5941892740a8f929ca0005e95b48a333cede62a8e8baf05312c0",
       "maxPnlFactorForTradersShort": "0x227e06582e069889ac13cbb616d3fdeeae60ecf7f8168d1c6735b88a0e1d43f3",
-      "positionFeeFactorForPositiveImpact": "0xd25728fc562ef369c5f9ca0569746770730f799eaf63c4b0eaa0ec16a272b652",
-      "positionFeeFactorForNegativeImpact": "0xe22b635fa6d9a5d645504462c7a6d08eef0c7bd5fd22a5c51e6fff32ab045a34",
+      "positionFeeFactorForBalanceWasImproved": "0xd25728fc562ef369c5f9ca0569746770730f799eaf63c4b0eaa0ec16a272b652",
+      "positionFeeFactorForBalanceWasNotImproved": "0xe22b635fa6d9a5d645504462c7a6d08eef0c7bd5fd22a5c51e6fff32ab045a34",
       "positionImpactFactorPositive": "0xc6dc725a1219aff8e142a456a399c768a7ba63b3cf8c7bba44991324511dff23",
       "positionImpactFactorNegative": "0xc4425eddf8a89bbd5df8ec5c5f26ef4066769441bb055defcc4171293450155d",
       "maxPositionImpactFactorPositive": "0x8cc4653a53206f190ed9e6141322f03b880455663553ae906eaea51d7f7f9593",
       "maxPositionImpactFactorNegative": "0x8d6cc7722076a7f7c3481a48edef3eb7ae0c3857f46de999989aa6e26f76eb2c",
       "maxPositionImpactFactorForLiquidations": "0x6c6d07eef5df4c62d9a6814f48a7dd355fc4cbef5a22b7cd055286f4c4018eba",
+      "maxLendableImpactFactor": "0x39410aa221bb52fda47a9a9aa5bbc3fc56ac816190b4f2fb9ffbcae10a758041",
+      "maxLendableImpactFactorForWithdrawals": "0x701e4d0f98cc7a405c786c2285854dcefbbb646aa3b7ceeca24c3dbd24e698f9",
+      "maxLendableImpactUsd": "0x9fb3ea52913ff1ff83859b0864d2b69e30ac8e3e7e58b75f0c504add0ed57b4c",
+      "lentPositionImpactPoolAmount": "0x58228cc255c9cdb64eea767639bb2533df63991bb9855e5ac80740d32c1c43cc",
       "minCollateralFactor": "0x74ff3abbabfffd3a5805a7c152e5b6f0d38444c6b1cf3684540fa3faf6f7bf57",
+      "minCollateralFactorForLiquidation": "0x373062bd389b4f542a94179cebaf0e1979ec7f3d420160cf1004f6599899fca1",
       "minCollateralFactorForOpenInterestLong": "0x635e26e9daa2510e295f35fa17f561563e7428351b9282c13d5c56878aa57f83",
       "minCollateralFactorForOpenInterestShort": "0x632cd25d22c65823f350addf0c66e3d333b599100702c61f455fd6404350eebd",
       "positionImpactExponentFactor": "0x3d6458a712d40d0d9feba464a4d7cc2541ceaca6a3cd139baf5acedb67490c82",
-      "swapFeeFactorForPositiveImpact": "0x07679aa91501709e499e12f6f80e0ee1b50c26cf4fe198f1d57b702626c8bc62",
-      "swapFeeFactorForNegativeImpact": "0xe92bea4730d8e0aeddb90dc9ab5aaaa8c2ca3f9602b8cd47d3e73008fc60315f",
+      "swapFeeFactorForBalanceWasImproved": "0x07679aa91501709e499e12f6f80e0ee1b50c26cf4fe198f1d57b702626c8bc62",
+      "swapFeeFactorForBalanceWasNotImproved": "0xe92bea4730d8e0aeddb90dc9ab5aaaa8c2ca3f9602b8cd47d3e73008fc60315f",
+      "atomicSwapFeeFactor": "0x9ffb7fa432de58e38ffdd8a092e66367438d3c576f448a16519c6ea37a68e4a4",
       "swapImpactFactorPositive": "0xe7ce551847a9a3c438d4b9e7a4099b50291bf4ab3242383a4b621ac959238f8d",
       "swapImpactFactorNegative": "0x599c414476937eeb2a4b91d90d9ca824d874a17112d7a5b7a7a7a6f6aad5628a",
       "swapImpactExponentFactor": "0x83b84faad6af2797827d5c92195c971fd812696ebd930863f80db617fab45f4f",
@@ -3180,19 +3728,25 @@
       "maxFundingFactorPerSecond": "0x165feae3bd1ab2eb1c9b96390f8e1fca5e9672ef7dfba842db1fa1ef6565ea1a",
       "maxPnlFactorForTradersLong": "0x77b27385bab5c8d5ed0fa84f2066e56cb9e87c0ba5ba36c35644129d849638dc",
       "maxPnlFactorForTradersShort": "0x0571bc79d5f2e7ac963ef77dcc8db61ab10117ece969811a6111959a54ee76fc",
-      "positionFeeFactorForPositiveImpact": "0x988dfbd600a0d356c99e2d7cdb6472503b3c188edf670ff9baf49bddba8da86b",
-      "positionFeeFactorForNegativeImpact": "0x97be254933fc6763edb5aba3e16fd3195f269f9344ffb3477c65e2557f1b8cff",
+      "positionFeeFactorForBalanceWasImproved": "0x988dfbd600a0d356c99e2d7cdb6472503b3c188edf670ff9baf49bddba8da86b",
+      "positionFeeFactorForBalanceWasNotImproved": "0x97be254933fc6763edb5aba3e16fd3195f269f9344ffb3477c65e2557f1b8cff",
       "positionImpactFactorPositive": "0x2ae31cc08f53dccf910ca8d14bff6f143a1daeb6308c48417e93dab69ba2cf37",
       "positionImpactFactorNegative": "0x939bf505096c7330665342c1763b56d68b607607ea69f5afcc92b2bc753e28db",
       "maxPositionImpactFactorPositive": "0x9feaaedae8e2a793d61085d2d1545f6b03b5ddc48e06a8a4492c2c66701797b9",
       "maxPositionImpactFactorNegative": "0xd2f75c6291a799c429b9fc0ead5e7e999583c93ae7e7dbcd94c693acab115f98",
       "maxPositionImpactFactorForLiquidations": "0x0dc9c6e1420908930d17d95aa2f6b86cbb245c6c47f36b9f8bd7a51a3d82344e",
+      "maxLendableImpactFactor": "0x788f98ffa2190a5988b35dc79455c3e80c54a0c8f6d797588ef056a348ab0c38",
+      "maxLendableImpactFactorForWithdrawals": "0x5184f8265c3a48b345a8c09d321d60ebefc9df83b223ac00fe70440baeb2f23c",
+      "maxLendableImpactUsd": "0x110a45da52b3e7db79bce35164417ea3233f51addcf53ea56a5cb548b3fedbcd",
+      "lentPositionImpactPoolAmount": "0x63a990834e9688db1597465ad191bfc5899c6158d1eb5e56bf0b43b4570ddfb9",
       "minCollateralFactor": "0x331419dea97f8be91933915bded722dd38f3b607cffba6deabf347336fdc3141",
+      "minCollateralFactorForLiquidation": "0x008138086200d4db7f493cd1697d2047828dee4c011532ed6d71a47f71aa6ca6",
       "minCollateralFactorForOpenInterestLong": "0xbc8a5091e0c1ff7f8b613fe045ad5ada27f7f46e2025bd0365840c89e99bbdbc",
       "minCollateralFactorForOpenInterestShort": "0xf612745ffdf98a5dc5d3c7043463ad56ee7554569609b8329755e5dac407e1cf",
       "positionImpactExponentFactor": "0xb9f2ac464580caead32af83210f8ec22c484b3987a0f6a817ed0cb94f08e41fa",
-      "swapFeeFactorForPositiveImpact": "0x8607c2a1d0ee1c4c21a541044c8adb91d9a89509c6c861cd6b9a197f272bcedb",
-      "swapFeeFactorForNegativeImpact": "0x67659dc676411b9d0f40e02dcb934b664abc8f22a45fd6934a1dfd6cfcd9deb1",
+      "swapFeeFactorForBalanceWasImproved": "0x8607c2a1d0ee1c4c21a541044c8adb91d9a89509c6c861cd6b9a197f272bcedb",
+      "swapFeeFactorForBalanceWasNotImproved": "0x67659dc676411b9d0f40e02dcb934b664abc8f22a45fd6934a1dfd6cfcd9deb1",
+      "atomicSwapFeeFactor": "0x064cd155fd94e4059e207e32db7756c0097be19306c57bf61774e0a1024d2d24",
       "swapImpactFactorPositive": "0xc99541a0a2b9d346b58261c0f9438a8b0406a64d5bcd334a1b4671a81191c4a0",
       "swapImpactFactorNegative": "0x6d6b01ffa99d507be49eb5b27911ed5c7682570a8105329a96ac502a102003e1",
       "swapImpactExponentFactor": "0x9bd8fd6fdc873ebcce7344f40df1fe423538ecf2de56154af9d701051d301c29",
@@ -3230,19 +3784,25 @@
       "maxFundingFactorPerSecond": "0x58ece9ebee476c6992b7e4411b02419d81d20383d2f311d307465a9f9e00aa56",
       "maxPnlFactorForTradersLong": "0x0f923bb0dd0946e1050b7ba75dd88bf9967278e4dfe561715889540d385495a2",
       "maxPnlFactorForTradersShort": "0xc9fe228bf6e22c68a23fdd312a66fd5ad61f9ba483081749b95cf2996d66e476",
-      "positionFeeFactorForPositiveImpact": "0x2dfe4e7a40a54d4735a5af55c781797d9b9a06190405585b6df4df42a0bd00b6",
-      "positionFeeFactorForNegativeImpact": "0x92a73e06bc1f50304c5efd275d352907f5e631cb1894e723d750b208b6eb231b",
+      "positionFeeFactorForBalanceWasImproved": "0x2dfe4e7a40a54d4735a5af55c781797d9b9a06190405585b6df4df42a0bd00b6",
+      "positionFeeFactorForBalanceWasNotImproved": "0x92a73e06bc1f50304c5efd275d352907f5e631cb1894e723d750b208b6eb231b",
       "positionImpactFactorPositive": "0xfe23009c84d86851927ecd97ec6347799ff32715b0fe20b75501e126ef8eb443",
       "positionImpactFactorNegative": "0x824d020df218432323640679d977c7c98fe3f3029ccafbd63195aa2422eaf290",
       "maxPositionImpactFactorPositive": "0xb50a00942d131a9cdc67aeb2b021f253c5f7770f1a1ba680495a485f25d9e13b",
       "maxPositionImpactFactorNegative": "0x93e43b69e532e6d6b7788fb09d13d70e2c6e5b1cac594fe1af51e466f3703af7",
       "maxPositionImpactFactorForLiquidations": "0x355b4df66f1c85fa3f11ecb95ce5e55103d0ed24f5670379791a0e82b88352eb",
+      "maxLendableImpactFactor": "0xdad319cf45697bcedde77cfcbe34250d74395c10cca8144e0cd9ce7c3db4a5f9",
+      "maxLendableImpactFactorForWithdrawals": "0xa0dcc39feebd4d40a2fa906c4dd57ad7568e21d02ca7b29f80f2a65cfaba8df7",
+      "maxLendableImpactUsd": "0xc041071fc0ff246cb4e5fb3bdf450e6e15863d4123e7681df11b25b75c0e2e72",
+      "lentPositionImpactPoolAmount": "0x3f8b0002f7421a5195a29a0d8a608e2564aa28856e490bfffdacc955f679bee5",
       "minCollateralFactor": "0x14f519d670ec6e5b2cdef769007dfcac09f7edd6f64da52fddd8a2160f7c51fe",
+      "minCollateralFactorForLiquidation": "0x41ba01e8c89c5d7646bfb600f8196c7bdba39101507971f06b9b0377054a7023",
       "minCollateralFactorForOpenInterestLong": "0x12be7656b291987a3022965d8be409d4ed7feb1d382eeec36e6d67225d120789",
       "minCollateralFactorForOpenInterestShort": "0x5c18aa8765ecd905d817d6f09fc2d40fc0793a5b3e88ef7e071dea5e352eea51",
       "positionImpactExponentFactor": "0x1cda6cde74b36b50f765db60993e7a63bf269f5b217d1279cf5f84cefc42ab75",
-      "swapFeeFactorForPositiveImpact": "0xeb2fab73e9fdff0596c8c72b854279382d79404b4aade537b8b8c1dbf352f45b",
-      "swapFeeFactorForNegativeImpact": "0xf589ab4da11879eaa7be922fbdb14ad14e6be45d55021a50ed0f509c5a5ac0e5",
+      "swapFeeFactorForBalanceWasImproved": "0xeb2fab73e9fdff0596c8c72b854279382d79404b4aade537b8b8c1dbf352f45b",
+      "swapFeeFactorForBalanceWasNotImproved": "0xf589ab4da11879eaa7be922fbdb14ad14e6be45d55021a50ed0f509c5a5ac0e5",
+      "atomicSwapFeeFactor": "0xd23b9d2924fefa998a226ea0487fa1d4c1f94ebe2e71bc8b03b027659190d2a1",
       "swapImpactFactorPositive": "0xb87eba0a263b57b8d2a7dff56d73ab92c164811cd1e56f479690b134e73821ce",
       "swapImpactFactorNegative": "0x21eb71230a7c89a8134055d6cd127bc1cbd69041800989e1a5ee25ee1186e241",
       "swapImpactExponentFactor": "0xbd575e96df4fd1e6eab867ee69312ea37c3b7ee3685992ad7b8c05035c439459",
@@ -3280,19 +3840,25 @@
       "maxFundingFactorPerSecond": "0x54fa90bc24f8ec4d11915477e376d3a3ba2eaff68805cc56f3010ee26ee58df4",
       "maxPnlFactorForTradersLong": "0xc096c65bba34dae39facecb48ff0681b31d49086bb6d5de9b06e8ccc7a4d683d",
       "maxPnlFactorForTradersShort": "0xf52d306b64f46f2b063e645f3774377ec308c0968723bb3ab0fca3423c4d0496",
-      "positionFeeFactorForPositiveImpact": "0x369579ab28cf003f555199fa0ad696810a2b5ce6c6b99b68c651421dccf9eb51",
-      "positionFeeFactorForNegativeImpact": "0xa8007eb5a7381de3671f24aa819ea3b3a78aee7c9af638c0ed219f4a94e006a3",
+      "positionFeeFactorForBalanceWasImproved": "0x369579ab28cf003f555199fa0ad696810a2b5ce6c6b99b68c651421dccf9eb51",
+      "positionFeeFactorForBalanceWasNotImproved": "0xa8007eb5a7381de3671f24aa819ea3b3a78aee7c9af638c0ed219f4a94e006a3",
       "positionImpactFactorPositive": "0xf2b3a944c7ff519fc4a0e90e963750bde57de840a4e834a2bb1c84e7c3e3536c",
       "positionImpactFactorNegative": "0x5d775398a3a1d3decdf0c0b7ff2f38c4245a2585a4bf7e2414b181c550825889",
       "maxPositionImpactFactorPositive": "0xef1ee058e62d2940f4c6bdb5d4284a74a47fdfd67bf40881d81675898d995c53",
       "maxPositionImpactFactorNegative": "0x6ae25f9f315f358886ff70b307f9d4c7642e783156df77121699c12723850724",
       "maxPositionImpactFactorForLiquidations": "0x962ac7fc3cbc4fd8d0aa8dbb670ddc393d37a7f65e15ab52a5324a7d7ec99145",
+      "maxLendableImpactFactor": "0x82e7f2ec187c1ff710ba4e3e47862c411ae48d8830278a64fe9799990f3523a7",
+      "maxLendableImpactFactorForWithdrawals": "0xe0b2a367ae98b305796ad880a05b938d573d1bbbda6b0ad17b8b0979e19e4038",
+      "maxLendableImpactUsd": "0x861ab51a6e050f8f87ea38c363c0dd0daa424191e606a9a3168fa28d926917a1",
+      "lentPositionImpactPoolAmount": "0xc674683266af6726324d60d4d9ab8343d0adedb4e571e32a91fa7faf189464a2",
       "minCollateralFactor": "0x522dce74cbd5b4d440202a34f633bc1a0fad761cc20ccbfd6a6ed661a8e22601",
+      "minCollateralFactorForLiquidation": "0x9b94fc585564e4ce1edae95b097a9949730d58e43dbafd70e0a5c10203b6d9a0",
       "minCollateralFactorForOpenInterestLong": "0x561ab444da9e0a84f33004689eaee0620921f53832690234974beadbb2874c16",
       "minCollateralFactorForOpenInterestShort": "0x9fa2d3d66e68869a791c2035796e490049a5eef5abb51228c8c92aa66eb2abd2",
       "positionImpactExponentFactor": "0x96e4e16197024832d8c5faa031a256a9ce1bc452407a2f713fbfb49a4ea1eb38",
-      "swapFeeFactorForPositiveImpact": "0xa6143605375dc242962140d0c9e0f878d85c68e51a3d8e88fe5a56ca06960270",
-      "swapFeeFactorForNegativeImpact": "0x412275642d4466535fa1e10c5215a27411e8188aacf2c49e83198b5cdf636ebb",
+      "swapFeeFactorForBalanceWasImproved": "0xa6143605375dc242962140d0c9e0f878d85c68e51a3d8e88fe5a56ca06960270",
+      "swapFeeFactorForBalanceWasNotImproved": "0x412275642d4466535fa1e10c5215a27411e8188aacf2c49e83198b5cdf636ebb",
+      "atomicSwapFeeFactor": "0xd240a56b63cd3c73e77f4732bce5e8f1f988d267f3a144307ac69a9f9a5923ba",
       "swapImpactFactorPositive": "0x697ece2ce23e93349986cb04edc1fd3fb4307a573d679f243701ae39bb87132a",
       "swapImpactFactorNegative": "0x19c2660bf05157a6c1248cb90af79be47b7804b52b52bf200a7732aa186c43e0",
       "swapImpactExponentFactor": "0xea094e8717554b6c479bc2c54a4737c25970e30aec419bfc4eb801ad7ee57268",
@@ -3330,19 +3896,25 @@
       "maxFundingFactorPerSecond": "0x5c4885506d3cfcf7c3c3df4da8ba4c32705fbde03ce01fbf66ca63641f5db6e5",
       "maxPnlFactorForTradersLong": "0x878e83953134a8b7aae4a5eb5da30d033850a7ea4d2fdec59d0637637d767f7b",
       "maxPnlFactorForTradersShort": "0xba6beb80a04dabea3486aa3f32e902bf27f5bfbdde4e3123993c5c17e7900097",
-      "positionFeeFactorForPositiveImpact": "0x50e88ebd0aa012a81bca5764a77610505af3166c0f8ecfd5ae63b6357988f677",
-      "positionFeeFactorForNegativeImpact": "0x40f2441d2587c304daeb28a5bdc047acd878b49efa716575ffc8f4a77374d0b6",
+      "positionFeeFactorForBalanceWasImproved": "0x50e88ebd0aa012a81bca5764a77610505af3166c0f8ecfd5ae63b6357988f677",
+      "positionFeeFactorForBalanceWasNotImproved": "0x40f2441d2587c304daeb28a5bdc047acd878b49efa716575ffc8f4a77374d0b6",
       "positionImpactFactorPositive": "0x26b2e3333bc77d9220de66a9684adafda830b2dd3984fc0135d832c9c9aebda2",
       "positionImpactFactorNegative": "0x1d33b34963c591c09fb0dc2f8250ffbb341eb9eb1dd6498b4148137181d6072a",
       "maxPositionImpactFactorPositive": "0xf3bc0955f963d0405f9e49d759d533014c9d06e7e60049c1b11ad3cf51b02cd4",
       "maxPositionImpactFactorNegative": "0xe8584089e60a1fe0f7b9dfd3064915a786668ee667eaae8ab4344ce463488bbf",
       "maxPositionImpactFactorForLiquidations": "0x874f76b33cc43ca63e6bbbccf8d5c047081f0d93bc3c8969584c39c6502afbef",
+      "maxLendableImpactFactor": "0xfd3549353cae50095a9c0773319d142d01774ec32b1132b0160e55da5c4b4489",
+      "maxLendableImpactFactorForWithdrawals": "0xb2fe4bf7818c52e2efafc54a069ceb3ef1bff7e3268efd1ec1d4629f6b50b219",
+      "maxLendableImpactUsd": "0x5c585e7bdc935a88ba8ef289ff518c08d861a30adc519571656489406bb425ed",
+      "lentPositionImpactPoolAmount": "0x2a3c3512270776586d597030cbab06098af2f26b51fca00e5172aa14e922adf0",
       "minCollateralFactor": "0xffdda94c552e89c37aa851adc7a18e6bc47663010a27d83661a2e2fa8492ad71",
+      "minCollateralFactorForLiquidation": "0x3a606eb444659fc6d8703d1f4915560cd0e71813d3c824fbb4634c73002f3d62",
       "minCollateralFactorForOpenInterestLong": "0xcb36c8d66209bda963fcd3a7029ca669b114218607d825722851aa897eba7ee6",
       "minCollateralFactorForOpenInterestShort": "0x53c5a6626ef4a008718fb02907498f647eb955e8d2e9db15607b547a0e9e0d66",
       "positionImpactExponentFactor": "0x6a63ed472aa0faeb03e4fe460e669a1671d1ca63f2fdb32c39f1c11786c97460",
-      "swapFeeFactorForPositiveImpact": "0xea517b49e33c27e75463e484f6c8b1fa64d533a6148e33a64a825cce02e3c6ce",
-      "swapFeeFactorForNegativeImpact": "0xa7d5519d3e5d0ce9c05ec4df62c4b00339295007b40272ed1284c5a9e47bd77a",
+      "swapFeeFactorForBalanceWasImproved": "0xea517b49e33c27e75463e484f6c8b1fa64d533a6148e33a64a825cce02e3c6ce",
+      "swapFeeFactorForBalanceWasNotImproved": "0xa7d5519d3e5d0ce9c05ec4df62c4b00339295007b40272ed1284c5a9e47bd77a",
+      "atomicSwapFeeFactor": "0xec0dc1c5be5c65cc62c6a41e7da4842a8b97475be0f2830a19705061d5d4c5f6",
       "swapImpactFactorPositive": "0x42aaaeae3f86b5e671a389d5b004816565f03a19ee4da5165ac22336d040cad2",
       "swapImpactFactorNegative": "0x33b9b4cb5a208b266e11de020970e508843c67544b51565d15e87b65c6aab0c1",
       "swapImpactExponentFactor": "0x06a8eebde08a6c76b4923730c450d72f3f7ee3bf564be64d693a846e46d222b7",
@@ -3380,19 +3952,25 @@
       "maxFundingFactorPerSecond": "0xb24d1a91550b99c973ce6afa96c6ab8b46696ae228ad5f7df4b9e79527211acc",
       "maxPnlFactorForTradersLong": "0x10abc2fb3642e6b77e373d7feb742ae7b4f43b8d165ccc63ed20cf7be3a38ff4",
       "maxPnlFactorForTradersShort": "0x36f7436deb57e87fb5231f1e926f3c374c28799403850aea708cc0a0b7a13be6",
-      "positionFeeFactorForPositiveImpact": "0x230d558789cdeaad85855af6d57dfb2579792b0e4bb659a8ca77e13403775717",
-      "positionFeeFactorForNegativeImpact": "0x85d3d3c8408ed4186fb1d31418526ce075322c262bd78196a82be5f47f263d5f",
+      "positionFeeFactorForBalanceWasImproved": "0x230d558789cdeaad85855af6d57dfb2579792b0e4bb659a8ca77e13403775717",
+      "positionFeeFactorForBalanceWasNotImproved": "0x85d3d3c8408ed4186fb1d31418526ce075322c262bd78196a82be5f47f263d5f",
       "positionImpactFactorPositive": "0xfb4ed8070ac47be8f9c3ce03faf5c8f0842e961739cd65e3b48883aa4adf73a1",
       "positionImpactFactorNegative": "0x14d2c5a86f041487eb054bdc08827a46d9eef3a079e8275e703ec0b3ac5d7639",
       "maxPositionImpactFactorPositive": "0xd13f53228e8d8bf025faddd4631cc12fd68e4d48f5aa750afad8589402adfa9a",
       "maxPositionImpactFactorNegative": "0x9c35cae350439063045993681f2c2e12a3e12aa11f77d56d357e3ceac618617c",
       "maxPositionImpactFactorForLiquidations": "0x814777913dda7bcd8fa344525f60a2b92045904645614e796279a2a12a91b43e",
+      "maxLendableImpactFactor": "0x0b27f7e85429e3bcdf576b39139a59b5f087b04e4c60934be6752d8650696937",
+      "maxLendableImpactFactorForWithdrawals": "0x0d78b77825c5c0319c860937d6e7913a1cddf33b55d54f3fa399403bc45469a5",
+      "maxLendableImpactUsd": "0xa0313f1f0a8838e9ed03e4b000d76d325bb4291f349abb20adbffe665b0df33d",
+      "lentPositionImpactPoolAmount": "0x82263be6ea01444d31e9f39fff7dbbd91e628f6df2038b89678be6f7f2af6a38",
       "minCollateralFactor": "0x8e3bed4f25e62e79d236e7ab4e5603e7622ef2eec8639585e4244725d8f409bd",
+      "minCollateralFactorForLiquidation": "0x67ae2314c7ad70da1afc2ff6bbc4ce36070db06a532137307b3949db7cdea89d",
       "minCollateralFactorForOpenInterestLong": "0x9b60006748c20ded25ebeb6cb5b8b4fa1637b243173d9721a4ccfbe3101e7de3",
       "minCollateralFactorForOpenInterestShort": "0x348e708289c489fd0cf6075ef11f4fbf37d202d578080b4cd5b8ca83b27d8dff",
       "positionImpactExponentFactor": "0x5069bbbb356975f0360cd8b8e434e3eef837db18168ba1a35726ab20805420b8",
-      "swapFeeFactorForPositiveImpact": "0x2870d390da5ab2fb9809a727bb1edabb063250342120237e7333410a6c0685c7",
-      "swapFeeFactorForNegativeImpact": "0x066947ada18828b53962d49069334357efc7942ad48f56a49ba67ad05f1492cd",
+      "swapFeeFactorForBalanceWasImproved": "0x2870d390da5ab2fb9809a727bb1edabb063250342120237e7333410a6c0685c7",
+      "swapFeeFactorForBalanceWasNotImproved": "0x066947ada18828b53962d49069334357efc7942ad48f56a49ba67ad05f1492cd",
+      "atomicSwapFeeFactor": "0x412adb54031393da1f49f36232cc914b0d967448a86304b21c03b564fd61ed8e",
       "swapImpactFactorPositive": "0xbe6bf34b093a711520a573026f4af33708c3df6b22ab11fcb08a211a8f3651e8",
       "swapImpactFactorNegative": "0xa04e19482a64c2873c80eee75fd5e05a21ea68458c3c31ba6514ceb2e6683954",
       "swapImpactExponentFactor": "0x4d2d86e81fee52bbcadc9b241d3f95a44696c92d2c6d839ced2571b341ecf432",
@@ -3430,19 +4008,25 @@
       "maxFundingFactorPerSecond": "0x080d6f647980e27c4c29eb0fef0259e35b78776eb12952361b643a56d7467a88",
       "maxPnlFactorForTradersLong": "0x5b6bc87065748793b2c2f058783f46c620cb13862d8f7be9c625d32ad3ffb1aa",
       "maxPnlFactorForTradersShort": "0x5df3f831541534cfe8b567244ca81a1d1c17a339c5c44dd9ccf847dd420840ba",
-      "positionFeeFactorForPositiveImpact": "0xe52a6cdd4d02804ca2087972e592e75b4c8448296c882ec0a5bb57428684b465",
-      "positionFeeFactorForNegativeImpact": "0x8af552f6423c82c053f9f9a49d8976fc5bf979f90ffcfe60e48f75efe78159af",
+      "positionFeeFactorForBalanceWasImproved": "0xe52a6cdd4d02804ca2087972e592e75b4c8448296c882ec0a5bb57428684b465",
+      "positionFeeFactorForBalanceWasNotImproved": "0x8af552f6423c82c053f9f9a49d8976fc5bf979f90ffcfe60e48f75efe78159af",
       "positionImpactFactorPositive": "0xd4030afb92b751b6cd3e4c23d70e48accf8185636083706bc6544769347ac75b",
       "positionImpactFactorNegative": "0x4e56928b8af1c4dccfb8cc4fe83564a16bdbd4c86962b7cbd71ed3974d449937",
       "maxPositionImpactFactorPositive": "0x81474e9f281247217a132604837f1a17c01f9718727675aad11a63ff67d7f77e",
       "maxPositionImpactFactorNegative": "0x071ddcdc5940ce06318c56b5bdce3a27847f535f8f0eac190abca1a73af7d02f",
       "maxPositionImpactFactorForLiquidations": "0x65a71358652e1f3f1de3770fe7df2b8400da9e60f8d814ca9a4b13022bee2222",
+      "maxLendableImpactFactor": "0x4226bc69694625b88f1e7ba618f2b5278690afbd7d04d09cd6e3e56adb598b3a",
+      "maxLendableImpactFactorForWithdrawals": "0xa55ea1d8e2d40aabd5bb601806317bae810b955bba23d271d4d45c020248a957",
+      "maxLendableImpactUsd": "0x3121bf7b8abbe87c16343a7a6afae2aa37e63995a487ac70ac184789097a9bd8",
+      "lentPositionImpactPoolAmount": "0x28b49f2cc08c123626db4c83de6905cf697c14932854642d34ebe011ef8bfee6",
       "minCollateralFactor": "0x679fb485dc1559e6adc640756fe4740ee19dee07b8badd48976bdd28a87879e1",
+      "minCollateralFactorForLiquidation": "0xafc489671c1d4873473ecfcb310025d579c1c8ee4205d613c879338f160e3cd8",
       "minCollateralFactorForOpenInterestLong": "0x84677935537cfc967f4cc379eda203039e555599457a5abe92b8d3be4ff80edf",
       "minCollateralFactorForOpenInterestShort": "0x2d128850ff4630e5e64b78a9cc6f155791e11e268c1ee76a65a21a989aaeac95",
       "positionImpactExponentFactor": "0xa5c274264328d204dbd59ba0c0c702d8968334ba38a54e107124afaacad4e265",
-      "swapFeeFactorForPositiveImpact": "0x308a352f40b9c052ce7816de933a0a33bf97cc8e380329add568c24e7266721c",
-      "swapFeeFactorForNegativeImpact": "0x9f6e5823120af6d9685bdd76e8b3305529cf50e322b43f7741bd5e944250a6fb",
+      "swapFeeFactorForBalanceWasImproved": "0x308a352f40b9c052ce7816de933a0a33bf97cc8e380329add568c24e7266721c",
+      "swapFeeFactorForBalanceWasNotImproved": "0x9f6e5823120af6d9685bdd76e8b3305529cf50e322b43f7741bd5e944250a6fb",
+      "atomicSwapFeeFactor": "0xb9c16ab0a352cd7cbdef66c7ec66d6f8c14b0d34563c4e7460065eecffb8422d",
       "swapImpactFactorPositive": "0x6e393cae4a648e5c019243aba3839b664048e7fe1cde4d352859420fd07959b4",
       "swapImpactFactorNegative": "0xc80a493f181476d72d586be4a7737108ccc7e4814d2219f4eff178a556f26fde",
       "swapImpactExponentFactor": "0xf6ae011706747949bc1e24692131acc79ed1463181bfde4014a52621ff41d7b7",
@@ -3480,19 +4064,25 @@
       "maxFundingFactorPerSecond": "0xf41eed297201b32337b5015b04637412f8c7cf877d9207165824065b9ce12642",
       "maxPnlFactorForTradersLong": "0xed40a6622b17aa7f593f513d6c523e1394c152e8444f7d60fb9934ff0a0b3b36",
       "maxPnlFactorForTradersShort": "0x3fab9e7f459753e306a6757c56d8494284da59067b34a6dd4e52c4bcb218000c",
-      "positionFeeFactorForPositiveImpact": "0xab8c6a651eba9a48ac235d445205bbca5713698e9d67bb5ef0dc2f9426e6aa78",
-      "positionFeeFactorForNegativeImpact": "0x032ac540578f841c629bd3639d9e6d77baf2627b1904afafd787db565f967ecb",
+      "positionFeeFactorForBalanceWasImproved": "0xab8c6a651eba9a48ac235d445205bbca5713698e9d67bb5ef0dc2f9426e6aa78",
+      "positionFeeFactorForBalanceWasNotImproved": "0x032ac540578f841c629bd3639d9e6d77baf2627b1904afafd787db565f967ecb",
       "positionImpactFactorPositive": "0xedfc5f812a44c154869cc9f560a95108879fe5d9e62f9412566cc073e134fffd",
       "positionImpactFactorNegative": "0x354deb6c75877b955292480f888e8b3234e16f3f0925fe00ee8498a4d2ba2fae",
       "maxPositionImpactFactorPositive": "0x1eb9f2b1fe7a5cadc30bf113d195fea531766a1f93c49e2aa83237c6608dcc7b",
       "maxPositionImpactFactorNegative": "0xc82616a5adaf7157ed23d8b6e8bede28a99be8cb7856e8eefd9db0176ee5ac92",
       "maxPositionImpactFactorForLiquidations": "0x1a672707fd488daa1eb12975ace82f66a734b02e01aa1301289bd08f8b8f7879",
+      "maxLendableImpactFactor": "0x3cf17adf688ac44c780ab85febad2a468a583e3c3399a220e5e29d1a5e53a6ad",
+      "maxLendableImpactFactorForWithdrawals": "0xa6c9ede03fe1cd0adfb5e47772869d804d2fcf9c944a44174c1679abe50884ac",
+      "maxLendableImpactUsd": "0x3cfe77f5b4887aa393147fe72920ff17c49724b3469e887c91f257f6e35546b3",
+      "lentPositionImpactPoolAmount": "0x44714ed5ca4a8ed1b13348b9bc0e34c9045a5d7184c0d7e8ffa51b2716970a9f",
       "minCollateralFactor": "0x3fe844c40773c125c030590d8b180fc7e7eea4b4620fc68b8933bffaa4c67b4a",
+      "minCollateralFactorForLiquidation": "0xb44f4b78ba17e0d1eff6125cbed7f5c6818e596f01fcd6aab2e739addb731706",
       "minCollateralFactorForOpenInterestLong": "0x6e86a14a179aecf4b9c5d905c249fb4e36fcdaa1976cbaf81acccc340311036d",
       "minCollateralFactorForOpenInterestShort": "0xe4d366912356c807f7849ae1df3147f1e7d208e9fc57e01fa4c2013876d14b79",
       "positionImpactExponentFactor": "0xa3bd98ef7c63272fec0aae30edea3e455dd7d50b81934602367f7325466365d5",
-      "swapFeeFactorForPositiveImpact": "0x13b14819e4af67beb4e9eebd58f4f859b45e51fd720169f4875c52069eaa93eb",
-      "swapFeeFactorForNegativeImpact": "0x041dd49ae33ca7961f20bb8147d5da1eb80300c220f91b5bf5acc56d5ae6aba8",
+      "swapFeeFactorForBalanceWasImproved": "0x13b14819e4af67beb4e9eebd58f4f859b45e51fd720169f4875c52069eaa93eb",
+      "swapFeeFactorForBalanceWasNotImproved": "0x041dd49ae33ca7961f20bb8147d5da1eb80300c220f91b5bf5acc56d5ae6aba8",
+      "atomicSwapFeeFactor": "0x86de7a3b9168b9558a4e968927972ae16bca2c45c79f3c6582d82ac1bd287cd0",
       "swapImpactFactorPositive": "0x3d6d4c367caf6195e2e17ccc844e61bfa11362e807edb31ed40c950aa0778457",
       "swapImpactFactorNegative": "0x630de465fa6597dfddf3012c25720bad36ddc1f3887a52037a864fb66dc66366",
       "swapImpactExponentFactor": "0x00622b30979575d1f66479e09f2f571d422345b18b2408762ad6506cf007dc77",
@@ -3530,19 +4120,25 @@
       "maxFundingFactorPerSecond": "0x9100124446cae7a4786e50ca6761bdf352fc6a3d3204f14e120094302af3f3be",
       "maxPnlFactorForTradersLong": "0x91d5ef2c1dfd5cdeaccda6be41c0e81b5ff5ca1cc70b18964d8838371a1e8b8f",
       "maxPnlFactorForTradersShort": "0xc2e47e1d5f976a489e1e02f890681e390a7dbbb1a75c22b20e8b96fac15f6b7c",
-      "positionFeeFactorForPositiveImpact": "0x17a1a4c5c12a42f5051a147fc90f77a01c548f6fcac70763eabbbda3a65cdd65",
-      "positionFeeFactorForNegativeImpact": "0x76fe7348053bd8f758cd8e4789c39906eeb5d5ce84205afdd1eb44a7a975a9c7",
+      "positionFeeFactorForBalanceWasImproved": "0x17a1a4c5c12a42f5051a147fc90f77a01c548f6fcac70763eabbbda3a65cdd65",
+      "positionFeeFactorForBalanceWasNotImproved": "0x76fe7348053bd8f758cd8e4789c39906eeb5d5ce84205afdd1eb44a7a975a9c7",
       "positionImpactFactorPositive": "0x64da39f22293431948db7537bad61f51ad1777bf4d4d6d4530bffcb919749832",
       "positionImpactFactorNegative": "0xeb28da7fbe5a9e66cfaa0e19a9cfa3f394112a3fa0f8faee75b2f47ac283675a",
       "maxPositionImpactFactorPositive": "0x7420c427b32409f5e82da6c15ead871dd919fcf1e1e92f384802d5bdb4e8c8f7",
       "maxPositionImpactFactorNegative": "0x8503fee7cf10b36db3a5563c313bc4517f5165f26a758cc0017f9ed63275fbbd",
       "maxPositionImpactFactorForLiquidations": "0x95f09f9b51350da41df77fc76f4eee0a9d0463e1594b8cc5f7370edddb01cd61",
+      "maxLendableImpactFactor": "0x770b5fe74d57ef3470e215fa854ee1d1e5b2e48cd5701bd56221ccbd0f5ff5c0",
+      "maxLendableImpactFactorForWithdrawals": "0x73ca53f0d77d24492d2fdc72f88e69576692534e1a53e82437e377791579753c",
+      "maxLendableImpactUsd": "0x6d40bb81b7f7cadac5717511628028b36e524c0c2fa42bca0262e3f36d2f0d3d",
+      "lentPositionImpactPoolAmount": "0xd2289eb77c6bc9daa9a7b0bb542da8b9072890647fa75d6744b71e942e3ba512",
       "minCollateralFactor": "0x477063fcf3dcb2f7f5ea4dbfa8ebd08b75668e951d64c79c207fe225a1c7d3bc",
+      "minCollateralFactorForLiquidation": "0xca1ade249503a15c4b948131034294456c5786080676a30a2316606becce1605",
       "minCollateralFactorForOpenInterestLong": "0xc28f780855330cd16102ba6fdb7ab47699efa33c0df3fcef42a44026ab9cceac",
       "minCollateralFactorForOpenInterestShort": "0x563eda60ad895862bb3e4b14cfeb79a20588ff0aa5e3d5bdfb2ac34f5e66d398",
       "positionImpactExponentFactor": "0x3db4ca02007d0bcac3d2f0cfd17c0750e24ba25b8c5eed37cf4cc5eca26ad574",
-      "swapFeeFactorForPositiveImpact": "0x1f03c21ebeb7b5ec284e3daaecc7cee0e823b4de3dc555fb313bc64f6e1b85fc",
-      "swapFeeFactorForNegativeImpact": "0x79d8564cf98ebc7211cbbb5b36fa9ec46a18bf9b41c3b3ecedfd3adacbd145dd",
+      "swapFeeFactorForBalanceWasImproved": "0x1f03c21ebeb7b5ec284e3daaecc7cee0e823b4de3dc555fb313bc64f6e1b85fc",
+      "swapFeeFactorForBalanceWasNotImproved": "0x79d8564cf98ebc7211cbbb5b36fa9ec46a18bf9b41c3b3ecedfd3adacbd145dd",
+      "atomicSwapFeeFactor": "0x9ef96e052a9f2aaab829e2a1ef21cc3e919165b44193e112a554f2a07991f25c",
       "swapImpactFactorPositive": "0x64e9abf3ebedf7ff2796a8a5fa366a70364fcd4f119fb9d15666e657f73eb729",
       "swapImpactFactorNegative": "0x2e08c5b1453619c4951c31850c9f89a154d538c544a90b73e73ba2ef063c9f17",
       "swapImpactExponentFactor": "0x3e9cda3aa0b96b0b39289b63ac5d0926a101a403958094fd676b4716658b7a77",
@@ -3580,19 +4176,25 @@
       "maxFundingFactorPerSecond": "0xfd17448b7052a0f4b2202a701bca57f6b687c5a0b7dadbebfd8279f57ddde32c",
       "maxPnlFactorForTradersLong": "0xbd4594835ab977699226e141d169ebf31221364cb1e8c00ea02158785a1bd1e2",
       "maxPnlFactorForTradersShort": "0x55bc4828ede3e74ebbf0451569d6e312d1109fe3e9a6bc5e40f2699cab82b71c",
-      "positionFeeFactorForPositiveImpact": "0x1c2b58fd5a66982e684fc09abb9ddb006bbb7bd04b22776103837b4d22fb88dc",
-      "positionFeeFactorForNegativeImpact": "0xfd77db7cb72af668ba7025a65dd934661476da45b8c10e28be6932247f634c66",
+      "positionFeeFactorForBalanceWasImproved": "0x1c2b58fd5a66982e684fc09abb9ddb006bbb7bd04b22776103837b4d22fb88dc",
+      "positionFeeFactorForBalanceWasNotImproved": "0xfd77db7cb72af668ba7025a65dd934661476da45b8c10e28be6932247f634c66",
       "positionImpactFactorPositive": "0x7baa57849b07319aaf8c28e1b5d5212e6a673612f5769a366628a21473d4bbce",
       "positionImpactFactorNegative": "0xba9cad4f66ee0de01e2762feedf92579733e81433bc367ab173a6d69bf710416",
       "maxPositionImpactFactorPositive": "0xe82f4b73da79de37c6d8828c855bc39363701137c4aafac1e50dddfb3a9841cc",
       "maxPositionImpactFactorNegative": "0xe66a60afb8061060957daf068784bab70e61cd6bb1ead11c3f81d4e60551076c",
       "maxPositionImpactFactorForLiquidations": "0xeca113ccf913f2b135ffc65612d8208716cc437352f94db4492778dbec26b3b7",
+      "maxLendableImpactFactor": "0xdd2a640ded519663fd6dcd0d0773556890b0bea71d5994f57ca2ae98995b007d",
+      "maxLendableImpactFactorForWithdrawals": "0x018bbb9224779541e9138199e7c2af6b2bbe8e1df422f70d261d08d983ca2c4b",
+      "maxLendableImpactUsd": "0xec2b1eab979e1acb5a68262c3c4e05ade1c5c5e7fa8d22e772a4c81b72cfb004",
+      "lentPositionImpactPoolAmount": "0xfad1d8649ac5eedbd8b7f1f8a8cf4c54120de09efb9bc37a7e0313192bc2300b",
       "minCollateralFactor": "0x66de3ebde9679ad0d1d7422384e7668a59308642f21b6ed99843bc6333dcfdbd",
+      "minCollateralFactorForLiquidation": "0xe5ff50ac9a0dfb0d5599b53e9c969ee858db161395ec92307f20922bc708557f",
       "minCollateralFactorForOpenInterestLong": "0x979afa01e39a53a0ee59cb19c28a83db1f5ecddcf336a44541738671ea529f07",
       "minCollateralFactorForOpenInterestShort": "0x6bd77d36ae31370d9b5b25f1b1a1301f9af23bfb9b7afbe1a76a2575570499ad",
       "positionImpactExponentFactor": "0x94c1d7ae56d6ee75a8fd07d00a806ad9f19aca4164c883661e618f7bc589c887",
-      "swapFeeFactorForPositiveImpact": "0xfda93cb94b8c430cc2c6a1e727953c276b7f78004466a98723415dc018dfca6d",
-      "swapFeeFactorForNegativeImpact": "0xaac48c0c555c2263a72df8ed6ebb170df9a43485c970f655c433dd9bca37c935",
+      "swapFeeFactorForBalanceWasImproved": "0xfda93cb94b8c430cc2c6a1e727953c276b7f78004466a98723415dc018dfca6d",
+      "swapFeeFactorForBalanceWasNotImproved": "0xaac48c0c555c2263a72df8ed6ebb170df9a43485c970f655c433dd9bca37c935",
+      "atomicSwapFeeFactor": "0x8628ddab301e77531e29770e6c0b85c34631783ca617e9ee2e618c086f3005bc",
       "swapImpactFactorPositive": "0x380f0aa935578c5e2efc586f4286a0954ecb8de9f0841a9369d5577638949f0b",
       "swapImpactFactorNegative": "0x24a92c575b4320d859d42a38cd8c94af9b78339d66e79ecb7423c253d8bc732e",
       "swapImpactExponentFactor": "0x16e0ff5fd356504437065f1903596bcc576bf46181ec5763a9f90411eec60b28",
@@ -3630,19 +4232,25 @@
       "maxFundingFactorPerSecond": "0x1fdb4813d9578c34eba7d40e8be3385373c685a85ba9d2937a79ca54b533f862",
       "maxPnlFactorForTradersLong": "0xcdea350cca22a37c0bee2fba1a00922504ebd7ecad69e18d81ebfe1cff20bc3f",
       "maxPnlFactorForTradersShort": "0x16ccdaa5770845bf1770f898bb130a218207a1abfd694b328cbca0447eefb23c",
-      "positionFeeFactorForPositiveImpact": "0xf89efb2df265c4bda64726efa91d82dfe2447cc6e1982d0a5df80b1a6c98e7bb",
-      "positionFeeFactorForNegativeImpact": "0x094f55fa807320bc8c19374bf714f9e2fc2eb9909953c31a142756810ed90bbf",
+      "positionFeeFactorForBalanceWasImproved": "0xf89efb2df265c4bda64726efa91d82dfe2447cc6e1982d0a5df80b1a6c98e7bb",
+      "positionFeeFactorForBalanceWasNotImproved": "0x094f55fa807320bc8c19374bf714f9e2fc2eb9909953c31a142756810ed90bbf",
       "positionImpactFactorPositive": "0xa1c42743459cc18584470bd7fcf394f287cbcd2426ee98e16b750c0cbe1843a9",
       "positionImpactFactorNegative": "0xff8af72e7c6be7bfbf7ebd7235d6610b6495c46ab493997b3e98e6e8c31b8a02",
       "maxPositionImpactFactorPositive": "0xd26604e096680008907eda5411c8f65b79e898f7fced8f2e8f3aeb2e113b2146",
       "maxPositionImpactFactorNegative": "0x78f8535809a6190aeef4e5fadd69800c7662133aaa6bf621f4acfc377ab01935",
       "maxPositionImpactFactorForLiquidations": "0x551b4069fdca4d0563164496a8b8865893dc2ebb3644af484c0ac7b5a6d9b382",
+      "maxLendableImpactFactor": "0x5515c68b6615a33d29c833a177c28e83eefa8d37359eadefe7f40cc4cf5e931b",
+      "maxLendableImpactFactorForWithdrawals": "0x523659400dbe19d15727217bcb08130ee6d223c198d685fface935b1860f2b0e",
+      "maxLendableImpactUsd": "0xc2bd44e6d3d1beb409b79733a13f2a124b59942c2ecd9f332ac4759623649a5b",
+      "lentPositionImpactPoolAmount": "0x8f5e9f8ab5f62683773f0547487f67d30d5e82dd4fceca41f857e9d994f199c0",
       "minCollateralFactor": "0xaea2afd33c6d2466b226b95971101b0250e5a558466f3e688135e606529cdea1",
+      "minCollateralFactorForLiquidation": "0xa65f72041f4bc42656406438eabaeb3a83e9f4f38aae62c9ff8235d0e81a7910",
       "minCollateralFactorForOpenInterestLong": "0xc425f5ca4051c07b0ef0a474ce087918aff548677159081ce684e1832a0dbfe0",
       "minCollateralFactorForOpenInterestShort": "0x6bbbbf6814e4de22856022d7020a208a63c369ae1fea354d25df0ff0deb385c6",
       "positionImpactExponentFactor": "0x528ceff820b2cc4de63f384e46d279050c14c12bbe069780248ca35209c7aa98",
-      "swapFeeFactorForPositiveImpact": "0xce4933def7de695772ebb91c5f48e74ddb76b3948fad48b878dd02ba9caec3f5",
-      "swapFeeFactorForNegativeImpact": "0x98ead5e154c29c07125c1e4e8cf110f5a0419cc47ddd938b394d97e787fa587c",
+      "swapFeeFactorForBalanceWasImproved": "0xce4933def7de695772ebb91c5f48e74ddb76b3948fad48b878dd02ba9caec3f5",
+      "swapFeeFactorForBalanceWasNotImproved": "0x98ead5e154c29c07125c1e4e8cf110f5a0419cc47ddd938b394d97e787fa587c",
+      "atomicSwapFeeFactor": "0x07eb2d60889510925c10701aa6384befe1dd08bb022b06557431c4910710f550",
       "swapImpactFactorPositive": "0xde03a55a07d901e98210970ac22f0cdf4cb6bfa89ac97a87aeb924e7382d4d8c",
       "swapImpactFactorNegative": "0x295a64c0d9cccfd469c2db10ea4fa9661c3c1630db9f753eb6d33eb59a7c34d4",
       "swapImpactExponentFactor": "0x27f090637cc766665ce9a0290f9ab38703f834afcee2cb6ff944556b43b9c60c",
@@ -3680,19 +4288,25 @@
       "maxFundingFactorPerSecond": "0x3d07c1c798dda7f35e115b1f7b3294455811db0f6b332105e6cd7640ed8d2979",
       "maxPnlFactorForTradersLong": "0x0643ab82acd1da935dccdca596b2467d15a15578392c8c1830c74d95cdf56bb5",
       "maxPnlFactorForTradersShort": "0x161cd5203040492bf6c154ee5a97667b266446a4a5ca70282f126ecd7616f1ba",
-      "positionFeeFactorForPositiveImpact": "0xa2642d8d9d5fb8e2ac0409d2db33e187719016ff7bf134045ae6182666bb05b8",
-      "positionFeeFactorForNegativeImpact": "0x23dcc4cd943557ef8ccebe9232754e9ffde52c137f085598ac91e7192a17ac59",
+      "positionFeeFactorForBalanceWasImproved": "0xa2642d8d9d5fb8e2ac0409d2db33e187719016ff7bf134045ae6182666bb05b8",
+      "positionFeeFactorForBalanceWasNotImproved": "0x23dcc4cd943557ef8ccebe9232754e9ffde52c137f085598ac91e7192a17ac59",
       "positionImpactFactorPositive": "0x6c77776d5e1445193adfe5b04337025ffcf54bdb11679bf34d87f421df699ec5",
       "positionImpactFactorNegative": "0x2565ee54946347b057bf1b32306485f036062453defc85ae44d043c9cff511c4",
       "maxPositionImpactFactorPositive": "0x1b5120ca944c5a33e540a1c6e406b523ce921000a984f97f95fa699d520cb7ed",
       "maxPositionImpactFactorNegative": "0x5296af9bb7d06b0cd08eb201218d7f1e6a2329be82fe448fdfd8b8fc39fa68a1",
       "maxPositionImpactFactorForLiquidations": "0xfe947f5fc6293d31166df3a75f524470845c7eeef041f8a2e420a094c3fac1cc",
+      "maxLendableImpactFactor": "0x0b0cf71a890beba3339150e4fce46b7790a1c75866ad17f049fa099046b1ecbf",
+      "maxLendableImpactFactorForWithdrawals": "0x39a407d8a89a525883f3f891a6ec25ffbe79da171cef45694bf1899c75f37fba",
+      "maxLendableImpactUsd": "0x5b55fff0d750ba099a6b448ed89defc38c817f3b5ea1a51b1e7c1159ea229250",
+      "lentPositionImpactPoolAmount": "0x7f747d0cf67f5b29218c28a4cc2d396981138a51c76a4d8ba6db2b8599352bc3",
       "minCollateralFactor": "0x0265939bb7d88fea6fff26636a6858305b038871546f1414e5701ad669d5dc1a",
+      "minCollateralFactorForLiquidation": "0xca9593cfa0c874962f22b8bb702032807b9427579010b042670806b64ab2df34",
       "minCollateralFactorForOpenInterestLong": "0x50d84922790ede06558e4ca6f2e96902c570c45e4f427cc6fcccdd32dddfecad",
       "minCollateralFactorForOpenInterestShort": "0xef11b410c5d53d8e576c956acea505ed667e5d34bb227625e99d6514bc07de92",
       "positionImpactExponentFactor": "0xbbea29388c648439a26a387b35619908b6b708893ec6e3555a1f26de057e27ea",
-      "swapFeeFactorForPositiveImpact": "0x8ef96c28cee73d45619581b8a28340afbb3e3f7d496d55e1ca67286de61e5f95",
-      "swapFeeFactorForNegativeImpact": "0xdf8618a78eede905a9aaa8a5ae18211a6a6bdb3737d54f794c8a999f091c0729",
+      "swapFeeFactorForBalanceWasImproved": "0x8ef96c28cee73d45619581b8a28340afbb3e3f7d496d55e1ca67286de61e5f95",
+      "swapFeeFactorForBalanceWasNotImproved": "0xdf8618a78eede905a9aaa8a5ae18211a6a6bdb3737d54f794c8a999f091c0729",
+      "atomicSwapFeeFactor": "0x3989f95dc50e51405be5cd609ce63faeb462947821d280425454f5fff74809e4",
       "swapImpactFactorPositive": "0x77668158274b0da81643c91786fdaa3d98c20ae3ed3bef765d11798b06b5f5d8",
       "swapImpactFactorNegative": "0xb4e19689f59f1f7a32a01249c2fce76b3af38202f0259d90af683019f13690a3",
       "swapImpactExponentFactor": "0x0a8ea7ff9e9e32e140583e2600c881c51c70a415f40a8d918b040cfe77219fb2",
@@ -3730,19 +4344,25 @@
       "maxFundingFactorPerSecond": "0xc4150965d758d86afdcb22b1c6849fa84e8966c11a134af851b682fddf33e4a6",
       "maxPnlFactorForTradersLong": "0xf3320cdc63c3a7d6f78ad9986ddb409c5134677e3ad4a0174891020a22b24fb4",
       "maxPnlFactorForTradersShort": "0x228b126e5894d16fa46757d3a5a5b6d5710a5b23ea94753de3f9737c4d2c5b9a",
-      "positionFeeFactorForPositiveImpact": "0x19a2a68bdbc66fa5dc4851a9378ede85ccdafe9acb99e62c017676872e343a6b",
-      "positionFeeFactorForNegativeImpact": "0xd8d7ebb0ecd47d813c8dadf9c1af95bfe460bf83fc2315e7c4ce9f6d63f128c2",
+      "positionFeeFactorForBalanceWasImproved": "0x19a2a68bdbc66fa5dc4851a9378ede85ccdafe9acb99e62c017676872e343a6b",
+      "positionFeeFactorForBalanceWasNotImproved": "0xd8d7ebb0ecd47d813c8dadf9c1af95bfe460bf83fc2315e7c4ce9f6d63f128c2",
       "positionImpactFactorPositive": "0x85203630052949e2750737f79f8d56725368a5c53228abbd1afe481db132006a",
       "positionImpactFactorNegative": "0x1e7f9610ae2f0862b2ec16dd348ba826566595be72f4492f52ff26c34d673622",
       "maxPositionImpactFactorPositive": "0x2de659890a4e8d1963570ff9b59d26e46be9b33cf7e136aacfcb2bb200550ccc",
       "maxPositionImpactFactorNegative": "0xc1bea97710f8e10627534a240eee6f82cd830e63d7b2c2dbd76556ea4fd033f7",
       "maxPositionImpactFactorForLiquidations": "0xf63f2b50f2ecdaa28b16771a42a2b5cd380e09f6de782cecb71e839cdc32f851",
+      "maxLendableImpactFactor": "0x07a3c676f0db6db3d8db26ff2fc47883d483091dccac5fce69b3c09a9b37808d",
+      "maxLendableImpactFactorForWithdrawals": "0xdfb2ca3011540b213a14ddf383ba4ed001f3d1ee172ab3f00b9ee5d376a363e6",
+      "maxLendableImpactUsd": "0x6b9b187296c4c45699c8b5fab9955585b18a428f093ffad2f06784a62a338e1c",
+      "lentPositionImpactPoolAmount": "0xbb1e96fafb49ae815aaf7feddc6be0f4b1663c66c5db81071b7e5b01391dcaa1",
       "minCollateralFactor": "0xfb841e5374643d23b05f191cc2f0e1148808a7f71da91675b9a3d8c64b016544",
+      "minCollateralFactorForLiquidation": "0xd2e092583c07aa062aed1369c062d31719a80ff6e75d84ddc76b5e6bc7826054",
       "minCollateralFactorForOpenInterestLong": "0x6d7fcd1f8264f3f59c707af933ec7782df25287b0b6b5f420a319b58b4886f7c",
       "minCollateralFactorForOpenInterestShort": "0xb605b4ef503f9544c442f94b2ac131cf5ee8da1d4e1316784bb9d7cce6d79138",
       "positionImpactExponentFactor": "0x5d9ed32420efc0bcbf1596941636a999f62042da229abce2fdd8c931da675f9f",
-      "swapFeeFactorForPositiveImpact": "0x062c0c2d730d24aa33c37d80bb065f727dbd4301b42a39c8d2459487d066749c",
-      "swapFeeFactorForNegativeImpact": "0x00a2196092d604bf9fc2ea751e06405e37f231e0fff627ce7be4cabc40bf6ca9",
+      "swapFeeFactorForBalanceWasImproved": "0x062c0c2d730d24aa33c37d80bb065f727dbd4301b42a39c8d2459487d066749c",
+      "swapFeeFactorForBalanceWasNotImproved": "0x00a2196092d604bf9fc2ea751e06405e37f231e0fff627ce7be4cabc40bf6ca9",
+      "atomicSwapFeeFactor": "0xaa8b5f5925e8ddcab441df093f783c1d1c83bfac7ca60f14b8bc3b84c012f08d",
       "swapImpactFactorPositive": "0xe317742a7019bf37820ea41ad199bdf4a6252562c7fe43a71abfce8e85ab80da",
       "swapImpactFactorNegative": "0xa8e910e7748bd5c02441c6d1c9a77e48c61af20a8e089b02a61a90f7b6678acc",
       "swapImpactExponentFactor": "0xb6ef980b459b0fe90605c30cdb2084285dd6c2b7ef578e2d4bbdfe1ca5cf4fdb",
@@ -3780,19 +4400,25 @@
       "maxFundingFactorPerSecond": "0xfa6364fb56a11345b92d4983b9bd8ea66cacd614eb3b7520137399f55d354b09",
       "maxPnlFactorForTradersLong": "0x13a27a353c7776ef31a2a496bec36eb5dfb23d8dcdde1c4873ac3c1e35e4313e",
       "maxPnlFactorForTradersShort": "0x0b3a39ad3f7d8d1ae1a553ad21654b2fcfd1e55feb8c3efecdf91d53200b45c4",
-      "positionFeeFactorForPositiveImpact": "0xfa2c3a7f66301b3059290169c87e11fb20c062c65383b5740c7d3b090bc98e04",
-      "positionFeeFactorForNegativeImpact": "0xd3ebf9538ef9ea88d6f7ef51523bc2cf6669cb01aee98f1de1fec0fa53b4eda9",
+      "positionFeeFactorForBalanceWasImproved": "0xfa2c3a7f66301b3059290169c87e11fb20c062c65383b5740c7d3b090bc98e04",
+      "positionFeeFactorForBalanceWasNotImproved": "0xd3ebf9538ef9ea88d6f7ef51523bc2cf6669cb01aee98f1de1fec0fa53b4eda9",
       "positionImpactFactorPositive": "0x3daf5ba49e3d385f7036de1ad15a6a638d9dd0a17a2cb765e1d772d5dcd7a91e",
       "positionImpactFactorNegative": "0xbe0d09f14005110d076128a12f6a0f4cc2ed5f0048479ee1d1d2658480d07c11",
       "maxPositionImpactFactorPositive": "0x07e3c045a079b6ba9dc07038336e09bce8c716941b675d352a7b05ba5b59ce60",
       "maxPositionImpactFactorNegative": "0x84e0600c16972b29f7da354d54020464629310f597f791a8dabe846828986384",
       "maxPositionImpactFactorForLiquidations": "0xfa799d4aacb60572cdac1ee643f9cd39f700a4b389b24222533c7364f308f5be",
+      "maxLendableImpactFactor": "0x21318669980e0bda8d54714e965f58fd6fee60aefe7a00084c3d2e72029d9057",
+      "maxLendableImpactFactorForWithdrawals": "0x98cadb0d1b4caa4c04ce0fc916b0616d3cbf8d94fe8191190485c40f926b1040",
+      "maxLendableImpactUsd": "0x552b8ab97c40de451e32f563871104f2a3bd6cb004f97bb20d14811feffd9cac",
+      "lentPositionImpactPoolAmount": "0xaccf2cb5694b087908d4e6919f53fb8138036e52d2817ad19bfb412c875cdcff",
       "minCollateralFactor": "0x3a6062579846cca4b922db1cf9688c3f8f090eb5448600fc904bdf4b4b72bd22",
+      "minCollateralFactorForLiquidation": "0xabcb9f7c66df854a36c97a3cb49e635446fb7a3c56f8ab8b55b39f68d12aafd1",
       "minCollateralFactorForOpenInterestLong": "0x94a978d635ef737465b195eec16b7f19c6f1bff0017c978ca61a17e5fe8b7808",
       "minCollateralFactorForOpenInterestShort": "0x2688ed464f128f747c02828d429a6aa3dccb40e2071454408f3296fbd87a16ec",
       "positionImpactExponentFactor": "0xae78eeb8d250d69bc9255def1e262c819c19b3aac6ed2626248730ada04b108a",
-      "swapFeeFactorForPositiveImpact": "0x50bf015e1af753131c148a7f0b5a8de5e482f08b30460d48e358105925cff626",
-      "swapFeeFactorForNegativeImpact": "0xe248339af6d57cabcbf56a435449881c63af9318e4a9248d8d230f1596d112cb",
+      "swapFeeFactorForBalanceWasImproved": "0x50bf015e1af753131c148a7f0b5a8de5e482f08b30460d48e358105925cff626",
+      "swapFeeFactorForBalanceWasNotImproved": "0xe248339af6d57cabcbf56a435449881c63af9318e4a9248d8d230f1596d112cb",
+      "atomicSwapFeeFactor": "0xa3fa7dc8862b484cb29feed8cfe4dbf7538e686228f907b5d4d7024ea5aa1c3d",
       "swapImpactFactorPositive": "0x1404bcb3b37fd6c73c429f0b67f0326ab072e3ed1c832a41cb8b3ed7eaf9047d",
       "swapImpactFactorNegative": "0x5b5cb62ae90c344158744facbd2041a7a9fe2104d068c90945d76de7c5d7fc7b",
       "swapImpactExponentFactor": "0x6cad51d8abbdc78def03b61c8b995d2f4f8ffbfbdd71285b0bd2218f4fd2a036",
@@ -3830,19 +4456,25 @@
       "maxFundingFactorPerSecond": "0xeae47123e370dddf6c9579930918a34f59c44b9945b68afb8a693a9444b9e6ac",
       "maxPnlFactorForTradersLong": "0x5bc743b0161813f436c45d2bc88a64de29d05cd30d9c1f6e1924f0b138328f57",
       "maxPnlFactorForTradersShort": "0xf95dd4ff89517f2fb139ba5f72e2b18bf7aa6ce454abbde2e24678c5e8c826e1",
-      "positionFeeFactorForPositiveImpact": "0xbbaa199810a58a8b632296eac0daae34a5f24fdf8013d5ecb0c269f5e9fd4430",
-      "positionFeeFactorForNegativeImpact": "0x668119f4388e461b52d33b9119d5fe66bab6e1612657d134841606b722fe5e21",
+      "positionFeeFactorForBalanceWasImproved": "0xbbaa199810a58a8b632296eac0daae34a5f24fdf8013d5ecb0c269f5e9fd4430",
+      "positionFeeFactorForBalanceWasNotImproved": "0x668119f4388e461b52d33b9119d5fe66bab6e1612657d134841606b722fe5e21",
       "positionImpactFactorPositive": "0x82d8a24ed60b8b954daaaa4afae9b80786c1a1d3524000b6e8fa2616c79af74a",
       "positionImpactFactorNegative": "0x8337e01de60f85dc0a20a5f6c2e0bdc5e8bfcdaf3ac72583acc8a80b1ebeec32",
       "maxPositionImpactFactorPositive": "0x2a25ce604cef5d4243bebc4f18af4f6387cbbcd46d1293e23fdfe810cd6854b9",
       "maxPositionImpactFactorNegative": "0x9a452777e6806271ad8cc47d6d8bd0a79dcde5bba1bf5fdb99b0c9056a752510",
       "maxPositionImpactFactorForLiquidations": "0xb4e94d1b92745024b727c7bcedcd895ed2e00e2ea2ccaf2eb37d50cc590131cf",
+      "maxLendableImpactFactor": "0x611a5706038f2743efbc3edfa3297c04acdf89cd037ac3e53652d6517659970b",
+      "maxLendableImpactFactorForWithdrawals": "0x84fb403374fc081fb547f1949582e0a12f3799f450b3be23e5d405da7e0f21ee",
+      "maxLendableImpactUsd": "0xb87743d8a51c6b26e2392bbbab800e130e3508cd359a5b592c70c6234b90adc1",
+      "lentPositionImpactPoolAmount": "0xf06057d3ae9088b458bc78d76f06e31965e631e1e38671ec6a45ca9d38983cd9",
       "minCollateralFactor": "0x0aa8885df89de8ff34563554e6069a4ad8949cd4e6f77d4e7e5fc6eed353b721",
+      "minCollateralFactorForLiquidation": "0xce9ba90c380212578833d426e036da7abf6c564caa45e126e5c9f3af3f39727a",
       "minCollateralFactorForOpenInterestLong": "0x4434267baa673353b931f72b997d623a8dbb24ad019fb1012b523e3445a9b522",
       "minCollateralFactorForOpenInterestShort": "0x6b1db050ad4883d52b32633aa49159bddd02262af4439b457a32cdcc5988fd43",
       "positionImpactExponentFactor": "0x79bfdbb2346f830a4c8d80f29a006b0baa9367418902e8b3c93a1213c9eed125",
-      "swapFeeFactorForPositiveImpact": "0x0faa1337b525b28e6422cd472df6548c0da443bc9077ed0fe6fa694f8ee772c7",
-      "swapFeeFactorForNegativeImpact": "0xf9975025f98c1742bafc5964493e42785f56e6673592097971feb7aba4729a0b",
+      "swapFeeFactorForBalanceWasImproved": "0x0faa1337b525b28e6422cd472df6548c0da443bc9077ed0fe6fa694f8ee772c7",
+      "swapFeeFactorForBalanceWasNotImproved": "0xf9975025f98c1742bafc5964493e42785f56e6673592097971feb7aba4729a0b",
+      "atomicSwapFeeFactor": "0x12fc02d199272ac56852e8a778bf732653628467efe2892262314456f4dbea18",
       "swapImpactFactorPositive": "0x107517ca8068a2882de0bab37ab86b35e91cfd63473089cacda01bc81f1c7daa",
       "swapImpactFactorNegative": "0x1e7d0f85278824210a3ce74721f888e34dee24c518278d80952dc9f1024b7f65",
       "swapImpactExponentFactor": "0x5c85d1cc64d3b9efcfab44480ef94a71a4456764663fdea9d64b006f2c0d809b",
@@ -3880,19 +4512,25 @@
       "maxFundingFactorPerSecond": "0x0fe3f71d3f4e380ac4bd1d45ec26be57ea2ec86a9e893c45e824fddb3233e5a5",
       "maxPnlFactorForTradersLong": "0xd9ccc9e84419059f691fdd180aecb410ad79540c2cafa902da62d54128d754e1",
       "maxPnlFactorForTradersShort": "0x88354aedfe906b9fb49ba2f728bfd0ddd470c9a1cc85cc055f0d716a3f2f54fb",
-      "positionFeeFactorForPositiveImpact": "0x5e34672fc4f42ab23d23213fa1d40cebe0a3e7bcf87eb11b76d2fcc1be32e252",
-      "positionFeeFactorForNegativeImpact": "0xf8e3dafc3f767e6295802eac15d1b04db4698328bcc74af85b81335b8ff21c99",
+      "positionFeeFactorForBalanceWasImproved": "0x5e34672fc4f42ab23d23213fa1d40cebe0a3e7bcf87eb11b76d2fcc1be32e252",
+      "positionFeeFactorForBalanceWasNotImproved": "0xf8e3dafc3f767e6295802eac15d1b04db4698328bcc74af85b81335b8ff21c99",
       "positionImpactFactorPositive": "0xff8e09a7151d33fcf5165e2ccf6ac14c30d229f18ee3a60a95abf260d1d243ac",
       "positionImpactFactorNegative": "0xed76416203eb5df0eae69591d057f2870fc448171a7e014906c629b9e71cda12",
       "maxPositionImpactFactorPositive": "0x5dae48e6dfe9c144cd58a6e4b90c070ef559116c76518323bed64e54cb43c85f",
       "maxPositionImpactFactorNegative": "0xf43b9ca73005afa930d529a7b5e512a0b072819f3addcdbf14fdd3c65835f385",
       "maxPositionImpactFactorForLiquidations": "0x63855710f19d2605d4dc599aac16e0d6240b8336befa7f7f0f0de89ca8fe48f4",
+      "maxLendableImpactFactor": "0xfb808e24c79a656df31ffd89dd51ea2faeda1bc9041f5b300080910bff27aead",
+      "maxLendableImpactFactorForWithdrawals": "0x970aca94d332873ab727b59cf55588a44f00b9007e4bde414002310939e8b72d",
+      "maxLendableImpactUsd": "0xce9f727834e2984c9a690e0cb55e001ee641c931895c37ce30dbdeb49f4d3085",
+      "lentPositionImpactPoolAmount": "0x4b22937fd39d48f629239894ad419f0a1622516fffb17e9d100dbdf808955cce",
       "minCollateralFactor": "0xb10b7742e2b3281b2f4c6c986ee610bdaae744a102b587ed040bd5a26d0cfcf6",
+      "minCollateralFactorForLiquidation": "0x54898fae937ffecc11f45b346e2c2d31190475b9cc7829e2801c3bd2aedf7953",
       "minCollateralFactorForOpenInterestLong": "0x24d067bde87a33817afba6f9159b1f879be5f907de489107e0e32433665c7c1d",
       "minCollateralFactorForOpenInterestShort": "0x970902c830d69c75cf173a1493daf4144604122b2f7b75fe359cbe15ea3dcd4d",
       "positionImpactExponentFactor": "0x099e85a8f05448a4731818fa874d8796b78a9a46cc87197eef4bb972b10e456a",
-      "swapFeeFactorForPositiveImpact": "0x440a965a2877911c4c99d8a22338d137721fc202a2d1e7ca75cdc9f094ba65b0",
-      "swapFeeFactorForNegativeImpact": "0xc926687ddd09ffe9ac71036d2dc7f560dc5b6ec92d888c1cf3e6195288dd6e80",
+      "swapFeeFactorForBalanceWasImproved": "0x440a965a2877911c4c99d8a22338d137721fc202a2d1e7ca75cdc9f094ba65b0",
+      "swapFeeFactorForBalanceWasNotImproved": "0xc926687ddd09ffe9ac71036d2dc7f560dc5b6ec92d888c1cf3e6195288dd6e80",
+      "atomicSwapFeeFactor": "0x7a0ebfae0537a6ec5958b1455006293dfae06de26368232249a3abdb986ab98f",
       "swapImpactFactorPositive": "0xa49e8eda8b34c14886ad044ddd88d3fa227afc72878a3c40e5d79a9528d0828a",
       "swapImpactFactorNegative": "0x5faab11fcfbefb319520e36256399baa608cde5c8dd19f2ca05aedf022d92b60",
       "swapImpactExponentFactor": "0xa6d25fa3b92b5de1e23bb759c281b102c8128053e311848ea83974e5c99e5567",
@@ -3930,19 +4568,25 @@
       "maxFundingFactorPerSecond": "0xa8772b6fe3e4bd1d145d63b633a14f0cc582e9e9e82d9f70afd965f3a00bcd03",
       "maxPnlFactorForTradersLong": "0xc778833983adf3aa53bbacdea870efa89b5919c3541f7446c37fb4400a12a024",
       "maxPnlFactorForTradersShort": "0xff7edb9cbc1b4d90d770d471c02a00bee32110e8343ec2fba13f34c52d474088",
-      "positionFeeFactorForPositiveImpact": "0x0d3420aa928b1da5f586478312c805f7ae21afe9e7baa721059122518ef67f63",
-      "positionFeeFactorForNegativeImpact": "0xd4ade9db9240512e1c696eb045235faf299ceac74180cf1a2027c662628aa3e0",
+      "positionFeeFactorForBalanceWasImproved": "0x0d3420aa928b1da5f586478312c805f7ae21afe9e7baa721059122518ef67f63",
+      "positionFeeFactorForBalanceWasNotImproved": "0xd4ade9db9240512e1c696eb045235faf299ceac74180cf1a2027c662628aa3e0",
       "positionImpactFactorPositive": "0x5ce30f4b82ba55df0e987029ded936711b6d1aff9a7aaad80a7edaf4eccd1603",
       "positionImpactFactorNegative": "0x05bfa4d4d178163c174ca600f23edd2beacb6251cc497dae969209ba7a28d586",
       "maxPositionImpactFactorPositive": "0x985a11ed1a8a61ba0836724b434483e8888ebbe9e30d8ac70cf036fc4e7685e0",
       "maxPositionImpactFactorNegative": "0xb5d03aaa44f4e51f4b5735ce62f55c1a038c064d10f3dbec30b1594f2bc2b5bd",
       "maxPositionImpactFactorForLiquidations": "0x26340ddf9e54bffb55bd5cb1470652d3b32960f41efa886140a723a2349d30ba",
+      "maxLendableImpactFactor": "0xc8f6751279bc8ee904f588df45a88d92f862015fa055333d4fb948cc621a6865",
+      "maxLendableImpactFactorForWithdrawals": "0xeedc3dbfb87abeea1d05fe424b4dad10401b1f1be8e153100e2fa74de7d50d1a",
+      "maxLendableImpactUsd": "0x9f3f857116557171c55b06b0c7e73c89dbbea720b7f88829ba87336931047320",
+      "lentPositionImpactPoolAmount": "0xa426d6ee0b72483ee1706ce54780b3f38afdb278be3606e662f03e4efd86c8ab",
       "minCollateralFactor": "0x80cc450de3e38bf0842c74de08feef0c83bbd4bd5b057c6ce752db74e8fc2004",
+      "minCollateralFactorForLiquidation": "0x8fd4ed805960eda98fc4829e08f9615cd22bfcb89ca38d1947083ff245785e55",
       "minCollateralFactorForOpenInterestLong": "0xf2505508b048b3a9f6cd5d4f0f28decb75a374a948a988d270c8da823ffd628d",
       "minCollateralFactorForOpenInterestShort": "0xc3922e36cb2027c649f679b0f13d927854201b6e8c96cf50c664679c9ff837c1",
       "positionImpactExponentFactor": "0x8d9148077d210c110220baff03e054b10b421a3f985a98fd1db1545c7318a3fa",
-      "swapFeeFactorForPositiveImpact": "0xef5f72f2eb9555a8148a2e1401958032aacc197c1da4022f0ec23590e253b6fa",
-      "swapFeeFactorForNegativeImpact": "0x95126626376b73774a4e8e523fb0db25be1726d1a0c5b08723b2efb6276b3561",
+      "swapFeeFactorForBalanceWasImproved": "0xef5f72f2eb9555a8148a2e1401958032aacc197c1da4022f0ec23590e253b6fa",
+      "swapFeeFactorForBalanceWasNotImproved": "0x95126626376b73774a4e8e523fb0db25be1726d1a0c5b08723b2efb6276b3561",
+      "atomicSwapFeeFactor": "0xbe395a7e6a556993f306449f4d11f63501a384176881647c46a37cc23d327072",
       "swapImpactFactorPositive": "0xc131b1e245ee5a6f5be3d03064d8b0b6510fe566b50f6c0c7e65a42270eb68d0",
       "swapImpactFactorNegative": "0x20f8d97e59061e27885e0d392886682d392172249b499132c6b686874c2353ed",
       "swapImpactExponentFactor": "0xa8ce35d21abd4702c2a6e0dc32684d552eab6ec32667e545a36a4da5b5c3643a",
@@ -3980,19 +4624,25 @@
       "maxFundingFactorPerSecond": "0x8daecf054a29b3068ae7b310026a2cfc33b6d325a507d8f38600c0cd4533e22b",
       "maxPnlFactorForTradersLong": "0x5b696c70bfe0b7b753a58b050c1701e8d0d2a17895c180b9436a9b9a00072830",
       "maxPnlFactorForTradersShort": "0xb5d1ce491c48ca9730b200fd60aaf94f616beb58f1c082d860911c0a8f7e0ad7",
-      "positionFeeFactorForPositiveImpact": "0x9e7af6bbc811961fb58a5140293e936a7fc8e62662a854d73e063fab60dbb7a0",
-      "positionFeeFactorForNegativeImpact": "0xcdd1ad112670f69342d21f543b820df3250e6d0b243b1b8aefc8345b89abb2ab",
+      "positionFeeFactorForBalanceWasImproved": "0x9e7af6bbc811961fb58a5140293e936a7fc8e62662a854d73e063fab60dbb7a0",
+      "positionFeeFactorForBalanceWasNotImproved": "0xcdd1ad112670f69342d21f543b820df3250e6d0b243b1b8aefc8345b89abb2ab",
       "positionImpactFactorPositive": "0x7fea51d79d1e76d3cb89da3577667440e794d696ec37d7fc5f7f921a8bbfe41b",
       "positionImpactFactorNegative": "0x03008449d0e3cf33fed94b24e8e058423e91206a57cbdb0b0f228173099744da",
       "maxPositionImpactFactorPositive": "0xae8761a60ec47c251789ab4ba75ff174152d05306b538265b50ed7906a9edb99",
       "maxPositionImpactFactorNegative": "0x3c35a9293aae318368124f14e86c5967640ac6767c0edd9abb2830ff3cd4d534",
       "maxPositionImpactFactorForLiquidations": "0xbb6d346ee918ea745aeb83d09af9be9a441249dd326421e57e19e0bfe338d10e",
+      "maxLendableImpactFactor": "0x7afb8a83e5ae3e633a983ecf68a396b1c767ad69879003c6e8ba4764516b1e16",
+      "maxLendableImpactFactorForWithdrawals": "0x862443f2dd7c14b1f9db2ba42990cec39441c33db9e6c0aa951f30a8864dbba9",
+      "maxLendableImpactUsd": "0xb5f25ad6874ca38d7c316af80adbb6479177e5896ff6381b1c5035c6b437df10",
+      "lentPositionImpactPoolAmount": "0xf8fd318a9bb13d620a7286dd499629f43f6ceb45af012e421f0a313eb4c48c2c",
       "minCollateralFactor": "0xa5d93c751fd967d449430928a31c30b819fd3a1123a0e85297dd2a15e1975187",
+      "minCollateralFactorForLiquidation": "0x41bc7acbf6580c7822c4f8242416ec35d9c8b2e50be1d5379221c039a8d1119a",
       "minCollateralFactorForOpenInterestLong": "0x4634662dada17c503986cce2faed9f7fc072f1051ebdd20db92b238c9f9ca03b",
       "minCollateralFactorForOpenInterestShort": "0x55718911d60d30d9b398b5790a01cfd8f83b42419d8e02cfaea4d5187c3f4b5b",
       "positionImpactExponentFactor": "0xa44af56cb9b277271d9b9a56b3650c87c94903e5f5405288258716550afa72f6",
-      "swapFeeFactorForPositiveImpact": "0xc4ba621aee7406ad5aee070791330082eca4849f02c5b02b28c722866a81e489",
-      "swapFeeFactorForNegativeImpact": "0x3a9540bbf96991551bb54d2f395b5549386da9efb15ea31bd2b2324ffeb59f1c",
+      "swapFeeFactorForBalanceWasImproved": "0xc4ba621aee7406ad5aee070791330082eca4849f02c5b02b28c722866a81e489",
+      "swapFeeFactorForBalanceWasNotImproved": "0x3a9540bbf96991551bb54d2f395b5549386da9efb15ea31bd2b2324ffeb59f1c",
+      "atomicSwapFeeFactor": "0xa1424279e592282be92a583ce5c44f2eab6258665b0793dc39c5345a33a23464",
       "swapImpactFactorPositive": "0xa8ef70684dcb1134f6786ae9427f62a50b92c4aef310158cd0f006bd34075508",
       "swapImpactFactorNegative": "0xbf74a7204ca3863044e31f33237488f15c51f51ce170161904e97f6076dc6f6c",
       "swapImpactExponentFactor": "0x56e72f39cd45b35e0f8ccbe4c6b62a5952afde048a9fa2656d1e9ca3a67da094",
@@ -4030,25 +4680,1375 @@
       "maxFundingFactorPerSecond": "0x9fe2c3a88553e6c8f1a937d605937e19ea8b8d768dfab0313ad6b0c4b727ed25",
       "maxPnlFactorForTradersLong": "0xefd0786c97fd0c1e5efe12c265540afe49357b5ce9410f203116ef97dfcbabaa",
       "maxPnlFactorForTradersShort": "0xef485852c8c3ee8c55de7e52d063da274901d0045a61839f7a8ffb2edee2037e",
-      "positionFeeFactorForPositiveImpact": "0xbbedf3f173f1ef4c451104ab8d9e85c4a8668255fd6383313da5e39c7e3fdf8b",
-      "positionFeeFactorForNegativeImpact": "0x2ef8737317c51e79612d985e398958d73119e5a3d176530ac7b67a2008c9176a",
+      "positionFeeFactorForBalanceWasImproved": "0xbbedf3f173f1ef4c451104ab8d9e85c4a8668255fd6383313da5e39c7e3fdf8b",
+      "positionFeeFactorForBalanceWasNotImproved": "0x2ef8737317c51e79612d985e398958d73119e5a3d176530ac7b67a2008c9176a",
       "positionImpactFactorPositive": "0x46205b42a73fde3057a08e8a43372557878909432252cf53a39eb8b568acd1e1",
       "positionImpactFactorNegative": "0x3fbbd6e4687059e8cd17798661898c1e6ac18c15305a69cba17f6aadb716996d",
       "maxPositionImpactFactorPositive": "0x09ab49987e86f02b3648e2765ed1d4d25bd1b0112530f62e0a33b726318fa816",
       "maxPositionImpactFactorNegative": "0x35f4914c65363c6934dbb5398de816f6e5ff326bb435026c981067b9481850d9",
       "maxPositionImpactFactorForLiquidations": "0x7922e33897dbbe67d00e7d6d23a286eb854b047a28ebc0809460232346fda898",
+      "maxLendableImpactFactor": "0xf98b5a7bea6b04cf524bfb79ac4ef7e8c2d5a63d18433a1069a4a96a5fa97631",
+      "maxLendableImpactFactorForWithdrawals": "0xaf51334f13ecb6f593199c15f26af85ce87d039650fd64b2841c2493c6fc202d",
+      "maxLendableImpactUsd": "0x822e1063ee7b9a5cefac8546f5eb8ec64948dc327a6d8d4f57e3f2c643a8bffb",
+      "lentPositionImpactPoolAmount": "0xa1b1838be047379eea778b2ffde45ac38a01637f2d9eba71b01be779b523cc4b",
       "minCollateralFactor": "0x57bc7d6117c01150e63f7d6376a598ee76432123b0a8f097c2b2e3acf36805c2",
+      "minCollateralFactorForLiquidation": "0x6ee2269ef5eaa11d456e4c5c24fcf4472789e05761bbccde7d124720734daca0",
       "minCollateralFactorForOpenInterestLong": "0xb2a7bec849de6c6b7a38d4d561e876a210dbebde36c0a50dc37aad9083f73647",
       "minCollateralFactorForOpenInterestShort": "0x08927937fa841003e009e8b483a7c0c26168f27b686c4bd9d2d6df5e5a0ceca5",
       "positionImpactExponentFactor": "0xcfcb8341caceb9af4665161bc4a5585b88134830d36019917b0cc166b439155a",
-      "swapFeeFactorForPositiveImpact": "0xd18573dc8f2a53bf9106216a900f943172999abf8f4b78c32a02ffb16fc9bb1e",
-      "swapFeeFactorForNegativeImpact": "0x6c9413f2853edd95a6752ced7c2bc05d4a59510e00f373d505f141630abbc5e8",
+      "swapFeeFactorForBalanceWasImproved": "0xd18573dc8f2a53bf9106216a900f943172999abf8f4b78c32a02ffb16fc9bb1e",
+      "swapFeeFactorForBalanceWasNotImproved": "0x6c9413f2853edd95a6752ced7c2bc05d4a59510e00f373d505f141630abbc5e8",
+      "atomicSwapFeeFactor": "0x8523c99151414acbe1151e349da6bdad037043215e785e5ddaa7ac7536e34e11",
       "swapImpactFactorPositive": "0x0466561a2291ccd4142344bd5609995bd96af67dda47cc7c6477b160d5fa60a4",
       "swapImpactFactorNegative": "0x463b2d08a99a0fbee14d053a2dbb048bf69fea6fa054f72852401d083cff1e33",
       "swapImpactExponentFactor": "0xca5db13289c957c3b79f07e49d87b20546ef63217ec61a192141de7e9e0663f5",
       "virtualMarketId": "0x9bfab2b19467f690a2c7d7a2ff79f023153dbf5544a93501c14c5936fcd75632",
       "virtualLongTokenId": "0xa59040b7efb6b7122a74cb318a192ebc6732849dff5332ee3ba40b90dfa0a04f",
       "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x4D3Eb91efd36C2b74181F34B111bc1E91a0d0cb4": {
+      "isDisabled": "0xe83e0ec1c1ac7b6988e49213d58bd11bbf6b5afd77c2181f70861e2d01a511d2",
+      "maxLongPoolAmount": "0xa097b6493cd049189f95eb24b10ee6bba633ffc345ca5368f002508e0710de5c",
+      "maxShortPoolAmount": "0x3a62c3ecc3bd77bc6ac9cd711f02b737a57957fd92f4ff4991e344a3cc2d9e90",
+      "maxLongPoolUsdForDeposit": "0x5b8f631e61e2c150cbc7216f1294708b77f7ffb5ac0ddc77e49e39d90973cd04",
+      "maxShortPoolUsdForDeposit": "0xcec2e1dfcff690b41a286cb908f8ec7e8d477eb0c5a4137df3ffa03d6b8bc1d0",
+      "longPoolAmountAdjustment": "0x4828e328562b81a0de9c9c1643b8d78dc00b3f1aeebf9bc2ac063913b360869b",
+      "shortPoolAmountAdjustment": "0xc59ca141127bbc1e0c05ca53f0a693b7753f2eb40e82e4a46091f5c6822ceabb",
+      "reserveFactorLong": "0x04b4bf4124bc2c435a8322257b69201f3faca69b4b41528b66c3ece775ec7599",
+      "reserveFactorShort": "0x3a6c9a54cb408352534a7cc18c5d7609255660fc230a8986f083a4aefd03e685",
+      "openInterestReserveFactorLong": "0x1b0e072734b61aafae0aa4477d30d3142dff83557526128e52921aa980795fc7",
+      "openInterestReserveFactorShort": "0x861a873250c1c87b0d3fcfe8a8bd868d5805edb4344b93c8b8c3c21d38a23f08",
+      "maxOpenInterestLong": "0x36306db41065a9ff0b80796d65c397fdb82feb0478876df11243ce8441c80442",
+      "maxOpenInterestShort": "0x0e76c80c44accb13dff368ae386a5f7ea4431453231552223b06d54e4436c2a9",
+      "minPositionImpactPoolAmount": "0xf532ebf558f007c799e40efcf925d5c8b0a54d20fa5a5827b98651c8fbc0d6a1",
+      "positionImpactPoolDistributionRate": "0xdfb096f793983ae1287c615cab10b12b9b78aac824cdf75f4555aaaa6c126c8b",
+      "borrowingFactorLong": "0x6bcb1c43b78a3699cc620c81d1913eab8fa38bdbd0ab09f278b1ffa3cf3fdbf5",
+      "borrowingFactorShort": "0x5c74aae37330a55a343662dfa6e90aa5eb8436337a24bc5ef6bdbb0184382746",
+      "borrowingExponentFactorLong": "0x0ffd6ce396e5ecd7bf6eb7f72c1904098a749d5778697b228d864900c43a085d",
+      "borrowingExponentFactorShort": "0x7a83fda1755ae48adc568c095c433b60a5fa8e185d2c0d048a7da5aa9c58fb37",
+      "fundingFactor": "0x6553e6ae127cfe5faac7b998815419cd3ff538d7f5119095ba608c1e06fd3c48",
+      "fundingExponentFactor": "0x4279f11a70c0e464b3f4ac316332f50c7c39433e7e8415f5d3507be3f9206254",
+      "fundingIncreaseFactorPerSecond": "0x15baa5f7d714f06984bab3b1a6e277e6afb0a48bc6d111c4bdaaf481945d4b33",
+      "fundingDecreaseFactorPerSecond": "0x255bb64b67c537678593fb60a785fff37eb4434e26dd8bf832dd2814733dda8b",
+      "thresholdForStableFunding": "0x54dd03fb88b75dc954f40a355526e9c8482cc98fc0f3968474c014fe1facee40",
+      "thresholdForDecreaseFunding": "0xfa037a22ec153bc6db4a99a10da601c82c9501e6df9e62291ba5564a97e5aa78",
+      "minFundingFactorPerSecond": "0x19da90413997cebefe8f8ea7272d94f356a7b8a4e8c79c08ce1752e02fb1a5df",
+      "maxFundingFactorPerSecond": "0x84b82ffe4834b4f94641d9a3e2a60fbc0ff1d7e4937d430ee80a014b13175f04",
+      "maxPnlFactorForTradersLong": "0x5c42ebcdd5cc73bbf367156af70735b25897a6accb5699e2dd442a3e7aec32a8",
+      "maxPnlFactorForTradersShort": "0x4845b537832a8b591e75676444faad0887e9747c7624c43298a64ef95d1c2d9a",
+      "positionFeeFactorForBalanceWasImproved": "0x379014e598d8d0024d508ff729cf9a31eaa22b3554e89bce3ed00e48534e7c5e",
+      "positionFeeFactorForBalanceWasNotImproved": "0x62a50f7f748ef2572aa3c3f6f486616ea33a0067bab4b7269610a1cacde6300e",
+      "positionImpactFactorPositive": "0xf181edeb1432f629bf14e39df272865fcc52c85bc89c06fe329eead795328349",
+      "positionImpactFactorNegative": "0xb409ce5f332ad37f5a8f1dd25badc32e20e7526c80ac6cba8faa43afd32f748f",
+      "maxPositionImpactFactorPositive": "0x9acf59a110f586200c0fc1906a2b18a23d3033df529808b6dcf746e8a235e46c",
+      "maxPositionImpactFactorNegative": "0xcf04d976c885aa14b78007f6e63a843f74393edd54f99f8d0c8f9878a33f87aa",
+      "maxPositionImpactFactorForLiquidations": "0x78534eabae34614434e9cbca171a7f3521bb40e26621d621fe9f1280a9eeea7a",
+      "maxLendableImpactFactor": "0xa2b52b7d280ea3167644b7d1d88aa7490627ba799fdccba28117f2723b8da2e3",
+      "maxLendableImpactFactorForWithdrawals": "0xdcaab1fd6f8489a043f5b64e2d047a783e8614c7a18f156c8f1748f31fe890c4",
+      "maxLendableImpactUsd": "0x8e1e71664e9351f656f66459f64b2449d5523d9e7b35a9db3c7bd579fad8ac62",
+      "lentPositionImpactPoolAmount": "0x264b7391ab282f4bfa197d75ab376b16b7478fcd9792ed8635ba82a3a16bd279",
+      "minCollateralFactor": "0x9286a24a3b626cd4b440c9ebc31ce5a5b709c22f2f4acc917c3135cac6b26ef6",
+      "minCollateralFactorForLiquidation": "0x8ed79f4e6d3d38bfdfea170a01f66193eb1ad238a766ceddb168e3621d7eada4",
+      "minCollateralFactorForOpenInterestLong": "0x8c69704d7ad8d47b8fc79dd9f203c622ac43de9aaa60e25de14b70468e2d9b25",
+      "minCollateralFactorForOpenInterestShort": "0xfb46f190074aa0025c421e05d226229b80b32da2a638dc566c0ee9b31a62b25e",
+      "positionImpactExponentFactor": "0xfa76ae24b59f8ccb8233c444e1d247e8e7dd78cdb2a7e1ba29dfbb782c4d00da",
+      "swapFeeFactorForBalanceWasImproved": "0x9108de9102344a53cfaba2ef2d276e027bb6b4051c3e818d7ecbddfc291f9e1f",
+      "swapFeeFactorForBalanceWasNotImproved": "0xac6ef53ecc38b138b10d39e00eeabffd9e05f54cc9903fe59702b86960bef8c5",
+      "atomicSwapFeeFactor": "0xfb5cf4b45d7ee1149347aeb46aef578efd22e69901f21d1f4092a2a870c59a33",
+      "swapImpactFactorPositive": "0xd6c74362814ea6fd65d9379cfd8fe06f850ac287b75940fd77e0bdc45264edcf",
+      "swapImpactFactorNegative": "0x1db488bdc1bc0726b938a5242b366c388f4ee2152ebfa088e8e35bec3646688d",
+      "swapImpactExponentFactor": "0xcc4807baa2417c31f1cb6b99b84cfa7be11077af4704aa12415f80c2ee7c50b8",
+      "virtualMarketId": "0x646b9cbcf92ff6e208db3b2e7267e1a70f08248b5233dca10c246d857ca6be9f",
+      "virtualLongTokenId": "0xaab37f889b9680dda34f58a689de3023cb22f7ae14d32a3c1d45798a973db1f5",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x9e79146b3A022Af44E0708c6794F03Ef798381A5": {
+      "isDisabled": "0x0475e2da2f39e86b13e17a8e1a5e41a323a9d501601c1bb88994c6b65a70a93b",
+      "maxLongPoolAmount": "0x42954675442295d3714fbb9445290f1a185313a3884dc857fff6745717953296",
+      "maxShortPoolAmount": "0xaec9a45bc874244034c2ad2857b2a3259e4dc3d552e09965b25f7e84da58f32b",
+      "maxLongPoolUsdForDeposit": "0xeb5ac490d65718b3a24c76fb1965ee15280d06647768fae12dccdad0119fbf42",
+      "maxShortPoolUsdForDeposit": "0xc1cf5052c31e50b5a66421b14d44a4e31d178c402a09b54bc6171746e2529a4a",
+      "longPoolAmountAdjustment": "0xca88d303fbee247afaac509fc3d02a8ede2a4b390cf945179c533d9e17bf61d9",
+      "shortPoolAmountAdjustment": "0x9d46fa266c44ce0a39150b67fc950ddd69255adaa00990372c35d11e8a5beba5",
+      "reserveFactorLong": "0x4f47da17a37d7837b3dd2621065be3fb526b5cd6ea6039f5bb22ef6e164fc77c",
+      "reserveFactorShort": "0xf992c464eadff45eb6c9103dcb095407e1b4be63eeedd2714e581d6c5cb91ab3",
+      "openInterestReserveFactorLong": "0xc111b6a58504211e22ab86879f175bda0ef2079b56ac91917f468a9309214ef7",
+      "openInterestReserveFactorShort": "0x89ba613b1acb6fadec0a3ccd945948362e31ce4ce41125c23808c1e1650dc9ce",
+      "maxOpenInterestLong": "0x61003fea7ef0390402b8880dc5c7318983fbd29cb8af534c2a1602408d9ece5d",
+      "maxOpenInterestShort": "0xebb55df130bfd721beffe07225d4c6f8911d29471a1be131498fbce1051d8d3f",
+      "minPositionImpactPoolAmount": "0x5683f92b4d50ac2a7bf628d1ed5a621c353416625e9f4380a360e80c0cff2e8b",
+      "positionImpactPoolDistributionRate": "0x141707092a7c67fbf169edb35c5f6f32fd5e2c9827401f8e5163050b652330bc",
+      "borrowingFactorLong": "0x0ac928e16e0c529cfa3e4866665c84847b657a700dea6a2a544d3477009d9e8d",
+      "borrowingFactorShort": "0xaa3f09c11dab27ac77dc54003dab98de598d3b22e4b9d7f30ec5e35de93c4eaa",
+      "borrowingExponentFactorLong": "0x107cd66ddbebcfeef67a74a73befe18642aca50e6ff3e95fb91630131a38e046",
+      "borrowingExponentFactorShort": "0x6e5c87fe4d1883f550aaff9984a14e1d65374c957e235d50fbc9bfebd41e37e5",
+      "fundingFactor": "0xb149941729ed3f405716376aadb0b5404cf6d268302f9dd640e94c76fd901b4c",
+      "fundingExponentFactor": "0x4be927fc7660fec6e4318b03f28d80aff171bae012fd27269381927a599dada3",
+      "fundingIncreaseFactorPerSecond": "0x62981fd31cf930bf83646d6d3be33c6112ec792ba00bb7fefcfd935b0b20a261",
+      "fundingDecreaseFactorPerSecond": "0x6d917b5daf3037c11cbb91db06bc94fea6fca8d2dcc5985d34f815391f5e37a2",
+      "thresholdForStableFunding": "0x0d4088b56189b96cc895f2e91fcb3422412b8ce668cad0dfb7b9313fd6f23e39",
+      "thresholdForDecreaseFunding": "0x57a218d6772f7ad7f70acf0c1c560986e9e9f8650dd1b345dd51cf5b75d01362",
+      "minFundingFactorPerSecond": "0xc507cbd3b72aa55a01c68755dd2ad2683027353e1e10e3e82c21e4d71f1a68a6",
+      "maxFundingFactorPerSecond": "0x3c9d9d1f111fa67d6bd93cc0f9e4a1a5c246a21a0ca8f42c669cdd823bab1b9f",
+      "maxPnlFactorForTradersLong": "0x4a26b85b0edbcc0d6335cf602ad6819e51cf6dc24e391701e6bdd1fcffcd4544",
+      "maxPnlFactorForTradersShort": "0xa96b85aebd11c974023e9971202a74e79c3de43f9c6d4f88c15f593aed77c6ca",
+      "positionFeeFactorForBalanceWasImproved": "0x08e0db12c4cbc02b52715243b24006c9e0b1ae4dd8a65bc497ce4500a7759354",
+      "positionFeeFactorForBalanceWasNotImproved": "0x7ae5c5977ac6c2ff75b5c33f55891a1ee92ca01a91cace6d34537f7b086d0e39",
+      "positionImpactFactorPositive": "0x0944db16ab1c5ed44b2f30434f9b1f20b11406eebd67e778867da43b508b1b85",
+      "positionImpactFactorNegative": "0x2ff6188ffe909ac033eee6b4e28cb823b6c9a8160eb32606cbed952f9befab63",
+      "maxPositionImpactFactorPositive": "0x44c15ba958ee8bbe1a9e5c73c10b75c6936ba34584c9547fedba2728646ee3c0",
+      "maxPositionImpactFactorNegative": "0xb4224d32c2294853cc1b30f309298e68e81abe215cf8f950ce667e6bfd815874",
+      "maxPositionImpactFactorForLiquidations": "0x4a45d8c9790fc0c140182e1495bf7db53c570f70d467d247a75abbb6e4c7dd94",
+      "maxLendableImpactFactor": "0x5aad15db5c0aab031655bbfcdce39721a019dd89143749bb04023c66b3981402",
+      "maxLendableImpactFactorForWithdrawals": "0x7b26a8a4a53b3f84d684319a11f37d5f04064a23c6547e6e80b051a079838fff",
+      "maxLendableImpactUsd": "0xbaec5d6a4eb97c342d5c7755b10a84cb1e91c2d325ddebf0fc549bb0a7639b6f",
+      "lentPositionImpactPoolAmount": "0x1836572fb0e199827d3336bc96133057527bff84368ac582fb0cb89c757b57a0",
+      "minCollateralFactor": "0xd47ee119ab4e108c88d288443718f11ca44df176472339b0c35e2d6ae56d3ec8",
+      "minCollateralFactorForLiquidation": "0x426ce46062a702d0d68326ca347a1fa5d705087d2b43789dd0310835cfdaa74a",
+      "minCollateralFactorForOpenInterestLong": "0xdbaf0c15b855b2a4e1a68a581469b8c5d15f803cdeeb711edb1640fd38715903",
+      "minCollateralFactorForOpenInterestShort": "0x9500d9c8dd829f81ebe5f3ce2e2346a105d682ef0a0d35b37aeac9aa198cdf04",
+      "positionImpactExponentFactor": "0xe0b1128fdc394a8c3371e2492ddebebe5899f40de9d868c640a7b65d7bdf7626",
+      "swapFeeFactorForBalanceWasImproved": "0xf7babb8373684c29ab67c7c832c6c4b2c9b94b8a48076a67d20626bb86628c7d",
+      "swapFeeFactorForBalanceWasNotImproved": "0x4f1228c156db69f770af6b10bd34a80b2fef41dd296f68fb8ae17e9f3dfe963a",
+      "atomicSwapFeeFactor": "0x31d209dbe461712a524e488388590e9540ae49400a417ef88110f2a7a977d43a",
+      "swapImpactFactorPositive": "0xb0b789da107bc523fb4849e8957a7d3df09235a6b2850f32e32fa6c800fd2d13",
+      "swapImpactFactorNegative": "0x3bdfc565c4eef3a98276ee71419fdc582ba1352266adce60e15cae7b1ab6a3a0",
+      "swapImpactExponentFactor": "0x2150168ec28af7f2a71556e78768f46722025ad4af9a7ea8963b9476a4057d90",
+      "virtualMarketId": "0xc3cb64939a0fe2585e655310db6325240adf5db6d3f8a1e14e40ea4d8c97b680",
+      "virtualLongTokenId": "0xaab37f889b9680dda34f58a689de3023cb22f7ae14d32a3c1d45798a973db1f5",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x0e46941F9bfF8d0784BFfa3d0D7883CDb82D7aE7": {
+      "isDisabled": "0x48e9d756d99adca3582e1e2d6907fd4b49915e259a79d1530d3a8efdaf4511d6",
+      "maxLongPoolAmount": "0x45f22bb0a2938e19ed041098cfd39553b185bfa8b6d6adcdbed75d8931804d63",
+      "maxShortPoolAmount": "0xc9577666dafcd72418eb60bd26a2de1fd9474e7cf6d33a00450fc9352f6fac71",
+      "maxLongPoolUsdForDeposit": "0x7bbe4dca750ce372f626f319110737665f10e1b4acfcf57d399557830796e233",
+      "maxShortPoolUsdForDeposit": "0x042311f216cbc8d64c84b970d4e0a3b80df8b5196612f1f73fb34102f80d3378",
+      "longPoolAmountAdjustment": "0x1a9bfacebabd4cb9b5da041b000aba3f5ccba2e95b664be2cd3da904e8e729dd",
+      "shortPoolAmountAdjustment": "0xf00763aac312f4f805d5ed15698c4c7c43d4de960942a7a0c71ef620d71dc53d",
+      "reserveFactorLong": "0x5a4bfd5d74dfb1505b78c9b78c3cc98e80e3163dafba129990c97afe6493b65b",
+      "reserveFactorShort": "0x7d0d95a75ee466f326a296cd3f41a25acdee9899f77edebffd698572d066fa06",
+      "openInterestReserveFactorLong": "0x1be139bf5400292c13c9bb69aeefec3a71607b28001bb9d0b189ac6d4210d440",
+      "openInterestReserveFactorShort": "0xa635d27eb1867244b6ec328617b976bde4d14a871e6b89ef8bf1f08180b7535b",
+      "maxOpenInterestLong": "0x21a20e7f030af6419998a3161b987e9bffc8b7091337a1c503e9b5ac8d401267",
+      "maxOpenInterestShort": "0xcb53433a62956ea5e45f724f9fd04321905f25afe5acea23e0a156ab22c91fb9",
+      "minPositionImpactPoolAmount": "0x98217fc8af319cc00d5fb84627aff2427eef15b5526726da08a6998da89d990f",
+      "positionImpactPoolDistributionRate": "0xbfd832619b3bb8d2e10d5a9f7f85bf84d0bf6ebb5e39ffac5ead92f1f6170819",
+      "borrowingFactorLong": "0xf62d6acf3468a23f7638f527c24b15a5e15770e1c27537a02db357b50ea5b761",
+      "borrowingFactorShort": "0x5eada4685d136b056c60bd5c22f01c6279232eb1c1115137ded2c16f32a56d3b",
+      "borrowingExponentFactorLong": "0x2644db7f9e8efab37355d932105b06a6384829d737fc63fcd696d4890c22c14c",
+      "borrowingExponentFactorShort": "0xf98a6945a743e0e67bcf58b0c8497ec72fa074357b7ed0d89d8ec0ee2548d029",
+      "fundingFactor": "0x4720d3bbf3d8db93fbe8d9ac817f4d4ccc5459c48e5985b8ad30ce14d69e08d4",
+      "fundingExponentFactor": "0xe12b6be31582f9c8495b740bf33b302acefdb239deaa99529d8684e48af92479",
+      "fundingIncreaseFactorPerSecond": "0xc299670a2b9b643e9f06efcb00559aaf4a654ef035d95ddea7bbfe4c5122a920",
+      "fundingDecreaseFactorPerSecond": "0x03bd7b4bdcc8a28d6e4757021490815210b8af8c46fe97e2104dfcfd0ee83484",
+      "thresholdForStableFunding": "0x0f5d0bd7852f8450a28fa0ceb472b808c72220241bbd4f89140a857b8bb5e798",
+      "thresholdForDecreaseFunding": "0xbb7f83c59e6db664d09d021eeee436638318193ed238c78e602c75ec47384029",
+      "minFundingFactorPerSecond": "0xcc874b4277fefcbe20b09eb25b561365ca0b37b9f9e73b762d2ee7b9aba2c341",
+      "maxFundingFactorPerSecond": "0xc95e5766d063b66a9e4d828a8f343d3605b797acb939d8052f7cb165f12a720b",
+      "maxPnlFactorForTradersLong": "0x69314750ad39f2f926595327d9d5783f3a5792f33631e9218dcad706b2ce94e3",
+      "maxPnlFactorForTradersShort": "0x917f17d9d3c1f59b94587197bae5b84ca8b68cdce19ec0b0adb596e165a2ae8d",
+      "positionFeeFactorForBalanceWasImproved": "0x4dab4716911af2ebdc1d72a2f2dc28f991adae1052770fd33ecba110bc7513ac",
+      "positionFeeFactorForBalanceWasNotImproved": "0x69a65a7c1becf35bd454efc07b02f5463d4e2b98fb575ba61e25e43ad7206655",
+      "positionImpactFactorPositive": "0x5e6e2a363e7c6f89c43d49f1ba94149d918067ab1b7434f796fcf4a2f6c3fead",
+      "positionImpactFactorNegative": "0x4e8b3ce015d13d1bb91d976bcd74334b6cfbe4e745fb898e6c012e2c19c0f8e6",
+      "maxPositionImpactFactorPositive": "0xb47910941cab06e9dc81d5662459e379e94e34b4dfbdd0c7e28fad6ad30e3e76",
+      "maxPositionImpactFactorNegative": "0x62ce4f0b286c8db680648b24acd47740f9e6d7a8be4c30cff769e41baea09719",
+      "maxPositionImpactFactorForLiquidations": "0xb472fc0d602f85dcd632ba64a9d563a9e46b83be79ff10fc84eb335346d9bdb1",
+      "maxLendableImpactFactor": "0x467d5377cb56667d1d0cf31bc63a7ceb4e120ead225195e3958bd30b44bcab7e",
+      "maxLendableImpactFactorForWithdrawals": "0x33cefb6f183a39a21457eebb2b74243010381d99af3f692e1860da516b1ca501",
+      "maxLendableImpactUsd": "0x81d4f9b3b66d42b3b7c3a3e9749146b8bff4969f429869f2094c64f8f1907778",
+      "lentPositionImpactPoolAmount": "0x039e702c728c5aa1acd7ea876e6337100d957dbcd32116f79bb8916122e4202b",
+      "minCollateralFactor": "0xbe95285a19c0ce88607d7b14c5230c60f53503455db2b61c3020f104d5ddbde0",
+      "minCollateralFactorForLiquidation": "0x79931b37d86fd4e1c24760f0d9c923458a505993af2db87ae125d2fc1d3b69df",
+      "minCollateralFactorForOpenInterestLong": "0x2a6d115de938ad85af12ca1d26a0f6644a2fe0599b2ab86f8acf87cb5624ae5d",
+      "minCollateralFactorForOpenInterestShort": "0x1ebd2256b3e588b811528c35ae535b13a6318727480afd98deddbc5642ccbc3b",
+      "positionImpactExponentFactor": "0xb245771c3ae81dfd3366eedd6e85e62cb81ded22f089f674bea08570fc61eb0f",
+      "swapFeeFactorForBalanceWasImproved": "0x80dd606da911d750d12feac8732c5a270c3c995c4ca3d3e54079dbac2379b81e",
+      "swapFeeFactorForBalanceWasNotImproved": "0x383121b58b83900c41c948bd2c559ea94adb05b4056fd61bbad4c59e84769e7c",
+      "atomicSwapFeeFactor": "0x4f9d4884fbe826892eb18a9bdc05b6e6dc722527913d699264560a50c0939931",
+      "swapImpactFactorPositive": "0x4bba0afab3bdd086e0cd858248bfc9a06b6a3b70331b7d26f8a7bfa935a4359f",
+      "swapImpactFactorNegative": "0xb354aac74baaf2cae90e78e7317392d514e57f555419d292ed80602fc3024b5b",
+      "swapImpactExponentFactor": "0x3b626f7eeb3d00ff95435218d2281154df74f515871c5010bb41b615d661ead6",
+      "virtualMarketId": "0xe490a941923b41502cc755ca86b51323d6f8d70df4cb7fde8dd2fd414120c7b4",
+      "virtualLongTokenId": "0xaab37f889b9680dda34f58a689de3023cb22f7ae14d32a3c1d45798a973db1f5",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x2523B89298908FEf4c5e5bd6F55F20926e22058f": {
+      "isDisabled": "0x6fdaa292fb3d569f026a7b1377bcc38355ec68e6fd18dcce996294e671890ee9",
+      "maxLongPoolAmount": "0xa55b6749550ee8b2a6c83a6600326e8c4b405fd4daf3d3364b6c108b216b6bdd",
+      "maxShortPoolAmount": "0x46f1ddcf1db79f7de7f47db9e446c9bebe37bc832ffc22b86b2d486cc923d083",
+      "maxLongPoolUsdForDeposit": "0x55bf3fba6701e6bc184b9a8be55c013094cbab20a0f80fbbfad87742dc88a348",
+      "maxShortPoolUsdForDeposit": "0xbe48025d93d804b71e7d0e6eb833b93bb859ca72d9628c9bec9e8f8f2442f190",
+      "longPoolAmountAdjustment": "0xed2dc69741dce989df6498bbc1d9833e94efdd594d69fae8243e92a0e8c03a20",
+      "shortPoolAmountAdjustment": "0xc2ea08307318387a3056a25b95ff9ad3464b41a0146ea919f606ef104516d557",
+      "reserveFactorLong": "0x6e1e1ee781d28806c8e9fdbda5a0549f83816c35730a96de6ffa648e57a41167",
+      "reserveFactorShort": "0x2a4c0746c4eea79b07c901c5bf9159b54a55fc79a884c1ef8ab840a79379456a",
+      "openInterestReserveFactorLong": "0xc1e49088f6b665aab620380747216a5eb6f9e364f5a8b25119c869b18cb3c395",
+      "openInterestReserveFactorShort": "0x24af8fb21fe2435834b1abaa581fb5a6f72dd2b9e414efa6da806f29d34d3c4a",
+      "maxOpenInterestLong": "0xfaa35d157e7f90e7cd5eb03a474d08746038cfc24f7416dde2d5c5aebe936462",
+      "maxOpenInterestShort": "0xc1477ed76fa09991cbaa1f6f2f6b84c60aea2865d3fd6deade9a622a056d15b3",
+      "minPositionImpactPoolAmount": "0x3e6e00f86558dcb2dc71da86ac1f039fc26b3b967c2f4237868db0bf9cc6aeb0",
+      "positionImpactPoolDistributionRate": "0xde9c776b189459473b36b0d69e916aab68904d6b7252043b30c10c9ca79d2311",
+      "borrowingFactorLong": "0x4c5dc1267da11dd149dc6cd4e506790aef14de55e4aae90f859ea166e6086780",
+      "borrowingFactorShort": "0x857947bed3eaab9c39cb9b855cb93392e28d4476b009f9a9a835215f26ba5835",
+      "borrowingExponentFactorLong": "0x87d71c447834bea1f7c9eda3bb666a4a6bc24484867353c41074deb72506753b",
+      "borrowingExponentFactorShort": "0xbad81c3811939f9f85c5df56ff4456a34de86483d07acccf00e8e2f500be2a3e",
+      "fundingFactor": "0xd52322fc5f7ea41b649c45d80e2d179ba2d45a2dbcf0518b043f8a5034b7ac60",
+      "fundingExponentFactor": "0x069a9166b718e6fe40d6a1333bfc2cf6102412b50739c3a40a51aab4752a9a85",
+      "fundingIncreaseFactorPerSecond": "0x35176d1affa78348d9d4fe86ae695bc5cf32f765545bf36a3e93ae92fdb8703c",
+      "fundingDecreaseFactorPerSecond": "0x53c84ed1e070b7df333db2e6678172b8c11c9bf827fb41c56e81d4b208c767e1",
+      "thresholdForStableFunding": "0x5041d05055d191d852bc4540f379fbe94326ba0cc21e56240ce6ace6c965c8bb",
+      "thresholdForDecreaseFunding": "0x563acc20bb3e628fc4783351df05c7866e4d7b327122ede255903cdfc4d5f4e0",
+      "minFundingFactorPerSecond": "0x368bf860d82a6edafdb435c130acf3fe9dbe9e8b9a61978fafd0aa8dad15fba0",
+      "maxFundingFactorPerSecond": "0x3b7e464dcc32f8d2c77e860a0077bb7b6e7fc8714ace34540f4b6729f2eac88d",
+      "maxPnlFactorForTradersLong": "0xb208f47a51944a9a40b2a68077be5ea5fb7056fc84e61b956d48c8ceec66bc12",
+      "maxPnlFactorForTradersShort": "0x837ea7e37d8fd9b843af71b7807536a04c768cb06fd91ae0e50ce8dba9666314",
+      "positionFeeFactorForBalanceWasImproved": "0x1f39632e8494b846449daae6b44f2092a07a39491e40fe93a9bf4db709fcc668",
+      "positionFeeFactorForBalanceWasNotImproved": "0x07e92106a27e33237eafa3dafd9f7c37e6ad36c6f6e5ab7e0381c751bf12879e",
+      "positionImpactFactorPositive": "0xae5be4d434eba0b99dcad4871a12edc786a7da4fc7a10f3af9f1f64bc45bda4d",
+      "positionImpactFactorNegative": "0xd306cf22995c236c2a25bcada07a1dce802918a16cb408e62c4c52df3bd940b3",
+      "maxPositionImpactFactorPositive": "0x4f8676b09189ae01e2d7895f06b00bfd93fa644c104976a0e56d0ca82bd5f4e4",
+      "maxPositionImpactFactorNegative": "0x92dbf0ecb90d8a9d5f8448f53a0ab2220070f4836fd4ad0f375f7b08841fbb73",
+      "maxPositionImpactFactorForLiquidations": "0x9b98aa2ed2c3185e82bc076abca8f66ecd35ff266e183479fba3f0986da0693c",
+      "maxLendableImpactFactor": "0xa200fdbfcb8ef3419f225c8ef2645f7c51ac78632d1d7c0b38178d02468cf5af",
+      "maxLendableImpactFactorForWithdrawals": "0xc92ba1efcc554e66ee1429f7f948f37e6c8d909a1821c89b3f56b77dd257b95c",
+      "maxLendableImpactUsd": "0xaac0b18a1002ea6fabf3793aee54fe98a640085f40b14daee9151ab652d97555",
+      "lentPositionImpactPoolAmount": "0x90e3f8c855ef37b87b1556a3ba6f520da85308d2845ab662128630c1895f37b7",
+      "minCollateralFactor": "0xa213ede0599ac0ad9d8d63cdfbd2bc353b68313ea17ae036bcc6b12ba1f3b46f",
+      "minCollateralFactorForLiquidation": "0x53242e803c0bb6381c1b5c42a8fcd00b54fbbe85995488a7a5dec6f225a5e5fc",
+      "minCollateralFactorForOpenInterestLong": "0x52afa3711c1e690c0bf7e156928aa8384c28f540b26fc9b607b05ca73c18bfd8",
+      "minCollateralFactorForOpenInterestShort": "0xbad6087b3466806fabbea91fd5fc6f95036dd696fda16dc077d0b562c1ea1889",
+      "positionImpactExponentFactor": "0x0b1c98df3775838da85a0fdc248a1cf9af5f8bd89a1a352595f658ee771f879a",
+      "swapFeeFactorForBalanceWasImproved": "0x0742e3f8db96ac05a07e004082428d900b556728a65c070a50e583aadb586cde",
+      "swapFeeFactorForBalanceWasNotImproved": "0xb0bc201c5b3d7ab2b6ae7430be01c9c0e53c7c22156ba22a14e00d5c4a0e44ef",
+      "atomicSwapFeeFactor": "0x5ac6e757ce8023173330912b9cf86157c369be3398b55ba4a7c490064fa6a5cb",
+      "swapImpactFactorPositive": "0x05b1fb95bc342c7618a883a763fbbd253740020c12568b3c5841032ee9a91fb8",
+      "swapImpactFactorNegative": "0x282f8a9226a14b7842f6da9a0232abcd867444a585257987dd9f5335a699b1be",
+      "swapImpactExponentFactor": "0xf12e162b0a4966f0b9769f68c3f3ed70f23caa0dcac8179962db95bccbbf1d09",
+      "virtualMarketId": "0x6cc33f61b23e39024011f4ef3b29a1ac5040cc0b0b1e7e879f90f5a536142ad3",
+      "virtualLongTokenId": "0xa59040b7efb6b7122a74cb318a192ebc6732849dff5332ee3ba40b90dfa0a04f",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x7c54D547FAD72f8AFbf6E5b04403A0168b654C6f": {
+      "isDisabled": "0x53c177fc7887f08a231c27c5d3d281810e5022bfead7d27d816494ab2e05e458",
+      "maxLongPoolAmount": "0x801eec4042c933e8df4dc560b4c45945cef8ecfc94e3537dbb6527c1ce304266",
+      "maxShortPoolAmount": "0x8cb5d7533c40dec81cb83952142852aaf60dd4de259cbef5d84bca9d8e7e05b4",
+      "maxLongPoolUsdForDeposit": "0x6f956443409da8be34877d16bae0e28ba398ec7faaa289b17187104c68ba1227",
+      "maxShortPoolUsdForDeposit": "0x901e985de7a8be80fb492112e6ff8e73e8643399d56dc558af3f0fa71ff3757b",
+      "longPoolAmountAdjustment": "0x06486548446d487486ca44833c29c8996a9c48ae030e25ce6a9bcaa6c9ef61e2",
+      "shortPoolAmountAdjustment": "0x6168b4e4efe6ca8a7926560b97cfc6062cf561139f4bcb80a07c45f17e34ddd0",
+      "reserveFactorLong": "0x2b2a2e18ef35c21b1d585f64d191d58e6ae6f78aaa746441c698ef902bc609ce",
+      "reserveFactorShort": "0x67e6d0a23faaced9d1c3405af40573f79767f021ac02ab5438d3f865fdeceb0c",
+      "openInterestReserveFactorLong": "0xe9e582f5b857962164478a78ecf838737e0cd83a146a5d74ca8c7c9dd4c51fed",
+      "openInterestReserveFactorShort": "0xe59e058ba7579752ff8893c518531b0c6004aecaaaf9ad3364c9e55cabb061e0",
+      "maxOpenInterestLong": "0x0a9f3bfcbf01a37bf5a7128ac82df59029306868e5cd1e51ed89f9d13e42b015",
+      "maxOpenInterestShort": "0xdb63d69d43bae876c4206f4e490afdf3892e9b82840d91bdff41ab2a8eeb432b",
+      "minPositionImpactPoolAmount": "0x4c2ce2d727fcb76997711946b816f95151d194ea3808b9a8cab2757c4613d6d2",
+      "positionImpactPoolDistributionRate": "0x196f754602a5586a734ef2ff716bed6db58f5f2254377afd46afeca9d47c5970",
+      "borrowingFactorLong": "0xbdd4087f827457c745a4ed5c546a12356f1a7c08ec2cde0d989ec405b3b79eff",
+      "borrowingFactorShort": "0x5fc22d90489f8908d8968ce2ff481f093045dd1ea8a27de3e34642d948404e61",
+      "borrowingExponentFactorLong": "0xaf24d73cbd828940b067b51bd4066794321c3d4daab2d94fea64ebff3e547d41",
+      "borrowingExponentFactorShort": "0x166bb008b2872061035968a58c9625f1e8e3a655479f8e68da7c736625f0154f",
+      "fundingFactor": "0x614441cfc2efe943c32181880c0cd30085df816652c4b964fd69cff1739cee34",
+      "fundingExponentFactor": "0xf223504ba91e4270ac2a11e51079ec5c47095857eecdf449c837ba03ba63b878",
+      "fundingIncreaseFactorPerSecond": "0xb7e1967295d8575f29fb008b296c716a64cc7d4ab4e321524455e55cc1e38d19",
+      "fundingDecreaseFactorPerSecond": "0x373d34e95c107fbc347a1130e5c642972668b7f352464e668df6f0a32dd24b4f",
+      "thresholdForStableFunding": "0xda8c7a66eaf5b7efb25a9e7267f27e776a2f09ed5ad5d497069c256b38d390e4",
+      "thresholdForDecreaseFunding": "0x94cc4b8b360197538a782558ec3814940247c809c36472a3b9f7f3ea475b2600",
+      "minFundingFactorPerSecond": "0x7e7eb9e4be0471ae51b92011e6cf8952cfef919d705eb6687e437a4188326cd7",
+      "maxFundingFactorPerSecond": "0x905535745f7dcc7ead3aa76a0505be53c7023ed5513d92b1418438b715038a0d",
+      "maxPnlFactorForTradersLong": "0xe501de2bc8a93d96072b609a4fd425fc203869cef4c669dd5fb53c8a6c87783d",
+      "maxPnlFactorForTradersShort": "0x37d75f0c5eeee8bdbd315af93d214125900cf328a96dff2a73e020f133bd3f28",
+      "positionFeeFactorForBalanceWasImproved": "0xba562318f5a151012be658e077d0d12ad906a8842a0a842a00cc28548f25da04",
+      "positionFeeFactorForBalanceWasNotImproved": "0xdbcb16c248b9bf77d2fad4161594283cbf8a2ae70cee09903580ba9d7db32b7b",
+      "positionImpactFactorPositive": "0x35db73cdefabea11f6cd0fa43405fdda2426809523af9751022b923c4b11c3f6",
+      "positionImpactFactorNegative": "0x7e8250a02a5cba229d6b061c7c308617c8276ed6bfd08646425add04874f30da",
+      "maxPositionImpactFactorPositive": "0xb34426026ad3844ff8e007e94303faf42789223dfda616700ff05ac9bf3fb53a",
+      "maxPositionImpactFactorNegative": "0x36dd4505b6a81d6a5d330cfdd00766abdf2b82925c43913674f06cbed5c5f60d",
+      "maxPositionImpactFactorForLiquidations": "0xedb4f51e93d6c8f03b0d81b69fdd15e493cca80bd51f35deefe354fbd9955f01",
+      "maxLendableImpactFactor": "0x452079f0f8e4232f1216d0e1dbc9899ddbb111cfc95fd67d8808bff645b9a676",
+      "maxLendableImpactFactorForWithdrawals": "0x4aa8d9ced2923efa1e9c767e9b96bdd98d460e517dd0638183d8e3540daa3b48",
+      "maxLendableImpactUsd": "0x6bc54f3ce9aeb8b08143f67bbedd05eec9d60aea96adcb960f288f6eaddbd863",
+      "lentPositionImpactPoolAmount": "0x7cd92d2fc980d67d61a33aac2a96004487fcdef64192e5424ca1aefbcfa21ce2",
+      "minCollateralFactor": "0xfbd9db0e5bcf95a34b4d52a97caee4aaacf32e91fea52fb3d0f6eedaff6b16e5",
+      "minCollateralFactorForLiquidation": "0xad6053c2d0c04fd2f4bf6806e2dc774d14481617371e602cbc76a83e6bb47d6f",
+      "minCollateralFactorForOpenInterestLong": "0xa7fc29d21ee4ffceb464f9889c70a3c5f92c8c48dbd5ffc824f088dda4b7515e",
+      "minCollateralFactorForOpenInterestShort": "0xc50491facbf7c3258a02e4353a0a8ffe64cc09fb4e9b86c8128e56b23b86d861",
+      "positionImpactExponentFactor": "0xa4552e9093aea5811829cf3a7fd9fdf23f2e84611cb07ff5aa35358e0b63be97",
+      "swapFeeFactorForBalanceWasImproved": "0x193d6f23c11a79d96b193a6e7cf4b05bbb7992031f956951ce396da8ff34812b",
+      "swapFeeFactorForBalanceWasNotImproved": "0xc6c49c25a6e5ba44da9722086f13b338b228602a55b3f441cf9e3088ae7bf488",
+      "atomicSwapFeeFactor": "0x2d9e442b1a976ff0bfc39bce6bc7316886f81ca7027007be437ef906d687f99f",
+      "swapImpactFactorPositive": "0xb410710dbae13f219397473794d9620624cfe337962ea6caa4a702e0ee64f15c",
+      "swapImpactFactorNegative": "0x789b271f70ed1b702855f3068f9d21c8443b15374529527d1a2c45c1cb7664fa",
+      "swapImpactExponentFactor": "0xfaa7cc800a5f080908196db817b1c00d6453eecca60a3854e890979ba0ccc5a7",
+      "virtualMarketId": "0x19b776cf74673f319867c1568f4c4ebc7e1281d5d2ed2086ae981688eb1d2a54",
+      "virtualLongTokenId": "0xa59040b7efb6b7122a74cb318a192ebc6732849dff5332ee3ba40b90dfa0a04f",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x39AC3C494950A4363D739201BA5A0861265C9ae5": {
+      "isDisabled": "0x30460bc98ef446074a0dc87fc270dd33d63cc176da5ba37905bb19b9c4a70618",
+      "maxLongPoolAmount": "0x781da7775f0a98e21da7b615ff3280041f8a1e7cc7710b2fc100ec0629a70a7d",
+      "maxShortPoolAmount": "0x975de1e00f08ccd6e7d1f36d81d8fe6412f4aa3153ff54a8d6bac526a4919492",
+      "maxLongPoolUsdForDeposit": "0x00b050a9c31535f12754bd4964dbce29c8eae93118ed7cdab517d87bf31fe215",
+      "maxShortPoolUsdForDeposit": "0xb02bd9cf66731499f398b81cfb7e350a38c4d959bc2e19c830491b058d600d56",
+      "longPoolAmountAdjustment": "0x3c2cb687c4c347b6e8ac0b5fe07c11b17f9c7434de5bfd71aecebc6c4221e6ee",
+      "shortPoolAmountAdjustment": "0x438912ccc28776202be53e38ab74aaebf25b1c1a588e5c98e8ab628093a29e79",
+      "reserveFactorLong": "0xa327b81440e2867aa7c0b7735adb5c5bc15a8b99bf7212620ba346ae8e554adc",
+      "reserveFactorShort": "0xd9615b2c8bc192a185e08f75443987f9d372812b50583602604fcd4f76a32a6d",
+      "openInterestReserveFactorLong": "0x25d41fd475fca423f259f9f045ccaaa1c8e095dd1aa3dc1d5a4ae00a0fffa689",
+      "openInterestReserveFactorShort": "0xbbcba7dd118ed9fc28eae9baf8a601a8f3ce46157aaa700fb212dfb0964d22bf",
+      "maxOpenInterestLong": "0xd277fed2bef7b1a7bd66ddff4dff87d38052a4d8477262660dfb063ecdb36616",
+      "maxOpenInterestShort": "0x69312ae41d47c3701a58dae51ebc813b15e262680aa90568de8fcc2c39361513",
+      "minPositionImpactPoolAmount": "0x0b49251e826981ec31f0962a2d50d0104ef63d38625c9d914bf8cd7e3fc0291d",
+      "positionImpactPoolDistributionRate": "0xc0cbd27b77897dcc40756f1ddfb15eaacde3572e76259876a861f188f6f538b9",
+      "borrowingFactorLong": "0x452ac2ce24f72b164f566689adef5592588839508a7c07c5c16465603135269f",
+      "borrowingFactorShort": "0x729aae30ac1288c63732727f9930a921ba999404d0c2f8b4a606f17b53f4cd8f",
+      "borrowingExponentFactorLong": "0x5290daa69a0c971aa51f2fa22607a499dd15e5b60b539eb208c3b07b70313494",
+      "borrowingExponentFactorShort": "0x27c69311b688c69e01240f32c80b5a8c9af5a69c02f61eba11e882aa95074efe",
+      "fundingFactor": "0xada510856fd3195114e6b5ad7a676169fa0a856bb4c868b8dda71ed81bb54755",
+      "fundingExponentFactor": "0xb98936ee914bb184f5157db9deb35b7092a713c842252ec37f348ad9270e489a",
+      "fundingIncreaseFactorPerSecond": "0x46af4d2c96eb33bac0dff0bd87c65bd4fb250267c6aaeba97a673b17fcdb2ead",
+      "fundingDecreaseFactorPerSecond": "0xb508215003f9b70e92679a959fedd50a44d03dda67eb990f6b6758f4b462482f",
+      "thresholdForStableFunding": "0x9fa438d031f60c76431b951f8c987118de63465fcc659a3efde7ba45225d5493",
+      "thresholdForDecreaseFunding": "0x7dc2a9aa1abd43af48c8b88f02a5898090cdbd1cdea691544ccc9b52ede205dc",
+      "minFundingFactorPerSecond": "0x977c66909c4df4c816dd4207d4001f0612de4982161d2ac64a92138df17bd890",
+      "maxFundingFactorPerSecond": "0x47e5eba0fec951108b66c2f06e9f318bc9453d6bd745b1b7e9abc20fd127cc56",
+      "maxPnlFactorForTradersLong": "0xd28e554a9db012d4ed8eeca3ac8cd3f086bff391c07e8af5a410d1758ebbab6b",
+      "maxPnlFactorForTradersShort": "0xd97bc32d7a6ec33719b5ac9e2b9b2d6f2db019c4f6d8170834ca4563475f58f2",
+      "positionFeeFactorForBalanceWasImproved": "0xc7e8a7e9eaa0ee2272f8bd1739375f19a3e3173788db16906632bd75c8718f24",
+      "positionFeeFactorForBalanceWasNotImproved": "0x29d9955cd26be376209096ce2ad3370e5b36ac80441815ba824f2d195e0ad0b7",
+      "positionImpactFactorPositive": "0x36fabe1eed7764e5e1ec15bb1ed069e590e7efaaa6f9e706ccb21400871ff524",
+      "positionImpactFactorNegative": "0x79aea67bc97087b08fd95200aab558b7a9646b9a26761bf62a1d3602c53fff0d",
+      "maxPositionImpactFactorPositive": "0x0d08c828dc9d769eeae616f4eb633aff60e0590d4e9f139ca4ed3896cc1ecef8",
+      "maxPositionImpactFactorNegative": "0x6d93932f4a91d8b721f586aff6195d1329e865f3e37ba0b5fb3fdb34804dc21d",
+      "maxPositionImpactFactorForLiquidations": "0xd1ca69a240770f649eac17fcef37e1ec3f08d89c8e052f9f3a52af6bed54bd72",
+      "maxLendableImpactFactor": "0x86d3e82fbbb7ef85d605daf0f3e91d2e2557e78900221935c18e3d8ef4ee45c4",
+      "maxLendableImpactFactorForWithdrawals": "0xab9b13bcbd53b81249545d8c3c013f17a8f3502f5f2fb550b8a08237f93d992e",
+      "maxLendableImpactUsd": "0x332ee1eb11b5ff3fd34fafdb9c874d59aa2f3c3814865c5413f8be67ac82cbda",
+      "lentPositionImpactPoolAmount": "0xd2da7ed412c9439f57c9e43d01ee9add8f84943df4615ceb1619bc2abf84bfdf",
+      "minCollateralFactor": "0x2d6c706dadc679262e11249e94c293095e1d2fbd28b2dc9bf4bb2bdae5a9b60f",
+      "minCollateralFactorForLiquidation": "0x7571230a5a26f9280aa55776430b802d4ce0c4b1f31edc7d7323e1fb55654fe6",
+      "minCollateralFactorForOpenInterestLong": "0xb31a483d7cacd648d5b1cead2934dce80ffb22bbb0b1b5eacf4f680e7a7f51ef",
+      "minCollateralFactorForOpenInterestShort": "0x9ef84ecd0f238d5e66bd19a337209e1da9e3e0c64cd87235d596cafe0b151459",
+      "positionImpactExponentFactor": "0xd39d36b5e26e0afd6b2bf7741114b6c4bcf6a7622e6234600ac9eafdbeae8fcc",
+      "swapFeeFactorForBalanceWasImproved": "0x418a49be80d3245ccf3c39d463131554ab2a57384eea5a6c25b22516862b90b1",
+      "swapFeeFactorForBalanceWasNotImproved": "0x83e5cb7cd6c5e665bf17311da7f373e698f0da5dd2a33a7cfcf0e383d4b71d20",
+      "atomicSwapFeeFactor": "0x3f94f7663c8911ea518a485ce2d6502e19cd61a00dd5da82b412a37a16ab296d",
+      "swapImpactFactorPositive": "0xb1a8a4e762d68aa90bc460f82724feadceb7c265b17e612e1c139b531db2d0e2",
+      "swapImpactFactorNegative": "0x281cb6561593d80eabe053a76d638d6ef11760761af38ca3b1157d4549682d91",
+      "swapImpactExponentFactor": "0x12ee03428639bfe3a2ee1e5e61f67385f449a679b84b4e70c550b81852611a4d",
+      "virtualMarketId": "0x4d20cfc9516de2a8e7c84f7eda56eda0c266f196478fb425a0bef534bc05a279",
+      "virtualLongTokenId": "0xa59040b7efb6b7122a74cb318a192ebc6732849dff5332ee3ba40b90dfa0a04f",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x4C0Bb704529Fa49A26bD854802d70206982c6f1B": {
+      "isDisabled": "0xeca5e5e326184f809f89d9420a1c3e9fbe205a56977d4343f375c0d594ce8ef6",
+      "maxLongPoolAmount": "0x206a8f73a58b1489ea55d7f055999d7e6eea616bacfda349b499d8341b3e5734",
+      "maxShortPoolAmount": "0x131b3ff2353105c286a95e93e26c245640f9b3417997836689a91df3d1af5942",
+      "maxLongPoolUsdForDeposit": "0xc85a1e47e93ab6eab8b2566df237eb739fe01b3d296e8c5f89f43fdeb2dc4e6f",
+      "maxShortPoolUsdForDeposit": "0xeffe072a8c71be2a22e6d1093c1c90e81bfd6b21cb32dbeab7b75acb19c36a55",
+      "longPoolAmountAdjustment": "0x26480c8b98de8e179b05d08b43465b52e8fab475827ba6987c8f30e3be60d23e",
+      "shortPoolAmountAdjustment": "0x6ee420c8738e03a48c1964bf0989c895f70ca8d35ab07c103d6b5069addf15ed",
+      "reserveFactorLong": "0x5ccd01b6246b5e77bb154ca1e49591d1d4fe051f9b6cd041a9c1ea1e14c6f07b",
+      "reserveFactorShort": "0x5c49479ab2c5dfd3ee3e5262b03a5e996a06347a30a2419f2265d74181354871",
+      "openInterestReserveFactorLong": "0xde87ebb3eeaf4a62a7c71dd6acd14922613632b824b1987f58b7ef621b58bdbf",
+      "openInterestReserveFactorShort": "0x205d8bf157cbba50bf65fe8734b05c4e6a5a039548534bfef85b4ed227f5d1e6",
+      "maxOpenInterestLong": "0x6737debac3c24380c04d81403096b9ce16535cf39d9f5c92a504a9d8b6016024",
+      "maxOpenInterestShort": "0x94a77667e8809a00230ec7d688c9205e31eb341691ab514b9d93ed7e86d1f884",
+      "minPositionImpactPoolAmount": "0x9c5bd9f3f0166cb4ad00f3d0ea194a0826405b88e9f342cb6648758d671f91b3",
+      "positionImpactPoolDistributionRate": "0x84d4d8e5b369d8151354f62765010b12c5e4869b4d773b6d72a380b9558ca6df",
+      "borrowingFactorLong": "0x293b6ada1d31fc1f8d8ba088e1b077f14cf919a11d626802afd750da41e17717",
+      "borrowingFactorShort": "0x79c3fb3365595e87e2a30d212ea90ca828fd2cc0494e97bf95a953c8e82f4780",
+      "borrowingExponentFactorLong": "0x91bee18eeca13466e503bd10e956b1dc2fe84304b678e5a5c0e1c1c7ebbb4d4c",
+      "borrowingExponentFactorShort": "0xe9e4446a826b8abe7f31e116ecde17206d6eda262067202f6ba39ac3565fc49e",
+      "fundingFactor": "0xe118a4950171fc43ebbd2267884b3cbe47e2614c9e54622a8434d71b17c9841d",
+      "fundingExponentFactor": "0x89a40c17f588f76173287c337203fab3a8c875c0a42ee97449d2187dd7abfebf",
+      "fundingIncreaseFactorPerSecond": "0xc5132dc9bf0f1f570e4f84f4b2601f42a25a1e663dd6132443f0348f5e160a6a",
+      "fundingDecreaseFactorPerSecond": "0xa45c74eaff7f498c0c3c6deacc4e28d469f4700f76aa65f89d4496e609bd2314",
+      "thresholdForStableFunding": "0xc8a11c5635442ed607b4c54b1c4a14f7b2a22e570424a0224e250cacdfe3d8cd",
+      "thresholdForDecreaseFunding": "0xfbf837388159c2be59e9c0add9415607431879b22c0a2c01ca510f8ff7efa44a",
+      "minFundingFactorPerSecond": "0xd72f4fc95031cc590ba40892ac33804e3842a57afc3d10ea092bb6a3f7e29e65",
+      "maxFundingFactorPerSecond": "0x2a180f41a8c4af0bf330505095cd046467771b23957c3896707338976ad8ba26",
+      "maxPnlFactorForTradersLong": "0x73d77d7c52833b1e8b72d2b87c03a954b582f3d7889e56d3bab5c6ef8c94f85e",
+      "maxPnlFactorForTradersShort": "0xc098c5553674aeb8cd0ab776ee7f44b18caf5c9c3a7eaec8fa78ea4660624e24",
+      "positionFeeFactorForBalanceWasImproved": "0xd5275ca6176b6f72af90745716e086778de82d015357f16baf310d0f704e8178",
+      "positionFeeFactorForBalanceWasNotImproved": "0x882f4679e77e4c52f383e53786ab6563d3a1ce41584498e3db3975e6c1b626e1",
+      "positionImpactFactorPositive": "0xee9618317d95068cfa01f27051b43663135a3267f556f9fc39c444130d03d789",
+      "positionImpactFactorNegative": "0x9d75badb56f42cc0ce64cd93cac78531fe3367324bac64c3003df3a601f2a657",
+      "maxPositionImpactFactorPositive": "0xe8592d9bc55e18be4a49c8938a1f4ec60a13de62065d4951c9b8dcb968689176",
+      "maxPositionImpactFactorNegative": "0x8d34d5799c99dbf0f3f2eab70aee41faedccd92ece8d3078f9cbf9124e1f9659",
+      "maxPositionImpactFactorForLiquidations": "0x1e5e430e83f4b42f50a9e51552c788f4eebf8994e68ea332efa2bd06dc860125",
+      "maxLendableImpactFactor": "0x43b76d012b4f31389a3a5779df50f80164e8c084ebdb0b0c6c4e322d2996be70",
+      "maxLendableImpactFactorForWithdrawals": "0x66c8168dfe39c73d827d067081ebebaa988316d15fce8f6bd526d72d68787fb1",
+      "maxLendableImpactUsd": "0x39f5a3d9577967c6e611987af1dded1b5021ea1a79577eea0d8d907ed770498d",
+      "lentPositionImpactPoolAmount": "0x34e71553618df94005fe1f31b089518cb9e6d5616c2ff9d2375c426e3de1b80e",
+      "minCollateralFactor": "0x8add9b807058f0efe927f8dcd209f053d49a4831121c5ff1df617c0aaac42fca",
+      "minCollateralFactorForLiquidation": "0xdd3da19ef77fae0831f70db252ee293b55b7beefe26610364d751d7a2f1ddf13",
+      "minCollateralFactorForOpenInterestLong": "0xb053e44f2c73e33aca860160ad83dbae4c866151a88752a096ccbfc939ee4f34",
+      "minCollateralFactorForOpenInterestShort": "0x9fb05f1825674751848bb279e1cf48b08f1f14a3b67e0a3ee96d3b205d19317c",
+      "positionImpactExponentFactor": "0x69ae7b3841a987747052ea2f11ea3220e78baeabd7a874e37bbbedae08219fff",
+      "swapFeeFactorForBalanceWasImproved": "0xcac43dbcf0982c139a541622f069cffb4bbf7ea35038dd0e0e1774e68d651ac4",
+      "swapFeeFactorForBalanceWasNotImproved": "0x44e45b505ea06e2dbd3b023457dbcf31fa94e16db1c9163282a8ab43da206bbc",
+      "atomicSwapFeeFactor": "0x257fb617aa6332d157ba1a605067b1e5c4c977a630ffce70b44a35e07bcaf599",
+      "swapImpactFactorPositive": "0x783b2e4266df71eb217aae14be4eb9048958ede5620cb605a584fe56ffd31d5f",
+      "swapImpactFactorNegative": "0x90d6976cdb86e2983cf7c8bef8d922c7484275d6a7ad3511a5c6083dd00363b2",
+      "swapImpactExponentFactor": "0x017ceefc4d7ac3c3767827541c967ca7649960bdca7b3fd74d66398a585d3140",
+      "virtualMarketId": "0xfb87b127d4425b91d7ce98276f4f83c0fbc729931ac9970b70bcfdf75e9c92b0",
+      "virtualLongTokenId": "0xa59040b7efb6b7122a74cb318a192ebc6732849dff5332ee3ba40b90dfa0a04f",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x8263bC3766a09f6dD4Bab04b4bf8D45F2B0973FF": {
+      "isDisabled": "0x218fb0027bbcbb046f53ce7705949508b319488ebe826f24c4dfe2e2d32becce",
+      "maxLongPoolAmount": "0x69b21193a6916b1c2943de52ac2fab21020bdf8bbfa238d85a1828f75d6ad36f",
+      "maxShortPoolAmount": "0xdb67ce505f21a763fea9ca65b8ab5e787af17ef79e369ec7663a839689141c5b",
+      "maxLongPoolUsdForDeposit": "0x08ebac6c3787d4c87b3109ea4c45f2542557df9e05133adb606ad458399efc1a",
+      "maxShortPoolUsdForDeposit": "0x1b4cd999d90e9ca89f6378d301ab1be2af539bac67e5bb6154974b7ee62f209c",
+      "longPoolAmountAdjustment": "0x95acbfd3661c1535125f3ff855cf4c7319190cb778b97b4cab302fc308d3eca9",
+      "shortPoolAmountAdjustment": "0x9e89d74c6906a7a2f5bba5e977c8c19b1b1b09f7a89477bd3cfa4735a3bb2aba",
+      "reserveFactorLong": "0xeda57004d0cc33fe02c44078c8a6a81aebd43ae454d4b8ed321af954fcd8b63d",
+      "reserveFactorShort": "0xea340548e0a1e5d5b2090671a8772ffafa38196ee56687c30f34234f1887ec74",
+      "openInterestReserveFactorLong": "0xabb71a094a3e2a2c4235e30e06c4839431540b8b0b15c0f7a109e36ffb7ef7bb",
+      "openInterestReserveFactorShort": "0xf3454fbfe7d700c35757aa686b102a10dbf6f41cdf6dc721bc47825e74899495",
+      "maxOpenInterestLong": "0xcbc6baf6e6e600b3b307eca5f1e33de96f48196ae57dd552dc62534804842d3b",
+      "maxOpenInterestShort": "0xec751727fe734c5ed583ff35b42eae2e3b35e0941f20a6b9d560a824328dc21b",
+      "minPositionImpactPoolAmount": "0x2e6e734373a7e2896bbeab0493765b4a0a22884c1a6ee4d3ea421f80205d6cfe",
+      "positionImpactPoolDistributionRate": "0xc9e9924b4dac6ca954f4fda4cff7cac132b86773d494ff4e5932c5df9eff05a9",
+      "borrowingFactorLong": "0xa3b5c4aa34c0b24f197d5602cd389ee17a3c7b31bb57aae4fdb6617464a34637",
+      "borrowingFactorShort": "0x4f16bdf562b5b620219671818ea10162b116b815523e3bc73f9d5950d2d37ce3",
+      "borrowingExponentFactorLong": "0x4f512d575dbdc50d6feb39602db6a69cda664c8b6a73501c7ab7c96c6e10dcb8",
+      "borrowingExponentFactorShort": "0x692525cd87395fb2e90bc2bffc79376761dac4403fe93b893ed24690569882d9",
+      "fundingFactor": "0x57ab0648fcd97f099657e13d723d532b88ebc7dcad0b780b2482399fe9c4169f",
+      "fundingExponentFactor": "0x7679820db1b59d02e46ee236c9e6a1b219b69bd837c98f4ef1d02e5c54abdf7e",
+      "fundingIncreaseFactorPerSecond": "0x129a199cf7a849f362041cf7aa70ceb35964e9d69ddfd45e81875a6c98c20b3a",
+      "fundingDecreaseFactorPerSecond": "0xfca15caa67f4ff7ffe128969bc3a0a67bd8fd60ceeb3e31a80192ab7f0836261",
+      "thresholdForStableFunding": "0x7b5b184ef3bdf57b4fe878dcfeb5243afcc71eda157201afe281b2c457d36756",
+      "thresholdForDecreaseFunding": "0xe63265fdb245ffe4eac009dc6b1ff74f61ee3e81871ab79864d101bcae9f6e17",
+      "minFundingFactorPerSecond": "0x74e8b3cddb67391566d06c48f8b3d7ebf9b38091e938655f27d91925ce9ef8e5",
+      "maxFundingFactorPerSecond": "0xe59999c7f93e9c0f5d269d2b807938b015990358cb696a09f0dcf9397578d955",
+      "maxPnlFactorForTradersLong": "0xa818d680cf700698ad177e101098884b64cf3ca714b3d300eaef01a25a68cdbd",
+      "maxPnlFactorForTradersShort": "0x351230ec92739f2c443812ce19e7bbfa3896bb6417920904b7e862849efc22ff",
+      "positionFeeFactorForBalanceWasImproved": "0x15402bfa37f912660ef6fc70f8e70a86822797bc030d8d69f72944f4e9ef815f",
+      "positionFeeFactorForBalanceWasNotImproved": "0x8b05f795931c137253905064c7de269860bb3d8854444ecc7147529b03c54648",
+      "positionImpactFactorPositive": "0x2243abc9598d70a11f2a93f42f12c916fe4d1acd5bdec6030ac973504cc7656c",
+      "positionImpactFactorNegative": "0x156feca532a456c62b9f4edc94b188038147a022e2a2b83599ad1294ef3ab751",
+      "maxPositionImpactFactorPositive": "0x27850656b1ab8bff92a4cb970443180805333fba1e5954116a96edf20af0aecd",
+      "maxPositionImpactFactorNegative": "0xd17bf66d7dc4dcbe61681941547f70da07e6419732de1c76de9af58e14b8acf8",
+      "maxPositionImpactFactorForLiquidations": "0x57cac5870aca44d2c8ed7cab262d525ecf7ad6474805fb1726c9da594fba1dca",
+      "maxLendableImpactFactor": "0x7a9398a675da4fe035a6bb70aae98124b12f2a45ba78177c4cf80f0c06b95b15",
+      "maxLendableImpactFactorForWithdrawals": "0x8e8faf1999fa9d901338e3d46ff1093c6b3b78dcd25eafc089199a025f777508",
+      "maxLendableImpactUsd": "0x1d5773e26db075dffce8c24dfc95f9769296c36454dd8a226a98ec61d2dbefae",
+      "lentPositionImpactPoolAmount": "0x7145ca807db24709f5474918671cd883ba269f313edf6b3cb7d68cadbf8175f2",
+      "minCollateralFactor": "0x239aebb5a33ed980f6d1c745fe313eddae94cfa8b6dfa61640ac3204d2e1ddea",
+      "minCollateralFactorForLiquidation": "0xa3d3e18739ebfbaca88f4aad3aef6b2545f949bae4d37af025a2f9ca18b7e555",
+      "minCollateralFactorForOpenInterestLong": "0x3ef566215c8b99506a5a252199891cb0268e97e592bf0ac06cf6f4227258e4ff",
+      "minCollateralFactorForOpenInterestShort": "0xab8d10d4912c00f6ee77fe9a2647645f124c1a076ba799a9d32382c16fac6183",
+      "positionImpactExponentFactor": "0x88a12fc0b4f12aa16021c7d1cbf24aa3cb512997c16b75286a220b8c2acec260",
+      "swapFeeFactorForBalanceWasImproved": "0x538b28d4395db6f7986920bebabc342259c741dd275250064091172e3a1ba3d9",
+      "swapFeeFactorForBalanceWasNotImproved": "0xe33673a8bbeb4f161224750f72466fc71c54b98eedcfb0cf4564d00af44802a9",
+      "atomicSwapFeeFactor": "0xac103d5917eb45342dd0844a5f1a394410222832fa4bd37010dec98599bf0419",
+      "swapImpactFactorPositive": "0x82d479352029c855a3a6f904eff05a6539b3e0551b966ecc6e94ca3961b93df6",
+      "swapImpactFactorNegative": "0xfba5946dca51e3c75530429ce15e40f13589f63992913fdcc7398620eb0ac04f",
+      "swapImpactExponentFactor": "0x4dad2505786bab6abb6c04b01c892dde2bd8ec44ddc7fab696e67c3a02f63f99",
+      "virtualMarketId": "0xbbbd270dd91a5b63926aec58111ae86f2d81bd9f6904f6be6fd081c667536fb2",
+      "virtualLongTokenId": "0xaab37f889b9680dda34f58a689de3023cb22f7ae14d32a3c1d45798a973db1f5",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x40dAEAc02dCf6b3c51F9151f532C21DCEF2F7E63": {
+      "isDisabled": "0x47d0005e45ea6c560efaf36e1de8126cd14dfc1d3c6a08261e8fd8e1a4048fca",
+      "maxLongPoolAmount": "0x131dc89e7c26d20f5a256f9cf7ebc4cb5ef47d9774bb4329b315b9905e34f0ab",
+      "maxShortPoolAmount": "0x88c95a79a9ce658479fbabbd3d195bbd712c6b8500cfc2f50b5d682f1f976513",
+      "maxLongPoolUsdForDeposit": "0x7bb2e926e4040d59e076c4e7886cb59428feb980f3f70a4cfdb9662cb8dbc094",
+      "maxShortPoolUsdForDeposit": "0xb9dd74d5b412d999ae018760d24d67c81820201cae6373273399b43dcb3028b9",
+      "longPoolAmountAdjustment": "0xe629e1398a0e0989d5d850eec94b29af7417440c76387729c0a100902daf32c0",
+      "shortPoolAmountAdjustment": "0x54a05ce81a2d1ef861827e4692e600b5d1875b273c1ffee73cd0555c98ff7e71",
+      "reserveFactorLong": "0x5882b99348210551eeee11328bd6dab495432650cc2eb5712298e8f00634e2d8",
+      "reserveFactorShort": "0x0191a2dc68f2c7f796c7207c34a876c869a8342df196841808cc79ecf1e1773a",
+      "openInterestReserveFactorLong": "0x39f731e8c0400b06cc09b2c96f7bde91c0663181491af17c03683cf5519da15d",
+      "openInterestReserveFactorShort": "0xce61fa5afa18352401617f4be0fa0132b06bcacc60247040f437d6ea4137a2ad",
+      "maxOpenInterestLong": "0xb2fbd4a1304848c968795b2ca72bf74dcfe8f810435790acb9e572e3f1299659",
+      "maxOpenInterestShort": "0x9ae18439ce3a4b04319af313703146ddb60f865198087f3b3349866d8a82334c",
+      "minPositionImpactPoolAmount": "0xaeabc06be99f5a9cb0e07a5167b45bee9da4e3968cd32f53138645d7201fa44e",
+      "positionImpactPoolDistributionRate": "0xf7ce737015a7f1a4bfe0d267b59486994ec720a621af2cd2893e45f99fc757c8",
+      "borrowingFactorLong": "0xf4d60d61d3a49c2d1269a4087f8bf0cc1c9f54a86a9a33534712f8f1d8a83d0d",
+      "borrowingFactorShort": "0x494b9a198e8b7056133642c94a31edbecbfeb60baa6a39a0676e18d23f3f922e",
+      "borrowingExponentFactorLong": "0x1b62d4ca52035b8de488322dd15942621e94f304f2e6239f90d2f22e6c23d794",
+      "borrowingExponentFactorShort": "0x66259e736ac3f393377bea8da36fd2941b691db815bda3dea684e5c9fde59305",
+      "fundingFactor": "0xd9a424895678857c510c707b0891735a99b09aedf2c5dfba5f6cebbe90ce0ee6",
+      "fundingExponentFactor": "0x72fcab305acdf7acc7ee270f3032ea17aeed62a18f4f0f1eb1232a9d5d9c306b",
+      "fundingIncreaseFactorPerSecond": "0xad767544ff86009410ad062cd70b4233da122b6820312a5364e817bdda87ff29",
+      "fundingDecreaseFactorPerSecond": "0xb273c35f5baa2bbfc8f23c4c5af810f3afb32be35b128f2d5d45fd41fca102b4",
+      "thresholdForStableFunding": "0xa0f825b6c8560a7d5548232cf253cb6aecc4140d1f5954f3ebbc272b19d3d0fe",
+      "thresholdForDecreaseFunding": "0xcc732dfa1a2c09c0c9326149fcbf3f2abf7fa2cfb0aea4d1fad1e83f9163c359",
+      "minFundingFactorPerSecond": "0x437233f7cc516fd11e7c2e93a541209659d3afea5ba037c76ec9216eb04c2919",
+      "maxFundingFactorPerSecond": "0x0c1d9fd3c9c50a89c1a9f638c8ca81cad9ab3e0b094576a832cd33a1221c1dc7",
+      "maxPnlFactorForTradersLong": "0xdf7b799c6368840f9eb69ef578c730d0868eb5367482971d0f8e4c12ecade3cb",
+      "maxPnlFactorForTradersShort": "0xcac3d1cff5f2b710556f161e0221ded9b79baebc8cfe756c1875a60a81f718af",
+      "positionFeeFactorForBalanceWasImproved": "0xfb5ca642475a8a07559ea34eb2e7508dcc8241dd8b15fa5b1ce641fc9cf5d8ae",
+      "positionFeeFactorForBalanceWasNotImproved": "0xe600126c35ea18326ca15275c87b293626591fc2d2822d335495103b1a54aa23",
+      "positionImpactFactorPositive": "0x86768527c93471ee2f003d29b69ea63c752e2deca3cd30a2fe30b16dd47afe5a",
+      "positionImpactFactorNegative": "0xe270778f1652bbd204a0485aeaefdbe2ca55598731f059017eb014446a212340",
+      "maxPositionImpactFactorPositive": "0xb9cf299657d322475fee346f7a388200f08e71a7158b47609ff2a80e9f5919dc",
+      "maxPositionImpactFactorNegative": "0x1886b30d47e73aa3e34335375e0ca436a7eb6c87e554941ae6abcc3cfe0c3316",
+      "maxPositionImpactFactorForLiquidations": "0xd6676820cc072bc0ae13225eae5bdc2a4f193c063fd64b4610cf65e8416d3c00",
+      "maxLendableImpactFactor": "0x96b20ee2310336fc91d3ae638e1aa0578534271ac496c0bf7f9f249880cbfe7f",
+      "maxLendableImpactFactorForWithdrawals": "0x735393a63607d60f6c069c503cc29efcb57db2a8af56011a97d78f3ee9a96727",
+      "maxLendableImpactUsd": "0x0ab6fb4bed20bf0e1ded571da67a009366693ea713a24cd8b71e6f3bf11c44f8",
+      "lentPositionImpactPoolAmount": "0xc7f3af484671f834f827b87322143ee35cb5cffbacfb4dc882cec4ca1657fca0",
+      "minCollateralFactor": "0x7802fed0c1073c7720f43038c4ce47a87f131dde78167cd6911e57369ea2f276",
+      "minCollateralFactorForLiquidation": "0x65f68a9afdb78cf330f681dd96e9cea7d39629c5298b7a0f26259e82af911a15",
+      "minCollateralFactorForOpenInterestLong": "0x4ec50614ebee32276c869866bc29cda2f0cd3b6a0fc081f99f69ee62d243e577",
+      "minCollateralFactorForOpenInterestShort": "0xa50de0ea17ca06f721f8aee0270ba6d29ff8987b3fe48e2bc8202575ae5da998",
+      "positionImpactExponentFactor": "0x35a3fc88d59ee55f461e3670e8bd83296076ef3453ec9ff6d2ec2250672413e9",
+      "swapFeeFactorForBalanceWasImproved": "0x2f63ac0203354e448324c4c48b6247b2ca26189fb244c7be4493adb4a519fa74",
+      "swapFeeFactorForBalanceWasNotImproved": "0x94f5bfca9defc2b97fa9c4af15ff2291ae956179af9176bfaeace643d1b9014e",
+      "atomicSwapFeeFactor": "0x7145c82f6478f400a52394760ae7578902572c92402adfb4907050d831b263d7",
+      "swapImpactFactorPositive": "0xb39cb4a6fec85abc09554145dddca153c0bdb62ea84c78a101cf865bb41600af",
+      "swapImpactFactorNegative": "0x4f54d9254ed13421d3335dff4dc71be5e038becb36096c26cbe5ed106ddd29a1",
+      "swapImpactExponentFactor": "0x8afe4a6b3d24928755222879f5c9617155461607fc17eb8151e97c77e68543db",
+      "virtualMarketId": "0x841d6a5e65217b9f4c5d5930926b8c7799181bb476c2262cc74e391cfc3dc0da",
+      "virtualLongTokenId": "0xaab37f889b9680dda34f58a689de3023cb22f7ae14d32a3c1d45798a973db1f5",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x672fEA44f4583DdaD620d60C1Ac31021F47558Cb": {
+      "isDisabled": "0xad66f9938aa162203ac512a6fbeb5d5a477e6fde64ac54b710f04bcec91ef0df",
+      "maxLongPoolAmount": "0xcd11796bd6d8efb902d2d680cb6aaa185762e4a3363ef3203b4a64d5b8705a37",
+      "maxShortPoolAmount": "0xcd11796bd6d8efb902d2d680cb6aaa185762e4a3363ef3203b4a64d5b8705a37",
+      "maxLongPoolUsdForDeposit": "0x41bbf7e9fa92bc1fa0adbd708fad2733703cd54292bc8918d7a92ba1b38bb015",
+      "maxShortPoolUsdForDeposit": "0x41bbf7e9fa92bc1fa0adbd708fad2733703cd54292bc8918d7a92ba1b38bb015",
+      "longPoolAmountAdjustment": "0xcc6503e59bc1fd405e1fbbba231bded1c8302678c53b9ecce57d867259eac21b",
+      "shortPoolAmountAdjustment": "0xcc6503e59bc1fd405e1fbbba231bded1c8302678c53b9ecce57d867259eac21b",
+      "reserveFactorLong": "0x00ca128c81161b52e421d1a2874cceb4784ed57c30921a8bd2e14da0087cc590",
+      "reserveFactorShort": "0x31a5f37fff18491c052c8efc056d5399c5face6ac5b87058773f64f96474f593",
+      "openInterestReserveFactorLong": "0x84ebaecbdbb2725d046ade1d02ebbce86822ade1b43cadec02f888961d78ea28",
+      "openInterestReserveFactorShort": "0x84d7067d5983f944aa30dd3dba0ed338d2126b3ee41490299966b66cbe02ea09",
+      "maxOpenInterestLong": "0xa259ea0e143c3da7f7dc9417e3e6972439e231729e4bd36cf253ae6974e938e9",
+      "maxOpenInterestShort": "0xb217da759750053725b382bac604897e9ff8f8e2c371dc8a3df460638776f4cb",
+      "minPositionImpactPoolAmount": "0x9a16991083fd437b4c10925baccb5601777ff287d2378b3577be0a1704f33127",
+      "positionImpactPoolDistributionRate": "0x923b692220114f1fe99fb31acab300ea2a9ade4b5424437d918341ba7bd596d4",
+      "borrowingFactorLong": "0x7fd453452ce8c3fb9d91817937051f5e3b9c704f70e235e37e2a38a0bb6f3add",
+      "borrowingFactorShort": "0x993cc41430b1495193c44786dae4fddca8bc987d7f01634a852a0df9d937d945",
+      "borrowingExponentFactorLong": "0x4cd338e051aeba5d0a467c2af58a4f5dc5204734c7a701b68ef20972bdf210e1",
+      "borrowingExponentFactorShort": "0xa01443f0399cc09103c48d37454be156186388ece9d86186c92eee72a1b0bf4f",
+      "fundingFactor": "0x6e527c9735848cb68d9868fb71f25662089b281c96ccc7a60fc15d02280769f0",
+      "fundingExponentFactor": "0x724d31e0411d4e508f5776fe9b114dc7fc26871d56f8f20b7d24f4d08946f048",
+      "fundingIncreaseFactorPerSecond": "0x2dd1e8a7c5e7f35a2037b281f32ae0c9ed8b580ca93f12bd47ce2a625bc7f7a2",
+      "fundingDecreaseFactorPerSecond": "0x2fc918ac35584b9ffc33564a7ec4014f537bea5975ebe5c05c94b7b9fc27c955",
+      "thresholdForStableFunding": "0xc500d3ac15e692d7cd61aa8e55a7a6d94bff929739a79cef2b214a5ca932ebcc",
+      "thresholdForDecreaseFunding": "0x2c3a063d1bbae02e50afcb51fe7c67df7b846fb6a8ba7f34f11264f13e42ea2e",
+      "minFundingFactorPerSecond": "0xbc03d2dc16cdde5146e0e911d3c189a3c1dd50a62bd002bd9204c6b9e63ed256",
+      "maxFundingFactorPerSecond": "0xee834c43c0cf755e67ffa6e7b768764b494a836bbdce12a1a4f097eb152dae95",
+      "maxPnlFactorForTradersLong": "0x548318e5ca63f4ec2e4a6e9bbe28de40c637787b9a495812ffec99838e4630df",
+      "maxPnlFactorForTradersShort": "0xaf1613e97d5f393e3ee604108a3788616475670f1f04197fad4abf4261ad1d1b",
+      "positionFeeFactorForBalanceWasImproved": "0xdeb4cf4c718552a7758a149c3fe2ce51bc1766094f05f58375a80a120db39c4a",
+      "positionFeeFactorForBalanceWasNotImproved": "0xff92969b970823a7e917ff8c7c341e98cf98ca743ccce1f7f22bc2f3bb32bfc4",
+      "positionImpactFactorPositive": "0xb7265148a953af3163464bb026391010b221ac00ea70c76e794db487e85fffc8",
+      "positionImpactFactorNegative": "0xa54ea45edf9314474ec0afeb829af3239b1203876ffdb8e708386874e455604a",
+      "maxPositionImpactFactorPositive": "0x8506da81af1e6ffae09575bd6579f6c9f2b36b78f9e469de3c117d7bc436554b",
+      "maxPositionImpactFactorNegative": "0x0019da4ff4b882ad2992f2a68b37612355e53734211625d04179daf8ecd3484a",
+      "maxPositionImpactFactorForLiquidations": "0xc8439eff03ba20bac9469b7399670162ffaa3c662e5794c5b84542efaa5a17c2",
+      "maxLendableImpactFactor": "0x1cd29cf18cb059adc0d26f7929c28b6dc1766caebe8b944c85cb663e640beafe",
+      "maxLendableImpactFactorForWithdrawals": "0x01e096f029bfb4ff702498771f8a1f317bc95104a3f49837d3b4da33db2be3a1",
+      "maxLendableImpactUsd": "0xc2f6645176282ea733a41d9f6d50ffcb8880edd3b7a176a966587ebf5d59cd8b",
+      "lentPositionImpactPoolAmount": "0x5cbe51b7302572a63d718c8349f8b5313fbccaf7212eb682bc1eacea91cb3cd0",
+      "minCollateralFactor": "0xbc7fc702ef6aaf9068cc0ed4435b3176394694d6737540ec0a9c001b764bfeff",
+      "minCollateralFactorForLiquidation": "0xc1d54cd6c502588af1cf73aa199beff47eaef8600505908f837db32a8c3d7c65",
+      "minCollateralFactorForOpenInterestLong": "0x0d6d3a35635ecae509baf03a4bb1d7cad458d3bfd2980159e523bea0d6ea36c4",
+      "minCollateralFactorForOpenInterestShort": "0xf090c034ca785ab99c12d5ae9fbdc732314f990a1821df63431eda6c9df58a8d",
+      "positionImpactExponentFactor": "0x6a7b0300adeb1279e72e90b8afd18a03b01d904a230a6116d1a3dce3bdda711c",
+      "swapFeeFactorForBalanceWasImproved": "0xb90a30595a23271996d72f1b7bc8f2b216242596bd1f66ee8e23c7a899460ff6",
+      "swapFeeFactorForBalanceWasNotImproved": "0xa7968fd876b4080577b846dbe984e4127995ca0e8bae0fd202ed896c64c7302f",
+      "atomicSwapFeeFactor": "0x3684560ccb2c25d736f4092efa5f8dcd091fa6305a45791a05db22943ad479b0",
+      "swapImpactFactorPositive": "0x92c1d29cd0ab89f325ad3b7e195fe5eaaa8f81e3f77e4e828a740710755ed9b4",
+      "swapImpactFactorNegative": "0xda142786efd0995a5c792b7ab292fbe984014b7ff1b0c01b57c8702fbf092c70",
+      "swapImpactExponentFactor": "0x609a7ba5e4455d511a629ef21e614f2ce5d45e87a21d2b58dc542ca9acf25dd5",
+      "virtualMarketId": "0xcc54dd35697602e276f35d33885783e1b5046e3a2a18cfaac0859856e3f93098",
+      "virtualLongTokenId": "0xd75a55ed2ecea1a03f2ca36bf769ceee55b3fcaa9c02f4cf863518485ed4918c",
+      "virtualShortTokenId": "0xd75a55ed2ecea1a03f2ca36bf769ceee55b3fcaa9c02f4cf863518485ed4918c"
+    },
+    "0x3B7f4e4Cf2fa43df013d2B32673e6A01d29ab2Ac": {
+      "isDisabled": "0xfd5fa72d82a4aad799c7b8bc4460d86dfbd250fb3558d6312e76863608642217",
+      "maxLongPoolAmount": "0x1a04317fa38127ddaded65528905f4fe21256e989821747ff02786e0210dc96e",
+      "maxShortPoolAmount": "0x3b46d8649c1a98d1693492c569f0a7f1029bfb293aec9b3fd4beb13c22828e4b",
+      "maxLongPoolUsdForDeposit": "0xf36e787e6a204238649d3ed5a43fd11730464602f2ff0568250f3a7412a1e243",
+      "maxShortPoolUsdForDeposit": "0x79242f1dd9cf9f73a82a9054c075ba5f2297920597e26872dfd1cf908ebbaaec",
+      "longPoolAmountAdjustment": "0x4c158e0ed74165f0ff97898bc12a5713bbcfecf2d7e160cb308875fae60c21e2",
+      "shortPoolAmountAdjustment": "0xb9560b341a395847d5c9a565d90795dc516681aadc51b1e279277a1a58fb3754",
+      "reserveFactorLong": "0xc5028c778bfefde7f31cf0032a6ef5b9fede4e6d9f6b17994ddb2c0de6527187",
+      "reserveFactorShort": "0x878ed1d4d771acb626e746293d2d8764b7c3005a89183bed56fcde51a1f02116",
+      "openInterestReserveFactorLong": "0xe82e6310b843548e0bf095d1b45bc2066cc4527aa9209e3c0a6de3b34f00b2e5",
+      "openInterestReserveFactorShort": "0x6ba36669027158041e03e3aaf68d9efd94200046617dcbcdc303e1efb932432b",
+      "maxOpenInterestLong": "0x1ad8dcd9a32390e52a60fb849f53a2549f3fcaf9300ac992961d085cb1a880d0",
+      "maxOpenInterestShort": "0x6c538222901c04b1853302c144ae6d365d518ce79e44664b7c84fce6148f25dc",
+      "minPositionImpactPoolAmount": "0xbaa3ab82ef59241b1789114e2388920d66f7e10e07177e80ed46df5847d1e946",
+      "positionImpactPoolDistributionRate": "0x33a24e8701dff51a216475956a898fd2588c1f76fd56e4061fc2609f21b26d94",
+      "borrowingFactorLong": "0xd156eb886bca64d0cd70c67588e629376595214a799478303e6fc6e8cfcc56ac",
+      "borrowingFactorShort": "0x8ff84d4c004926fda9f2eaba03d9074eed541f89f53347d8d7e85c794c558308",
+      "borrowingExponentFactorLong": "0xda3218e11c2b944babb0a1e74cc8ae6ae577f0c5792af7685ae087a122a270c0",
+      "borrowingExponentFactorShort": "0x440c68d4ccd6cf1d79343f571e028921162c51525a9dcf2c02605516c1dbd97d",
+      "fundingFactor": "0x77f70a6b9badf6163053a0f806eea300a43d910ed82914c9659ce9d9bd543814",
+      "fundingExponentFactor": "0xacfe75607f6c994dbf0660bc952ec34a16a9c33ba459f6460cb5c8e974822305",
+      "fundingIncreaseFactorPerSecond": "0x30b85647845b6dfc616f1a3f4645268dce583f31f3a8d1fb1f17620fb5a4ce33",
+      "fundingDecreaseFactorPerSecond": "0x1a3cd533f287f4f3e6a8ce2ab94ba01918127f242c9c5be6fb0f031870234f72",
+      "thresholdForStableFunding": "0x077e838142dce935bc74c7a27e5722134fbaa54e63baaa41f11b3c673c833861",
+      "thresholdForDecreaseFunding": "0xf051238a56894642f047befa32beb7d118b90d1376d7564777e39f2c2efdd38e",
+      "minFundingFactorPerSecond": "0xcd7094cfdf28638fea1b87c39ac81c4bbdb9b70fe508022c6e6584bf4e8f839c",
+      "maxFundingFactorPerSecond": "0xfdf0c22ab02cda4cf7c42fba3a5de7f767c758e52240f1297711726d2f18b739",
+      "maxPnlFactorForTradersLong": "0xfbee674b478748228fa397aa30d5c71d8f6d688f46ee1584b15a4f235955ced2",
+      "maxPnlFactorForTradersShort": "0x44113a76580d3869dc3faa0b6ad857bc32792f066d8c5cb8f2ed85273c48ece6",
+      "positionFeeFactorForBalanceWasImproved": "0xacd9358063a2bce12a2ae1ec0ecf20b82638b59dacd1e1fd24fb7352115024d7",
+      "positionFeeFactorForBalanceWasNotImproved": "0xfca0b6d02a8c923ee01e52683e19ea1f828803f2ed40e66a85df06edf60ef740",
+      "positionImpactFactorPositive": "0xb73aecc3e3478c17887d8b395f24784b99476d144784227e7228c114478dcb9c",
+      "positionImpactFactorNegative": "0x1ce4c4434ca64823203dbb1664559d2963735fa2d2fcdb4126a643cfb86e41c8",
+      "maxPositionImpactFactorPositive": "0x92d1e21a660fbb927c52c338215fbdfe97e318d74a74ebec791a69dcdea71cef",
+      "maxPositionImpactFactorNegative": "0x75e7fce1e22e84792d01d6d425607e48763e53668a39386cf9b80a2680dc242e",
+      "maxPositionImpactFactorForLiquidations": "0xa8437434446ebf51d1285f09fcf7ec0a49687004e3415ccd347067278d658dba",
+      "maxLendableImpactFactor": "0x27f9d6df70fc97a74e3b829720bb772fa03cc8c7c0ec8fac9425438d0149d17f",
+      "maxLendableImpactFactorForWithdrawals": "0x31a542b6e730c23b8228a3901af7fd0ea4098d91978966c87ab64d7945129979",
+      "maxLendableImpactUsd": "0x4d4cca6302a1214b790200799b0ca5e2b742f8320945db9435448e331814dbcc",
+      "lentPositionImpactPoolAmount": "0x2e769d68a09414ff7c40d8d63b70be3725d11c9da8548e2b26923350bf6fe2d3",
+      "minCollateralFactor": "0xd2a3fc6200cad6ceefc89cd6fd11223bba1e5112b3c32822481d17e67c3a682a",
+      "minCollateralFactorForLiquidation": "0xb8ddca48aa09da174c6b9d743ad7800272dd601298b1cf8a20fcc7f02f3dc28f",
+      "minCollateralFactorForOpenInterestLong": "0x16564792d825aa02be225fdbae443d22a6398e40a3239c1309b49af701177170",
+      "minCollateralFactorForOpenInterestShort": "0x33becca3d21c448200bec2782b5d80c6058dda35e03d3605be114b02fad807c0",
+      "positionImpactExponentFactor": "0xbd40da207468bcd57272e99e2ac4d6a751faedf9eb11202be9e8e674f25b9e6f",
+      "swapFeeFactorForBalanceWasImproved": "0xcc1dd20f7c01880a4c7c95ba6cf9de2d25011356abaa57f789a5100a60abbfd1",
+      "swapFeeFactorForBalanceWasNotImproved": "0x760a6cd2b15f3d09fe03ee5e0cc39c2b87ccac457a477faaf1b8c10000c21ad9",
+      "atomicSwapFeeFactor": "0x7672749e148b6d7dea467b114e16c3b129fecad7cb77b516a132aab20c9942da",
+      "swapImpactFactorPositive": "0x4e1859b022ac41a8c0bb4876ac60e5667736a43a39775b67e8c5899e394f23a1",
+      "swapImpactFactorNegative": "0x5446dbb4b522361bc79d2469cfa8f1a99d2491ef4398814a4226a28f9d006d5a",
+      "swapImpactExponentFactor": "0x6830c79dd3c864da62a7266a17c9832c28b1c38252c1be73a0855c961c1a0fa6",
+      "virtualMarketId": "0x05801b4b27d6ea25eb7dd9c7fd912969e42f12067f6e018dad07d0ba0656e85c",
+      "virtualLongTokenId": "0xa59040b7efb6b7122a74cb318a192ebc6732849dff5332ee3ba40b90dfa0a04f",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0xa29FfE4152B65A0347512Ae5c6A4Bbc7a3d6d51B": {
+      "isDisabled": "0x655f89cc964c373df7acbb74bb2b9696211d3cec41d04a432b2231e810869993",
+      "maxLongPoolAmount": "0x4ee8dfdfc61074487ab8bb9e07e0c57233b44fc92520a5301443290e427410f6",
+      "maxShortPoolAmount": "0x14bd587a94193edf3c6bb135bca981ce136a8dc54cb51c1be792b6596937920f",
+      "maxLongPoolUsdForDeposit": "0x363d1fa2d587e9b42e08f12efb10bf940d18c776457b71bce250de90d7ab4df5",
+      "maxShortPoolUsdForDeposit": "0x4982bee1eaf425e6956c3eb3e11f53f46ddb833936b8b7a1eb6fdf2b382fe123",
+      "longPoolAmountAdjustment": "0x22c8dee2944dd7bdeadb3ab965f1448bab2c1a066efbf6acdc565bba6c3674ab",
+      "shortPoolAmountAdjustment": "0xc265405f9d1ad84400f0840c835cb34e8bd3279bbec7e7bfc91ec103329c477a",
+      "reserveFactorLong": "0x78aa8bd4220ded416aab6bdeee7bd0cef8752b7c155806b3bc66d5cf4fb6b0dd",
+      "reserveFactorShort": "0xf24f52c01c3e421999edf45d9609869d8ad75e79d92c8983fb09134040186788",
+      "openInterestReserveFactorLong": "0x5b3c5457fb5953d082687eef265e6aa9a28239caf14e2dcc9e836c5cc6be24f8",
+      "openInterestReserveFactorShort": "0x3a387aa398301760114135f0f65c9b6b9e00849898d1fb5c1f110199e90c7b46",
+      "maxOpenInterestLong": "0x0f0a676195729871476ac9921516e1ea219fb5d79740019204df909a23887152",
+      "maxOpenInterestShort": "0xac8c450ff1914ef2909f345ce9db3c48e2ee5bc05648e7791a008ad2e8b3a27b",
+      "minPositionImpactPoolAmount": "0x9a04ba8c824af1ca29e97990c1767d5411ecbbdf970b0c3f15f55ea9826c70a2",
+      "positionImpactPoolDistributionRate": "0xb8e68af73265f0e04d3ebabdc9e2d3309710f40be693c5357bcc6dce4f26ff22",
+      "borrowingFactorLong": "0xf5dcb8ea2f563b6735b057b088214b4bc4b94ff2b87a14084f73f2cb76307a81",
+      "borrowingFactorShort": "0xcb35971acf58cb7d9abfc56056ea2793d5b130e49c9dc3dedaeccd0ab09eaf06",
+      "borrowingExponentFactorLong": "0x7641bff938753185a84290c6905f523345b5da87d94d19ca87fbc60dbe760bd0",
+      "borrowingExponentFactorShort": "0x86fc9421150c226b2c8ee392f68cbfac96559689bd672c91147f526d760dad14",
+      "fundingFactor": "0xbdbfd73234acad7c28c5d9ace7a5d41434a74cd99cc47b4bf0af16c46c24a39a",
+      "fundingExponentFactor": "0x4e58858a62c93c05fd373aff4e7a333e76b442d61842235cd8df1a79f980a731",
+      "fundingIncreaseFactorPerSecond": "0xeb9ea954d01bbf38a24099c29f792b9de52dd43ea11fa58bab9155f0bd615b0b",
+      "fundingDecreaseFactorPerSecond": "0x694edf8047c440bcbef6c1aed7ba413fa7a4e0713774991fd3e6d4fa27036014",
+      "thresholdForStableFunding": "0x4b99957fdd599ec456dd3add266b35e83be88a469111332ddc6591ff497c0252",
+      "thresholdForDecreaseFunding": "0xc28636461a6c62411e6bc222198c11777785965529400ceec591e0225593b355",
+      "minFundingFactorPerSecond": "0x501606311145eca9130272487e3dc94756abe2257a82d045d8763e42418ca263",
+      "maxFundingFactorPerSecond": "0xddbaba7525d87c78ea72b05619c98c837332437cab54d76abc63fed6b9e5d992",
+      "maxPnlFactorForTradersLong": "0x4fc4b7f879cccd213692433479c1170b0457f8ebae348a47ce26789067a979f3",
+      "maxPnlFactorForTradersShort": "0xe654cd003327fab6cb2371ca02d4b6aa6cd9a656de3831078f28257e8201ee8e",
+      "positionFeeFactorForBalanceWasImproved": "0xc2fcf47d8a51c092883946b050b69e99115b0876a81c11bebdde55b9dc2eaf92",
+      "positionFeeFactorForBalanceWasNotImproved": "0xe35da348d32c0779ec042b1e5c0da2f3afd9abca092404df57b333d3f95011dd",
+      "positionImpactFactorPositive": "0x5955b711dba2a7dd61632f63d9f65f1b66c40bb1da16a132888a09426f6d64e1",
+      "positionImpactFactorNegative": "0x5497abbb63013c29a533403e1c5be0b5581c34c0dac3386eae2213e933bdd0f4",
+      "maxPositionImpactFactorPositive": "0x4ae55a5fc79ee436df87560c979bee51973e66896b4eacf8cb35603736fb1851",
+      "maxPositionImpactFactorNegative": "0x47a013d2b3cd5333ebc49aa286bdebd4b6811feb816b39eb86c1a7a373399755",
+      "maxPositionImpactFactorForLiquidations": "0xd83dec73a7cc8d8e0e4bf3974bf6a5d2202d8ed5b90a1d513d85691b900e30b5",
+      "maxLendableImpactFactor": "0x451b64316edf792914e442c55deb12560e3c4dad668ff95ec7a54d6459a9a7ac",
+      "maxLendableImpactFactorForWithdrawals": "0x183c9a6ca36462aa94646ee6e14e022331d472b3f8cb806eef2a8bd0640a89c1",
+      "maxLendableImpactUsd": "0xa696760d7618dbc157257aa7e5d7c2b12cb3f5ee0dbe3a5fe02f7979f327e028",
+      "lentPositionImpactPoolAmount": "0x6fa08dba1f1d10143d59ca5ec6752871c3b19412c7235899b09dfcc00af60e9a",
+      "minCollateralFactor": "0xf67fd77e9442ca54cf9851feec12819f4bd320e432f7ab1111cc775b9bddd543",
+      "minCollateralFactorForLiquidation": "0xf91cb8d735678f9b6455105a627fed7029da41c0ee1db64713ad218cc3fb4b73",
+      "minCollateralFactorForOpenInterestLong": "0x76df1c8a6b2192aee31ce7da93f1801aa488f2cc6fafe8348bc7603d11b2bd54",
+      "minCollateralFactorForOpenInterestShort": "0xbb137e83f8e614721bed724ef82250aad6525ff6fa83d9421c69e81a4572b75d",
+      "positionImpactExponentFactor": "0x93ed1ff765c6467493cd699f6aa9c0ac23402e80c5b045be5fefbba77ec8c4fc",
+      "swapFeeFactorForBalanceWasImproved": "0x18a2d2a2a65816643f3f28661a0e8f9973f4bd6d0c80df41f4c683e75331aa9e",
+      "swapFeeFactorForBalanceWasNotImproved": "0xcf2315f65481f521af66a64d93e8dfc653d2616448c5fdda9dd6a1878caa6374",
+      "atomicSwapFeeFactor": "0x83da1e3a9fb8be7e763b6f0c4a6cdeaad58b598ac5065b44b0a2c9b2244908a5",
+      "swapImpactFactorPositive": "0x6524171a312035ff45f09f5ce5e8e72b493a0151fab50a7e3f7952fe870f855a",
+      "swapImpactFactorNegative": "0xe35e936f9c891f0d8a39f444f436acd668d642d2fe6649bd198fa3152d081f59",
+      "swapImpactExponentFactor": "0x8b0cd58c026f5262d60d2f2eeaced4d3d8b030080d868b89b0ea66c953ef77da",
+      "virtualMarketId": "0x44fd5d876bc0cfe385cc4c305802dea4650a721d786255315a061e2e0ceea484",
+      "virtualLongTokenId": "0xa59040b7efb6b7122a74cb318a192ebc6732849dff5332ee3ba40b90dfa0a04f",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x9f0849FB830679829d1FB759b11236D375D15C78": {
+      "isDisabled": "0x70d4a8440e3934dc73cdd8dad5232fc244f5260094c378cb29218699cf1883b6",
+      "maxLongPoolAmount": "0xf459e0d7b8983eed0cf44e0f18a5d070479ca951c034bd20e0457703526e51aa",
+      "maxShortPoolAmount": "0x60ad847395472c8a01aa77ca89317287919f7f1cf9278b3050f670143708e4b6",
+      "maxLongPoolUsdForDeposit": "0xca7cbd9052412a0d39ea279b8a1e0a67c43bb19b126c4c304d52f2db6578de63",
+      "maxShortPoolUsdForDeposit": "0xe018ef03b2ebac5c75197af7eab742a1a3f8c1e8674048c80796b1e13dd6d6fd",
+      "longPoolAmountAdjustment": "0x2daa355bbf2951a22bf99148e6ca7f8a6b4761bc83f9b53fec0bf724719da16f",
+      "shortPoolAmountAdjustment": "0x2ee975dcd05a106a0a7a703440ffa4ef5b444e7867776e9dd2c8ffe9cc8242aa",
+      "reserveFactorLong": "0x88147275181254f61f1f643d82465f108c78aab97747f50089669dad394b79f1",
+      "reserveFactorShort": "0x883bee62fe5698d76af2bdb91bc0bbd3f55c1f711470e6205bc205f5da15b0e7",
+      "openInterestReserveFactorLong": "0x3b8e41c9af33e2c268ccf0e299d5819a56f6841c290063a7ba2c7129b7a17c16",
+      "openInterestReserveFactorShort": "0xa30de1e2fc2aeedbb99f8eac73672e74b420789fa0529c20e622004ee2158954",
+      "maxOpenInterestLong": "0x9e270ab3db9caee30b8def678ebb1bda5c23c195daf4efdeb189d072e3d2fcb7",
+      "maxOpenInterestShort": "0x0fcde85069480e4d78fc6a55bc7c5114ec5f665eda3a7c31f933f04c8bd83db5",
+      "minPositionImpactPoolAmount": "0xdfef34e374a5adcdda87dc79a40ffe9ea1d501f8f2fbb8fe9482c79cbe840455",
+      "positionImpactPoolDistributionRate": "0x232c22c40f465685b2f41b8575455aaa9f3077845331ee5ebcef43aede9bd59c",
+      "borrowingFactorLong": "0x8b2609dccfa30ece7b49001ebb6472b25b39448c891a9e667d0ca97c6a3f395d",
+      "borrowingFactorShort": "0x6cd4b6b94f03816003de1173609e7f080e3ac35c230125163eb67465dc69ca84",
+      "borrowingExponentFactorLong": "0x368f05b3881a29ef0faa8bfff6f941f8883633c78f33119a8e760316aa542752",
+      "borrowingExponentFactorShort": "0x73bc71473466737dd6809a8cb8790e728f88ec580dc4a1902f6699d471654ed2",
+      "fundingFactor": "0x3c8a807bdf06d8a07b26c48f6fd6b3400ff0b2e1075f2077e289de37871bd7b9",
+      "fundingExponentFactor": "0x1d60cd5b67c0cf8efbf36f7007825364d37ae43323a809d8f5088194b60b18a0",
+      "fundingIncreaseFactorPerSecond": "0xb9a9d157ece2c8e5627f8744de63a5eb41fd2b626dce2a5a055687d267d0c947",
+      "fundingDecreaseFactorPerSecond": "0x6bb2d8261ce2d445a8533526295f5c0be5b33b3f8bd1fc6c02c8895efd2a97eb",
+      "thresholdForStableFunding": "0xa7ba5d9a1a22a97ae8eb355cc9dd879a200ea4e34c6dc40d3b0cf0d85a35ba37",
+      "thresholdForDecreaseFunding": "0x03826a1f3b11ce96467b8e3c2d8ac650b261816ce9bc9c2cf7b5f4b272f750af",
+      "minFundingFactorPerSecond": "0x7f575f7ea878f417e1c07616f2792e62b7cf1d6539ca919aad83fb3126b323cd",
+      "maxFundingFactorPerSecond": "0x3edce080c912c7159cc2af9be9b8d935c1e7da94d34f245e78fe45f547230aa1",
+      "maxPnlFactorForTradersLong": "0x0f8733db56596bda2e7a935523fb8e2ab57238e87b16fc8808ceabf130bceb7d",
+      "maxPnlFactorForTradersShort": "0x95cb2326f5d5f7cc3feabb0627300da352237384e54372d57ea4c02cd2973134",
+      "positionFeeFactorForBalanceWasImproved": "0x892bd9f05d3a31b47484ce9ac57301be8abc4e1dc63786a1ba89922b76c5a068",
+      "positionFeeFactorForBalanceWasNotImproved": "0x72e8e66dfa0b152d0d25abf49693232039bfe8380ea6f7231c7d2eccbe8ad3c0",
+      "positionImpactFactorPositive": "0x12f5976404087d471f16a033855bae40461ef2dc929e67aeed5e9a89b30bdac1",
+      "positionImpactFactorNegative": "0x7b8d79a21965f2b3717cc43341c47aa71ee8dbbd3f50bf6e38c1afa0e080caea",
+      "maxPositionImpactFactorPositive": "0xa31980d133a84f9bcf168fb28e47f09089949e08dcc38d4edf1edaa963c8518d",
+      "maxPositionImpactFactorNegative": "0xaffa30444e90436e6bfbe272aace9d6acc910774643e6e44d1987d96679b9ff2",
+      "maxPositionImpactFactorForLiquidations": "0x1cee7bb847cd721fdf49b3bed05d17e8cc1ecfb8199291c1a842f18c45762031",
+      "maxLendableImpactFactor": "0x0c3fe7038f76707787807a08f93c22dd14a490a2a204b9959435c8ec3442c51e",
+      "maxLendableImpactFactorForWithdrawals": "0x2188536e3974554bc6b3ee5f38d150fe9e7fc259e72e68b07e6bded472b39c40",
+      "maxLendableImpactUsd": "0xf0f6309864d086d2e0fb7da646adfe979619767ba4c3198c598c56b5ac051615",
+      "lentPositionImpactPoolAmount": "0x25c6b419467d06997d151a1721b1f20439723998c5aaba86c136bc5a2f6e4d2e",
+      "minCollateralFactor": "0xcee0d4cd08657f94f4c538e07c7020de356cd64a601fd6e58c8da6896d0f15f1",
+      "minCollateralFactorForLiquidation": "0xd901a64e17c3b8de6009bb0664596c577794080f85649ff18e1c52c6496b1171",
+      "minCollateralFactorForOpenInterestLong": "0xb20b211dbc8ddafec3527b5303e70d11d78510e03ad73616837e18b58dbcbe54",
+      "minCollateralFactorForOpenInterestShort": "0x0d8002a33d3e210a6bb7edc11265d891b4054384165307478bb6692adfa413a7",
+      "positionImpactExponentFactor": "0xdc269f2a393ac393db33d43b78286c52298d019d82450953e2597ad86d2cfeea",
+      "swapFeeFactorForBalanceWasImproved": "0xa5bf8672cdc8d80a7f7d173aed9e45cb655f8a7553d8748d54f7676d43b4e300",
+      "swapFeeFactorForBalanceWasNotImproved": "0x145d7a7b634ae4afa918af32435fdccf07cbc51975c337dd4a65153591172321",
+      "atomicSwapFeeFactor": "0xf257b603234c802c7fc31101bc28f671a4d859c4c0c0f412d5c8efa81958b28e",
+      "swapImpactFactorPositive": "0x04c5699d604ec5a80450d9d5d087144970d05fcead05c845b2d6559c131306fe",
+      "swapImpactFactorNegative": "0x53260868c297fecd4de6a79d9bb2f0b4963724d73a2575a30a915b8e3de06aaf",
+      "swapImpactExponentFactor": "0x1989cc7ae40577256f526573d129a999f1473ca248e65136dd848170078ce4c8",
+      "virtualMarketId": "0xa19df05e222c2dc267a2a76aa9025cb90fcfe1f3ecc7125e9870f90653676486",
+      "virtualLongTokenId": "0xa59040b7efb6b7122a74cb318a192ebc6732849dff5332ee3ba40b90dfa0a04f",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x41E3bC5B72384C8B26b559B7d16C2B81Fd36fbA2": {
+      "isDisabled": "0x12e6a561313673e85491e3cce341fdc467218efe7a524455f6bb05f771e265a4",
+      "maxLongPoolAmount": "0xe041fc4f46d22961ccbec7a240779405f1e0797fa535a08dfd91bc8330ebe23f",
+      "maxShortPoolAmount": "0x6cc2090a1ff91cf42e40d466e6ee09893515412a77223804333b363ee5054cc3",
+      "maxLongPoolUsdForDeposit": "0x3af86c80e3b834afb8848c4ac60a4d4f1cecdb1e1539893399a9777717b4aa52",
+      "maxShortPoolUsdForDeposit": "0x2e1df93dee003c6a81f58000630c2e596c89411898bb86126236b18b4ef4cec2",
+      "longPoolAmountAdjustment": "0x48b29d94d6f0c2490c089245d77ba541dc357f7ebcf71cd43dcc0282a8cf8fb5",
+      "shortPoolAmountAdjustment": "0x7b5f7250a945414ba5a5f73616c6f59d3f5127a5bb1b3be992aff83b94e28e67",
+      "reserveFactorLong": "0x2acb007c79461b9fd9bcea792789057f18a0082076b0d0fdf011a8195a1a9070",
+      "reserveFactorShort": "0x59bcd4fd8bb0d98fb7c47da68d82775f78489930798b800961d4a8f16aff61d8",
+      "openInterestReserveFactorLong": "0xb311b793192cea3d5b292df6392317c8ad33aa62eb3023fe16b5d666f084e23b",
+      "openInterestReserveFactorShort": "0xe14026d6519750885c37ed12cd47ae20344684a69cb5763c6e17b28378c937b5",
+      "maxOpenInterestLong": "0x6d7174bf071db8e57671c5cf99afbc94650b9d17e9fdf4dd1ebd72186fa77c21",
+      "maxOpenInterestShort": "0xc2db8e39cb5032983f5f6af4d9941ad5d1ab9311b9fefc9ac13f260777813396",
+      "minPositionImpactPoolAmount": "0x7510194e8b59faf93ea9eb08d027729d1939cc6e6a54f1c29e1e23b1d3742be4",
+      "positionImpactPoolDistributionRate": "0x63770ae74f469746448bd539a693a202c5dbe6033165330488778121587a19c1",
+      "borrowingFactorLong": "0x96c21334923377ad14a099a0e916f4f28f89716c0e9998346aea548a57489634",
+      "borrowingFactorShort": "0xa989f006a3fb480127f394bc8e120d1bef356bd838f5e1bc85d1d22efa3e2546",
+      "borrowingExponentFactorLong": "0xaca1139c6dba6077f7226fa14f3415771eb8d6e178b098d79b58d3613f53eeed",
+      "borrowingExponentFactorShort": "0xfee416a6d5fd8a5600905b38d15e33dc729cad8dedc4f6872e811f8d3855263c",
+      "fundingFactor": "0x248b07530e78fb51b3b5ba5c6fb6546ae86801e221f224a3e89da59f456e3542",
+      "fundingExponentFactor": "0xa44ff262ca3ebfa51e8851952e950767d7487e17e3e2ecd8c34bf78fbffc821d",
+      "fundingIncreaseFactorPerSecond": "0x01a6312028250875c28da1d7579a632e17a44862207864e29c2bce8f4ec94e07",
+      "fundingDecreaseFactorPerSecond": "0xa902f97672a94cd1850bc6082a728832160c702aaf287efba9532a64cf8f328f",
+      "thresholdForStableFunding": "0xa5421f777873b0a56b42138531b23f244edd4c590c1cb347624d4b79fed0233d",
+      "thresholdForDecreaseFunding": "0xdfab8f2ca86e93e9e2bed729d9e8efdd9e9240e4abcc9659c46b67ca6a51c0ac",
+      "minFundingFactorPerSecond": "0x9ec2c504f9f6de7e7df397185c9793f62e8502afafc219378bed4d83c16d2292",
+      "maxFundingFactorPerSecond": "0xe9f7a798f1e64760d998eff76c83497e6d3bae5076f10387ad3d25283e7f0756",
+      "maxPnlFactorForTradersLong": "0x72bc2700738b014a9020ed163c657bf4be3e5dc90657a5445cfb4ce3b268b5b0",
+      "maxPnlFactorForTradersShort": "0xfa55c015211801f65f30c1b310b88b26bd239bdcf195280d93549b435f9f2cd3",
+      "positionFeeFactorForBalanceWasImproved": "0x9352efb9ed4bb260d234be3cc930ca526a6a449f01b3ea5d90c4b3d280759162",
+      "positionFeeFactorForBalanceWasNotImproved": "0x641becad1584896609a18d89e20b68219c6b7be463eaf6174e148545c35ef443",
+      "positionImpactFactorPositive": "0x4ce50be0d27419784013eb08bc367baebaf542d94e0e35f3546b9dac0ce73766",
+      "positionImpactFactorNegative": "0x2d7f9ea326be405dbafa7454545a09317540967ed652af75628dfa77f06933a7",
+      "maxPositionImpactFactorPositive": "0x72466ae54a1f7c4298fcf5393d74a79fedc73944eeba90fdb7d1b5e3dcdea11b",
+      "maxPositionImpactFactorNegative": "0x692f5b72683ecd6cc81b8e7b11d29f65f83bf0633e823ac97aa63c307c5aea90",
+      "maxPositionImpactFactorForLiquidations": "0x08be8b867001c97bd4eb42be9b92ac20799bb0760f09cc3dc0bcc834220855e3",
+      "maxLendableImpactFactor": "0xa47b27d0059fbc137157c1c7296f6dec82ae86c2b057e44427bbbfbedb66c7f1",
+      "maxLendableImpactFactorForWithdrawals": "0x886c9117e996158f48cb22df0ff02ae4b5b435ec4278474d4cf7ed8607934a3d",
+      "maxLendableImpactUsd": "0x1c7655be4d65e05641cd067c7dcae99bc02e46f6ff9026a4340a709187b2950b",
+      "lentPositionImpactPoolAmount": "0xba2682d0b463938322cf1b2fc05e54d63a3bd942088aa3ced8c1e202a58fbbcf",
+      "minCollateralFactor": "0x599cda8749b7b1a8291e1d4bd8da114ac14acf9f13ba7d2fcb8011b887469a1a",
+      "minCollateralFactorForLiquidation": "0x2a970205b1409ecd739d0efd67713aea8bfc8f7dfc531f8a378f31adc6d5d0fe",
+      "minCollateralFactorForOpenInterestLong": "0x0ebd847abf1588de8f7a20e53835417c8f55b25f632784b243b921e83aa1db4c",
+      "minCollateralFactorForOpenInterestShort": "0x2cf97b6e306aedd4f13e959cba0194e4d0551eb6b2aeabe2b44a77fc5544fed7",
+      "positionImpactExponentFactor": "0x21e18b6ada76a9758f2c252f5f66feb66f15d029f30cfb06d6794080b05d1dcd",
+      "swapFeeFactorForBalanceWasImproved": "0xbc1df01093272c457bdf9d8b83e5f99c06ced2bf7c36bf56bb391a5854e7c7ee",
+      "swapFeeFactorForBalanceWasNotImproved": "0xe19b3f0fd99a2b31826d3d750a2c993975a9218c4605876820de37d1bf766dac",
+      "atomicSwapFeeFactor": "0x6203d9af25c2f24724df74e18c6ff6084a5c14c68ed74dafaa89438e2287f6a6",
+      "swapImpactFactorPositive": "0x856ad0ae542957677f61ef46a1f09c648c517e14d5aac391401a6fd84d512de1",
+      "swapImpactFactorNegative": "0x958ab36c0743cc8b24487034dd1b67aeaf095178896263abdeb003ded0edebaa",
+      "swapImpactExponentFactor": "0xe1366fd641d735cca1151ff2f0405fbe2e6a0da4435393e8e00d16f41fb43417",
+      "virtualMarketId": "0x9f9e2235905456d5bcb30fa7629322ddc71f65c078ae9a8e908c9ce2b1c8a53f",
+      "virtualLongTokenId": "0xaab37f889b9680dda34f58a689de3023cb22f7ae14d32a3c1d45798a973db1f5",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x4024418592450E4d62faB15e2f833FC03A3447dc": {
+      "isDisabled": "0xd42572bdafaddd78234512b8b3cd1fbb49d800a8c58653f349e777754242a509",
+      "maxLongPoolAmount": "0xdf419079c70a4c0853b1fa7ba9bc11ffeb457cd13f3a7ce605ff9ebae5c66ead",
+      "maxShortPoolAmount": "0x083357ff7ac9c725dc85c16ee451c0b358e3460f62a10088c02fd501d4f6b030",
+      "maxLongPoolUsdForDeposit": "0xd4089b78c7070b2856432855dd4d1b8aa17f39b86f1b207d05ca81e9bd9222b7",
+      "maxShortPoolUsdForDeposit": "0xede9702c836160dc49cc02158af1760d82c3c2f0000a3bd7bbcfa1ff218faa0e",
+      "longPoolAmountAdjustment": "0x0c04fa2a39de544b6feea6b0484b5e44a47433c3c0eb0c885facbf9dfb3ad754",
+      "shortPoolAmountAdjustment": "0x477357d10e4e30c473a3d588f2f1eedd315c1ea357c625a81c4a235f32831cd7",
+      "reserveFactorLong": "0x84deb30bd50d9c57704445f963f68434122863304c8b938b1f1f43ae1885b3cb",
+      "reserveFactorShort": "0x55aefb86ef4daff81b7f3a6b3ed5f7dab1652678d83ccea87d688b867f885b6e",
+      "openInterestReserveFactorLong": "0x55db6a88d1e64350dfcf69f6957ac84218b7ea410f3b99a10a8ccc1121a2e155",
+      "openInterestReserveFactorShort": "0x00a4c9783df2156e106f29de5d3f7fa2fcf36b3f6cc925cf6fb60f1bf1da853c",
+      "maxOpenInterestLong": "0xc3f52aed14b3467e4161b74524aabd30af65a6622c988419efecd0595b3b2a36",
+      "maxOpenInterestShort": "0xebd643e11c4643d1efa8f437a0fa1195e01d23c2d9c136ff98ddaed8f9ddce61",
+      "minPositionImpactPoolAmount": "0x3cf23d034f7e79c2727d17d6bb8aabbec1ab392217e9980b6d2c5b34cce0442f",
+      "positionImpactPoolDistributionRate": "0x8b723006c84dcb2f90187c73d22c244fb2a810eacdfd7af3bc0f9a21abf39a5c",
+      "borrowingFactorLong": "0xb52ca4c790c91f218831ade1fa5a3570715374d034473a1800399191ce0dd123",
+      "borrowingFactorShort": "0x907054d2c7cd239f396f29585aff0f7e1a014b7215e0d9d035436fae49e9e33c",
+      "borrowingExponentFactorLong": "0x57e558b177d2f59cffa5c91fce3e55599c395134f15acb078619966c5693599d",
+      "borrowingExponentFactorShort": "0xb0138c2e1e26c589a2b6255ac946cd941a4acc7abff8d3afb32b264ad6a46ec6",
+      "fundingFactor": "0x73481b486c2cc62b642cc3f3ecc16ef707e5a50b10457f3c9bd2edf80aff4c5a",
+      "fundingExponentFactor": "0xa0522fc8de1b152118241034202aa9fd2c68fc185b50afdc22ec75972cb76a3a",
+      "fundingIncreaseFactorPerSecond": "0xe781aa85c77b8143fbdac6ccb35ad39fe9f378d2a0fd02b3a776734f44d0cd72",
+      "fundingDecreaseFactorPerSecond": "0xd2126dad9ee212a1db9a1b6531e5b18a1ae8197a15e903a0fc306848160af3cf",
+      "thresholdForStableFunding": "0x387b5caab463d395b7a8fa6013623c8ff825ac736d1a575a5d0118d0531425ca",
+      "thresholdForDecreaseFunding": "0x130699f20ba0da999ad9e6d6813b71d8e034ee28ecae074c5722cf54cc45d718",
+      "minFundingFactorPerSecond": "0xb79704ba8217d99a7cc8b045e6839f51341e1bbab89c8ed64cd09bc2eca659f2",
+      "maxFundingFactorPerSecond": "0x8632b27e7def10dea4b07b59a8a81e684a74728bc5ea3299be98e021e82111d8",
+      "maxPnlFactorForTradersLong": "0x175c3ddd30d95f2f62727fde459fab22222f3106b0831b38316cf7e858e44bb4",
+      "maxPnlFactorForTradersShort": "0xc694945b20c2fd5a477e91a758c8c4d03fcc2cb9ac4e63ae8f8b444f4cdb8884",
+      "positionFeeFactorForBalanceWasImproved": "0x7aa25b2b9295464e79bdc2bf8edf99658f6ed9cc0070ad2ba6b184c2bc492a58",
+      "positionFeeFactorForBalanceWasNotImproved": "0xf84d8d4636f980c9e6695fd9833295798db2920e450ce319b515a3cd0b0d9a8c",
+      "positionImpactFactorPositive": "0x9b9a6cfafe1eb60f1b25b153cf1bb6cafbef9b030da6adb1a2063ac360f23662",
+      "positionImpactFactorNegative": "0xf48b19207a3ccf2a6cf634e4ba37a6d3065ba6438e0ff10e57e722394d6a4d4f",
+      "maxPositionImpactFactorPositive": "0xd804c0f6e6ec8e65a8017f96e7a50e795c0baf4c5cb9e748aa00efc78c41aab5",
+      "maxPositionImpactFactorNegative": "0xf792b9c6c740721664f21eaebf5c6c1898594824ac2505d3c527c57bf59368d1",
+      "maxPositionImpactFactorForLiquidations": "0xdcadd6faf113625d0fe7287ebeea383192234486e31204a612c6da64a577b720",
+      "maxLendableImpactFactor": "0xe1c3f5474838032fecfd72219fc38d0bb051223d18f286acb64ae091e864db6e",
+      "maxLendableImpactFactorForWithdrawals": "0x7db4c69e6602ed79fddfc3584d055c3eb77620dee379d8bc204bc4f016b16e33",
+      "maxLendableImpactUsd": "0x5eec370632915d936e214e635550ff1d8550bfd877b7dfc7009d6e63d6fde2f4",
+      "lentPositionImpactPoolAmount": "0x72ad21bbd2331b51ca89bf19af1ac0ee1368ffa9fb81324743ffd495c971628e",
+      "minCollateralFactor": "0xeea5901e5e5e8363f56dd49d5edd7667799d757d62b1b44605e733fca56395b5",
+      "minCollateralFactorForLiquidation": "0xa6483f30e7f86a80add0ec0803bd63edc2a3cd4c80b696924e18b43428fafc54",
+      "minCollateralFactorForOpenInterestLong": "0x098ac53af972242c2bf90966b71274b0503daa3d7415109382e89aec3f0d5fcc",
+      "minCollateralFactorForOpenInterestShort": "0x272f94b4401da17e4b6780e7b3503e62844e308c94d18b08a79ef4400786e98d",
+      "positionImpactExponentFactor": "0xfbf1fc3654cd4402abd21435b47f6f64defcd9c2a261d0ad6d5f73df6f861362",
+      "swapFeeFactorForBalanceWasImproved": "0x15386dbc11dd0bcb2e4b184a1139129f2e348a083c59042fb520d811bc6b67b7",
+      "swapFeeFactorForBalanceWasNotImproved": "0x69d548651306f8b9d0d7ded4c22928fe35c2075e9e71c54032a9063f0b71a6d2",
+      "atomicSwapFeeFactor": "0x1149ab7ad33a4bc7e61ac7ad65652409c54e67736fb94a97a61fdaaea746373d",
+      "swapImpactFactorPositive": "0xf539169edc1b866f4a532d157e90d5c31ddc3671eb3bb994ab4d7df62cf8cecb",
+      "swapImpactFactorNegative": "0xc67c8191ecee9d9ab2d8eed8f244939cef958b6a8429ca9924390e951785a5ac",
+      "swapImpactExponentFactor": "0x8b8d5ea5eefc0a4b3af099277ff396f1ce6552062f92e9ec4dd424e88ea4427d",
+      "virtualMarketId": "0xf4c691455c153cf85af9843f77b4d810ec347424e34a0dd4f0571a6e458b9192",
+      "virtualLongTokenId": "0xa59040b7efb6b7122a74cb318a192ebc6732849dff5332ee3ba40b90dfa0a04f",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x2a331e51a3D17211852d8625a1029898450e539B": {
+      "isDisabled": "0x4e5b345d08fe4b3933c060ed5956113665782345d4b8d81ec19b05c10ce6f143",
+      "maxLongPoolAmount": "0xeb05d981724a40f1f49bdc616af4874ff18868f34cf6c8e5a884d19c8986d049",
+      "maxShortPoolAmount": "0xafa0343c723b0a37802852fc6102a57795c5621626711e25dd5f02b890e1d4ba",
+      "maxLongPoolUsdForDeposit": "0x5e252a3f38c695ad9388822e16aba217cdd47dc8a436f98423ff193a7b312720",
+      "maxShortPoolUsdForDeposit": "0x6b5ea9165b2433278a94771fc1894f84242ce13089dcbf8cf6c3344148a95697",
+      "longPoolAmountAdjustment": "0x139224da0850fcacfd36d75590e48a7d32da696447a7dcfb583f543384d53cd7",
+      "shortPoolAmountAdjustment": "0x167a086e40c34ffe03c765d1480c6cd71b8cbae0eff7c72a8a630014763cf8a9",
+      "reserveFactorLong": "0xf513608c8d9f4831b242b0d87a227ac745b9eb4f1af55fd61bfa63533c8531d2",
+      "reserveFactorShort": "0x326f3bca22805c41fe21a6ae00c6944f24b01deae993892a6f09e69ffa067b3c",
+      "openInterestReserveFactorLong": "0x4657f72c166707c29d3845cc4363aced6508e941510abc9dd9617c64388f5bda",
+      "openInterestReserveFactorShort": "0xa91d70e7fd0a74a08c62330667984f4754974710233689695b76d131c8e0d5c2",
+      "maxOpenInterestLong": "0xe5784f71d60b6b242b3314cb59dfff2f3003105a5dc4b6838399fc883e68aa8c",
+      "maxOpenInterestShort": "0x018b75ef78466ff9ccba4207cfd462141f0391c0ab581a785d9d78dab546540f",
+      "minPositionImpactPoolAmount": "0x680fed5650211e3479be243e4f8c6d49db2fd0edb5410ca2f41f30ff89c73bc1",
+      "positionImpactPoolDistributionRate": "0xe0321b0837c3266e4bd5b6069b13a9685d29a926487aac356fa5fd5946fd8311",
+      "borrowingFactorLong": "0x174b96dbe40e6c5bcdde8de4397eb6dc809ea09ecce77dea8b4fae644e2ec850",
+      "borrowingFactorShort": "0xec8d7565c1442ce8b7b924f490dcfe4b4948cb69f30b35c8ba9240a6d60741f1",
+      "borrowingExponentFactorLong": "0x6b529d6842b4ff687d09384e478f47a10471ee71728ba5aa4ea7114112038881",
+      "borrowingExponentFactorShort": "0x13405a2dc8a9fb8c0d6f0ad388b49fb887b0f275c5e53dc30c7021a846d17f32",
+      "fundingFactor": "0x5d20b0645f0d69f382a3cbadd50ff8797470243bd784bb0aaf1cbcceecf15f99",
+      "fundingExponentFactor": "0xc3604cece4f67e185a83388cf3b1e972003844e9330a14266cc02918375641b5",
+      "fundingIncreaseFactorPerSecond": "0xada38be8bf80203f7759df58f23fa5a487d196c8454eefdfbd483c035d5f0db4",
+      "fundingDecreaseFactorPerSecond": "0x0a8b976b7e2a93b933bbd2e4d6f4efb605e46b6a56f44cb73827a5258d843720",
+      "thresholdForStableFunding": "0x1b6d40bae49de67bcf5f8a41e7a17c6512d5cf61369a5435c438871910d90e19",
+      "thresholdForDecreaseFunding": "0xd6087bdf7c1e424ecff658799c5aac0fd5c9634c59b124478b4951f458ab3900",
+      "minFundingFactorPerSecond": "0x442ab972fb42c206edecab95b5a6df73a3c0407e1cd55aeceb9bfd3f42505a33",
+      "maxFundingFactorPerSecond": "0x20524a39c8d595c269542d849f64c3b01a930e37e69f4ea0bcc3a4493eaf9452",
+      "maxPnlFactorForTradersLong": "0xdb830a2a09baf63007929541aad630b10fc49261a647722d474c78f655295d47",
+      "maxPnlFactorForTradersShort": "0x1399d1f85da0ce3fd72c07f4af875870b6c8ab8c6112cb11547638a574a6a78e",
+      "positionFeeFactorForBalanceWasImproved": "0xf2c0c481d616dc6e2e9624308411f1242b08ea711f32e070961ddccc13eec8e8",
+      "positionFeeFactorForBalanceWasNotImproved": "0x512e54b494da1d43ac439edaf0bcfa40ed082eab6492f35975755ec6d7f63593",
+      "positionImpactFactorPositive": "0x7a469cb478f0dea58ef5170e64b2877172d6e8282e004fe4d80ad030d5fc46a4",
+      "positionImpactFactorNegative": "0x8811ba3a2dd8e033d371a6e20ebd8768e85d7bbae2930f9a5a1ed0f98ac8157b",
+      "maxPositionImpactFactorPositive": "0xbfcf411a0c483db3eecb460672671d3be8c4aabb54e8dfdb52169d0b5e1d9a78",
+      "maxPositionImpactFactorNegative": "0xece579ffbd1bf9cc94eb71c1e636481a3114ae6547d92786ffe0be4ed3f77898",
+      "maxPositionImpactFactorForLiquidations": "0x3ad1deb3f886d676008e3c1ca67fa6465e0a203c3c2694cc3dfaedd6eea3e709",
+      "maxLendableImpactFactor": "0x3afd6526cab711eb423fc6438587bfac0995909c8007185d7e808da93af7f049",
+      "maxLendableImpactFactorForWithdrawals": "0x12fc6f883558bce46b1fdf6efa258c9575e099359f89233922d54970ae60e6d1",
+      "maxLendableImpactUsd": "0x745fbee397dbd9e4a2aa9c6ef299f187ae70db0f9d8b51906824108e7fafdfbe",
+      "lentPositionImpactPoolAmount": "0x0fb07e631c78007ab0a1c0b6cebd2c5687790c60f7f6185a09c13ad748fa94cf",
+      "minCollateralFactor": "0x197dc11afd89a4579335ecc3e2cdf3f42c666b348dbdfc39eb1389913b9e1f22",
+      "minCollateralFactorForLiquidation": "0x1944c38597cfa42fe45895448cd9c319a40de1226cfe211e755c95638673d78b",
+      "minCollateralFactorForOpenInterestLong": "0x8849255dcc39c605b9264107f43f7f5249f9bfcf284097be0dfd8cdef4f1ad52",
+      "minCollateralFactorForOpenInterestShort": "0xa1076d5f2603039a1ae1dbf4b47a94d472f445a9d6f273137e289338838c3333",
+      "positionImpactExponentFactor": "0xf78baa451beb79ae8d00ad4d35e475d8e488198a940b291c8960820f62841473",
+      "swapFeeFactorForBalanceWasImproved": "0x920ada93ca7baf660918360668d5c77367a6adc35234bfac6f6f30eca47b1892",
+      "swapFeeFactorForBalanceWasNotImproved": "0xfb4196fe9108ed2af77777408949219b02d15307c2e59b8deff3d8899f7e753e",
+      "atomicSwapFeeFactor": "0x2611d915678c3ba3835d10a745d3b62133daf635b52273675675f0dd32ef5105",
+      "swapImpactFactorPositive": "0xf50e95ce46085e5f5abc37698e61eb49a9cebdda3a633e376c7b3668c71f5066",
+      "swapImpactFactorNegative": "0x75e480a70248780f710fbd00017aa698ae7ca38f06b5d16f213df891c2becd68",
+      "swapImpactExponentFactor": "0x68f979c59d1a3c5bb3bc555f3d3e222c39329a0d249993f146e1017ecbeab2ee",
+      "virtualMarketId": "0x79757c66756773ac1fb65c3ca12d0142f2155e78b8f1afad4bc9f89172adfc5e",
+      "virtualLongTokenId": "0xaab37f889b9680dda34f58a689de3023cb22f7ae14d32a3c1d45798a973db1f5",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x3f649eab7f4CE4945F125939C64429Be2C5d0cB4": {
+      "isDisabled": "0x74b77a9741f2605e55fc6d391e91a46cfb7b305bea8c08e71f0619cc60b58173",
+      "maxLongPoolAmount": "0x1187f15673d708a8144e040b1e33cc229b9a70d55df01f19edc6fa923b34a9c4",
+      "maxShortPoolAmount": "0xc6270a5da4497f588f12f66d04b46884b8a69fadc3a64f9855baf63eccb9f279",
+      "maxLongPoolUsdForDeposit": "0x71ef28b43215807304f179b6e253f01dfe74bcae190f5a797d729ee2a7efeef7",
+      "maxShortPoolUsdForDeposit": "0x2e5d87af3297a6e55a0a530e1e28e1d1f6b52aa848ba67e5f72f99772899b35a",
+      "longPoolAmountAdjustment": "0x679030dd1200e6a89881c1d08a9e7fc3481a325d6793f2cd723c43a61207d7ca",
+      "shortPoolAmountAdjustment": "0x005c5ca041df44fe245d3b9b5ef53babd7f532ef53b1aba13c5700499ad5a90a",
+      "reserveFactorLong": "0xfd289648b74d4ea78a934f9dc6f57802e00b3fded0f6a5ac4bfd9ff59c1931fb",
+      "reserveFactorShort": "0x2dfd1e831c73d06634754d7685ff4c597cfab1fe44b32d44bc628705a116c6bf",
+      "openInterestReserveFactorLong": "0xe5fd7cca739458b00548948afbfa9ae28f08f44f8a75c66a9b8cbffdf3c01709",
+      "openInterestReserveFactorShort": "0xcb063153954f43dd4dd1a0b644478f8df509e24365b0849fd5d3e15bd1db4db1",
+      "maxOpenInterestLong": "0x090caed2583a3eda0134f80d44ff2ad5328ac7ab3e53d8e298920b49d7f5025a",
+      "maxOpenInterestShort": "0x78fa2975888d8172f439eb9f540ae0b87cfe1995f73982e139da8e560137afe8",
+      "minPositionImpactPoolAmount": "0xd07a659b443fc933a655d93818421eff1a21e2faaed34bf392ff5f940a3c4fa1",
+      "positionImpactPoolDistributionRate": "0xd080f4336942acce9537c0f82b9d036b44cd1e727192db8472ebc42d091cad37",
+      "borrowingFactorLong": "0x39e8a8b178abb07e8ea600216afeb7afa20e90fde25db91366fa199b7ed2a5e8",
+      "borrowingFactorShort": "0x52f6c2f1fa025db0cf3b5163683957f6fb5fafd6bce13f3ceb090274db23e2b5",
+      "borrowingExponentFactorLong": "0xc82d6938b999f9b98a85ea5b7477100e918d2325aecc2f16f751050b2979b6cd",
+      "borrowingExponentFactorShort": "0xca66e19695dc343d349b7dc9ec5e7251bb6d8afe64de848ffb1585a61d3affbe",
+      "fundingFactor": "0x8ccd4fea2793ff87c2d1d62e40b7be8b52b6af11be161861e6e41633f5afce28",
+      "fundingExponentFactor": "0x42d20952c1b8d3d6a6ff41da6d551a9c619bcccad480199711f82e8d4bd16f7b",
+      "fundingIncreaseFactorPerSecond": "0x4d03b8d5d48cf525e36f45292b5837601d763f63443f1bdf6afc191e710f6374",
+      "fundingDecreaseFactorPerSecond": "0xe3494f0769440853fcd8f15cfe74c18413821626cf5ce26ef7272f6faf5e9fcb",
+      "thresholdForStableFunding": "0xbcf6dfaba82ac18e4c263baca8c103a5989793310af1360a225fe196bf487451",
+      "thresholdForDecreaseFunding": "0xe0f772a3fc2e6d652c9f70a07242afc35f52032cc22d42dc2be4d98548f0743f",
+      "minFundingFactorPerSecond": "0xdd6d101985185ae62eac487d143d900408cda4c19e8a165ce2c6a39537ffe7ee",
+      "maxFundingFactorPerSecond": "0x42b07943bbc0fee043cc3911936469143fefc43fd7faa6ac215da8128e05f7c6",
+      "maxPnlFactorForTradersLong": "0xe417e27698ff4cade71e0acf114b55775b57998ee2499174fc50ecf2287b4934",
+      "maxPnlFactorForTradersShort": "0xf1bd4d5f9a4c164f7664edbf84132833b0c44cb440d17fac0b2237059ab19cdd",
+      "positionFeeFactorForBalanceWasImproved": "0x847db1019a24ed30b3433cb4f148a23795a8554baf38686f0de4e67f35a7dc42",
+      "positionFeeFactorForBalanceWasNotImproved": "0xafd8be0cc8f262a4773ffc33a94686d627a641f25f658ab2178974fd694e5cb3",
+      "positionImpactFactorPositive": "0x8e3a8d36dedf177ea0c49ab3344eff549ac752100ea420b6028f98de5bae6274",
+      "positionImpactFactorNegative": "0x823e24ece46ecf8af8e26399b4b258306ef66b2090e88e6750c24d5c93daa9f1",
+      "maxPositionImpactFactorPositive": "0x1f7af453f36b2ae2eb7da0d04e4e1f167cd6a3456c2ab0986fc20ca4efe0ce9b",
+      "maxPositionImpactFactorNegative": "0x4763ccb1a899511fa524032c5502e529852c0ff01cbe65414504a20b3af70f75",
+      "maxPositionImpactFactorForLiquidations": "0x9aa3b6fcc12a7ff3e23d854dd6cebcd3dab2e2f109997c63adc5ee5f011aab23",
+      "maxLendableImpactFactor": "0xe99cfffc264b67c9ea5b47ba9a87de70077b44cda0d4a660a46ac809cae25b45",
+      "maxLendableImpactFactorForWithdrawals": "0x65e3df1d8b7b27cb8352ca11ccd1728167b3ed13dd2d1720c35fd5be840a1ca4",
+      "maxLendableImpactUsd": "0x03e381a03fe0e9c3d4575767815e736fc6a65cfb107aa3de361c74566f21f214",
+      "lentPositionImpactPoolAmount": "0xf8af95d9c90caf32d6c2d1a96738e2d2b54609bbcb95ed9b0c72a1dfad82d125",
+      "minCollateralFactor": "0x1b290507ed4c18f8d153e6b8ea42d03ccaca41bd5840eaea855084ec1e3c6fb7",
+      "minCollateralFactorForLiquidation": "0x22792d6b6a7d400242edceedf07505e6d1b55ed62e2ea73558d2eb3975aa07b6",
+      "minCollateralFactorForOpenInterestLong": "0x7a21b1bad18f2929d4abd3fae6e5292ba91b468230661c4a9153381bf4bde9f5",
+      "minCollateralFactorForOpenInterestShort": "0xfaa2dfea02a378d3f445302ad4d018ebf25d2efc81a8f78f8b5c999126284f2a",
+      "positionImpactExponentFactor": "0x45485db332baa33654279b12e959c160e8c490c950a66707ce6b0070d4a9beec",
+      "swapFeeFactorForBalanceWasImproved": "0x3ef7d02bc5b049e46654695f4d4cdcb0da8174292c1ccb2ae66bc547d084a35a",
+      "swapFeeFactorForBalanceWasNotImproved": "0x9f3aec9f5417900c61bc567fd4ab582ee286a16ea86b041e4e12eb810a70b1dd",
+      "atomicSwapFeeFactor": "0x980aafe9db4d75676c435b7a079a84808ba90ace4c733e396244dad89b4f8fe1",
+      "swapImpactFactorPositive": "0x989a958fe693c45261754194c1c09e37a7d131e3caa329427de1e0635aa6ae06",
+      "swapImpactFactorNegative": "0x729ebfba77820dc9ec925f21523d7ba5c66a36b235d071d93e2ff61f815e79b6",
+      "swapImpactExponentFactor": "0x6baf070ae5a6f5402ff0c66767b10fe7995876536f6f6a7483216922b99ae65d",
+      "virtualMarketId": "0x52aed1451e9996f5863bc4425bbdc6a2f17f242f93a995c0721073e7f435149d",
+      "virtualLongTokenId": "0xa59040b7efb6b7122a74cb318a192ebc6732849dff5332ee3ba40b90dfa0a04f",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0xfaEaE570B07618D3F10360608E43c241181c4614": {
+      "isDisabled": "0xab771b3c140fe41e89761c9bc259dfc66d054e1d3dfad2e7cbcd27c0372cd75f",
+      "maxLongPoolAmount": "0xc3875c93ab57e6687ac7cc0018c69f711448a8fd62398824e02fdd79eefcac5d",
+      "maxShortPoolAmount": "0xffa1e3077efa19a6b9695a89a685bca911c223844272c8a3c618f96b9c65e215",
+      "maxLongPoolUsdForDeposit": "0x5187be964156fe62402dfa21b7101d4e0e230c2e7cfdbd59a796cdcd5bd7c698",
+      "maxShortPoolUsdForDeposit": "0x6362e8852f74596d70512d3a0dde8290966254596ce052479481bff70e9856b3",
+      "longPoolAmountAdjustment": "0x8f27406c90ab4102f4512d38a2c7e871241a8954614248a5baefb63ea9f9eaeb",
+      "shortPoolAmountAdjustment": "0xc96a9ea4ff8bef5feeb06bd5cabca5f870bf3d24433d1d5d481d2357d0d29404",
+      "reserveFactorLong": "0x0a1e97a6a1bff94cf42f5114be21099fae6c718c43e3c966f48960d1dceaefa3",
+      "reserveFactorShort": "0xb219f5bafa4db7658d26799e64d237e0b33664fca3b0e99f7b540ccb09dc9d12",
+      "openInterestReserveFactorLong": "0x9b352924abfdc3fa8a3a7064805ee5d79116cd1ecfaefddea1bd964fa5e8a5b5",
+      "openInterestReserveFactorShort": "0x48270ae00f82e9779cf3e1c1d60ff6cb7aef39cdf077bcab0c6f6e3a7772bce7",
+      "maxOpenInterestLong": "0xbf70965a5a2304772f5963af3e6ac25a74656131127edd426a44f111b9f43779",
+      "maxOpenInterestShort": "0x74a05168b7426d295547679fbe8409cd53b756b9223e0ba24c15a66207795d46",
+      "minPositionImpactPoolAmount": "0x1d9475ba68974100d7e4c6f5ad84304a2c52c0e3350bd5a5d8976ca389b29944",
+      "positionImpactPoolDistributionRate": "0xdc27a4fc3549cb8fd84866cfd941e159c9e8ccbb85039720103050933bf7b50c",
+      "borrowingFactorLong": "0x8ce2de9e2277eb7e2de33969c037bee3034cbfd76f4b8af770ab21eb946771e7",
+      "borrowingFactorShort": "0x345a75a3d0a2f61dec914fdc9258e659f9b964ae8e43bbd5a7e3866273b7540e",
+      "borrowingExponentFactorLong": "0xdf1700173db9c3b6e06397885acecdbc84defc2df4816756a6dd108a528537fc",
+      "borrowingExponentFactorShort": "0x75d5bdbd0d46d1bb36f6717c7030bbba2f1fadcc9bea76caba54a8cf861b8768",
+      "fundingFactor": "0xeca8ac81b4a7344e181a42b88816473ca096e6c3a55bf09d3374a6179f4275d6",
+      "fundingExponentFactor": "0xd911c9dc019cb703382d6b6c7e0a7c4d37c19cd88164d3c1c466a6f4eefebdb5",
+      "fundingIncreaseFactorPerSecond": "0x5bf7c4c10461dba6c2cad99d553fbe0e91946b9d65caef0d557273b937b210a2",
+      "fundingDecreaseFactorPerSecond": "0x9302360e2361b5f112b3c03a7a6db3163467bd0b2806bcfaf6c746dae041c4bf",
+      "thresholdForStableFunding": "0xd15566063bf9ebf3ca3a1f48aa8a898a9246198b113dd465688604d5f4f09ccd",
+      "thresholdForDecreaseFunding": "0x82e3198b37e0c989e30cdcb04611453f44685f647e4d408fce8758fbd49d773a",
+      "minFundingFactorPerSecond": "0x3e571b6111be5f6f13820ac128de31f03b2c4eaba1e6314aa6426594e23710a4",
+      "maxFundingFactorPerSecond": "0xd0c63c0f5ae6632f857fc7e43450976ff2247aa6d082f470d7f6ff9271d45b63",
+      "maxPnlFactorForTradersLong": "0xc19bc186179470fd38b60a0ddcb3abf05fc88228b09fb4087c4b58a2bb27bb57",
+      "maxPnlFactorForTradersShort": "0x3d794a66e8d1eec14d853a48cb274d0b2c933e00686a66a64d8001d1e3e21053",
+      "positionFeeFactorForBalanceWasImproved": "0x432434d8e5381ba58e891683566e60d591c3c9dd4b2a41dcbac6daeed01f37ee",
+      "positionFeeFactorForBalanceWasNotImproved": "0x0b7ff30c6d3fd72bcefbca600d460c64e3c7ad8ab3e850b6de145dfa5927e027",
+      "positionImpactFactorPositive": "0x35d3f9d839458d92f915fb9ebf041cdd3f291a7d62c75a73dec65c02994f8648",
+      "positionImpactFactorNegative": "0xd67f5913a36a87caea58a6d9fb8359e9c05de645f929c178385ed6a622d15849",
+      "maxPositionImpactFactorPositive": "0xbb6361a2148635ce7d9016d845bd99929be2679058b3c426ee6539b63a6c79c9",
+      "maxPositionImpactFactorNegative": "0xf75f4eed74d924c5b010afcfeebc0a4199e464d9f20c0f688d37010cc68a242f",
+      "maxPositionImpactFactorForLiquidations": "0xf62bb6f59876d0eeed6e3c0720e740993f5cb6cbf8be0b62a2284816dff67e6a",
+      "maxLendableImpactFactor": "0x0f650a0bc66775f82838a085118daf1edb2aa3874c20c3dd8451c30d84128f12",
+      "maxLendableImpactFactorForWithdrawals": "0x36de2316a484d963f1c9a7e6c24fe1e1a8f888d1c94581285c4d644b38284d11",
+      "maxLendableImpactUsd": "0x82ed11bbade9f2e229c7c4c760abac958134150d426b2a83ed375bf16d28b704",
+      "lentPositionImpactPoolAmount": "0x8228f43464765c8548833dab87d6ffc57e4d2a9a443142de6400582a225ef905",
+      "minCollateralFactor": "0x5cce857e2742c8ca996e8b42fd3af61196fe33fa7385ddec3ceec5cc7f62ad24",
+      "minCollateralFactorForLiquidation": "0x300d7b83c28097683856f9e2686505916f1b5bfbc62a6fccd6ce5aabb8cf48b6",
+      "minCollateralFactorForOpenInterestLong": "0x1d820cde050256acefd96c32ccb6be28d4d6109cb72dd08e2bfb56e7b6e9a73d",
+      "minCollateralFactorForOpenInterestShort": "0xc553733dc3acb295f0e3b96bc2619537a3f2c1f932fa5d541a7168fbcd639fc3",
+      "positionImpactExponentFactor": "0x3b96f8ee57d055df827e1af2670a7580089991fc0d51b7711af29b2252bbb4d3",
+      "swapFeeFactorForBalanceWasImproved": "0xce14b2aa2425696565c2d15d18113436079f9af6aa2ca16d7fd47af67077c876",
+      "swapFeeFactorForBalanceWasNotImproved": "0x24d93a752c4a3c3003fad0e2b9e57b7d23f02e9d6f5bf0d47f3cf0f339f2495a",
+      "atomicSwapFeeFactor": "0x24f9d72f4f6789a454120a032ead4225d5b3b67363249abb09e9a17d361d6bc5",
+      "swapImpactFactorPositive": "0x1ea2bab7e1f81014c954b3dce99e3748c6871441b6af46ec3b1b6c53f372360f",
+      "swapImpactFactorNegative": "0x845e8b715731e873f696c86e30d4d66195e14cba387d692b8789e1ff74ca9ee8",
+      "swapImpactExponentFactor": "0x98189c02bace01b82785c38cb52ed6eccff9e007b48f8d8f57d7fb9c94723f2f",
+      "virtualMarketId": "0x58681037ae37cd322ef8d34c5a12042f757e15f14b187dd728e8917d5738b6d8",
+      "virtualLongTokenId": "0xaab37f889b9680dda34f58a689de3023cb22f7ae14d32a3c1d45798a973db1f5",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x6EeE8098dBC106aEde99763FA5F955A5bBc42C50": {
+      "isDisabled": "0xb103f8a02ae65f8e517e68bffc3b709e4895e27c36809a5de8997c3a338f8f90",
+      "maxLongPoolAmount": "0xe958e3c6cc0f4a968159aef3b3203daa34f4857c94894fb6e7df60ac4e8352a9",
+      "maxShortPoolAmount": "0x528740efd684fc16407530a9f946f433f0f385eec64b688e8cb7733d4fe4539a",
+      "maxLongPoolUsdForDeposit": "0xd15549e5b3985aa56c3263b75a0b5c363ce2ccdeedb147a7bf252824c072c92b",
+      "maxShortPoolUsdForDeposit": "0x89d452b22c2c52737491a8359e965a77d0dd3ce65a837a469717e5f8c9845883",
+      "longPoolAmountAdjustment": "0x627253fec533ae8e731162bc662292afbf1ee36b8f3e3ba11678368515c0c0d6",
+      "shortPoolAmountAdjustment": "0x39c254c43ef19972fa68ec7b510c2d3e8017f8e9cf989caadbc56ee5cac67154",
+      "reserveFactorLong": "0x89e984722d28697a86a29e661f4f025e0b87616f17fd8de0bbf0658074b99c6e",
+      "reserveFactorShort": "0xa00db71b2123b9b1450ed5370873d6783dac01b0526126784d0abf1f07a11443",
+      "openInterestReserveFactorLong": "0xd71b2c5f423a70f34fe4730b259c159ee02f81c0fb2051170ff13610a7e93dbf",
+      "openInterestReserveFactorShort": "0x66193c752c6fd2a5026694fb997a7c48286620d424fe7b3f65a172b231badd64",
+      "maxOpenInterestLong": "0x43d35c46c3467d00241fb5e7fabdd220786b4995638298825e1498c6570af19a",
+      "maxOpenInterestShort": "0x765f28e85313bd30cc4bf556c0db94bcfeeaf7ad9054e179f5c9372c706731e0",
+      "minPositionImpactPoolAmount": "0x98eda4a0a265ac479a49932e6df743de30402ead49140dd09c2c9d3d14f97a2e",
+      "positionImpactPoolDistributionRate": "0xc57e7478c4c77df2f2fde19136a48db955805c1954ff6bf10ebde9cae2f7c0b9",
+      "borrowingFactorLong": "0xb388005c2e66cb532329a3a5342c335cfe8c46f0a4387b0e2936feaa7b5752b6",
+      "borrowingFactorShort": "0x777843feabd67eeb94ad45128a6403fff6ffa9f4dd6723a0d596018534f66156",
+      "borrowingExponentFactorLong": "0xac830025d74ec7a430b479f932c6b9d11dd33de8e104a4191a90af550d0aaec9",
+      "borrowingExponentFactorShort": "0x9cf7caef1be54a1cd6173365b055689dab8f5efed026ab4a70de0b2eef5b8601",
+      "fundingFactor": "0x240dd096950cb498e6a8f84250d5e036a1aba535ff1b3760adb109531f6efce2",
+      "fundingExponentFactor": "0x7e54a0191e05e3784a1c58cedaa3c6653f98dd58828a46d31eb59c19defe43e8",
+      "fundingIncreaseFactorPerSecond": "0xef62ae6868306bd16878072e01e6a169b7329bd525597d394ee8a39f9fbbef8d",
+      "fundingDecreaseFactorPerSecond": "0x4288f339c0285c7ed4ffcd569e84ed4424a00a57fdd6c7d84797de852aa30ab4",
+      "thresholdForStableFunding": "0x26618bd9d74266088f27709e2bd3b2ba915edcedd498871a7106439be96a260f",
+      "thresholdForDecreaseFunding": "0x6d80e76e64548de96ca8d865d75509a6ea80be4d628734d3810e5ad90b1ea515",
+      "minFundingFactorPerSecond": "0xe0b751c2674a2129b7abdbd608766f0f00f12547af22d9f7c6ee0a451a37c7fa",
+      "maxFundingFactorPerSecond": "0x3565d4c7d9d67a2ee10f18d17166a9c3d1da0073e64c67a43095a084173e1789",
+      "maxPnlFactorForTradersLong": "0x996854ee2cf03cf2f36b4909ed88ca57c1c6fd8b131859970a7ab711b80dae13",
+      "maxPnlFactorForTradersShort": "0xc5dd88327c6eb79d49cf3fae54bd442af1d7c2819842bb2aa83fcea9fd7b3757",
+      "positionFeeFactorForBalanceWasImproved": "0x0d7dfaa3a81d3f6bb5275985f8496f2ff5753e673d4223d149552eaf69f53987",
+      "positionFeeFactorForBalanceWasNotImproved": "0x67bd9caeedd682cd887a0f5e4f0794cfedd0f9e87d3e070e3ab7d12b102d0112",
+      "positionImpactFactorPositive": "0xee96af88af9c39f720eb03b78ee25460d7d64a8da8801e8a0175bf0e8595a607",
+      "positionImpactFactorNegative": "0x4a0f697c9700f8f2db295e3263080ec671f40e3b8caba07af4c296b14dba5b1b",
+      "maxPositionImpactFactorPositive": "0xc3b6473f36d612a66a9d2b16f54536e1337af2c4a100e2bb8faa02b210f1e43c",
+      "maxPositionImpactFactorNegative": "0xfca7b27421c42baa94a4a3fa24a5cf3b8862432ff9c05380967a44c0ccb6b18b",
+      "maxPositionImpactFactorForLiquidations": "0xa8db6f5afd96462572fee20549475d51537f7ceb0b600019a99142722c4154be",
+      "maxLendableImpactFactor": "0x2671b5d5029245a30dfddbe4905dbf2c37a9fd7d61e1835fc5cc19f19bb19dcc",
+      "maxLendableImpactFactorForWithdrawals": "0xe6e1dfbce6abd35d2f60ec331cc183fe59c76696fa34c881b7a06e3d8e0c7fe7",
+      "maxLendableImpactUsd": "0x567c74c47e4fb9204230b9876bf7b68763f046b66e30c25f55767e3f50dc644d",
+      "lentPositionImpactPoolAmount": "0xf2c1ece85f3f914cd8b04bc8a5685ba94cfbba25cd8536ba9e9d5985465951b6",
+      "minCollateralFactor": "0xd4c3978725e4f0793124f79d7eab6b3ad60f4a14e9a2fa6be3f9ca3186138cea",
+      "minCollateralFactorForLiquidation": "0x9996a4847c6306981151e04717d3c51afec65f0392af29c7bd8abf9cd379d377",
+      "minCollateralFactorForOpenInterestLong": "0x1b19830a06a6cc77730f7f0dab868f056fe82652f8ad897ca9e125880b1227d3",
+      "minCollateralFactorForOpenInterestShort": "0x9dd9ae7475e697c7bfa823582595098c48def087170f650d11f98adbd2ed824e",
+      "positionImpactExponentFactor": "0x69faa6d06a4fc137d20da6cac127b8d616687c86644538aba19f0e8c6f246455",
+      "swapFeeFactorForBalanceWasImproved": "0x2e1e66a02f233eb61899c3377e30c61a4d5a1337702823f1de9c26c12db1ca02",
+      "swapFeeFactorForBalanceWasNotImproved": "0xd0f878623266b2e9c002db7234bcb1e8f6b49aa7c70b5b1af084b41a9fad7cb5",
+      "atomicSwapFeeFactor": "0xd9b869dff4dd1ad79061c7c1c40d4a1970ce47d8fef11de2e7f853d0c9b501b2",
+      "swapImpactFactorPositive": "0xe21a52a0e2c6facc1b425c0f0a85e8054edc5c5555cc1d4ff25ca1bd6c6d4a84",
+      "swapImpactFactorNegative": "0x773df7e7484d0513f3cbe4e22752c34474e5f9af372329af481ed87527c0a2be",
+      "swapImpactExponentFactor": "0x7cecb982a58f90bd054d18b102bdeaf59098603166898c149be3ee5c58b06ef6",
+      "virtualMarketId": "0xc32b6a02bc74d9775fa58d5515cdf69bf46b3b603e7ec5a0857da2eaf0cdcc42",
+      "virtualLongTokenId": "0xaab37f889b9680dda34f58a689de3023cb22f7ae14d32a3c1d45798a973db1f5",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0xb3588455858a49D3244237CEe00880CcB84b91Dd": {
+      "isDisabled": "0x087ba50382083fa517d97fa52e1064524f44b18e1f0a7c170c2e8506c63f5ef4",
+      "maxLongPoolAmount": "0xb80fe19ef167bbaaf8f96bdff28c57a7da1b36f6c1033a16dccd1fc14bc865a3",
+      "maxShortPoolAmount": "0x70a0f55ec4aa84e936d72562c1a5c558bb05a99a0b8626741f6406a5272f9aea",
+      "maxLongPoolUsdForDeposit": "0x015121df87225cd6cb24d24a0317d4a09e5fcd08829a3e4dbfce7f0219c49217",
+      "maxShortPoolUsdForDeposit": "0x2fb300f6a3c1650e8e56c03c05ba011a8de93c34ad3f2b586f6a27ed417ead56",
+      "longPoolAmountAdjustment": "0x65a4e6396efa612fbe342abd96a8c79cd208ea04d317459c50df7345985576c8",
+      "shortPoolAmountAdjustment": "0x7336c6d18260026d2e4b1fb6288a58cda8bf0bbabb2b17a0db44b3c0d2219ec0",
+      "reserveFactorLong": "0x905c8475e0f87b03c0a3c17f53b89d4062af157c023117ddf2e7517b703ffa5f",
+      "reserveFactorShort": "0xf11f3236d446dfd133048eca0c658b1b86198b8907bd16b391ee697a238d4ade",
+      "openInterestReserveFactorLong": "0x663c2495a658c238b0398b369dd6f583eae60af2f4dabb535d008728d967a740",
+      "openInterestReserveFactorShort": "0xab7113a3f3d99300a88baa389ef21c573fa7920b7ad02af153e4fe84d769260d",
+      "maxOpenInterestLong": "0xe73fe172ee55535f0f1ab7fce1c7481933fc3988a6b72436fc6d64bfcc4e0c21",
+      "maxOpenInterestShort": "0x55f62bd4ec7c3b4158d84a4bc8bada3cc574fb4a6226ce3c90376358ab6257d8",
+      "minPositionImpactPoolAmount": "0x9c206c3ab95c6d59d7ebe8608843a56db95aaa05d2e43cdf7333514f33312fdc",
+      "positionImpactPoolDistributionRate": "0xd754f215466701d2fbc94c9f24455c384a4989189a955ed694de13916320e545",
+      "borrowingFactorLong": "0x162e55390c73c2bf0c1d1cf8532e531a139539b72dfa64f54c34150d1cf034d4",
+      "borrowingFactorShort": "0xa974c0912f4751ddd5a00b02d3d51089f55fb02a4185994b8403d904ccf17bb1",
+      "borrowingExponentFactorLong": "0x2fa677c61c0b5219f8eee2b6eb07300a63b3998aca5a5faf5933f96edebcce8b",
+      "borrowingExponentFactorShort": "0xabd0a428d633e4ed5460bf1ed739e3e80cfad25d8788005b400f4d1f28b828d8",
+      "fundingFactor": "0xd0ef3a070ad5d496f68d0f31d853091dddf32e21e357ba75551f025907939d4f",
+      "fundingExponentFactor": "0x4619253b1f232dc65a46d450ba1dafe638d075472746c43685a302c6dcc5fc4b",
+      "fundingIncreaseFactorPerSecond": "0xb78155093afe438c7eeaef9f84b97f46b45147482b98c94f4a91e5defe94f322",
+      "fundingDecreaseFactorPerSecond": "0x424bce54623b6862a048ffc0f34bbd38be36333f9e99aabadbe0b3d83585a131",
+      "thresholdForStableFunding": "0x5bd9e2adfa744ddde661789f58e6f9ff986bda6dd27d265c8418c0556360fb07",
+      "thresholdForDecreaseFunding": "0x396b9451c243cee568fdaaf57ecf8d4484e4d9b796cdfed814f49dfaac219e77",
+      "minFundingFactorPerSecond": "0x570b75e2f4d07344cdc0ff5bdc78dc206d954890549d8afebdeb3287fbf9f631",
+      "maxFundingFactorPerSecond": "0x3ff550b65d5e5ed2887757ee3f37361c56d3645c186364f84dfd0e20ff98b6f6",
+      "maxPnlFactorForTradersLong": "0x6b733980eb1cc18b31cc0df19ed607b6f9ce14cf8b253c3753377324c5296bf2",
+      "maxPnlFactorForTradersShort": "0xb905d0c87978761d854a662a47e04c46bf18f2b4b9c36101c0b1b1b235257ad6",
+      "positionFeeFactorForBalanceWasImproved": "0xffed83bd1175eb44911a3e9a9215a196765547075b534e749ceda1638cdc00b4",
+      "positionFeeFactorForBalanceWasNotImproved": "0x643c3514611d21fdee722f8b1c63520afa7ecaaeab0a5b9c7ba7f6316eb12e0f",
+      "positionImpactFactorPositive": "0xbd6ee4d7d48b6c21630c4005fab0443da6490425dc32aeb28082a9057781d1ec",
+      "positionImpactFactorNegative": "0x412f566d332c16699630bcca7f48e39fd70a76bb677c98148d3d2d0cf5cffaac",
+      "maxPositionImpactFactorPositive": "0x9ad8b9633804638bd2b9a1cf2a79ae9dd6cf2837c295b7ba4805b22dad8efb78",
+      "maxPositionImpactFactorNegative": "0x5bf727926cc9afe0d9c0993362b2c404011895fb4b5e8d773a2e21bfbefa9705",
+      "maxPositionImpactFactorForLiquidations": "0xdfe02109b2318434c2abf7521fc910dc9be7a8542b8692b26a122e75939b6223",
+      "maxLendableImpactFactor": "0x67596777039a8393003d122c15434082869bfa3e8701fc978d7b8e5b365d917f",
+      "maxLendableImpactFactorForWithdrawals": "0xd9a0097bc8c60291dde25e97977d9d665815235efb79f11d7deea177b6989843",
+      "maxLendableImpactUsd": "0x5715238f0ce5529d1cd923f0ab4211e970d1120e51ce40855f8b6a09115216cd",
+      "lentPositionImpactPoolAmount": "0x3da640a73773ad04897f1a686311a27ad18536d3d7b8ca668bd3c6ee0d1e4b58",
+      "minCollateralFactor": "0xdbb17b68fc5ad181d59dcdb103b689dfdfb3764224c8986cab6b2bf38a8a0379",
+      "minCollateralFactorForLiquidation": "0x9aca1909c44992d26e5ccb538c5334d5b8dca7393aa6339213a19986d34d924e",
+      "minCollateralFactorForOpenInterestLong": "0x5330c0a9bbd31e8f54f43572e56f11950eecac70d417300fa75b977fab069b8d",
+      "minCollateralFactorForOpenInterestShort": "0xa5251493e4e0adc408ca88a197dfea776e4b157b68d8bbb6c062d49cb4f5637a",
+      "positionImpactExponentFactor": "0x40e0896e7b104487f587c227a5cefd6db59e1af67cbef2659e4c57abe16c03ab",
+      "swapFeeFactorForBalanceWasImproved": "0x4b9d6db0a1455c0849b4796f9b3ec170bb2200fe90d597599febd9f8f938449d",
+      "swapFeeFactorForBalanceWasNotImproved": "0x15987449691f95d965a6ef584446dbe580b93a7e11732d1896f8d1049ada56c8",
+      "atomicSwapFeeFactor": "0x17c26cf56070ae4c21c7f4c607b0f7a2d17fc3d0f1817e4524c77abc3f1c4460",
+      "swapImpactFactorPositive": "0xe729062ec881d996d457de015f30cd07d967548eb7b8cb74770f8a252d17682c",
+      "swapImpactFactorNegative": "0x1f1c511295fdf3c8d8e60f068aeb25a1d1b6910358dfeeacb5b9f592492f507c",
+      "swapImpactExponentFactor": "0x28853728bd8217673a1158098306e6b709acec86515f8d793e55be9687101df7",
+      "virtualMarketId": "0x332ad90837b091df9f9dc2461a62ef5b30c67bde2df9d1e20d96df6a1f1201a4",
+      "virtualLongTokenId": "0xaab37f889b9680dda34f58a689de3023cb22f7ae14d32a3c1d45798a973db1f5",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0xF913B4748031EF569898ED91e5BA0d602bB93298": {
+      "isDisabled": "0x7171052f69883d0466d136c9a0bb12eea6dbe136aa587b93d75b0a78119e725a",
+      "maxLongPoolAmount": "0x0d1e845c29365cfc25f248a4fbeb886fe7170499972ef561b447a086bb297437",
+      "maxShortPoolAmount": "0x20eef9e89df81b67d478aa94e112d5a1c876f588d15adf3ef9dcab688c1304bd",
+      "maxLongPoolUsdForDeposit": "0x83f7dab460616279f22db598689a9e6230ea36376d99679c8a3e13a18e309e7b",
+      "maxShortPoolUsdForDeposit": "0xc58b34a295ba26e42dc2fb99213ee3b128a6fdad1c86ad1125bdf86b7a2100a6",
+      "longPoolAmountAdjustment": "0x49bb24df6b1959fc0be188bf64ff47b81ed37c7929faa53753b38bbe7a6bc874",
+      "shortPoolAmountAdjustment": "0x8a897fb1c49283dad079e2c6618c5d7cf0572320bb3105ed0ab962a421243c6f",
+      "reserveFactorLong": "0x05832fb67536f350af426ffbf08b90bca1f348955e56679fe51b8cb255b8675a",
+      "reserveFactorShort": "0xd00c5a4ba3fc82a581df78df64bf914e1b4121fb3f641768338f150e668d69bf",
+      "openInterestReserveFactorLong": "0x3b805711b9a1448fe1ddcac8be5df72fd536f11ff9e4f9711e867bfff2749157",
+      "openInterestReserveFactorShort": "0x661246aafc2d67787c0e9df8bcc6cc1604e8fe2bbac5582210fd60cdb932a232",
+      "maxOpenInterestLong": "0x6fbe669b0d5d4f52dc960dfeadbe34bb132e4b656bfa8cd500c7bc908e234911",
+      "maxOpenInterestShort": "0xa9fd1dc9795a185dad2373d984f81114c6b237bdc540fe48f4527863c5425d3a",
+      "minPositionImpactPoolAmount": "0x1ddf3a53e4df2a7b1bb3c03b7d6ba73cf69859bfb1b8b9683bb8f32e43e06178",
+      "positionImpactPoolDistributionRate": "0x5d2578bd0271827c1ddfeb54acd5d31ad1f68790cd79a92342f0c0fd1fee5b21",
+      "borrowingFactorLong": "0x57de15f097323669d265f3918e5cca7437cf3dbc5dcb6fac71c3a645f034de70",
+      "borrowingFactorShort": "0xb51e52182709f3927383c98906f9492589c969a6d2d28248f556e3192dde9898",
+      "borrowingExponentFactorLong": "0x9e0c67ae706f0f18f654bd128d240a2b3f91fe1c4bb922e6d3472d164b80e579",
+      "borrowingExponentFactorShort": "0xc4297239a05c53b69f528b15aafbfc0bcb8c82fbb41c3ee4b3893736cf5e5846",
+      "fundingFactor": "0xa9694a93a027c00a7ee384394831c6e32e8ba1c90966c75097fbd7bad6715c63",
+      "fundingExponentFactor": "0x7d877245f28068ec3f3e66aa59b648944a084149a18fe5e908ec7cdd115c6a45",
+      "fundingIncreaseFactorPerSecond": "0x161590b0d73de8089e5d7f1252f703485a7ce51aa801261be70b1d7658157ae9",
+      "fundingDecreaseFactorPerSecond": "0x8b5467c8ebb5508ef40b405cda59377ef730b59841bc7018b30f3990d1544861",
+      "thresholdForStableFunding": "0x46205e2862db562665d045c6eb6ce7f5e4f53053507cdb6646593194fc47997a",
+      "thresholdForDecreaseFunding": "0x1085dd67a668c287c8a923dcd5f33c597d97922822f85571634d6e8356c2f4a9",
+      "minFundingFactorPerSecond": "0x301540b0eaad87e8477e8b9f0e0dcb92d4cf5f42dd4b092327c49a406fb59378",
+      "maxFundingFactorPerSecond": "0x31697c024d968ef4352dddca1584170784811718297fc018f1672951091b5a4e",
+      "maxPnlFactorForTradersLong": "0xdc04f0af1c799f01e6531b7d51d21b7fbff2e9196513119caa57bff00782f951",
+      "maxPnlFactorForTradersShort": "0x787f911a7f503e0653f800c068f15f98a724587a9bc66d709b6a6e152fd8de13",
+      "positionFeeFactorForBalanceWasImproved": "0x9ffe49353d2f6779223d71ef23b3ecfed1ffc1e7a260130a11ad33850108f563",
+      "positionFeeFactorForBalanceWasNotImproved": "0x6faeb451c662ac2763d1fa98adad9d3b4966a5501b85e8758eae27d51f18cde2",
+      "positionImpactFactorPositive": "0x3d7d58ddc5916370dd4d407a284c5f45ef64d18f800361f07db04c585de6920e",
+      "positionImpactFactorNegative": "0xba209389f44716f62a06d34576107d475713d5f4e97a13b5a41042687b7a4472",
+      "maxPositionImpactFactorPositive": "0xb8ce4312161299c4025278bed8dc070e81462069058213188b2da21e6ecf7649",
+      "maxPositionImpactFactorNegative": "0x033fb4fd100c0aa392a9eeba71e1c59cbeeb73c2aba94ed9cba33fd20d2bf3dd",
+      "maxPositionImpactFactorForLiquidations": "0xdebe88428f24444455895b4d340f6b5cbed33bba8f1b638f264db2b9512c90ba",
+      "maxLendableImpactFactor": "0x3b610d0dfd60cced4b2c618cd38e6149ecd73fc79a86681855555f887968e84f",
+      "maxLendableImpactFactorForWithdrawals": "0x8e0258e1f2e14422ad56bf458a0557f86d38a7ca4cd2672ce21144b61ad7be05",
+      "maxLendableImpactUsd": "0xcc05dbb7a8c1882d7ae862465efd86b6a6a5a0cdf8ea47b281b47a5c96dded62",
+      "lentPositionImpactPoolAmount": "0x3bd2096959b8cc7dce89d78a65ec402a30c6671bf31e26249c1281c77cbf7454",
+      "minCollateralFactor": "0x8161ad35a4e2ef07f26601211593e35a01576b14f8259082212945ab692bc042",
+      "minCollateralFactorForLiquidation": "0xf5d9fef257ff2a16e455117446d0fa9d6596c3a599a75e8e39124a037c2e0c73",
+      "minCollateralFactorForOpenInterestLong": "0xa5e55cb18c125a5e6979763f25151ebd5c063f127d63598f08ee4dd15b2dcf3c",
+      "minCollateralFactorForOpenInterestShort": "0x0f730d7a734ceb03073aa1b6d86d32de32c78ad41a21b96ae2b28d44c233145f",
+      "positionImpactExponentFactor": "0xf6facf2eb0f2bba488d40a0bbf99b7a29e81118a4461f441d527a3f461a27b80",
+      "swapFeeFactorForBalanceWasImproved": "0xa5db4123efcabcef77b152df9fa9532d15321801dc959adb0f04c0591f77ef59",
+      "swapFeeFactorForBalanceWasNotImproved": "0xd6f3436b9782f7a1e4327b8e3cc4150c4842bc74ed1268cb37210715ecfe7d2c",
+      "atomicSwapFeeFactor": "0xfe7b999cd2a06bcd05bc9613ed6f521275850d24838991c9acb8de1507f41150",
+      "swapImpactFactorPositive": "0x653cf34669836ec174cd5b8043f2e218f07dfabb4edc99b4a2c31ebfeccb198b",
+      "swapImpactFactorNegative": "0x8eb1e5c63ccbb972b196f0789a1b3792f81f1a2c2f8bc58cb0d0c1dbaf9023bf",
+      "swapImpactExponentFactor": "0x15c1a9cc873d265a983d5ab766fa16286756c665459e214901597bec6eb279c8",
+      "virtualMarketId": "0x456d5c46fbf05d61813bd78ea3326a97ba417a7305e7bf6f94d9afc4e50aaede",
+      "virtualLongTokenId": "0xaab37f889b9680dda34f58a689de3023cb22f7ae14d32a3c1d45798a973db1f5",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x4De268aC68477f794C3eAC5A419Cbcffc2cD5e02": {
+      "isDisabled": "0xe105dbfccfa9897839dfa12deeae02dce0bf5cbeb985d344c4d2fa5efc97b3d9",
+      "maxLongPoolAmount": "0x306d619a987d3971787676dd09bb9cb1f6608620765ffa30aa227762a1148d3a",
+      "maxShortPoolAmount": "0x2cc8b3e9e728fdae43714f4c4a3481a916ec277947cf0de1b2e3081b3947dd20",
+      "maxLongPoolUsdForDeposit": "0xb3b21e9c1c3558cf268b6fb4c826830878809e6a945179c58bf2ace4134d3741",
+      "maxShortPoolUsdForDeposit": "0xe3aabb2e838ab30d483f8801227062a7078e3c44ae743fe969f2400051464497",
+      "longPoolAmountAdjustment": "0x152390d71d4062cdf1c5c0cc6ee0b66f827e45da82eafeee847bbdd05cd13022",
+      "shortPoolAmountAdjustment": "0x61a312c3a694a103be5d491bca57811e2659a1cd8fff3b82f2e660225a90b070",
+      "reserveFactorLong": "0x8e0cdeb7a856f7bf0fe8f517d2c16a5e509c95c68688d4fdaab9e798d8617b32",
+      "reserveFactorShort": "0xbc0aa30dac91126611bfe80dd66129431823c1ce7a3b1d903b8e710bdb836f9f",
+      "openInterestReserveFactorLong": "0xb610cbffc4c0b139e757615ae2107e2bf7c480ffabc1bd6c3c7feb4ab7b58f5a",
+      "openInterestReserveFactorShort": "0xae0e7fa3f96ee981df47a476919258bc8e93d9954ea9dbeffcd9127ca3bdb895",
+      "maxOpenInterestLong": "0x54d7c37921575dc7aa81bfdf010beb350be6db4969ef660924b24af80585889e",
+      "maxOpenInterestShort": "0x3c9043a45d0108859379ed1bc8e4812e7bda3ee06e7197dabd2a59dfd33ea013",
+      "minPositionImpactPoolAmount": "0xc931976f352dd5c91ce24e55cbe664c81d769bc5b27351e8a2c51efe2587f98b",
+      "positionImpactPoolDistributionRate": "0xedc980dcffd34060de799f6495da75d5dc489c717513d4ec0129a9f0223bf38a",
+      "borrowingFactorLong": "0xe4bf8f7e43b4cc55f00e72c70fa8311797da6b03d700e136f13a00645273f4b1",
+      "borrowingFactorShort": "0x714f7eff7d9b96ca338e4f1921a6b7fef36bb1b6a9baf6ff2824ca5c2dc01a62",
+      "borrowingExponentFactorLong": "0xbb3df59a19596676cd4694821028b9754e2afdb5c6c49ef46112209aaf21fa86",
+      "borrowingExponentFactorShort": "0x12bbf9f6768e80a5905c2625b32e77dc87c16a4b4fec49025ebe662b95662f1e",
+      "fundingFactor": "0xfbf9486ea4f477699df66d944ec280fa4800d5025886744c224acef09e0f4044",
+      "fundingExponentFactor": "0x7524ae481aa1f733d0f637f82c8ccac777a72d04ec5301a578770c94cf456795",
+      "fundingIncreaseFactorPerSecond": "0xba5febdf198e1d935b767651efc44002465178d36f1191353a17600a9b91ba2c",
+      "fundingDecreaseFactorPerSecond": "0xf7ea3a93c0f5d70cd1f5bd160d73545cbb565e8ccd83ccdcef9388aee10527f9",
+      "thresholdForStableFunding": "0x036718b8bd6dabfc2417c18526d426d4ccc60b1cd8703765322119143c47d3a6",
+      "thresholdForDecreaseFunding": "0x2f199670b0d374e12dcde4b0ccda1bcbea6592a3cad62c0f18f2dc7b71c04a97",
+      "minFundingFactorPerSecond": "0x5fae26a33d5cfb6af4ddc0528e6325e42b376be78b05c38462d2299313ea83de",
+      "maxFundingFactorPerSecond": "0x211a8804c51dd3b88431fde3c6f2d10e37ce229526dffbfa502ae8e9d0b2bdc0",
+      "maxPnlFactorForTradersLong": "0x28b7596765fa53db59228d3848216ca3052833202780bde72622d0455e9209c4",
+      "maxPnlFactorForTradersShort": "0x53ceb5f3c645a3632e09fea4c9c063d12a3782eec1a562f821e8ecd6a2c94b5b",
+      "positionFeeFactorForBalanceWasImproved": "0xdc9f51a621d073ef770bf453b9a19a1f6b28931daad160856fe9b8eff3e3e5e5",
+      "positionFeeFactorForBalanceWasNotImproved": "0x671a1734c5fa796545a6e9fbc3f4bd4a0e600ddb74e6f780dc4193f75716bfbc",
+      "positionImpactFactorPositive": "0xfebe696df8f54539074c69e45c1bcf42086b75971c947005114cf331a2654cda",
+      "positionImpactFactorNegative": "0xa5b620b508e05c3ddd64257ab4aba8d879568e7479cef60a86f766af522d0917",
+      "maxPositionImpactFactorPositive": "0x27f0a7fc427ba5063427d7e29cc530b1c5fe528918b626431def9fa6409537fd",
+      "maxPositionImpactFactorNegative": "0xceeaf845da4887b2cb3c72ab00756c1fe722858b94a1afad69c471d2ff21710b",
+      "maxPositionImpactFactorForLiquidations": "0xa05606a0301b0c352f2c303a4f61a7f7342044068dbe1e689b67048870916322",
+      "maxLendableImpactFactor": "0xecafec43531cac5624f1a29b162ae55c90349a23142a13b5a658636c50a14dc5",
+      "maxLendableImpactFactorForWithdrawals": "0x7d4fed035975ff22fcb23da42d38142c0dd38b62039e89122e7380164f6af43a",
+      "maxLendableImpactUsd": "0xb994d73476a61a2cfe492e714750f83084aa2f63b2555510a9493bd78732d2fb",
+      "lentPositionImpactPoolAmount": "0x02172de50e2d8722de65d80812f013676a71c950a9afaa2273205a99759f91c7",
+      "minCollateralFactor": "0x2bdc211fdd881929440f962a7d5da510f0e640499d6b9276d5c4ab9c04f2fe8f",
+      "minCollateralFactorForLiquidation": "0x38ebb6b137f1b49e3fbbef70877993eff5126bf284cb09081f73fcdf149462cc",
+      "minCollateralFactorForOpenInterestLong": "0x6c5e4de30fb36932670cfcb1b5485610f7249d2ec8a28899ee2eb8b3499971fe",
+      "minCollateralFactorForOpenInterestShort": "0x6157a4d4a9fbfe4520880fbc858bad07c8565e3617761cdc45f4bead14361229",
+      "positionImpactExponentFactor": "0x327bce005fb728fe14354f37a710dfb97b70b6cd606b13e7cf3f0a20c165fb72",
+      "swapFeeFactorForBalanceWasImproved": "0x1dfdbb97d3ae8fc434e1065ecccd47ec8e9493d8f9405a62a276dce104d15e27",
+      "swapFeeFactorForBalanceWasNotImproved": "0xba095123633cac258be40340b1c0e07229eddcdf851515fc904f576ce2614857",
+      "atomicSwapFeeFactor": "0xfcfe605a647b5a3ac152e8737dd85d9ba4b4885737e57831531540d03c099919",
+      "swapImpactFactorPositive": "0x733308f470dddafb1e071f00410ee631d739ff8ebf477329984ff3f876aac9a6",
+      "swapImpactFactorNegative": "0x944600f556adeb6eace463d9a38c8951dd8a43222219c3d03d74f16dc0b376e4",
+      "swapImpactExponentFactor": "0x5302f3771f5d65408e3ba3d4b13100485b8b6e113cc89c979e961fb8ba25c0c6",
+      "virtualMarketId": "0xdd0293f26f6cb56777b6b1960ff5a2252741a2a28999f22f283e176189fec3e1",
+      "virtualLongTokenId": "0xaab37f889b9680dda34f58a689de3023cb22f7ae14d32a3c1d45798a973db1f5",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x947C521E44f727219542B0f91a85182193c1D2ad": {
+      "isDisabled": "0xb121552819536177987eed204e7c92f1fdb57717728db9dec3916fd02d032a58",
+      "maxLongPoolAmount": "0x45038f0266a4b5008c805466bc6a7478c6bd2439e7227884a4e2975b574997b7",
+      "maxShortPoolAmount": "0x20b766ec22cc78a5d8c50f07e8c3850587edcede8c3f2f99cf713ab430edbc02",
+      "maxLongPoolUsdForDeposit": "0x54b505a7f38c70de7071eee50a08624d32fca17f787eb0f603219e82a9f5108b",
+      "maxShortPoolUsdForDeposit": "0xd689983a2f74dd1b577521357f3d6db37193af119375d4ee54c9976fbd422c59",
+      "longPoolAmountAdjustment": "0xaa08d85d9024d461bb5f67ef5d0712fc08236ce006bd780b26b8145df1ca35e3",
+      "shortPoolAmountAdjustment": "0x42de80af3822b98b16b3750edf369573ca9916f72350bfff0fef1f03f1208d2c",
+      "reserveFactorLong": "0x33d1e2531eeb5d4c75ea1cc998a455d1dbaf95895b3e659b386b97d1465e053f",
+      "reserveFactorShort": "0x1dd95b81562d89f51d47caa3b25a9fe7282bf93136018f324ce8be0d0255a321",
+      "openInterestReserveFactorLong": "0xb353b343038684c1c8341308124745da76b82ab2cd2722cb922cde12c8a3f060",
+      "openInterestReserveFactorShort": "0xe0e243f87e2c27f5d9e21c4473f321dab0cd1ba1cf08369627d1d899641d77d8",
+      "maxOpenInterestLong": "0x6b5727619e9d10e5280699233f288a9fc906338dfaba680e6db6789720c9c4e9",
+      "maxOpenInterestShort": "0x84610baf34f9df65076480d031d298f1b07f293491bd88a80e2db959ca684c33",
+      "minPositionImpactPoolAmount": "0xbdecb1882d0c8cf652592ea40320fbc1452816dd295961b0343960b7320b9d83",
+      "positionImpactPoolDistributionRate": "0x13dd5d284e805304c33e7c25ab4dc5eea6e6c0db3d2e71bd1b3c0402436ee80f",
+      "borrowingFactorLong": "0x0746f13db200e0c8c0289c1419dbacdee030bcc64c83177c9a890688e2ddbe79",
+      "borrowingFactorShort": "0xf6231186724142f5de4a9489129f0898979f28c191a2e4ee18e6210844d0b062",
+      "borrowingExponentFactorLong": "0x5678a98ef447beec4f2a8e9a3775b1ceb6e8b9c5f22ed771b9b4f5cc0722d240",
+      "borrowingExponentFactorShort": "0x6d5f89c985e09baf95ec371dab1c2666e94f8acaa87bb5733c4dbc7f3705917e",
+      "fundingFactor": "0x0be5e3a6f5365f605c283c0e4c9612ed68050ff742a9555d1447042410bf4f49",
+      "fundingExponentFactor": "0x4be6f73df96053e182d2d85ec8be838450242c2e2978944e36ed3f9e718c5078",
+      "fundingIncreaseFactorPerSecond": "0xe0c187ac259ad0ada87bcec3f76bb02e2c61718c77569910e09a423276f218dd",
+      "fundingDecreaseFactorPerSecond": "0xa8e0a9949dfe2d57d0ee9286d23a66fef860754535ac69a257a303fffec9b3fe",
+      "thresholdForStableFunding": "0xd44c73cc8d21703b4bfdf0feba87ecb62f895059c170289db700b829ca8abea7",
+      "thresholdForDecreaseFunding": "0x3a301405965af729a44913e22fbc72e076290713bdcf94a6ee05f28cd3a0130e",
+      "minFundingFactorPerSecond": "0x7e7288aa04fde0c2fcb56863cf74cc55cfc98bdc60e910c9dafe8748d3b517e9",
+      "maxFundingFactorPerSecond": "0x4f81aea19456f05547f21eb436aa350146eafd4eac4ec18f851d99bacb5ab27e",
+      "maxPnlFactorForTradersLong": "0x0c499dd26dc375bd82c3ab34b6f263bd30c4c7da20629cd1797712244faf0fac",
+      "maxPnlFactorForTradersShort": "0x1ebddc6ce0dc413b7af4d9f14608094b2853c00c8fa20ef4005b99d4873b3894",
+      "positionFeeFactorForBalanceWasImproved": "0x86f166c1121f7688cebc702c4a61659f6d536c76bbdc26972c521c10ec9e2d68",
+      "positionFeeFactorForBalanceWasNotImproved": "0xc242dfaeddc23e673ad37a9788cc61d96a3ecd07a4d8b1cc3ca61eda8f5d07c4",
+      "positionImpactFactorPositive": "0xb2e6f5113c98086cd4a662975f4326fa38d40e342b39440dad78c4913faa068e",
+      "positionImpactFactorNegative": "0x9d6b34e9180633f34b2059eb33f71095c1d8392eaccd97342afe24055979ee88",
+      "maxPositionImpactFactorPositive": "0xe6aa0ce7baa225a26916ebfa1647167c4e1d7dfcab0f41de6191285282cfbab7",
+      "maxPositionImpactFactorNegative": "0xf21f0f503101b9cf05568135e83162fb5e20796ff4752038f57433c3bfa45fd4",
+      "maxPositionImpactFactorForLiquidations": "0x6904ce2cfcff224f29c089d341d88263f929a412c98ef9fef4aee9a19a72ba39",
+      "maxLendableImpactFactor": "0x6ffc793915100bee54926e59011e873eefb4d084266ad3f2e570abad40de92ba",
+      "maxLendableImpactFactorForWithdrawals": "0x5d7404edb84fb873d603f9296ab3451608fe05a4f91ccd0588c6c1ab1203e9d8",
+      "maxLendableImpactUsd": "0xb1bbac5a7bed7d5e805a52d3c217c120e336e668f51308d3a62f0edee5290d6b",
+      "lentPositionImpactPoolAmount": "0x0ea5b10e33a7c25b3971a5d9041d6d2379b7054099e9ca6367cb94c57e77aa76",
+      "minCollateralFactor": "0x3d05b56fb25642094eb6a96a2c1190361a3223c51c33e60e31ee8adb55c4996b",
+      "minCollateralFactorForLiquidation": "0x9b70b196f29143806bfa15ba08aebb2e612957ffde9d25e1c6de00d1ac8a8e6e",
+      "minCollateralFactorForOpenInterestLong": "0xa463bb0bf65c138eb97c740465a234c791aa8ef3ab676e5f7293b3a3195a8f1c",
+      "minCollateralFactorForOpenInterestShort": "0x976b7368d3aeeabd8d5c6b51a6718392b2d2d617c10a3e2bc7bbcce192e8ed72",
+      "positionImpactExponentFactor": "0xb0f5a9ad757a67304a4f78a36043f2cfbf20cb368f9aaa3a28eca3957c5db38c",
+      "swapFeeFactorForBalanceWasImproved": "0xe9a251bde0c47e85618045ae9ec3334d22ad42bc7b57142e9935e36118ca9175",
+      "swapFeeFactorForBalanceWasNotImproved": "0xd2a7b2e5d86f8973eedf837f8bd6eca83ce6f603220fd1dacd42435fa74c2008",
+      "atomicSwapFeeFactor": "0xfa1e62406674f01917fe055d8728e664b84210dd46b2bbd7dec01dde23db9722",
+      "swapImpactFactorPositive": "0xfd600d715e5d2039bf5109147188931b05a2456cffe359b1a16c6adac07f380a",
+      "swapImpactFactorNegative": "0xf8a517e7cde0dcc764d8ccab0f00be54d170d6b3b4c77842e0de29ea9606262e",
+      "swapImpactExponentFactor": "0x7a7392ce55574d97eeb9c161fc00357c52b7f718f943065109bc542d8f518319",
+      "virtualMarketId": "0xdfc85149750ae318b04c1535e4375433c2d4a57562bd6eed5f71811f3ad8be96",
+      "virtualLongTokenId": "0xaab37f889b9680dda34f58a689de3023cb22f7ae14d32a3c1d45798a973db1f5",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
+    },
+    "0x2347EbB8645Cc2EA0Ba92D1EC59704031F2fCCf4": {
+      "isDisabled": "0x7b4154ebe8e8c30ed188baaef685d55a91cf50b9a5ac308cad004cccbba11007",
+      "maxLongPoolAmount": "0xe8a31e2808c418d13c2487c72a12cd2f2661fb282d7a05114e05196096c979b3",
+      "maxShortPoolAmount": "0x99b74904ccb9912e64dc6361a4a07c23a9ee793c75fd75c094af5ae47dbce73c",
+      "maxLongPoolUsdForDeposit": "0xe0a4dd800dbb1c513f298021b4297a08a6f46d95f582face2cc389cfaeb25e63",
+      "maxShortPoolUsdForDeposit": "0xa67b2ce25b0e40da8ff6b276a995a576bbe156898a660f71fdf984e940acb294",
+      "longPoolAmountAdjustment": "0xe3b01e43fe7a9d1a953f0f7c172d0c44f0f33867bd223d56cdb57b7d30c76163",
+      "shortPoolAmountAdjustment": "0xcb58379c455682437cca901fff6b7ba21abfaa834da3365233bcd87ca593c7c1",
+      "reserveFactorLong": "0x1b067adc08ba60a01304538920219166705db995ea105fd145de933765773ca3",
+      "reserveFactorShort": "0xa2fe0c2209166b21bd82949521140ca6bb13ed553da6edcbce4f92aa5b2232ca",
+      "openInterestReserveFactorLong": "0x309cbaa767f0ef9de8d77a508b0f5599a725d40e41bf749e82c965d565d2753b",
+      "openInterestReserveFactorShort": "0xefc72817272072b230b22a11e2ffe3d22337f90f6bc3cbff141e9c9ec1f0fce4",
+      "maxOpenInterestLong": "0x6cc08dcce846335c6594c73e93e5c05e88ec5bc1028bbd4b39893f9f4c29f5d3",
+      "maxOpenInterestShort": "0xd495a445097d14f008e5f58aeccc3828607006915fc6aa61a677e77ea3963a3c",
+      "minPositionImpactPoolAmount": "0x805fbaf185cf57e38e1bf1bc36b97d17aba55516232bc921e005a2fb368ec27f",
+      "positionImpactPoolDistributionRate": "0xbbbc1bad7d41729a048026a2555aa589bd32063d2c7552bfa4d37673631f9369",
+      "borrowingFactorLong": "0x11b8763df0c3a0e92919659212f7afa6837196afa3edff424e97f29c4c37559e",
+      "borrowingFactorShort": "0x9a0095cc5a498993c7ac10f0085b7bfbf012a3c42748228b23d6622a5c9eaa12",
+      "borrowingExponentFactorLong": "0xddae5f84a09d8916f68cf381ed3dc7a527ec394b56649eaeb384b4b112f53a72",
+      "borrowingExponentFactorShort": "0x5aa4b07622bb38e5564c37dfeee1afa4f64cae5a12b5528a6627b0a363bb399b",
+      "fundingFactor": "0xa79ea8bb755f167bdd618976f749a2b0b27501382d5afd592aee5320c673e325",
+      "fundingExponentFactor": "0x264f1d31182e79c863dbbf2851bbf0f5bf72a3b21a02e9d51fcb92f52fe6e6a8",
+      "fundingIncreaseFactorPerSecond": "0x4ff7c7fa19ef6f3b5a9741d9feca6c8949c563703730e79005acb7e360002109",
+      "fundingDecreaseFactorPerSecond": "0x7f283633c5360d75a6c29485721106df8977ce79765fc3fb1d006d0ff8360ac2",
+      "thresholdForStableFunding": "0x6159d744358d22bbb33811bb6005e6e2a52b656ed5c1451ac201db168a2955ab",
+      "thresholdForDecreaseFunding": "0x21b142145fce77d35e1052deba73add64f92a898dc310a120c835c1ca40c5e63",
+      "minFundingFactorPerSecond": "0x1171f0d87e6415c3dddfff6de7efd925bb1c8edd2bef707cc6bf7b338008c920",
+      "maxFundingFactorPerSecond": "0x87d1cd01094a1b5ef0ed95f1bda7b667e1e13a6330171126b399e0fa80939c4e",
+      "maxPnlFactorForTradersLong": "0x5467de62f3597ca2dd689a60deca0844009a6b5c99f672d52a274e206be084a6",
+      "maxPnlFactorForTradersShort": "0x78d12c7ce194bc5cdf1ab87ca31b1bfcb040a6341851f56e853de76f208975a5",
+      "positionFeeFactorForBalanceWasImproved": "0x76833eb14104290bb99bf976783216c67e7e2dc8272f9334bce6a93fb749fd2e",
+      "positionFeeFactorForBalanceWasNotImproved": "0x3b2647ab874cf814b12fe1955d0590838c8a2debf408bdf9366f649488a95509",
+      "positionImpactFactorPositive": "0x3db475bc531ef7b42fee34c3f6a733aabfcbf36b24bf36df2c94094db0840cd4",
+      "positionImpactFactorNegative": "0xedf20c8d09155c3ff0f69776c3972e151606ccd2a31d4b468ce7f7d5834aaa9f",
+      "maxPositionImpactFactorPositive": "0x3e4dffa5478c52a35e5140ea6439792a093a8f79f083f9595447ccec7f54c31f",
+      "maxPositionImpactFactorNegative": "0x99b02f5dce1b3c9f2c40017467d8e0c48276a809c6ccd47f7a9b5860c90dee23",
+      "maxPositionImpactFactorForLiquidations": "0xb0ed4cd8cd6bb2c63ce259752abace4f044dbc5eef78a18551f28ccfee1cec0b",
+      "maxLendableImpactFactor": "0xc3449f50953d1498dd440bfa7783820f737587b7480e316e2ef31c8aa410cb21",
+      "maxLendableImpactFactorForWithdrawals": "0x95818b7f2c7f40a7504e0b67dc5153b46a338937badaf9a3ed208debdea51a2b",
+      "maxLendableImpactUsd": "0x9b2bd81064d50c1014d8f54ac3e12d8e05f2b790b872ce2c5923982a00933f21",
+      "lentPositionImpactPoolAmount": "0x5192d5bf1d68075ecd2fd6ef504cbe1af938959c8b014c8ec9155f2e8ac8e52a",
+      "minCollateralFactor": "0x1181ceec0e6850fab6bd90b9203cd088efab011704af98c4940748670d0c0c7c",
+      "minCollateralFactorForLiquidation": "0xf3cd626f31924cebe44eb53b4d3f93e8baa5a6dec5fa61d368b3b5dc211cfea6",
+      "minCollateralFactorForOpenInterestLong": "0x0a49cd6cf89940daa7273277296663930e02a97a33e384501320df18d89553d9",
+      "minCollateralFactorForOpenInterestShort": "0x3ddbac86d1050ffbe51179dfd33fc8b68d6bdd6677e2ef03c596774fd7763ed3",
+      "positionImpactExponentFactor": "0x6c376766a0728ffddfde792193f8c4bf3fe375e201c135dfbb43e6c3d1af46af",
+      "swapFeeFactorForBalanceWasImproved": "0xeed1d4eb8d21f124d78e73f4322a880920fb0c4e067c366abc31f3f59cb67a26",
+      "swapFeeFactorForBalanceWasNotImproved": "0x346e2a9e5b9ed2a45bd4b1f59aaa1a4a92f7e2885df0dc216cb9f2780504b6e9",
+      "atomicSwapFeeFactor": "0x04049424025e808cd6dd2231f58e313e442d777d3af3807df8b2db8660e86943",
+      "swapImpactFactorPositive": "0x7975df19a8b17790ed01606614f98f56f39ca6f9f6829b8da95810d661554640",
+      "swapImpactFactorNegative": "0xd89e695ff64a92e7a0d74651df1a623b880ab1006f4cf6f78d111f54b32baae2",
+      "swapImpactExponentFactor": "0xcfe098aa5b07e41390a50bfc18156f58d374efa92124e5a38242695bb7f8ca33",
+      "virtualMarketId": "0x9da5cfec805186e676d65a6042bfce7d05b7a19416289e075f8a6b683242e22d",
+      "virtualLongTokenId": "0xaab37f889b9680dda34f58a689de3023cb22f7ae14d32a3c1d45798a973db1f5",
+      "virtualShortTokenId": "0xd5258cb84f0039be58306488e8df941c05f3cf4f219e92aacb6561c736bbb960"
     }
   },
   "43113": {
@@ -4082,19 +6082,25 @@
       "maxFundingFactorPerSecond": "0xd1fc06210a074798a3d8507eaf9f700de175c23098526798515da3d093ae3644",
       "maxPnlFactorForTradersLong": "0x36decf951766da747b2bb875b646c43c9f4548d1db9bd2983230b1cef12460b1",
       "maxPnlFactorForTradersShort": "0xad102f8399fa1b92ae45845f95f896d5bf61d8b53e3904b35d0bca50f2d16de9",
-      "positionFeeFactorForPositiveImpact": "0xebf23a62b9be6bd236fe83a4a7cdaf4a0f22063071a2045354032286b1d0c088",
-      "positionFeeFactorForNegativeImpact": "0xeb54a7af740d7a9353478e56d3482cd29b9c3afaae2669b1a47ccbc6ae975b96",
+      "positionFeeFactorForBalanceWasImproved": "0xebf23a62b9be6bd236fe83a4a7cdaf4a0f22063071a2045354032286b1d0c088",
+      "positionFeeFactorForBalanceWasNotImproved": "0xeb54a7af740d7a9353478e56d3482cd29b9c3afaae2669b1a47ccbc6ae975b96",
       "positionImpactFactorPositive": "0xddf60db455866355beb69621cc530e07d254c81adc27b15a564d05b388f5ee2f",
       "positionImpactFactorNegative": "0x456efec2eb744a5ec841bd0d4b515de7274f1ca8557472a4de5c42508c4efef2",
       "maxPositionImpactFactorPositive": "0x3be668a8c7be13b0a349732303c4b95a907bd0e9668a4bbec4dc3f1ed5e7c2bc",
       "maxPositionImpactFactorNegative": "0xd8d979478a3b8bceafa8a848b25784dd00b64bef081c4c1dc9dd60bff7cea798",
       "maxPositionImpactFactorForLiquidations": "0xbbfe96bfe46f446d24be78d7bd2edd34334294e89048f8882360bb743584cf7f",
+      "maxLendableImpactFactor": "0x9db704bec7ac071e0e90f7a93461809904f80664c78d05e69d231e9439dd5dfe",
+      "maxLendableImpactFactorForWithdrawals": "0xba0e0bf03d0c02aa72bc5fc17c3ebd655ee0636528247532b4e13226a1037ef3",
+      "maxLendableImpactUsd": "0x68cb741fa9d254bfcd5c73666794d3e6a3fbb6b6544049e7dffc7f04409ad248",
+      "lentPositionImpactPoolAmount": "0x30dfa4ec399ba1f32b162a7574da6d48c51bd0cbf10a878bed90528917e8b324",
       "minCollateralFactor": "0xe910b1cb7c36fa1e005d1ce213e744ebb8e19c07f0e934605fb998fb518ec4c0",
+      "minCollateralFactorForLiquidation": "0x363406d304aa67f7d3bbde74f80598186c221785469b490cb4927732ee1de679",
       "minCollateralFactorForOpenInterestLong": "0x3a15736cf99d0f99680260b5422bc87fd69925adbb1387bf7048191f19cab935",
       "minCollateralFactorForOpenInterestShort": "0xcf4ade53abb36ffbad4b0f4ae1379faa82afa998f3a47875c9986f82cedd274b",
       "positionImpactExponentFactor": "0x376b7203a91e73beffcee3efd325eb4e5f07101811d7f211fc36009ca3c95b91",
-      "swapFeeFactorForPositiveImpact": "0x0f8107aaf93b9fe210573d13194d9f77eaceb15b8771c42c821a0046b76f94d0",
-      "swapFeeFactorForNegativeImpact": "0xc6659dc00cc2d64bc22cd4217267efab7bd990328add0b4bc154feee535e0c6d",
+      "swapFeeFactorForBalanceWasImproved": "0x0f8107aaf93b9fe210573d13194d9f77eaceb15b8771c42c821a0046b76f94d0",
+      "swapFeeFactorForBalanceWasNotImproved": "0xc6659dc00cc2d64bc22cd4217267efab7bd990328add0b4bc154feee535e0c6d",
+      "atomicSwapFeeFactor": "0x788e6796662b5dd7c35ce1b4ff0d9af55b38c49eca63a9d2560f226d15721a71",
       "swapImpactFactorPositive": "0x915a610544b2e035a83207d2f281b51c24cd0d652142267d6d4eb3690a449afe",
       "swapImpactFactorNegative": "0xf38fd5205d6308e37a289083eb9bf290becf831331de85ae14d6b8e2c0d9c839",
       "swapImpactExponentFactor": "0x9762e6daac9702ee4052c875bf12c8c18afc24669a6373f713b6d5f3b2988a4e",
@@ -4132,19 +6138,25 @@
       "maxFundingFactorPerSecond": "0xb91853fc411f43eb24c1a9cb597ea51291798489477cf5983c01a385db812d62",
       "maxPnlFactorForTradersLong": "0x8d750459295a168d231d34ac38231e1d2ba6dfa008a6d164ff6a72509d095f4c",
       "maxPnlFactorForTradersShort": "0xdf531b55429ddeadb59af967cb730b299076d579cdb25bb1cf017a0326f4284e",
-      "positionFeeFactorForPositiveImpact": "0x0d325124b70072382ae96a7cd97da4d8a5a51f68468d67f742addfcf4a4f669a",
-      "positionFeeFactorForNegativeImpact": "0x6fa4e6c42336bf8f1d32bb48964ba1c24df421fd3d1072a63b1528b2a8a4b609",
+      "positionFeeFactorForBalanceWasImproved": "0x0d325124b70072382ae96a7cd97da4d8a5a51f68468d67f742addfcf4a4f669a",
+      "positionFeeFactorForBalanceWasNotImproved": "0x6fa4e6c42336bf8f1d32bb48964ba1c24df421fd3d1072a63b1528b2a8a4b609",
       "positionImpactFactorPositive": "0xc3112e11103bfb1a728062fd6fb789086df6e7819d99cadc56161673ec2f5747",
       "positionImpactFactorNegative": "0xbcaa544b510afd8e66299f43b2457e58d68d5ee44a0e71314a9c54ccda29166b",
       "maxPositionImpactFactorPositive": "0x885c542053b7fa77c9a4a2dc267dcb133edcfafd7c93d3e34b3aaaeb84d71e15",
       "maxPositionImpactFactorNegative": "0x6a5409f88cb735d2e2ff70cc0c5738c19422c5543034d1bfc997cb4e8e0ff913",
       "maxPositionImpactFactorForLiquidations": "0xb6f88dc723473750a0b961170270d31fba437679f22bfde4b267a55325fa5f57",
+      "maxLendableImpactFactor": "0x6905d1082b2762772ab4518370d5c5168d2c3877e2381e37393452d44fd74932",
+      "maxLendableImpactFactorForWithdrawals": "0x1922711cd16e88c089890bb41826689426a3ff93c3f9a56cc5afb69254caa92d",
+      "maxLendableImpactUsd": "0x80124f278e5d8cabb600bb5eab8b4bb250364ebcdfd43d6c301ce4f4deb5fbf6",
+      "lentPositionImpactPoolAmount": "0x684e8643977be0d44bab018cfe226692650c5fffe6a6a71595e8e68b6b57398a",
       "minCollateralFactor": "0x2bda0f19bd0a9c7a0bf9e89a4b1bcf0d06949d290d084f094d1f2daa73890e18",
+      "minCollateralFactorForLiquidation": "0x4675a79fa14651780daca8e35375904acbeb2958eb5414537ee4214241ee8dbb",
       "minCollateralFactorForOpenInterestLong": "0x6cf8feab7ea0d8a785b057c390baee97be69e93f87bd3b5ef1b32522ade977e0",
       "minCollateralFactorForOpenInterestShort": "0x0b5cf2a96425f12b6771217757ad7d3eef0e1a618e0d28884219088615a51649",
       "positionImpactExponentFactor": "0x54962ade4b4aac31514ded3d1b37063c949d3579f0ffb707be0d92b66cb3279b",
-      "swapFeeFactorForPositiveImpact": "0x620fd8da66402524c473af3d4496c67b9d787ee9a73d0b1ebc33c2ca501999c8",
-      "swapFeeFactorForNegativeImpact": "0x8b76d4be7c26e5330ccd659b7b84869b2521aee30ad02c0f64dde54d33ba740a",
+      "swapFeeFactorForBalanceWasImproved": "0x620fd8da66402524c473af3d4496c67b9d787ee9a73d0b1ebc33c2ca501999c8",
+      "swapFeeFactorForBalanceWasNotImproved": "0x8b76d4be7c26e5330ccd659b7b84869b2521aee30ad02c0f64dde54d33ba740a",
+      "atomicSwapFeeFactor": "0xa9b44fdca74a0013f9f5a792e7c24b494f5f530b98830110e47b0d42c5fbc47c",
       "swapImpactFactorPositive": "0xa6ac9172d7f7529d6a77a02977721eee7008f596226749c98b3cd137f49b0309",
       "swapImpactFactorNegative": "0xcbd4c14cf1648fdf9f19d309a2d11d4ac497544d25f3a913d864cb326abcf08b",
       "swapImpactExponentFactor": "0x4f79dda5d67fa79de75a32bbb31b26de722b1282d3e32860aaf16aebf440459d",
@@ -4182,19 +6194,25 @@
       "maxFundingFactorPerSecond": "0x2830ae0739c9163de9cf708a6f6c32f662f2ad071c3499e9b12c675056298d40",
       "maxPnlFactorForTradersLong": "0x36fcc2dbb30808ebaad7f8c9a844eb1b4689f9a62d90e552adbbe4343dfebdf1",
       "maxPnlFactorForTradersShort": "0x3d08433ff57f425f4721425d4315941b31adf3f673530845a92056ba70004ace",
-      "positionFeeFactorForPositiveImpact": "0xac00be90a0f05763ef66e50ae8ca9e0ff056b82fac3f307ce8a14e91af0899c4",
-      "positionFeeFactorForNegativeImpact": "0x1a3121c3ff93d3120708ecebb47afb56c49c4c1363ea731e7b0bb8a2e228d1dd",
+      "positionFeeFactorForBalanceWasImproved": "0xac00be90a0f05763ef66e50ae8ca9e0ff056b82fac3f307ce8a14e91af0899c4",
+      "positionFeeFactorForBalanceWasNotImproved": "0x1a3121c3ff93d3120708ecebb47afb56c49c4c1363ea731e7b0bb8a2e228d1dd",
       "positionImpactFactorPositive": "0x850a0dee7de0bfcf04be51d47c2f3668bc4fdaab5e29e2d589984376b5dd86ff",
       "positionImpactFactorNegative": "0xb9e817b94ea5ac97ad5125913ad2807a275718730c2498740fc9c888d6b43a03",
       "maxPositionImpactFactorPositive": "0x06870bc32614718b265349bf6300294056628d60ca10f5d35c63998d55a41f8a",
       "maxPositionImpactFactorNegative": "0xe68bf971e0e02267b79e78933811a5fcbb67012ffb373f57d08e6053bf50d2eb",
       "maxPositionImpactFactorForLiquidations": "0xda655d82bdfac7f52574b69be3faba4684029b4f692b4d6e9a27e9ed0db5eb18",
+      "maxLendableImpactFactor": "0xfa593d54b5c34e98fec7dc8515a180443bfd9b30e100c68d75df4dfd70527401",
+      "maxLendableImpactFactorForWithdrawals": "0x184a90bdd9e17af13d4c8ff820c9331f157e6db5a2e18d6e5e51735e82734246",
+      "maxLendableImpactUsd": "0xa8b90dcf6d7893f3198c375cdd895ccc3d8497d9742cdd4877e2f876d9a33d8a",
+      "lentPositionImpactPoolAmount": "0x70eddaca6e85713493750fac03e971df8177bcfa9bb091ec0c121e2f0f968c86",
       "minCollateralFactor": "0x45d92c625d74a031ce8338d168d2ec1699f338ca8669ad7f210c98ef9461bc43",
+      "minCollateralFactorForLiquidation": "0xe92fa6b0415f90201edf5c668993487dbedb71de9bb489cc4bec41ecebb369cc",
       "minCollateralFactorForOpenInterestLong": "0xff9fe8e3365a18b999251316da505a550055626be033cf34378f1afd550a4f5b",
       "minCollateralFactorForOpenInterestShort": "0x770be0a07523fcc86290097d7261ec89c9c2e6b811a5abde348eec9b6afb5bf8",
       "positionImpactExponentFactor": "0xc64593f64cf0192c99b011e0843ca58075f1d4b6dbc285f91e812aef624b75f3",
-      "swapFeeFactorForPositiveImpact": "0x4ef7984fde2237fdd6c76d410cd45733e29a8208a1a444d416a4cf2c552455e2",
-      "swapFeeFactorForNegativeImpact": "0xe14d026478c114bfabffde611c4387b3c1ec943f2fc6b1304d98755239ac4946",
+      "swapFeeFactorForBalanceWasImproved": "0x4ef7984fde2237fdd6c76d410cd45733e29a8208a1a444d416a4cf2c552455e2",
+      "swapFeeFactorForBalanceWasNotImproved": "0xe14d026478c114bfabffde611c4387b3c1ec943f2fc6b1304d98755239ac4946",
+      "atomicSwapFeeFactor": "0xc4d687e7509a762728b1ea111a0ce1183ee56281a43f6b3c16a44a935ed87041",
       "swapImpactFactorPositive": "0x4b1439a3ac79073d516183f0266a7545a2d55413d776d8837dbba0d3238f3744",
       "swapImpactFactorNegative": "0x15e3223c9f47dc35339b9fcc3a24b9984db33d7a74d7e949f62e3f082f005e20",
       "swapImpactExponentFactor": "0xe8bfbaf25ed510be1d648f3cfc47f80928dcce48b8e3de792bcce21079984ee6",
@@ -4232,19 +6250,25 @@
       "maxFundingFactorPerSecond": "0x2c064f54afa3c1d6d05b856843db27379f139cb7e88aa826aba60051b5a0c9bf",
       "maxPnlFactorForTradersLong": "0xa8005a0f060de7da9b23e9af19cfef87a6e232331d9f356a74ac63f8df764658",
       "maxPnlFactorForTradersShort": "0xc532b70d99e867d7eb5cb21b12c09a281e800f89ef7a7477438017caec63b4db",
-      "positionFeeFactorForPositiveImpact": "0xf44b4bd2efe1f90144b6e87f9f83928ff11876ba474225b551b9728f684be6d7",
-      "positionFeeFactorForNegativeImpact": "0x3f12c9cb349f4feec74d2fcbdfff7757fe630c8d65b95af0f23dd5a01cbf7f14",
+      "positionFeeFactorForBalanceWasImproved": "0xf44b4bd2efe1f90144b6e87f9f83928ff11876ba474225b551b9728f684be6d7",
+      "positionFeeFactorForBalanceWasNotImproved": "0x3f12c9cb349f4feec74d2fcbdfff7757fe630c8d65b95af0f23dd5a01cbf7f14",
       "positionImpactFactorPositive": "0xe7e37a77797c58eed5479a474355840c4b068f56e66f1fd356518754d41e8d71",
       "positionImpactFactorNegative": "0xaea38fd5a23fbdf8e436805ba7d16709b9587de0e613614a27e241159c532cc3",
       "maxPositionImpactFactorPositive": "0xe58eaeb5cb769661e5812ed30888816663d04e418a2a2294a60dc183998bc24d",
       "maxPositionImpactFactorNegative": "0xbdf2714c7cee0ba4bc78512846368491218658bf4506af2c0a5560c5d2ccb98b",
       "maxPositionImpactFactorForLiquidations": "0xb0ea1a8a442d94107fa9d601c8fe41c3071a4f6a212f6ee8cf5d2f3af03af9f3",
+      "maxLendableImpactFactor": "0xe2a4e43bde1878da29dae5a7787f199a8bb5e583957c3ddd566ee2d466af01c8",
+      "maxLendableImpactFactorForWithdrawals": "0xbf2805b8a8888767a4b59cf8ef33f341460051999a88a860f0d352014d579a12",
+      "maxLendableImpactUsd": "0x8fc9544d8899a2083f0091010b86542f2c88c79f9f46951724d8d8b039c94407",
+      "lentPositionImpactPoolAmount": "0xec44cf942c5f80c1aaa3001e30261cf0af83d55f473974a1c1c7af1e94f2c720",
       "minCollateralFactor": "0xbaaa90a41b92be436a5c13d02137ab4d1da57a1256942b29ff1122f4ae3910ee",
+      "minCollateralFactorForLiquidation": "0x87ff74340b078cfd33cae47ce1e3ddb268a2380d8badb47bb14ff760be63c9a8",
       "minCollateralFactorForOpenInterestLong": "0x8cbab030e059e5061c5844541de54fd884103976d5748b1afc27800eb6956781",
       "minCollateralFactorForOpenInterestShort": "0x964f5425e2d87724d0e98f792e7d202ad30cd08d5b28a305041ef1365fd64c24",
       "positionImpactExponentFactor": "0x1a4921b5ca5088e7e780e76a9b8c2cae1f8c46ad9238eecd0677d65eeb88c8a1",
-      "swapFeeFactorForPositiveImpact": "0x6f04144bb368e6acb012e2a47ebfe5802a7aeb1a89c990f21c1c805091c45e74",
-      "swapFeeFactorForNegativeImpact": "0x62632c19dc73e4144e7d5c11add032ee54ca6c78c5bf178800e5fc530e3f6c5a",
+      "swapFeeFactorForBalanceWasImproved": "0x6f04144bb368e6acb012e2a47ebfe5802a7aeb1a89c990f21c1c805091c45e74",
+      "swapFeeFactorForBalanceWasNotImproved": "0x62632c19dc73e4144e7d5c11add032ee54ca6c78c5bf178800e5fc530e3f6c5a",
+      "atomicSwapFeeFactor": "0x40fedddf9a8da6ade587f270ef4508b82a4eaeff05567fc8fffe4a1e958b4d49",
       "swapImpactFactorPositive": "0x0b7287e535216c5171cff8248a990ebfd8cff085af5f7b8d599679ad5642795f",
       "swapImpactFactorNegative": "0x2a313049a3fcf67138a26bc513f4c9fdd1b9585276633b01dd5de9092ab96423",
       "swapImpactExponentFactor": "0x3f4613e8874352a37ea67ac77a3d73f85f46d1096e67f9ab6e6003f28bff3ca3",
@@ -4282,19 +6306,25 @@
       "maxFundingFactorPerSecond": "0x53278f7d22214bd9097904f84ff59ee91463aff495cdaf5e810dde8564083b73",
       "maxPnlFactorForTradersLong": "0xe5e10ecab6bc07b943b0913ee1f61ca27256d563b5375b5c695809a2b59d0fb4",
       "maxPnlFactorForTradersShort": "0x55ad52312b9a5bbcf07832826e1e59f7dd60ba801769b7e2b9b3e2278fa232df",
-      "positionFeeFactorForPositiveImpact": "0x571589e332241341cdf027492e3d4374b2a93ef06874b73075cb7947f93534d1",
-      "positionFeeFactorForNegativeImpact": "0xa5f763cab3d8762f2a7027c677bf7c9f5786542d01a7f59c96bedc648bb035ba",
+      "positionFeeFactorForBalanceWasImproved": "0x571589e332241341cdf027492e3d4374b2a93ef06874b73075cb7947f93534d1",
+      "positionFeeFactorForBalanceWasNotImproved": "0xa5f763cab3d8762f2a7027c677bf7c9f5786542d01a7f59c96bedc648bb035ba",
       "positionImpactFactorPositive": "0x9810f2d2e180503c8290af9f276347ca3ce4791e1479fd6532913e67a424ba69",
       "positionImpactFactorNegative": "0x95e072ed96f17673dc5ebc6fa2fdd7737b58d4200f69f9fe06451d81ede06b1b",
       "maxPositionImpactFactorPositive": "0x7bb5f084d55a70ddca3fd48f65cca1a09c0709f02816844610198577d9f41498",
       "maxPositionImpactFactorNegative": "0xb581b24a566d8407faf6b940b547885f670884caa28552f4c4267ed3e292f0e5",
       "maxPositionImpactFactorForLiquidations": "0x5ab50ee39c6a00792a7a8994d4881f8b946180b937ebdac34e2d199a9b884c6f",
+      "maxLendableImpactFactor": "0x1387afb6154c7cbf8daf4f65eaadbbeae179487de4bbee973f41a0729bc0b681",
+      "maxLendableImpactFactorForWithdrawals": "0xaa191090a6af58e3f09e9e41a5353a606d8e25033b4e863abfe15077aad8e928",
+      "maxLendableImpactUsd": "0x709de5010e9f8d311a65eeb69d9b8903728d7c6a78a49ab3f838d6123b345b54",
+      "lentPositionImpactPoolAmount": "0x95b9d0993679ca9c2649b9f826e54f2fde0d14b3e9dc6af3ac2b338a09834abe",
       "minCollateralFactor": "0xae80dde9ed11f8ffd789be3583df9e79a38f49ab1ba4dbe01fb87936545f600e",
+      "minCollateralFactorForLiquidation": "0xcbd111c1ddb157b7224dfa2eebc5b69b6666e02062258c016e027a45b66059d8",
       "minCollateralFactorForOpenInterestLong": "0x3ee6bddafa71cc4e83b9278ef2f015a79ffc105e946f4b46c521388432cd9939",
       "minCollateralFactorForOpenInterestShort": "0x02a996d1421fa2442a1f27ce3c7f58aee300fe3089fc26ec58f76f12d1faf28f",
       "positionImpactExponentFactor": "0x8ed469b25e2d0ab97824ae5523c62e7010f10d1777fefd34b5035c6cfc03a10d",
-      "swapFeeFactorForPositiveImpact": "0x4ca3b7aa799d579bba5612492862b5bbf5f22db53b16b6f664e01e2089fff96f",
-      "swapFeeFactorForNegativeImpact": "0x7892b0a32c16b5e6569488049b577a75dc35440887bd5ff698747b8e8b09e079",
+      "swapFeeFactorForBalanceWasImproved": "0x4ca3b7aa799d579bba5612492862b5bbf5f22db53b16b6f664e01e2089fff96f",
+      "swapFeeFactorForBalanceWasNotImproved": "0x7892b0a32c16b5e6569488049b577a75dc35440887bd5ff698747b8e8b09e079",
+      "atomicSwapFeeFactor": "0x980e9ca063510ef3ccf46dbbcfad2ab7317123c8c17b73377123f2b751281a82",
       "swapImpactFactorPositive": "0x1feef3112a12fa7240eea516d9c5fc70ea06e89d908422e4232c8bbf77d9bf65",
       "swapImpactFactorNegative": "0x5159d374359947b125e79c43605b0fc3a99c2ce395723b046cea6101d0c2cc6b",
       "swapImpactExponentFactor": "0xf8a49893dd52d401bc8615640b9a0b489fc7d0b89dff990a52d2b2d4d718670f",
@@ -4332,19 +6362,25 @@
       "maxFundingFactorPerSecond": "0xa1d6b04d3383638cf84863ad9e37716f8c576f9000d419ef9909e4131ffb5fe5",
       "maxPnlFactorForTradersLong": "0xc84854c769b03060ed2982322c35b638313b98d6884e5485b4a55ec74c8767aa",
       "maxPnlFactorForTradersShort": "0x0f40ef579c4fbf10923b92970b0dd1ecbbaac182f90856a23bd4ae629f9941a0",
-      "positionFeeFactorForPositiveImpact": "0x7a63c5bf1f71d763ce6eeca7382fc999d1fb9cf639ee124990e6d6466e40f06c",
-      "positionFeeFactorForNegativeImpact": "0x36ca219c1c81bea677d62e2b2e5b22206cd385f69e1544fa978de4749b2f18fc",
+      "positionFeeFactorForBalanceWasImproved": "0x7a63c5bf1f71d763ce6eeca7382fc999d1fb9cf639ee124990e6d6466e40f06c",
+      "positionFeeFactorForBalanceWasNotImproved": "0x36ca219c1c81bea677d62e2b2e5b22206cd385f69e1544fa978de4749b2f18fc",
       "positionImpactFactorPositive": "0x851dde81ea8d4ee781c8694a717fe043ef8d687bef17d6f4ed67a0e4b068dc8c",
       "positionImpactFactorNegative": "0x5a4d44557ccbfc629001935ce839c93d7e73deecd01bd5d529c6c637e1d075b3",
       "maxPositionImpactFactorPositive": "0xda40b2f3412500cccbeb10fe49e074350c9332e85d7f2ac70b628198eb5cbe19",
       "maxPositionImpactFactorNegative": "0xcc72fedfb67e03fb6e89c35995b133c60e72ebf835ceda1ddcb11dfea7cfd9df",
       "maxPositionImpactFactorForLiquidations": "0x12e5eff138fee8a5165e1120e527f7fbedb647b60b8003214942ea80a27eb245",
+      "maxLendableImpactFactor": "0xa943d492ea8a8ee576462f5e20bb1329caa15626d3eecb3cd191c4a09030a172",
+      "maxLendableImpactFactorForWithdrawals": "0x092c6d65ead5d73190c48d23445cc8d833e1d57a9c858110967b1b396becf01a",
+      "maxLendableImpactUsd": "0xaf602d636576bf89bbbb45ed6340469fc1b1f314812b3ea2cc443e77a00ae9b8",
+      "lentPositionImpactPoolAmount": "0x385ee4d8d93ad8c682386b2f3b5ae4ca4418b1f0d3e139ee4f1d997f6b5f49dc",
       "minCollateralFactor": "0x458441692f08c6fd6bc9096d6c6a85c9b30df02b3f2956d04603b1d84b5823aa",
+      "minCollateralFactorForLiquidation": "0x2fa437b43c4b8978a735c50513a74e89c5cd7f0d2a35ab4f964c4910b9563771",
       "minCollateralFactorForOpenInterestLong": "0x2397923fc51dfa26d6dac95bec87e8d79e15cf9c934d9cfe3b26e3462bcc2145",
       "minCollateralFactorForOpenInterestShort": "0xcce46a44d5608dda488c9313a4ec985f8c2102f31fd7c96fb91156aae3911ca0",
       "positionImpactExponentFactor": "0x707aa723bf3a479a8300aafd64736f2425a181ce672a79718ad6af650ff87cf8",
-      "swapFeeFactorForPositiveImpact": "0xa90535e679944e8be6065b015c62d6a51632451ce684f9e398c1544929caa6d5",
-      "swapFeeFactorForNegativeImpact": "0x8cda7ab8513c5de3476aa7c0474266c014d1298074d525ca18f1f04002df6891",
+      "swapFeeFactorForBalanceWasImproved": "0xa90535e679944e8be6065b015c62d6a51632451ce684f9e398c1544929caa6d5",
+      "swapFeeFactorForBalanceWasNotImproved": "0x8cda7ab8513c5de3476aa7c0474266c014d1298074d525ca18f1f04002df6891",
+      "atomicSwapFeeFactor": "0x40825caecd1cdc11f5c50fb7cbd67e8e4d02416e771c516e624c1b12ab6d8a2c",
       "swapImpactFactorPositive": "0x5ba4c56931ed525a5b04e368b7c85d09ef955a121f1a28906a13a6724b5d8cdc",
       "swapImpactFactorNegative": "0x45e04b88cc7e70f0735c51990a40628b581844ad76c1158d93ce57505753ce24",
       "swapImpactExponentFactor": "0x49a3c45cc6fb8b327035f5165a13336c0a22c057e7ac09b9eafe737518c1a180",
@@ -4382,19 +6418,25 @@
       "maxFundingFactorPerSecond": "0x47105b65f791d1f40086a1d5a655bb4666efbc5229212cec0927bbabf56ade3e",
       "maxPnlFactorForTradersLong": "0x0b29dfb8a7685ae6f9cf9b6d3a2c914d24bc484bea6fbf87ab472447e77e2b26",
       "maxPnlFactorForTradersShort": "0xd5e520348bde318f79a2b259ab5c1dd90b414994393279c9a8e729faa3e20ae6",
-      "positionFeeFactorForPositiveImpact": "0xd0777dcb9da47555ce8b2b77dad364d19b48c036066ad3aea8237e599d73865d",
-      "positionFeeFactorForNegativeImpact": "0x88d8852e314bfc2cf80165d339483901a2cc40302b93d830ae9f5214bbed895f",
+      "positionFeeFactorForBalanceWasImproved": "0xd0777dcb9da47555ce8b2b77dad364d19b48c036066ad3aea8237e599d73865d",
+      "positionFeeFactorForBalanceWasNotImproved": "0x88d8852e314bfc2cf80165d339483901a2cc40302b93d830ae9f5214bbed895f",
       "positionImpactFactorPositive": "0x2991b8b03f8bbda42160bf02d03729611c46a37dc975195ca27fc317f24f5434",
       "positionImpactFactorNegative": "0xc38d57490f22112f54b2f4af3fc063982f98dde1580822c4491a4d068e2e2dce",
       "maxPositionImpactFactorPositive": "0x14edeb4f5ee66980440cdfd82bc36b526d86225c9d23444487094c41da526a25",
       "maxPositionImpactFactorNegative": "0x4d7a0c4c14200e8f4572eedcd3e0d0ecc5d86504661f9f1390478eb7a7c52108",
       "maxPositionImpactFactorForLiquidations": "0x5522503c2d885644e228ff626074c899a79689cdd05bb8d67790e462358751b5",
+      "maxLendableImpactFactor": "0xfb52c27fcefb2609956b29fac761b9eb9b098d57dfbbfa54a8bdffbb11ccddf7",
+      "maxLendableImpactFactorForWithdrawals": "0x0be5d9b16721e73e6e070dfe64d01b649b6d79ee2c263e63189e728a7a09b264",
+      "maxLendableImpactUsd": "0x8013378f3d03169032387578c5e109fb8db8941fe391a656ab3186122c360c3f",
+      "lentPositionImpactPoolAmount": "0xa4edccb84829e4c3e08bb988898e50993e8f78e5a47ab2fa82550677f4f7cd8b",
       "minCollateralFactor": "0x97ea28d35e02b8862fda306e39a8c77858b4b942901171d778184db29497531e",
+      "minCollateralFactorForLiquidation": "0x3144b9a5938b191d682d5b8efeed673dc9c06646f4e283817ed5269a4b6cd78f",
       "minCollateralFactorForOpenInterestLong": "0xdd677dfaf255e6feb915781df3a369173f1ba6a2fdeab9b5042ec3fe4f996930",
       "minCollateralFactorForOpenInterestShort": "0x54debf477ef3d09f2ef162dc9e624468c36c8e85f1e888837f6068c67b7aaf66",
       "positionImpactExponentFactor": "0x5133495a189f1db6dc1f6e752ad0ec22aa469f193c9333ba9bd2fcd99903f55b",
-      "swapFeeFactorForPositiveImpact": "0xf6498bb4fa2f2989961e3464a3947df93d9cac0bbce132a839479cdf8e09267b",
-      "swapFeeFactorForNegativeImpact": "0x142b92fa5d0cf4e4757c0eae3b63d0bb49d6845429c32cc3dbf57eafa62d388f",
+      "swapFeeFactorForBalanceWasImproved": "0xf6498bb4fa2f2989961e3464a3947df93d9cac0bbce132a839479cdf8e09267b",
+      "swapFeeFactorForBalanceWasNotImproved": "0x142b92fa5d0cf4e4757c0eae3b63d0bb49d6845429c32cc3dbf57eafa62d388f",
+      "atomicSwapFeeFactor": "0x70bc5ab7094ea2c8739cfd003eccbe740c18d03242e18d4c23a943eea2fd5ab7",
       "swapImpactFactorPositive": "0x4c21de75900510998632752943bdaae846fb3cd120da605ec2704287c27dae45",
       "swapImpactFactorNegative": "0x97a9546d0e8771e3f65b56eb7a6faf815f6d257777ae8d7b03473eb0e1246ab2",
       "swapImpactExponentFactor": "0x50eb756d6759ffca7723754dcf3ff56c2525bb49868fc2d0e52c4f642d0da36a",
@@ -4432,19 +6474,25 @@
       "maxFundingFactorPerSecond": "0x5cf677b3b1836a5324b2a974c9db309322a2e9ac6335f3a82639b1915a4daeec",
       "maxPnlFactorForTradersLong": "0x1cf2cc01138a5b15358c77d1bb3bc7726748f718951ac707bbddb05d169d85ac",
       "maxPnlFactorForTradersShort": "0xeb9383656f42f363d792368765a94c2b9484ea2881c93bf05af173918d33c5fc",
-      "positionFeeFactorForPositiveImpact": "0x53f43ebe35bb75a4ee867704637ce5d443464239fcc35e163497e387be3ab150",
-      "positionFeeFactorForNegativeImpact": "0x50fc727f8f54290d02a7258554829d16dbfd870ae3e74e06ce8188f6186073cf",
+      "positionFeeFactorForBalanceWasImproved": "0x53f43ebe35bb75a4ee867704637ce5d443464239fcc35e163497e387be3ab150",
+      "positionFeeFactorForBalanceWasNotImproved": "0x50fc727f8f54290d02a7258554829d16dbfd870ae3e74e06ce8188f6186073cf",
       "positionImpactFactorPositive": "0x25e7d425bc1d7d56be537e4b15f50da3a4976eda1912e15a52e365447948b3d7",
       "positionImpactFactorNegative": "0x0881517f1b4fb63898040c1a3861d9ff6f924a0abc44917078dd8a38f9522e12",
       "maxPositionImpactFactorPositive": "0xc0e44af408c1c79ee19e0fef8f6b9c8307a67016336daee3621b3f615c652fe7",
       "maxPositionImpactFactorNegative": "0xd2ef5fd6cd84b151dc6b5328579738856c7d99d53c98fd5795aef56623c303af",
       "maxPositionImpactFactorForLiquidations": "0xcfded09cfb3bb784b53a06ed6b95c34d3ee29481a0e8166668fbeea50ab3286e",
+      "maxLendableImpactFactor": "0xf9897dcd773b1ba122ecc580128b3a20eb2e3929c268e59b038e498dd0d2e1d2",
+      "maxLendableImpactFactorForWithdrawals": "0x2b55d610f89fae16d27b55ee4da7f9351976d0cc50b6d855ad3627659e3f99b7",
+      "maxLendableImpactUsd": "0x755fea56f53ee53ce8149795f297794b064a2fb7ef5cef2ea858fa2c454ade6e",
+      "lentPositionImpactPoolAmount": "0x973f246bc300b23e97621a478ca0167dc414f08c0bb747b4095a23e33cf79103",
       "minCollateralFactor": "0xa9476f3721a3ace0e929e1ba274fc72c6d8db29cc1d9e2c0fc2bd49bec67b197",
+      "minCollateralFactorForLiquidation": "0xe0c8811ffba815d0fbb87b64a17f0f1bac3ea3b6613f79f8646289964d94fec7",
       "minCollateralFactorForOpenInterestLong": "0xfab6fae41bc596b1bfcfb94ae9584c0de545d379cd225cb9c25c487d0503e4f7",
       "minCollateralFactorForOpenInterestShort": "0x4c1326fc073e6b1d85be6a3d20e1c8ad4cbb9954a3705d9143e1c9245907cd85",
       "positionImpactExponentFactor": "0x01843a5efcc528e9c8ac7b8cd268b5bacd76a50ab8567b7642f774d15aaedd66",
-      "swapFeeFactorForPositiveImpact": "0x88018f8220a21b3917d43ad26912e52e3b8ca361da3d8174be35567b0e24af1d",
-      "swapFeeFactorForNegativeImpact": "0x548929a4495accb9b6cb141f314517f145ce7ea2b032738583b964b3c67b20c5",
+      "swapFeeFactorForBalanceWasImproved": "0x88018f8220a21b3917d43ad26912e52e3b8ca361da3d8174be35567b0e24af1d",
+      "swapFeeFactorForBalanceWasNotImproved": "0x548929a4495accb9b6cb141f314517f145ce7ea2b032738583b964b3c67b20c5",
+      "atomicSwapFeeFactor": "0x21e2089d1f40e0a0778c1fe9629870e40fd58fdeeca822dde9b9354502d6fbdf",
       "swapImpactFactorPositive": "0xd4a7c4f352139efdc20b2198b165d123a241d6de0e2dd735b8acb612c061d0e2",
       "swapImpactFactorNegative": "0x7f18362928b7b6e3cfe488252656020e312b67e2ce13853c49295f2c527cb640",
       "swapImpactExponentFactor": "0x545b4c56631b0395a4578efc12493a09fa5d60f69389a8fe615faffa96085a57",
@@ -4482,19 +6530,25 @@
       "maxFundingFactorPerSecond": "0x2f8ed037f4b86f410d55251a6e584e5118efd5645d4865848bc87ed7bdbaede5",
       "maxPnlFactorForTradersLong": "0x76b2fe888bb64d0008c3995d3a6e048f9a303bfae1767930b7fd0eea879ac4da",
       "maxPnlFactorForTradersShort": "0x923022b22940da2aa68b4cb6005d691ba6233e080c3623e941e43f2c430955ee",
-      "positionFeeFactorForPositiveImpact": "0x05831240f177dd0955fadc960829380bf92e1c712f1859a742e5ea2ad4d4c05b",
-      "positionFeeFactorForNegativeImpact": "0x69767d4f85a4b4005871a2809886deaf3f8b09d3276f87cb1791b2b54e520e3d",
+      "positionFeeFactorForBalanceWasImproved": "0x05831240f177dd0955fadc960829380bf92e1c712f1859a742e5ea2ad4d4c05b",
+      "positionFeeFactorForBalanceWasNotImproved": "0x69767d4f85a4b4005871a2809886deaf3f8b09d3276f87cb1791b2b54e520e3d",
       "positionImpactFactorPositive": "0x47b7d1855a247fd82c8eecf0d326e5ae988891305f3a710e6c4561d05baf35d9",
       "positionImpactFactorNegative": "0xc5c1a6f5484e0f94cc872be2da2b7cf82d5be7c99fd12ef686741b633eeae6db",
       "maxPositionImpactFactorPositive": "0xbb9a2a0e8df90d35b1ecbc9a6db7bd441a601352dbcd99cdcbea0056619d0f0b",
       "maxPositionImpactFactorNegative": "0xc6a7c94f56163dbe9158b0b91e27abaf66020e9938d9f8d0bf0daff073b208ec",
       "maxPositionImpactFactorForLiquidations": "0x56b55f2d38345ee5f7f194546671a92848327ddc4541fe1da6d8128892c85820",
+      "maxLendableImpactFactor": "0x11517d9f021a799d56cc05ffe023b8af3fa22e0179b9afc2ede623c1df2bcc0e",
+      "maxLendableImpactFactorForWithdrawals": "0xc3525088ea56688cdc3f32e3a992678fef8f0a73f5c1a94cbf812c49abf8694b",
+      "maxLendableImpactUsd": "0x26e49505583b0c4d0a766368396063d2fc26383e2ca88093f3547b043fdf6609",
+      "lentPositionImpactPoolAmount": "0x826b081eac25c9e00c2ec3d3d4da2f60365eb135db2d40ec280eea606945ded5",
       "minCollateralFactor": "0x33951e7ffe03288c836a45ddfaf69495b239d3c884d18c273d65d3293fd82492",
+      "minCollateralFactorForLiquidation": "0xb8b85be580514372ca4219fe34e89d7d0ff5cff5390ed948981ac4b39e138bdd",
       "minCollateralFactorForOpenInterestLong": "0xe7dd7bf273ece58779bb00ae9a2e4ab2d1f6e2f112ee752f0a84ba30faea843c",
       "minCollateralFactorForOpenInterestShort": "0x43b427a16d943f601dd6b7698573380c2a7a77ae99d8ef7cddfa8abdad16790f",
       "positionImpactExponentFactor": "0x77063961ee3e498fb05ab39858f824d05c58816f9e207fe4bf16657af84815e0",
-      "swapFeeFactorForPositiveImpact": "0x632b360e31d6b7c0caf0657bc4b336b0a87afd7750cfcc4f10d835b6874ccc13",
-      "swapFeeFactorForNegativeImpact": "0x56e3a25432533027ea1aea296261935fb42abbf8d7511bf774f09b39b1b6af92",
+      "swapFeeFactorForBalanceWasImproved": "0x632b360e31d6b7c0caf0657bc4b336b0a87afd7750cfcc4f10d835b6874ccc13",
+      "swapFeeFactorForBalanceWasNotImproved": "0x56e3a25432533027ea1aea296261935fb42abbf8d7511bf774f09b39b1b6af92",
+      "atomicSwapFeeFactor": "0x4d154679eb20c8c9e3bc42655beb1e043cb33b0daf24b875b462ca85f3277609",
       "swapImpactFactorPositive": "0x2564b478c28569a694e8e1fb47b526f33680c4f7655cc4899f1db2f21620bf68",
       "swapImpactFactorNegative": "0xa57b6e86d1bd0290122b20c59ffec9cccc1f57d12b491a54bb852dcdaecc99ed",
       "swapImpactExponentFactor": "0xf0bc83626090efa1a26c684a05571eeb18eedd79b19922960cd956cb993c328c",
@@ -4532,19 +6586,25 @@
       "maxFundingFactorPerSecond": "0xee840dbdd37dbab6e21bd9dcdbcfbfe5284ae1a501fdabc50ce4150a97dd5770",
       "maxPnlFactorForTradersLong": "0x5e6bd97d8b67a79878fb401aa439f382c2ce00faa792ff3bda9997bdf9f49b83",
       "maxPnlFactorForTradersShort": "0xff4d30a24922db985d3abe365f9ffe5089d4bf1e0a0e28281658864067e11c9c",
-      "positionFeeFactorForPositiveImpact": "0x003f9bfe07251be94e44da647dfc5ac14b546d29c05120ec71d8b78bfa305bb4",
-      "positionFeeFactorForNegativeImpact": "0x7cb977b054e40ab743916d35fcc4f033211b0cdb90e910e4d092f141fc80d168",
+      "positionFeeFactorForBalanceWasImproved": "0x003f9bfe07251be94e44da647dfc5ac14b546d29c05120ec71d8b78bfa305bb4",
+      "positionFeeFactorForBalanceWasNotImproved": "0x7cb977b054e40ab743916d35fcc4f033211b0cdb90e910e4d092f141fc80d168",
       "positionImpactFactorPositive": "0x0278a85160a96126d4130fd831ff4c5a9a5836e4fe2d3d568929efb9f3d40d32",
       "positionImpactFactorNegative": "0x529d29bf23dcde0de61a3835c8b66c977a5e2bf880979c2865b6ea725424e99a",
       "maxPositionImpactFactorPositive": "0x483000e66191fc8c744699dddee741439f87f05f61b1b3b300355642fde81ed3",
       "maxPositionImpactFactorNegative": "0xd86f1bc409f50d72733d15fd7c61943af6eab714ee4299f2c00269bdf58debd4",
       "maxPositionImpactFactorForLiquidations": "0x08d87760292cca5a5f69a8b95583423ad1be6acc521c68f8b152ccd1283ffdd1",
+      "maxLendableImpactFactor": "0xf86cc4e80ed83486a203d9ff30f38623d0ff5306e16750251f5da994f3edaf6a",
+      "maxLendableImpactFactorForWithdrawals": "0xd371f71f87885ebd4068cf3bd59048947f6fcf6722997d0b7cf4a9dfae5abea7",
+      "maxLendableImpactUsd": "0x6aaf08ea12a86b4684eb7a367795aa8ef1a12c8ed55801045e5614108c512e6d",
+      "lentPositionImpactPoolAmount": "0x7fb815659dc4e7e09f0fecefae2f2c327f47ba2fdc04bcf45f5dd8c0aad2fac4",
       "minCollateralFactor": "0x9486c729d2726d090319334bf0c997eb6d988e6503abfc033835f3d21e5369da",
+      "minCollateralFactorForLiquidation": "0x62d319d61a973cf3d78242c86aaff68636bcfb93ee41be3b9060305db4ea1129",
       "minCollateralFactorForOpenInterestLong": "0xd7fbf50ca354ff2b3f6828cd7e94d4ed7aa174e32264de0c0aabd07a70d52335",
       "minCollateralFactorForOpenInterestShort": "0x895bbd377e9a108c1b204b937d4a844252362e5be220248efe30bc9b8935381c",
       "positionImpactExponentFactor": "0x28d3ce9203477c09d7c98c67792a73495a0073c0d280ff8ec79e13fe5054e79e",
-      "swapFeeFactorForPositiveImpact": "0x52e150ad8d5dc548a6fb24c385f9a05225f9bd42eafa9af93b25572a445156b1",
-      "swapFeeFactorForNegativeImpact": "0xb4c438e9e70648650f3498d02748bb64d17e2b4f7231db82ff4649ad5289e8f2",
+      "swapFeeFactorForBalanceWasImproved": "0x52e150ad8d5dc548a6fb24c385f9a05225f9bd42eafa9af93b25572a445156b1",
+      "swapFeeFactorForBalanceWasNotImproved": "0xb4c438e9e70648650f3498d02748bb64d17e2b4f7231db82ff4649ad5289e8f2",
+      "atomicSwapFeeFactor": "0x8474deeea21e6229bd4dfae50c5540804ed3a90a2dc43c65d48a15d6bab32d3c",
       "swapImpactFactorPositive": "0x7ff382731e8dfa0db35f01ee8463833b919a2b6b67c270a7a120b70271e46f39",
       "swapImpactFactorNegative": "0x32a66fa15048d75d0970f64a82100bf289c0de735a0e68eb6d26d2f4732a4013",
       "swapImpactExponentFactor": "0x9baffdf906867bf9114fac9e614d47056e935ef5cbe673eded7571c8b58825bd",
@@ -4582,19 +6642,25 @@
       "maxFundingFactorPerSecond": "0xf5611db4775347e39747ed1c456b96e740dbcba6d01ce0979b9cfc4b5b80780d",
       "maxPnlFactorForTradersLong": "0xf80fbd5a69a030c28a382e7651f4fb41c03f68d90aa1de4cacba5b2859b41682",
       "maxPnlFactorForTradersShort": "0x270f5d9379748c17627fe9488d62cc5da2408ec415db81d38decac01627f4464",
-      "positionFeeFactorForPositiveImpact": "0x570d2910c810c94dfa7f44eccaa32dca9b9f8171f3cf3c503b5da5918d780611",
-      "positionFeeFactorForNegativeImpact": "0xf94d71fba5341183b697cdf3d1d488cebb016b48961b01f37bd045a5fadfe955",
+      "positionFeeFactorForBalanceWasImproved": "0x570d2910c810c94dfa7f44eccaa32dca9b9f8171f3cf3c503b5da5918d780611",
+      "positionFeeFactorForBalanceWasNotImproved": "0xf94d71fba5341183b697cdf3d1d488cebb016b48961b01f37bd045a5fadfe955",
       "positionImpactFactorPositive": "0x9a1ba3f8a56c233e194a6da5424ed1fac6faf15b32579933605ed26debab95ab",
       "positionImpactFactorNegative": "0x2670b9b3cf284a0eced68cce887acbe4ccdb7d12b689a5bbea55e9b035daf01b",
       "maxPositionImpactFactorPositive": "0x41fbf5bebd182b215d84d8a6cfcd739da1f102035358c8e37161c10bb23bb5e9",
       "maxPositionImpactFactorNegative": "0x133b02ce85d0279230305871c5ed18f9a1a995cf1a08c58d84da047224e911b7",
       "maxPositionImpactFactorForLiquidations": "0x4bf31804c08ca6629d17e8f51e28fb15a7ae9748960415407accdd4b886bb1ac",
+      "maxLendableImpactFactor": "0xbc4271dc645cdb7a59c16379ebdd343b6d1ada38f01cecd54e9761ed0d574ef1",
+      "maxLendableImpactFactorForWithdrawals": "0x91b91a16da46e40742b38969282b0297214b8a36f5e60638301643bde203c3a0",
+      "maxLendableImpactUsd": "0xe85cd1244e603122d8d3b0419264586117d4da110d1357e8f0812a3e4f9f90d6",
+      "lentPositionImpactPoolAmount": "0xe3788d964dad2d90bd7275f010f379846528012f5dc7e5fbbb2b9acf46c08c72",
       "minCollateralFactor": "0xa5212835c9f726f03f4cc8e303e120a1f7cada099661ad2c42cc57dd28a7e3c1",
+      "minCollateralFactorForLiquidation": "0x8585b33652b828809ca030664ee0d9ea5e3bf9a37b335e934cb4127331d0ed7b",
       "minCollateralFactorForOpenInterestLong": "0x7d50ef920428f507294cd36c1782f6d973a2fe06024c91df3cde7689c79fed96",
       "minCollateralFactorForOpenInterestShort": "0x11f7e8e55c8b9b9dd122a4b43e86c521b1c348c5f813cc016f22cdfd50f834c3",
       "positionImpactExponentFactor": "0x815c6fefb00b14bbddc0e03e7c0f220de918f46c3dd67b8fd755edeabae8ecc4",
-      "swapFeeFactorForPositiveImpact": "0xd87f563eee35ff644bbcbc81c285b4b9ba3c76774d5a1529bd482c790240b52d",
-      "swapFeeFactorForNegativeImpact": "0x10af337efb0891fdc93cfc3f957b35e6e8b478cd80dc1dfe84fab10aafedc81e",
+      "swapFeeFactorForBalanceWasImproved": "0xd87f563eee35ff644bbcbc81c285b4b9ba3c76774d5a1529bd482c790240b52d",
+      "swapFeeFactorForBalanceWasNotImproved": "0x10af337efb0891fdc93cfc3f957b35e6e8b478cd80dc1dfe84fab10aafedc81e",
+      "atomicSwapFeeFactor": "0x862667862206eb72e1989351e89dcbc22cb14ba73b6b531c6d53ea7f7c8cd932",
       "swapImpactFactorPositive": "0xc0cb03d2db382d5e9290eece3432fd194293e21ef1f83ad1a08567da811114cf",
       "swapImpactFactorNegative": "0xd04dc2dc10cd11ac26ed96f19c2994147a753b9dd0645404de4d4f3ec46342fc",
       "swapImpactExponentFactor": "0x0bb5e3bd16263d02f75dff55677c009d9b8aa9a24a1912ab72536173b2930658",
@@ -4632,19 +6698,25 @@
       "maxFundingFactorPerSecond": "0xb720d8c81a84ac462d6ad8ea0a9ccc2523ff17b5e0c0f15a8aafaf55cd6c53b6",
       "maxPnlFactorForTradersLong": "0x4cf830df61af03df6e23af106054f616cb9a7ce443aba0fbd0e816de8b7d7f37",
       "maxPnlFactorForTradersShort": "0x36314aac4793617375d3c0f447920154a9e0677c0a73deb623acb486bc5971ae",
-      "positionFeeFactorForPositiveImpact": "0x3c6f2ca5835a333de5eeebc176cb9b6f23bd82af006ee38e94d499e3aac81d15",
-      "positionFeeFactorForNegativeImpact": "0xca27165c5c39f5ccd9e46ccb45f6c09e7a534d3a375800993d3ca026f9c97bbc",
+      "positionFeeFactorForBalanceWasImproved": "0x3c6f2ca5835a333de5eeebc176cb9b6f23bd82af006ee38e94d499e3aac81d15",
+      "positionFeeFactorForBalanceWasNotImproved": "0xca27165c5c39f5ccd9e46ccb45f6c09e7a534d3a375800993d3ca026f9c97bbc",
       "positionImpactFactorPositive": "0x81715340e5d4867f20c0e71ba4030c88632d88ebfaf0326c105e9389501597ca",
       "positionImpactFactorNegative": "0xf3642a309bc16d8b2f0543b7719a7814ad020625035d830a111faca0a5cd5d73",
       "maxPositionImpactFactorPositive": "0x810d342c12f39497d4bdaca55af877dbd05f964e4a6d626792683c2bb37ea46f",
       "maxPositionImpactFactorNegative": "0x38aee17eb1d3a3866869b91987c0516326292ccec2a7a87dad70b74fd8ce82ee",
       "maxPositionImpactFactorForLiquidations": "0x1383bc6b5727ae22703084ef3665da3c3000c20a53f6e6ab16dd9c1435f2e30f",
+      "maxLendableImpactFactor": "0x87eb71dea79f9e9147e18c50874b625378b9d2dd15db5a290a1da097820d69eb",
+      "maxLendableImpactFactorForWithdrawals": "0x5aebbf4c3422790268750ed775f292618e011ffbd1919d380104ec446620cd4e",
+      "maxLendableImpactUsd": "0x7735b5def38a0561a96a26df53592dc337b7ed02afa7e6232454b7285bdbc391",
+      "lentPositionImpactPoolAmount": "0x669be26aec44a803a0bf0bc1d8325beb60e5bbfbd3e9e691b71f0dcde116da30",
       "minCollateralFactor": "0xee85c017db292f5a8eb09973adcde4bc15ebfd93d8fed7acc24ab19ebd74b07c",
+      "minCollateralFactorForLiquidation": "0x33b00fb914ce7903aa886f91080c2351c74dab96ad8d7ddffbb6bef6d8d652a6",
       "minCollateralFactorForOpenInterestLong": "0x5ae759fed69d3b0c091d183c77af7e0a17e8e28bf134058733d7e4f6c65a9803",
       "minCollateralFactorForOpenInterestShort": "0x6b3ee35f5d240926128b2cd6d6e06959f849b8be18b92b74cccf3092dc4f17ea",
       "positionImpactExponentFactor": "0xe567e59cfea800eb361efb60841f05c69cb32e748be6262247a2a421f040c9cc",
-      "swapFeeFactorForPositiveImpact": "0x47ffe2b682a8bf31cf63778aad5f0eb07789da2a14cc68b4b2d225150807fbc4",
-      "swapFeeFactorForNegativeImpact": "0xcc012787e83c0b903b1eb1aee64607e237da7ad41657778ff1cfafe6e680b371",
+      "swapFeeFactorForBalanceWasImproved": "0x47ffe2b682a8bf31cf63778aad5f0eb07789da2a14cc68b4b2d225150807fbc4",
+      "swapFeeFactorForBalanceWasNotImproved": "0xcc012787e83c0b903b1eb1aee64607e237da7ad41657778ff1cfafe6e680b371",
+      "atomicSwapFeeFactor": "0x1df5c00e70e1661c59e1d86e3fe88018b64b65e3f65a756a4b5103507ed3d495",
       "swapImpactFactorPositive": "0x46909c5fad97c43653f9d5f3368abd6fbebc393ed3e03cac4b1e929beca08746",
       "swapImpactFactorNegative": "0x09a07f2403de8c394c33d6b5a4546bd1c717e0b5b73b7a4093e0d8de38068017",
       "swapImpactExponentFactor": "0x3523cf94456f655920bded4f975e92a883868ac996de759eadc368f6c7e65cd4",
@@ -4682,19 +6754,25 @@
       "maxFundingFactorPerSecond": "0x6549b6f8d7b08064cb0485409e72f4eb7a42fd9ed8e2fd25cb26ffe0d98dd323",
       "maxPnlFactorForTradersLong": "0xbc279e968e78308cb4557b820b21e00749855574d8379d85706f1306e896f2de",
       "maxPnlFactorForTradersShort": "0x7456fdb6d19e2d4c7d61b6c7293cb3b71b9e8e26eac6d1a6b44f6ab0537e768b",
-      "positionFeeFactorForPositiveImpact": "0xa1835230a8d851762c1c01d2f7e523fdf1f5b85f8f0affb93b0feabbfcdbe56a",
-      "positionFeeFactorForNegativeImpact": "0x4a50364bddba2784ddc1aab575088f8f740d30343b8e0b6eaca6fd68bc6cdbd7",
+      "positionFeeFactorForBalanceWasImproved": "0xa1835230a8d851762c1c01d2f7e523fdf1f5b85f8f0affb93b0feabbfcdbe56a",
+      "positionFeeFactorForBalanceWasNotImproved": "0x4a50364bddba2784ddc1aab575088f8f740d30343b8e0b6eaca6fd68bc6cdbd7",
       "positionImpactFactorPositive": "0x9873a18090b7c56c11578568a8d0b49769743ad165bdff83f1f8aec8241a0736",
       "positionImpactFactorNegative": "0x7160368f4494684e7a4d5086f623cb1cc84b4b05f87c2382e9d5110187041096",
       "maxPositionImpactFactorPositive": "0xae1808bb11b54e6d0fe2b85630feb3c2ded4eb5fc8ac820c5178e8038b90ff71",
       "maxPositionImpactFactorNegative": "0xeaebc7a49d460ddf770f6014464e36e8b242cba8e657fc32a4a68717108b7309",
       "maxPositionImpactFactorForLiquidations": "0x4dbc4b65a887e96a0525c0ed58fe21806d349f7f596ec1d1c66d1020abb11cce",
+      "maxLendableImpactFactor": "0x43f787538d78a2982ef11e17adbd6055fbc1cbe7d7f3321bb713082f2b61add7",
+      "maxLendableImpactFactorForWithdrawals": "0xc2c1928a2bceb51e93a1c8de408430612601e80a44f1f531a216c1f4250bfc01",
+      "maxLendableImpactUsd": "0x81cf9f95385a790d1db64b27d3e85b6e83cf27e8a1efb5e386d329be83f31100",
+      "lentPositionImpactPoolAmount": "0xfaef63d717438bfd78f4e1ad3bc2189c3fef771b7a624d0e229faf3a4bf9061e",
       "minCollateralFactor": "0x0f3ac78bcef32cacef7f434288d1dc395406249bac71ffd1f153ddf1aff1cb18",
+      "minCollateralFactorForLiquidation": "0x6b71547189b8a846f015a1f2343da687dedcadc907ab4ce46d1b5940de3dfc45",
       "minCollateralFactorForOpenInterestLong": "0x45eedbc7142301fe4c59155e6ebd1653a9ff0c9a978099ccb2e9d707967adbca",
       "minCollateralFactorForOpenInterestShort": "0x2903f6e84538e5373d1f54d464ba5df3df4b3588d0d14741fece1716eb35f9a2",
       "positionImpactExponentFactor": "0x8844c8b03bd3eaef0764ca1ba1b1d78473ea2cec2d9e6a21b41b938f1af0bae2",
-      "swapFeeFactorForPositiveImpact": "0x2b6b19422df17ba8c28fced3c7d789005d1a0356b44c1c4c4c0164cc39331e71",
-      "swapFeeFactorForNegativeImpact": "0xbc5189d59edc722196387581523527cb1d98b00ea7da4f20aac7c20e08b72a3b",
+      "swapFeeFactorForBalanceWasImproved": "0x2b6b19422df17ba8c28fced3c7d789005d1a0356b44c1c4c4c0164cc39331e71",
+      "swapFeeFactorForBalanceWasNotImproved": "0xbc5189d59edc722196387581523527cb1d98b00ea7da4f20aac7c20e08b72a3b",
+      "atomicSwapFeeFactor": "0xe173a809ced2500304a23dfa344ca6b3e827719804bd77f8acb525af28d6569c",
       "swapImpactFactorPositive": "0xc37e7182e1a56e126c4733aecc60d53d29e2b3f102dcfca70d3a86ca928e8814",
       "swapImpactFactorNegative": "0xc26f85c9450226223a1d4af07280496abe35a15674106503cf26c2c1b7757ff7",
       "swapImpactExponentFactor": "0xeab458e24e12f3d09444cdcdea113b9f7374871735d166318fc9323552ab2bfc",
@@ -4732,19 +6810,25 @@
       "maxFundingFactorPerSecond": "0xd542499df9e7d24699d8ecc8f75aa401549a3b0ae9e80d5c6fbe14864ce032af",
       "maxPnlFactorForTradersLong": "0x986987a2297981d099e91af2872dbe813e25706c4a933026830723cbd2bf48db",
       "maxPnlFactorForTradersShort": "0x113f7f83548aaff453d477911793de665a501f3a279fc4dba114df9d1a14d422",
-      "positionFeeFactorForPositiveImpact": "0x83a5a35f6638777558e5ce07e52e0ffdb233fbb2be93bd388cad801e523b53ba",
-      "positionFeeFactorForNegativeImpact": "0x592d834e78e74865f3eca09aa13a218982d8f685c5efeb92cb33847c99851438",
+      "positionFeeFactorForBalanceWasImproved": "0x83a5a35f6638777558e5ce07e52e0ffdb233fbb2be93bd388cad801e523b53ba",
+      "positionFeeFactorForBalanceWasNotImproved": "0x592d834e78e74865f3eca09aa13a218982d8f685c5efeb92cb33847c99851438",
       "positionImpactFactorPositive": "0xab8a73b8fe33ad230ba513a905a375d42d0a091419bb26f2652dbef04f62f039",
       "positionImpactFactorNegative": "0x0c08812385bf9ddb26fa10c909560b93bd3b346dcc7bfc0552d34c8bca9e73de",
       "maxPositionImpactFactorPositive": "0xe22c34e3ff7ef7fcb54504b4c66044899d1a384b96d04624c1dc5dabeb6e24a2",
       "maxPositionImpactFactorNegative": "0xdb06d0ebe3729da81037c1999fb1b027ed37550201bd6f4075ff5e2d6f56e550",
       "maxPositionImpactFactorForLiquidations": "0xabce0e14b6bed5cfb566df3ae082320a41e649005e3fc70da278c9f5569ccee9",
+      "maxLendableImpactFactor": "0x645e69af1d93a9c831437acf36d0470c8cee9cc3aa9a8bf7341a8346a5a5fd40",
+      "maxLendableImpactFactorForWithdrawals": "0xec453c03edf0091beb32aa8f62f9f626ba440ea571d6ff6429f8895d2cd90f2d",
+      "maxLendableImpactUsd": "0x0354f66f3a07b5322458c2d5a07f228c988a01e772550a43b547be2f110dfbde",
+      "lentPositionImpactPoolAmount": "0xdfd6ce9b1aa654201b8b2de147da83c9e17e3523ce8aea92feff2bebb671d7dc",
       "minCollateralFactor": "0xd0e0e53e9fcc4b8aef885995a8c93e42395bc1bde27f72958c9ba5ceaa17b797",
+      "minCollateralFactorForLiquidation": "0x1b75189827254a93f7a53377e63f17e1b8e28a9e760227a07cab05b17a8c6e8c",
       "minCollateralFactorForOpenInterestLong": "0x29db49c2d35032fbaa6998ba219c6b02284f74bfd0acc163ee051df95ed68ca3",
       "minCollateralFactorForOpenInterestShort": "0xa40cad44d05c973096a2efad341a66060c01fff6f46ea68b91b0b2bf3fba6c08",
       "positionImpactExponentFactor": "0x756f45fc0ceffe9e5d95fa382724d0f2e89ef58b1420ec60110167e98b8eab13",
-      "swapFeeFactorForPositiveImpact": "0x65de51630b94a759ff7b7fd83e2592f29f091279d19914ccdf27614d77d6bdc4",
-      "swapFeeFactorForNegativeImpact": "0xee0edaec66c781a5fbc4bc1a3309d734eb0f66eea1a501f5db8b418e4fcddb53",
+      "swapFeeFactorForBalanceWasImproved": "0x65de51630b94a759ff7b7fd83e2592f29f091279d19914ccdf27614d77d6bdc4",
+      "swapFeeFactorForBalanceWasNotImproved": "0xee0edaec66c781a5fbc4bc1a3309d734eb0f66eea1a501f5db8b418e4fcddb53",
+      "atomicSwapFeeFactor": "0x5a0d29797f44932d02b08bc879eacb1bcb68e88d6abb2ad4ce3ed486b716738b",
       "swapImpactFactorPositive": "0x84849cdedb39593852cf43252cd82e46a876f305e4ce1d974ee08fc8ec59d9f7",
       "swapImpactFactorNegative": "0x09ecd5127f93d7213f6c1fcaf8804ee66808221cf2bf57983e1953fc99bcf9f3",
       "swapImpactExponentFactor": "0x2d0e9c34fb6aba09c0d97799dcb19419b140516c7a10e3c58b4049a74c67e293",
@@ -4782,19 +6866,25 @@
       "maxFundingFactorPerSecond": "0x55d695443c4b50290b2c35ab4ae3670a19023d27d4c7588e6838c3b254970f70",
       "maxPnlFactorForTradersLong": "0xa79de625f455941562c64463d65e8ccde24b967c7891abcf10a84ca42f8768e2",
       "maxPnlFactorForTradersShort": "0x6411fd75d22e56aa0f990c53a99acaa487bf7a7260c253aecda50eb063d3cc96",
-      "positionFeeFactorForPositiveImpact": "0x480caa020e0fe99251b3c9ab63ec9c6300cc5f1bdfbcc7893ea0b68d47aba2ac",
-      "positionFeeFactorForNegativeImpact": "0xadc6faa886ee5047e61292441d823e4e0473167e7d00c08187cd3fff2d470328",
+      "positionFeeFactorForBalanceWasImproved": "0x480caa020e0fe99251b3c9ab63ec9c6300cc5f1bdfbcc7893ea0b68d47aba2ac",
+      "positionFeeFactorForBalanceWasNotImproved": "0xadc6faa886ee5047e61292441d823e4e0473167e7d00c08187cd3fff2d470328",
       "positionImpactFactorPositive": "0xd0558f405ea9df084ccb4faa357f969f7ccc3f1a5681fef8022ad1fe8f331079",
       "positionImpactFactorNegative": "0xbd84cae6ed3696ea71d13a21fcc8382099cd628f1cb5cdf2590b86018f9bd8cf",
       "maxPositionImpactFactorPositive": "0x0555a94ebd0aca297889436c37ca360b21d9a1867d3413495097a4271eca412a",
       "maxPositionImpactFactorNegative": "0xe2865315d05144575e7ba076bda6b3e6f1d6a62cfc85b71e54d9656b6806510a",
       "maxPositionImpactFactorForLiquidations": "0x8b55985ffe6a807094924998522579cd88bb81f293c1c18cc9ebdd31c0f673c2",
+      "maxLendableImpactFactor": "0xe5721d6e94d288c9654430be4987fa3d783dc1430dd883024130228daf783939",
+      "maxLendableImpactFactorForWithdrawals": "0x967a68e49df22c2a02894afba3eca0e6453e773fa086acf7daaea0df5432eb45",
+      "maxLendableImpactUsd": "0x3f2eed2086112d3b3b1f2a58fa5372070a78a0875ffea86305c4c441763edd92",
+      "lentPositionImpactPoolAmount": "0x42380fd5cf401a3161284b137691c1c76ee02238b15bfb0e8d0eb9bae653310a",
       "minCollateralFactor": "0x40dde6825fead3925144ef7d7985c7eabc5f1c3989c554c16f0a6750ce8d661b",
+      "minCollateralFactorForLiquidation": "0x86ec7dea0767afca2e51da7c95db51654f3f0663312019e5e6cc4b0d1ba41843",
       "minCollateralFactorForOpenInterestLong": "0x8f3f572e97c9d9c670333b644f13a2d0f6e539e9c061ee0a857cd9792672d22e",
       "minCollateralFactorForOpenInterestShort": "0x34f3aabf9a0899301758ec60b458136eedccf8190f866a24fb5752b22f439232",
       "positionImpactExponentFactor": "0xb2ce75652d03556e0bc3788493523ca7fdebc934c6e54c6c632e181236ffddd9",
-      "swapFeeFactorForPositiveImpact": "0x0589c40a90c42a9ebfc1efeb4b92aade95b9b797d8aa1d5a3157bf122b7d4c51",
-      "swapFeeFactorForNegativeImpact": "0x1a598b463e1879679db300d3d2984300793cbf7707c66a39bbdd2d35d13f732a",
+      "swapFeeFactorForBalanceWasImproved": "0x0589c40a90c42a9ebfc1efeb4b92aade95b9b797d8aa1d5a3157bf122b7d4c51",
+      "swapFeeFactorForBalanceWasNotImproved": "0x1a598b463e1879679db300d3d2984300793cbf7707c66a39bbdd2d35d13f732a",
+      "atomicSwapFeeFactor": "0xe41d968c3b6e3f6edf6a01941130301b746bab7671905eb80ba9d50d65bb3aaf",
       "swapImpactFactorPositive": "0xd1e65efb757541f80edfff9551b4826043c8e145abe10ae3ef3541fb538f07d1",
       "swapImpactFactorNegative": "0x7cf01dde2b8fa10b9187d30fd71c411dcdeec784c219d8650622215ee0595300",
       "swapImpactExponentFactor": "0xd44bd1c8059198d34bfc8874c1651224c654429e4ca93c43743a04c165dec81c",
@@ -4832,19 +6922,25 @@
       "maxFundingFactorPerSecond": "0x89da6ffa766e2bb3ff8a903aeb5e5317b11be4f883d2cb321a1d86d04dc167f2",
       "maxPnlFactorForTradersLong": "0xcfc8c3f8c13b2c4398d6120c557c104931e11c73a21992df116452c5d2523914",
       "maxPnlFactorForTradersShort": "0x66f86df6730745dd50e417a44bac9675a815fd2b0cff011e7d4e49d0f8f61f8e",
-      "positionFeeFactorForPositiveImpact": "0x09ef3e68667ac1932aa3da09c082f3521ca03280960d931ab17c5fc2b610bd94",
-      "positionFeeFactorForNegativeImpact": "0x8d2011dd8f0c59f59b6d50bfa9ee5e8128c82d9b0906177241687ed9b76ff0e0",
+      "positionFeeFactorForBalanceWasImproved": "0x09ef3e68667ac1932aa3da09c082f3521ca03280960d931ab17c5fc2b610bd94",
+      "positionFeeFactorForBalanceWasNotImproved": "0x8d2011dd8f0c59f59b6d50bfa9ee5e8128c82d9b0906177241687ed9b76ff0e0",
       "positionImpactFactorPositive": "0xa762537645af98f083f258eea26bb39c97b5d6e2b7eeb7d008838577587a2416",
       "positionImpactFactorNegative": "0x7af4efee5f0f9f89b838201e77ea1a99c065a8c3aeb2857c9dd06453fd16118c",
       "maxPositionImpactFactorPositive": "0xc46b18667cb5e79692a544765cbf3b008b009c084a840f0716f07e49ffd33a82",
       "maxPositionImpactFactorNegative": "0xb374e022a3912b6738b5afb8398914723c91acf6fbd33f1375c0a62d1def494c",
       "maxPositionImpactFactorForLiquidations": "0x04560594fff18fe74dd94ec976fe48da33f3ccd2fb5522b10afba7ba587d69e3",
+      "maxLendableImpactFactor": "0x97d1f7d41c638437b98777c03b3388b74eb4980c40c7dca97fba9217ae29c6ed",
+      "maxLendableImpactFactorForWithdrawals": "0xc99f2609161c72997d9c62c49fcf6db65bb39723458bbce2528451f563683e61",
+      "maxLendableImpactUsd": "0x1ceab2cb317724a5fc0354768c165e6dd92822dd5c5390e9d819900036be174d",
+      "lentPositionImpactPoolAmount": "0x030bf10049a914dbbe618dce6f66bfa15642ffcb560c9e2a1c7d49658bd90832",
       "minCollateralFactor": "0xceb66e48992ccf002db99c948b87853fe88fb25d3d2f5639955fda193c33ca22",
+      "minCollateralFactorForLiquidation": "0xc181dcf243c0f2329ea8f867834c56e7922d6087c6f367ed5c51e860bb1751a2",
       "minCollateralFactorForOpenInterestLong": "0x583df5e6f1edfb745d316e7bcd94e72ca9b5ca746577c020be7c18dd7dd4fe06",
       "minCollateralFactorForOpenInterestShort": "0x36351baa910c7a93b9275819cd9a2692a2cd3a2e6ba054c08ee6b21a35de4d33",
       "positionImpactExponentFactor": "0x7ce20313f86d1399be6c8e5a879b0f8444aadf143db8d96c0acb06d082131e5c",
-      "swapFeeFactorForPositiveImpact": "0xa23ea26f349b7feb83ddc8a2a9fecd42486e44e6fc12a1801d13effd3586b489",
-      "swapFeeFactorForNegativeImpact": "0x6426e51a54739e518248dcb47aa6a5ef9663cd0c4882d6e49f2c4a9e4e13fac1",
+      "swapFeeFactorForBalanceWasImproved": "0xa23ea26f349b7feb83ddc8a2a9fecd42486e44e6fc12a1801d13effd3586b489",
+      "swapFeeFactorForBalanceWasNotImproved": "0x6426e51a54739e518248dcb47aa6a5ef9663cd0c4882d6e49f2c4a9e4e13fac1",
+      "atomicSwapFeeFactor": "0x37af8cd2427637879560e4b804999bbc1df9abd6e4d2550024f191a228196de3",
       "swapImpactFactorPositive": "0xccdda93d693c2b04ac36cdd1fcb740da6b9a9b761375c4315e1ce1b8474ce507",
       "swapImpactFactorNegative": "0xa2277bc26726f7bfa667b90d37019e338cd90877358ef57a93296d388daf3b67",
       "swapImpactExponentFactor": "0x97522d4a4b0412dd7c94149fd9517707b9a13df61108a0fec3f05f9b7c31e9b7",
@@ -4882,19 +6978,25 @@
       "maxFundingFactorPerSecond": "0x80005808724cc96e2a097ee4c2a7f82e47d1a320388b4dc63476035d8973d9d6",
       "maxPnlFactorForTradersLong": "0x8f32f5ad7e284bdbfeeeb70ebe1ef991953f55095e79351d35ca3d9497976253",
       "maxPnlFactorForTradersShort": "0x274a6b8ec92a0bc3ba50a90e9f19dc2252961f33485ade4ce0f822cd5bc1b0cb",
-      "positionFeeFactorForPositiveImpact": "0x81bd544cd8ceb46ea99b4bd10d6e56ed02222dcbed27f28ad372cbdc124a1cf9",
-      "positionFeeFactorForNegativeImpact": "0x2d8a55901ecd0092c6089b9d517ed1667d3e1847c1694ed8f29c7ace94df16a8",
+      "positionFeeFactorForBalanceWasImproved": "0x81bd544cd8ceb46ea99b4bd10d6e56ed02222dcbed27f28ad372cbdc124a1cf9",
+      "positionFeeFactorForBalanceWasNotImproved": "0x2d8a55901ecd0092c6089b9d517ed1667d3e1847c1694ed8f29c7ace94df16a8",
       "positionImpactFactorPositive": "0x5a05266478f4928dd9cde3872bd527fa16309411dffc0471ebbe70c025c0aa4d",
       "positionImpactFactorNegative": "0xe1eae2c4d281cdee0d161a428cda3065b406412fd953c1f82db82b2691a9a9d2",
       "maxPositionImpactFactorPositive": "0xf99eaaaab16734840b8d4300ca590da487556dcc8db34a9268d847536510b97f",
       "maxPositionImpactFactorNegative": "0x6535c04d5a63e538f6f562f433d7c993b32f3bcfe19cfc4d3da90a725fdf88ff",
       "maxPositionImpactFactorForLiquidations": "0xbc6a63fc5880d67cb592c33676d51dd81ea8b5f48ffc5113afc459ae7186280d",
+      "maxLendableImpactFactor": "0x9d986995d89682b9dcf24e1ae5b7e017a9d4d97cc808212fd610df60e5dc3a33",
+      "maxLendableImpactFactorForWithdrawals": "0xead7c06076b339077d22cf69bfcc2e275509ab440c3ef83eeb4384862155a903",
+      "maxLendableImpactUsd": "0x3500e247bbf32363b84ac11c7d6bf7ebce25e5fda330143d45e10188c796a34d",
+      "lentPositionImpactPoolAmount": "0x968aab8cc872fc87527ad5a54e806bcf3b29b92aec3c89ad595940bfbe10992b",
       "minCollateralFactor": "0xa46adf9b6edb48c1ef2b4bbb2aca842015364a5f80ef06c351663fbf426c409f",
+      "minCollateralFactorForLiquidation": "0xf72fdbe7a9a4fa1a18392a24aac135b2854ad6702857dcb7a02b0396689742df",
       "minCollateralFactorForOpenInterestLong": "0x818e5181980953fa609b761f0ae96c7ca154f7f0646efb32703b8b00f9066681",
       "minCollateralFactorForOpenInterestShort": "0x5755b8f70ab34aa48a6f09e98b3f0ea7d53f481a51bf3c43ea8eb29e944c99c8",
       "positionImpactExponentFactor": "0x3b971039415093ccc226058fec1bbf78b3120fcce1cc233615f3e18b5360ebf3",
-      "swapFeeFactorForPositiveImpact": "0xb843072f0f5a7464d8d1f7396c97cb7da8af935cae8e33176c8d5f175cc9a55c",
-      "swapFeeFactorForNegativeImpact": "0xbdb97358626fd42e2914f666f839a6f60265e9ec51dccd6175f3c83aa463977d",
+      "swapFeeFactorForBalanceWasImproved": "0xb843072f0f5a7464d8d1f7396c97cb7da8af935cae8e33176c8d5f175cc9a55c",
+      "swapFeeFactorForBalanceWasNotImproved": "0xbdb97358626fd42e2914f666f839a6f60265e9ec51dccd6175f3c83aa463977d",
+      "atomicSwapFeeFactor": "0x9532ae7cbc6108a2afb6bc4567e4a7a60decca5cc940dde150db06998e8af445",
       "swapImpactFactorPositive": "0x901b3d05b703f3c40f99b34c4ff2cba75269582be15a402353f187ed49ff5165",
       "swapImpactFactorNegative": "0xa0e259f65f79fca5bec4d5341eaf9470dba0fc4d48ba1defd29a7572fd125ebc",
       "swapImpactExponentFactor": "0xd14dd7875505bc9756a4e613d29ed6582f111ab4bcdfff9cf4753558a94802c1",
@@ -4932,19 +7034,25 @@
       "maxFundingFactorPerSecond": "0x2f9dd902a53addb43038e9d24efe34c486a2911e7f672bb79365aa927e257c78",
       "maxPnlFactorForTradersLong": "0x47c6b942963abe1930bcb6cea0d32323d424e1b4981f35c33c5bd81acd296b8c",
       "maxPnlFactorForTradersShort": "0x0790c0bd1a893408eabd1ea57630663590c62ec1d13a4858c77460a7fafd2ec5",
-      "positionFeeFactorForPositiveImpact": "0x633594b09c0e8b31be3792e4ff37f2252f8cc94b768efee52d747044f9a55dfb",
-      "positionFeeFactorForNegativeImpact": "0x2bcf6671743d299f81ef6291530ecce27d3429a6fb61494a9ca8944a5b34c582",
+      "positionFeeFactorForBalanceWasImproved": "0x633594b09c0e8b31be3792e4ff37f2252f8cc94b768efee52d747044f9a55dfb",
+      "positionFeeFactorForBalanceWasNotImproved": "0x2bcf6671743d299f81ef6291530ecce27d3429a6fb61494a9ca8944a5b34c582",
       "positionImpactFactorPositive": "0x221221e7b50c289b02ea5905c1f2379370338250693b13b8fd1087ac9e901b5b",
       "positionImpactFactorNegative": "0x0954d88366713719281605b30c385e1b10b87ca6ef69733491e7e22dc4cea296",
       "maxPositionImpactFactorPositive": "0x53277309fab06bd5cf4cd915cecab1990fbd08f2cfcdbbe96de2eaca6d3795d6",
       "maxPositionImpactFactorNegative": "0x8d19baf07e1b3da292b4f4b001bce49c60d0372a4fc49f934c5ca3c9414dbb24",
       "maxPositionImpactFactorForLiquidations": "0x041392716702b20c5a401b7fb483b82cce6c4f4b59876f8f36ffb3c32aa1db80",
+      "maxLendableImpactFactor": "0x2af1c47f779a27a18253d53f6443de1cdffc94a6192e21b639da78604ad9f505",
+      "maxLendableImpactFactorForWithdrawals": "0xb691e2d75e4a37455e4f38a7b8b9b4fde166307d87ba85df806b12ffa2bdc8b7",
+      "maxLendableImpactUsd": "0xf349ba50793ac7f79b1850b03ec2cc01301d6e631b630d11cebbf9154b66ea6f",
+      "lentPositionImpactPoolAmount": "0xdc5bff4aaf558f8e46fe9ee42999c64cecc23edd86204ad1a3b8962c4ae25569",
       "minCollateralFactor": "0x660d36995d7842d65142957335204b2f5a47ee4ef14e45e808cd2a558ee1d64f",
+      "minCollateralFactorForLiquidation": "0x49ae2627469cbefb68666adbbbeb744cf29a4400c48e0e21c31cc84e0f34670e",
       "minCollateralFactorForOpenInterestLong": "0x27e803ec18d5fa51715be719542a289f7423ac9ba9b20f576973d66b2551bf5d",
       "minCollateralFactorForOpenInterestShort": "0x5258e3c070aaebb888fd398d917ecf80832a6656f40d50a745b124f8ccb7e254",
       "positionImpactExponentFactor": "0xc51909a330c2401736876b71a8cfd7c96f42890319cdb371a3b9dec9ecd409ce",
-      "swapFeeFactorForPositiveImpact": "0x9102f6ad4161a08f0849b3c43c223e364bd4aff8f481d198a4eebeae069553f7",
-      "swapFeeFactorForNegativeImpact": "0x67ecf17e7395492331fb10f81e89dea078a77a9e46f2fceda54099cc9797a959",
+      "swapFeeFactorForBalanceWasImproved": "0x9102f6ad4161a08f0849b3c43c223e364bd4aff8f481d198a4eebeae069553f7",
+      "swapFeeFactorForBalanceWasNotImproved": "0x67ecf17e7395492331fb10f81e89dea078a77a9e46f2fceda54099cc9797a959",
+      "atomicSwapFeeFactor": "0xe16a19c405ac3aff97f370f32424f0cd347870c1e04c55a2359c3be144d17f7a",
       "swapImpactFactorPositive": "0x1e345ec4f6a863e7ebe4e075da4fcf31672a9182dcb21cd591068f690f2262fc",
       "swapImpactFactorNegative": "0x4a493f0dc59ec102f37040fb63e5125680bdd15a0fcb2ff76badbcdf3db3fa86",
       "swapImpactExponentFactor": "0x9e82099a8967147ca78b2ea77f8668503b02fd34e8d52886e684f211da201bba",
@@ -4982,19 +7090,25 @@
       "maxFundingFactorPerSecond": "0x6cd221f1fe702a065c3d5d488eb64b15023dbd5ead70c58a0e8b1a7558e5b16e",
       "maxPnlFactorForTradersLong": "0x164ea8b6a97c0ffc267213ba294b3058ee4387ecc19b87e31ffd5700554ee028",
       "maxPnlFactorForTradersShort": "0xee0486fca5c436f99d4772832e3457cbfd2afa0eb06e079f5df49b1c68a287f3",
-      "positionFeeFactorForPositiveImpact": "0x645a45b8c2066831a700ed199d13dc8dea613b7154569b827cd1c384062ee908",
-      "positionFeeFactorForNegativeImpact": "0x1e7a0738deae0fdb87f558226e5bbafed021fc35d1e8a3cc8bb5f41227fa5fb5",
+      "positionFeeFactorForBalanceWasImproved": "0x645a45b8c2066831a700ed199d13dc8dea613b7154569b827cd1c384062ee908",
+      "positionFeeFactorForBalanceWasNotImproved": "0x1e7a0738deae0fdb87f558226e5bbafed021fc35d1e8a3cc8bb5f41227fa5fb5",
       "positionImpactFactorPositive": "0x4ab1412183e3cdf2bc0183be8ce586927a7514a7c59547650caaec2deac8a23e",
       "positionImpactFactorNegative": "0x7dd1eeecae673aa27159de19e7f7dc5dad8733c52b5f2d223e2baefde25790fc",
       "maxPositionImpactFactorPositive": "0x0c431c9f06de832473be0ce2b10621da8568de58d41a129cf8dee1cad68e2d31",
       "maxPositionImpactFactorNegative": "0x70801029438f48a6f9e93c6c346b4662b7237c7f8956c67f6ed0d6f078a36766",
       "maxPositionImpactFactorForLiquidations": "0xf3f9f58a52a4fc1c974c701e5465340061095f605b37e589d1762386d409d1e6",
+      "maxLendableImpactFactor": "0x6c1d98f22fff91d60a00b7c05b1b230a046b90a706418c2316a6c3d04e1d1617",
+      "maxLendableImpactFactorForWithdrawals": "0xa744777827f361636e1ad96588f20e344c7763d253a17cf9b8c5f3cb0eaf3f03",
+      "maxLendableImpactUsd": "0x9946ea3fbd797b9c1613a06aec4c30f015cdb56fa0ec67235106eee841cadcf2",
+      "lentPositionImpactPoolAmount": "0x88e6f8f4a655e6486c463837cd2547e678b291002d988d8e41cad234301d4f35",
       "minCollateralFactor": "0x47c761a326bc43721df008dbd681a56a95f967c8782f6c5627c44b0ee1e28d09",
+      "minCollateralFactorForLiquidation": "0x5d8b1de57e1489bee6417db642bdc78295466e0b17ac7cf4f3a4b6cbaf500513",
       "minCollateralFactorForOpenInterestLong": "0x8e08f3f7be11c7cf1e417bad78b67816cc018466d09dbc178cbf14e775ec84fb",
       "minCollateralFactorForOpenInterestShort": "0xbdceb26bf2f98e5cc12acaa3f849b8d4b55bdda9afeb7ccf0290238518f1db47",
       "positionImpactExponentFactor": "0xff24652bb0828da1596a0f12cb00abede91225f771ad892955193da803cbdf7a",
-      "swapFeeFactorForPositiveImpact": "0x31e3930b9996b14fe6f38568e44639ccc50e56787240e19e98310ddcd4a92fda",
-      "swapFeeFactorForNegativeImpact": "0x79ffe210749a415402ab9be45d30efda2ecb18e6812b20adb226da48d4ca5f02",
+      "swapFeeFactorForBalanceWasImproved": "0x31e3930b9996b14fe6f38568e44639ccc50e56787240e19e98310ddcd4a92fda",
+      "swapFeeFactorForBalanceWasNotImproved": "0x79ffe210749a415402ab9be45d30efda2ecb18e6812b20adb226da48d4ca5f02",
+      "atomicSwapFeeFactor": "0x032774c61cbf297fedbbf78bb87559d207fee070f6f33e2d7f5704a2821e886e",
       "swapImpactFactorPositive": "0x2cab7d169dfb0076ae18bbbcc61065aee049442b6a4625d90829f74f1d431f17",
       "swapImpactFactorNegative": "0xf62851c1a6f64e7d365044132259a31dd64a680ebb18db650df5aafbff986aa3",
       "swapImpactExponentFactor": "0x386e3e54e4848c60015711213f37290b3dcc77280b39dfb0a922b780b1126763",
@@ -5032,19 +7146,25 @@
       "maxFundingFactorPerSecond": "0x5f65898b6df057aaff1a80e1fe7b4459c8bdbb538e96f4952cba9f5c29c547dd",
       "maxPnlFactorForTradersLong": "0xc5618ce541d1aeea5346d6164351ee7f983bbcce8eecc05f8bfba0c314e57cfa",
       "maxPnlFactorForTradersShort": "0x9750d780280359bf0a2069730d38874a1fd839050a59255fa453aa8515935bf4",
-      "positionFeeFactorForPositiveImpact": "0xb6245117418c14e0b4c75a17449ff7390ff57f8a6b0afef0084679dfac296fb5",
-      "positionFeeFactorForNegativeImpact": "0x4a7b08d27f8e7a95ea2a14564163d6f42a663ea247c9f297a278fd26b35514c8",
+      "positionFeeFactorForBalanceWasImproved": "0xb6245117418c14e0b4c75a17449ff7390ff57f8a6b0afef0084679dfac296fb5",
+      "positionFeeFactorForBalanceWasNotImproved": "0x4a7b08d27f8e7a95ea2a14564163d6f42a663ea247c9f297a278fd26b35514c8",
       "positionImpactFactorPositive": "0x58529c64a00bf54d5a13ded16f36034aaa7dda5530f74cf23d46aac19acbbff7",
       "positionImpactFactorNegative": "0x078d064d98101201466c1c551b0ca6a8a305140a5696dc99ff74821392d97c8f",
       "maxPositionImpactFactorPositive": "0x6a348a258a1098bae9ec5b403d66b4e0b14d27f5ce1fb2b13767d6655c4ea428",
       "maxPositionImpactFactorNegative": "0x3119b21aa76ac0e07b2df9300c392b6156a893a2bf6c75c785dd67b8e3dcc8a1",
       "maxPositionImpactFactorForLiquidations": "0x74f32194510fe6d7b037bc0fc902159ad98ec50b06317ca50726ee5695ed5920",
+      "maxLendableImpactFactor": "0x7b03b41e9a35c9255a36f3a2ea41f5d8c94ca90a8e56658957a4c47b14a6711b",
+      "maxLendableImpactFactorForWithdrawals": "0xddaf6fa2c5ac46d8f95e4f366bb5e4b0f86f4fcace6d44d2f09b9be4db3e5887",
+      "maxLendableImpactUsd": "0x4916e8e20539620254fe26d080e1c680d02dae6a51ba6739263bf33d778775ba",
+      "lentPositionImpactPoolAmount": "0x79fcfdb4c739ab33a96f51e01469d88d5008f6ee60d0547e63391256b2969de8",
       "minCollateralFactor": "0x70d8296fff44280d8f08d21c4827e88e576995b4ba5abe74057005597a25366f",
+      "minCollateralFactorForLiquidation": "0x9ea6294cb72900e32d374e281f6bf719a9a65fd530ecfb43f4fd2dccd7d267b1",
       "minCollateralFactorForOpenInterestLong": "0x1ad4a9c2b4ce935ef436514c8854eedb430a2d63208a46b5b4c1a539c33e3d09",
       "minCollateralFactorForOpenInterestShort": "0x9e8636270bb17fe8d5dee385bf6abb8ecc53da1f4a98c52ccef3b75eaf4895b4",
       "positionImpactExponentFactor": "0xb6d3bd408c744959ffd59a568819258af55102649edb14de3f8c525ed02f5568",
-      "swapFeeFactorForPositiveImpact": "0x9be51f5179ba5927f3ec2509daf80d5ccb06af86cac7f814d62123fdcd41cdd3",
-      "swapFeeFactorForNegativeImpact": "0x8a9fe3c474ef4ef9d9693f2e0fbc6765169ed2b19284ae93a0ce93eb09b6e2fe",
+      "swapFeeFactorForBalanceWasImproved": "0x9be51f5179ba5927f3ec2509daf80d5ccb06af86cac7f814d62123fdcd41cdd3",
+      "swapFeeFactorForBalanceWasNotImproved": "0x8a9fe3c474ef4ef9d9693f2e0fbc6765169ed2b19284ae93a0ce93eb09b6e2fe",
+      "atomicSwapFeeFactor": "0x3f814b1990fcc2590ee1e6f34b76b7aa9820a7cbcfec9ebbf1eb526848ac6707",
       "swapImpactFactorPositive": "0xab8e032738aa576a838476c84eb601e7e2f2a8b34e5dc5c536aa6f1b9264bb00",
       "swapImpactFactorNegative": "0x89dd570058416dd9eabb37b9b0572fe09e54d9096bd0805a622035cd5858e426",
       "swapImpactExponentFactor": "0xacbb4a823d8b7377146f586552852bef3ceca091776f5b319e655537bcc21ceb",
@@ -5084,19 +7204,25 @@
       "maxFundingFactorPerSecond": "0xfbca942b223f41bd0fe94b280cf01a8646913b11864a69ce11b17538e7129cc6",
       "maxPnlFactorForTradersLong": "0xcca14cbe5461dd8604717dd723e8fcb2511a1c803ef6b99d5fc49368a88f8a22",
       "maxPnlFactorForTradersShort": "0x66ad3a6552e212142e97a1ca0e9f38be81f997c7c15016254f1e805c59387874",
-      "positionFeeFactorForPositiveImpact": "0x3f73aa8aa2902b49a18adc8fcfc80f673b7fc9234a14b2206dc5076920fc3fee",
-      "positionFeeFactorForNegativeImpact": "0xeee66d741c66a82695578446740ad96569e35f6d461874a00d2699d9e5e6b133",
+      "positionFeeFactorForBalanceWasImproved": "0x3f73aa8aa2902b49a18adc8fcfc80f673b7fc9234a14b2206dc5076920fc3fee",
+      "positionFeeFactorForBalanceWasNotImproved": "0xeee66d741c66a82695578446740ad96569e35f6d461874a00d2699d9e5e6b133",
       "positionImpactFactorPositive": "0xfa4c51cba11d6919e4e3d3d0afdfd0f1d395c556e064f8d3d4a57e0ab392ab35",
       "positionImpactFactorNegative": "0x9bd82d60d6308707faab3f5a82e1a88387143aa9dad017bc8895f6d7e675065f",
       "maxPositionImpactFactorPositive": "0xc6e8ff82b7067dd8ba4d505f65921fa7ef232a09369691b1bccb4f36a5fc478c",
       "maxPositionImpactFactorNegative": "0x505752b0d40ffae647798a4bd22d80761466d2a05ccd57c64c55c65e96c46beb",
       "maxPositionImpactFactorForLiquidations": "0x2ed4cb8dc5a833446a21721d3415cc0338c637436b0d9dd5800b6493fb998b36",
+      "maxLendableImpactFactor": "0xede02bf5b44840e30969babd4f118cc6b7e1417a8c9679dba4e4343d1849cfdb",
+      "maxLendableImpactFactorForWithdrawals": "0x47f9d09cd9c1e56b7433edbf033d908ee9e2516e3063f470d46d5de26a0866e4",
+      "maxLendableImpactUsd": "0x575358386936c0620890f124f6d19141fd53c5745167a1a23d8a461a5e3aae29",
+      "lentPositionImpactPoolAmount": "0x8a9fbab28ccd7a5d1247cf6f98262b8705b2861e0549b6a65929a7b72f05caf0",
       "minCollateralFactor": "0x79c16947dbddcd32e966cec7dab3ba71dfdcc0024ae40d2207d271067d727681",
+      "minCollateralFactorForLiquidation": "0xb8e50c3357c9b0687230c6323576d8c4ee3945c335963d1b140edeaacb2d4266",
       "minCollateralFactorForOpenInterestLong": "0xa4bfbf6c0ee876da9dcbfee32442a86b0f70ea215d40f50d6136531dde67e999",
       "minCollateralFactorForOpenInterestShort": "0x1155b83e2cfe76f46bd264febe8e7e2cba6781f6ae11885ebbce9ddfc94c3d50",
       "positionImpactExponentFactor": "0xf7ac92d06cfc6e497db204105052083fb5fbfb4ca5eae120a960a9a3ee379273",
-      "swapFeeFactorForPositiveImpact": "0x9ff68505a5a6a99d8fcfaa7feffaf3845707beef48ea8496c9938dcc1c8cd659",
-      "swapFeeFactorForNegativeImpact": "0xc122e6184657495f1328c62b42c211b809ac9f91bae19dcbfa431ea1ba12345f",
+      "swapFeeFactorForBalanceWasImproved": "0x9ff68505a5a6a99d8fcfaa7feffaf3845707beef48ea8496c9938dcc1c8cd659",
+      "swapFeeFactorForBalanceWasNotImproved": "0xc122e6184657495f1328c62b42c211b809ac9f91bae19dcbfa431ea1ba12345f",
+      "atomicSwapFeeFactor": "0xe28fd3f8caddb693b7f72402386369bf85b84285eaf07d50a09950d9240aa883",
       "swapImpactFactorPositive": "0x76e9a37967d0130ab2ef994e9eb21736904cb97869b42ea63c2ecfb00b01f743",
       "swapImpactFactorNegative": "0x782fdd24d86e31774c77cbb4cb2ccb0841cb0ccc392d2863a9ee28a52fa8dac8",
       "swapImpactExponentFactor": "0x7f06ebca597ee9e3171b8bce637b368ae38f9832a9b69b7b9182ad85232d5dd2",
@@ -5134,19 +7260,25 @@
       "maxFundingFactorPerSecond": "0xcc699ede2997c9256b1197a6b45fec1044e2a5f5cf19b6c5b0c1f6fa998cf188",
       "maxPnlFactorForTradersLong": "0xc723c6695a9b5598af4de3e27a64e8bfb5c1079334ae20b2ac01a5dbf3fda13b",
       "maxPnlFactorForTradersShort": "0x5bc9090529cd94bcbdfb42182bf165d6024d177072db492cec78c05bab9b00e9",
-      "positionFeeFactorForPositiveImpact": "0xebe11e396eb1f9b2104202c8d05d730f6138cccc95a5a7cf183b235de07df730",
-      "positionFeeFactorForNegativeImpact": "0xb0db1387c147d7aead4388becf2c94d3f2fa2e6f8960908338a21fbab5d12eb5",
+      "positionFeeFactorForBalanceWasImproved": "0xebe11e396eb1f9b2104202c8d05d730f6138cccc95a5a7cf183b235de07df730",
+      "positionFeeFactorForBalanceWasNotImproved": "0xb0db1387c147d7aead4388becf2c94d3f2fa2e6f8960908338a21fbab5d12eb5",
       "positionImpactFactorPositive": "0x1eaff5142fbc691c04970ca9b0a261acfbbc76e2f052ad3b534055a8726b61aa",
       "positionImpactFactorNegative": "0x80b4b7fdc25c6bc930765f247486bf3ca062f8b15113fbab0d41e05f1c13af98",
       "maxPositionImpactFactorPositive": "0x30e99c791acc5aee7b6dc78ac7375ce3f9edf7745062239ee1b6fa54793ec829",
       "maxPositionImpactFactorNegative": "0x2eda01c71a69850c6bc77ec241f94fa7dd2b3a5663a8e91c7d881a9b376c8dc8",
       "maxPositionImpactFactorForLiquidations": "0xc3f4605a72bee84cf508210e7cc38fb8ec214af45a27fb5896bed941b4295358",
+      "maxLendableImpactFactor": "0xa4b4dcc843bd519c25c8f9e70d0ba37cfd2ff83d416261138e059c2e430a1f00",
+      "maxLendableImpactFactorForWithdrawals": "0x8146f601db0a6724c0490b88a7d1131ffdc58dd2c4bda1b2cb89acbe5db00572",
+      "maxLendableImpactUsd": "0xf4d256872fdefbcf6f9b74b35ef660550377eaf74d9d13f26c70df2f30c9cf66",
+      "lentPositionImpactPoolAmount": "0x41ffa61b8497a2d31d80c90b5aa91a5d20d6abc145edb9e99c25ffc358920dc7",
       "minCollateralFactor": "0xc2edb3063d48246267159dc0decbc6ad303c34d2ca3dfccd5f22ca671ba417a6",
+      "minCollateralFactorForLiquidation": "0x13c9ef205907f266e10818c057548e059c57d5a0b0fca29f21341a3a34a5f3c8",
       "minCollateralFactorForOpenInterestLong": "0x21af53e3b857539d49a91f80cd682c8386a7536bacee74a1e3694fcd304a8e46",
       "minCollateralFactorForOpenInterestShort": "0x49e09964b342ebf117d63182ee4a5d8dfd68db919bc3246e63d6efe220a8936b",
       "positionImpactExponentFactor": "0xfeab5aa4b409a9a9a3ac990b76057d6bc1959f9ee2fded5fcf41f952766de901",
-      "swapFeeFactorForPositiveImpact": "0xff7943d5848e1ae0a03982cfab38f79b5e09eab5e5f62e140ecc2c6a2f85f271",
-      "swapFeeFactorForNegativeImpact": "0x5a429e1ede60115ef530a2ca58fc82631d68c05947a67ca99fcc7620b9f5ac99",
+      "swapFeeFactorForBalanceWasImproved": "0xff7943d5848e1ae0a03982cfab38f79b5e09eab5e5f62e140ecc2c6a2f85f271",
+      "swapFeeFactorForBalanceWasNotImproved": "0x5a429e1ede60115ef530a2ca58fc82631d68c05947a67ca99fcc7620b9f5ac99",
+      "atomicSwapFeeFactor": "0x23378dcb748980f5601979fa6eca9aede2470a803a8fdafd86daef60715c771c",
       "swapImpactFactorPositive": "0xc0cfe1a7954d25ec07bce3d66dab98e0e6f267790c569760cebf1bbab2261402",
       "swapImpactFactorNegative": "0xfaeadc81caa528d9ef2ad32fae0acfde6fcd2b7caecb02a1636dd457cfbf8a6e",
       "swapImpactExponentFactor": "0xee2501baa786d9721010c6fa98e1110d7eee82eb1f0e9445b705fd718bc9ebc1",
@@ -5184,19 +7316,25 @@
       "maxFundingFactorPerSecond": "0x339531b45d58d8d4022581103de344aa555609a986dee2271d571fdc908f4e33",
       "maxPnlFactorForTradersLong": "0x503ad4b2fad7874abfbdc32026d94268af5857b707d8ccd6cdf5fa832772675e",
       "maxPnlFactorForTradersShort": "0x2efd3f2a4ec3819cbf55352c533036ca3d65488c891c79372dadf02092df0fe7",
-      "positionFeeFactorForPositiveImpact": "0xd0e35efb814d9ca4f45fdc44baf063dbcac15b6908cad3ee66c1cb92db7bd080",
-      "positionFeeFactorForNegativeImpact": "0x03c3809639c69d28aa9ed9966d12d8b3fd8f6d025724c3493932916bfe67f32f",
+      "positionFeeFactorForBalanceWasImproved": "0xd0e35efb814d9ca4f45fdc44baf063dbcac15b6908cad3ee66c1cb92db7bd080",
+      "positionFeeFactorForBalanceWasNotImproved": "0x03c3809639c69d28aa9ed9966d12d8b3fd8f6d025724c3493932916bfe67f32f",
       "positionImpactFactorPositive": "0xc344ccb8fdb0aa469744b8475e04e2635b7c780d96ed1e179192285000262875",
       "positionImpactFactorNegative": "0x718de37c3d799a6004ef0742bd5d880f70abc00efce52e69a73701299d42b272",
       "maxPositionImpactFactorPositive": "0x87906bb7a0d357d25f8ed21eabd489b025c321b2916e03f8694f319053bf1361",
       "maxPositionImpactFactorNegative": "0x127276fbb55e276a0f1b3be9f0ca36b656d46b87215b98180bfa14e78471dbb2",
       "maxPositionImpactFactorForLiquidations": "0xbacbc40e853def28c8e96ed81e0d395d1a9aa1e654a6e35b590a66b26cd16b15",
+      "maxLendableImpactFactor": "0x0c1c501bad7caa28ce0cda92c9d13c41e1bdc27420c262dc86801600ce4e0300",
+      "maxLendableImpactFactorForWithdrawals": "0x82672a03ee0b97e8fba5febf62e25e2af569f1d84ea5b3ab8e0f29d64baa0745",
+      "maxLendableImpactUsd": "0x5ad0e04cd5e93778c30d1d0c96b2c22a8d5824733cdf0723ea91310a87c888f4",
+      "lentPositionImpactPoolAmount": "0x5d767b7eb39d6309ad824615d743711cb9f4a5f9533ff3b152042c8b040349cb",
       "minCollateralFactor": "0x44602657c72e1dbb7ac480657ba83e69528e0b3d1cdcf2232dc8f37156fc4d71",
+      "minCollateralFactorForLiquidation": "0x096a65eaa096404bd43912fab0518b62149c2bf39f85d1848fd4d78c40f8dedd",
       "minCollateralFactorForOpenInterestLong": "0xcf807ed6fdcc8664b593225fc63bb816add4008d891a840fc6af82bb00f9bf3c",
       "minCollateralFactorForOpenInterestShort": "0xd1aaec1d623b1045cdfb9e5e91e9ee1667fc872a64bab967a18ed039fbaf1c97",
       "positionImpactExponentFactor": "0xe50ebe93dd21ce63048f6b6fc748a98f88786e0b798aa7bf3f8c594b729e06b2",
-      "swapFeeFactorForPositiveImpact": "0x4bfc0ff68b6a51da4cd8b290dbdca223e00ed95be57f4ec4d0387d80893f6042",
-      "swapFeeFactorForNegativeImpact": "0xd1f0eb18d1b70fd022efbaa081a9d9d49f5a66041f12a9ddd7d542b91dda9500",
+      "swapFeeFactorForBalanceWasImproved": "0x4bfc0ff68b6a51da4cd8b290dbdca223e00ed95be57f4ec4d0387d80893f6042",
+      "swapFeeFactorForBalanceWasNotImproved": "0xd1f0eb18d1b70fd022efbaa081a9d9d49f5a66041f12a9ddd7d542b91dda9500",
+      "atomicSwapFeeFactor": "0x348129bb3c99c81479947c66771ea7a63bc37b52fa6038a498dc9cd885ee1573",
       "swapImpactFactorPositive": "0x419f18d9a5b531da198a09ba7ef2476b5eeae9c3a16e5c3d739aeac467d6a30f",
       "swapImpactFactorNegative": "0x0959316b70af2ad02e67588267776e3771423d4755a6eec179108a4455b6703d",
       "swapImpactExponentFactor": "0xbaa3866145a17207d0e14128c5635d797994884691d43aab2b26b0d235af844d",
@@ -5234,19 +7372,25 @@
       "maxFundingFactorPerSecond": "0x4363b648ca091537e2c5408897e3c34bb6380b0c8870eb250431ddd4d9cf0fe5",
       "maxPnlFactorForTradersLong": "0x3657770ac232bd911685198e77896550ac98ea07bd3be93000066572dd1fd8cc",
       "maxPnlFactorForTradersShort": "0x2b6639dc74e8755ba6784ae540104e3b1c785ad41deb8ef4acc35eac48946a9f",
-      "positionFeeFactorForPositiveImpact": "0xd08ce0583fe23ac92c70660cefeac56bbefd6b54b303dd1cb722c3fcabb538f9",
-      "positionFeeFactorForNegativeImpact": "0xbe8cf5d2f567f1e7d9660088308c5a52b20c8068dbd2fe57c168ebed0d2f415c",
+      "positionFeeFactorForBalanceWasImproved": "0xd08ce0583fe23ac92c70660cefeac56bbefd6b54b303dd1cb722c3fcabb538f9",
+      "positionFeeFactorForBalanceWasNotImproved": "0xbe8cf5d2f567f1e7d9660088308c5a52b20c8068dbd2fe57c168ebed0d2f415c",
       "positionImpactFactorPositive": "0x50bf2b50d5afe0943511cfe7e7f889efa38cc054fb783ba2e8c6672921681c81",
       "positionImpactFactorNegative": "0x19533b0de3f3027fdb5f002bdaa315c9dd4cbf24b6a5fe39bc1754c1066141d3",
       "maxPositionImpactFactorPositive": "0x2482cb95ad826a33a01a649439805f9295b2bffe6efe7b22a5b720cf7dfb7adb",
       "maxPositionImpactFactorNegative": "0x40f507260eac6d8ef3148a83c4bbb9f3027b8dd0705c25cb0d87fee8f7f2f23d",
       "maxPositionImpactFactorForLiquidations": "0x65f16fd2b957f2ebbe014e43740b694eceba4c8f42c90ace60fe4757d7585b0d",
+      "maxLendableImpactFactor": "0x52a172fe78507a9b9add733f90452d0a34ceb3816b9767276b98d85811835206",
+      "maxLendableImpactFactorForWithdrawals": "0x752da6cd6aa8253a60ca57985add1d8ffee67545335af24e4366b8ddc91abce6",
+      "maxLendableImpactUsd": "0xf95b2bd88f276a228ae665c88208504a71e3bfea2e410f081042f071f52bf1fa",
+      "lentPositionImpactPoolAmount": "0xd24943d88bab006242167704656591770eb1c997b369d82c72fec93e6746476a",
       "minCollateralFactor": "0x03257da2786063bfdd152d461897826eaf6dc4b2694b0b10710a6537e478ccdb",
+      "minCollateralFactorForLiquidation": "0x71a102ce47f7a87ab0db19e35ee9bd0490ab45b2b21733cd96c946728333c56e",
       "minCollateralFactorForOpenInterestLong": "0x958a0b1e22336db2aa2a005c0f60bec36679d2f78effd8393d8faa699cb6f401",
       "minCollateralFactorForOpenInterestShort": "0x6ec70b5f9ac71a65136fe6ef68e9cccd1641597d35bb772801bffd12156232f0",
       "positionImpactExponentFactor": "0x2067b76344d2ef6c31a16da6d9c602f6f0b6c6083b623dc415b7c54e9227b51e",
-      "swapFeeFactorForPositiveImpact": "0xf90922ccdbdf7bf5da782f778623194f62c4e1a1bf2feecd9c5d65cc21a052a4",
-      "swapFeeFactorForNegativeImpact": "0x19b9bf256fd0b1fd3cb363b592c1a5f6fce3898af1562c22259551a5325fa8ad",
+      "swapFeeFactorForBalanceWasImproved": "0xf90922ccdbdf7bf5da782f778623194f62c4e1a1bf2feecd9c5d65cc21a052a4",
+      "swapFeeFactorForBalanceWasNotImproved": "0x19b9bf256fd0b1fd3cb363b592c1a5f6fce3898af1562c22259551a5325fa8ad",
+      "atomicSwapFeeFactor": "0x7c6db4ecbc64f7d30f081d2bd25be2c58442d77ab91b8d0afc618978d26d0722",
       "swapImpactFactorPositive": "0xf5aaedb45293401a80c2272b02d76b9e9aaa280cd4b02ea183b8e8e8dd1ecdc1",
       "swapImpactFactorNegative": "0xcac9b44754232c7262bb194373f9b73d63a1d935f0fbb466fac538af440f8ac2",
       "swapImpactExponentFactor": "0xf51d1fed9f0cc109d834f2868958a9c12cef620aa1a089a6878be5cd5b0416a8",
@@ -5284,19 +7428,25 @@
       "maxFundingFactorPerSecond": "0xc60cb8ec9c7a2ddc7592215b67a9910c4a5e809a0a941acec4dbac6c84a710f0",
       "maxPnlFactorForTradersLong": "0x4004e4cb4f7de39fad349b0ccfed00751e05dfb34548abbcd5315e41f829d125",
       "maxPnlFactorForTradersShort": "0x387cb59e244352f770fa55d46004fd6f25bfa7184a60c4c0bf8d1fd120968064",
-      "positionFeeFactorForPositiveImpact": "0x007d917567b487df00776907fbf3909e6e58e8bf6af6c915a571971d74fea386",
-      "positionFeeFactorForNegativeImpact": "0x2a9bf82d99539da12193636e2446af64b47b5c20d7277629a281dfef45ad8efc",
+      "positionFeeFactorForBalanceWasImproved": "0x007d917567b487df00776907fbf3909e6e58e8bf6af6c915a571971d74fea386",
+      "positionFeeFactorForBalanceWasNotImproved": "0x2a9bf82d99539da12193636e2446af64b47b5c20d7277629a281dfef45ad8efc",
       "positionImpactFactorPositive": "0xac6ea7f431089b9b98dc614c7fdd3090046b6c7d38d70e6f824e6d62fc09d18c",
       "positionImpactFactorNegative": "0xc520bbf5ba1eb0f504168529d37814d8b0f495e3d27ab587043c8901c206642f",
       "maxPositionImpactFactorPositive": "0x48932c41a37bb5d92ced58448a95e809e96961bd3f7832a7911e3041246e1be7",
       "maxPositionImpactFactorNegative": "0x191b0a45795e7aaed845f26d2f8773c8257d42e64cea8af9fda6503f523441c0",
       "maxPositionImpactFactorForLiquidations": "0xf36d46d20e0c1d149236595d78dd3ddd30347332890a251c867d61ec30100141",
+      "maxLendableImpactFactor": "0xc15d25d475f4aa50f9a5259cbe7a305a9847cdf6c045b230a6afbc1cd5f18531",
+      "maxLendableImpactFactorForWithdrawals": "0x5d91aa603ca8ea2d4acb5cfdcab217ab180813ca23ff7670b30b9b4607e2b708",
+      "maxLendableImpactUsd": "0xb1de43a4aafe1524432c9c4db804da4f7367fc8bd9cc0ae46e9e466c04d6283d",
+      "lentPositionImpactPoolAmount": "0x692b86231bae04b5cfb515b5ba1649dbb2ee9790b3dbe504e80e4265ea73ae54",
       "minCollateralFactor": "0x03ecbc69da5ac390ea111fe758b31fa45985710c5a9c25586abb760798bbbf9c",
+      "minCollateralFactorForLiquidation": "0xd920b7294e62802604fada6c7c980ebb231a9aa0696622422269bdda53254fd5",
       "minCollateralFactorForOpenInterestLong": "0x5f9b7158e11769003f8be017ed1bf645a37c93d2c7f1a07fbcef8ec7f04cbb6a",
       "minCollateralFactorForOpenInterestShort": "0x1de376a03ba431c6f254a42ac66ba838045ae552f87f4894d0ab5c0854f94ff1",
       "positionImpactExponentFactor": "0xe4d2b50abb09343c53a1dfa74b24cbb4c5aad66c8e94cae1da7a611c0e637eba",
-      "swapFeeFactorForPositiveImpact": "0x1e5f4c350cf2fbeb7312594b741013cab6f982ba880e400fb00a410cb3abad5f",
-      "swapFeeFactorForNegativeImpact": "0x56c6c93fd5ef836406270f67fb0be7246f7414db276316b34265d269283dcf0c",
+      "swapFeeFactorForBalanceWasImproved": "0x1e5f4c350cf2fbeb7312594b741013cab6f982ba880e400fb00a410cb3abad5f",
+      "swapFeeFactorForBalanceWasNotImproved": "0x56c6c93fd5ef836406270f67fb0be7246f7414db276316b34265d269283dcf0c",
+      "atomicSwapFeeFactor": "0x1d242793f220d0a818aadfde2c9fe8c1a13017f1ddd5ef560b7b7628d73e23ca",
       "swapImpactFactorPositive": "0xccc77f870ba42d778057d944e6c80fb332320084fea7acffec3838cc2c4b84e6",
       "swapImpactFactorNegative": "0x581d1441b56c1e2c8de4ef60d65ab0f3ee119350688aa8214bc1f3f19f629eea",
       "swapImpactExponentFactor": "0xc6d4eda05e33dec48a6acd523dbd21543dfdae520576087b2de5a6b6aaeb56ad",
@@ -5334,19 +7484,25 @@
       "maxFundingFactorPerSecond": "0xe583c28fd1a56971b89b5ebafef4b397c75a891ecd2f3597eda555c9babc451d",
       "maxPnlFactorForTradersLong": "0x260b5157f577177177d6e74a07933ed6d32ffd849c45791a0d8538ad1babb03b",
       "maxPnlFactorForTradersShort": "0x43283c63738dfddde878706561d7fa7f4bb18ec01f2d9308279b83d303f0e4c7",
-      "positionFeeFactorForPositiveImpact": "0x7ec81b3e05aff0463fc38a88e0778c5e06266089c1c1c9ff80375db1c09d0ad6",
-      "positionFeeFactorForNegativeImpact": "0x5de7369530849ca490d75f556ffda8ccd56ba55bced76157c3810980600f0339",
+      "positionFeeFactorForBalanceWasImproved": "0x7ec81b3e05aff0463fc38a88e0778c5e06266089c1c1c9ff80375db1c09d0ad6",
+      "positionFeeFactorForBalanceWasNotImproved": "0x5de7369530849ca490d75f556ffda8ccd56ba55bced76157c3810980600f0339",
       "positionImpactFactorPositive": "0xc2527ce6d7f8c869e87302ca90c44863224f17dd52e949cec5034fe7d6d1b506",
       "positionImpactFactorNegative": "0x3f918c6ec9c1980cebaf33b83d31c052e45c7ee570447898dedf2860a7da2bfa",
       "maxPositionImpactFactorPositive": "0x44883af09d61a5b41c7deb568c97737dc232031443215f6042ab1fa0054e99ce",
       "maxPositionImpactFactorNegative": "0x8d3d65312060d4e8c2e1ef88e1b12303fbb03e94b4067d2568a696aec00deacb",
       "maxPositionImpactFactorForLiquidations": "0xff0330b70a4077634b40ca74c3933d6d7815a91a542082add3fc1ebe41273d50",
+      "maxLendableImpactFactor": "0xafb174ffaf8c22d2186ede3633386a2679c5ed9dffe2ba2ab2cf2d56467e6d92",
+      "maxLendableImpactFactorForWithdrawals": "0xf600423e844ceebbe6fbae6cd7555a99b428eb86905f6115658fb17146d07eeb",
+      "maxLendableImpactUsd": "0x5fc6ba3bfef635a161b780169896828c41dc9166a4430883ccd793f8c6c74542",
+      "lentPositionImpactPoolAmount": "0x93214cec9c92ce9615bafdb3d0a74acc28e91c14b848066260b9661b049c5b47",
       "minCollateralFactor": "0x27aae14bd281c4cad2e25eb7dddf2056cf33fe30c92334b6c1908e33603a594a",
+      "minCollateralFactorForLiquidation": "0x4d36cb411e16178e83604c194f3384eea3dfc987123fd9cc25ef8f78dd043ee1",
       "minCollateralFactorForOpenInterestLong": "0x35b24de0a1a1af62333ba0be24b03cf0639b0e1395d94c4cedec839ca221b0e7",
       "minCollateralFactorForOpenInterestShort": "0x7a3010bd5329103b10512f4947b9d5ac36e6bc5677729ec4f8f68f35924f787c",
       "positionImpactExponentFactor": "0x337e63e32187ff3fc173f5011397d5eabbdc507646d2393fd8fbeb287fc4b868",
-      "swapFeeFactorForPositiveImpact": "0x1d62b36458b3597ca93c501028c3de5017918bd9aca0ee3acd919329b2ff8ae2",
-      "swapFeeFactorForNegativeImpact": "0x5cd08eeaa4133f740cfe2c8d7f4ac62db55fbf503024a0c08b306fd39b48c935",
+      "swapFeeFactorForBalanceWasImproved": "0x1d62b36458b3597ca93c501028c3de5017918bd9aca0ee3acd919329b2ff8ae2",
+      "swapFeeFactorForBalanceWasNotImproved": "0x5cd08eeaa4133f740cfe2c8d7f4ac62db55fbf503024a0c08b306fd39b48c935",
+      "atomicSwapFeeFactor": "0x9c34e983234a66a6e55681e0829a7d27ab358f9897eb04561eed25f40afcb787",
       "swapImpactFactorPositive": "0xfb399f4414b807428dd2340b923793f8e3e223c3758d217c66c320265786db6c",
       "swapImpactFactorNegative": "0xa7583e74286befd226ba820f162caca16ce41291b51dcf4210b99a53bf8d713a",
       "swapImpactExponentFactor": "0x943c4ce8ee656546292d9a194c061eea37683b344e34d71495cd4555edee883c",
@@ -5384,19 +7540,25 @@
       "maxFundingFactorPerSecond": "0x9c399ce61641bb1f0de20944b462410a44f2d09642ccf0a04c6d0f5d066aa031",
       "maxPnlFactorForTradersLong": "0x4bfbce99eb77139d55e6df621e0cf75763a4593d151d8150bb501c048935acd1",
       "maxPnlFactorForTradersShort": "0x242cc33a4317819d85f507e8d122cbaefed1ae2eac046c9dcd77511b6a3d023e",
-      "positionFeeFactorForPositiveImpact": "0x72816d892a8d960262b4fe693b71a6b9de0ac694a154cd31dcd7284bf516cdb2",
-      "positionFeeFactorForNegativeImpact": "0x6ba910a9a74e758085688e794fcbb3b0915c9b0cc0b288dff018b306dcad09e2",
+      "positionFeeFactorForBalanceWasImproved": "0x72816d892a8d960262b4fe693b71a6b9de0ac694a154cd31dcd7284bf516cdb2",
+      "positionFeeFactorForBalanceWasNotImproved": "0x6ba910a9a74e758085688e794fcbb3b0915c9b0cc0b288dff018b306dcad09e2",
       "positionImpactFactorPositive": "0xb2c83f915182511fcb38344c11c91765c4152fe820e172cd68400029c8b937c0",
       "positionImpactFactorNegative": "0xe6d1b89ac6f2ce52f9e9071a251b08d41ad0d7cb998360a09141c49b6bea4156",
       "maxPositionImpactFactorPositive": "0x9a594d5ba6384739325febf4bddd5b6cca6fb616edfd9088afbee47fb41ff533",
       "maxPositionImpactFactorNegative": "0x1fe2b6e82973868d11b609eaabb2aaad17824947cf596b31285207b6a783a402",
       "maxPositionImpactFactorForLiquidations": "0xacd16f5d1fc4dbfe6e4d7ea04482a833154d53ee9158fd4bcf814a3c152c7968",
+      "maxLendableImpactFactor": "0x218dfb2f3fa7191c4314e14e2e8ba2945227027b451a23eea586f505242377fa",
+      "maxLendableImpactFactorForWithdrawals": "0xb260aecb10c9f454588ec8744bd33fe7996e449f70f197bff29b8f9d4ec9a3d5",
+      "maxLendableImpactUsd": "0x726bf4307a78ca4571ac740aaa9b8b643ce70e00fd2875843a363eb07bbf971e",
+      "lentPositionImpactPoolAmount": "0x6aabcfc53d8a865968fc2c45d4bb3b69753a7ef87ce5ee9516d112d14189ec80",
       "minCollateralFactor": "0x698b96cd3a094ea412a7628c971920e715fe06bd06e200035b367b3dc046f745",
+      "minCollateralFactorForLiquidation": "0x00a26c33e84c34d7464b8b5e05c899812831d9c82e964ca0f6f73e84eb5a7c1e",
       "minCollateralFactorForOpenInterestLong": "0x58330b893e1565ce7732e4b4d3255dc018500d7aefd5d58946144d3067508cc0",
       "minCollateralFactorForOpenInterestShort": "0x2d6e8b614741229e997e7f625533433018db60bb050980a288071b2228df61b8",
       "positionImpactExponentFactor": "0xbcd5e535b6b2461dd01c0915177b85bdf2ca0974c38402810a2dc5ca974cb8ed",
-      "swapFeeFactorForPositiveImpact": "0xa3ba4d614e29505bac315dee9664716cfa96cadb6207c8ead416299ebab8b69f",
-      "swapFeeFactorForNegativeImpact": "0x8b990fd6ef7a24250b629c7fa3d3e965f2ee10c1b17c15d9b072aaf0d75d11b0",
+      "swapFeeFactorForBalanceWasImproved": "0xa3ba4d614e29505bac315dee9664716cfa96cadb6207c8ead416299ebab8b69f",
+      "swapFeeFactorForBalanceWasNotImproved": "0x8b990fd6ef7a24250b629c7fa3d3e965f2ee10c1b17c15d9b072aaf0d75d11b0",
+      "atomicSwapFeeFactor": "0x65cef630b6bd35dafd0d12f900765be7171b761240e6caaf01c21d18f5f78ee0",
       "swapImpactFactorPositive": "0xdb794233f573199e11b2568c3c92f38a3744dece73525f013a685e528bdc6e00",
       "swapImpactFactorNegative": "0xd579ac5d1571cd61c69c378ebd76a71638e7312306b99fbdfeece3fa47ada36d",
       "swapImpactExponentFactor": "0x29711b33c281e649cfa71890aa153b28782df34f91a2097dd43f8e75fc408262",
@@ -5434,19 +7596,25 @@
       "maxFundingFactorPerSecond": "0xe7e734e4c1ee8b93b86880b6848f5b207f5b234caf98b8bc386b7e79ab7912b2",
       "maxPnlFactorForTradersLong": "0x8f7a05cdbf1b297c4fcea4c609f84320afac0ebf972c4f616e17c44655115971",
       "maxPnlFactorForTradersShort": "0x2a71f9cf361d204760610fd760b56d5b35a843c78755085077c75a48b6df8e1b",
-      "positionFeeFactorForPositiveImpact": "0x3ff5c2fda86cb6ac7357de79b9bca5e1ef107ddab75f57c0e867404f228a60d2",
-      "positionFeeFactorForNegativeImpact": "0x9cd7ddbb8e1b8f130805f1cffd550815ce4a4c2d07b961c3051da5f11f0669f7",
+      "positionFeeFactorForBalanceWasImproved": "0x3ff5c2fda86cb6ac7357de79b9bca5e1ef107ddab75f57c0e867404f228a60d2",
+      "positionFeeFactorForBalanceWasNotImproved": "0x9cd7ddbb8e1b8f130805f1cffd550815ce4a4c2d07b961c3051da5f11f0669f7",
       "positionImpactFactorPositive": "0x5c0251c56debcff9b65ee9d854dbf08d1c881deddfbe7ef48d37e8d18fa17989",
       "positionImpactFactorNegative": "0x5840e8072ec9ea74977c498a91feed3c815d61b5f3062818f45df2b9d7b363fd",
       "maxPositionImpactFactorPositive": "0x030f83905621bfd3cd25bbfe083e31bcb71db9826b067f346ee05170950136dd",
       "maxPositionImpactFactorNegative": "0x1926d782940abb168cdd50e7c4a4db14fb213dab129751ff6b6cfdda7a1153e3",
       "maxPositionImpactFactorForLiquidations": "0x72bbd2b2d9d41e43f87c725279a503454cf2ee59430cdde4b5c8efc5d07f0aea",
+      "maxLendableImpactFactor": "0x0def8c8ea46384cb92a739eb0740b85aa9501a27c1e0b83de960af9c67343e4f",
+      "maxLendableImpactFactorForWithdrawals": "0xae42fa5e213f98535331eb37f6d70d88b1b1244713d7dccf1b585ab06436b7f7",
+      "maxLendableImpactUsd": "0x06ca1a93a5dc53cbe9ad35ae34186d6f863555074a5b712728d36d3e8c1aa27e",
+      "lentPositionImpactPoolAmount": "0xa74a87486b3920fd1739353f9da119fb9946409f1881627f55a1d20fb5cc99f7",
       "minCollateralFactor": "0x3c8e9a2263e7b3aaed77f397cbb78c154d7df45c8fd9f3293610e7a9499f3bd6",
+      "minCollateralFactorForLiquidation": "0x8e64049c3c2981df32bed046c45d8b9a264df191d293b069d02d0e790add562c",
       "minCollateralFactorForOpenInterestLong": "0x68db012f561515480190c5a28c8b7c8bff8bcfefa9f2329aa4ebb00a64dfb027",
       "minCollateralFactorForOpenInterestShort": "0x3e66b9a84db4568cb7137ffa35aae284f2ee5221724165a49f4fab30490c337c",
       "positionImpactExponentFactor": "0x71f13bfb0b47f4087378469ece6811760e36e271d52c8b788af0871595bdb4b5",
-      "swapFeeFactorForPositiveImpact": "0x82120bfaf43c7c864880c85bea94c8aed5961dce6c788d1b372783676253b5c4",
-      "swapFeeFactorForNegativeImpact": "0x9d43fe0c42b447782429e2c237376e87968a70de628212c5900a269da92a6c55",
+      "swapFeeFactorForBalanceWasImproved": "0x82120bfaf43c7c864880c85bea94c8aed5961dce6c788d1b372783676253b5c4",
+      "swapFeeFactorForBalanceWasNotImproved": "0x9d43fe0c42b447782429e2c237376e87968a70de628212c5900a269da92a6c55",
+      "atomicSwapFeeFactor": "0x4d523175da4643979f545e13545036af4f14cdec8da5cdadd33ef6ff363b0521",
       "swapImpactFactorPositive": "0x5ac0772f7d1d01adeca5890fd7a12efb194b042a949ff9676956a1b18a6684d8",
       "swapImpactFactorNegative": "0x1fda8752104b3cec09d2f3deae9a845297c27bf555787375a5095da13b00a0a0",
       "swapImpactExponentFactor": "0x67ffca46672ad8e81a5ccd1f83a1b5ecb12177ef0235a68e15c3aba5f7e6d588",
@@ -5484,19 +7652,25 @@
       "maxFundingFactorPerSecond": "0xf4a6e146dbba3de83c2a8aabcf4b4534960ef8f3dc3d3a65280175e9fee6ab1f",
       "maxPnlFactorForTradersLong": "0x9273a00d6ed482033b858572f916738237adaabfde3490be6d0b711a5dfcf512",
       "maxPnlFactorForTradersShort": "0x5a4471cae0c0e536aae769ddd3bbb923858fbc28cf44b3f334d627fde16722bf",
-      "positionFeeFactorForPositiveImpact": "0x6a49a1b6a150b462c7840424e50779181c431198c05864aa79c2c0297d288f36",
-      "positionFeeFactorForNegativeImpact": "0x34c8eee3a2807ea0c00ffd49ca20197cdbae2767ebb1b4bf906f6e4ee05b62c7",
+      "positionFeeFactorForBalanceWasImproved": "0x6a49a1b6a150b462c7840424e50779181c431198c05864aa79c2c0297d288f36",
+      "positionFeeFactorForBalanceWasNotImproved": "0x34c8eee3a2807ea0c00ffd49ca20197cdbae2767ebb1b4bf906f6e4ee05b62c7",
       "positionImpactFactorPositive": "0x72390a7575ebd481acb4a269886445b8b8f18624dd31366204ea5f052a5e0249",
       "positionImpactFactorNegative": "0x1dc71efbb909b75009ef1ecd28f125af6248efb7cce08016373e95750fb1a492",
       "maxPositionImpactFactorPositive": "0xefc0e6f13b3331a365027b599cb8bceaaa44eba98e35841da10f95042ce2ffc0",
       "maxPositionImpactFactorNegative": "0x3f0f9566fb6f301b104bbcdab7775e865df1cffc16a345bb33f8807b947431ee",
       "maxPositionImpactFactorForLiquidations": "0x75ecfa326eed4ad5245c1e4bfdda62bd8cf3edf7460afad031192c187071cf70",
+      "maxLendableImpactFactor": "0x22eba806cb5e0c3009a64cbd36dfe0c17608afd15fd51fe16ce47227e3a6dcc2",
+      "maxLendableImpactFactorForWithdrawals": "0x54c88b5d971110d4696941f23633e7580df99a0bb0554d81075f1e7690981907",
+      "maxLendableImpactUsd": "0x5c0c70fd4d948fc0eb766512928cc611648c1c3defc6875b5fa542a4dcfee832",
+      "lentPositionImpactPoolAmount": "0x3b40905ffd2685035d5d06ff218c8a48e780e73c7cceef85ca19fbb7fec01e62",
       "minCollateralFactor": "0x2c1b564020448b09588e27ce484dac4ed1e5788851545539ed25326726fa047d",
+      "minCollateralFactorForLiquidation": "0x9793b322d406bd3ab07bab9bfeba55d733658a1866fcd18806a2ea761138e9ec",
       "minCollateralFactorForOpenInterestLong": "0x764b0b370f16745c38880c82893b0b0272f2631f1298984dce74474631a139fd",
       "minCollateralFactorForOpenInterestShort": "0x0341fd2b324b8ef1cf6e9c3df7335e1ea580bf8a0dbeb293d36f45ccb4e7cd76",
       "positionImpactExponentFactor": "0x6ee59d63c0332b05fdfd3c9c24565b31a667e9634f594ec3454331863bb0bec7",
-      "swapFeeFactorForPositiveImpact": "0x2b53b9fd42b44447585ad140436a690598b97e3a3ac95e23f5fb572474e47b91",
-      "swapFeeFactorForNegativeImpact": "0x3768b6cc037ee07054b27d75caca82f3c4fed7ad75cbb2cf6309c3bb6b558a1d",
+      "swapFeeFactorForBalanceWasImproved": "0x2b53b9fd42b44447585ad140436a690598b97e3a3ac95e23f5fb572474e47b91",
+      "swapFeeFactorForBalanceWasNotImproved": "0x3768b6cc037ee07054b27d75caca82f3c4fed7ad75cbb2cf6309c3bb6b558a1d",
+      "atomicSwapFeeFactor": "0xe25421b86db3537779e58211d2533e3a76b716d49a68233219f571797714db0b",
       "swapImpactFactorPositive": "0x4d2ba8b5784292dddf36d28528876fe8c70b2c1a23eba9b543e83fe6ce4fde58",
       "swapImpactFactorNegative": "0x98753b02e57caff21ef4bdd4d67181248ece31553487ccb8d253684f83680156",
       "swapImpactExponentFactor": "0x89f9737019e4ed3d7fefca8064ca1c1f1c2eac686143ba606cf7bebc80a84660",
@@ -5534,19 +7708,25 @@
       "maxFundingFactorPerSecond": "0x4f793acfb9cb975268489ed8551b3f2f46d2d0f8a3cd7a43491cbf8acfc364a9",
       "maxPnlFactorForTradersLong": "0xe5ce7dabbd210f062e994ea004dd7f12c8ea4a7050eaed2faf3fb9c82e210576",
       "maxPnlFactorForTradersShort": "0x8b3ce0762bdf8219d617fbff36144b7969b899768039a47a4a8acd6fa666a696",
-      "positionFeeFactorForPositiveImpact": "0xeb9630d085c018891245c6e5b7ae66ce78e43855b5d70fa82f19b150d6f85846",
-      "positionFeeFactorForNegativeImpact": "0x4511e3199a94aecfb03cf6734ee8dee591ee9f2a524325eb49e6c28d63292314",
+      "positionFeeFactorForBalanceWasImproved": "0xeb9630d085c018891245c6e5b7ae66ce78e43855b5d70fa82f19b150d6f85846",
+      "positionFeeFactorForBalanceWasNotImproved": "0x4511e3199a94aecfb03cf6734ee8dee591ee9f2a524325eb49e6c28d63292314",
       "positionImpactFactorPositive": "0xf995c6a210011bc0300d3d784ceba4deaac6ece23aff73df2e74273d16483e3e",
       "positionImpactFactorNegative": "0xa351ffcfb63dab651a9502901937d3e0c389398b5201794bc8150b8ff163ea6b",
       "maxPositionImpactFactorPositive": "0xe94e46b223077a3dfcfed3014349de0924dbcafa5d5e12436a179b1148578c09",
       "maxPositionImpactFactorNegative": "0x1240bf4cd804c59b4d70c5f53273a26a1f66d6a2a3b041c7eef81b64b2e64e7f",
       "maxPositionImpactFactorForLiquidations": "0x69b5edc246570d7a59c97b4b024398d7872e5e809881f97e17c7edee0d084877",
+      "maxLendableImpactFactor": "0x80ca26367a53b7bb69eb63378896b856d9c56873e514539df9fd1f8cbe0f5fcb",
+      "maxLendableImpactFactorForWithdrawals": "0x6946ea1947e9f712789712f745d5501523f92ddc69ee681186e7215cf7f6c325",
+      "maxLendableImpactUsd": "0x389a546d02e4ac6d3d52cfeafe5bd1a34a3a1419974e040e4f8cfee3a6a9b22b",
+      "lentPositionImpactPoolAmount": "0x1473b20c05aadac00091df90bb3acf3f7a408bf29d27d7a82fcb147690cf6125",
       "minCollateralFactor": "0x8c07e19be90a3b67ead909350737c6f60ec7994cf1284b8de1374a905df4782b",
+      "minCollateralFactorForLiquidation": "0x47485a33abc979478e8344f4f7d339fe712240f96bba4b1b86e87d5e787073b5",
       "minCollateralFactorForOpenInterestLong": "0xe1a895360341ff2c180e3c4243d98086f42adfb2b9d2e5081ac3a5f955d63d07",
       "minCollateralFactorForOpenInterestShort": "0xc71812a119761c33f9b4103ee133e3ccc0d55fadf484bdbabb43cd21eb503207",
       "positionImpactExponentFactor": "0x9431bd8b3347a4230288b4bdb918b609eb1a647bc3c10c3db5e795b420ebdef1",
-      "swapFeeFactorForPositiveImpact": "0xa8d9f9cff183b65b7dca088651a8baed5af77625298af1a905ae91969311ec55",
-      "swapFeeFactorForNegativeImpact": "0x93427d77b84c63793a2d92dfa0d1f2129b49307b109fdf789f92d4dfc3eba264",
+      "swapFeeFactorForBalanceWasImproved": "0xa8d9f9cff183b65b7dca088651a8baed5af77625298af1a905ae91969311ec55",
+      "swapFeeFactorForBalanceWasNotImproved": "0x93427d77b84c63793a2d92dfa0d1f2129b49307b109fdf789f92d4dfc3eba264",
+      "atomicSwapFeeFactor": "0x59e74a1d6a0fe01c168273b218979ba368fcbead6edd6248f4062f1ae77e128e",
       "swapImpactFactorPositive": "0xd4d4fec3dac5d648af883c5241e322bb47dcd508044fcdd52b3676e7a8609cba",
       "swapImpactFactorNegative": "0xf7d514343cd53634029821b1b23419bffd04823ee244f6403632a85290c4fc68",
       "swapImpactExponentFactor": "0x6598158e286f5d7fb1e33ce7d4d6d6cdc134811b72f3166399ca5f0683005f9c",
@@ -5584,19 +7764,25 @@
       "maxFundingFactorPerSecond": "0x87cda574200426b085d0a9ac4bf0126dfc9c003d1b5e856664fb881d2d2e31af",
       "maxPnlFactorForTradersLong": "0x5547985ce54c37c2d55099fa306cb53b663eeefec986166283ffc78a99ddb3f2",
       "maxPnlFactorForTradersShort": "0x30bbab14c6e9a74e4f0a9c331552123b1a1ed09050d7049e45a068cff9e3945b",
-      "positionFeeFactorForPositiveImpact": "0x52f75e2b52a2be4cf30bbe37ac74de800099d99c85ab644ecaf2769dcaeab408",
-      "positionFeeFactorForNegativeImpact": "0xeec77ebd209895b9b469d59875df04a8166aff79665dfa4815544afd8d7eeaa1",
+      "positionFeeFactorForBalanceWasImproved": "0x52f75e2b52a2be4cf30bbe37ac74de800099d99c85ab644ecaf2769dcaeab408",
+      "positionFeeFactorForBalanceWasNotImproved": "0xeec77ebd209895b9b469d59875df04a8166aff79665dfa4815544afd8d7eeaa1",
       "positionImpactFactorPositive": "0xe7488d5212884b2cd7c31a9d55af9caa7298e6bf97a817fa559aaa4ef9933438",
       "positionImpactFactorNegative": "0xc4f2ae062f8c381b7c2c2ee80c24f8f49553e36fb19ba199947bca94109f3eb2",
       "maxPositionImpactFactorPositive": "0x56f3bd4b6832379e513140b9c350ab03da7cc63005fd55651e65d0feb9784906",
       "maxPositionImpactFactorNegative": "0x26ccc2913b07c97f219cfb9a1f1f5ed65318c3504404e547bde20c6c7d816310",
       "maxPositionImpactFactorForLiquidations": "0xcb6ad3df6f86f0480c0f46ecf12b617607347bc774faf8840d30565f0006fd78",
+      "maxLendableImpactFactor": "0x2951dbec739b96f6c80548203cac5b59883a33f7d8169c7bbe6a6bf99be780bc",
+      "maxLendableImpactFactorForWithdrawals": "0x233d6a215085716798e78c682a74257be7d51f245b2786c4bfe337dc3bbadcb1",
+      "maxLendableImpactUsd": "0xf69e318de5ae2ff85065f2f5240e7f849c3d7e07bdb9004742b1a1e9c0f025a1",
+      "lentPositionImpactPoolAmount": "0x1a601b98de6e741f33523dde850eee355272cdbc616c1ae7da182c065d0a7862",
       "minCollateralFactor": "0x6e0deb754cc255b60e296d94475feb89ecb013d88a5091c3d9784547a2cd00ea",
+      "minCollateralFactorForLiquidation": "0xbf4106a36b751df8edfb0c97be58049aa60a9535d83945c1e856f91aac3fbe2e",
       "minCollateralFactorForOpenInterestLong": "0x39019addfc2617caa7a3c788332ec013a656af5eeb2726791dd869e978b6f0b5",
       "minCollateralFactorForOpenInterestShort": "0x39fb129d3f05dd00fe0eaf0d95008439a0067785fd383e421191678b13db471a",
       "positionImpactExponentFactor": "0xa7b30afea3af30a71b26148e633e26ce9280e6a9b0585f0bb857a52208354a90",
-      "swapFeeFactorForPositiveImpact": "0x4f4d5219acbebf609e4d3f6dfab866ab875b7493b5ac846a466dd651bd2c238e",
-      "swapFeeFactorForNegativeImpact": "0x78661a123a93d91d906d41c15c007b19ab8687ce43ae33bed9698de1fd05e9ed",
+      "swapFeeFactorForBalanceWasImproved": "0x4f4d5219acbebf609e4d3f6dfab866ab875b7493b5ac846a466dd651bd2c238e",
+      "swapFeeFactorForBalanceWasNotImproved": "0x78661a123a93d91d906d41c15c007b19ab8687ce43ae33bed9698de1fd05e9ed",
+      "atomicSwapFeeFactor": "0x1079426947df79faf42bbbfd1ee6735ad7dc60b72e13f804901d8eb426ab5b70",
       "swapImpactFactorPositive": "0x9b3474784c1a93dc2d0f8f721f7efefb15a584887583dfa3e303ce08249ae5bb",
       "swapImpactFactorNegative": "0x8fd022a687a7b4da97ceb03d51c39824c1f0669ab078f69b9e27d1f044192986",
       "swapImpactExponentFactor": "0xe32d18703e43af3e655c210a037d7e7e68a985884947ccaac21eaaf0f08d89b0",
@@ -5634,19 +7820,25 @@
       "maxFundingFactorPerSecond": "0x004e278e7702bb56eea4b7bfa829e24caf2f518450986ad173e546530d2e0b62",
       "maxPnlFactorForTradersLong": "0xc5e37a7383f04094590554537fd623f3f5e2dfb0c1ed990e050d311dec0b4db4",
       "maxPnlFactorForTradersShort": "0xee9e62068284a18ed2aa3b418994b275c3bdcec92ceaf9df9e5424cce221f64b",
-      "positionFeeFactorForPositiveImpact": "0xadcac867fbe2a8921851835e116067be9c8cb80a25e3f9dc8605f42936c0a6d5",
-      "positionFeeFactorForNegativeImpact": "0x77dfa60716036f7a00a2b0fc133c1fbf8a019ab698205223897a482a4285000b",
+      "positionFeeFactorForBalanceWasImproved": "0xadcac867fbe2a8921851835e116067be9c8cb80a25e3f9dc8605f42936c0a6d5",
+      "positionFeeFactorForBalanceWasNotImproved": "0x77dfa60716036f7a00a2b0fc133c1fbf8a019ab698205223897a482a4285000b",
       "positionImpactFactorPositive": "0x7a07316499b40f0073431796eece11c8912bfd12dfe2996258ff15f97531c120",
       "positionImpactFactorNegative": "0xc20c88d27b7d859c64ca0ebedb1966de23dc1f690724efe32accfe87c5a6861b",
       "maxPositionImpactFactorPositive": "0xe9bbed667ae52cbcc22d8903f5f3c889e17cc0b4a6fc995a26385ef189bb8c68",
       "maxPositionImpactFactorNegative": "0x3c09dbea3b5ac087cac8f9c8f775aeddbdadcb2be2d04ec6e7353bdab8da7635",
       "maxPositionImpactFactorForLiquidations": "0x8e295cf7af601901120e22edd2c3ae17b6fa8e0fcf16c1744f374054ae457b1c",
+      "maxLendableImpactFactor": "0x8d16f5c15f018ef27f8fffe83d845516d72374453112ad3c58f6ba9c4854278a",
+      "maxLendableImpactFactorForWithdrawals": "0x71fd88f3e3d94c6b3027b0b13b0c6fcaf00118b551fb1290aae4c362d2959e9b",
+      "maxLendableImpactUsd": "0xbd4ef1fd1114165f56db57865f029ec14b70c5137ab2100cb2f51c263d0701fe",
+      "lentPositionImpactPoolAmount": "0x37dbc28688043222222ca65d6034c3457c780155d9da89fa92cfda496573c08e",
       "minCollateralFactor": "0xd2a56837fd65e7a57ec1b4df363df080248a402cdf8e4e10d32205f1299315c9",
+      "minCollateralFactorForLiquidation": "0xfbd2218164ffb156dd63428496d0a3038351db6817aa610b8a3d9c01b6da48d6",
       "minCollateralFactorForOpenInterestLong": "0xf7423212c3b818bdb9261de36121cde34561293943f7645be9b61f0c35d8a996",
       "minCollateralFactorForOpenInterestShort": "0x4940911a4ea682a30fc360ef3c5e02a757e3602a50c2abe4c13542699a19566c",
       "positionImpactExponentFactor": "0x795f98ee94796448bf3c91698960e4f41eda771cc887322c8157f4ab66fdadf0",
-      "swapFeeFactorForPositiveImpact": "0x8051fea8c9ec4de78eb316a8f6d57c8d0b9d3dac08c8a31160bdb0338a464696",
-      "swapFeeFactorForNegativeImpact": "0xd4a1049e6ea909adb6b8b5053de089ae6d2daa94063b181bde473d202ffdd8e6",
+      "swapFeeFactorForBalanceWasImproved": "0x8051fea8c9ec4de78eb316a8f6d57c8d0b9d3dac08c8a31160bdb0338a464696",
+      "swapFeeFactorForBalanceWasNotImproved": "0xd4a1049e6ea909adb6b8b5053de089ae6d2daa94063b181bde473d202ffdd8e6",
+      "atomicSwapFeeFactor": "0xe62f0e0365e746421c58914761a9d357d610cb48872ab926c581ce083d18f243",
       "swapImpactFactorPositive": "0x22637b36db12b76a57e8d2282175608a9516baec885472a076edde09e43cc8c4",
       "swapImpactFactorNegative": "0x61bc53940189842d15da4f36e1a347872fbeeaf835344cfcdd930d6a2a9f7d69",
       "swapImpactExponentFactor": "0x89d217876518450d1fd8f2c44713331334b39b926d37e7afe8889a1bbdda8164",
@@ -5684,19 +7876,25 @@
       "maxFundingFactorPerSecond": "0x5e9c13af5bd51073d690fcf1d92ce4fbc5a18fe616d0753b9b8089f080d46d2f",
       "maxPnlFactorForTradersLong": "0x111c54fa8fa9b8f89c04ea2006627602fd015c62512f1c5e61d432c1fe942968",
       "maxPnlFactorForTradersShort": "0x5cb4e4a6d83ca3d2868a466198d3173d458c899f7555f78541290b9f644f23f8",
-      "positionFeeFactorForPositiveImpact": "0xd7d0c01acab1ea6cc465b2701c6b5e5c5292c6ee342c478556ca16265a760d0d",
-      "positionFeeFactorForNegativeImpact": "0x00b6dbe9a37a2707f1be21a552e2463cfbd8db4a5e35ccd714b5c0bb29e97eb5",
+      "positionFeeFactorForBalanceWasImproved": "0xd7d0c01acab1ea6cc465b2701c6b5e5c5292c6ee342c478556ca16265a760d0d",
+      "positionFeeFactorForBalanceWasNotImproved": "0x00b6dbe9a37a2707f1be21a552e2463cfbd8db4a5e35ccd714b5c0bb29e97eb5",
       "positionImpactFactorPositive": "0x6f94cce3663de546a3528f8755407b57f03730094ba6f211b0e42a6a70f8eedb",
       "positionImpactFactorNegative": "0xee2c38b11e133a53650fbfa980cb4bc36122945f2602992ef66fde5e64eb72c9",
       "maxPositionImpactFactorPositive": "0x5bf9efed9d033d8b3d82ac1ba1702bf49d60d7777d313cfbb63d8526acacde52",
       "maxPositionImpactFactorNegative": "0xa072463b5208c63f61e70635833da9e17f4c8b309731674dadd4b5ed2aa2d6b1",
       "maxPositionImpactFactorForLiquidations": "0x4c6abc8a7e55f93dbe98925db44f441c8a6d58ae4c30f1c292d2de9be2bacc8d",
+      "maxLendableImpactFactor": "0xc6273fcfdf59cd91deb9fb9686994494903d24a668dd4ad0960048cc817a4723",
+      "maxLendableImpactFactorForWithdrawals": "0x6213a0c14104706f4387d058b9cdb7582e400d89a03dc291fd9340077744d57a",
+      "maxLendableImpactUsd": "0xd790b6460a2b4c13213d3a699653358bc4d22d0e5324cb36d2ea96b7082a2fc2",
+      "lentPositionImpactPoolAmount": "0x90f402d88b7e250c0375c0cd9913c020c63395778aa45a0262d28e8b77d7e6f2",
       "minCollateralFactor": "0x2f63aa6789d2240d4a5aad10ba4b0c0db02e4972c9dd4ab57f67efec5028c9fe",
+      "minCollateralFactorForLiquidation": "0x0665b1af9c69fea970edc0f3ec2b5c6e6319e90749f8f70c60460cd7bde7230f",
       "minCollateralFactorForOpenInterestLong": "0x8854c35c045fa4645e96d74bbd69b2e0bc8404a342aa528d70cdc0c015026ca9",
       "minCollateralFactorForOpenInterestShort": "0xb0c72eb9d2d10ce537aad4e5cd5d143f5b5c48dd97242bbf412e9389771dcb22",
       "positionImpactExponentFactor": "0x64355c2777d71979de9e4cdfbad1d22d2f3c0162f675b37da17c3f912c43d52d",
-      "swapFeeFactorForPositiveImpact": "0xa84ba5835f870711f5395ff91353a8b6cad4f3c91c427a56d5320d1a1e73df7d",
-      "swapFeeFactorForNegativeImpact": "0xd2ef95e30885f11501ff5474333b4ddab4a7c3348404023f250f4b4cc35868c5",
+      "swapFeeFactorForBalanceWasImproved": "0xa84ba5835f870711f5395ff91353a8b6cad4f3c91c427a56d5320d1a1e73df7d",
+      "swapFeeFactorForBalanceWasNotImproved": "0xd2ef95e30885f11501ff5474333b4ddab4a7c3348404023f250f4b4cc35868c5",
+      "atomicSwapFeeFactor": "0x6bce913f581100dedec439ca6a6eaf80d0df49d846242f6f00b0bff1c2a4d493",
       "swapImpactFactorPositive": "0xbcf53b75dc064d05b8bbae7a8a9024400149ad81b3ccfb631fdcda0458c165f4",
       "swapImpactFactorNegative": "0x3dcb45d69a8bf6040e48ce2cbb0331be6eee579fa2332e638f0399c4b36e059b",
       "swapImpactExponentFactor": "0x9e8158dfdc3ab305b80ec742213b82433923bedad9de6c23ef432f9e4dd99126",
@@ -5734,19 +7932,25 @@
       "maxFundingFactorPerSecond": "0xd1c75d99d1e0d55fed811ab7109f61d2a5fc5dc753395161e0a250bb568f1eb7",
       "maxPnlFactorForTradersLong": "0x5178c9558eb7f0e67cb317eb0f0db1bd5dc31e9af20d0431221c62cebd6c0f43",
       "maxPnlFactorForTradersShort": "0xb9d62f806f60de1776cc1a1441f3166ff0f040f1290e9f1edeba9e884fc29b3c",
-      "positionFeeFactorForPositiveImpact": "0x85da364e330c83367e0ff53a8201bc1233422ba6defc548390d2fb6a93fe02b3",
-      "positionFeeFactorForNegativeImpact": "0xb8a86fe041a22eaf0cebba2f98c6dd1a531187f598e901dd6789bac6b2ea7e77",
+      "positionFeeFactorForBalanceWasImproved": "0x85da364e330c83367e0ff53a8201bc1233422ba6defc548390d2fb6a93fe02b3",
+      "positionFeeFactorForBalanceWasNotImproved": "0xb8a86fe041a22eaf0cebba2f98c6dd1a531187f598e901dd6789bac6b2ea7e77",
       "positionImpactFactorPositive": "0x64d7622ed8e794198faf8ca31ceb147ece9c26b6893932e57df76a33c36fcbd3",
       "positionImpactFactorNegative": "0x0fca63fa41ce47cda279cb680774b4933f5ac163bd047f18e91981cc047f107b",
       "maxPositionImpactFactorPositive": "0x3f0459921f4e5e61cb8d446dd272e0bfd9f48cdb07d56369dbbc483b2722412d",
       "maxPositionImpactFactorNegative": "0x0a70f20878f3ebcb0412780dd074651d29dd4e33564801af749ec1b219e3ce86",
       "maxPositionImpactFactorForLiquidations": "0x0c38e8b8f845b3cc6c44e36ddf308aead734dee480d32f423c9e7e77f9b0c20d",
+      "maxLendableImpactFactor": "0x5b88cb66dee6cb5dd91dadb3901d8750fcd4ef4958d904cee1c86a554127e19e",
+      "maxLendableImpactFactorForWithdrawals": "0x2ad2552fb14cf42643c0cd8d117266d5f9306cf7973c8e606b419b86fa432eb2",
+      "maxLendableImpactUsd": "0x223f7aa968e4d0cfa0719b43405e29ecedbc98585b16e36703fb433f3a5c0d90",
+      "lentPositionImpactPoolAmount": "0xfb1d20c5fa708d5d80f340dd72df24d3b3a657a382d8d53b8927da368c88f2c7",
       "minCollateralFactor": "0xd38d20369d10ff1ed3db4eac4f163d02310aedcd18a1d8ffd0e6e3ebb41d3907",
+      "minCollateralFactorForLiquidation": "0xb09c34890fe5881ad70910d4f2f6ea1ad50ef8990deedb4f6bd2a67212024656",
       "minCollateralFactorForOpenInterestLong": "0x09d4ab823430791729510b7468eaaabcb5e8c00f90ecaa1c0fdcffec4c8aaa0a",
       "minCollateralFactorForOpenInterestShort": "0x579b51b3578168574b5541908b2b4d2a82f61c2e826c25afabf9d443e128d5ad",
       "positionImpactExponentFactor": "0x35d0a868df28094966b90e68e435ce14766666913cd4ac19de3d2f6e17f350d3",
-      "swapFeeFactorForPositiveImpact": "0x33a28ad90937883abb9dbc045d6711064d05be93dc5f2805878a0fc4c3847fca",
-      "swapFeeFactorForNegativeImpact": "0x671f1f5b7f0621951ea9fe875c9f5d648343b4f77ed6ade840a32b4caf223378",
+      "swapFeeFactorForBalanceWasImproved": "0x33a28ad90937883abb9dbc045d6711064d05be93dc5f2805878a0fc4c3847fca",
+      "swapFeeFactorForBalanceWasNotImproved": "0x671f1f5b7f0621951ea9fe875c9f5d648343b4f77ed6ade840a32b4caf223378",
+      "atomicSwapFeeFactor": "0x1e07a30854257a03f15d64a12ba476fc3f11822584607c73ec8cf159ebc9684b",
       "swapImpactFactorPositive": "0x780903830a9905f560d95f984e56ca7a535833e0bc89c7c2de42ffcbb432b0c2",
       "swapImpactFactorNegative": "0xdbe58f613a7e4a83dd8f4f2ba745c6bc2a0c8f5d5558b611dbc0d06a12f8d934",
       "swapImpactExponentFactor": "0x6056e3873031dae6bf9c4ca9cc825412671792c122c3ea69a648c5cf3ed93be0",
@@ -5784,19 +7988,25 @@
       "maxFundingFactorPerSecond": "0xff6698495092f6f156e88af5173fb3d86e5c4f0a72e74984b560766b186e2c1b",
       "maxPnlFactorForTradersLong": "0x5c1093d84b01a746d4b8c95544831ac2638da23ddf64e962929c4bfc6ffc7e29",
       "maxPnlFactorForTradersShort": "0x1bc4eddcf3728b1855ea78bebc5b067fbf0de2f3fb75cd873d2e248535dabb99",
-      "positionFeeFactorForPositiveImpact": "0x38dd2ccc17adc9a4c4b524f6bb1a4dcda13fee1268a662f46e935fcb59675902",
-      "positionFeeFactorForNegativeImpact": "0xdd10c7fd407c5f9532e0f265c2c62c58b473945b96144bce0a6a7bdca076532f",
+      "positionFeeFactorForBalanceWasImproved": "0x38dd2ccc17adc9a4c4b524f6bb1a4dcda13fee1268a662f46e935fcb59675902",
+      "positionFeeFactorForBalanceWasNotImproved": "0xdd10c7fd407c5f9532e0f265c2c62c58b473945b96144bce0a6a7bdca076532f",
       "positionImpactFactorPositive": "0xbacca2d52482098f69dbbd12e34d1dd2e74acbc5110dc2a9683cd6cc3daffc4c",
       "positionImpactFactorNegative": "0x9733b0f659b3c23d37f2e2ed58d0bdf22b880057ccefdc4db9c7183bfacebdac",
       "maxPositionImpactFactorPositive": "0xf89e8a9d7805cfff27c4f5ca38fa2661cd2173227d018b822c254d982665680e",
       "maxPositionImpactFactorNegative": "0x43e3fef6d75c28ee36b8f8df12f375aaee95018a1bb6525b40c440a85e40a724",
       "maxPositionImpactFactorForLiquidations": "0xa20e5a211dac98b89ee7dd23830d4fef0b911bc430588d4e4a3ffbb443ef888e",
+      "maxLendableImpactFactor": "0x60ea3fb8c0541347b44a27c9adf58e1d7977c75a12da3231c1f5d99177670b91",
+      "maxLendableImpactFactorForWithdrawals": "0xae7bf691e11f1ada5a403209414a428140d869b9f15bf32c4d8abffb7b4f37b4",
+      "maxLendableImpactUsd": "0x7cca29147821282e9cd61ddbbc45b2989d9a4fab470d277e19af5d91c49df52b",
+      "lentPositionImpactPoolAmount": "0xd18d949138e1a7b7fd3bbd5e09e89ba26ec06904f7a2b1936242b3cdd2c7ab13",
       "minCollateralFactor": "0x28b8c6de3b16af893d3062b3c6dd997355b0571f574d9d3614932a2aee60c2bc",
+      "minCollateralFactorForLiquidation": "0xdf248c72ad94002750220a12ba36fc086656e26676a6700755ba2e70eb3bd3a7",
       "minCollateralFactorForOpenInterestLong": "0xdfad34850b6f15e9790e144784adf3e0dbe917690bb3f58260b5e578ff17e8c6",
       "minCollateralFactorForOpenInterestShort": "0x94ec591967c0c2e8b041b2a28bdefa3b898eaa8cd7752278ac568543a7d600e0",
       "positionImpactExponentFactor": "0xc412266eb7c2ad47ed8f8e8466b3f28a9cbbb8c1a1366f702a948ef7de625198",
-      "swapFeeFactorForPositiveImpact": "0x0e1fd9b3a95146e9c5fa9bf8f76c80ba91f3ddc271c5cb43a2b574fb4150c557",
-      "swapFeeFactorForNegativeImpact": "0x6b9f269680991ffdd1f95773dab02b0962549ff15150976518a739e333c551dd",
+      "swapFeeFactorForBalanceWasImproved": "0x0e1fd9b3a95146e9c5fa9bf8f76c80ba91f3ddc271c5cb43a2b574fb4150c557",
+      "swapFeeFactorForBalanceWasNotImproved": "0x6b9f269680991ffdd1f95773dab02b0962549ff15150976518a739e333c551dd",
+      "atomicSwapFeeFactor": "0xe6ab96eb56a8cf140d345d6f681e1ad4ee5897159a1f571c4b7d81273301acae",
       "swapImpactFactorPositive": "0x59346f9a4a1b766c626faf5a262d7c4682290eafde924edaccf4793b5aaf9ff8",
       "swapImpactFactorNegative": "0x7abecb50f1f40514c8910dfdbe2c77053ce52f786284e6cfbb103935052858bc",
       "swapImpactExponentFactor": "0x67a8eef04a49c1b96d230f1b3113bb32a730fa1868ae6e307b8fe2f8ff5615bf",
@@ -5834,25 +8044,425 @@
       "maxFundingFactorPerSecond": "0xcb59ee5ef3be4bb3dcd75afcf8cfbb66dfae23d6e9f836ac3da808d3fb18afd6",
       "maxPnlFactorForTradersLong": "0x35cf80c1d6ca70828ffd5850a8470b83ed4be705cd4c53d5e31c7a71c13acd5f",
       "maxPnlFactorForTradersShort": "0xb3de355071ca623883ad8e9625132c0af60f04bc5d015b6222463bce1b564dfe",
-      "positionFeeFactorForPositiveImpact": "0x6b96cff86524d5625bd57c852413391a7e705a4c7f4f4510ae95963142243b1d",
-      "positionFeeFactorForNegativeImpact": "0x16ac8268f70816ce91541a0cce16bde38ea509432b182bd8925799d34f35479b",
+      "positionFeeFactorForBalanceWasImproved": "0x6b96cff86524d5625bd57c852413391a7e705a4c7f4f4510ae95963142243b1d",
+      "positionFeeFactorForBalanceWasNotImproved": "0x16ac8268f70816ce91541a0cce16bde38ea509432b182bd8925799d34f35479b",
       "positionImpactFactorPositive": "0x7d619479b2efd31138f8d97c5b621b759c6c66181d9957b2308864289d1d5a3a",
       "positionImpactFactorNegative": "0x525cf3807a5f51ee9eb90b96c15535155064117ca8b01820ac02a7ba105a48c5",
       "maxPositionImpactFactorPositive": "0xfa7f7b8a323dfc202971fc487699fe4182f7bea1e938000a0ac5cdf2e3e4d08c",
       "maxPositionImpactFactorNegative": "0x0f8d93bbcd3913979a10b97c5c35c0ac9422be88b98c33f2a2ac7883626c8c46",
       "maxPositionImpactFactorForLiquidations": "0x631c0c8acda0aa7818ad99ee375e50d8c4275aa073e6b3dc0861797d835ab103",
+      "maxLendableImpactFactor": "0x2a06ec84a62ccb33f287dd45185f7bf53cc99a1f93569c347a3235b9c7627ae6",
+      "maxLendableImpactFactorForWithdrawals": "0x2fbf71e0d4fe56729305f96cabf0114d94bb0f0b6084c580588b4b44a9d492e5",
+      "maxLendableImpactUsd": "0xbd9c23f98d94e6649cb6abe4422a6332e3860e2c52306a711662240d466fd90a",
+      "lentPositionImpactPoolAmount": "0x7e0650a0ea46877b830195e52bead93bf0a89cd861fc5fcea632beb980abcec3",
       "minCollateralFactor": "0x31ff077a89a32edefaa4d80de3855e73eaf6a40cc50f32ebe71560a577c4afba",
+      "minCollateralFactorForLiquidation": "0x5d282deab53e4da440e31d2f5627a9596a180d66855aa39e8afb0fb887459757",
       "minCollateralFactorForOpenInterestLong": "0x5adf64aba368af76710a5ace26141cbcc2d482564ff50ff73428a666445593c1",
       "minCollateralFactorForOpenInterestShort": "0xd44120b8a84afe8d59f0398a652e9af48d30ce0d68ed753e577d4ee474ec59a5",
       "positionImpactExponentFactor": "0xea5bbc31f9ad83ef0b26dc676f4badba0dd7967b8c2fdfaf5fcd6e378541d5b9",
-      "swapFeeFactorForPositiveImpact": "0x3528ea3c107c290c0787944fcffb8dcab5c79eb99749ef137cb4251321c05bea",
-      "swapFeeFactorForNegativeImpact": "0x7f2d20dd6425fb3deefa3d5e2fb1421b98021539f97c248ec897a051737b71a9",
+      "swapFeeFactorForBalanceWasImproved": "0x3528ea3c107c290c0787944fcffb8dcab5c79eb99749ef137cb4251321c05bea",
+      "swapFeeFactorForBalanceWasNotImproved": "0x7f2d20dd6425fb3deefa3d5e2fb1421b98021539f97c248ec897a051737b71a9",
+      "atomicSwapFeeFactor": "0xb385bfac626209fd528bf5ac05da0bca75944b6079274d8edf7de200d6b709b0",
       "swapImpactFactorPositive": "0x7994d0769514a0f8458062cc3ec7ac46e35e61a41837ef95de31499b096f6afa",
       "swapImpactFactorNegative": "0x51498d6010ec706431bb43497559c424d46d5a4732ae654c0f8010ada52e32a6",
       "swapImpactExponentFactor": "0xd0855b4e2c4b463a9d8ef095e149f5f4160bbcf019518d19088398b85d20b0bb",
       "virtualMarketId": "0xba31ac4f17f85fe1d4f13f98606a4d6795476499126baf4091154165b41ba171",
       "virtualLongTokenId": "0xe7ad78f733831866f62141bd25f6d75da98498ad5783721686716dce5043e520",
       "virtualShortTokenId": "0xb315f0a55a09b93c77ef9d370a2278b19027c88ccc7afd8b899b98bb033ffed6"
+    },
+    "0x94cE6F65188a92F297C7f0A5A7B3cAd9013450F8": {
+      "isDisabled": "0x89bcc04282bcd72f274dbbf5c69a218672a3c992739968c54377a846aff11f7e",
+      "maxLongPoolAmount": "0x3188f2dca2e5f3c71df00a93d8c8d3a1e3753fa8a879f3878f5243199a367b69",
+      "maxShortPoolAmount": "0x4003a7a22a73accac8f7962d259bb5771ee8eb59a7112305b153df938bb2fde0",
+      "maxLongPoolUsdForDeposit": "0x75e474aafee5000be82f183609236d05dbec67d943e7cfe146f47fea6d32842c",
+      "maxShortPoolUsdForDeposit": "0x408f7129b2e243d5e659ea97d05c76d4eb0bdc25af291d63942b3725aa4e0e87",
+      "longPoolAmountAdjustment": "0x7ad29bfa54753d283ca13c5eebb287ffa67770d4ac45ed5de90eb38e5fd24d2c",
+      "shortPoolAmountAdjustment": "0x2c51e1c48aa7ee0183e9a810e17ad1a745f129c2716a3b4b7b6937069cdf784b",
+      "reserveFactorLong": "0x23dbce0dd7be42904e2a91abaca8e1047216ba71fe638a21223be900e0eaebe8",
+      "reserveFactorShort": "0xc441cd48637a20b188f4fc9ebea48594bed51eb8aef1257d4f6cd46dc5dc3e49",
+      "openInterestReserveFactorLong": "0x83fb822355b440c8b1509f722733397ced67a7273e1276ced0880de3a363c6c9",
+      "openInterestReserveFactorShort": "0x23b126e49498ac81568aab25e0b8c675c3884697fe4417f7c6ab704538db150b",
+      "maxOpenInterestLong": "0xa6738e0e75f66e1351d631e3f59089f1dffac08e015fba80666731e3b8c3def0",
+      "maxOpenInterestShort": "0xdb557209e9acb4504749b3a590dfa535e2440fb4c0d309f6ca8f5d04e26a86a8",
+      "minPositionImpactPoolAmount": "0x399e109204381ae342b5a49e8bfab7786f7bf38efd6fe637cd7ecfddf52fff8b",
+      "positionImpactPoolDistributionRate": "0x3e4892bbd57899e78063b0d9c3fbf64ac5a6877018fc2196492605665ed15276",
+      "borrowingFactorLong": "0xe64c44664e4c47891d52e67037e0cc550dcbd7fef3b9d87e57e15052f8a9e702",
+      "borrowingFactorShort": "0x8c30ddfc9f7b957106905e0e2c2a85d24b5b25237274482146be4998c22751ed",
+      "borrowingExponentFactorLong": "0xfd68db6e367e61198ae7700e62c0f41d231c3e7690e8e76a30a0407ce339a503",
+      "borrowingExponentFactorShort": "0xe19aa0a3089a9ca63bc36d717a3ca7796ba6f5e80a67f970018e6bc43f35e42e",
+      "fundingFactor": "0x37f459ce8ceed4cbaa4fb55f66ca5a9952b8d05a6e8e406ed30591dc14fc8498",
+      "fundingExponentFactor": "0xb888cf52dfb2a4dca622eb8849006ec145b580c20fddc269fe59bfbb178f526d",
+      "fundingIncreaseFactorPerSecond": "0x0977b1b2de3552728bce1b0298653e7f6bdaf6426d7739d5829080caa8037847",
+      "fundingDecreaseFactorPerSecond": "0x23f4c707e58772f50ffa63d78aae2344259eb4dacb87e3b136db2c2b1a8a8dba",
+      "thresholdForStableFunding": "0x3d18f11bb3c78643b234340317555905fa7444104440dd9a60f8e572269a004a",
+      "thresholdForDecreaseFunding": "0x431801f691f5a4e18605d819ec51de2ee97b030251b2a9e96a3653848389467a",
+      "minFundingFactorPerSecond": "0x83bef73f02089f667467971e42c4ab6c0b86b76b6770ad5bc89eee7eeb89917e",
+      "maxFundingFactorPerSecond": "0x3d879373a6dbc474117188678af6b54c7b754d7349a778a272952be0055cd801",
+      "maxPnlFactorForTradersLong": "0x1d4b3905266555bf208c7e91f0df10c6e90f04866f4c12524c458ddb8e46e544",
+      "maxPnlFactorForTradersShort": "0x8800492fed366a35684b184acff0e9017122a2f1f170d0c02b8687f895deede7",
+      "positionFeeFactorForBalanceWasImproved": "0xa50c13baccb97ab048c4ead7cd94dfe2695883e1d3a197cf448032ea3c93a375",
+      "positionFeeFactorForBalanceWasNotImproved": "0xe4f900a5f09daf553661a9bd0fdae509b97500b0866865182ade55accc608e68",
+      "positionImpactFactorPositive": "0xa6e9f0c5c0b0d06ae6c7277beb6df5fb688e0f4283e201acd07822cf2af06ceb",
+      "positionImpactFactorNegative": "0x52b0b5ca35497485a83e29a44f88bf5c84e307f6279e296af1a81f24d5a108c3",
+      "maxPositionImpactFactorPositive": "0x5d467c9f907e36c18b5409da7f1644855e816266fdc8a8d4a2675737253055b0",
+      "maxPositionImpactFactorNegative": "0x682266750b3120e1ef54690fb33594543a790242cf65f4fa4acb058416de4e08",
+      "maxPositionImpactFactorForLiquidations": "0x6b484552e98fb266ce6eadc47c4f48f3749cd5d2624591a4c6815c55e6d8121e",
+      "maxLendableImpactFactor": "0xa456c783748d386471539dabbf506b9f523aca38e0cd40409d8d9463ba4ab882",
+      "maxLendableImpactFactorForWithdrawals": "0x154c58896af81cac2a2ae567841141398833a5ea9bb6efd0215d0b64087b4234",
+      "maxLendableImpactUsd": "0x310ee4e0657f8fc1c015e019261f7cfaaba724ab6a864d5ccb6789fdde5c5bf7",
+      "lentPositionImpactPoolAmount": "0x05c0ba1e67d6a269ca3e77cee12b3a57df58fc601ecb22b3ca1311187ab37f70",
+      "minCollateralFactor": "0x1adace9e32dddc011e401ada4d5ee58e76ceb2fac5990dac9ff8d1c8d1666049",
+      "minCollateralFactorForLiquidation": "0x013a678abe6ed4cd220abe15c07141f42893af0f2e47ff3b029c01b50819b3fd",
+      "minCollateralFactorForOpenInterestLong": "0x522166a0e6ac5a421bc8346f41d2ffbeace0d26930dbd211138e25646df6b4f0",
+      "minCollateralFactorForOpenInterestShort": "0x7ddb336108bda726fb332947360b0a11f8c33b983801dbbdddd318a9ab55f11d",
+      "positionImpactExponentFactor": "0xad96faefa227e00036c010d351a3ebbcb3ec721b49800ef99607f862b21c281f",
+      "swapFeeFactorForBalanceWasImproved": "0xf1433913b0de4e70f155241c318905ddf54f866c643995a74fc783abba5b5b0c",
+      "swapFeeFactorForBalanceWasNotImproved": "0x072e62bab56c7ea4e91c5ecf1e66732e65b6a95d193631133a001763b30943c8",
+      "atomicSwapFeeFactor": "0xd44cce6933c88884874d99321734dd2823da1495a6bea0020272a18028cf4b9e",
+      "swapImpactFactorPositive": "0xa9bdf476dc12be080747e58c4aa34606357476853c4dc0e1d805569a12fb9bc0",
+      "swapImpactFactorNegative": "0xe62da899f3cd8b0bb237665e81fa32f29cf80a4952c3756a33a3b8fe15c27023",
+      "swapImpactExponentFactor": "0x049d9cff2da901aca1737a4881a54b31c685dc4235e9967f04a5dc4e7864a27f",
+      "virtualMarketId": "0x01ac8acc7ef4e6616b090638328c05814c2ce047f4f286659cca62cef1b6ea7d",
+      "virtualLongTokenId": "0xe7ad78f733831866f62141bd25f6d75da98498ad5783721686716dce5043e520",
+      "virtualShortTokenId": "0xb315f0a55a09b93c77ef9d370a2278b19027c88ccc7afd8b899b98bb033ffed6"
+    },
+    "0x1cb9932CE322877A2B86489BD1aA3C3CfF879F0d": {
+      "isDisabled": "0xebb33910cc4646a1348ba2f11609be1151bbfafe0412fb715a73e588ac29914b",
+      "maxLongPoolAmount": "0x5ff8bce1bed99b5c273875c3dbcd28ee26feafb046e26a855b803661b4bdb97f",
+      "maxShortPoolAmount": "0xc26afbf2f4e8d85b0a9a999cbeb4f284c87b39b0e954232ae34c3491dcc61afd",
+      "maxLongPoolUsdForDeposit": "0x9ff0a95b59709ce6d515976eca41fff1292a84e433116a84b3494c48b11496c6",
+      "maxShortPoolUsdForDeposit": "0x704a285a990b509401113105670a4c435ab1fa240401686df9d67ae6b7db7eb4",
+      "longPoolAmountAdjustment": "0x49879369b77157be34710fef2eaa0ede22035c918aef0ad65deacf6528a1d520",
+      "shortPoolAmountAdjustment": "0x3bd91678b05f5d0c2964ac7271e30d3f84ddbfe51edddb5f4e6dde31f0fe7272",
+      "reserveFactorLong": "0xe6c9e7c85bd0e3e736658f3345b37b78d1928f90476c6aa62f8f2720981d35e0",
+      "reserveFactorShort": "0x7d03f9a854a7863b0f453494c09e00dfe49d4a3f1f95e1a1032290ab4beffd6c",
+      "openInterestReserveFactorLong": "0xcdb1fbc15fb31317c67d7e5daf45b9ceacf7ddb98b14c4299e3e8662d2bd287b",
+      "openInterestReserveFactorShort": "0x1f067e254be72f970ed9861d074c1543d28a96e99a002f39303ae5fd946b6ea2",
+      "maxOpenInterestLong": "0x20973c87f04907259e8568681963227692f1b1db2f502d6995b4bcf7dff88532",
+      "maxOpenInterestShort": "0x3fa04bb2238063f1a9115d9652850198a9c820450f170d7c1fab4ef42e5b9a40",
+      "minPositionImpactPoolAmount": "0xdd3a561b397f8a19c2de9a1362a1f555bf40aebb208bf45c5b6b2ac64c316e77",
+      "positionImpactPoolDistributionRate": "0x16744e5a5dd1f0b976e6d0cc7df79f95db83dcdbc48a374c925585bb965c28c6",
+      "borrowingFactorLong": "0x8dbac26b6818e424199721529b4e8c01272db6e3830dd46d3cb7430d78d3dd97",
+      "borrowingFactorShort": "0xe785f5992f811c5f81f01e17bd2b2acab5678e760e999144711bb0ae9ebb2d89",
+      "borrowingExponentFactorLong": "0xa5d0f2f588277775c7160b9418141fb1542942840fbda3dac5ef6a64068d5d2d",
+      "borrowingExponentFactorShort": "0x43af59ddd8e7a8bed3b72f0835c24f96f76a357d04632cf651c4d1ee0d427680",
+      "fundingFactor": "0x15a0b8b85c1b09335454dcf6bc66e30317c05c1a50a587ee6790d914559a5b01",
+      "fundingExponentFactor": "0xbcb87b1d2221861ebbb6fa9094f41368223b372c82c137667128e546e2bcbb2a",
+      "fundingIncreaseFactorPerSecond": "0x06930e060368f57b3a5d86b611df385915b9c9fd48e7d4c8c6f755fa77cb7e69",
+      "fundingDecreaseFactorPerSecond": "0xf83258deaef338981e643902bae707d5e8b1f5e3667be93797c03ca62e8314af",
+      "thresholdForStableFunding": "0xcc645ae68cff0354eba0aca8e88e28a5fba454d1896b9078148e71ce83838710",
+      "thresholdForDecreaseFunding": "0xe3dada9aeed254e836571c90e5fbefe7193edd8e4b192803956bacc7c3354483",
+      "minFundingFactorPerSecond": "0x53db165ed21ddee62fe80c1e3294d6e1d0c7735bbd5cb28d7a524ae4c5d6cdb4",
+      "maxFundingFactorPerSecond": "0x922d22f5c836407b0e6598d97e15bb1467b56baecfd92252609d89ac7e96b1fc",
+      "maxPnlFactorForTradersLong": "0xb4c68d724a87d5a9c03a4a9e5d3995fc61c739fd84e4a3e801832cc728146c1c",
+      "maxPnlFactorForTradersShort": "0x5dcd66f5e69165e960d98b19738dc8a94a7413aebed63646b4b1e7441d31a309",
+      "positionFeeFactorForBalanceWasImproved": "0xa8a06286cb1ac7016c8d61942faaa1d01e9bece42c91a94247ac1e0b8ab17bda",
+      "positionFeeFactorForBalanceWasNotImproved": "0x4f68937dd4e8bff1f3aff6fc9ef65f267b94043df95ee1183c79017f6bc08f4a",
+      "positionImpactFactorPositive": "0x628747b7ea36c03c715679b7e5be27d09af22fe981219ee78028a6195d89cc73",
+      "positionImpactFactorNegative": "0xe02ae0e4c24085d1dd80048e57f8813dae079e0755317a180bf6bb94fd0a296c",
+      "maxPositionImpactFactorPositive": "0x11cbc1097e6145a45474802d2a3941f9a8d2c2799919776d7135c4ee6a2c342b",
+      "maxPositionImpactFactorNegative": "0xb3b742e1b3c41999c71f83f169e2099192cc3f74b73e7b4d93e8cc57b2a8d51e",
+      "maxPositionImpactFactorForLiquidations": "0x2b2f263d11ac199b1f04074693e18eb7683cd69b0a84b1aca24a3100a5cade60",
+      "maxLendableImpactFactor": "0x8446555b0627703d8d897b2c32de98236b4bcc4c41745250e942f66041ca38bf",
+      "maxLendableImpactFactorForWithdrawals": "0x0cff63a42fce9d44f2b48dbb68ff4a2c78c103f2b29c8a4691928f0d332998fc",
+      "maxLendableImpactUsd": "0xd6760aac54bc844e7bba6e45c8bbd5bba1b2698ff5a1375b933416ed853bcac2",
+      "lentPositionImpactPoolAmount": "0xfcb97c2fc9eb0f0dcd0efb805cb53f4c4379be78cd5640693ab02c3170c28b32",
+      "minCollateralFactor": "0x444e84c476c7f7be747d938eedd174a127275e0d02612a78a4e1d0cf8e624edc",
+      "minCollateralFactorForLiquidation": "0x83daa2393cc33b7dc64c5de46d0cedd412df54fa451b2fa796d3a3afffbb343a",
+      "minCollateralFactorForOpenInterestLong": "0xe14af2de5341f4d7ada010da66eab444c786f294634afe829fd59115fde1864d",
+      "minCollateralFactorForOpenInterestShort": "0x0ab2e46e7d989cc72c4f04653c04ebef18615b5205bd1210df620a0323bea279",
+      "positionImpactExponentFactor": "0xcc448f832f38a53c72b3a20aad711d94f1319608da95e6345e955b5d1b022483",
+      "swapFeeFactorForBalanceWasImproved": "0x4c14a9f8f2f155359a7b7f2d521ab42355ef06734ae9cecc66913d8a914f3c7e",
+      "swapFeeFactorForBalanceWasNotImproved": "0x7a69ad6d42cefe157b1592436c7133cf9b656fff0c34ed1397148257e979cd95",
+      "atomicSwapFeeFactor": "0x271e4c35276904d2fd9051c2f2b9870deccf2afb45a614adf9a73e296ee62664",
+      "swapImpactFactorPositive": "0x9dcf486ab9270640d6a7f168059824daa74d09bb72a40b7c0edab9d7fe20b5ca",
+      "swapImpactFactorNegative": "0xe678e975c804127c9fa120ea3f8b70364d73a50e51e0cacfa25c99986c15c3cd",
+      "swapImpactExponentFactor": "0xba375b0cf4c9ea71ac0d50044be9059bdb533ca6211951fb1aa89cb114acdf8b",
+      "virtualMarketId": "0x362fa87fde70f1c219b43817f05453f32571be142fa68e587a14975907a9690e",
+      "virtualLongTokenId": "0xe7ad78f733831866f62141bd25f6d75da98498ad5783721686716dce5043e520",
+      "virtualShortTokenId": "0xb315f0a55a09b93c77ef9d370a2278b19027c88ccc7afd8b899b98bb033ffed6"
+    }
+  },
+  "421614": {
+    "0x482Df3D320C964808579b585a8AC7Dd5D144eFaF": {
+      "isDisabled": "0xce6c0c2ecb98c1d352f3d852f960de84f48fe3867311b66232f955f673daf585",
+      "maxLongPoolAmount": "0x89492e9183bb65131fe32ce8973237cc253240e3060139aaacf9acc66925862b",
+      "maxShortPoolAmount": "0x73e597a69c0dec119e8916093d87e7b56b82ac29ab3667e27826914aaac30e05",
+      "maxLongPoolUsdForDeposit": "0x23edccb6911ee20b6d0c59789f3d5d26ff32d25ab07cf85caef8771a97967e11",
+      "maxShortPoolUsdForDeposit": "0xbf814f0e5300854973f384039fd287bd514ffa3b9ad15b34dbb4055bbb723d44",
+      "longPoolAmountAdjustment": "0x6e636a8f0e2c668d0c375828110389a372d135cf5506a1da74711575022ccacf",
+      "shortPoolAmountAdjustment": "0x73661373813516e3c79a1efa7ce587a977bcaef5431403dcfa8cf8bac85ce6a2",
+      "reserveFactorLong": "0xc03afcc033db8b33bd7107271906b4e39162e08e1d23d18b2aa6279c6b221e1a",
+      "reserveFactorShort": "0x1e584881c18b1459848bd91c6d6a36e54ef1a5a3c7226108bef84ed92d677643",
+      "openInterestReserveFactorLong": "0x158bba94013f63393566db1ea024c4720b90490c3a5740d4cbc504fac98e7bbf",
+      "openInterestReserveFactorShort": "0xc3f27a9edcb2e8b48b7bf88d85c2fa8f9da26558b6093b64adf5bc14c6c08408",
+      "maxOpenInterestLong": "0x943e889bc8173f5167778e26ae6eb80919379f909bea0a6d493b60789ff6bc88",
+      "maxOpenInterestShort": "0xca567f7e9b277f4b2ed73a47d3bfd9da23e95e2b0d37a09ac569818549155384",
+      "minPositionImpactPoolAmount": "0x8cc53d99aed3a213348d20feba316a35eb9d75efce7e3ae404a67436e579807e",
+      "positionImpactPoolDistributionRate": "0x4a56e82278b786ff671b2d5807e93e80279b21d3dc7ba76580f02987491fa84d",
+      "borrowingFactorLong": "0x2ea60a18c06414c07b6868f255344cd7af7cfda122efbcbc5e53c1d7fc35ea86",
+      "borrowingFactorShort": "0xd10f6aa6241a18645103b03f01ce6f7f622049d8419492055aa2a54d007ab877",
+      "borrowingExponentFactorLong": "0x58510b24e1be2d1be14c874e3c4f90672f8b2ba0b6cdf01d31f74805c7b686d0",
+      "borrowingExponentFactorShort": "0xf518ed27048895476ad4c1739a4b4288fbacbe291befc9bbda662828db1d7d77",
+      "fundingFactor": "0x449c0b68dea79628b772625526bf9ad7612d7bda5ee9f1151b93963aeea27221",
+      "fundingExponentFactor": "0x31e83d07a65d45c1f7b0de4c4a1edf381b234e12877789a8b2a06807896c2ac0",
+      "fundingIncreaseFactorPerSecond": "0x7ef9fb923e8d5a0ebaad6bd6b382643fa9bcc2a2d209ef40400e6d60f384f6f2",
+      "fundingDecreaseFactorPerSecond": "0x63b7ed3470036ab1f94ee0d411eb6be5be422f45ab93d60900e38d4934f026c9",
+      "thresholdForStableFunding": "0x8f737a9a7b2ca376fd6210689f39567605ce3bb3a84e545c73d954309be7df59",
+      "thresholdForDecreaseFunding": "0x258e7b0d5ed47dcd083c082cf1538b6fc6d986d7809b0e6d508aaafc51e0e370",
+      "minFundingFactorPerSecond": "0x51cd017d8401cf5dff31636de9d78fa0135ec22804086c2709f27ada08ab479c",
+      "maxFundingFactorPerSecond": "0x0819314a7a0ccad3addec63a8f871db40c19a9b95e1f63615a8bba140630f8a0",
+      "maxPnlFactorForTradersLong": "0x9d4b0bc82a0b1b09075ff804cad8c941e6ace3bb074724d30bba974ef8cfc11f",
+      "maxPnlFactorForTradersShort": "0x9574252828683f00a80ad5ae60eabbc8df2d88e20b58052c1b1fa376af11c838",
+      "positionFeeFactorForBalanceWasImproved": "0xb78c4d36b9d748c770c1f5d4dc131819a12adefe3d8f9473dfecc038d5b28eae",
+      "positionFeeFactorForBalanceWasNotImproved": "0xf7858fc955e73874ac18c2d1a0a4171a522f70de0d21d96cc55cbbb4ac31846b",
+      "positionImpactFactorPositive": "0x679f24874d8b50cd1b92b812fcbcfd224c6c8e817c7e0beb59ba85b90b2b07e2",
+      "positionImpactFactorNegative": "0xc97668cd423c1910439b16141588f37f5300f570dcfea5e8d18b72c9ae91a2ba",
+      "maxPositionImpactFactorPositive": "0x195d5103e0b678fe18962202af5e0f7d23f006ff5d6f4251507fdc33b0904322",
+      "maxPositionImpactFactorNegative": "0x2d7f0f5d04c19fd9d7f353e8f51112370c9797b3cf3e47df3cf405a8f984a6af",
+      "maxPositionImpactFactorForLiquidations": "0x0f49be714a6c0867808bd206252d6923e950915118468a8abe497acb9d266093",
+      "maxLendableImpactFactor": "0x022ad3811d7b7d91bc080bd3301809fcf2f2d81a8038cc01dd3055b8eb688620",
+      "maxLendableImpactFactorForWithdrawals": "0x19d6b24c84ef3046336297552cb5a0d5d7bb5b7b7d08fbaa16f0891be5cf1209",
+      "maxLendableImpactUsd": "0x99b21d3e9498dee8d5ac721b3ee663996f73b5c396afff9e8d85a398cafed053",
+      "lentPositionImpactPoolAmount": "0xf989959db1a04a0704266024f6d994121f3e33842c9e7d51dda04dce3617b029",
+      "minCollateralFactor": "0xc8ac65a0133369e799e6bf3c2643209fc8999c2bcff00259d9627e16ab94df40",
+      "minCollateralFactorForLiquidation": "0x5f1772e6791b6c0a69b330be106779748f3a9f8d283357a42308bcd741f65989",
+      "minCollateralFactorForOpenInterestLong": "0xce4c8aa0201126eed98457458fc4d149dcf4493dd67f019fba0201d31699ef29",
+      "minCollateralFactorForOpenInterestShort": "0xec53e2b4c748d71f93a22d19be42e483fb467de3da64e08345bfe07b46cf458d",
+      "positionImpactExponentFactor": "0x86e444a2a7d73b6e45ce3d479c088bcff698e43838ad15450330c9c9eabd8529",
+      "swapFeeFactorForBalanceWasImproved": "0x582396506dac5a19c1f0d1830190c86cb1806ffa2f7fe28ecc2fe43355a322db",
+      "swapFeeFactorForBalanceWasNotImproved": "0xf591bff2380073f41efc2642b062009ea4f5a8cdcefbaed5d8fe46b94b228acb",
+      "atomicSwapFeeFactor": "0xa3e865258a0c6c558a839986f79a58c226474df4d8361461925154417547351d",
+      "swapImpactFactorPositive": "0x4ba7599baa40e9165e69982d1a27dcce324f52f09654b8e59a50aad15bff499d",
+      "swapImpactFactorNegative": "0x7f4945cb90820690df92a26203f54d6dec3444276801e77b49ad6ebcd60792ed",
+      "swapImpactExponentFactor": "0x2cf00a0393c53a8d1adf7cb3a553d29a0d8e951cdb793e24e891264f37a252da",
+      "virtualMarketId": "0x1c5f558f016365f8662333fd181132c33c50ee0bf4947fa83fa9e776133da025",
+      "virtualLongTokenId": "0xbeb8096910fd4d4b3ade12aad31c27a0e5f047fce87d1279b0c71579a8c4ef5b",
+      "virtualShortTokenId": "0x14f396b003aeaa96ad78845dcb7d6d9789c777a23d4ea1e14a7dc58704a595b3"
+    },
+    "0xBb532Ab4923C23c2bfA455151B14fec177a34C0D": {
+      "isDisabled": "0xe1e304a1d3f1b7aed5d7643887746b17682425b7b06073c08a2054e8b5721b9b",
+      "maxLongPoolAmount": "0xd695cb6384004da9658032d6fd69874a10da52bb13a19813f816a0d14b0f719e",
+      "maxShortPoolAmount": "0x4f0f32930b9a140ba510ffe0ce2d85cd60848909bfd7efe19b1aafefabc6838d",
+      "maxLongPoolUsdForDeposit": "0xf1d19ed404ec9744adb4ecaa5940d32a5d44635ac1089b2aefb9aa7f95453c6c",
+      "maxShortPoolUsdForDeposit": "0x440eab273a4684158d163843799a346464e5ef680ff01e5b43b04bf399a97f53",
+      "longPoolAmountAdjustment": "0x053bfc751b03d34819fd9d82af904b2b15ed4cc1bd2e82f6c3e822c26adc8b1f",
+      "shortPoolAmountAdjustment": "0xe85e5d6ddf933f1b269729cb69eb92b0f5485426b304ed17f434f00c6156d2ca",
+      "reserveFactorLong": "0xf865e3c8dfebcb3953792a6f4a52185334b12bfe1208957f13a13476c6c3c549",
+      "reserveFactorShort": "0x3a491ad6e5b0c5bf1147255d18a85301f651c2fc798765cf7eb593631637a867",
+      "openInterestReserveFactorLong": "0x757d9ede69fb1f95303e4885b813c08dc5ee4a0bd34f724dcbd4f09d3c06be38",
+      "openInterestReserveFactorShort": "0xf79421e69bda7c2e7dff57266b63a20c15c96bdaed1756b2d87d74d1fcbda7dc",
+      "maxOpenInterestLong": "0xc7a7406ac715c249cc6016b5ac35f34c9f143e496cde8fc7c78a415ad75ef307",
+      "maxOpenInterestShort": "0x1c454e6ab21509639ba236901f551b98222da30388556533873707431ead0316",
+      "minPositionImpactPoolAmount": "0x564e14b2100c4184ee92a21091b1434c3cb8447cf8d721fa7b1fefa59fcfdfba",
+      "positionImpactPoolDistributionRate": "0x9a93fa9f6c680c28dbe9c02e2a479caa6444c905efcdc178aa14be5cd057956a",
+      "borrowingFactorLong": "0x93a3842e312fddb0563ca982845cc0a738286f9a983c0b7cc9b3d00b4d2f20f6",
+      "borrowingFactorShort": "0x32556229ced23871d8328779aeecd80e1aa21dfcdbf9d1d9335c69784547a861",
+      "borrowingExponentFactorLong": "0x8aaf9fab3ed2dd70aa8dc71bf8325444c61d5917a07a9493ab268496b6dc5218",
+      "borrowingExponentFactorShort": "0x76c8c2f2169f8feccada373c91fed5951fd4ff52b103cd6df0417d1d3e1d5ac4",
+      "fundingFactor": "0xdf254aacf81fd1ad398184e3d31cb69698b081e03bf71648523266ee6f99f3ee",
+      "fundingExponentFactor": "0xa1903f654de2aefabb3301853f73cdc88b1de1a50b4fb5bef2b1e129bd62c9c2",
+      "fundingIncreaseFactorPerSecond": "0xe704c715f69ff2f8a5c5f6767ff32133e0aa5dc28485fe338684e2f0d85c5ec9",
+      "fundingDecreaseFactorPerSecond": "0x864dce8a9dbe818c77ce0d6a17d237888ce66e92f4538b69d53158782f78d90b",
+      "thresholdForStableFunding": "0x8df13680577c7e74b9754f433fe72dfe0cfd9913bcd887646868c6f4aadb0d44",
+      "thresholdForDecreaseFunding": "0x503de8950935dbc45b470350b5f7a0889c597228c0deb43e95c15f23d40106c1",
+      "minFundingFactorPerSecond": "0x8c86c3a2ee160ec9bdbcddf59f26c11376125ab8051fdc0ecb633d41bb848ae6",
+      "maxFundingFactorPerSecond": "0xce11facf77fb82e1a1d1845d38e100ade11aa7ad61a90c9920dbfb43b527986b",
+      "maxPnlFactorForTradersLong": "0x791e3a1f749906ac461b79c011bdf0ff8b232095ccd3223f8ea223de91a24464",
+      "maxPnlFactorForTradersShort": "0x3f33bb1ca09d93e827e72241e157a0ffe823c79f199160c3f904b044a4fa20a0",
+      "positionFeeFactorForBalanceWasImproved": "0x08438db6daa87a913feda631f68759dc6ac09b740d7a98ce4c49c9a1538dc1f5",
+      "positionFeeFactorForBalanceWasNotImproved": "0x613d88324299f23d8454f412a02f35cd3dc73e707a7eafe7cd59c01f11b73536",
+      "positionImpactFactorPositive": "0xe5d4228737565bb87aec9a167b07ca264620d828db9ef79990c54ffa971af118",
+      "positionImpactFactorNegative": "0x8734f73a31d38410fb1ad685c661c108f81088edc5eb4b5d2bb5c80f5a2fe662",
+      "maxPositionImpactFactorPositive": "0xc0298da5a9e2deaa3cb58fef159a83d6acd73199e529486e390d8954d805d54e",
+      "maxPositionImpactFactorNegative": "0xc0adebdf41a6f30c0a33e801dfe4441bd35a183f3a78a7799831c978f222fd42",
+      "maxPositionImpactFactorForLiquidations": "0x71d401a3103b3ad15f7b3bd545bff45fd3e911b15a372869c7da887e570b2ca7",
+      "maxLendableImpactFactor": "0x7b6fddaaab7639f429fe405d397616696bb906c4be231cfb1c4d7e236562c50b",
+      "maxLendableImpactFactorForWithdrawals": "0xe556b79a93716a37cb4b0a756f9742dcdadef058d74a812d65ae62ae59a89e54",
+      "maxLendableImpactUsd": "0x9cfe20df3a4b61875138447ee723fe49dbeb3527295e022c21c020256c16ed3c",
+      "lentPositionImpactPoolAmount": "0xc4308a48266b27dbd2e69834596e4a81c95624603602246bc55fb30d0eee0b0b",
+      "minCollateralFactor": "0xc71123704a2c87e18f41f95e892d2e27ce8da0b6018544ae460f48f8f2144ea4",
+      "minCollateralFactorForLiquidation": "0x7992b22e42f8e8f71ab230265b54505134806d370ae23ea1846b52cadd750028",
+      "minCollateralFactorForOpenInterestLong": "0x06dae7e677152cf439b23a94671cfe2f632bae0a0eb85f52610742b73280818d",
+      "minCollateralFactorForOpenInterestShort": "0xd2576f0cd21f4f8b4aad0b77571a8f5288935a3a461fd9531f47b73aa3bff01e",
+      "positionImpactExponentFactor": "0xf44a08bc5690d4fd32f6b9bfe2deabee95b4ab4d36c368b22e428736451d5786",
+      "swapFeeFactorForBalanceWasImproved": "0x334cc9b895850a332fe44e9e2215e5112afe286f0299655afae72b50c7eba86c",
+      "swapFeeFactorForBalanceWasNotImproved": "0x6fb4f892d73acfa2c61cd7ff401e7cfb10eaa3de07ef7c585307b232ca95a17e",
+      "atomicSwapFeeFactor": "0xb41252535f4ea1933db20a160f99b2b369e7a3e96ed58e8fc69fd023555b859e",
+      "swapImpactFactorPositive": "0x8c6991810b91663028e92da492838890535b045f4f6315753142a6587d3ea2aa",
+      "swapImpactFactorNegative": "0xd61daf7708276f38ea49e14d3a708747b70aae2748be4082f230782a1bc144cb",
+      "swapImpactExponentFactor": "0x73e3ff3cce5475da6d435335f98d7ebe12eb4516f82fd00d562baadf4ebda69c",
+      "virtualMarketId": "0xff3e25d5b26afce16c7292fd6816d955cd0a6a9742ad9ebbf9ead33b13cba441",
+      "virtualLongTokenId": "0xa05108a58d25332e075fca49149dbb671f4b30a226a3325bb46f83000c50ff11",
+      "virtualShortTokenId": "0x14f396b003aeaa96ad78845dcb7d6d9789c777a23d4ea1e14a7dc58704a595b3"
+    },
+    "0xb6fC4C9eB02C35A134044526C62bb15014Ac0Bcc": {
+      "isDisabled": "0xdaa260175fc3f2932edb37457d62afbba94e495ae740be393a2569cc8670c4a3",
+      "maxLongPoolAmount": "0x029c5ecbfd780378e675cafc59b47fd5e3ef6630ff03c439636ca8790d93c4bc",
+      "maxShortPoolAmount": "0x7bae869049b373441b706e5d0b2a33a9b2d4e0184979a351eca28b60619b4f91",
+      "maxLongPoolUsdForDeposit": "0xc305af46daf38d80f9127a6def8abaf570059221067bf503a8809584120a2efe",
+      "maxShortPoolUsdForDeposit": "0x7b2ab53e2abd85166f2b560c2be6a436f3729b08287ffb5c56c2a5f2ba94ce73",
+      "longPoolAmountAdjustment": "0xf418c257ae268296149111ce163e06e66945126255cd037f59cd5d6dddb6e089",
+      "shortPoolAmountAdjustment": "0x20bc0492e7b97586507d1a3108a78b318f93f77030adbc5c6f1d216b0eb222d2",
+      "reserveFactorLong": "0x3d83ecea80d42860f999b5e3501e112306785a87eeb79980e53c5215e9001d5a",
+      "reserveFactorShort": "0x1e3cf27d5f83c080630f18638b39fa7c678deb87255a369cff61ea2d36cdda9a",
+      "openInterestReserveFactorLong": "0x791344e59f964cd52f723720d8adf00734c78d1c800b9fde2cd914aef015fccc",
+      "openInterestReserveFactorShort": "0xa5f56aca5e27195eb038fafad73fa921826a18fa420a871de46b11ceb8696f69",
+      "maxOpenInterestLong": "0xb262f616cd0572f778cf40bb4f0e11e6bf6fba3e9300926e2447af1aec2b9bb9",
+      "maxOpenInterestShort": "0x0176e54af2e994b745420ba7fa25ab45f50ba2d8c305e7190428f3033d18b070",
+      "minPositionImpactPoolAmount": "0xcc2a1b60113f0e4a71402867f8208b3e82ded6bdf8acc6adedb615719d60389a",
+      "positionImpactPoolDistributionRate": "0x1a13050d1468415f41e69de49acbc2d0275b1ee850f7f758a6e6da60d2a424a0",
+      "borrowingFactorLong": "0x684ec359bbb20b38cc68c14764059e247d10e57bf8f811aa07764a76822a9c73",
+      "borrowingFactorShort": "0xcba31ef808fb8aec781dac12ebeac89b87f89150a61344ec1075600a2d27d009",
+      "borrowingExponentFactorLong": "0xf9560f411ad15f579e9dc0d6ec2050ec2f1a11403d18150da26a9a9db48f5a36",
+      "borrowingExponentFactorShort": "0x9d5e175fefb1ce684b2cbbcbc4842964653e1470b2d4adfed5f1f2e9dc80e0e7",
+      "fundingFactor": "0xf28f1e92a1bd7d5222de7498f0a8669398873379f41cdf7d5eae1516d11b15c3",
+      "fundingExponentFactor": "0xb0e50976650b897579520a624f9cab363dd9e83f5c266edab538a04446788b45",
+      "fundingIncreaseFactorPerSecond": "0xd40ad820903d0163f728e33f551f31987fc76b3df0359c85815ab7d6fa01a408",
+      "fundingDecreaseFactorPerSecond": "0x47ede55ce51489b89afc372137a61c2f2a15a4836a5dbfe046aa25a133fec5dc",
+      "thresholdForStableFunding": "0xd86bdc92e1db208733dc5d54e3e04f9019cacbba1f5ef05003b73f47e1a65ec8",
+      "thresholdForDecreaseFunding": "0x973e02f4734aeadfdefc4835d5cbe77ef8d89d6d8984e7003f60584c6fde8869",
+      "minFundingFactorPerSecond": "0xa8590be469f5c8837d446b480606146ed14a04b899b248a02283b65c9abd736b",
+      "maxFundingFactorPerSecond": "0x644713dc4b6f15531dc82bd8fa0c2b336d9716e8349f7db4701a4830249d42a7",
+      "maxPnlFactorForTradersLong": "0x639651a76cb1ad07aa38a5ec8812acb51a72e9248b16c9be0bac98d77bb28d6c",
+      "maxPnlFactorForTradersShort": "0x09b5b7da1228e5261a6568813661c1900086468b3e91ee6432ab559494632358",
+      "positionFeeFactorForBalanceWasImproved": "0x643470e54ea2759137d583e66023c76b481580c1ccfec2b0dd4865bb25fe74e4",
+      "positionFeeFactorForBalanceWasNotImproved": "0x6ff5e45b14ecbb02605d082c9e60e11d651d67d98a81cd36decb594652756325",
+      "positionImpactFactorPositive": "0x45adb3e26ef4f16dd148363c8e7bc917a28eb43db6f3a5116a8ea47ab67ec82c",
+      "positionImpactFactorNegative": "0x1f1874577913939d4f58e13c84f59296ca4a74a0dcd7e768292435ea7d1c020b",
+      "maxPositionImpactFactorPositive": "0x8bf288bd429a21ec0e505a4b76fc46ad8599a7cdd7acf412e703e05cba852e15",
+      "maxPositionImpactFactorNegative": "0xee5014c8e6b0d317afa6dbf3ad0512046c5352ebfbc9e2c5bb8b194b9584a2df",
+      "maxPositionImpactFactorForLiquidations": "0x5fc79117f4e9b35419d2f5cd17f558be6f5c080156f3f80ccc26bbca8d57f574",
+      "maxLendableImpactFactor": "0x9200212f010b5dd1abeb243eb2ac086d9bbcd93551d90e20804aea6cab322b56",
+      "maxLendableImpactFactorForWithdrawals": "0x7300e17fa70454eb385939bf4ec80163beddeaf3f354790ef94aed9dc4c13d10",
+      "maxLendableImpactUsd": "0x280ea380e16eb78606095ca2ddfc82434fbec454e9779085a9d7163e8d951f8e",
+      "lentPositionImpactPoolAmount": "0xf71e037f8855a3cc202629a9ae07d8b408ccfd58492c038acea574a2905c18a0",
+      "minCollateralFactor": "0xf7acb321f5990dbd2bf54ddab8e7426f8c045dd4be514bb56b519748395f3cb5",
+      "minCollateralFactorForLiquidation": "0x9a87fa7bb6705fede532152e983195af8bf8b86ed9b80c87ea22dea75b961c3b",
+      "minCollateralFactorForOpenInterestLong": "0x6ed33823024e228a1e472abbb2b3101ade60d23a6a6039ce31db1558d0954430",
+      "minCollateralFactorForOpenInterestShort": "0xfdc98985190bf92f5a5f4972db27fb5b49fc365e3ec3c65a608cce7ff01a0528",
+      "positionImpactExponentFactor": "0xf540790997b084333a82f882ae86123e74b7d3ca7f5100a87caf8c87b00cd336",
+      "swapFeeFactorForBalanceWasImproved": "0x6acb142cb77be26541af1bf784495cd07034fe9371c95a45888cac47bfa4dec9",
+      "swapFeeFactorForBalanceWasNotImproved": "0x7993bf7ee942df132ca439a415dc24b3a0d37f9d966e7fed424621f22e08aff0",
+      "atomicSwapFeeFactor": "0xc46dff7dcd179b6c69db86df5ffc8eaf8ae18c2a8aa86f51a930178d6a1f63b9",
+      "swapImpactFactorPositive": "0xc837e4fd08a4075186e2247915ec7e2af6fcbe68d971d312379a2ede79efc8bb",
+      "swapImpactFactorNegative": "0x5784a907a885c68e0ded4e2c68ae06e3ab0072a0718afcaf89a77d08b1a4bf80",
+      "swapImpactExponentFactor": "0xaa5fed51d9e41d58b45b18df3f2d05b427613e1b04f4875164ae6612d4dedd71",
+      "virtualMarketId": "0xa3ef6bfad330ae40521f70558f2fcadca93725b8acccd3105366e422b829692a",
+      "virtualLongTokenId": "0xbeb8096910fd4d4b3ade12aad31c27a0e5f047fce87d1279b0c71579a8c4ef5b",
+      "virtualShortTokenId": "0xc4ab6a4bf31c6daf14b4280e1dca54edfcb90a85aff3598cfb550dbec25f7786"
+    },
+    "0x3A83246bDDD60c4e71c91c10D9A66Fd64399bBCf": {
+      "isDisabled": "0x3e73e8e5da5a2c49d99343e753feced56b56dec5149a80c9d12bfd6b6b14c179",
+      "maxLongPoolAmount": "0x6e8305d27641f00d5ee2dcd51756cffc715f0c070b569df60f9d37748e557f7e",
+      "maxShortPoolAmount": "0x47bfc249d865ba3e7fa37ddb8c08894ef35219d700e48f5e50dda68c648415f2",
+      "maxLongPoolUsdForDeposit": "0xf88824613fd584bedde59cdd654ee7ddfcfbd6fca9fc0301262bc7fe5b02f212",
+      "maxShortPoolUsdForDeposit": "0x077b2bb0dc1a1b11668dd4fd319ea2f662a90d349bcb5c47dd98ba0b3b784e92",
+      "longPoolAmountAdjustment": "0xecbb2f82fe5330278cf6047f74ed37a560d524d55f17c7b01916dd7420049f00",
+      "shortPoolAmountAdjustment": "0x2cf60c9035291dae87a44b7598e8d283e74ca470aed7cefeabefbb8049445e71",
+      "reserveFactorLong": "0x843f706dc60d4a87c883780887a33f606ded5c8fce7058881a2cc704e7e8effb",
+      "reserveFactorShort": "0x263cfefa4032f24002e72993f01a3fb1b7592736a134b4b5d327e1d21851f76c",
+      "openInterestReserveFactorLong": "0x8fe56ff8982100fae8af035ecb1a498280a226ae31c54ae592bc4384b419cc7e",
+      "openInterestReserveFactorShort": "0x603e0389e13d90a2cc02adcc05203a9c93591dc2a90b46bff1cf78ee49e89e09",
+      "maxOpenInterestLong": "0x910b3e02f956c0624cac4721096937943150eb3512905b1ee754589deef81fcf",
+      "maxOpenInterestShort": "0x0cacdae8dff30a5cb15b383f56de30f3a225199e2a2f3f1b3f8347aa4a6a1c82",
+      "minPositionImpactPoolAmount": "0xdc8a798526f8870f7e57be73d7d9679477cf3119b89eb8ea8d896282dc5cf19e",
+      "positionImpactPoolDistributionRate": "0xbcfe325cf09ff7143fcf5e2dcfede756a2a31fee57fb4c79b66dadbba530c0b7",
+      "borrowingFactorLong": "0x51f37a2a6b08dfcd3d82505d843daad2cd48df5caf98873ab5d697d93045cbfd",
+      "borrowingFactorShort": "0xdfca0deaffe28de3c7198c2129d890b4fd418e918de0b8c095a286187f1b1ba5",
+      "borrowingExponentFactorLong": "0x2bcd94993965710c5e67ad2c6810fda6b6c18d418c0cd55224a03c245b28db82",
+      "borrowingExponentFactorShort": "0xe0925fffb531e814ce9a6ec91a8f9fafa4af268405d71521dfaa37dd37283d34",
+      "fundingFactor": "0xd36c8aaa5616db3752d2d7ae6d4cdd543747665d03d8ae727235758f6bc3ec40",
+      "fundingExponentFactor": "0x0b01c0360bb65f92b5740b42e337ef102d510dada7f692ddcd51950765e29692",
+      "fundingIncreaseFactorPerSecond": "0x624306c52aa3589ced9e85dc2ca1bebe0bf7215e3c53c60ad232ae6572147a34",
+      "fundingDecreaseFactorPerSecond": "0xe8bd1fcac3682f51cf71497d314fe0308ba55805db055e486878ef705893e33b",
+      "thresholdForStableFunding": "0x40251ed05d1608f97e27a88a320ef1c69cb26b9a00f0bc5366b0bb30ce154e53",
+      "thresholdForDecreaseFunding": "0xb222322ab00353dfbfb62a6c43267503532a1275993b8aac92ab4b9bb6fa25cb",
+      "minFundingFactorPerSecond": "0x5a950930e022aee63fd5d8937bb3b8f75dd87847b72a293ebe3f65ecb33e8f8b",
+      "maxFundingFactorPerSecond": "0x36ce5651dc4050cff509a4ae5851ef6c46c8809c148242ce599926a1cae18c44",
+      "maxPnlFactorForTradersLong": "0xaaac151fe4483f6784b1463cd475862ebe13d73608ff674aaa1f0bea2439b530",
+      "maxPnlFactorForTradersShort": "0x2c315562881c0fc9e5d2f9af924de34c634f941dbc58d939007fc353829f4562",
+      "positionFeeFactorForBalanceWasImproved": "0xc8c6177c5fedb2073ca588c81ae6161c1f1fb2fdc4403213217dd0b8de721fd6",
+      "positionFeeFactorForBalanceWasNotImproved": "0x7e5b09f11124a2ccb387d6b35ca15cd880758b3648feb3a364f4d6f792611620",
+      "positionImpactFactorPositive": "0x42a911e221ae0820a3aa336a98732d26b6f2ea0188f36ef456a85b6fb8fc4281",
+      "positionImpactFactorNegative": "0x08170fe7c7ae44f7244a6b26525f7b9949f90590f828fb923c0443324476cb4f",
+      "maxPositionImpactFactorPositive": "0x5aaf6678ea33ed3d589fc87b7805bbb094492c3ae15e56ae493dd9f14fb7eb15",
+      "maxPositionImpactFactorNegative": "0xff1c5cc44fb9debaf827b86c2caa20763dc9a3af29f0190b8ca7f0e023803f45",
+      "maxPositionImpactFactorForLiquidations": "0x3f2252f85c1256f07b5f8d3653ba0d151275399bd78c9c150d2d5fdd793dff1c",
+      "maxLendableImpactFactor": "0x2eb81ca2db52707f192ab9632661f0e1132cdfc0694ad18bee397a254f222731",
+      "maxLendableImpactFactorForWithdrawals": "0x6a89295107925cc7889dd59bbb7105ac3c9584561e8c96004478d45814e912a2",
+      "maxLendableImpactUsd": "0x3988b771b9d14b205a91822bd00ca86670b27988546645d5be212e6249b58312",
+      "lentPositionImpactPoolAmount": "0xcbdd8337c03f23f45a4523c3806217336ba930b7a98c4077c269a09c60c8e901",
+      "minCollateralFactor": "0x0ea5c12870d31f5d56509a8d6f937d6d265bb0835b1633663c78d3b55ad2cbc6",
+      "minCollateralFactorForLiquidation": "0x4dc8fa882d20557c438d4b989132dffcdec3a2eaba1089cef51b90436232479e",
+      "minCollateralFactorForOpenInterestLong": "0x638947e41e3db0abc6f46332e4c0312c0f771ed78912b88148a27aa777c9b3f6",
+      "minCollateralFactorForOpenInterestShort": "0x7c8769a5a124b433fded94e525223a96e7bbd8896e3f732a186cb3cb7b2aba0f",
+      "positionImpactExponentFactor": "0x931cfbe7dea65d7aff1a7a9d5ad2deb94a8425d54956ba10da61b16c6afb9b2e",
+      "swapFeeFactorForBalanceWasImproved": "0xde99941e4f2591ef17e7e67bc6cfd36f554cb1ce2d7ca5c1e72da99597eba076",
+      "swapFeeFactorForBalanceWasNotImproved": "0xc84b8858b02972a3e3317df608a8c071096fee1a877c70587e6e03f136be8b3f",
+      "atomicSwapFeeFactor": "0xa79caaa8f613f973bfa9f2169a68ef604f5609c375fb2a8f1fb26bdfd0c1c634",
+      "swapImpactFactorPositive": "0x074a3442b4dae7be586549047b6a5a6a20ca259ca5a3d41ec54a5a8863efd116",
+      "swapImpactFactorNegative": "0xbf15c04624ef8978f119e3622f8ecee78ac7dda7045062f7e52fe444da1b70f2",
+      "swapImpactExponentFactor": "0x4cafea763650e7b8f0c8520a3bb775cf805cc589bf41624dfa2832d90f9941e1",
+      "virtualMarketId": "0xcffa9b917dfc97b3f9003d4b7b97c67f28bf90b1ede4e09739a87cb2a196f95a",
+      "virtualLongTokenId": "0xa05108a58d25332e075fca49149dbb671f4b30a226a3325bb46f83000c50ff11",
+      "virtualShortTokenId": "0xc4ab6a4bf31c6daf14b4280e1dca54edfcb90a85aff3598cfb550dbec25f7786"
+    },
+    "0xAde9D177B9E060D2064ee9F798125e6539fDaA1c": {
+      "isDisabled": "0x9adf70a19045dd6236ea8afec4450be4f995f9b9e21824b1e0f982d564c377f2",
+      "maxLongPoolAmount": "0xa494b0ed2c322518e756e2f0c4c011a3539c7468a5e96bb17ae3aa8fd469372e",
+      "maxShortPoolAmount": "0xb8bc819bf494e11fe7a55d68af1da8a3fa6a42b065e37f39ee351c375815e280",
+      "maxLongPoolUsdForDeposit": "0xf31d10e6b0fdca7a2a1221e1aef71a01637a24b41f1071e52ba32c9e23002a23",
+      "maxShortPoolUsdForDeposit": "0x9cd5fc54b24566a5041bde16ee93911ebff949b113d87c40935c5b0cdfe61762",
+      "longPoolAmountAdjustment": "0x24ec886fdee4040e95b783b161a0641874ff0ad61bac238b26216ac3ab184a37",
+      "shortPoolAmountAdjustment": "0x7ee15ba70ea0db723f2dcfad06b4e03f51708c0fab8e63ceaaad04a8a5d23ba7",
+      "reserveFactorLong": "0xaa7f10f290bfdb4f26a9fb241fb0b5eaff79108061e9a1a241def8f62237af2f",
+      "reserveFactorShort": "0x2c0b0c4131bb7003b86a3a2808499e4b359243f803a447c18384f8442aeca164",
+      "openInterestReserveFactorLong": "0x9cda8a7ee4adf4348828dc1a822d32ff3d456605ae512275be3644e4b6ba8f5e",
+      "openInterestReserveFactorShort": "0xfc84b5205c5e8ef5a611889c5b5679da16495ffb8aeb03036cb4dc0c73250fdd",
+      "maxOpenInterestLong": "0x61ae6419291bb6853ec66aaeecbc977a50bfcc49f120a0666e0d9a4b8f992026",
+      "maxOpenInterestShort": "0xfc48b4a05400912b9a9c3805cfc3422cd72fae7b0a4f6241a984e6b46f447cf6",
+      "minPositionImpactPoolAmount": "0x713be7f821633701e59656eafd705a6956045ef1a3c571534774a5bac37d40e1",
+      "positionImpactPoolDistributionRate": "0x1f527fa7bae33f81103a0fee03dd250ca1761b7b6784854214bcb95fbe5402fd",
+      "borrowingFactorLong": "0xdeea8e242831c4eb5b13679b80abc309ca896927f5eb3d65aacbfc07480d09c5",
+      "borrowingFactorShort": "0xe3ad1094a1a43eab9e1feb5b508bc34c0acd5bbb64b2c7af6cf75314a1aba7da",
+      "borrowingExponentFactorLong": "0x42b191c584e1f7da0722b69ff00fd497596010de616c1a4b1963873baa4e9821",
+      "borrowingExponentFactorShort": "0xd3e85f7bd025600c969e0c6297ed0866234c4af37910d5dd90aa98c3540fd2c8",
+      "fundingFactor": "0x7482ea5b5159440926b266b873b386a00fb308a358c9ee00ce02e0a64200bbdf",
+      "fundingExponentFactor": "0xc9309c003dc7c2ea5a686c4a66b8b74bccd0f073a233255dc37eb7a588087249",
+      "fundingIncreaseFactorPerSecond": "0xfff1619b1f12d404d66ac296fbc07ebf1efc6e81db1ef757b06ba8a319c923c4",
+      "fundingDecreaseFactorPerSecond": "0x4b0f378266e9006f27d08c3bd4aeab079a7de5d0e3d548823eb523aaf6ce6457",
+      "thresholdForStableFunding": "0xfb25a58b6f1a1f931e8fcdf74f69ffaf0e763d174ae512037bfeef36fd3a3e44",
+      "thresholdForDecreaseFunding": "0xdcad7496c528d355930e72e9a1ee24a70905a742fa4baaf4fae8d035451c5773",
+      "minFundingFactorPerSecond": "0xe694771765746f4985641aae2b6dc2945e2a516abf649cd90032804992c8f1b9",
+      "maxFundingFactorPerSecond": "0x8786e0c1bac43a9b370c8bc9b4a85442c53fa187df0e0e09d6d2251cc24b8f8c",
+      "maxPnlFactorForTradersLong": "0xab77cc8036047e02324260261733ef57be9918e1bf199781e51941813168a7d6",
+      "maxPnlFactorForTradersShort": "0xff1233dae75cfb95a1e20060a3bcfcaa4e28adc91fa29a77ae424c95c5841af8",
+      "positionFeeFactorForBalanceWasImproved": "0x6da940b55096a35d47e458287ce3c798b91e6b1110aaf6623fa517ece76a3ad1",
+      "positionFeeFactorForBalanceWasNotImproved": "0xbef2aab9b9c4dcb732be4f0e64bb8e977ab9e96e6fb957cd59cc11c1c4e4269d",
+      "positionImpactFactorPositive": "0x49d1389250c712b139306aef87658a1efd8f7bec2652d80651ed4bfc1567fb58",
+      "positionImpactFactorNegative": "0xc64532c373c21ad3424f3d67c93beced2b0f95056eafcfebe79f8f0dcaf7a8ca",
+      "maxPositionImpactFactorPositive": "0x8ed5cf785b7bbf911434a93877ef8ff62ee004e6a316d584a14e5cf694267435",
+      "maxPositionImpactFactorNegative": "0x89a8e7d6a7a53617847d3c7101d1e9b637eacb8f614cef2148dcbc1753cc860e",
+      "maxPositionImpactFactorForLiquidations": "0x8d5706ffa347c8e3730dbb1ca3c5d280c77059ff6f2a8fe4ef0968d71d46a3dd",
+      "maxLendableImpactFactor": "0xf708b5ec47885aabb16b2d447bf2cd5c1402a3bdcf70b3a5e109371f1369a98c",
+      "maxLendableImpactFactorForWithdrawals": "0x28de0a3bba927558d52feec34658ddc40cbc5ba8dc1b93a4375d92657bd287e6",
+      "maxLendableImpactUsd": "0x2eca434623f8709dc1cfe29b4c8ee81075194579976131913f1b79cce84dd375",
+      "lentPositionImpactPoolAmount": "0x9c1c07244a02b8aaa14935b64b49922544464cc6d1f2d1656ef3c6288f167971",
+      "minCollateralFactor": "0xe90b7b04eb6f259d072fd69ed1f54345da2f08de8fc9a0dcc299a87c8bf98244",
+      "minCollateralFactorForLiquidation": "0x97c9697f9c54bee1d7aa87aafb951e9271ee448039c033ee1b07f82f6bd393c6",
+      "minCollateralFactorForOpenInterestLong": "0xa671eebbbbf69e5fdc8ba09cd259de013c3efedf731d39a16b2aacfcb0897650",
+      "minCollateralFactorForOpenInterestShort": "0x6e1e0c0d41c794387409f63a8d15cc4185ddab61cc6d53f4b5a097e054db2112",
+      "positionImpactExponentFactor": "0x2447adae280fd431e18cb993e9f552f9346101d4218b0996a3fd1d6509478a0a",
+      "swapFeeFactorForBalanceWasImproved": "0xfd5c18e7555f9acba6ea862d6e14a04932754012def735e239b47582799926f0",
+      "swapFeeFactorForBalanceWasNotImproved": "0x12b575bf244e9c972168fd84385a4ca7a59f21fbe87aa00290549e16edfa98ca",
+      "atomicSwapFeeFactor": "0x38bcb40bde3296ddd8d48f7105becfc841bb32812c3dad279cd07aebb8245b24",
+      "swapImpactFactorPositive": "0xf8e3ab382a889a5076ee8a8fdad1001719fadd0a46cc58a5dbf1acdb2015cdb4",
+      "swapImpactFactorNegative": "0x3926196acc50053643fa4c3c067d2927c88d7baeeb09455c2398c1d3f51cb680",
+      "swapImpactExponentFactor": "0xf3207408fe2e68e65822649ad5a0519eea88f25d7536f2bf260bbe23833764b3",
+      "virtualMarketId": "0x1508cc8b108cc92247ff1a8f212cdac883536956cf50ab8b3eaf42ae5d37b7ec",
+      "virtualLongTokenId": "0xbeb8096910fd4d4b3ade12aad31c27a0e5f047fce87d1279b0c71579a8c4ef5b",
+      "virtualShortTokenId": "0xc4ab6a4bf31c6daf14b4280e1dca54edfcb90a85aff3598cfb550dbec25f7786"
     }
   }
 }
\ No newline at end of file
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/prebuilt/hashedMarketValuesKeys.json b/src/Managing.Web3Proxy/src/generated/gmxsdk/prebuilt/hashedMarketValuesKeys.json
index d95c4ff0..824f35de 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/prebuilt/hashedMarketValuesKeys.json
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/prebuilt/hashedMarketValuesKeys.json
@@ -1,4 +1,51 @@
 {
+  "3637": {
+    "0x6682BB60590a045A956541B1433f016Ed22E361d": {
+      "longPoolAmount": "0x69a00ee30c22f748c1aa54b8f77a5b786c365e817497322cea18cba5e12f8446",
+      "shortPoolAmount": "0x69a00ee30c22f748c1aa54b8f77a5b786c365e817497322cea18cba5e12f8446",
+      "positionImpactPoolAmount": "0xe72b2da1beeaa2cde5f5861b60f1adb27ed581864c6e39ecb37f8794e03e174d",
+      "swapImpactPoolAmountLong": "0x02603eac1d091c38978f864769361f985169348da32b431d4c0ee7c8559fddc1",
+      "swapImpactPoolAmountShort": "0x02603eac1d091c38978f864769361f985169348da32b431d4c0ee7c8559fddc1",
+      "longInterestUsingLongToken": "0x214be68b117ab3421e08bccb2521f805f76ae486dc92f1464abb3d7ed9ce907c",
+      "longInterestUsingShortToken": "0x214be68b117ab3421e08bccb2521f805f76ae486dc92f1464abb3d7ed9ce907c",
+      "shortInterestUsingLongToken": "0x44a1c0cc7e5e724918f78b1ae77c240bc1dec8098ddefd9fb15dfb4e06f58b39",
+      "shortInterestUsingShortToken": "0x44a1c0cc7e5e724918f78b1ae77c240bc1dec8098ddefd9fb15dfb4e06f58b39",
+      "longInterestInTokensUsingLongToken": "0xddc7e3aefe087c9ff970def36636c36cefa45ea75bf9d99c2747b921d46e3936",
+      "longInterestInTokensUsingShortToken": "0xddc7e3aefe087c9ff970def36636c36cefa45ea75bf9d99c2747b921d46e3936",
+      "shortInterestInTokensUsingLongToken": "0x85a20a5a323d16c5f5ecbc2d6352b4f47dc7921eef88e4cc987b3c8022e6a87f",
+      "shortInterestInTokensUsingShortToken": "0x85a20a5a323d16c5f5ecbc2d6352b4f47dc7921eef88e4cc987b3c8022e6a87f"
+    },
+    "0x2f95a2529328E427d3204555F164B1102086690E": {
+      "longPoolAmount": "0xecf9656e2b727f8d13f37e55d2400a942dccac9d6381148f77d902fcbe2cf7ee",
+      "shortPoolAmount": "0xcfec2d18f35126352a2ce695309d775bbee4fafefe3413f7042939145a8b0573",
+      "positionImpactPoolAmount": "0xf6f96ba2726dd8a85b2e9405309d1d848df3d96880d59321dcc218ef8d980668",
+      "swapImpactPoolAmountLong": "0x357c18aaf9d45a361d90863904ade24e17fb77c64a416ece27086f31a0d8b054",
+      "swapImpactPoolAmountShort": "0xbbb05a1d798d61588b2c44b94b16386d41137dbe373c187371d86d997a9147e1",
+      "longInterestUsingLongToken": "0x129ec5ddb1853ff59fe335e75bd2fcfa6bbb9269fdc499282cf18e2f4d5964c9",
+      "longInterestUsingShortToken": "0x3f654d7efcfe4f6cb7c83aa01e873c16e5af513cc4f87adf6eed255042a258fc",
+      "shortInterestUsingLongToken": "0x1f410105f8be87f75b58b9cdee8d74667aced7496bb99a82f07f68db7ed1beb4",
+      "shortInterestUsingShortToken": "0x51765c7340efd23bef0fef20734bbc293d17b324540a253b57bd0337038c7668",
+      "longInterestInTokensUsingLongToken": "0x7f172a05ae40ac360e65ac522e8714499e4695d2250d219b96a6cf33fdbc083b",
+      "longInterestInTokensUsingShortToken": "0xc34e82056451cf4f589cdb5609780092eef55a11937ecb6b97120c6425979ea4",
+      "shortInterestInTokensUsingLongToken": "0xdfc2472d4b9b2c6f4b2754c1ade2bef5e4fe747aa61d86922f62b34d4f9b09bb",
+      "shortInterestInTokensUsingShortToken": "0x3eff00ec29f463c99b6b378801ecb7b167366433326231573f74fa7ae20bbe20"
+    },
+    "0x6bFDD025827F7CE130BcfC446927AEF34ae2a98d": {
+      "longPoolAmount": "0x3e705a690a4f6e12b648b46021d64b1a19979c3930bc633008e776bfdcffa768",
+      "shortPoolAmount": "0x3e705a690a4f6e12b648b46021d64b1a19979c3930bc633008e776bfdcffa768",
+      "positionImpactPoolAmount": "0x1be724cd8642f6c98c8e6633f9f575d86a98fece1cd51e45ed7069c050dd1d63",
+      "swapImpactPoolAmountLong": "0xeb84c49e6ea3a599a47e95dda2e1d815088f3d9e477e2ddec50ee2f862e98a17",
+      "swapImpactPoolAmountShort": "0xeb84c49e6ea3a599a47e95dda2e1d815088f3d9e477e2ddec50ee2f862e98a17",
+      "longInterestUsingLongToken": "0x14569ffe0e8d775adefb50fc1d34370af1b37a000cafbb1f1ae069b594f9f0bd",
+      "longInterestUsingShortToken": "0x14569ffe0e8d775adefb50fc1d34370af1b37a000cafbb1f1ae069b594f9f0bd",
+      "shortInterestUsingLongToken": "0xe37270197048b507763f8de54b0cc4c02fe2d03bf112ddf44d60e119144de97f",
+      "shortInterestUsingShortToken": "0xe37270197048b507763f8de54b0cc4c02fe2d03bf112ddf44d60e119144de97f",
+      "longInterestInTokensUsingLongToken": "0x117853215d2155afd79c91f4586cd55c7cc7fa8885a5ae4cb9203c9df1e8f7e5",
+      "longInterestInTokensUsingShortToken": "0x117853215d2155afd79c91f4586cd55c7cc7fa8885a5ae4cb9203c9df1e8f7e5",
+      "shortInterestInTokensUsingLongToken": "0xe8a3c7877b603e90c025cd38a1f20d1b94f4f7a8ec7054e17b629218c7474c27",
+      "shortInterestInTokensUsingShortToken": "0xe8a3c7877b603e90c025cd38a1f20d1b94f4f7a8ec7054e17b629218c7474c27"
+    }
+  },
   "42161": {
     "0x47c031236e19d024b42f8AE6780E44A573170703": {
       "longPoolAmount": "0xc97d6ba9e3cbf19c2bdb3eb671109e97cbbb0c4684ac5ea9b34fffbf3fff84fb",
@@ -1214,6 +1261,366 @@
       "longInterestInTokensUsingShortToken": "0x6f542fdc6addee4e75891c4bfb8860c6232b10e35d2cf34d56a31f6e37a073a4",
       "shortInterestInTokensUsingLongToken": "0xbe1d49d8de9f15dd608c0ec6671808b8204838b14e8d31769b30489ee71e6e8e",
       "shortInterestInTokensUsingShortToken": "0xb19e3d111bcebca624cd2077e9c21d2f53f98e22648b3625c51cdcaf1ca09ddd"
+    },
+    "0x4D3Eb91efd36C2b74181F34B111bc1E91a0d0cb4": {
+      "longPoolAmount": "0xcfdeeee75cef8de81f3e98bc2ee46390b1ebb489016a64e945f8df208913cd15",
+      "shortPoolAmount": "0x819197d0e2f89533aaf9f8f682459b4a9632d54904ec9e5a550c76963ae99f8b",
+      "positionImpactPoolAmount": "0x744ca86ca9666aad1339f04e710e921b3d1ebc7c56ed244640e5088fa98d6757",
+      "swapImpactPoolAmountLong": "0x762b06f45ebc57521994d8ebf527c46abf5058816c792501f0bf625506e82d35",
+      "swapImpactPoolAmountShort": "0x58950f4dfb0a69cfd67091901b12864103bb9cad22c497d86b4d4d258cf85687",
+      "longInterestUsingLongToken": "0xa31015cdcb4172aaed407c2d933b627f7a8e46999aa67ae98973a8fe9b8c6a15",
+      "longInterestUsingShortToken": "0x139a84e762d9799d19c51f6fb7241c93ea222cd11cfe52aae1306d8825cc6e42",
+      "shortInterestUsingLongToken": "0x3d6d99fcb9adf2d5dcfe04612a0c670605275b61a237d5a077d2eb3044ad8f6a",
+      "shortInterestUsingShortToken": "0xe0e0724df520d9ed9306b7611305b3d4ee8a7b7c48296c8a1bb7df9ad33a4807",
+      "longInterestInTokensUsingLongToken": "0xe992d65208bb38ea6097352425d679b71a75429322dc6b4c872c9451cadd26a6",
+      "longInterestInTokensUsingShortToken": "0xdf1bda8a83a0560547c25e3e4ca770baecbd6a61efb81b6d5e8e4e912f054329",
+      "shortInterestInTokensUsingLongToken": "0x0d9c0848acc691d704ebb980a19c1661d77056a084d0147232952666d6d7780c",
+      "shortInterestInTokensUsingShortToken": "0x41d05cc1bd601fe40bf8e5a838e9e832eb3bd6d9a56dabcf470e99d5e52c3de9"
+    },
+    "0x9e79146b3A022Af44E0708c6794F03Ef798381A5": {
+      "longPoolAmount": "0x9c617050f77600ca856ef1119cbd36bb1eec68a511bb34b762bbaa699ef70793",
+      "shortPoolAmount": "0x2d53f1549b165f9f8db0d7ec7e02680e970f29434a615215d9aaa894a19c2468",
+      "positionImpactPoolAmount": "0x065cc9b8f43747f67442bc10b49e0ed840fdfa7a8d8e0702866a21749de3b62a",
+      "swapImpactPoolAmountLong": "0xb1a0d964e70a12baf428183526200debe0c74f56af4ea665ea0b479f5575a75e",
+      "swapImpactPoolAmountShort": "0x56f00e78bdb148aaead6242be6b03e4c9201ee4b80465bdc1cd19cab797536ca",
+      "longInterestUsingLongToken": "0x008b836e3b01bb5b5c7fd81c366681c398c24bd81b5ad3cd44c272c98cb95a4a",
+      "longInterestUsingShortToken": "0xc466b0c4230ff4b64b09c87515017bf0bfa42f419243f973c8860fe547d477e7",
+      "shortInterestUsingLongToken": "0x04a5833e48beb387f1aff721fe09b0e0b277734e07c1c701b72f16751937d793",
+      "shortInterestUsingShortToken": "0x09ef0af5dbe9d78c25fa7fe47bab4c53897b0221b49490023638af367d3ff665",
+      "longInterestInTokensUsingLongToken": "0xf58d64f0e41f61a49a828be86024481a12e29015cdaa606bed07928b1838bcde",
+      "longInterestInTokensUsingShortToken": "0x401b4f7fe4e249488787c5e8ed3d5b0b097ac08e418f45b7cb148b2c9fed9f43",
+      "shortInterestInTokensUsingLongToken": "0xd30216795b710aa170af3198f18a117b7bd846a98051fdd9d73b9a80002223b9",
+      "shortInterestInTokensUsingShortToken": "0xdfddd1e52c69cfcb2242fe606793a01faa8fa0bbbf2e482c89f600e74dd24f09"
+    },
+    "0x0e46941F9bfF8d0784BFfa3d0D7883CDb82D7aE7": {
+      "longPoolAmount": "0x76339270fdf9fe51d24e487304213bdb0e24389b875d0e7d3f7398a8c92de8b5",
+      "shortPoolAmount": "0xa1210429f9581af23981f66de5daca169404b4e37c8daca06dc62fe56a947cf4",
+      "positionImpactPoolAmount": "0x89e555a84a9efa20e5ce28cb2a0df69557d180ab3da7cb1cc925162dd833cfc2",
+      "swapImpactPoolAmountLong": "0xfbcb206ea4f7f1710bed958a5c148695f00afa1483f7f239f123720fe3d7c04e",
+      "swapImpactPoolAmountShort": "0x86edc84a8c9ee6a09d745337c03d8005efd194acdddef85e36054d8313d36980",
+      "longInterestUsingLongToken": "0xc99f3886c7d51b7d601686086b17ce369710a8d8af5c841a04a9eee87168fa68",
+      "longInterestUsingShortToken": "0x839a0605a5833c4bf23d839f9753ad7b7f527d1d70fd49e229829e81d1b0e75b",
+      "shortInterestUsingLongToken": "0xaf71d1be4d68c93f86dd1231424dc8978f28799e03e76aee5b3b1d8e219735d1",
+      "shortInterestUsingShortToken": "0x77ea0d9da2ae89c287618474189f7d0cbd002043bf9e1524b3a20ed9097ec4cf",
+      "longInterestInTokensUsingLongToken": "0xa9c8c0075d6b9f7ea3257f5868d91a1066be9c72cbfd79c3378398677fc454e9",
+      "longInterestInTokensUsingShortToken": "0x990383f8aeebd168f8a25a52959bac05b31864a40946078e9c1821cc31997f17",
+      "shortInterestInTokensUsingLongToken": "0x5f86375e18d3884992954c21ebe2191fc875d5d7514d830c967296d98ad22e03",
+      "shortInterestInTokensUsingShortToken": "0xdef08d11b573ba8e3b6d919c724a60bbed677501313332e2d09bf3ef4e4a057f"
+    },
+    "0x2523B89298908FEf4c5e5bd6F55F20926e22058f": {
+      "longPoolAmount": "0xc1cb4d3d87e1401e8b451df65d5bb41d628a71fce88be244b1be8a137ca5390a",
+      "shortPoolAmount": "0x47e03c22f82ad390e58372207fd4c6d5a1685935568a343d2967fc263447ff4b",
+      "positionImpactPoolAmount": "0x789583d3f45ef3e09b31e99fc1b3b47d1bdc3c179d4133b04e8f6a2810a171b4",
+      "swapImpactPoolAmountLong": "0xc196aa2876aed0daa4a963857bf348cfc35acbfb7f5b3131c43cb63ddc104f58",
+      "swapImpactPoolAmountShort": "0x37f0eabb9281ed4c4e87eb6c8b1a8264733d74deb3a2736908ee2e1d332bacb2",
+      "longInterestUsingLongToken": "0x197bac785d03ea078e0b1fec22575baa8fdac1acd38fa15aefdfe092b2095477",
+      "longInterestUsingShortToken": "0x28c25793551271bd5b21b8c86f31e16060dfe01e3ad6046c6f4be2bfbedd437c",
+      "shortInterestUsingLongToken": "0xcb64f5ea4b0fffa761f1e828104bc0f49a7f887cf54731cec3634a4b7631427d",
+      "shortInterestUsingShortToken": "0x585a446a024173ef0268da647ad0df5d5644b39235073e6d4e6da49f4c71deef",
+      "longInterestInTokensUsingLongToken": "0x26e7ea7037b83a38bafbd2a65ca4a96371b56d6549ae8255a8aa820e2c5112e5",
+      "longInterestInTokensUsingShortToken": "0x53cabdd1589982ca208ed4eccb26b9a4c84f02219b3097d7bfa348de853c1f15",
+      "shortInterestInTokensUsingLongToken": "0xdd32f7b3d7add0fce0abaae3bef28acffc2e581605a60f6f272781352ddea05e",
+      "shortInterestInTokensUsingShortToken": "0x713b5c0f4d0910279e8d3bad2e6d80f784c6d0ba3fb55ce6e0327937d4b81bc5"
+    },
+    "0x7c54D547FAD72f8AFbf6E5b04403A0168b654C6f": {
+      "longPoolAmount": "0xead0643a2dc9e50fd5d68a68feee0b1bab6f98c5acc68e480bbec9ae7ee920f2",
+      "shortPoolAmount": "0x3c6786065166f7f8a3829b4d978a706c91c622febcbfa56eb8308bd23fa1d352",
+      "positionImpactPoolAmount": "0xd59fbf1f47b4fa2fb02b36548fae94bbf1e3a3d26fa5e0c5250066dc583c0839",
+      "swapImpactPoolAmountLong": "0xbf213e14458ad58545aea523ec0105609069dad6b6b017eda8f0024daf63422b",
+      "swapImpactPoolAmountShort": "0xf45fc23e8e69e28a9fa3a184fb43f255defdde09b840bfbca5192cda38b4f960",
+      "longInterestUsingLongToken": "0x185834a73a6749224b3fcb782fc3ef073266aa5d77e39857125524964b2764b6",
+      "longInterestUsingShortToken": "0xf2c5529f9011666344b81373a841fd14bb1b97f7562b761fd8b678302906eb4c",
+      "shortInterestUsingLongToken": "0x33d0f93fc2126fe4d94c308eae266696b2b13adf7c0221d89f4e62020af79584",
+      "shortInterestUsingShortToken": "0x466523fd838cf12da1d164b26cfb2eccec195bd29d8aecbf49cdd60ed06c56d8",
+      "longInterestInTokensUsingLongToken": "0x5c1f450df618dc8dd4e3f46d6ddfa8f8e27a857ba2934ec5d4cec14182cd7b34",
+      "longInterestInTokensUsingShortToken": "0xebd0844d77cf10b0a53213d880054e84a66dfd57853c583cbce83e124dc24a96",
+      "shortInterestInTokensUsingLongToken": "0x09467669e73c2ebad9ae4ce2aa06ca52348ae5da2d25be4c35b608e4dff0e2bc",
+      "shortInterestInTokensUsingShortToken": "0x4f4bacd66cdf5d93d6c55dd2c019d75653b63183bef9db11f98764fdd8cc60c7"
+    },
+    "0x39AC3C494950A4363D739201BA5A0861265C9ae5": {
+      "longPoolAmount": "0x8b35db61cf1d679856d17037bff17b6d5909ef3d237ec5fddb6e9c45a2553c95",
+      "shortPoolAmount": "0x74b22e46171010c4d6867a3420af82b00c739ec3bbeb295a4cf625bcdbfe07b5",
+      "positionImpactPoolAmount": "0x9435975a828122df0431350d47a44d4700715d393c9d5f55a4fe7d1972f1d95f",
+      "swapImpactPoolAmountLong": "0x9113211843bb2a4695cb03f9350950920a54e63b8a69010a2a9b440fc41d6ef8",
+      "swapImpactPoolAmountShort": "0xa9a4df803ab35db2d17f39f87fd42b18a2830e58416f919391481f6d2e31a3c2",
+      "longInterestUsingLongToken": "0x4e71590171ab7ef030cafac110a7385d65ce24f61c6c2edb04898654f04ec898",
+      "longInterestUsingShortToken": "0x915ae07505869779440f15749260d59c6ea24880abd0d72c343b52d2b86b8f40",
+      "shortInterestUsingLongToken": "0x829c7683ed83c5cff99e9e5313aff403cd26085ba4a43964d011d6bd4977efcd",
+      "shortInterestUsingShortToken": "0xd193c75ba20a56756011040cfd14a59b30a569e75a1ac818c598210db4459c52",
+      "longInterestInTokensUsingLongToken": "0x30d45feb138a7c16fa2eb74acaee67e95e1c60bc1e10c30301d3762b64883834",
+      "longInterestInTokensUsingShortToken": "0x270eaf7ded63283fe668107dae6e74b2f65611f2ce8ac93f7587aa42690e726a",
+      "shortInterestInTokensUsingLongToken": "0xba25770c0d2c19cb82136ca008f7f59e3f0a6273159a121852ef001e7fcf5cd4",
+      "shortInterestInTokensUsingShortToken": "0x434a95fd250b7b15239714a1a92599a7706c946310e7cc999a66202318a3b9d5"
+    },
+    "0x4C0Bb704529Fa49A26bD854802d70206982c6f1B": {
+      "longPoolAmount": "0xc996bc9829549ec431dc6686d166b850c834ca57d6d13eef76878eb034346f49",
+      "shortPoolAmount": "0x73576063b41f5bfab75ba59775beae18756d9a05d1934205cd5c1c8ba136c37f",
+      "positionImpactPoolAmount": "0x336c51bf0ded13ba7909d73214583e37c9b26efea4938aceda45c44e8a3daf11",
+      "swapImpactPoolAmountLong": "0x82459c6efac2e94161ec6d0598601585325eef90f2af9881301f2278fee5099f",
+      "swapImpactPoolAmountShort": "0x9f0dbc64c99da086cb864d7e695f4e7f266ca1440f08ec043ff6ed3665184d81",
+      "longInterestUsingLongToken": "0x7994ea7561117141e087e7af8aa01cf4051b35e85120e52501d1e5796828d4b9",
+      "longInterestUsingShortToken": "0xb5d3a077dd57f1759a6d816686fbf4107a01d451800b80f4ac2355fa60c2310f",
+      "shortInterestUsingLongToken": "0xb28ff06b21c5927f46a4156fee083f0c7441fd5c53971d47344678e9ef9cf0ae",
+      "shortInterestUsingShortToken": "0xf2729a78f904139a3e33a1278c11af17d3b46e5f5ca6223c397814f052e5d019",
+      "longInterestInTokensUsingLongToken": "0xaeeeb61d7d9544320d5c9223f4d671475bfb227124129ec581bdd1c9427961b0",
+      "longInterestInTokensUsingShortToken": "0x3f8f433c8c804ca8bc6c5c383e9201516559ee81f67de93db9ce8b2c2ee2403b",
+      "shortInterestInTokensUsingLongToken": "0xf8b11af0ad2d1ab5f63791944792e3d3c96e5973b7f003dd86bd4314a25dcda9",
+      "shortInterestInTokensUsingShortToken": "0x4ed2301ae42565af0bc559a51c13c60223d0159f349ccc0efc2f080d3a467298"
+    },
+    "0x8263bC3766a09f6dD4Bab04b4bf8D45F2B0973FF": {
+      "longPoolAmount": "0x376d10c7c9e12d555cc72da9c11f290bb948dee849e7ac53c9919cb7ea326356",
+      "shortPoolAmount": "0x0328aa07dddd94e5b175e0c18e2a038a87ef77dbe0f01598abfd5334e14f8e5e",
+      "positionImpactPoolAmount": "0xec2057fa3283a4b58a58071d0fc709fbabe164669de94f39a32c0f9e6d8ad857",
+      "swapImpactPoolAmountLong": "0xcad777762cbf8191fdc7a83fed0b6dc7267c3ec95deafbc3f278c78640f5def2",
+      "swapImpactPoolAmountShort": "0x4ea39496d661599d66dd7c36f636e2beb1d9f22d494251079661ef97b260796b",
+      "longInterestUsingLongToken": "0x60b2619176219b8e25afc32c0822b3ff9866f234f23171cd5c443e1307aadb83",
+      "longInterestUsingShortToken": "0x2d9f098282c2b594ffa540647b1ac0c6209b17e64061586c5c89f70b7f1e561c",
+      "shortInterestUsingLongToken": "0x46574cd73b54eb902ef9f6257cf28096088a744437a313e50ac6a3dcdde873ad",
+      "shortInterestUsingShortToken": "0xa8bbf0769960efdfe8fcd0fb1dd38f6713bf76f3980f613aee0fb1c8fbcb5fa6",
+      "longInterestInTokensUsingLongToken": "0x64f6ab661c3fb1f4782cee482f58fa61e4a8e8f100f407793406835061104b48",
+      "longInterestInTokensUsingShortToken": "0x2aa02635cddc8d2c7be1cb924b3bb933eeb0fea6fa8a5a480180c0d0cb7d3aca",
+      "shortInterestInTokensUsingLongToken": "0x82047a97d39c5c336f198c2c03598016c99e5e7c055d3507be800f23e516aef6",
+      "shortInterestInTokensUsingShortToken": "0xe2de08baa4086bcdaa890f544b6144c2a3e1f7687a0724b6d9211851eb8851cb"
+    },
+    "0x40dAEAc02dCf6b3c51F9151f532C21DCEF2F7E63": {
+      "longPoolAmount": "0x3ada05b4ab6a01c1e9d5d14a6623330ac706b167ef0a071c44caae0f2e86fdc5",
+      "shortPoolAmount": "0x4549e636396f94e60a42c4e6cf6de9cc4641b422616da34afad3bb545252d55b",
+      "positionImpactPoolAmount": "0x7ac4153f38da7f40234e4278155360da68d5d7ba448b8406a58a32e3984e1c84",
+      "swapImpactPoolAmountLong": "0x23d98dcb90fa99c0c0afaf8da74219739891cb8110408cf62f0ff7ee9791b841",
+      "swapImpactPoolAmountShort": "0x67689a5fe771bcce0255ea6af7497ebdf969b44a2925b0a7d57ab813a7d92528",
+      "longInterestUsingLongToken": "0xb54834f5f22fd80d4bff9e5fad82cdc0812f9c92145c9213d61ec65e023f4a49",
+      "longInterestUsingShortToken": "0x6b03ae70dddc4ea9ffac583d90730c4deb7aa91f2e05b0ef4496373135f501db",
+      "shortInterestUsingLongToken": "0xb7825b979161efdf744c59e3a2f1ce9a946401f1fff467cdda4c79b4eeef1dee",
+      "shortInterestUsingShortToken": "0x20d46f0c26c10020a4caa0b8508e679b5c0366ffa1957348f4af12e02e8ae627",
+      "longInterestInTokensUsingLongToken": "0xb05b543fd027e0faeac576b85e5eb8dd16dbe9b0a287951e880462f74428dbe7",
+      "longInterestInTokensUsingShortToken": "0x548e4ec925976c9573b2513f3e04ccb85992e7b2f9fcadef9d390972901249d2",
+      "shortInterestInTokensUsingLongToken": "0x43eeca3a191fb5f9d6e028d433477afb80d8bc8be6d4736ca40f72100ed01760",
+      "shortInterestInTokensUsingShortToken": "0x08fb093e1d5256360f715652095ebef083a166cb62c222f96d377cc7aee3e961"
+    },
+    "0x672fEA44f4583DdaD620d60C1Ac31021F47558Cb": {
+      "longPoolAmount": "0xd88d77f52c0605af9087b8ac011f7ce71651f30489699ab476eaaf49fe3169be",
+      "shortPoolAmount": "0xd88d77f52c0605af9087b8ac011f7ce71651f30489699ab476eaaf49fe3169be",
+      "positionImpactPoolAmount": "0xc7f1c4797976d4aa2d9af5b9b4bac9af3820775e22a642a5f882d0040e30d7e4",
+      "swapImpactPoolAmountLong": "0x10f2963890a8ae4e833e0f611420b6c41136c2ff83a764654cddfcb185ce39ec",
+      "swapImpactPoolAmountShort": "0x10f2963890a8ae4e833e0f611420b6c41136c2ff83a764654cddfcb185ce39ec",
+      "longInterestUsingLongToken": "0x5ebd54efa4eec2c74d89f7fdbbad947ed4ade7a369f87b940aa4c455a8140f8f",
+      "longInterestUsingShortToken": "0x5ebd54efa4eec2c74d89f7fdbbad947ed4ade7a369f87b940aa4c455a8140f8f",
+      "shortInterestUsingLongToken": "0x300b925f106354291a9776ac37a374aa7149da134418f5f8bdc2b59739fa7829",
+      "shortInterestUsingShortToken": "0x300b925f106354291a9776ac37a374aa7149da134418f5f8bdc2b59739fa7829",
+      "longInterestInTokensUsingLongToken": "0x8ff57a652cd892eade9757b138549656bc9f8dc00d9eeeb3fc4f9bd6f2cc2bd4",
+      "longInterestInTokensUsingShortToken": "0x8ff57a652cd892eade9757b138549656bc9f8dc00d9eeeb3fc4f9bd6f2cc2bd4",
+      "shortInterestInTokensUsingLongToken": "0x81b4fc3022e9cb293b10549fa7ff90ca91abec03ca725ded69a4b35c09858ddf",
+      "shortInterestInTokensUsingShortToken": "0x81b4fc3022e9cb293b10549fa7ff90ca91abec03ca725ded69a4b35c09858ddf"
+    },
+    "0x3B7f4e4Cf2fa43df013d2B32673e6A01d29ab2Ac": {
+      "longPoolAmount": "0x950f55352377af24d3a96bc2a3a38d1e5dfbf04c07d8364475feb8092ec75c64",
+      "shortPoolAmount": "0x0704221c55eb30a2efec7b9d42ad18b41c308c26c638e85ce53d08cc694bb340",
+      "positionImpactPoolAmount": "0x757e7478893be5bf67fc10551f9ed34f1403a3628a8ff3f99bafa17b3ea66b79",
+      "swapImpactPoolAmountLong": "0x7d1c81974ef4c7afb3592f7ebd245358952ca21333678e9ed0685d30b02e8a0a",
+      "swapImpactPoolAmountShort": "0x71ba227bbc9232cd200c2a208ce26cb2991da321664a31bbd5d410174d07eefa",
+      "longInterestUsingLongToken": "0xffbd879ff459c888617ba08141ca99969c83ac9de54990cab294ce2edd9fc9bd",
+      "longInterestUsingShortToken": "0xb86c0a56965a83b03c7f93e6612efc66d78eaffc027d8877b4edf23ad75fa4cc",
+      "shortInterestUsingLongToken": "0x769be22d39b7606b33a7734d76e3b9416cba72fff936b26a9ddb7875b4497dc3",
+      "shortInterestUsingShortToken": "0x1746986fd30dbb8fb1939fe11604f11eeb57acbc85b1a76b5c78551798afdea7",
+      "longInterestInTokensUsingLongToken": "0x19507cd2da36e6ca0e96b043c6b0e853e477cd1aab3ee7f74db45f918910549d",
+      "longInterestInTokensUsingShortToken": "0x8d9c0ab0775b9405e5f54458dcbe28bfa2a49a07e39253b6d9735a77ba8a6c16",
+      "shortInterestInTokensUsingLongToken": "0x10863b6d78d3d1746d0bb8de8b7e3df021ddcdc1008d6c1ede3c3bfb30f08199",
+      "shortInterestInTokensUsingShortToken": "0x98724366736175a92826c63d94d611bc2ea3a63f24714d71c2c106a24a7548ea"
+    },
+    "0xa29FfE4152B65A0347512Ae5c6A4Bbc7a3d6d51B": {
+      "longPoolAmount": "0x6693ae65f8c7bbbdb4dafdc6e2d2a4824b589b7c7454b411517e795feae42bc8",
+      "shortPoolAmount": "0x29057b0a5f9faf83d5b250aa95a44056aafe0c87f6ebbed9ff5bede52e4b2d7e",
+      "positionImpactPoolAmount": "0x2882e4b9bb2ad8ea954630b4ecb75982cf32cba38bac0acaf3db59d61735bee3",
+      "swapImpactPoolAmountLong": "0xd496578938511700e33179b3c23bd8fed3ce421ad8800f4dfd11e3363ba2dddb",
+      "swapImpactPoolAmountShort": "0x3308ca648709f2b017c80f87483d2f87e1f55bc67d0a7de075d50ef01af25a13",
+      "longInterestUsingLongToken": "0xd5f0aacccbc59df807fe217610dff270e934ce85b5629a8bd93f723389fd628c",
+      "longInterestUsingShortToken": "0x250a4ce3cc83fa6179cdff4c755cd1434fa1d2ca4fbc8dd0db896098ce0fd94a",
+      "shortInterestUsingLongToken": "0x977c23ba871ab8a9572a25e627de71e8665f2ff6f3bcd6fb8aa1c033382ec0a1",
+      "shortInterestUsingShortToken": "0xce032220c9bf7365cd2b408a5f6bb2df31f6220585ceaaffbecb714a182cba81",
+      "longInterestInTokensUsingLongToken": "0xbb9538095139b99b8d1a471e5298108f9879203fdc9f88e302b98edbc810f377",
+      "longInterestInTokensUsingShortToken": "0xaf453df5666a65e4ccc0f2a16fe04f10e5c7c44b0c24d8ebfdd1da10e0b57e1e",
+      "shortInterestInTokensUsingLongToken": "0x168d1abf6abf13f235b7fbc88ac6a316e280110fb243fa96ba0d1d39184a8863",
+      "shortInterestInTokensUsingShortToken": "0xfd8853a8fc94ff0f74ae1b99c4dd162d6a5673bf3a2b1d7cea2217cfecd8ad2a"
+    },
+    "0x9f0849FB830679829d1FB759b11236D375D15C78": {
+      "longPoolAmount": "0x21b6ff319e87d9484b5155577154f1e7eb2a02719b2c78877e1b878bd628aab6",
+      "shortPoolAmount": "0xcbcc6f24046ab5a5cb181328fc5279797aa888128db0943ca97d5e29cd07589c",
+      "positionImpactPoolAmount": "0x7bc771e3bd2c1e339894d8cc0e339f3bd29571b1f81dc4aaab752d9d5c4565d8",
+      "swapImpactPoolAmountLong": "0x9b8e8803dce19ab635bdcbd739151269bdcfe50181bdded95378e3fd86b32060",
+      "swapImpactPoolAmountShort": "0x55f2af971ae258c2ac5ae48e016329ea7e3d41558f1171bc082f9de3c822dff3",
+      "longInterestUsingLongToken": "0xe7339c70b7e5f38ed83fde6e7db586b5472612110751aa45da936bdbac49d176",
+      "longInterestUsingShortToken": "0x8be7905da5f947c317e5183fdcb4ccfa7dc100dd7b612f5c7ba9ecba45220914",
+      "shortInterestUsingLongToken": "0x35cff8db41f43cd082d5ec9e12c8e41e96e62da8ad6e9f62c24ab649ae2de828",
+      "shortInterestUsingShortToken": "0xd933217c4dd384699dac11292fa70a208607ffbf9a63beb7bae9d66b1b7080b8",
+      "longInterestInTokensUsingLongToken": "0x3953a9515c3bf950fa114c7de0c76524b7dce1188855ed5e1858ff72a757b4f3",
+      "longInterestInTokensUsingShortToken": "0x0b102716f7adc9208283d13cf4d33943256dda36d1ee07862e50753261911492",
+      "shortInterestInTokensUsingLongToken": "0x6a9fe892379ef84c1da651fb1b30387a0d01a1569c5351d4a18984b34bfd1f62",
+      "shortInterestInTokensUsingShortToken": "0x84181252090dc10bfd3e2e1e50d08518e7699461a3fa413f0231e14bdacb16fd"
+    },
+    "0x41E3bC5B72384C8B26b559B7d16C2B81Fd36fbA2": {
+      "longPoolAmount": "0xd6ed59f255e08bef3cf9e68aa634540a79f8cf8c24a8f1afbbdc50d71fdd5b73",
+      "shortPoolAmount": "0x8de9f8593e9eeb6e5362d0d1c895805b3d1e668310efc235dcaa2d2c404c788f",
+      "positionImpactPoolAmount": "0x7222de6cc3da940aca8ee2060a44d3de7e70ecd226f81f9a1b2ca69d6a6a2644",
+      "swapImpactPoolAmountLong": "0x52336ec1e9c00866cbede2fbe31e97ff00baf2a6e3a26ba3620216a96c74e1cc",
+      "swapImpactPoolAmountShort": "0x127deefe4568977525b74d0b273ed1d87786f0d42a695653794bbd73ff876f49",
+      "longInterestUsingLongToken": "0xfa0eeda66aa4975b3a93cf07412f2cfeee9834076ff9c1e85f60f00a4c523462",
+      "longInterestUsingShortToken": "0x08a35ff52c7b661c5dcb38f52398a128d4fc1aeae9c5c45ff08e5cba6e01d174",
+      "shortInterestUsingLongToken": "0x7db9b4dee13ca7279a42d464d3031dea20b5b677f20cdf5b20710a82324945ec",
+      "shortInterestUsingShortToken": "0x9c2a5fee2968fb07453d28eb67579914466110b820d4b96d9a48e7adcce43578",
+      "longInterestInTokensUsingLongToken": "0xb5e89a6d37702072e196e5441e96699d88f453415a13db6e8d80ef6a25222c12",
+      "longInterestInTokensUsingShortToken": "0xc76b943c3379d44c6d5a908c2c3fa46f9ec10174347bf7dd1658d2c1f027e60c",
+      "shortInterestInTokensUsingLongToken": "0xc8b8935b9902170550dfb96508f2ea66040dfedd45158b208a858d20acbd929f",
+      "shortInterestInTokensUsingShortToken": "0xfc8615b99a334d4bb6cc031e1094a9fe778c53077112dc1618c605b0b3e84dc7"
+    },
+    "0x4024418592450E4d62faB15e2f833FC03A3447dc": {
+      "longPoolAmount": "0x83f34cc222753541fc5a71c11281066b32f516795bf4a8ef8e72ff7e0c54e436",
+      "shortPoolAmount": "0x66fbafb6e6d8e08c11832bf31814caa8f6a95c301c3619bbeaa8835108e8a378",
+      "positionImpactPoolAmount": "0x2541d06e4691a422b923bd6675ec85a5ce82eda37f4ec522b1c6b9256841dfe3",
+      "swapImpactPoolAmountLong": "0xa085cf24fc0f0f4bd0bb963935565be9a367b5e8d90e154692b8d6c01f849f5b",
+      "swapImpactPoolAmountShort": "0x4277b357f8145ba122dfc509d9615e7ffbd88f9c6ae1a647edbece5beab18b14",
+      "longInterestUsingLongToken": "0x5e70ba3d2b3949a2b2ea13fd5b984b161752fe5617e02f777f2687a92dbe0c6e",
+      "longInterestUsingShortToken": "0x7f8d92fae1514a43bde14520c2b62f05cdcb3c516f9c057aae527e5caff0650c",
+      "shortInterestUsingLongToken": "0xb1d21632141d96aac72c4267fa7ab91127f3f3b4f6a239bd98025ff4d4904c25",
+      "shortInterestUsingShortToken": "0xed6b6a776eb923184cdef0888b7c6131065dc62e9fb3e8485852626b9f830557",
+      "longInterestInTokensUsingLongToken": "0xb8e1a132e4523d7ad7c86d630a12c9c166aaecc01293303a4ed54b43c6ace833",
+      "longInterestInTokensUsingShortToken": "0xdd7f9cbbea3932ac56d5821e688b06257fdcad3e617f5f3a4a998019c7182e5e",
+      "shortInterestInTokensUsingLongToken": "0x1e790e78ad84d7aa79f44402cd60cf352af29c5b6eead4c92244d7be1d538d1d",
+      "shortInterestInTokensUsingShortToken": "0x8c0fdb55a8f1c62ce6e80c0563160e8c1c3e4b96d0a26ec7ab862ed027c264f5"
+    },
+    "0x2a331e51a3D17211852d8625a1029898450e539B": {
+      "longPoolAmount": "0x659509d7fa0fda2d8e744e0c9644d219df684fbc50598b1d1b15d88b9313c681",
+      "shortPoolAmount": "0x3e0c8ce5fb9cf02bb8556946902167b4841b475adc549fc5fb5c041b674bff9b",
+      "positionImpactPoolAmount": "0x65c4c70da8cdc0fb0b45eb00c226f85deee481283ac2cd33f39c872fd3db5938",
+      "swapImpactPoolAmountLong": "0xf72fa15da10d167ca27c544b595ecd700ea8329b10ed2631e9383b7b4b820922",
+      "swapImpactPoolAmountShort": "0xae355549c57a687fd96229c3e5f02d2886c7d25ae243088d950cd86968e9a9ff",
+      "longInterestUsingLongToken": "0xd46023d8348b8b885875e18a02e1d5736f685867ec4e8be5ee445cfa37d580f1",
+      "longInterestUsingShortToken": "0x91ecc8e169c4a8f0b52cfdec15975121c4ca08e4719de7644915427222e11f7f",
+      "shortInterestUsingLongToken": "0x02cf20750719c9ca3489788be07d62221679996956fda294cecf59948d182ed5",
+      "shortInterestUsingShortToken": "0x7dcee765554639c9fc9ea5dbbd16dc17a2b17adadceda176a42ebe1416bc6ed9",
+      "longInterestInTokensUsingLongToken": "0x10bbf01caf11a412eabf5f96f17e554bcaacf1bf851ceee9820a1be78c477aae",
+      "longInterestInTokensUsingShortToken": "0x2bbf2a4970d56ecea00c8bcb796e89404bfd59aa8a97f1c088f19f00fd12ba31",
+      "shortInterestInTokensUsingLongToken": "0x8ce7591973fe243cc0099e82295c51dd26024e0820aca410607fdd5a1427f1a2",
+      "shortInterestInTokensUsingShortToken": "0xaf9d5fb1cefaf0a08e43a88456228b8e30e67fe43f6355db440585ec197ce6dd"
+    },
+    "0x3f649eab7f4CE4945F125939C64429Be2C5d0cB4": {
+      "longPoolAmount": "0x50021591a0db3ce445862a6deccd582a8a89f7e7b8a395ff7c3e6a9c1641ebc0",
+      "shortPoolAmount": "0x46e840b7349f19041d03c15334d9d36f598f934565c0c1d5cb7cc1444aa7af26",
+      "positionImpactPoolAmount": "0xea29851583407889ceed629935a7725d49c1b1cdf8f7d9f36950c9fe0bec3d5c",
+      "swapImpactPoolAmountLong": "0x55fd263f5a7b559af2a67b50ca6a156e8cfedb40660fb5f9c0683fed5b016a70",
+      "swapImpactPoolAmountShort": "0x019bbdc9a4d0bf4d6fb72ba20350b1ae78d68261409062264dac47730129a7a2",
+      "longInterestUsingLongToken": "0x2678021537f42a4dfbd6a3a9abbba466e9112f7d00a98920c853179e45080b49",
+      "longInterestUsingShortToken": "0x254166ee412fb56fe6bf12ff0351026a135dfbb3a63a7d5e768c8d660a8ee14f",
+      "shortInterestUsingLongToken": "0xa55c83874b02c061524f33b53fe646548ce37b83a4d9c8375087d3bf745062ef",
+      "shortInterestUsingShortToken": "0x6dcbf98ae30f2d205771f8aaa0e84afd62175ad41cc6a6035fe5b6ad17cb3c97",
+      "longInterestInTokensUsingLongToken": "0x4f56026fa3fd35ae7036b41c2a967c921ff837db320c1cce338da05b0528ddea",
+      "longInterestInTokensUsingShortToken": "0x00e69b7bf298b90c16ef69ff36db4b035a598bff7b80f69269d4ea8683d8fcb1",
+      "shortInterestInTokensUsingLongToken": "0xdaa2bc65d530f5cb53b34c1a342f0b0c1560ba589d2e9fea3bd3c63a839ecdd1",
+      "shortInterestInTokensUsingShortToken": "0x01f14b9baf4d510252960662eed0c373507faa13b8141454255241fdf8435afc"
+    },
+    "0xfaEaE570B07618D3F10360608E43c241181c4614": {
+      "longPoolAmount": "0x8a72f9dd5241aae4fec3f462150eb6ec079c0e57a268744249ad38644efa68ef",
+      "shortPoolAmount": "0xcbe25ccc91ef8a53882bdf1d5f942cd8badd8d59c09e5b8617a21fea976603e0",
+      "positionImpactPoolAmount": "0x9d2316aa3880c4d911fdd7cd8fc31d7f1c6cb1c89a0d816ba9cabc134f0d064f",
+      "swapImpactPoolAmountLong": "0x64907bf4a3b9aeee952aa2f4fd03ad6775d536ebbcfa2d22e1ae1e35a2d338b0",
+      "swapImpactPoolAmountShort": "0x959ad5a4dba9ac953420a0735929bd9f1e4f4a814aea3eea834fc06c88384afe",
+      "longInterestUsingLongToken": "0x06a39814acd5d9756fc552e09ae57737aa3c62d174aa5e651ca74f5fbb8212cd",
+      "longInterestUsingShortToken": "0x7ed444d60e663737325d75baf64a9d272ef5ca5b136f30144d475d45c8a7f774",
+      "shortInterestUsingLongToken": "0x2826923e2508ed051f1d376cd7fd11fad83feb6c865a428231720640d2df7110",
+      "shortInterestUsingShortToken": "0xb31048797c81f2c66f83b6ac15411f2570c7140c71cbdfc993cdae66963fef68",
+      "longInterestInTokensUsingLongToken": "0x432027648cd2b1542d9bfb30e3979578b1e29eef0e0d3b4f88807ac37fe33513",
+      "longInterestInTokensUsingShortToken": "0xad49f2d31a82ad8b9d6a80434d1729841da6477f672703ef3cc46d7fed32163a",
+      "shortInterestInTokensUsingLongToken": "0xd173bc3d0d10312c88d35bf8eb1cdea9f71e7aeb48fa8b97fcb3e7b70debb76f",
+      "shortInterestInTokensUsingShortToken": "0xf08346748fcaf05878849d20375b4bdde817abb3a030c259ceb5607d4d2db468"
+    },
+    "0x6EeE8098dBC106aEde99763FA5F955A5bBc42C50": {
+      "longPoolAmount": "0xf0f68ff6a59536f53d75d1290668f43d86036aa93021b8c1a54f743eec140ae0",
+      "shortPoolAmount": "0x12876f72e651deac6f33082e4d16bb817d98550d5cc9243b5b4a25fab6401315",
+      "positionImpactPoolAmount": "0x17d4b7dbc22006be9840cb37fec14b70790cb6f69d4507706c64186827bb4c58",
+      "swapImpactPoolAmountLong": "0xf6fa1917141d60ec14934a75f2d63ff3ed0e1f38688c8a421b1ab995d811ba56",
+      "swapImpactPoolAmountShort": "0xfe036fe6d6a67d305e8927c485d1b78f4e8b05b913e0e72c092414b5e684e413",
+      "longInterestUsingLongToken": "0x617c6f662ef4c095f73e9bfd59b61dc1c16030db39cc5d8e5d53150b622d8133",
+      "longInterestUsingShortToken": "0x1abbb5e44eedad51541b1a193c0c032a38ccf2b41e5830a6e408600a5224080d",
+      "shortInterestUsingLongToken": "0xbdb508d5b3e8f585c7b62dcf8325189eb23b47ca22096a063a97dfc732c9bf10",
+      "shortInterestUsingShortToken": "0x64b1331a2bb3e6cd07c41c58906e6e124a222c1823746b2b4ae88c0c1cba2db5",
+      "longInterestInTokensUsingLongToken": "0xd2e95ba95918bffa388956782ae752bc84c80f006821d0d25b6aea7a3b0673a9",
+      "longInterestInTokensUsingShortToken": "0xdeb4a1cb7576524fdd7aca3983e6fa086ccdaed271bb8901b921e8aefd2d0290",
+      "shortInterestInTokensUsingLongToken": "0x279f4f7193060e6d7a03cae98cb3600919f4c62f9bc45455c763fc9fd4036393",
+      "shortInterestInTokensUsingShortToken": "0x3a5b89ac8075a9b0600d0bfbbc8750dc5240297f942646d4665e4ebaa27f99d6"
+    },
+    "0xb3588455858a49D3244237CEe00880CcB84b91Dd": {
+      "longPoolAmount": "0xe2371c5c929d4777222ab27f74abce5bb121bc461c7348dbb986ea3c3a8ac782",
+      "shortPoolAmount": "0xe37dbaf4f42147b19722527f418f97a33a7f0abf9f35d768ea661cf3d04bf49f",
+      "positionImpactPoolAmount": "0xb88ced6c6baba2c8d4d00a2095efe33f80462e5e97f12ac5b00c4caa645859d5",
+      "swapImpactPoolAmountLong": "0xc3c16377eab524ae40cb98b1c081a1c7ef5d047315ef6d61835b92e97c67aa27",
+      "swapImpactPoolAmountShort": "0x0d7dc09d659d2ac0466d0098192e57a1c861a0e213fd164516029af3e11a9ee8",
+      "longInterestUsingLongToken": "0x9fa688dfb0e144d7b35c644d214a32dac98ddd6df7b16a23b30cfb574694ef84",
+      "longInterestUsingShortToken": "0xf61885cc87995d2294e91c634de592010e1367e64bec74eba8124fb995b42f68",
+      "shortInterestUsingLongToken": "0x4c26636aad88b1f13cf67eea34dabffa123741bd428950f810a4748b0ff60ab7",
+      "shortInterestUsingShortToken": "0xb09abf74d298edf201e156aa3cd71aed0dd5ac4a2ac5fe964ab50cbfe157bc90",
+      "longInterestInTokensUsingLongToken": "0xffbe460b595251eb74d5e5d6f91ef9431b216faf56bd466cf118f4017c1210c0",
+      "longInterestInTokensUsingShortToken": "0x87b8fbd9d598471aa3ea5053c9840d7f6496057bf367d550291b429725d88d91",
+      "shortInterestInTokensUsingLongToken": "0x0304eeddd5d87227f90e9dd22b3ad39573da0ed1d07c0ae5d2b3a0ad9b14ca19",
+      "shortInterestInTokensUsingShortToken": "0x0a28d88d02c6da0f1e9da244a7db2b1f9a8c231a341025ba72f8ed7d3979abe8"
+    },
+    "0xF913B4748031EF569898ED91e5BA0d602bB93298": {
+      "longPoolAmount": "0x4e32b073b1d891267faa911b2026d27398e783fe47ac5897f0ac3e65a77b180e",
+      "shortPoolAmount": "0x74beee2ee892cd19cdd4c49e4e87ed9ef91932777f7510cb08afa76955f5e56f",
+      "positionImpactPoolAmount": "0xbad08b4bdf3ca9496bf7be36238681eb5ade243558ae504cd5f578c7942d0455",
+      "swapImpactPoolAmountLong": "0x93d1a8df53a9fb5e5792da0d0941aa43d89b778f728559eef47c8b4ccad6ae22",
+      "swapImpactPoolAmountShort": "0xb54532f7ba14c372e33175bc4b211d4f17afaef58151c88b619de877f1a2d38f",
+      "longInterestUsingLongToken": "0x2619523773cac98ea0e5199dca5c8f9d17708a21f0d18e230932effbade1c8c7",
+      "longInterestUsingShortToken": "0x80ab066711c75e89aafe87550f1925d75dcc1065348b18a36cb5fe501bacad69",
+      "shortInterestUsingLongToken": "0xf4a4e80263f30771406ab23258fb5e0f3cc5dfbaa1b4b7a33dd9b81d94c2bd95",
+      "shortInterestUsingShortToken": "0x6e905caaca22092a177156b3462bc3151b8c587ad4ea3582548cbc7195f89ad5",
+      "longInterestInTokensUsingLongToken": "0x561f5a9761274c3ac1667aec675f97a263115b837cdd55c1c2c8d44af40d9cba",
+      "longInterestInTokensUsingShortToken": "0x5fa74582bd92383fde22c777688c0686e7af27efd082e47955f2707f94787d9e",
+      "shortInterestInTokensUsingLongToken": "0x0d97214c2dc1a5e2b6bcf67a3c80f2359a0f3dea82b1c140f12a4cc052dbf903",
+      "shortInterestInTokensUsingShortToken": "0x328e1d94076bf2a92e9cd803136b955f233accb8d5754a2fe5344b4a6e4fb358"
+    },
+    "0x4De268aC68477f794C3eAC5A419Cbcffc2cD5e02": {
+      "longPoolAmount": "0xe28547c0c17bd91a25c645d777adc9219889531845d68d5d2955f5a9e7adf388",
+      "shortPoolAmount": "0xe9ecedc339bb8d14e1d68eb288c81c1b22fb3e6901b0421cf39379a59b731850",
+      "positionImpactPoolAmount": "0x97bfc9130f5af068d0994759abc5cefc6a318a01cac69c23a3e5ad371fd2c4db",
+      "swapImpactPoolAmountLong": "0xa72ffb68b7795fc2811a2bb09816ce651232d3b0b82ebf53ff16e10cb6df845e",
+      "swapImpactPoolAmountShort": "0x50ee7507f04693208d277e1df709052311339f8b0dc88614fdfaed21cbca341b",
+      "longInterestUsingLongToken": "0x407192382563274212987e487eae9da0913fb07a67cb172c90f6c0ba8fb0396f",
+      "longInterestUsingShortToken": "0x46e53daf34ea673270d48e3378485694a42cc89330e4a249a06b7eda50ee2d41",
+      "shortInterestUsingLongToken": "0x2da73ffa3d816951ae5ac1483405e0214bfc4d923637a80916a1228721251316",
+      "shortInterestUsingShortToken": "0xd5939b0acf91f8de52396a2ce2b022ec942f519e0420c3fe4506f5dd77c872b8",
+      "longInterestInTokensUsingLongToken": "0x11c80459a0f4d665e2697d461b89e4a3b3e5ed4190127f59035a5164529ef129",
+      "longInterestInTokensUsingShortToken": "0xac7b7a5b15fd2f40becd35de5403b5825297c9fe3e9591293608426db2a5f857",
+      "shortInterestInTokensUsingLongToken": "0xbe2e062d70098fedc078ce344d49096edb0c2d483efb8b40a073df2d3bec1675",
+      "shortInterestInTokensUsingShortToken": "0x7148ff630c4aedff55c32c9d296df445e408dc02e19c62c578906a9f2589508b"
+    },
+    "0x947C521E44f727219542B0f91a85182193c1D2ad": {
+      "longPoolAmount": "0x4f8ca797a73bd7a6e0e5764371def4943c729d59d0c0c2425df547412012b2ae",
+      "shortPoolAmount": "0x50e613546ea75d92cca3aee5c5935d34a16bf100ab7db93f34b6005249d59e22",
+      "positionImpactPoolAmount": "0xf415f967aa02cc464e3570e521e26084591233246a30ff64cdbe477bc5617619",
+      "swapImpactPoolAmountLong": "0x64abd8a5fd4efce5e402f51bcf0820d4ea2ada8027eb690fb413ed348a000bbf",
+      "swapImpactPoolAmountShort": "0x8dbe415bc61935945bd9b52baf0715c6fb445634124660fc8c01946c05b93762",
+      "longInterestUsingLongToken": "0xfb3c77df1fcefa269177768c1b9fcf9fddaf0ba8a99f382b0536ca76fc67e2dc",
+      "longInterestUsingShortToken": "0xe544cac798429b4da6359e02136f7330d29f4ec4b5797f0652e86bf047775a12",
+      "shortInterestUsingLongToken": "0x595d76c42178ed7d18884f651b21e8d1d10280166f208dcfbba93146e0126f58",
+      "shortInterestUsingShortToken": "0x0e1e76c1bec83587626de9f55c180513ad9c6276d83d6c7d7fcc8228d0165f21",
+      "longInterestInTokensUsingLongToken": "0x1d40144557c68977be40c3609c4cd3011615c82baedc60d1faceeee0fe58d03c",
+      "longInterestInTokensUsingShortToken": "0xd42c20c92ee8add244311eecce0bb9aee2e34509a642fd45cb091646c0e3136d",
+      "shortInterestInTokensUsingLongToken": "0x5685c9c3cedc76f7f4eb9a550a783ba3d1a51e0b83624559df6f18ecd2395abe",
+      "shortInterestInTokensUsingShortToken": "0xa029faf66a0c6d3862e25e5f180756e6552e04c2c95193785e0848191c045ded"
+    },
+    "0x2347EbB8645Cc2EA0Ba92D1EC59704031F2fCCf4": {
+      "longPoolAmount": "0xe6b0f43e7615e46a90205e63d63e43687c7e578e404fca321711f427f7f0c8b1",
+      "shortPoolAmount": "0x34aaea7b406618de19385f819b0ab9caa7debb9713c44c14e495efb4f73d6a73",
+      "positionImpactPoolAmount": "0xfdd324af6053708576054f97c7a56b0be5d67603503335d7f9f182705b94e70e",
+      "swapImpactPoolAmountLong": "0x5452823907a822ac7742924415616dfe23a07a931ceaa50fd28b9470067f0bfe",
+      "swapImpactPoolAmountShort": "0x377e578ba634d7cc4b1e874e640c005c3f80ba45d59060e4ea1ab0115905c743",
+      "longInterestUsingLongToken": "0xe2fc113ed7c4e1413282c85d324137ab9c9e9b067954c71c313acf36b05c498c",
+      "longInterestUsingShortToken": "0x69d46c6d0f72f52d4c6e9a31dde0d1280d82b349b42dfa7c3708c43213524c93",
+      "shortInterestUsingLongToken": "0xfefdadf4b69a4dc1789be717ca1db60bedf0435c3e1c4b27f9f670a44ef01d6f",
+      "shortInterestUsingShortToken": "0x0eeca8196e7d5b7d6321eb72ee60d9716e0eedaefdd54c1a1a671bf3e734647c",
+      "longInterestInTokensUsingLongToken": "0x0e36a6eda64ca5fac6eae3ef799ffcbfbd61c737850cb101f76da735137ba816",
+      "longInterestInTokensUsingShortToken": "0x1ff50c1b1d847765805fc064151fd0dd0cc5a70e3ccae18692296216c566dba4",
+      "shortInterestInTokensUsingLongToken": "0x84f2e6f5d63becd425968f24d9eafa3e629fa6c1e802a36531fdf7942131fcf1",
+      "shortInterestInTokensUsingShortToken": "0xf2974ad3b0355d5e21d9f0bb876e1362ed876460902b71d2127c86c885f96a00"
     }
   },
   "43113": {
@@ -1758,6 +2165,113 @@
       "longInterestInTokensUsingShortToken": "0xaf01e4f4a7b0884f217695d374acc70a5904db6d460bc5c5d31591557300f689",
       "shortInterestInTokensUsingLongToken": "0x562b9a09cca894aa54f6d4b17a72fe7e9c4ddc4686516dcfd15a597f3eec7ee3",
       "shortInterestInTokensUsingShortToken": "0xc563cc005593b275e1c8e42f993a0b8df38c5d1634f6867ece778bea7be36823"
+    },
+    "0x94cE6F65188a92F297C7f0A5A7B3cAd9013450F8": {
+      "longPoolAmount": "0x0cfc5b6a91f7d200cae8e17385f5c1fd9b500ba6919cbf2e8cec407444011762",
+      "shortPoolAmount": "0xb6914e1bc1f98f7ccb5bd8c45a6f66837aaa99b2dd99cce7445612f34d61159b",
+      "positionImpactPoolAmount": "0xdee53ff0bba09c25e3b7b789306f2f0748efb7192065f1e8f7048e202dd961a6",
+      "swapImpactPoolAmountLong": "0x80a076262b69e244f998a5e5223c9be6a98454c49f5035e917e980745aedb3c1",
+      "swapImpactPoolAmountShort": "0x0ef33099e30c494475f3538713b9d743ef7d10110336e09a076dba073c1d50c2",
+      "longInterestUsingLongToken": "0xb7bd39bc06702cd6a32bb1f032526ef3eccbfe167f07f613fe092b0407dfbc2f",
+      "longInterestUsingShortToken": "0xa4f7b789a5352e3e7647a57749c1c429c988f01e0418f452cff7ffac89a1ab31",
+      "shortInterestUsingLongToken": "0xc535618ec842c32b50e86466a8d22286ad738227af317ce4d50dcb098780b650",
+      "shortInterestUsingShortToken": "0x4de2b3fa042fd5b54999ab452e6fb1080a078f2ccf6e19c933ad1414defb3730",
+      "longInterestInTokensUsingLongToken": "0x3c9e0baac56e2818c4a3eb98924f340b2f65d5fec4afe3238d2744be64c62406",
+      "longInterestInTokensUsingShortToken": "0xd0ce682e37dcac3e21bfb60546f612310ddc6d55cde3010a03f39c8254c58c9e",
+      "shortInterestInTokensUsingLongToken": "0xe4a0a086a57e5ebf93c02996173518a25df8280b48bfaab22ddad851d5d5f279",
+      "shortInterestInTokensUsingShortToken": "0x459afc07ae83faa216fe9bcbbb75a032a0557d866842476547540f230077ab76"
+    },
+    "0x1cb9932CE322877A2B86489BD1aA3C3CfF879F0d": {
+      "longPoolAmount": "0xad56a0742868c3f4d39bdabc6eb90751687b8783cd4d1c87a656b972ac94f362",
+      "shortPoolAmount": "0xc4860b276e11628fdf9568c1ecafb4c1f1696e77ff9f2107f2d0a25d8674c189",
+      "positionImpactPoolAmount": "0x1419731b8a479a3688df057e0a4033c443e675e518b5591180bb313dc11ce678",
+      "swapImpactPoolAmountLong": "0xdd20e2c64c6f0a1239498b6ccca9663021d35f8c343865f706597a54bd0cf7b1",
+      "swapImpactPoolAmountShort": "0x7acdba86bcd54a661ee090115379fb5e819a82e6fd137e6ff6cd53379e31581f",
+      "longInterestUsingLongToken": "0x55163a490779a711bfdd9608942dd00fcc82b5a5bca21f5e5651d1e0cd2073d1",
+      "longInterestUsingShortToken": "0xe9e15ba9bf85cb3daf420725890f38a8022d9d4014eff9623827a8a3a1db27b9",
+      "shortInterestUsingLongToken": "0x0d91379d8f3eb0c60e304b5ba7800655ecacc3ca8deddd3688e7d2a0f0931fd9",
+      "shortInterestUsingShortToken": "0x95e8052b45df9ba1e967e650cf45f7109e29effb3b2ad0ad0ad99cfe247fe4f1",
+      "longInterestInTokensUsingLongToken": "0x767e1771b41d53e64006f73ada7340e3cf1785f9b217b47b76dd71b53f5c6055",
+      "longInterestInTokensUsingShortToken": "0xe66cbf40dbb64071b803a8739120264576e6de7d7eebf7c3f75a12a97040d222",
+      "shortInterestInTokensUsingLongToken": "0x6e32e6700f16a1a53fe8c811c5b3e7ceee4b7c7552816bebe96ebca708c87e25",
+      "shortInterestInTokensUsingShortToken": "0xd710836d5908bc3e16f18b7bd2f7f2930256fba5067f84b467f2aad0818aa49a"
+    }
+  },
+  "421614": {
+    "0x482Df3D320C964808579b585a8AC7Dd5D144eFaF": {
+      "longPoolAmount": "0x1ec0396d749853b2fbba67bf4a9b63ee6c10acc4d2f436febe09f1d1f22b0c5e",
+      "shortPoolAmount": "0x966ce6d85e013c191a28ae5d018091e0977856d1e46c38f400d171c0f167c61b",
+      "positionImpactPoolAmount": "0x59846886db6aea850e805c57f34fb2e011dc0ef1e7adb646d2658abc07f0bf63",
+      "swapImpactPoolAmountLong": "0x57ab3e5d4bf6949f6a528441273a53ab9cd656f343e5d061998cc53065caaabd",
+      "swapImpactPoolAmountShort": "0x6a381d4f3adda0215422faf57cdfc1b16d416a29aa2ff331b4bffc91cd2d0eed",
+      "longInterestUsingLongToken": "0xacda5af0a8de33f1e16ed19c34f899475e2fedff3c74d823744e5dd827e438f5",
+      "longInterestUsingShortToken": "0x4cfb492a8112307cbada8ea447a0ce6a4c11ff2bfade59018ce0ce5c15db6a9b",
+      "shortInterestUsingLongToken": "0x21bbed12abc8ea55003797eea6889821b5edaab8a7797e6bc32a3bf049fe1735",
+      "shortInterestUsingShortToken": "0x817a1463ac1219c0e9b4a0d860e8930a6d46db91ce0d8fabb16500f5f84abb3e",
+      "longInterestInTokensUsingLongToken": "0x100d64c96e9cac0c854f64f9e0df2ef84e0f9345953235c46550f90c0c6b5687",
+      "longInterestInTokensUsingShortToken": "0x189399d250ad271f1a21e2c2f65a9f35cf1ab0f1c43ed0801362c29b65db6e10",
+      "shortInterestInTokensUsingLongToken": "0x9c1e5c3cd21ef1109f76ec647ab04d40fb29f66b5d5f297fcfa8e83c8905ba15",
+      "shortInterestInTokensUsingShortToken": "0xac1c8c21f4f015b06b1f3a276029a141d3c18d6023c2eea7e202f0551ef6b014"
+    },
+    "0xBb532Ab4923C23c2bfA455151B14fec177a34C0D": {
+      "longPoolAmount": "0xf8f5984b5f6823422477171a767c309ef3e66bb03fd9250c2338c923b3f826cd",
+      "shortPoolAmount": "0x17fe969fc101cde65c93cdea179927ea235c4dd02cf6fc4393c2f87c804bf155",
+      "positionImpactPoolAmount": "0x9126d9e193e88aa45b54fbc6cd8065097741e70da912e43ddff7b31a3e1b604a",
+      "swapImpactPoolAmountLong": "0x9d47d3c9bfe2bdc467ff67de884bfad5d4de00e1ca466c99be1a1092a7af2141",
+      "swapImpactPoolAmountShort": "0x5c43473b1082f43b6f9aa5249b7eaab0c4ff65a516bc4fb261b32ff93bd8174f",
+      "longInterestUsingLongToken": "0x169e6b04a9e8678b2b9f7946ece753dade93057f3e9843349f0fe5a7005da237",
+      "longInterestUsingShortToken": "0x3e70f2ab88230fd47e9404a701ef9424e4f20b387eeb9de44c0bb86eaf94a2b2",
+      "shortInterestUsingLongToken": "0x2916e4265d709d2ef21afe08b5ab9f1561d7f26987208b0a8cbfacdc5dadd8bc",
+      "shortInterestUsingShortToken": "0x91a2fce531bf3417c5b52a2a5339e04ee0e1ded24d2d861577c21c988645e0cd",
+      "longInterestInTokensUsingLongToken": "0x66ba10da6bc8084a3a5cc0852a07b2672ff1c5b5c95e63de444f085af32532a2",
+      "longInterestInTokensUsingShortToken": "0xc1180ae0f4a1033944ec547d3b0ef99e10049c319db9d3a46258dfd6badb8ea4",
+      "shortInterestInTokensUsingLongToken": "0xe17033f35824563158cc320f75d6c5555cc82b4e2042604c4cdb4830ef3c9881",
+      "shortInterestInTokensUsingShortToken": "0x58e77d188c1a5575aade08d268601c46aec9fa6947a7f5c834bc2c00d02510b2"
+    },
+    "0xb6fC4C9eB02C35A134044526C62bb15014Ac0Bcc": {
+      "longPoolAmount": "0x5181afcd124d09ecf3cc0183366419590e613f89f0baeb6f2a254b864d1ded10",
+      "shortPoolAmount": "0x343aa8429e73bd4ea04046b08e044979ef44e502b642f8d1ac4205d3a16cdba1",
+      "positionImpactPoolAmount": "0xa4a2162d0d1924d188b6da3e89cc4666698d0673a3ce0d117ac4060d971bd40a",
+      "swapImpactPoolAmountLong": "0x07f51927e52071245c00905daeb9a3f626b50f5d7a776c594476ce5cf2fe8194",
+      "swapImpactPoolAmountShort": "0xd3c393266534b2c089d9a134566dc3808e40936c9b429f6be41f3828397d9cd3",
+      "longInterestUsingLongToken": "0xc85cc31027778d0ea13196668b57ceb45c1ea78917381d411d06fe8a62ab8073",
+      "longInterestUsingShortToken": "0x8b5a79f28c17506e7caf37ae1e02516067eb1f42a1562a2bc9f3799fd7b159c8",
+      "shortInterestUsingLongToken": "0xe2a3d5cb489f8168c7fb25429bd5bc3864cff0081f5bed90f87a0928a4d6a2ae",
+      "shortInterestUsingShortToken": "0xc15572223fa93a63c1306166390d39186b2e13b66203bb8da04f48c05239083e",
+      "longInterestInTokensUsingLongToken": "0x7c8cce0e9bfec8d13e6feff6341af5931b3732a9a55a7f25473a88ca4bbbfacf",
+      "longInterestInTokensUsingShortToken": "0x0b1320cb3d7324a5c2e8e18bb798f8ccfa1acc8e56604c57c1bf4155c73f7079",
+      "shortInterestInTokensUsingLongToken": "0x6be2375335308fffff2d8e9ff62b96acde6d1cffb4ddb1813ebff64cda059f7d",
+      "shortInterestInTokensUsingShortToken": "0x6189501bde268b7f87ea49dc02723f702c95061a6e339774b74bef3341ade66e"
+    },
+    "0x3A83246bDDD60c4e71c91c10D9A66Fd64399bBCf": {
+      "longPoolAmount": "0xa2075faf68c9726bb08bb027b98fcecd4f0f380983553b6aed4a7bf993d02ea2",
+      "shortPoolAmount": "0x414c60762f70eea230bcd80009a752335b653c02037cd66deb7c36dbf3498b81",
+      "positionImpactPoolAmount": "0xe084c2f70684f43aa96742d584cfb131021f8128e5828c29b7b3845423ccbdad",
+      "swapImpactPoolAmountLong": "0x7fb1713aaf6cb5808aff7a90a6af51774c89f8b65f52236d5c9fa0b1d53c66ca",
+      "swapImpactPoolAmountShort": "0x14b77dc07e765ab968065f1a550ad0a5aeec121d1fc90812ae88079db53883b5",
+      "longInterestUsingLongToken": "0x5b3ff89f6dc478e77a3ebecd74a52b7f110bf3f31913ffb4b738e010405ff256",
+      "longInterestUsingShortToken": "0xddad805de02d7bbc3f074197f1c0f8a28ac3452b129d3ccfb977044433ca1407",
+      "shortInterestUsingLongToken": "0x79c7f949bed9c76895450148d13cbd2943e77e7eaa5319a13813eae044a06c17",
+      "shortInterestUsingShortToken": "0x2755569cb50b991dde964096fa69cba032d8b7585f3a08b96682f1802b1b290d",
+      "longInterestInTokensUsingLongToken": "0x8e57e5f724ac170095bdbd8ba1578908e9889266226882bcef5829bc6d2b6c6c",
+      "longInterestInTokensUsingShortToken": "0x71bb78048905f09a82839779926db8aff078392c82b239b5b1551d323e7a50bf",
+      "shortInterestInTokensUsingLongToken": "0x2dad3d52c3bfd9b175fd4422536a36576d5a7b719800cf33f82c2891345fc168",
+      "shortInterestInTokensUsingShortToken": "0x2102a3bee36639520696b3d223cd869c7b21925f61e77331cf32335c4dae4362"
+    },
+    "0xAde9D177B9E060D2064ee9F798125e6539fDaA1c": {
+      "longPoolAmount": "0x50d0f68f6a4fecbc901e4a8082d9317f682e4b2f5a87c11e368abf51c37ae5a6",
+      "shortPoolAmount": "0xfacfa0c2d3c3056986b1c7ef2727d911129f7d4169bf668f9570e8998bd2ad08",
+      "positionImpactPoolAmount": "0xa28e40173205226b450ee3f66e740ac1e123b81eed4198899746b45993480b0b",
+      "swapImpactPoolAmountLong": "0xe80d5b6847cd87925fc341da9e3982e056ef5308ee6735242877c46b36630f33",
+      "swapImpactPoolAmountShort": "0xe0f8ac8f75912883b35bd29b9ccdc044d9b58db259776e40024578264ba5e245",
+      "longInterestUsingLongToken": "0xaead92698f3316bb52e70fd394f1944f87bf576e5ffb2b4a4a1d0c7fdcf8f8b6",
+      "longInterestUsingShortToken": "0x99a8e43d4a6c016b51f0562ca4ff9e5b1fe08e7027c4dd4683ced9ae2f0a4470",
+      "shortInterestUsingLongToken": "0xc81070e2b6a9277ea42887805edb202fdbd227668ea67024d66f69439358c671",
+      "shortInterestUsingShortToken": "0xa0980940eb86bfbe3a5a9a1c03c397b15064c09dba8e4cff7d6add6671f9ce51",
+      "longInterestInTokensUsingLongToken": "0x4087fbc85522f334dc81f3fb0c97490d2bf309131eb503ea550960057037dc3a",
+      "longInterestInTokensUsingShortToken": "0xf61da26292dbce9b746fcc8438f02fab8e8a28a0d610791c191d64038ece27fc",
+      "shortInterestInTokensUsingLongToken": "0x4e9ca5ca185f24d2f633d7bc31c3203b976717299efa1596032b0ffab3e8ff32",
+      "shortInterestInTokensUsingShortToken": "0xfa0bb36ec3ca4732de1401392424dff4ce738063ac80315a014d3fffc4f7bd60"
     }
   }
 }
\ No newline at end of file
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/prebuilt/index.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/prebuilt/index.ts
index b00423fd..31f0c5df 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/prebuilt/index.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/prebuilt/index.ts
@@ -2,14 +2,16 @@
  * Json files in this directory are prebuild by scripts from the `scripts/prebuild` directory.
  * No need to edit them manually, use `yarn run prebuild` command instead.
  */
-import hashedMarketValuesKeysJson from "./hashedMarketValuesKeys.json" with { type: "json" };
-import hashedMarketConfigKeysJson from "./hashedMarketConfigKeys.json" with { type: "json" };
-import hashedKinkModelMarketRatesKeys from "./hashedKinkModelMarketRatesKeys.json" with { type: "json" };
+
+
 import {
-  KinkModelMarketRateMulticallRequestConfig,
-  MarketConfigMulticallRequestConfig,
-  MarketValuesMulticallRequestConfig,
+    KinkModelMarketRateMulticallRequestConfig,
+    MarketConfigMulticallRequestConfig,
+    MarketValuesMulticallRequestConfig
 } from "../modules/markets/types.js";
+import hashedKinkModelMarketRatesKeys from "./hashedKinkModelMarketRatesKeys.json" with {type: "json"};
+import hashedMarketConfigKeysJson from "./hashedMarketConfigKeys.json" with {type: "json"};
+import hashedMarketValuesKeysJson from "./hashedMarketValuesKeys.json" with {type: "json"};
 
 type HashedMarketValuesKeys = Omit<
   Record<keyof MarketValuesMulticallRequestConfig[`${string}-dataStore`]["calls"], string>,
@@ -22,7 +24,9 @@ const HASHED_MARKET_VALUES_KEYS: {
   };
 } = hashedMarketValuesKeysJson;
 
-type HashedMarketConfigKeys = Record<keyof MarketConfigMulticallRequestConfig[`${string}-dataStore`]["calls"], string>;
+type HashedMarketConfigKeys = Partial<
+  Record<keyof MarketConfigMulticallRequestConfig[`${string}-dataStore`]["calls"], string>
+>;
 
 const HASHED_MARKET_CONFIG_KEYS: {
   [chainId: number]: {
@@ -41,4 +45,4 @@ const HASHED_KINK_MODEL_MARKET_RATES_KEYS: {
   };
 } = hashedKinkModelMarketRatesKeys;
 
-export { HASHED_MARKET_VALUES_KEYS, HASHED_MARKET_CONFIG_KEYS, HASHED_KINK_MODEL_MARKET_RATES_KEYS };
+export { HASHED_KINK_MODEL_MARKET_RATES_KEYS, HASHED_MARKET_CONFIG_KEYS, HASHED_MARKET_VALUES_KEYS };
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/fees.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/fees.ts
index 90d1f74d..ff9197b3 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/fees.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/fees.ts
@@ -1,5 +1,5 @@
-import { ExternalSwapAggregator } from "./trade.js";
-import { Token } from "./tokens.js";
+import {ExternalSwapAggregator} from "./trade.js";
+import {Token} from "./tokens.js";
 
 export type ExecutionFee = {
   feeUsd: bigint;
@@ -39,7 +39,18 @@ export type GasLimitsConfig = {
   estimatedGasFeeBaseAmount: bigint;
   estimatedGasFeePerOraclePrice: bigint;
   estimatedFeeMultiplierFactor: bigint;
+  gelatoRelayFeeMultiplierFactor: bigint;
   glvDepositGasLimit: bigint;
   glvWithdrawalGasLimit: bigint;
   glvPerMarketGasLimit: bigint;
+  createOrderGasLimit: bigint;
+  updateOrderGasLimit: bigint;
+  cancelOrderGasLimit: bigint;
+  tokenPermitGasLimit: bigint;
+  gmxAccountCollateralGasLimit: bigint;
+};
+
+export type L1ExpressOrderGasReference = {
+  gasLimit: bigint;
+  sizeOfData: bigint;
 };
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/markets.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/markets.ts
index a0d6b2f9..3e5112c1 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/markets.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/markets.ts
@@ -1,4 +1,4 @@
-import { TokenData } from "./tokens";
+import {TokenData} from "./tokens";
 
 export type PnlFactorType = "FOR_DEPOSITS" | "FOR_WITHDRAWALS" | "FOR_TRADERS";
 
@@ -120,6 +120,14 @@ export type MarketInfo = Market &
     virtualMarketId: string;
     virtualLongTokenId: string;
     virtualShortTokenId: string;
+
+    atomicSwapFeeFactor: bigint;
+    swapFeeFactorForBalanceWasImproved: bigint;
+    swapFeeFactorForBalanceWasNotImproved: bigint;
+    positionFeeFactorForBalanceWasImproved: bigint;
+    positionFeeFactorForBalanceWasNotImproved: bigint;
+
+    minCollateralFactorForLiquidation: bigint;
   };
 
 export type MarketsData = {
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/orders.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/orders.ts
index c7819067..8bd9e99c 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/orders.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/orders.ts
@@ -1,6 +1,6 @@
-import { MarketInfo } from "./markets";
-import { TokenData, TokensRatio, TokensRatioAndSlippage } from "./tokens";
-import { SwapPathStats, TriggerThresholdType } from "./trade";
+import {MarketInfo} from "./markets";
+import {TokenData, TokensRatio, TokensRatioAndSlippage} from "./tokens";
+import {SwapPathStats, TriggerThresholdType} from "./trade";
 
 export enum OrderType {
   // the order will be cancelled if the minOutputAmount cannot be fulfilled
@@ -25,6 +25,10 @@ export enum OrderType {
   StopIncrease = 8,
 }
 
+export type SwapOrderType = OrderType.MarketSwap | OrderType.LimitSwap;
+export type IncreaseOrderType = OrderType.MarketIncrease | OrderType.LimitIncrease | OrderType.StopIncrease;
+export type DecreaseOrderType = OrderType.MarketDecrease | OrderType.LimitDecrease | OrderType.StopLossDecrease;
+
 export enum SwapPricingType {
   TwoStep = 0,
   Shift = 1,
@@ -59,11 +63,15 @@ export type Order = {
   orderType: OrderType;
   shouldUnwrapNativeToken: boolean;
   autoCancel: boolean;
-  data: string;
+  data: string[];
+  uiFeeReceiver: string;
+  validFromTime: bigint;
   title?: string;
 };
 
 export type SwapOrderInfo = Order & {
+  isSwap: true;
+  isTwap: false;
   swapPathStats?: SwapPathStats;
   triggerRatio?: TokensRatio | TokensRatioAndSlippage;
   initialCollateralToken: TokenData;
@@ -71,6 +79,8 @@ export type SwapOrderInfo = Order & {
 };
 
 export type PositionOrderInfo = Order & {
+  isSwap: false;
+  isTwap: false;
   marketInfo: MarketInfo;
   swapPathStats?: SwapPathStats;
   indexToken: TokenData;
@@ -78,10 +88,17 @@ export type PositionOrderInfo = Order & {
   targetCollateralToken: TokenData;
   acceptablePrice: bigint;
   triggerPrice: bigint;
-  triggerThresholdType: TriggerThresholdType;
+  triggerThresholdType: TriggerThresholdType | undefined;
 };
 
-export type OrderInfo = SwapOrderInfo | PositionOrderInfo;
+export type TwapOrderInfo<T extends PositionOrderInfo | SwapOrderInfo = PositionOrderInfo | SwapOrderInfo> = Omit<
+  T,
+  "isTwap"
+> & {
+  isSwap: T extends SwapOrderInfo ? true : false;
+} & TwapOrderParams<T>;
+
+export type OrderInfo = SwapOrderInfo | PositionOrderInfo | TwapOrderInfo;
 
 export type OrdersData = {
   [orderKey: string]: Order;
@@ -92,3 +109,20 @@ export type OrdersInfoData = {
 };
 
 export type OrderTxnType = "create" | "update" | "cancel";
+
+type SingleOrderParams = {
+  key: string;
+  isTwap: false;
+  orderType: OrderType;
+};
+
+type TwapOrderParams<T extends SingleOrderParams = SingleOrderParams> = {
+  key: string;
+  isTwap: true;
+  orders: T[];
+  orderType: OrderType;
+  twapId: string;
+  numberOfParts: number;
+};
+
+export type OrderParams = SingleOrderParams | TwapOrderParams;
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/positions.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/positions.ts
index 80e2b294..ed4d93eb 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/positions.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/positions.ts
@@ -1,5 +1,5 @@
-import { Market, MarketInfo } from "./markets";
-import { TokenData } from "./tokens";
+import {Market, MarketInfo} from "./markets";
+import {TokenData} from "./tokens";
 
 export type Position = {
   key: string;
@@ -22,6 +22,23 @@ export type Position = {
   positionFeeAmount: bigint;
   traderDiscountAmount: bigint;
   uiFeeAmount: bigint;
+  pendingImpactAmount: bigint;
+  /**
+   * Not implemented in parsing
+   */
+  borrowingFactor?: bigint;
+  /**
+   * Not implemented in parsing
+   */
+  fundingFeeAmountPerSize?: bigint;
+  /**
+   * Not implemented in parsing
+   */
+  longTokenClaimableFundingAmountPerSize?: bigint;
+  /**
+   * Not implemented in parsing
+   */
+  shortTokenClaimableFundingAmountPerSize?: bigint;
   data: string;
 };
 
@@ -46,6 +63,10 @@ export type PositionInfo = Position & {
   pnlPercentage: bigint;
   pnlAfterFees: bigint;
   pnlAfterFeesPercentage: bigint;
+  netPriceImapctDeltaUsd: bigint;
+  priceImpactDiffUsd: bigint;
+  pendingImpactUsd: bigint;
+  closePriceImpactDeltaUsd: bigint;
   leverage: bigint | undefined;
   leverageWithPnl: bigint | undefined;
   netValue: bigint;
@@ -55,6 +76,8 @@ export type PositionInfo = Position & {
   pendingClaimableFundingFeesUsd: bigint;
 };
 
+export type PositionInfoLoaded = PositionInfo & { marketInfo: MarketInfo };
+
 export type PositionsData = {
   [positionKey: string]: Position;
 };
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/sdk.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/sdk.ts
index 66962580..efac4294 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/sdk.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/sdk.ts
@@ -1,31 +1,30 @@
-import type { PublicClient, WalletClient } from "viem";
-import type { Token } from "./tokens";
-import type { MarketSdkConfig } from "./markets";
+import type {PublicClient, WalletClient} from "viem";
+import type {Token} from "./tokens";
+import type {MarketSdkConfig} from "./markets";
+import {ContractsChainId} from "../configs/chains";
 
 export interface GmxSdkConfig {
-  /** Chain ID */
-  chainId: number;
-  /** Account's address */
-  account?: string;
-  /** GMX Oracle URL */
-  oracleUrl: string;
-  /** Blockhain RPC URL */
-  rpcUrl: string;
-  /** GMX Subsquid URL */
-  subsquidUrl: string;
-  /** GMX Subgraph Synthetics Stats URL */
-  subgraphUrl: string;
-
-  /** Custom viem's public and private client */
-  publicClient?: PublicClient;
-  walletClient?: WalletClient;
-
-  /** Tokens override configurations */
-  tokens?: Record<string, Partial<Token>>;
-  /** Markets override configurations */
-  markets?: Record<string, Partial<MarketSdkConfig>>;
-
-  settings?: {
-    uiFeeReceiverAccount?: string;
-  };
+    /** Chain ID */
+    chainId: ContractsChainId;
+    /** Account's address */
+    account?: string;
+    /** GMX Oracle URL */
+    oracleUrl: string;
+    /** Blockhain RPC URL */
+    rpcUrl: string;
+    /** GMX Subsquid URL */
+    subsquidUrl: string;
+  
+    /** Custom viem's public and private client */
+    publicClient?: PublicClient;
+    walletClient?: WalletClient;
+  
+    /** Tokens override configurations */
+    tokens?: Record<string, Partial<Token>>;
+    /** Markets override configurations */
+    markets?: Record<string, Partial<MarketSdkConfig>>;
+  
+    settings?: {
+      uiFeeReceiverAccount?: string;
+    };
 }
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/subsquid.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/subsquid.ts
new file mode 100644
index 00000000..ba8f9358
--- /dev/null
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/subsquid.ts
@@ -0,0 +1,9106 @@
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
+export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
+export type Incremental<T> = T | { [P in keyof T]?: P extends " $fragmentName" | "__typename" ? T[P] : never };
+/** All built-in and custom scalars, mapped to their actual values */
+export interface Scalars {
+  ID: { input: string; output: string };
+  String: { input: string; output: string };
+  Boolean: { input: boolean; output: boolean };
+  Int: { input: number; output: number };
+  Float: { input: number; output: number };
+  BigInt: { input: number; output: string };
+}
+
+export interface AccountPnlHistoryPointObject {
+  __typename?: "AccountPnlHistoryPointObject";
+  account: Scalars["String"]["output"];
+  cumulativePnl: Scalars["BigInt"]["output"];
+  /** Field for debug */
+  cumulativeRealizedFees: Scalars["BigInt"]["output"];
+  /** Field for debug */
+  cumulativeRealizedPnl: Scalars["BigInt"]["output"];
+  /** Field for debug */
+  cumulativeRealizedPriceImpact: Scalars["BigInt"]["output"];
+  pnl: Scalars["BigInt"]["output"];
+  /** Field for debug */
+  realizedFees: Scalars["BigInt"]["output"];
+  /** Field for debug */
+  realizedPnl: Scalars["BigInt"]["output"];
+  /** Field for debug */
+  realizedPriceImpact: Scalars["BigInt"]["output"];
+  /** Field for debug */
+  startUnrealizedFees: Scalars["BigInt"]["output"];
+  /** Field for debug */
+  startUnrealizedPnl: Scalars["BigInt"]["output"];
+  timestamp: Scalars["Int"]["output"];
+  /** Field for debug */
+  unrealizedFees: Scalars["BigInt"]["output"];
+  /** Field for debug */
+  unrealizedPnl: Scalars["BigInt"]["output"];
+}
+
+export interface AccountPnlSummaryBucketObject {
+  __typename?: "AccountPnlSummaryBucketObject";
+  bucketLabel: Scalars["String"]["output"];
+  losses: Scalars["Int"]["output"];
+  pnlBps: Scalars["BigInt"]["output"];
+  pnlUsd: Scalars["BigInt"]["output"];
+  /** Field for debug */
+  realizedBasePnlUsd: Scalars["BigInt"]["output"];
+  /** Field for debug */
+  realizedFeesUsd: Scalars["BigInt"]["output"];
+  realizedPnlUsd: Scalars["BigInt"]["output"];
+  /** Field for debug */
+  realizedPriceImpactUsd: Scalars["BigInt"]["output"];
+  /** Field for debug */
+  startUnrealizedBasePnlUsd: Scalars["BigInt"]["output"];
+  /** Field for debug */
+  startUnrealizedFeesUsd: Scalars["BigInt"]["output"];
+  startUnrealizedPnlUsd: Scalars["BigInt"]["output"];
+  /** Field for debug */
+  unrealizedBasePnlUsd: Scalars["BigInt"]["output"];
+  /** Field for debug */
+  unrealizedFeesUsd: Scalars["BigInt"]["output"];
+  unrealizedPnlUsd: Scalars["BigInt"]["output"];
+  usedCapitalUsd: Scalars["BigInt"]["output"];
+  volume: Scalars["BigInt"]["output"];
+  wins: Scalars["Int"]["output"];
+  /** Null when no losses and no wins */
+  winsLossesRatioBps?: Maybe<Scalars["BigInt"]["output"]>;
+}
+
+export interface AccountStat {
+  __typename?: "AccountStat";
+  closedCount: Scalars["Int"]["output"];
+  cumsumCollateral: Scalars["BigInt"]["output"];
+  cumsumSize: Scalars["BigInt"]["output"];
+  id: Scalars["String"]["output"];
+  losses: Scalars["Int"]["output"];
+  maxCapital: Scalars["BigInt"]["output"];
+  netCapital: Scalars["BigInt"]["output"];
+  positions: Array<Position>;
+  realizedFees: Scalars["BigInt"]["output"];
+  realizedPnl: Scalars["BigInt"]["output"];
+  realizedPriceImpact: Scalars["BigInt"]["output"];
+  sumMaxSize: Scalars["BigInt"]["output"];
+  volume: Scalars["BigInt"]["output"];
+  wins: Scalars["Int"]["output"];
+}
+
+export interface AccountStatpositionsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<PositionOrderByInput>>;
+  where?: InputMaybe<PositionWhereInput>;
+}
+
+export interface AccountStatEdge {
+  __typename?: "AccountStatEdge";
+  cursor: Scalars["String"]["output"];
+  node: AccountStat;
+}
+
+export enum AccountStatOrderByInput {
+  closedCount_ASC = "closedCount_ASC",
+  closedCount_ASC_NULLS_FIRST = "closedCount_ASC_NULLS_FIRST",
+  closedCount_ASC_NULLS_LAST = "closedCount_ASC_NULLS_LAST",
+  closedCount_DESC = "closedCount_DESC",
+  closedCount_DESC_NULLS_FIRST = "closedCount_DESC_NULLS_FIRST",
+  closedCount_DESC_NULLS_LAST = "closedCount_DESC_NULLS_LAST",
+  cumsumCollateral_ASC = "cumsumCollateral_ASC",
+  cumsumCollateral_ASC_NULLS_FIRST = "cumsumCollateral_ASC_NULLS_FIRST",
+  cumsumCollateral_ASC_NULLS_LAST = "cumsumCollateral_ASC_NULLS_LAST",
+  cumsumCollateral_DESC = "cumsumCollateral_DESC",
+  cumsumCollateral_DESC_NULLS_FIRST = "cumsumCollateral_DESC_NULLS_FIRST",
+  cumsumCollateral_DESC_NULLS_LAST = "cumsumCollateral_DESC_NULLS_LAST",
+  cumsumSize_ASC = "cumsumSize_ASC",
+  cumsumSize_ASC_NULLS_FIRST = "cumsumSize_ASC_NULLS_FIRST",
+  cumsumSize_ASC_NULLS_LAST = "cumsumSize_ASC_NULLS_LAST",
+  cumsumSize_DESC = "cumsumSize_DESC",
+  cumsumSize_DESC_NULLS_FIRST = "cumsumSize_DESC_NULLS_FIRST",
+  cumsumSize_DESC_NULLS_LAST = "cumsumSize_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  losses_ASC = "losses_ASC",
+  losses_ASC_NULLS_FIRST = "losses_ASC_NULLS_FIRST",
+  losses_ASC_NULLS_LAST = "losses_ASC_NULLS_LAST",
+  losses_DESC = "losses_DESC",
+  losses_DESC_NULLS_FIRST = "losses_DESC_NULLS_FIRST",
+  losses_DESC_NULLS_LAST = "losses_DESC_NULLS_LAST",
+  maxCapital_ASC = "maxCapital_ASC",
+  maxCapital_ASC_NULLS_FIRST = "maxCapital_ASC_NULLS_FIRST",
+  maxCapital_ASC_NULLS_LAST = "maxCapital_ASC_NULLS_LAST",
+  maxCapital_DESC = "maxCapital_DESC",
+  maxCapital_DESC_NULLS_FIRST = "maxCapital_DESC_NULLS_FIRST",
+  maxCapital_DESC_NULLS_LAST = "maxCapital_DESC_NULLS_LAST",
+  netCapital_ASC = "netCapital_ASC",
+  netCapital_ASC_NULLS_FIRST = "netCapital_ASC_NULLS_FIRST",
+  netCapital_ASC_NULLS_LAST = "netCapital_ASC_NULLS_LAST",
+  netCapital_DESC = "netCapital_DESC",
+  netCapital_DESC_NULLS_FIRST = "netCapital_DESC_NULLS_FIRST",
+  netCapital_DESC_NULLS_LAST = "netCapital_DESC_NULLS_LAST",
+  realizedFees_ASC = "realizedFees_ASC",
+  realizedFees_ASC_NULLS_FIRST = "realizedFees_ASC_NULLS_FIRST",
+  realizedFees_ASC_NULLS_LAST = "realizedFees_ASC_NULLS_LAST",
+  realizedFees_DESC = "realizedFees_DESC",
+  realizedFees_DESC_NULLS_FIRST = "realizedFees_DESC_NULLS_FIRST",
+  realizedFees_DESC_NULLS_LAST = "realizedFees_DESC_NULLS_LAST",
+  realizedPnl_ASC = "realizedPnl_ASC",
+  realizedPnl_ASC_NULLS_FIRST = "realizedPnl_ASC_NULLS_FIRST",
+  realizedPnl_ASC_NULLS_LAST = "realizedPnl_ASC_NULLS_LAST",
+  realizedPnl_DESC = "realizedPnl_DESC",
+  realizedPnl_DESC_NULLS_FIRST = "realizedPnl_DESC_NULLS_FIRST",
+  realizedPnl_DESC_NULLS_LAST = "realizedPnl_DESC_NULLS_LAST",
+  realizedPriceImpact_ASC = "realizedPriceImpact_ASC",
+  realizedPriceImpact_ASC_NULLS_FIRST = "realizedPriceImpact_ASC_NULLS_FIRST",
+  realizedPriceImpact_ASC_NULLS_LAST = "realizedPriceImpact_ASC_NULLS_LAST",
+  realizedPriceImpact_DESC = "realizedPriceImpact_DESC",
+  realizedPriceImpact_DESC_NULLS_FIRST = "realizedPriceImpact_DESC_NULLS_FIRST",
+  realizedPriceImpact_DESC_NULLS_LAST = "realizedPriceImpact_DESC_NULLS_LAST",
+  sumMaxSize_ASC = "sumMaxSize_ASC",
+  sumMaxSize_ASC_NULLS_FIRST = "sumMaxSize_ASC_NULLS_FIRST",
+  sumMaxSize_ASC_NULLS_LAST = "sumMaxSize_ASC_NULLS_LAST",
+  sumMaxSize_DESC = "sumMaxSize_DESC",
+  sumMaxSize_DESC_NULLS_FIRST = "sumMaxSize_DESC_NULLS_FIRST",
+  sumMaxSize_DESC_NULLS_LAST = "sumMaxSize_DESC_NULLS_LAST",
+  volume_ASC = "volume_ASC",
+  volume_ASC_NULLS_FIRST = "volume_ASC_NULLS_FIRST",
+  volume_ASC_NULLS_LAST = "volume_ASC_NULLS_LAST",
+  volume_DESC = "volume_DESC",
+  volume_DESC_NULLS_FIRST = "volume_DESC_NULLS_FIRST",
+  volume_DESC_NULLS_LAST = "volume_DESC_NULLS_LAST",
+  wins_ASC = "wins_ASC",
+  wins_ASC_NULLS_FIRST = "wins_ASC_NULLS_FIRST",
+  wins_ASC_NULLS_LAST = "wins_ASC_NULLS_LAST",
+  wins_DESC = "wins_DESC",
+  wins_DESC_NULLS_FIRST = "wins_DESC_NULLS_FIRST",
+  wins_DESC_NULLS_LAST = "wins_DESC_NULLS_LAST",
+}
+
+export interface AccountStatWhereInput {
+  AND?: InputMaybe<Array<AccountStatWhereInput>>;
+  OR?: InputMaybe<Array<AccountStatWhereInput>>;
+  closedCount_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  closedCount_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  closedCount_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  closedCount_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  closedCount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  closedCount_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  closedCount_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  closedCount_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  closedCount_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  cumsumCollateral_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumsumCollateral_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumsumCollateral_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumsumCollateral_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumsumCollateral_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  cumsumCollateral_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumsumCollateral_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumsumCollateral_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumsumCollateral_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumsumSize_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumsumSize_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumsumSize_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumsumSize_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumsumSize_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  cumsumSize_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumsumSize_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumsumSize_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumsumSize_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  losses_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  losses_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  losses_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  losses_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  losses_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  losses_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  losses_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  losses_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  losses_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  maxCapital_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxCapital_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxCapital_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxCapital_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxCapital_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxCapital_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxCapital_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxCapital_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxCapital_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  netCapital_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  netCapital_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  netCapital_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  netCapital_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  netCapital_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  netCapital_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  netCapital_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  netCapital_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  netCapital_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positions_every?: InputMaybe<PositionWhereInput>;
+  positions_none?: InputMaybe<PositionWhereInput>;
+  positions_some?: InputMaybe<PositionWhereInput>;
+  realizedFees_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedFees_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedFees_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedFees_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  realizedFees_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  realizedFees_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedFees_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedFees_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedFees_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  realizedPnl_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPnl_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPnl_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPnl_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  realizedPnl_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  realizedPnl_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPnl_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPnl_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPnl_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  realizedPriceImpact_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPriceImpact_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPriceImpact_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPriceImpact_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  realizedPriceImpact_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  realizedPriceImpact_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPriceImpact_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPriceImpact_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPriceImpact_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  sumMaxSize_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sumMaxSize_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sumMaxSize_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sumMaxSize_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  sumMaxSize_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  sumMaxSize_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sumMaxSize_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sumMaxSize_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sumMaxSize_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  volume_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  volume_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  volume_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  volume_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  volume_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  volume_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  volume_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  volume_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  volume_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  wins_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  wins_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  wins_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  wins_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  wins_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  wins_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  wins_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  wins_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  wins_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+}
+
+export interface AccountStatsConnection {
+  __typename?: "AccountStatsConnection";
+  edges: Array<AccountStatEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface AnnualizedPerformanceObject {
+  __typename?: "AnnualizedPerformanceObject";
+  address: Scalars["String"]["output"];
+  entity: Scalars["String"]["output"];
+  longTokenPerformance: Scalars["BigInt"]["output"];
+  shortTokenPerformance: Scalars["BigInt"]["output"];
+  uniswapV2Performance: Scalars["BigInt"]["output"];
+}
+
+export interface AprSnapshot {
+  __typename?: "AprSnapshot";
+  address: Scalars["String"]["output"];
+  aprByBorrowingFee: Scalars["BigInt"]["output"];
+  aprByFee: Scalars["BigInt"]["output"];
+  entityType: EntityType;
+  id: Scalars["String"]["output"];
+  snapshotTimestamp: Scalars["Int"]["output"];
+}
+
+export interface AprSnapshotEdge {
+  __typename?: "AprSnapshotEdge";
+  cursor: Scalars["String"]["output"];
+  node: AprSnapshot;
+}
+
+export enum AprSnapshotOrderByInput {
+  address_ASC = "address_ASC",
+  address_ASC_NULLS_FIRST = "address_ASC_NULLS_FIRST",
+  address_ASC_NULLS_LAST = "address_ASC_NULLS_LAST",
+  address_DESC = "address_DESC",
+  address_DESC_NULLS_FIRST = "address_DESC_NULLS_FIRST",
+  address_DESC_NULLS_LAST = "address_DESC_NULLS_LAST",
+  aprByBorrowingFee_ASC = "aprByBorrowingFee_ASC",
+  aprByBorrowingFee_ASC_NULLS_FIRST = "aprByBorrowingFee_ASC_NULLS_FIRST",
+  aprByBorrowingFee_ASC_NULLS_LAST = "aprByBorrowingFee_ASC_NULLS_LAST",
+  aprByBorrowingFee_DESC = "aprByBorrowingFee_DESC",
+  aprByBorrowingFee_DESC_NULLS_FIRST = "aprByBorrowingFee_DESC_NULLS_FIRST",
+  aprByBorrowingFee_DESC_NULLS_LAST = "aprByBorrowingFee_DESC_NULLS_LAST",
+  aprByFee_ASC = "aprByFee_ASC",
+  aprByFee_ASC_NULLS_FIRST = "aprByFee_ASC_NULLS_FIRST",
+  aprByFee_ASC_NULLS_LAST = "aprByFee_ASC_NULLS_LAST",
+  aprByFee_DESC = "aprByFee_DESC",
+  aprByFee_DESC_NULLS_FIRST = "aprByFee_DESC_NULLS_FIRST",
+  aprByFee_DESC_NULLS_LAST = "aprByFee_DESC_NULLS_LAST",
+  entityType_ASC = "entityType_ASC",
+  entityType_ASC_NULLS_FIRST = "entityType_ASC_NULLS_FIRST",
+  entityType_ASC_NULLS_LAST = "entityType_ASC_NULLS_LAST",
+  entityType_DESC = "entityType_DESC",
+  entityType_DESC_NULLS_FIRST = "entityType_DESC_NULLS_FIRST",
+  entityType_DESC_NULLS_LAST = "entityType_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  snapshotTimestamp_ASC = "snapshotTimestamp_ASC",
+  snapshotTimestamp_ASC_NULLS_FIRST = "snapshotTimestamp_ASC_NULLS_FIRST",
+  snapshotTimestamp_ASC_NULLS_LAST = "snapshotTimestamp_ASC_NULLS_LAST",
+  snapshotTimestamp_DESC = "snapshotTimestamp_DESC",
+  snapshotTimestamp_DESC_NULLS_FIRST = "snapshotTimestamp_DESC_NULLS_FIRST",
+  snapshotTimestamp_DESC_NULLS_LAST = "snapshotTimestamp_DESC_NULLS_LAST",
+}
+
+export interface AprSnapshotWhereInput {
+  AND?: InputMaybe<Array<AprSnapshotWhereInput>>;
+  OR?: InputMaybe<Array<AprSnapshotWhereInput>>;
+  address_contains?: InputMaybe<Scalars["String"]["input"]>;
+  address_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  address_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_eq?: InputMaybe<Scalars["String"]["input"]>;
+  address_gt?: InputMaybe<Scalars["String"]["input"]>;
+  address_gte?: InputMaybe<Scalars["String"]["input"]>;
+  address_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  address_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  address_lt?: InputMaybe<Scalars["String"]["input"]>;
+  address_lte?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  address_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  aprByBorrowingFee_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aprByBorrowingFee_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aprByBorrowingFee_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aprByBorrowingFee_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  aprByBorrowingFee_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  aprByBorrowingFee_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aprByBorrowingFee_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aprByBorrowingFee_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aprByBorrowingFee_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  aprByFee_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aprByFee_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aprByFee_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aprByFee_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  aprByFee_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  aprByFee_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aprByFee_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aprByFee_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aprByFee_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  entityType_eq?: InputMaybe<EntityType>;
+  entityType_in?: InputMaybe<Array<EntityType>>;
+  entityType_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  entityType_not_eq?: InputMaybe<EntityType>;
+  entityType_not_in?: InputMaybe<Array<EntityType>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  snapshotTimestamp_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  snapshotTimestamp_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  snapshotTimestamp_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+}
+
+export interface AprSnapshotsConnection {
+  __typename?: "AprSnapshotsConnection";
+  edges: Array<AprSnapshotEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface BorrowingRateSnapshot {
+  __typename?: "BorrowingRateSnapshot";
+  address: Scalars["String"]["output"];
+  borrowingFactorPerSecondLong: Scalars["BigInt"]["output"];
+  borrowingFactorPerSecondShort: Scalars["BigInt"]["output"];
+  borrowingRateForPool: Scalars["BigInt"]["output"];
+  entityType: EntityType;
+  id: Scalars["String"]["output"];
+  snapshotTimestamp: Scalars["Int"]["output"];
+}
+
+export interface BorrowingRateSnapshotEdge {
+  __typename?: "BorrowingRateSnapshotEdge";
+  cursor: Scalars["String"]["output"];
+  node: BorrowingRateSnapshot;
+}
+
+export enum BorrowingRateSnapshotOrderByInput {
+  address_ASC = "address_ASC",
+  address_ASC_NULLS_FIRST = "address_ASC_NULLS_FIRST",
+  address_ASC_NULLS_LAST = "address_ASC_NULLS_LAST",
+  address_DESC = "address_DESC",
+  address_DESC_NULLS_FIRST = "address_DESC_NULLS_FIRST",
+  address_DESC_NULLS_LAST = "address_DESC_NULLS_LAST",
+  borrowingFactorPerSecondLong_ASC = "borrowingFactorPerSecondLong_ASC",
+  borrowingFactorPerSecondLong_ASC_NULLS_FIRST = "borrowingFactorPerSecondLong_ASC_NULLS_FIRST",
+  borrowingFactorPerSecondLong_ASC_NULLS_LAST = "borrowingFactorPerSecondLong_ASC_NULLS_LAST",
+  borrowingFactorPerSecondLong_DESC = "borrowingFactorPerSecondLong_DESC",
+  borrowingFactorPerSecondLong_DESC_NULLS_FIRST = "borrowingFactorPerSecondLong_DESC_NULLS_FIRST",
+  borrowingFactorPerSecondLong_DESC_NULLS_LAST = "borrowingFactorPerSecondLong_DESC_NULLS_LAST",
+  borrowingFactorPerSecondShort_ASC = "borrowingFactorPerSecondShort_ASC",
+  borrowingFactorPerSecondShort_ASC_NULLS_FIRST = "borrowingFactorPerSecondShort_ASC_NULLS_FIRST",
+  borrowingFactorPerSecondShort_ASC_NULLS_LAST = "borrowingFactorPerSecondShort_ASC_NULLS_LAST",
+  borrowingFactorPerSecondShort_DESC = "borrowingFactorPerSecondShort_DESC",
+  borrowingFactorPerSecondShort_DESC_NULLS_FIRST = "borrowingFactorPerSecondShort_DESC_NULLS_FIRST",
+  borrowingFactorPerSecondShort_DESC_NULLS_LAST = "borrowingFactorPerSecondShort_DESC_NULLS_LAST",
+  borrowingRateForPool_ASC = "borrowingRateForPool_ASC",
+  borrowingRateForPool_ASC_NULLS_FIRST = "borrowingRateForPool_ASC_NULLS_FIRST",
+  borrowingRateForPool_ASC_NULLS_LAST = "borrowingRateForPool_ASC_NULLS_LAST",
+  borrowingRateForPool_DESC = "borrowingRateForPool_DESC",
+  borrowingRateForPool_DESC_NULLS_FIRST = "borrowingRateForPool_DESC_NULLS_FIRST",
+  borrowingRateForPool_DESC_NULLS_LAST = "borrowingRateForPool_DESC_NULLS_LAST",
+  entityType_ASC = "entityType_ASC",
+  entityType_ASC_NULLS_FIRST = "entityType_ASC_NULLS_FIRST",
+  entityType_ASC_NULLS_LAST = "entityType_ASC_NULLS_LAST",
+  entityType_DESC = "entityType_DESC",
+  entityType_DESC_NULLS_FIRST = "entityType_DESC_NULLS_FIRST",
+  entityType_DESC_NULLS_LAST = "entityType_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  snapshotTimestamp_ASC = "snapshotTimestamp_ASC",
+  snapshotTimestamp_ASC_NULLS_FIRST = "snapshotTimestamp_ASC_NULLS_FIRST",
+  snapshotTimestamp_ASC_NULLS_LAST = "snapshotTimestamp_ASC_NULLS_LAST",
+  snapshotTimestamp_DESC = "snapshotTimestamp_DESC",
+  snapshotTimestamp_DESC_NULLS_FIRST = "snapshotTimestamp_DESC_NULLS_FIRST",
+  snapshotTimestamp_DESC_NULLS_LAST = "snapshotTimestamp_DESC_NULLS_LAST",
+}
+
+export interface BorrowingRateSnapshotWhereInput {
+  AND?: InputMaybe<Array<BorrowingRateSnapshotWhereInput>>;
+  OR?: InputMaybe<Array<BorrowingRateSnapshotWhereInput>>;
+  address_contains?: InputMaybe<Scalars["String"]["input"]>;
+  address_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  address_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_eq?: InputMaybe<Scalars["String"]["input"]>;
+  address_gt?: InputMaybe<Scalars["String"]["input"]>;
+  address_gte?: InputMaybe<Scalars["String"]["input"]>;
+  address_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  address_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  address_lt?: InputMaybe<Scalars["String"]["input"]>;
+  address_lte?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  address_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  borrowingFactorPerSecondLong_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondLong_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondLong_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondLong_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFactorPerSecondLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  borrowingFactorPerSecondLong_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondLong_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondLong_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondLong_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFactorPerSecondShort_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondShort_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondShort_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondShort_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFactorPerSecondShort_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  borrowingFactorPerSecondShort_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondShort_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondShort_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondShort_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingRateForPool_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingRateForPool_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingRateForPool_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingRateForPool_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingRateForPool_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  borrowingRateForPool_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingRateForPool_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingRateForPool_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingRateForPool_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  entityType_eq?: InputMaybe<EntityType>;
+  entityType_in?: InputMaybe<Array<EntityType>>;
+  entityType_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  entityType_not_eq?: InputMaybe<EntityType>;
+  entityType_not_in?: InputMaybe<Array<EntityType>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  snapshotTimestamp_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  snapshotTimestamp_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  snapshotTimestamp_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+}
+
+export interface BorrowingRateSnapshotsConnection {
+  __typename?: "BorrowingRateSnapshotsConnection";
+  edges: Array<BorrowingRateSnapshotEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface ClaimAction {
+  __typename?: "ClaimAction";
+  account: Scalars["String"]["output"];
+  amounts: Array<Scalars["String"]["output"]>;
+  eventName: ClaimActionType;
+  id: Scalars["String"]["output"];
+  isLongOrders: Array<Scalars["Boolean"]["output"]>;
+  marketAddresses: Array<Scalars["String"]["output"]>;
+  timestamp: Scalars["Int"]["output"];
+  tokenAddresses: Array<Scalars["String"]["output"]>;
+  tokenPrices: Array<Scalars["String"]["output"]>;
+  transaction: Transaction;
+}
+
+export interface ClaimActionEdge {
+  __typename?: "ClaimActionEdge";
+  cursor: Scalars["String"]["output"];
+  node: ClaimAction;
+}
+
+export enum ClaimActionOrderByInput {
+  account_ASC = "account_ASC",
+  account_ASC_NULLS_FIRST = "account_ASC_NULLS_FIRST",
+  account_ASC_NULLS_LAST = "account_ASC_NULLS_LAST",
+  account_DESC = "account_DESC",
+  account_DESC_NULLS_FIRST = "account_DESC_NULLS_FIRST",
+  account_DESC_NULLS_LAST = "account_DESC_NULLS_LAST",
+  eventName_ASC = "eventName_ASC",
+  eventName_ASC_NULLS_FIRST = "eventName_ASC_NULLS_FIRST",
+  eventName_ASC_NULLS_LAST = "eventName_ASC_NULLS_LAST",
+  eventName_DESC = "eventName_DESC",
+  eventName_DESC_NULLS_FIRST = "eventName_DESC_NULLS_FIRST",
+  eventName_DESC_NULLS_LAST = "eventName_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  timestamp_ASC = "timestamp_ASC",
+  timestamp_ASC_NULLS_FIRST = "timestamp_ASC_NULLS_FIRST",
+  timestamp_ASC_NULLS_LAST = "timestamp_ASC_NULLS_LAST",
+  timestamp_DESC = "timestamp_DESC",
+  timestamp_DESC_NULLS_FIRST = "timestamp_DESC_NULLS_FIRST",
+  timestamp_DESC_NULLS_LAST = "timestamp_DESC_NULLS_LAST",
+  transaction_blockNumber_ASC = "transaction_blockNumber_ASC",
+  transaction_blockNumber_ASC_NULLS_FIRST = "transaction_blockNumber_ASC_NULLS_FIRST",
+  transaction_blockNumber_ASC_NULLS_LAST = "transaction_blockNumber_ASC_NULLS_LAST",
+  transaction_blockNumber_DESC = "transaction_blockNumber_DESC",
+  transaction_blockNumber_DESC_NULLS_FIRST = "transaction_blockNumber_DESC_NULLS_FIRST",
+  transaction_blockNumber_DESC_NULLS_LAST = "transaction_blockNumber_DESC_NULLS_LAST",
+  transaction_chainId_ASC = "transaction_chainId_ASC",
+  transaction_chainId_ASC_NULLS_FIRST = "transaction_chainId_ASC_NULLS_FIRST",
+  transaction_chainId_ASC_NULLS_LAST = "transaction_chainId_ASC_NULLS_LAST",
+  transaction_chainId_DESC = "transaction_chainId_DESC",
+  transaction_chainId_DESC_NULLS_FIRST = "transaction_chainId_DESC_NULLS_FIRST",
+  transaction_chainId_DESC_NULLS_LAST = "transaction_chainId_DESC_NULLS_LAST",
+  transaction_from_ASC = "transaction_from_ASC",
+  transaction_from_ASC_NULLS_FIRST = "transaction_from_ASC_NULLS_FIRST",
+  transaction_from_ASC_NULLS_LAST = "transaction_from_ASC_NULLS_LAST",
+  transaction_from_DESC = "transaction_from_DESC",
+  transaction_from_DESC_NULLS_FIRST = "transaction_from_DESC_NULLS_FIRST",
+  transaction_from_DESC_NULLS_LAST = "transaction_from_DESC_NULLS_LAST",
+  transaction_hash_ASC = "transaction_hash_ASC",
+  transaction_hash_ASC_NULLS_FIRST = "transaction_hash_ASC_NULLS_FIRST",
+  transaction_hash_ASC_NULLS_LAST = "transaction_hash_ASC_NULLS_LAST",
+  transaction_hash_DESC = "transaction_hash_DESC",
+  transaction_hash_DESC_NULLS_FIRST = "transaction_hash_DESC_NULLS_FIRST",
+  transaction_hash_DESC_NULLS_LAST = "transaction_hash_DESC_NULLS_LAST",
+  transaction_id_ASC = "transaction_id_ASC",
+  transaction_id_ASC_NULLS_FIRST = "transaction_id_ASC_NULLS_FIRST",
+  transaction_id_ASC_NULLS_LAST = "transaction_id_ASC_NULLS_LAST",
+  transaction_id_DESC = "transaction_id_DESC",
+  transaction_id_DESC_NULLS_FIRST = "transaction_id_DESC_NULLS_FIRST",
+  transaction_id_DESC_NULLS_LAST = "transaction_id_DESC_NULLS_LAST",
+  transaction_timestamp_ASC = "transaction_timestamp_ASC",
+  transaction_timestamp_ASC_NULLS_FIRST = "transaction_timestamp_ASC_NULLS_FIRST",
+  transaction_timestamp_ASC_NULLS_LAST = "transaction_timestamp_ASC_NULLS_LAST",
+  transaction_timestamp_DESC = "transaction_timestamp_DESC",
+  transaction_timestamp_DESC_NULLS_FIRST = "transaction_timestamp_DESC_NULLS_FIRST",
+  transaction_timestamp_DESC_NULLS_LAST = "transaction_timestamp_DESC_NULLS_LAST",
+  transaction_to_ASC = "transaction_to_ASC",
+  transaction_to_ASC_NULLS_FIRST = "transaction_to_ASC_NULLS_FIRST",
+  transaction_to_ASC_NULLS_LAST = "transaction_to_ASC_NULLS_LAST",
+  transaction_to_DESC = "transaction_to_DESC",
+  transaction_to_DESC_NULLS_FIRST = "transaction_to_DESC_NULLS_FIRST",
+  transaction_to_DESC_NULLS_LAST = "transaction_to_DESC_NULLS_LAST",
+  transaction_transactionIndex_ASC = "transaction_transactionIndex_ASC",
+  transaction_transactionIndex_ASC_NULLS_FIRST = "transaction_transactionIndex_ASC_NULLS_FIRST",
+  transaction_transactionIndex_ASC_NULLS_LAST = "transaction_transactionIndex_ASC_NULLS_LAST",
+  transaction_transactionIndex_DESC = "transaction_transactionIndex_DESC",
+  transaction_transactionIndex_DESC_NULLS_FIRST = "transaction_transactionIndex_DESC_NULLS_FIRST",
+  transaction_transactionIndex_DESC_NULLS_LAST = "transaction_transactionIndex_DESC_NULLS_LAST",
+}
+
+export enum ClaimActionType {
+  ClaimFunding = "ClaimFunding",
+  ClaimPriceImpact = "ClaimPriceImpact",
+  SettleFundingFeeCancelled = "SettleFundingFeeCancelled",
+  SettleFundingFeeCreated = "SettleFundingFeeCreated",
+  SettleFundingFeeExecuted = "SettleFundingFeeExecuted",
+}
+
+export interface ClaimActionWhereInput {
+  AND?: InputMaybe<Array<ClaimActionWhereInput>>;
+  OR?: InputMaybe<Array<ClaimActionWhereInput>>;
+  account_contains?: InputMaybe<Scalars["String"]["input"]>;
+  account_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  account_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_eq?: InputMaybe<Scalars["String"]["input"]>;
+  account_gt?: InputMaybe<Scalars["String"]["input"]>;
+  account_gte?: InputMaybe<Scalars["String"]["input"]>;
+  account_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  account_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  account_lt?: InputMaybe<Scalars["String"]["input"]>;
+  account_lte?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  account_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  amounts_containsAll?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  amounts_containsAny?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  amounts_containsNone?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  amounts_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  eventName_eq?: InputMaybe<ClaimActionType>;
+  eventName_in?: InputMaybe<Array<ClaimActionType>>;
+  eventName_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  eventName_not_eq?: InputMaybe<ClaimActionType>;
+  eventName_not_in?: InputMaybe<Array<ClaimActionType>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  isLongOrders_containsAll?: InputMaybe<Array<Scalars["Boolean"]["input"]>>;
+  isLongOrders_containsAny?: InputMaybe<Array<Scalars["Boolean"]["input"]>>;
+  isLongOrders_containsNone?: InputMaybe<Array<Scalars["Boolean"]["input"]>>;
+  isLongOrders_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  marketAddresses_containsAll?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddresses_containsAny?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddresses_containsNone?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddresses_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  timestamp_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  timestamp_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  timestamp_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  tokenAddresses_containsAll?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenAddresses_containsAny?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenAddresses_containsNone?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenAddresses_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  tokenPrices_containsAll?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenPrices_containsAny?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenPrices_containsNone?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenPrices_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  transaction?: InputMaybe<TransactionWhereInput>;
+  transaction_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+}
+
+export interface ClaimActionsConnection {
+  __typename?: "ClaimActionsConnection";
+  edges: Array<ClaimActionEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface ClaimRef {
+  __typename?: "ClaimRef";
+  id: Scalars["String"]["output"];
+}
+
+export interface ClaimRefEdge {
+  __typename?: "ClaimRefEdge";
+  cursor: Scalars["String"]["output"];
+  node: ClaimRef;
+}
+
+export enum ClaimRefOrderByInput {
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+}
+
+export interface ClaimRefWhereInput {
+  AND?: InputMaybe<Array<ClaimRefWhereInput>>;
+  OR?: InputMaybe<Array<ClaimRefWhereInput>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+}
+
+export interface ClaimRefsConnection {
+  __typename?: "ClaimRefsConnection";
+  edges: Array<ClaimRefEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface ClaimableCollateral {
+  __typename?: "ClaimableCollateral";
+  account: Scalars["String"]["output"];
+  claimed: Scalars["Boolean"]["output"];
+  factor: Scalars["BigInt"]["output"];
+  factorByTime: Scalars["BigInt"]["output"];
+  group: ClaimableCollateralGroup;
+  id: Scalars["String"]["output"];
+  marketAddress: Scalars["String"]["output"];
+  reductionFactor: Scalars["BigInt"]["output"];
+  timeKey: Scalars["String"]["output"];
+  tokenAddress: Scalars["String"]["output"];
+  value: Scalars["BigInt"]["output"];
+}
+
+export interface ClaimableCollateralEdge {
+  __typename?: "ClaimableCollateralEdge";
+  cursor: Scalars["String"]["output"];
+  node: ClaimableCollateral;
+}
+
+export interface ClaimableCollateralGroup {
+  __typename?: "ClaimableCollateralGroup";
+  claimables: Array<ClaimableCollateral>;
+  factor: Scalars["BigInt"]["output"];
+  id: Scalars["String"]["output"];
+  marketAddress: Scalars["String"]["output"];
+  timeKey: Scalars["String"]["output"];
+  tokenAddress: Scalars["String"]["output"];
+}
+
+export interface ClaimableCollateralGroupclaimablesArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<ClaimableCollateralOrderByInput>>;
+  where?: InputMaybe<ClaimableCollateralWhereInput>;
+}
+
+export interface ClaimableCollateralGroupEdge {
+  __typename?: "ClaimableCollateralGroupEdge";
+  cursor: Scalars["String"]["output"];
+  node: ClaimableCollateralGroup;
+}
+
+export enum ClaimableCollateralGroupOrderByInput {
+  factor_ASC = "factor_ASC",
+  factor_ASC_NULLS_FIRST = "factor_ASC_NULLS_FIRST",
+  factor_ASC_NULLS_LAST = "factor_ASC_NULLS_LAST",
+  factor_DESC = "factor_DESC",
+  factor_DESC_NULLS_FIRST = "factor_DESC_NULLS_FIRST",
+  factor_DESC_NULLS_LAST = "factor_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  marketAddress_ASC = "marketAddress_ASC",
+  marketAddress_ASC_NULLS_FIRST = "marketAddress_ASC_NULLS_FIRST",
+  marketAddress_ASC_NULLS_LAST = "marketAddress_ASC_NULLS_LAST",
+  marketAddress_DESC = "marketAddress_DESC",
+  marketAddress_DESC_NULLS_FIRST = "marketAddress_DESC_NULLS_FIRST",
+  marketAddress_DESC_NULLS_LAST = "marketAddress_DESC_NULLS_LAST",
+  timeKey_ASC = "timeKey_ASC",
+  timeKey_ASC_NULLS_FIRST = "timeKey_ASC_NULLS_FIRST",
+  timeKey_ASC_NULLS_LAST = "timeKey_ASC_NULLS_LAST",
+  timeKey_DESC = "timeKey_DESC",
+  timeKey_DESC_NULLS_FIRST = "timeKey_DESC_NULLS_FIRST",
+  timeKey_DESC_NULLS_LAST = "timeKey_DESC_NULLS_LAST",
+  tokenAddress_ASC = "tokenAddress_ASC",
+  tokenAddress_ASC_NULLS_FIRST = "tokenAddress_ASC_NULLS_FIRST",
+  tokenAddress_ASC_NULLS_LAST = "tokenAddress_ASC_NULLS_LAST",
+  tokenAddress_DESC = "tokenAddress_DESC",
+  tokenAddress_DESC_NULLS_FIRST = "tokenAddress_DESC_NULLS_FIRST",
+  tokenAddress_DESC_NULLS_LAST = "tokenAddress_DESC_NULLS_LAST",
+}
+
+export interface ClaimableCollateralGroupWhereInput {
+  AND?: InputMaybe<Array<ClaimableCollateralGroupWhereInput>>;
+  OR?: InputMaybe<Array<ClaimableCollateralGroupWhereInput>>;
+  claimables_every?: InputMaybe<ClaimableCollateralWhereInput>;
+  claimables_none?: InputMaybe<ClaimableCollateralWhereInput>;
+  claimables_some?: InputMaybe<ClaimableCollateralWhereInput>;
+  factor_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factor_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factor_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factor_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  factor_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  factor_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factor_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factor_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factor_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  marketAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_contains?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_eq?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_gt?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_gte?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  timeKey_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  timeKey_lt?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_lte?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  timeKey_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  tokenAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+}
+
+export interface ClaimableCollateralGroupsConnection {
+  __typename?: "ClaimableCollateralGroupsConnection";
+  edges: Array<ClaimableCollateralGroupEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export enum ClaimableCollateralOrderByInput {
+  account_ASC = "account_ASC",
+  account_ASC_NULLS_FIRST = "account_ASC_NULLS_FIRST",
+  account_ASC_NULLS_LAST = "account_ASC_NULLS_LAST",
+  account_DESC = "account_DESC",
+  account_DESC_NULLS_FIRST = "account_DESC_NULLS_FIRST",
+  account_DESC_NULLS_LAST = "account_DESC_NULLS_LAST",
+  claimed_ASC = "claimed_ASC",
+  claimed_ASC_NULLS_FIRST = "claimed_ASC_NULLS_FIRST",
+  claimed_ASC_NULLS_LAST = "claimed_ASC_NULLS_LAST",
+  claimed_DESC = "claimed_DESC",
+  claimed_DESC_NULLS_FIRST = "claimed_DESC_NULLS_FIRST",
+  claimed_DESC_NULLS_LAST = "claimed_DESC_NULLS_LAST",
+  factorByTime_ASC = "factorByTime_ASC",
+  factorByTime_ASC_NULLS_FIRST = "factorByTime_ASC_NULLS_FIRST",
+  factorByTime_ASC_NULLS_LAST = "factorByTime_ASC_NULLS_LAST",
+  factorByTime_DESC = "factorByTime_DESC",
+  factorByTime_DESC_NULLS_FIRST = "factorByTime_DESC_NULLS_FIRST",
+  factorByTime_DESC_NULLS_LAST = "factorByTime_DESC_NULLS_LAST",
+  factor_ASC = "factor_ASC",
+  factor_ASC_NULLS_FIRST = "factor_ASC_NULLS_FIRST",
+  factor_ASC_NULLS_LAST = "factor_ASC_NULLS_LAST",
+  factor_DESC = "factor_DESC",
+  factor_DESC_NULLS_FIRST = "factor_DESC_NULLS_FIRST",
+  factor_DESC_NULLS_LAST = "factor_DESC_NULLS_LAST",
+  group_factor_ASC = "group_factor_ASC",
+  group_factor_ASC_NULLS_FIRST = "group_factor_ASC_NULLS_FIRST",
+  group_factor_ASC_NULLS_LAST = "group_factor_ASC_NULLS_LAST",
+  group_factor_DESC = "group_factor_DESC",
+  group_factor_DESC_NULLS_FIRST = "group_factor_DESC_NULLS_FIRST",
+  group_factor_DESC_NULLS_LAST = "group_factor_DESC_NULLS_LAST",
+  group_id_ASC = "group_id_ASC",
+  group_id_ASC_NULLS_FIRST = "group_id_ASC_NULLS_FIRST",
+  group_id_ASC_NULLS_LAST = "group_id_ASC_NULLS_LAST",
+  group_id_DESC = "group_id_DESC",
+  group_id_DESC_NULLS_FIRST = "group_id_DESC_NULLS_FIRST",
+  group_id_DESC_NULLS_LAST = "group_id_DESC_NULLS_LAST",
+  group_marketAddress_ASC = "group_marketAddress_ASC",
+  group_marketAddress_ASC_NULLS_FIRST = "group_marketAddress_ASC_NULLS_FIRST",
+  group_marketAddress_ASC_NULLS_LAST = "group_marketAddress_ASC_NULLS_LAST",
+  group_marketAddress_DESC = "group_marketAddress_DESC",
+  group_marketAddress_DESC_NULLS_FIRST = "group_marketAddress_DESC_NULLS_FIRST",
+  group_marketAddress_DESC_NULLS_LAST = "group_marketAddress_DESC_NULLS_LAST",
+  group_timeKey_ASC = "group_timeKey_ASC",
+  group_timeKey_ASC_NULLS_FIRST = "group_timeKey_ASC_NULLS_FIRST",
+  group_timeKey_ASC_NULLS_LAST = "group_timeKey_ASC_NULLS_LAST",
+  group_timeKey_DESC = "group_timeKey_DESC",
+  group_timeKey_DESC_NULLS_FIRST = "group_timeKey_DESC_NULLS_FIRST",
+  group_timeKey_DESC_NULLS_LAST = "group_timeKey_DESC_NULLS_LAST",
+  group_tokenAddress_ASC = "group_tokenAddress_ASC",
+  group_tokenAddress_ASC_NULLS_FIRST = "group_tokenAddress_ASC_NULLS_FIRST",
+  group_tokenAddress_ASC_NULLS_LAST = "group_tokenAddress_ASC_NULLS_LAST",
+  group_tokenAddress_DESC = "group_tokenAddress_DESC",
+  group_tokenAddress_DESC_NULLS_FIRST = "group_tokenAddress_DESC_NULLS_FIRST",
+  group_tokenAddress_DESC_NULLS_LAST = "group_tokenAddress_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  marketAddress_ASC = "marketAddress_ASC",
+  marketAddress_ASC_NULLS_FIRST = "marketAddress_ASC_NULLS_FIRST",
+  marketAddress_ASC_NULLS_LAST = "marketAddress_ASC_NULLS_LAST",
+  marketAddress_DESC = "marketAddress_DESC",
+  marketAddress_DESC_NULLS_FIRST = "marketAddress_DESC_NULLS_FIRST",
+  marketAddress_DESC_NULLS_LAST = "marketAddress_DESC_NULLS_LAST",
+  reductionFactor_ASC = "reductionFactor_ASC",
+  reductionFactor_ASC_NULLS_FIRST = "reductionFactor_ASC_NULLS_FIRST",
+  reductionFactor_ASC_NULLS_LAST = "reductionFactor_ASC_NULLS_LAST",
+  reductionFactor_DESC = "reductionFactor_DESC",
+  reductionFactor_DESC_NULLS_FIRST = "reductionFactor_DESC_NULLS_FIRST",
+  reductionFactor_DESC_NULLS_LAST = "reductionFactor_DESC_NULLS_LAST",
+  timeKey_ASC = "timeKey_ASC",
+  timeKey_ASC_NULLS_FIRST = "timeKey_ASC_NULLS_FIRST",
+  timeKey_ASC_NULLS_LAST = "timeKey_ASC_NULLS_LAST",
+  timeKey_DESC = "timeKey_DESC",
+  timeKey_DESC_NULLS_FIRST = "timeKey_DESC_NULLS_FIRST",
+  timeKey_DESC_NULLS_LAST = "timeKey_DESC_NULLS_LAST",
+  tokenAddress_ASC = "tokenAddress_ASC",
+  tokenAddress_ASC_NULLS_FIRST = "tokenAddress_ASC_NULLS_FIRST",
+  tokenAddress_ASC_NULLS_LAST = "tokenAddress_ASC_NULLS_LAST",
+  tokenAddress_DESC = "tokenAddress_DESC",
+  tokenAddress_DESC_NULLS_FIRST = "tokenAddress_DESC_NULLS_FIRST",
+  tokenAddress_DESC_NULLS_LAST = "tokenAddress_DESC_NULLS_LAST",
+  value_ASC = "value_ASC",
+  value_ASC_NULLS_FIRST = "value_ASC_NULLS_FIRST",
+  value_ASC_NULLS_LAST = "value_ASC_NULLS_LAST",
+  value_DESC = "value_DESC",
+  value_DESC_NULLS_FIRST = "value_DESC_NULLS_FIRST",
+  value_DESC_NULLS_LAST = "value_DESC_NULLS_LAST",
+}
+
+export interface ClaimableCollateralWhereInput {
+  AND?: InputMaybe<Array<ClaimableCollateralWhereInput>>;
+  OR?: InputMaybe<Array<ClaimableCollateralWhereInput>>;
+  account_contains?: InputMaybe<Scalars["String"]["input"]>;
+  account_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  account_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_eq?: InputMaybe<Scalars["String"]["input"]>;
+  account_gt?: InputMaybe<Scalars["String"]["input"]>;
+  account_gte?: InputMaybe<Scalars["String"]["input"]>;
+  account_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  account_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  account_lt?: InputMaybe<Scalars["String"]["input"]>;
+  account_lte?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  account_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  claimed_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  claimed_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  claimed_not_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  factorByTime_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factorByTime_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factorByTime_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factorByTime_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  factorByTime_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  factorByTime_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factorByTime_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factorByTime_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factorByTime_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  factor_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factor_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factor_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factor_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  factor_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  factor_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factor_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factor_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  factor_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  group?: InputMaybe<ClaimableCollateralGroupWhereInput>;
+  group_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  marketAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  reductionFactor_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reductionFactor_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reductionFactor_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reductionFactor_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  reductionFactor_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  reductionFactor_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reductionFactor_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reductionFactor_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reductionFactor_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  timeKey_contains?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_eq?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_gt?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_gte?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  timeKey_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  timeKey_lt?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_lte?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  timeKey_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  timeKey_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  tokenAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  value_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  value_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  value_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  value_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  value_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  value_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  value_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  value_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  value_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+}
+
+export interface ClaimableCollateralsConnection {
+  __typename?: "ClaimableCollateralsConnection";
+  edges: Array<ClaimableCollateralEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface ClaimableFundingFeeInfo {
+  __typename?: "ClaimableFundingFeeInfo";
+  amounts: Array<Scalars["String"]["output"]>;
+  id: Scalars["String"]["output"];
+  marketAddresses: Array<Scalars["String"]["output"]>;
+  tokenAddresses: Array<Scalars["String"]["output"]>;
+}
+
+export interface ClaimableFundingFeeInfoEdge {
+  __typename?: "ClaimableFundingFeeInfoEdge";
+  cursor: Scalars["String"]["output"];
+  node: ClaimableFundingFeeInfo;
+}
+
+export enum ClaimableFundingFeeInfoOrderByInput {
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+}
+
+export interface ClaimableFundingFeeInfoWhereInput {
+  AND?: InputMaybe<Array<ClaimableFundingFeeInfoWhereInput>>;
+  OR?: InputMaybe<Array<ClaimableFundingFeeInfoWhereInput>>;
+  amounts_containsAll?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  amounts_containsAny?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  amounts_containsNone?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  amounts_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddresses_containsAll?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddresses_containsAny?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddresses_containsNone?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddresses_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  tokenAddresses_containsAll?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenAddresses_containsAny?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenAddresses_containsNone?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenAddresses_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+}
+
+export interface ClaimableFundingFeeInfosConnection {
+  __typename?: "ClaimableFundingFeeInfosConnection";
+  edges: Array<ClaimableFundingFeeInfoEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface CollectedFeesInfo {
+  __typename?: "CollectedFeesInfo";
+  address: Scalars["String"]["output"];
+  borrowingFeeUsdForPool: Scalars["BigInt"]["output"];
+  borrowingFeeUsdPerPoolValue: Scalars["BigInt"]["output"];
+  cumulativeBorrowingFeeUsdForPool: Scalars["BigInt"]["output"];
+  cumulativeBorrowingFeeUsdPerPoolValue: Scalars["BigInt"]["output"];
+  cumulativeFeeUsdForPool: Scalars["BigInt"]["output"];
+  cumulativeFeeUsdPerPoolValue: Scalars["BigInt"]["output"];
+  entityType: EntityType;
+  feeUsdForPool: Scalars["BigInt"]["output"];
+  feeUsdPerPoolValue: Scalars["BigInt"]["output"];
+  id: Scalars["String"]["output"];
+  period: Scalars["String"]["output"];
+  timestampGroup: Scalars["Int"]["output"];
+}
+
+export interface CollectedFeesInfoEdge {
+  __typename?: "CollectedFeesInfoEdge";
+  cursor: Scalars["String"]["output"];
+  node: CollectedFeesInfo;
+}
+
+export enum CollectedFeesInfoOrderByInput {
+  address_ASC = "address_ASC",
+  address_ASC_NULLS_FIRST = "address_ASC_NULLS_FIRST",
+  address_ASC_NULLS_LAST = "address_ASC_NULLS_LAST",
+  address_DESC = "address_DESC",
+  address_DESC_NULLS_FIRST = "address_DESC_NULLS_FIRST",
+  address_DESC_NULLS_LAST = "address_DESC_NULLS_LAST",
+  borrowingFeeUsdForPool_ASC = "borrowingFeeUsdForPool_ASC",
+  borrowingFeeUsdForPool_ASC_NULLS_FIRST = "borrowingFeeUsdForPool_ASC_NULLS_FIRST",
+  borrowingFeeUsdForPool_ASC_NULLS_LAST = "borrowingFeeUsdForPool_ASC_NULLS_LAST",
+  borrowingFeeUsdForPool_DESC = "borrowingFeeUsdForPool_DESC",
+  borrowingFeeUsdForPool_DESC_NULLS_FIRST = "borrowingFeeUsdForPool_DESC_NULLS_FIRST",
+  borrowingFeeUsdForPool_DESC_NULLS_LAST = "borrowingFeeUsdForPool_DESC_NULLS_LAST",
+  borrowingFeeUsdPerPoolValue_ASC = "borrowingFeeUsdPerPoolValue_ASC",
+  borrowingFeeUsdPerPoolValue_ASC_NULLS_FIRST = "borrowingFeeUsdPerPoolValue_ASC_NULLS_FIRST",
+  borrowingFeeUsdPerPoolValue_ASC_NULLS_LAST = "borrowingFeeUsdPerPoolValue_ASC_NULLS_LAST",
+  borrowingFeeUsdPerPoolValue_DESC = "borrowingFeeUsdPerPoolValue_DESC",
+  borrowingFeeUsdPerPoolValue_DESC_NULLS_FIRST = "borrowingFeeUsdPerPoolValue_DESC_NULLS_FIRST",
+  borrowingFeeUsdPerPoolValue_DESC_NULLS_LAST = "borrowingFeeUsdPerPoolValue_DESC_NULLS_LAST",
+  cumulativeBorrowingFeeUsdForPool_ASC = "cumulativeBorrowingFeeUsdForPool_ASC",
+  cumulativeBorrowingFeeUsdForPool_ASC_NULLS_FIRST = "cumulativeBorrowingFeeUsdForPool_ASC_NULLS_FIRST",
+  cumulativeBorrowingFeeUsdForPool_ASC_NULLS_LAST = "cumulativeBorrowingFeeUsdForPool_ASC_NULLS_LAST",
+  cumulativeBorrowingFeeUsdForPool_DESC = "cumulativeBorrowingFeeUsdForPool_DESC",
+  cumulativeBorrowingFeeUsdForPool_DESC_NULLS_FIRST = "cumulativeBorrowingFeeUsdForPool_DESC_NULLS_FIRST",
+  cumulativeBorrowingFeeUsdForPool_DESC_NULLS_LAST = "cumulativeBorrowingFeeUsdForPool_DESC_NULLS_LAST",
+  cumulativeBorrowingFeeUsdPerPoolValue_ASC = "cumulativeBorrowingFeeUsdPerPoolValue_ASC",
+  cumulativeBorrowingFeeUsdPerPoolValue_ASC_NULLS_FIRST = "cumulativeBorrowingFeeUsdPerPoolValue_ASC_NULLS_FIRST",
+  cumulativeBorrowingFeeUsdPerPoolValue_ASC_NULLS_LAST = "cumulativeBorrowingFeeUsdPerPoolValue_ASC_NULLS_LAST",
+  cumulativeBorrowingFeeUsdPerPoolValue_DESC = "cumulativeBorrowingFeeUsdPerPoolValue_DESC",
+  cumulativeBorrowingFeeUsdPerPoolValue_DESC_NULLS_FIRST = "cumulativeBorrowingFeeUsdPerPoolValue_DESC_NULLS_FIRST",
+  cumulativeBorrowingFeeUsdPerPoolValue_DESC_NULLS_LAST = "cumulativeBorrowingFeeUsdPerPoolValue_DESC_NULLS_LAST",
+  cumulativeFeeUsdForPool_ASC = "cumulativeFeeUsdForPool_ASC",
+  cumulativeFeeUsdForPool_ASC_NULLS_FIRST = "cumulativeFeeUsdForPool_ASC_NULLS_FIRST",
+  cumulativeFeeUsdForPool_ASC_NULLS_LAST = "cumulativeFeeUsdForPool_ASC_NULLS_LAST",
+  cumulativeFeeUsdForPool_DESC = "cumulativeFeeUsdForPool_DESC",
+  cumulativeFeeUsdForPool_DESC_NULLS_FIRST = "cumulativeFeeUsdForPool_DESC_NULLS_FIRST",
+  cumulativeFeeUsdForPool_DESC_NULLS_LAST = "cumulativeFeeUsdForPool_DESC_NULLS_LAST",
+  cumulativeFeeUsdPerPoolValue_ASC = "cumulativeFeeUsdPerPoolValue_ASC",
+  cumulativeFeeUsdPerPoolValue_ASC_NULLS_FIRST = "cumulativeFeeUsdPerPoolValue_ASC_NULLS_FIRST",
+  cumulativeFeeUsdPerPoolValue_ASC_NULLS_LAST = "cumulativeFeeUsdPerPoolValue_ASC_NULLS_LAST",
+  cumulativeFeeUsdPerPoolValue_DESC = "cumulativeFeeUsdPerPoolValue_DESC",
+  cumulativeFeeUsdPerPoolValue_DESC_NULLS_FIRST = "cumulativeFeeUsdPerPoolValue_DESC_NULLS_FIRST",
+  cumulativeFeeUsdPerPoolValue_DESC_NULLS_LAST = "cumulativeFeeUsdPerPoolValue_DESC_NULLS_LAST",
+  entityType_ASC = "entityType_ASC",
+  entityType_ASC_NULLS_FIRST = "entityType_ASC_NULLS_FIRST",
+  entityType_ASC_NULLS_LAST = "entityType_ASC_NULLS_LAST",
+  entityType_DESC = "entityType_DESC",
+  entityType_DESC_NULLS_FIRST = "entityType_DESC_NULLS_FIRST",
+  entityType_DESC_NULLS_LAST = "entityType_DESC_NULLS_LAST",
+  feeUsdForPool_ASC = "feeUsdForPool_ASC",
+  feeUsdForPool_ASC_NULLS_FIRST = "feeUsdForPool_ASC_NULLS_FIRST",
+  feeUsdForPool_ASC_NULLS_LAST = "feeUsdForPool_ASC_NULLS_LAST",
+  feeUsdForPool_DESC = "feeUsdForPool_DESC",
+  feeUsdForPool_DESC_NULLS_FIRST = "feeUsdForPool_DESC_NULLS_FIRST",
+  feeUsdForPool_DESC_NULLS_LAST = "feeUsdForPool_DESC_NULLS_LAST",
+  feeUsdPerPoolValue_ASC = "feeUsdPerPoolValue_ASC",
+  feeUsdPerPoolValue_ASC_NULLS_FIRST = "feeUsdPerPoolValue_ASC_NULLS_FIRST",
+  feeUsdPerPoolValue_ASC_NULLS_LAST = "feeUsdPerPoolValue_ASC_NULLS_LAST",
+  feeUsdPerPoolValue_DESC = "feeUsdPerPoolValue_DESC",
+  feeUsdPerPoolValue_DESC_NULLS_FIRST = "feeUsdPerPoolValue_DESC_NULLS_FIRST",
+  feeUsdPerPoolValue_DESC_NULLS_LAST = "feeUsdPerPoolValue_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  period_ASC = "period_ASC",
+  period_ASC_NULLS_FIRST = "period_ASC_NULLS_FIRST",
+  period_ASC_NULLS_LAST = "period_ASC_NULLS_LAST",
+  period_DESC = "period_DESC",
+  period_DESC_NULLS_FIRST = "period_DESC_NULLS_FIRST",
+  period_DESC_NULLS_LAST = "period_DESC_NULLS_LAST",
+  timestampGroup_ASC = "timestampGroup_ASC",
+  timestampGroup_ASC_NULLS_FIRST = "timestampGroup_ASC_NULLS_FIRST",
+  timestampGroup_ASC_NULLS_LAST = "timestampGroup_ASC_NULLS_LAST",
+  timestampGroup_DESC = "timestampGroup_DESC",
+  timestampGroup_DESC_NULLS_FIRST = "timestampGroup_DESC_NULLS_FIRST",
+  timestampGroup_DESC_NULLS_LAST = "timestampGroup_DESC_NULLS_LAST",
+}
+
+export interface CollectedFeesInfoWhereInput {
+  AND?: InputMaybe<Array<CollectedFeesInfoWhereInput>>;
+  OR?: InputMaybe<Array<CollectedFeesInfoWhereInput>>;
+  address_contains?: InputMaybe<Scalars["String"]["input"]>;
+  address_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  address_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_eq?: InputMaybe<Scalars["String"]["input"]>;
+  address_gt?: InputMaybe<Scalars["String"]["input"]>;
+  address_gte?: InputMaybe<Scalars["String"]["input"]>;
+  address_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  address_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  address_lt?: InputMaybe<Scalars["String"]["input"]>;
+  address_lte?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  address_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  borrowingFeeUsdForPool_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeUsdForPool_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeUsdForPool_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeUsdForPool_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFeeUsdForPool_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  borrowingFeeUsdForPool_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeUsdForPool_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeUsdForPool_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeUsdForPool_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFeeUsdPerPoolValue_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeUsdPerPoolValue_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeUsdPerPoolValue_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeUsdPerPoolValue_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFeeUsdPerPoolValue_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  borrowingFeeUsdPerPoolValue_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeUsdPerPoolValue_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeUsdPerPoolValue_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeUsdPerPoolValue_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeBorrowingFeeUsdForPool_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeBorrowingFeeUsdForPool_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeBorrowingFeeUsdForPool_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeBorrowingFeeUsdForPool_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeBorrowingFeeUsdForPool_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  cumulativeBorrowingFeeUsdForPool_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeBorrowingFeeUsdForPool_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeBorrowingFeeUsdForPool_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeBorrowingFeeUsdForPool_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeBorrowingFeeUsdPerPoolValue_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeBorrowingFeeUsdPerPoolValue_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeBorrowingFeeUsdPerPoolValue_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeBorrowingFeeUsdPerPoolValue_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeBorrowingFeeUsdPerPoolValue_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  cumulativeBorrowingFeeUsdPerPoolValue_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeBorrowingFeeUsdPerPoolValue_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeBorrowingFeeUsdPerPoolValue_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeBorrowingFeeUsdPerPoolValue_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeFeeUsdForPool_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeFeeUsdForPool_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeFeeUsdForPool_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeFeeUsdForPool_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeFeeUsdForPool_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  cumulativeFeeUsdForPool_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeFeeUsdForPool_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeFeeUsdForPool_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeFeeUsdForPool_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeFeeUsdPerPoolValue_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeFeeUsdPerPoolValue_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeFeeUsdPerPoolValue_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeFeeUsdPerPoolValue_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeFeeUsdPerPoolValue_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  cumulativeFeeUsdPerPoolValue_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeFeeUsdPerPoolValue_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeFeeUsdPerPoolValue_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeFeeUsdPerPoolValue_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  entityType_eq?: InputMaybe<EntityType>;
+  entityType_in?: InputMaybe<Array<EntityType>>;
+  entityType_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  entityType_not_eq?: InputMaybe<EntityType>;
+  entityType_not_in?: InputMaybe<Array<EntityType>>;
+  feeUsdForPool_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdForPool_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdForPool_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdForPool_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  feeUsdForPool_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  feeUsdForPool_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdForPool_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdForPool_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdForPool_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  feeUsdPerPoolValue_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdPerPoolValue_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdPerPoolValue_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdPerPoolValue_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  feeUsdPerPoolValue_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  feeUsdPerPoolValue_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdPerPoolValue_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdPerPoolValue_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdPerPoolValue_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  period_contains?: InputMaybe<Scalars["String"]["input"]>;
+  period_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  period_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  period_eq?: InputMaybe<Scalars["String"]["input"]>;
+  period_gt?: InputMaybe<Scalars["String"]["input"]>;
+  period_gte?: InputMaybe<Scalars["String"]["input"]>;
+  period_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  period_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  period_lt?: InputMaybe<Scalars["String"]["input"]>;
+  period_lte?: InputMaybe<Scalars["String"]["input"]>;
+  period_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  period_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  period_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  period_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  period_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  period_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  period_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  timestampGroup_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  timestampGroup_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  timestampGroup_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  timestampGroup_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  timestampGroup_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  timestampGroup_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  timestampGroup_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  timestampGroup_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  timestampGroup_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+}
+
+export interface CollectedFeesInfosConnection {
+  __typename?: "CollectedFeesInfosConnection";
+  edges: Array<CollectedFeesInfoEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface CumulativePnl {
+  __typename?: "CumulativePnl";
+  address: Scalars["String"]["output"];
+  cumulativeRealizedPnlLong: Scalars["BigInt"]["output"];
+  cumulativeRealizedPnlShort: Scalars["BigInt"]["output"];
+  cumulativeUnrealizedPnlLong: Scalars["BigInt"]["output"];
+  cumulativeUnrealizedPnlShort: Scalars["BigInt"]["output"];
+  entityType: EntityType;
+  id: Scalars["String"]["output"];
+  isSnapshot: Scalars["Boolean"]["output"];
+  lastUnrealizedPnlLong?: Maybe<Scalars["BigInt"]["output"]>;
+  lastUnrealizedPnlShort?: Maybe<Scalars["BigInt"]["output"]>;
+  snapshotTimestamp?: Maybe<Scalars["Int"]["output"]>;
+}
+
+export interface CumulativePnlEdge {
+  __typename?: "CumulativePnlEdge";
+  cursor: Scalars["String"]["output"];
+  node: CumulativePnl;
+}
+
+export enum CumulativePnlOrderByInput {
+  address_ASC = "address_ASC",
+  address_ASC_NULLS_FIRST = "address_ASC_NULLS_FIRST",
+  address_ASC_NULLS_LAST = "address_ASC_NULLS_LAST",
+  address_DESC = "address_DESC",
+  address_DESC_NULLS_FIRST = "address_DESC_NULLS_FIRST",
+  address_DESC_NULLS_LAST = "address_DESC_NULLS_LAST",
+  cumulativeRealizedPnlLong_ASC = "cumulativeRealizedPnlLong_ASC",
+  cumulativeRealizedPnlLong_ASC_NULLS_FIRST = "cumulativeRealizedPnlLong_ASC_NULLS_FIRST",
+  cumulativeRealizedPnlLong_ASC_NULLS_LAST = "cumulativeRealizedPnlLong_ASC_NULLS_LAST",
+  cumulativeRealizedPnlLong_DESC = "cumulativeRealizedPnlLong_DESC",
+  cumulativeRealizedPnlLong_DESC_NULLS_FIRST = "cumulativeRealizedPnlLong_DESC_NULLS_FIRST",
+  cumulativeRealizedPnlLong_DESC_NULLS_LAST = "cumulativeRealizedPnlLong_DESC_NULLS_LAST",
+  cumulativeRealizedPnlShort_ASC = "cumulativeRealizedPnlShort_ASC",
+  cumulativeRealizedPnlShort_ASC_NULLS_FIRST = "cumulativeRealizedPnlShort_ASC_NULLS_FIRST",
+  cumulativeRealizedPnlShort_ASC_NULLS_LAST = "cumulativeRealizedPnlShort_ASC_NULLS_LAST",
+  cumulativeRealizedPnlShort_DESC = "cumulativeRealizedPnlShort_DESC",
+  cumulativeRealizedPnlShort_DESC_NULLS_FIRST = "cumulativeRealizedPnlShort_DESC_NULLS_FIRST",
+  cumulativeRealizedPnlShort_DESC_NULLS_LAST = "cumulativeRealizedPnlShort_DESC_NULLS_LAST",
+  cumulativeUnrealizedPnlLong_ASC = "cumulativeUnrealizedPnlLong_ASC",
+  cumulativeUnrealizedPnlLong_ASC_NULLS_FIRST = "cumulativeUnrealizedPnlLong_ASC_NULLS_FIRST",
+  cumulativeUnrealizedPnlLong_ASC_NULLS_LAST = "cumulativeUnrealizedPnlLong_ASC_NULLS_LAST",
+  cumulativeUnrealizedPnlLong_DESC = "cumulativeUnrealizedPnlLong_DESC",
+  cumulativeUnrealizedPnlLong_DESC_NULLS_FIRST = "cumulativeUnrealizedPnlLong_DESC_NULLS_FIRST",
+  cumulativeUnrealizedPnlLong_DESC_NULLS_LAST = "cumulativeUnrealizedPnlLong_DESC_NULLS_LAST",
+  cumulativeUnrealizedPnlShort_ASC = "cumulativeUnrealizedPnlShort_ASC",
+  cumulativeUnrealizedPnlShort_ASC_NULLS_FIRST = "cumulativeUnrealizedPnlShort_ASC_NULLS_FIRST",
+  cumulativeUnrealizedPnlShort_ASC_NULLS_LAST = "cumulativeUnrealizedPnlShort_ASC_NULLS_LAST",
+  cumulativeUnrealizedPnlShort_DESC = "cumulativeUnrealizedPnlShort_DESC",
+  cumulativeUnrealizedPnlShort_DESC_NULLS_FIRST = "cumulativeUnrealizedPnlShort_DESC_NULLS_FIRST",
+  cumulativeUnrealizedPnlShort_DESC_NULLS_LAST = "cumulativeUnrealizedPnlShort_DESC_NULLS_LAST",
+  entityType_ASC = "entityType_ASC",
+  entityType_ASC_NULLS_FIRST = "entityType_ASC_NULLS_FIRST",
+  entityType_ASC_NULLS_LAST = "entityType_ASC_NULLS_LAST",
+  entityType_DESC = "entityType_DESC",
+  entityType_DESC_NULLS_FIRST = "entityType_DESC_NULLS_FIRST",
+  entityType_DESC_NULLS_LAST = "entityType_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  isSnapshot_ASC = "isSnapshot_ASC",
+  isSnapshot_ASC_NULLS_FIRST = "isSnapshot_ASC_NULLS_FIRST",
+  isSnapshot_ASC_NULLS_LAST = "isSnapshot_ASC_NULLS_LAST",
+  isSnapshot_DESC = "isSnapshot_DESC",
+  isSnapshot_DESC_NULLS_FIRST = "isSnapshot_DESC_NULLS_FIRST",
+  isSnapshot_DESC_NULLS_LAST = "isSnapshot_DESC_NULLS_LAST",
+  lastUnrealizedPnlLong_ASC = "lastUnrealizedPnlLong_ASC",
+  lastUnrealizedPnlLong_ASC_NULLS_FIRST = "lastUnrealizedPnlLong_ASC_NULLS_FIRST",
+  lastUnrealizedPnlLong_ASC_NULLS_LAST = "lastUnrealizedPnlLong_ASC_NULLS_LAST",
+  lastUnrealizedPnlLong_DESC = "lastUnrealizedPnlLong_DESC",
+  lastUnrealizedPnlLong_DESC_NULLS_FIRST = "lastUnrealizedPnlLong_DESC_NULLS_FIRST",
+  lastUnrealizedPnlLong_DESC_NULLS_LAST = "lastUnrealizedPnlLong_DESC_NULLS_LAST",
+  lastUnrealizedPnlShort_ASC = "lastUnrealizedPnlShort_ASC",
+  lastUnrealizedPnlShort_ASC_NULLS_FIRST = "lastUnrealizedPnlShort_ASC_NULLS_FIRST",
+  lastUnrealizedPnlShort_ASC_NULLS_LAST = "lastUnrealizedPnlShort_ASC_NULLS_LAST",
+  lastUnrealizedPnlShort_DESC = "lastUnrealizedPnlShort_DESC",
+  lastUnrealizedPnlShort_DESC_NULLS_FIRST = "lastUnrealizedPnlShort_DESC_NULLS_FIRST",
+  lastUnrealizedPnlShort_DESC_NULLS_LAST = "lastUnrealizedPnlShort_DESC_NULLS_LAST",
+  snapshotTimestamp_ASC = "snapshotTimestamp_ASC",
+  snapshotTimestamp_ASC_NULLS_FIRST = "snapshotTimestamp_ASC_NULLS_FIRST",
+  snapshotTimestamp_ASC_NULLS_LAST = "snapshotTimestamp_ASC_NULLS_LAST",
+  snapshotTimestamp_DESC = "snapshotTimestamp_DESC",
+  snapshotTimestamp_DESC_NULLS_FIRST = "snapshotTimestamp_DESC_NULLS_FIRST",
+  snapshotTimestamp_DESC_NULLS_LAST = "snapshotTimestamp_DESC_NULLS_LAST",
+}
+
+export interface CumulativePnlWhereInput {
+  AND?: InputMaybe<Array<CumulativePnlWhereInput>>;
+  OR?: InputMaybe<Array<CumulativePnlWhereInput>>;
+  address_contains?: InputMaybe<Scalars["String"]["input"]>;
+  address_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  address_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_eq?: InputMaybe<Scalars["String"]["input"]>;
+  address_gt?: InputMaybe<Scalars["String"]["input"]>;
+  address_gte?: InputMaybe<Scalars["String"]["input"]>;
+  address_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  address_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  address_lt?: InputMaybe<Scalars["String"]["input"]>;
+  address_lte?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  address_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  cumulativeRealizedPnlLong_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeRealizedPnlLong_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeRealizedPnlLong_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeRealizedPnlLong_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeRealizedPnlLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  cumulativeRealizedPnlLong_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeRealizedPnlLong_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeRealizedPnlLong_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeRealizedPnlLong_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeRealizedPnlShort_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeRealizedPnlShort_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeRealizedPnlShort_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeRealizedPnlShort_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeRealizedPnlShort_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  cumulativeRealizedPnlShort_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeRealizedPnlShort_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeRealizedPnlShort_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeRealizedPnlShort_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeUnrealizedPnlLong_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeUnrealizedPnlLong_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeUnrealizedPnlLong_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeUnrealizedPnlLong_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeUnrealizedPnlLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  cumulativeUnrealizedPnlLong_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeUnrealizedPnlLong_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeUnrealizedPnlLong_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeUnrealizedPnlLong_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeUnrealizedPnlShort_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeUnrealizedPnlShort_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeUnrealizedPnlShort_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeUnrealizedPnlShort_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeUnrealizedPnlShort_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  cumulativeUnrealizedPnlShort_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeUnrealizedPnlShort_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeUnrealizedPnlShort_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeUnrealizedPnlShort_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  entityType_eq?: InputMaybe<EntityType>;
+  entityType_in?: InputMaybe<Array<EntityType>>;
+  entityType_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  entityType_not_eq?: InputMaybe<EntityType>;
+  entityType_not_in?: InputMaybe<Array<EntityType>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  isSnapshot_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isSnapshot_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isSnapshot_not_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  lastUnrealizedPnlLong_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastUnrealizedPnlLong_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastUnrealizedPnlLong_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastUnrealizedPnlLong_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  lastUnrealizedPnlLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  lastUnrealizedPnlLong_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastUnrealizedPnlLong_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastUnrealizedPnlLong_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastUnrealizedPnlLong_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  lastUnrealizedPnlShort_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastUnrealizedPnlShort_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastUnrealizedPnlShort_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastUnrealizedPnlShort_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  lastUnrealizedPnlShort_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  lastUnrealizedPnlShort_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastUnrealizedPnlShort_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastUnrealizedPnlShort_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastUnrealizedPnlShort_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  snapshotTimestamp_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  snapshotTimestamp_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  snapshotTimestamp_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+}
+
+export interface CumulativePnlsConnection {
+  __typename?: "CumulativePnlsConnection";
+  edges: Array<CumulativePnlEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface CumulativePoolValue {
+  __typename?: "CumulativePoolValue";
+  address: Scalars["String"]["output"];
+  cumulativePoolValueByTime: Scalars["BigInt"]["output"];
+  cumulativeTime: Scalars["BigInt"]["output"];
+  entityType: EntityType;
+  id: Scalars["String"]["output"];
+  isSnapshot: Scalars["Boolean"]["output"];
+  lastPoolValue: Scalars["BigInt"]["output"];
+  lastUpdateTimestamp: Scalars["Int"]["output"];
+  snapshotTimestamp?: Maybe<Scalars["Int"]["output"]>;
+}
+
+export interface CumulativePoolValueEdge {
+  __typename?: "CumulativePoolValueEdge";
+  cursor: Scalars["String"]["output"];
+  node: CumulativePoolValue;
+}
+
+export enum CumulativePoolValueOrderByInput {
+  address_ASC = "address_ASC",
+  address_ASC_NULLS_FIRST = "address_ASC_NULLS_FIRST",
+  address_ASC_NULLS_LAST = "address_ASC_NULLS_LAST",
+  address_DESC = "address_DESC",
+  address_DESC_NULLS_FIRST = "address_DESC_NULLS_FIRST",
+  address_DESC_NULLS_LAST = "address_DESC_NULLS_LAST",
+  cumulativePoolValueByTime_ASC = "cumulativePoolValueByTime_ASC",
+  cumulativePoolValueByTime_ASC_NULLS_FIRST = "cumulativePoolValueByTime_ASC_NULLS_FIRST",
+  cumulativePoolValueByTime_ASC_NULLS_LAST = "cumulativePoolValueByTime_ASC_NULLS_LAST",
+  cumulativePoolValueByTime_DESC = "cumulativePoolValueByTime_DESC",
+  cumulativePoolValueByTime_DESC_NULLS_FIRST = "cumulativePoolValueByTime_DESC_NULLS_FIRST",
+  cumulativePoolValueByTime_DESC_NULLS_LAST = "cumulativePoolValueByTime_DESC_NULLS_LAST",
+  cumulativeTime_ASC = "cumulativeTime_ASC",
+  cumulativeTime_ASC_NULLS_FIRST = "cumulativeTime_ASC_NULLS_FIRST",
+  cumulativeTime_ASC_NULLS_LAST = "cumulativeTime_ASC_NULLS_LAST",
+  cumulativeTime_DESC = "cumulativeTime_DESC",
+  cumulativeTime_DESC_NULLS_FIRST = "cumulativeTime_DESC_NULLS_FIRST",
+  cumulativeTime_DESC_NULLS_LAST = "cumulativeTime_DESC_NULLS_LAST",
+  entityType_ASC = "entityType_ASC",
+  entityType_ASC_NULLS_FIRST = "entityType_ASC_NULLS_FIRST",
+  entityType_ASC_NULLS_LAST = "entityType_ASC_NULLS_LAST",
+  entityType_DESC = "entityType_DESC",
+  entityType_DESC_NULLS_FIRST = "entityType_DESC_NULLS_FIRST",
+  entityType_DESC_NULLS_LAST = "entityType_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  isSnapshot_ASC = "isSnapshot_ASC",
+  isSnapshot_ASC_NULLS_FIRST = "isSnapshot_ASC_NULLS_FIRST",
+  isSnapshot_ASC_NULLS_LAST = "isSnapshot_ASC_NULLS_LAST",
+  isSnapshot_DESC = "isSnapshot_DESC",
+  isSnapshot_DESC_NULLS_FIRST = "isSnapshot_DESC_NULLS_FIRST",
+  isSnapshot_DESC_NULLS_LAST = "isSnapshot_DESC_NULLS_LAST",
+  lastPoolValue_ASC = "lastPoolValue_ASC",
+  lastPoolValue_ASC_NULLS_FIRST = "lastPoolValue_ASC_NULLS_FIRST",
+  lastPoolValue_ASC_NULLS_LAST = "lastPoolValue_ASC_NULLS_LAST",
+  lastPoolValue_DESC = "lastPoolValue_DESC",
+  lastPoolValue_DESC_NULLS_FIRST = "lastPoolValue_DESC_NULLS_FIRST",
+  lastPoolValue_DESC_NULLS_LAST = "lastPoolValue_DESC_NULLS_LAST",
+  lastUpdateTimestamp_ASC = "lastUpdateTimestamp_ASC",
+  lastUpdateTimestamp_ASC_NULLS_FIRST = "lastUpdateTimestamp_ASC_NULLS_FIRST",
+  lastUpdateTimestamp_ASC_NULLS_LAST = "lastUpdateTimestamp_ASC_NULLS_LAST",
+  lastUpdateTimestamp_DESC = "lastUpdateTimestamp_DESC",
+  lastUpdateTimestamp_DESC_NULLS_FIRST = "lastUpdateTimestamp_DESC_NULLS_FIRST",
+  lastUpdateTimestamp_DESC_NULLS_LAST = "lastUpdateTimestamp_DESC_NULLS_LAST",
+  snapshotTimestamp_ASC = "snapshotTimestamp_ASC",
+  snapshotTimestamp_ASC_NULLS_FIRST = "snapshotTimestamp_ASC_NULLS_FIRST",
+  snapshotTimestamp_ASC_NULLS_LAST = "snapshotTimestamp_ASC_NULLS_LAST",
+  snapshotTimestamp_DESC = "snapshotTimestamp_DESC",
+  snapshotTimestamp_DESC_NULLS_FIRST = "snapshotTimestamp_DESC_NULLS_FIRST",
+  snapshotTimestamp_DESC_NULLS_LAST = "snapshotTimestamp_DESC_NULLS_LAST",
+}
+
+export interface CumulativePoolValueWhereInput {
+  AND?: InputMaybe<Array<CumulativePoolValueWhereInput>>;
+  OR?: InputMaybe<Array<CumulativePoolValueWhereInput>>;
+  address_contains?: InputMaybe<Scalars["String"]["input"]>;
+  address_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  address_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_eq?: InputMaybe<Scalars["String"]["input"]>;
+  address_gt?: InputMaybe<Scalars["String"]["input"]>;
+  address_gte?: InputMaybe<Scalars["String"]["input"]>;
+  address_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  address_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  address_lt?: InputMaybe<Scalars["String"]["input"]>;
+  address_lte?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  address_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  cumulativePoolValueByTime_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativePoolValueByTime_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativePoolValueByTime_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativePoolValueByTime_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativePoolValueByTime_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  cumulativePoolValueByTime_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativePoolValueByTime_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativePoolValueByTime_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativePoolValueByTime_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeTime_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeTime_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeTime_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeTime_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cumulativeTime_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  cumulativeTime_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeTime_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeTime_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  cumulativeTime_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  entityType_eq?: InputMaybe<EntityType>;
+  entityType_in?: InputMaybe<Array<EntityType>>;
+  entityType_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  entityType_not_eq?: InputMaybe<EntityType>;
+  entityType_not_in?: InputMaybe<Array<EntityType>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  isSnapshot_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isSnapshot_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isSnapshot_not_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  lastPoolValue_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastPoolValue_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastPoolValue_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastPoolValue_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  lastPoolValue_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  lastPoolValue_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastPoolValue_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastPoolValue_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lastPoolValue_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  lastUpdateTimestamp_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  lastUpdateTimestamp_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  lastUpdateTimestamp_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  lastUpdateTimestamp_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  lastUpdateTimestamp_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  lastUpdateTimestamp_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  lastUpdateTimestamp_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  lastUpdateTimestamp_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  lastUpdateTimestamp_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  snapshotTimestamp_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  snapshotTimestamp_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  snapshotTimestamp_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+}
+
+export interface CumulativePoolValuesConnection {
+  __typename?: "CumulativePoolValuesConnection";
+  edges: Array<CumulativePoolValueEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface Distribution {
+  __typename?: "Distribution";
+  amounts: Array<Scalars["String"]["output"]>;
+  amountsInUsd: Array<Scalars["String"]["output"]>;
+  id: Scalars["String"]["output"];
+  receiver: Scalars["String"]["output"];
+  tokens: Array<Scalars["String"]["output"]>;
+  transaction: Transaction;
+  typeId: Scalars["BigInt"]["output"];
+}
+
+export interface DistributionEdge {
+  __typename?: "DistributionEdge";
+  cursor: Scalars["String"]["output"];
+  node: Distribution;
+}
+
+export enum DistributionOrderByInput {
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  receiver_ASC = "receiver_ASC",
+  receiver_ASC_NULLS_FIRST = "receiver_ASC_NULLS_FIRST",
+  receiver_ASC_NULLS_LAST = "receiver_ASC_NULLS_LAST",
+  receiver_DESC = "receiver_DESC",
+  receiver_DESC_NULLS_FIRST = "receiver_DESC_NULLS_FIRST",
+  receiver_DESC_NULLS_LAST = "receiver_DESC_NULLS_LAST",
+  transaction_blockNumber_ASC = "transaction_blockNumber_ASC",
+  transaction_blockNumber_ASC_NULLS_FIRST = "transaction_blockNumber_ASC_NULLS_FIRST",
+  transaction_blockNumber_ASC_NULLS_LAST = "transaction_blockNumber_ASC_NULLS_LAST",
+  transaction_blockNumber_DESC = "transaction_blockNumber_DESC",
+  transaction_blockNumber_DESC_NULLS_FIRST = "transaction_blockNumber_DESC_NULLS_FIRST",
+  transaction_blockNumber_DESC_NULLS_LAST = "transaction_blockNumber_DESC_NULLS_LAST",
+  transaction_chainId_ASC = "transaction_chainId_ASC",
+  transaction_chainId_ASC_NULLS_FIRST = "transaction_chainId_ASC_NULLS_FIRST",
+  transaction_chainId_ASC_NULLS_LAST = "transaction_chainId_ASC_NULLS_LAST",
+  transaction_chainId_DESC = "transaction_chainId_DESC",
+  transaction_chainId_DESC_NULLS_FIRST = "transaction_chainId_DESC_NULLS_FIRST",
+  transaction_chainId_DESC_NULLS_LAST = "transaction_chainId_DESC_NULLS_LAST",
+  transaction_from_ASC = "transaction_from_ASC",
+  transaction_from_ASC_NULLS_FIRST = "transaction_from_ASC_NULLS_FIRST",
+  transaction_from_ASC_NULLS_LAST = "transaction_from_ASC_NULLS_LAST",
+  transaction_from_DESC = "transaction_from_DESC",
+  transaction_from_DESC_NULLS_FIRST = "transaction_from_DESC_NULLS_FIRST",
+  transaction_from_DESC_NULLS_LAST = "transaction_from_DESC_NULLS_LAST",
+  transaction_hash_ASC = "transaction_hash_ASC",
+  transaction_hash_ASC_NULLS_FIRST = "transaction_hash_ASC_NULLS_FIRST",
+  transaction_hash_ASC_NULLS_LAST = "transaction_hash_ASC_NULLS_LAST",
+  transaction_hash_DESC = "transaction_hash_DESC",
+  transaction_hash_DESC_NULLS_FIRST = "transaction_hash_DESC_NULLS_FIRST",
+  transaction_hash_DESC_NULLS_LAST = "transaction_hash_DESC_NULLS_LAST",
+  transaction_id_ASC = "transaction_id_ASC",
+  transaction_id_ASC_NULLS_FIRST = "transaction_id_ASC_NULLS_FIRST",
+  transaction_id_ASC_NULLS_LAST = "transaction_id_ASC_NULLS_LAST",
+  transaction_id_DESC = "transaction_id_DESC",
+  transaction_id_DESC_NULLS_FIRST = "transaction_id_DESC_NULLS_FIRST",
+  transaction_id_DESC_NULLS_LAST = "transaction_id_DESC_NULLS_LAST",
+  transaction_timestamp_ASC = "transaction_timestamp_ASC",
+  transaction_timestamp_ASC_NULLS_FIRST = "transaction_timestamp_ASC_NULLS_FIRST",
+  transaction_timestamp_ASC_NULLS_LAST = "transaction_timestamp_ASC_NULLS_LAST",
+  transaction_timestamp_DESC = "transaction_timestamp_DESC",
+  transaction_timestamp_DESC_NULLS_FIRST = "transaction_timestamp_DESC_NULLS_FIRST",
+  transaction_timestamp_DESC_NULLS_LAST = "transaction_timestamp_DESC_NULLS_LAST",
+  transaction_to_ASC = "transaction_to_ASC",
+  transaction_to_ASC_NULLS_FIRST = "transaction_to_ASC_NULLS_FIRST",
+  transaction_to_ASC_NULLS_LAST = "transaction_to_ASC_NULLS_LAST",
+  transaction_to_DESC = "transaction_to_DESC",
+  transaction_to_DESC_NULLS_FIRST = "transaction_to_DESC_NULLS_FIRST",
+  transaction_to_DESC_NULLS_LAST = "transaction_to_DESC_NULLS_LAST",
+  transaction_transactionIndex_ASC = "transaction_transactionIndex_ASC",
+  transaction_transactionIndex_ASC_NULLS_FIRST = "transaction_transactionIndex_ASC_NULLS_FIRST",
+  transaction_transactionIndex_ASC_NULLS_LAST = "transaction_transactionIndex_ASC_NULLS_LAST",
+  transaction_transactionIndex_DESC = "transaction_transactionIndex_DESC",
+  transaction_transactionIndex_DESC_NULLS_FIRST = "transaction_transactionIndex_DESC_NULLS_FIRST",
+  transaction_transactionIndex_DESC_NULLS_LAST = "transaction_transactionIndex_DESC_NULLS_LAST",
+  typeId_ASC = "typeId_ASC",
+  typeId_ASC_NULLS_FIRST = "typeId_ASC_NULLS_FIRST",
+  typeId_ASC_NULLS_LAST = "typeId_ASC_NULLS_LAST",
+  typeId_DESC = "typeId_DESC",
+  typeId_DESC_NULLS_FIRST = "typeId_DESC_NULLS_FIRST",
+  typeId_DESC_NULLS_LAST = "typeId_DESC_NULLS_LAST",
+}
+
+export interface DistributionWhereInput {
+  AND?: InputMaybe<Array<DistributionWhereInput>>;
+  OR?: InputMaybe<Array<DistributionWhereInput>>;
+  amountsInUsd_containsAll?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  amountsInUsd_containsAny?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  amountsInUsd_containsNone?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  amountsInUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  amounts_containsAll?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  amounts_containsAny?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  amounts_containsNone?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  amounts_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_contains?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_eq?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_gt?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_gte?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  receiver_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  receiver_lt?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_lte?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  receiver_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokens_containsAll?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokens_containsAny?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokens_containsNone?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokens_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  transaction?: InputMaybe<TransactionWhereInput>;
+  transaction_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  typeId_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  typeId_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  typeId_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  typeId_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  typeId_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  typeId_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  typeId_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  typeId_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  typeId_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+}
+
+export interface DistributionsConnection {
+  __typename?: "DistributionsConnection";
+  edges: Array<DistributionEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export enum EntityType {
+  Glv = "Glv",
+  Market = "Market",
+}
+
+export interface Glv {
+  __typename?: "Glv";
+  glvTokenAddress: Scalars["String"]["output"];
+  gmComposition: Array<Scalars["String"]["output"]>;
+  id: Scalars["String"]["output"];
+  longTokenAddress: Scalars["String"]["output"];
+  markets: Array<Scalars["String"]["output"]>;
+  poolValue: Scalars["BigInt"]["output"];
+  shortTokenAddress: Scalars["String"]["output"];
+}
+
+export interface GlvApr {
+  __typename?: "GlvApr";
+  aprByBorrowingFee: Scalars["BigInt"]["output"];
+  aprByFee: Scalars["BigInt"]["output"];
+  glvAddress: Scalars["String"]["output"];
+}
+
+export interface GlvAprsWhereInputWhereInput {
+  glvAddresses?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  periodEnd: Scalars["Float"]["input"];
+  periodStart: Scalars["Float"]["input"];
+}
+
+export interface GlvEdge {
+  __typename?: "GlvEdge";
+  cursor: Scalars["String"]["output"];
+  node: Glv;
+}
+
+export enum GlvOrderByInput {
+  glvTokenAddress_ASC = "glvTokenAddress_ASC",
+  glvTokenAddress_ASC_NULLS_FIRST = "glvTokenAddress_ASC_NULLS_FIRST",
+  glvTokenAddress_ASC_NULLS_LAST = "glvTokenAddress_ASC_NULLS_LAST",
+  glvTokenAddress_DESC = "glvTokenAddress_DESC",
+  glvTokenAddress_DESC_NULLS_FIRST = "glvTokenAddress_DESC_NULLS_FIRST",
+  glvTokenAddress_DESC_NULLS_LAST = "glvTokenAddress_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  longTokenAddress_ASC = "longTokenAddress_ASC",
+  longTokenAddress_ASC_NULLS_FIRST = "longTokenAddress_ASC_NULLS_FIRST",
+  longTokenAddress_ASC_NULLS_LAST = "longTokenAddress_ASC_NULLS_LAST",
+  longTokenAddress_DESC = "longTokenAddress_DESC",
+  longTokenAddress_DESC_NULLS_FIRST = "longTokenAddress_DESC_NULLS_FIRST",
+  longTokenAddress_DESC_NULLS_LAST = "longTokenAddress_DESC_NULLS_LAST",
+  poolValue_ASC = "poolValue_ASC",
+  poolValue_ASC_NULLS_FIRST = "poolValue_ASC_NULLS_FIRST",
+  poolValue_ASC_NULLS_LAST = "poolValue_ASC_NULLS_LAST",
+  poolValue_DESC = "poolValue_DESC",
+  poolValue_DESC_NULLS_FIRST = "poolValue_DESC_NULLS_FIRST",
+  poolValue_DESC_NULLS_LAST = "poolValue_DESC_NULLS_LAST",
+  shortTokenAddress_ASC = "shortTokenAddress_ASC",
+  shortTokenAddress_ASC_NULLS_FIRST = "shortTokenAddress_ASC_NULLS_FIRST",
+  shortTokenAddress_ASC_NULLS_LAST = "shortTokenAddress_ASC_NULLS_LAST",
+  shortTokenAddress_DESC = "shortTokenAddress_DESC",
+  shortTokenAddress_DESC_NULLS_FIRST = "shortTokenAddress_DESC_NULLS_FIRST",
+  shortTokenAddress_DESC_NULLS_LAST = "shortTokenAddress_DESC_NULLS_LAST",
+}
+
+export interface GlvPnlApr {
+  __typename?: "GlvPnlApr";
+  apr: Scalars["BigInt"]["output"];
+  glvAddress: Scalars["String"]["output"];
+  periodRealizedPnlLong: Scalars["BigInt"]["output"];
+  periodRealizedPnlShort: Scalars["BigInt"]["output"];
+  periodUnrealizedPnlLong: Scalars["BigInt"]["output"];
+  periodUnrealizedPnlShort: Scalars["BigInt"]["output"];
+  timeWeightedPoolValue: Scalars["BigInt"]["output"];
+}
+
+export interface GlvPnlAprsWhereInputWhereInput {
+  glvAddresses?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  periodEnd: Scalars["Float"]["input"];
+  periodStart: Scalars["Float"]["input"];
+}
+
+export interface GlvWhereInput {
+  AND?: InputMaybe<Array<GlvWhereInput>>;
+  OR?: InputMaybe<Array<GlvWhereInput>>;
+  glvTokenAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  glvTokenAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  glvTokenAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  glvTokenAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  glvTokenAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  glvTokenAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  glvTokenAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  glvTokenAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  glvTokenAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  glvTokenAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  glvTokenAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  glvTokenAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  glvTokenAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  glvTokenAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  glvTokenAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  glvTokenAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  glvTokenAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  gmComposition_containsAll?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  gmComposition_containsAny?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  gmComposition_containsNone?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  gmComposition_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  longTokenAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  longTokenAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  longTokenAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  markets_containsAll?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  markets_containsAny?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  markets_containsNone?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  markets_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  poolValue_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValue_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValue_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValue_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  poolValue_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  poolValue_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValue_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValue_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValue_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortTokenAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  shortTokenAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  shortTokenAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  shortTokenAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+}
+
+export interface GlvsConnection {
+  __typename?: "GlvsConnection";
+  edges: Array<GlvEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface Market {
+  __typename?: "Market";
+  id: Scalars["String"]["output"];
+  indexToken: Scalars["String"]["output"];
+  longToken: Scalars["String"]["output"];
+  shortToken: Scalars["String"]["output"];
+}
+
+export interface MarketApr {
+  __typename?: "MarketApr";
+  aprByBorrowingFee: Scalars["BigInt"]["output"];
+  aprByFee: Scalars["BigInt"]["output"];
+  marketAddress: Scalars["String"]["output"];
+}
+
+export interface MarketAprsWhereInput {
+  marketAddresses?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  periodEnd: Scalars["Float"]["input"];
+  periodStart: Scalars["Float"]["input"];
+}
+
+export interface MarketEdge {
+  __typename?: "MarketEdge";
+  cursor: Scalars["String"]["output"];
+  node: Market;
+}
+
+export interface MarketInfo {
+  __typename?: "MarketInfo";
+  aboveOptimalUsageBorrowingFactorLong: Scalars["BigInt"]["output"];
+  aboveOptimalUsageBorrowingFactorShort: Scalars["BigInt"]["output"];
+  atomicSwapFeeFactor: Scalars["BigInt"]["output"];
+  baseBorrowingFactorLong: Scalars["BigInt"]["output"];
+  baseBorrowingFactorShort: Scalars["BigInt"]["output"];
+  borrowingExponentFactorLong: Scalars["BigInt"]["output"];
+  borrowingExponentFactorShort: Scalars["BigInt"]["output"];
+  borrowingFactorLong: Scalars["BigInt"]["output"];
+  borrowingFactorPerSecondForLongs: Scalars["BigInt"]["output"];
+  borrowingFactorPerSecondForShorts: Scalars["BigInt"]["output"];
+  borrowingFactorShort: Scalars["BigInt"]["output"];
+  fundingDecreaseFactorPerSecond: Scalars["BigInt"]["output"];
+  fundingExponentFactor: Scalars["BigInt"]["output"];
+  fundingFactor: Scalars["BigInt"]["output"];
+  fundingFactorPerSecond: Scalars["BigInt"]["output"];
+  fundingIncreaseFactorPerSecond: Scalars["BigInt"]["output"];
+  id: Scalars["String"]["output"];
+  indexTokenAddress: Scalars["String"]["output"];
+  isDisabled: Scalars["Boolean"]["output"];
+  lentPositionImpactPoolAmount: Scalars["BigInt"]["output"];
+  longOpenInterestInTokens: Scalars["BigInt"]["output"];
+  longOpenInterestInTokensUsingLongToken: Scalars["BigInt"]["output"];
+  longOpenInterestInTokensUsingShortToken: Scalars["BigInt"]["output"];
+  longOpenInterestUsd: Scalars["BigInt"]["output"];
+  longOpenInterestUsingLongToken: Scalars["BigInt"]["output"];
+  longOpenInterestUsingShortToken: Scalars["BigInt"]["output"];
+  longPoolAmount: Scalars["BigInt"]["output"];
+  longPoolAmountAdjustment: Scalars["BigInt"]["output"];
+  longTokenAddress: Scalars["String"]["output"];
+  longsPayShorts: Scalars["Boolean"]["output"];
+  marketTokenAddress: Scalars["String"]["output"];
+  marketTokenSupply: Scalars["BigInt"]["output"];
+  maxFundingFactorPerSecond: Scalars["BigInt"]["output"];
+  maxLendableImpactFactor: Scalars["BigInt"]["output"];
+  maxLendableImpactFactorForWithdrawals: Scalars["BigInt"]["output"];
+  maxLendableImpactUsd: Scalars["BigInt"]["output"];
+  maxLongPoolAmount: Scalars["BigInt"]["output"];
+  maxLongPoolUsdForDeposit: Scalars["BigInt"]["output"];
+  maxOpenInterestLong: Scalars["BigInt"]["output"];
+  maxOpenInterestShort: Scalars["BigInt"]["output"];
+  maxPnlFactorForTradersLong: Scalars["BigInt"]["output"];
+  maxPnlFactorForTradersShort: Scalars["BigInt"]["output"];
+  maxPositionImpactFactorForLiquidations: Scalars["BigInt"]["output"];
+  maxPositionImpactFactorNegative: Scalars["BigInt"]["output"];
+  maxPositionImpactFactorPositive: Scalars["BigInt"]["output"];
+  maxShortPoolAmount: Scalars["BigInt"]["output"];
+  maxShortPoolUsdForDeposit: Scalars["BigInt"]["output"];
+  minCollateralFactor: Scalars["BigInt"]["output"];
+  minCollateralFactorForOpenInterestLong: Scalars["BigInt"]["output"];
+  minCollateralFactorForOpenInterestShort: Scalars["BigInt"]["output"];
+  minFundingFactorPerSecond: Scalars["BigInt"]["output"];
+  minPositionImpactPoolAmount: Scalars["BigInt"]["output"];
+  openInterestReserveFactorLong: Scalars["BigInt"]["output"];
+  openInterestReserveFactorShort: Scalars["BigInt"]["output"];
+  optimalUsageFactorLong: Scalars["BigInt"]["output"];
+  optimalUsageFactorShort: Scalars["BigInt"]["output"];
+  poolValue: Scalars["BigInt"]["output"];
+  poolValueMax: Scalars["BigInt"]["output"];
+  poolValueMin: Scalars["BigInt"]["output"];
+  positionFeeFactorForNegativeImpact: Scalars["BigInt"]["output"];
+  positionFeeFactorForPositiveImpact: Scalars["BigInt"]["output"];
+  positionImpactExponentFactor: Scalars["BigInt"]["output"];
+  positionImpactFactorNegative: Scalars["BigInt"]["output"];
+  positionImpactFactorPositive: Scalars["BigInt"]["output"];
+  positionImpactPoolAmount: Scalars["BigInt"]["output"];
+  positionImpactPoolDistributionRate: Scalars["BigInt"]["output"];
+  reserveFactorLong: Scalars["BigInt"]["output"];
+  reserveFactorShort: Scalars["BigInt"]["output"];
+  shortOpenInterestInTokens: Scalars["BigInt"]["output"];
+  shortOpenInterestInTokensUsingLongToken: Scalars["BigInt"]["output"];
+  shortOpenInterestInTokensUsingShortToken: Scalars["BigInt"]["output"];
+  shortOpenInterestUsd: Scalars["BigInt"]["output"];
+  shortOpenInterestUsingLongToken: Scalars["BigInt"]["output"];
+  shortOpenInterestUsingShortToken: Scalars["BigInt"]["output"];
+  shortPoolAmount: Scalars["BigInt"]["output"];
+  shortPoolAmountAdjustment: Scalars["BigInt"]["output"];
+  shortTokenAddress: Scalars["String"]["output"];
+  swapFeeFactorForNegativeImpact: Scalars["BigInt"]["output"];
+  swapFeeFactorForPositiveImpact: Scalars["BigInt"]["output"];
+  swapImpactExponentFactor: Scalars["BigInt"]["output"];
+  swapImpactFactorNegative: Scalars["BigInt"]["output"];
+  swapImpactFactorPositive: Scalars["BigInt"]["output"];
+  swapImpactPoolAmountLong: Scalars["BigInt"]["output"];
+  swapImpactPoolAmountShort: Scalars["BigInt"]["output"];
+  thresholdForDecreaseFunding: Scalars["BigInt"]["output"];
+  thresholdForStableFunding: Scalars["BigInt"]["output"];
+  totalBorrowingFees: Scalars["BigInt"]["output"];
+  virtualIndexTokenId: Scalars["String"]["output"];
+  virtualInventoryForPositions: Scalars["BigInt"]["output"];
+  virtualLongTokenId: Scalars["String"]["output"];
+  virtualMarketId: Scalars["String"]["output"];
+  virtualPoolAmountForLongToken: Scalars["BigInt"]["output"];
+  virtualPoolAmountForShortToken: Scalars["BigInt"]["output"];
+  virtualShortTokenId: Scalars["String"]["output"];
+}
+
+export interface MarketInfoEdge {
+  __typename?: "MarketInfoEdge";
+  cursor: Scalars["String"]["output"];
+  node: MarketInfo;
+}
+
+export enum MarketInfoOrderByInput {
+  aboveOptimalUsageBorrowingFactorLong_ASC = "aboveOptimalUsageBorrowingFactorLong_ASC",
+  aboveOptimalUsageBorrowingFactorLong_ASC_NULLS_FIRST = "aboveOptimalUsageBorrowingFactorLong_ASC_NULLS_FIRST",
+  aboveOptimalUsageBorrowingFactorLong_ASC_NULLS_LAST = "aboveOptimalUsageBorrowingFactorLong_ASC_NULLS_LAST",
+  aboveOptimalUsageBorrowingFactorLong_DESC = "aboveOptimalUsageBorrowingFactorLong_DESC",
+  aboveOptimalUsageBorrowingFactorLong_DESC_NULLS_FIRST = "aboveOptimalUsageBorrowingFactorLong_DESC_NULLS_FIRST",
+  aboveOptimalUsageBorrowingFactorLong_DESC_NULLS_LAST = "aboveOptimalUsageBorrowingFactorLong_DESC_NULLS_LAST",
+  aboveOptimalUsageBorrowingFactorShort_ASC = "aboveOptimalUsageBorrowingFactorShort_ASC",
+  aboveOptimalUsageBorrowingFactorShort_ASC_NULLS_FIRST = "aboveOptimalUsageBorrowingFactorShort_ASC_NULLS_FIRST",
+  aboveOptimalUsageBorrowingFactorShort_ASC_NULLS_LAST = "aboveOptimalUsageBorrowingFactorShort_ASC_NULLS_LAST",
+  aboveOptimalUsageBorrowingFactorShort_DESC = "aboveOptimalUsageBorrowingFactorShort_DESC",
+  aboveOptimalUsageBorrowingFactorShort_DESC_NULLS_FIRST = "aboveOptimalUsageBorrowingFactorShort_DESC_NULLS_FIRST",
+  aboveOptimalUsageBorrowingFactorShort_DESC_NULLS_LAST = "aboveOptimalUsageBorrowingFactorShort_DESC_NULLS_LAST",
+  atomicSwapFeeFactor_ASC = "atomicSwapFeeFactor_ASC",
+  atomicSwapFeeFactor_ASC_NULLS_FIRST = "atomicSwapFeeFactor_ASC_NULLS_FIRST",
+  atomicSwapFeeFactor_ASC_NULLS_LAST = "atomicSwapFeeFactor_ASC_NULLS_LAST",
+  atomicSwapFeeFactor_DESC = "atomicSwapFeeFactor_DESC",
+  atomicSwapFeeFactor_DESC_NULLS_FIRST = "atomicSwapFeeFactor_DESC_NULLS_FIRST",
+  atomicSwapFeeFactor_DESC_NULLS_LAST = "atomicSwapFeeFactor_DESC_NULLS_LAST",
+  baseBorrowingFactorLong_ASC = "baseBorrowingFactorLong_ASC",
+  baseBorrowingFactorLong_ASC_NULLS_FIRST = "baseBorrowingFactorLong_ASC_NULLS_FIRST",
+  baseBorrowingFactorLong_ASC_NULLS_LAST = "baseBorrowingFactorLong_ASC_NULLS_LAST",
+  baseBorrowingFactorLong_DESC = "baseBorrowingFactorLong_DESC",
+  baseBorrowingFactorLong_DESC_NULLS_FIRST = "baseBorrowingFactorLong_DESC_NULLS_FIRST",
+  baseBorrowingFactorLong_DESC_NULLS_LAST = "baseBorrowingFactorLong_DESC_NULLS_LAST",
+  baseBorrowingFactorShort_ASC = "baseBorrowingFactorShort_ASC",
+  baseBorrowingFactorShort_ASC_NULLS_FIRST = "baseBorrowingFactorShort_ASC_NULLS_FIRST",
+  baseBorrowingFactorShort_ASC_NULLS_LAST = "baseBorrowingFactorShort_ASC_NULLS_LAST",
+  baseBorrowingFactorShort_DESC = "baseBorrowingFactorShort_DESC",
+  baseBorrowingFactorShort_DESC_NULLS_FIRST = "baseBorrowingFactorShort_DESC_NULLS_FIRST",
+  baseBorrowingFactorShort_DESC_NULLS_LAST = "baseBorrowingFactorShort_DESC_NULLS_LAST",
+  borrowingExponentFactorLong_ASC = "borrowingExponentFactorLong_ASC",
+  borrowingExponentFactorLong_ASC_NULLS_FIRST = "borrowingExponentFactorLong_ASC_NULLS_FIRST",
+  borrowingExponentFactorLong_ASC_NULLS_LAST = "borrowingExponentFactorLong_ASC_NULLS_LAST",
+  borrowingExponentFactorLong_DESC = "borrowingExponentFactorLong_DESC",
+  borrowingExponentFactorLong_DESC_NULLS_FIRST = "borrowingExponentFactorLong_DESC_NULLS_FIRST",
+  borrowingExponentFactorLong_DESC_NULLS_LAST = "borrowingExponentFactorLong_DESC_NULLS_LAST",
+  borrowingExponentFactorShort_ASC = "borrowingExponentFactorShort_ASC",
+  borrowingExponentFactorShort_ASC_NULLS_FIRST = "borrowingExponentFactorShort_ASC_NULLS_FIRST",
+  borrowingExponentFactorShort_ASC_NULLS_LAST = "borrowingExponentFactorShort_ASC_NULLS_LAST",
+  borrowingExponentFactorShort_DESC = "borrowingExponentFactorShort_DESC",
+  borrowingExponentFactorShort_DESC_NULLS_FIRST = "borrowingExponentFactorShort_DESC_NULLS_FIRST",
+  borrowingExponentFactorShort_DESC_NULLS_LAST = "borrowingExponentFactorShort_DESC_NULLS_LAST",
+  borrowingFactorLong_ASC = "borrowingFactorLong_ASC",
+  borrowingFactorLong_ASC_NULLS_FIRST = "borrowingFactorLong_ASC_NULLS_FIRST",
+  borrowingFactorLong_ASC_NULLS_LAST = "borrowingFactorLong_ASC_NULLS_LAST",
+  borrowingFactorLong_DESC = "borrowingFactorLong_DESC",
+  borrowingFactorLong_DESC_NULLS_FIRST = "borrowingFactorLong_DESC_NULLS_FIRST",
+  borrowingFactorLong_DESC_NULLS_LAST = "borrowingFactorLong_DESC_NULLS_LAST",
+  borrowingFactorPerSecondForLongs_ASC = "borrowingFactorPerSecondForLongs_ASC",
+  borrowingFactorPerSecondForLongs_ASC_NULLS_FIRST = "borrowingFactorPerSecondForLongs_ASC_NULLS_FIRST",
+  borrowingFactorPerSecondForLongs_ASC_NULLS_LAST = "borrowingFactorPerSecondForLongs_ASC_NULLS_LAST",
+  borrowingFactorPerSecondForLongs_DESC = "borrowingFactorPerSecondForLongs_DESC",
+  borrowingFactorPerSecondForLongs_DESC_NULLS_FIRST = "borrowingFactorPerSecondForLongs_DESC_NULLS_FIRST",
+  borrowingFactorPerSecondForLongs_DESC_NULLS_LAST = "borrowingFactorPerSecondForLongs_DESC_NULLS_LAST",
+  borrowingFactorPerSecondForShorts_ASC = "borrowingFactorPerSecondForShorts_ASC",
+  borrowingFactorPerSecondForShorts_ASC_NULLS_FIRST = "borrowingFactorPerSecondForShorts_ASC_NULLS_FIRST",
+  borrowingFactorPerSecondForShorts_ASC_NULLS_LAST = "borrowingFactorPerSecondForShorts_ASC_NULLS_LAST",
+  borrowingFactorPerSecondForShorts_DESC = "borrowingFactorPerSecondForShorts_DESC",
+  borrowingFactorPerSecondForShorts_DESC_NULLS_FIRST = "borrowingFactorPerSecondForShorts_DESC_NULLS_FIRST",
+  borrowingFactorPerSecondForShorts_DESC_NULLS_LAST = "borrowingFactorPerSecondForShorts_DESC_NULLS_LAST",
+  borrowingFactorShort_ASC = "borrowingFactorShort_ASC",
+  borrowingFactorShort_ASC_NULLS_FIRST = "borrowingFactorShort_ASC_NULLS_FIRST",
+  borrowingFactorShort_ASC_NULLS_LAST = "borrowingFactorShort_ASC_NULLS_LAST",
+  borrowingFactorShort_DESC = "borrowingFactorShort_DESC",
+  borrowingFactorShort_DESC_NULLS_FIRST = "borrowingFactorShort_DESC_NULLS_FIRST",
+  borrowingFactorShort_DESC_NULLS_LAST = "borrowingFactorShort_DESC_NULLS_LAST",
+  fundingDecreaseFactorPerSecond_ASC = "fundingDecreaseFactorPerSecond_ASC",
+  fundingDecreaseFactorPerSecond_ASC_NULLS_FIRST = "fundingDecreaseFactorPerSecond_ASC_NULLS_FIRST",
+  fundingDecreaseFactorPerSecond_ASC_NULLS_LAST = "fundingDecreaseFactorPerSecond_ASC_NULLS_LAST",
+  fundingDecreaseFactorPerSecond_DESC = "fundingDecreaseFactorPerSecond_DESC",
+  fundingDecreaseFactorPerSecond_DESC_NULLS_FIRST = "fundingDecreaseFactorPerSecond_DESC_NULLS_FIRST",
+  fundingDecreaseFactorPerSecond_DESC_NULLS_LAST = "fundingDecreaseFactorPerSecond_DESC_NULLS_LAST",
+  fundingExponentFactor_ASC = "fundingExponentFactor_ASC",
+  fundingExponentFactor_ASC_NULLS_FIRST = "fundingExponentFactor_ASC_NULLS_FIRST",
+  fundingExponentFactor_ASC_NULLS_LAST = "fundingExponentFactor_ASC_NULLS_LAST",
+  fundingExponentFactor_DESC = "fundingExponentFactor_DESC",
+  fundingExponentFactor_DESC_NULLS_FIRST = "fundingExponentFactor_DESC_NULLS_FIRST",
+  fundingExponentFactor_DESC_NULLS_LAST = "fundingExponentFactor_DESC_NULLS_LAST",
+  fundingFactorPerSecond_ASC = "fundingFactorPerSecond_ASC",
+  fundingFactorPerSecond_ASC_NULLS_FIRST = "fundingFactorPerSecond_ASC_NULLS_FIRST",
+  fundingFactorPerSecond_ASC_NULLS_LAST = "fundingFactorPerSecond_ASC_NULLS_LAST",
+  fundingFactorPerSecond_DESC = "fundingFactorPerSecond_DESC",
+  fundingFactorPerSecond_DESC_NULLS_FIRST = "fundingFactorPerSecond_DESC_NULLS_FIRST",
+  fundingFactorPerSecond_DESC_NULLS_LAST = "fundingFactorPerSecond_DESC_NULLS_LAST",
+  fundingFactor_ASC = "fundingFactor_ASC",
+  fundingFactor_ASC_NULLS_FIRST = "fundingFactor_ASC_NULLS_FIRST",
+  fundingFactor_ASC_NULLS_LAST = "fundingFactor_ASC_NULLS_LAST",
+  fundingFactor_DESC = "fundingFactor_DESC",
+  fundingFactor_DESC_NULLS_FIRST = "fundingFactor_DESC_NULLS_FIRST",
+  fundingFactor_DESC_NULLS_LAST = "fundingFactor_DESC_NULLS_LAST",
+  fundingIncreaseFactorPerSecond_ASC = "fundingIncreaseFactorPerSecond_ASC",
+  fundingIncreaseFactorPerSecond_ASC_NULLS_FIRST = "fundingIncreaseFactorPerSecond_ASC_NULLS_FIRST",
+  fundingIncreaseFactorPerSecond_ASC_NULLS_LAST = "fundingIncreaseFactorPerSecond_ASC_NULLS_LAST",
+  fundingIncreaseFactorPerSecond_DESC = "fundingIncreaseFactorPerSecond_DESC",
+  fundingIncreaseFactorPerSecond_DESC_NULLS_FIRST = "fundingIncreaseFactorPerSecond_DESC_NULLS_FIRST",
+  fundingIncreaseFactorPerSecond_DESC_NULLS_LAST = "fundingIncreaseFactorPerSecond_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  indexTokenAddress_ASC = "indexTokenAddress_ASC",
+  indexTokenAddress_ASC_NULLS_FIRST = "indexTokenAddress_ASC_NULLS_FIRST",
+  indexTokenAddress_ASC_NULLS_LAST = "indexTokenAddress_ASC_NULLS_LAST",
+  indexTokenAddress_DESC = "indexTokenAddress_DESC",
+  indexTokenAddress_DESC_NULLS_FIRST = "indexTokenAddress_DESC_NULLS_FIRST",
+  indexTokenAddress_DESC_NULLS_LAST = "indexTokenAddress_DESC_NULLS_LAST",
+  isDisabled_ASC = "isDisabled_ASC",
+  isDisabled_ASC_NULLS_FIRST = "isDisabled_ASC_NULLS_FIRST",
+  isDisabled_ASC_NULLS_LAST = "isDisabled_ASC_NULLS_LAST",
+  isDisabled_DESC = "isDisabled_DESC",
+  isDisabled_DESC_NULLS_FIRST = "isDisabled_DESC_NULLS_FIRST",
+  isDisabled_DESC_NULLS_LAST = "isDisabled_DESC_NULLS_LAST",
+  lentPositionImpactPoolAmount_ASC = "lentPositionImpactPoolAmount_ASC",
+  lentPositionImpactPoolAmount_ASC_NULLS_FIRST = "lentPositionImpactPoolAmount_ASC_NULLS_FIRST",
+  lentPositionImpactPoolAmount_ASC_NULLS_LAST = "lentPositionImpactPoolAmount_ASC_NULLS_LAST",
+  lentPositionImpactPoolAmount_DESC = "lentPositionImpactPoolAmount_DESC",
+  lentPositionImpactPoolAmount_DESC_NULLS_FIRST = "lentPositionImpactPoolAmount_DESC_NULLS_FIRST",
+  lentPositionImpactPoolAmount_DESC_NULLS_LAST = "lentPositionImpactPoolAmount_DESC_NULLS_LAST",
+  longOpenInterestInTokensUsingLongToken_ASC = "longOpenInterestInTokensUsingLongToken_ASC",
+  longOpenInterestInTokensUsingLongToken_ASC_NULLS_FIRST = "longOpenInterestInTokensUsingLongToken_ASC_NULLS_FIRST",
+  longOpenInterestInTokensUsingLongToken_ASC_NULLS_LAST = "longOpenInterestInTokensUsingLongToken_ASC_NULLS_LAST",
+  longOpenInterestInTokensUsingLongToken_DESC = "longOpenInterestInTokensUsingLongToken_DESC",
+  longOpenInterestInTokensUsingLongToken_DESC_NULLS_FIRST = "longOpenInterestInTokensUsingLongToken_DESC_NULLS_FIRST",
+  longOpenInterestInTokensUsingLongToken_DESC_NULLS_LAST = "longOpenInterestInTokensUsingLongToken_DESC_NULLS_LAST",
+  longOpenInterestInTokensUsingShortToken_ASC = "longOpenInterestInTokensUsingShortToken_ASC",
+  longOpenInterestInTokensUsingShortToken_ASC_NULLS_FIRST = "longOpenInterestInTokensUsingShortToken_ASC_NULLS_FIRST",
+  longOpenInterestInTokensUsingShortToken_ASC_NULLS_LAST = "longOpenInterestInTokensUsingShortToken_ASC_NULLS_LAST",
+  longOpenInterestInTokensUsingShortToken_DESC = "longOpenInterestInTokensUsingShortToken_DESC",
+  longOpenInterestInTokensUsingShortToken_DESC_NULLS_FIRST = "longOpenInterestInTokensUsingShortToken_DESC_NULLS_FIRST",
+  longOpenInterestInTokensUsingShortToken_DESC_NULLS_LAST = "longOpenInterestInTokensUsingShortToken_DESC_NULLS_LAST",
+  longOpenInterestInTokens_ASC = "longOpenInterestInTokens_ASC",
+  longOpenInterestInTokens_ASC_NULLS_FIRST = "longOpenInterestInTokens_ASC_NULLS_FIRST",
+  longOpenInterestInTokens_ASC_NULLS_LAST = "longOpenInterestInTokens_ASC_NULLS_LAST",
+  longOpenInterestInTokens_DESC = "longOpenInterestInTokens_DESC",
+  longOpenInterestInTokens_DESC_NULLS_FIRST = "longOpenInterestInTokens_DESC_NULLS_FIRST",
+  longOpenInterestInTokens_DESC_NULLS_LAST = "longOpenInterestInTokens_DESC_NULLS_LAST",
+  longOpenInterestUsd_ASC = "longOpenInterestUsd_ASC",
+  longOpenInterestUsd_ASC_NULLS_FIRST = "longOpenInterestUsd_ASC_NULLS_FIRST",
+  longOpenInterestUsd_ASC_NULLS_LAST = "longOpenInterestUsd_ASC_NULLS_LAST",
+  longOpenInterestUsd_DESC = "longOpenInterestUsd_DESC",
+  longOpenInterestUsd_DESC_NULLS_FIRST = "longOpenInterestUsd_DESC_NULLS_FIRST",
+  longOpenInterestUsd_DESC_NULLS_LAST = "longOpenInterestUsd_DESC_NULLS_LAST",
+  longOpenInterestUsingLongToken_ASC = "longOpenInterestUsingLongToken_ASC",
+  longOpenInterestUsingLongToken_ASC_NULLS_FIRST = "longOpenInterestUsingLongToken_ASC_NULLS_FIRST",
+  longOpenInterestUsingLongToken_ASC_NULLS_LAST = "longOpenInterestUsingLongToken_ASC_NULLS_LAST",
+  longOpenInterestUsingLongToken_DESC = "longOpenInterestUsingLongToken_DESC",
+  longOpenInterestUsingLongToken_DESC_NULLS_FIRST = "longOpenInterestUsingLongToken_DESC_NULLS_FIRST",
+  longOpenInterestUsingLongToken_DESC_NULLS_LAST = "longOpenInterestUsingLongToken_DESC_NULLS_LAST",
+  longOpenInterestUsingShortToken_ASC = "longOpenInterestUsingShortToken_ASC",
+  longOpenInterestUsingShortToken_ASC_NULLS_FIRST = "longOpenInterestUsingShortToken_ASC_NULLS_FIRST",
+  longOpenInterestUsingShortToken_ASC_NULLS_LAST = "longOpenInterestUsingShortToken_ASC_NULLS_LAST",
+  longOpenInterestUsingShortToken_DESC = "longOpenInterestUsingShortToken_DESC",
+  longOpenInterestUsingShortToken_DESC_NULLS_FIRST = "longOpenInterestUsingShortToken_DESC_NULLS_FIRST",
+  longOpenInterestUsingShortToken_DESC_NULLS_LAST = "longOpenInterestUsingShortToken_DESC_NULLS_LAST",
+  longPoolAmountAdjustment_ASC = "longPoolAmountAdjustment_ASC",
+  longPoolAmountAdjustment_ASC_NULLS_FIRST = "longPoolAmountAdjustment_ASC_NULLS_FIRST",
+  longPoolAmountAdjustment_ASC_NULLS_LAST = "longPoolAmountAdjustment_ASC_NULLS_LAST",
+  longPoolAmountAdjustment_DESC = "longPoolAmountAdjustment_DESC",
+  longPoolAmountAdjustment_DESC_NULLS_FIRST = "longPoolAmountAdjustment_DESC_NULLS_FIRST",
+  longPoolAmountAdjustment_DESC_NULLS_LAST = "longPoolAmountAdjustment_DESC_NULLS_LAST",
+  longPoolAmount_ASC = "longPoolAmount_ASC",
+  longPoolAmount_ASC_NULLS_FIRST = "longPoolAmount_ASC_NULLS_FIRST",
+  longPoolAmount_ASC_NULLS_LAST = "longPoolAmount_ASC_NULLS_LAST",
+  longPoolAmount_DESC = "longPoolAmount_DESC",
+  longPoolAmount_DESC_NULLS_FIRST = "longPoolAmount_DESC_NULLS_FIRST",
+  longPoolAmount_DESC_NULLS_LAST = "longPoolAmount_DESC_NULLS_LAST",
+  longTokenAddress_ASC = "longTokenAddress_ASC",
+  longTokenAddress_ASC_NULLS_FIRST = "longTokenAddress_ASC_NULLS_FIRST",
+  longTokenAddress_ASC_NULLS_LAST = "longTokenAddress_ASC_NULLS_LAST",
+  longTokenAddress_DESC = "longTokenAddress_DESC",
+  longTokenAddress_DESC_NULLS_FIRST = "longTokenAddress_DESC_NULLS_FIRST",
+  longTokenAddress_DESC_NULLS_LAST = "longTokenAddress_DESC_NULLS_LAST",
+  longsPayShorts_ASC = "longsPayShorts_ASC",
+  longsPayShorts_ASC_NULLS_FIRST = "longsPayShorts_ASC_NULLS_FIRST",
+  longsPayShorts_ASC_NULLS_LAST = "longsPayShorts_ASC_NULLS_LAST",
+  longsPayShorts_DESC = "longsPayShorts_DESC",
+  longsPayShorts_DESC_NULLS_FIRST = "longsPayShorts_DESC_NULLS_FIRST",
+  longsPayShorts_DESC_NULLS_LAST = "longsPayShorts_DESC_NULLS_LAST",
+  marketTokenAddress_ASC = "marketTokenAddress_ASC",
+  marketTokenAddress_ASC_NULLS_FIRST = "marketTokenAddress_ASC_NULLS_FIRST",
+  marketTokenAddress_ASC_NULLS_LAST = "marketTokenAddress_ASC_NULLS_LAST",
+  marketTokenAddress_DESC = "marketTokenAddress_DESC",
+  marketTokenAddress_DESC_NULLS_FIRST = "marketTokenAddress_DESC_NULLS_FIRST",
+  marketTokenAddress_DESC_NULLS_LAST = "marketTokenAddress_DESC_NULLS_LAST",
+  marketTokenSupply_ASC = "marketTokenSupply_ASC",
+  marketTokenSupply_ASC_NULLS_FIRST = "marketTokenSupply_ASC_NULLS_FIRST",
+  marketTokenSupply_ASC_NULLS_LAST = "marketTokenSupply_ASC_NULLS_LAST",
+  marketTokenSupply_DESC = "marketTokenSupply_DESC",
+  marketTokenSupply_DESC_NULLS_FIRST = "marketTokenSupply_DESC_NULLS_FIRST",
+  marketTokenSupply_DESC_NULLS_LAST = "marketTokenSupply_DESC_NULLS_LAST",
+  maxFundingFactorPerSecond_ASC = "maxFundingFactorPerSecond_ASC",
+  maxFundingFactorPerSecond_ASC_NULLS_FIRST = "maxFundingFactorPerSecond_ASC_NULLS_FIRST",
+  maxFundingFactorPerSecond_ASC_NULLS_LAST = "maxFundingFactorPerSecond_ASC_NULLS_LAST",
+  maxFundingFactorPerSecond_DESC = "maxFundingFactorPerSecond_DESC",
+  maxFundingFactorPerSecond_DESC_NULLS_FIRST = "maxFundingFactorPerSecond_DESC_NULLS_FIRST",
+  maxFundingFactorPerSecond_DESC_NULLS_LAST = "maxFundingFactorPerSecond_DESC_NULLS_LAST",
+  maxLendableImpactFactorForWithdrawals_ASC = "maxLendableImpactFactorForWithdrawals_ASC",
+  maxLendableImpactFactorForWithdrawals_ASC_NULLS_FIRST = "maxLendableImpactFactorForWithdrawals_ASC_NULLS_FIRST",
+  maxLendableImpactFactorForWithdrawals_ASC_NULLS_LAST = "maxLendableImpactFactorForWithdrawals_ASC_NULLS_LAST",
+  maxLendableImpactFactorForWithdrawals_DESC = "maxLendableImpactFactorForWithdrawals_DESC",
+  maxLendableImpactFactorForWithdrawals_DESC_NULLS_FIRST = "maxLendableImpactFactorForWithdrawals_DESC_NULLS_FIRST",
+  maxLendableImpactFactorForWithdrawals_DESC_NULLS_LAST = "maxLendableImpactFactorForWithdrawals_DESC_NULLS_LAST",
+  maxLendableImpactFactor_ASC = "maxLendableImpactFactor_ASC",
+  maxLendableImpactFactor_ASC_NULLS_FIRST = "maxLendableImpactFactor_ASC_NULLS_FIRST",
+  maxLendableImpactFactor_ASC_NULLS_LAST = "maxLendableImpactFactor_ASC_NULLS_LAST",
+  maxLendableImpactFactor_DESC = "maxLendableImpactFactor_DESC",
+  maxLendableImpactFactor_DESC_NULLS_FIRST = "maxLendableImpactFactor_DESC_NULLS_FIRST",
+  maxLendableImpactFactor_DESC_NULLS_LAST = "maxLendableImpactFactor_DESC_NULLS_LAST",
+  maxLendableImpactUsd_ASC = "maxLendableImpactUsd_ASC",
+  maxLendableImpactUsd_ASC_NULLS_FIRST = "maxLendableImpactUsd_ASC_NULLS_FIRST",
+  maxLendableImpactUsd_ASC_NULLS_LAST = "maxLendableImpactUsd_ASC_NULLS_LAST",
+  maxLendableImpactUsd_DESC = "maxLendableImpactUsd_DESC",
+  maxLendableImpactUsd_DESC_NULLS_FIRST = "maxLendableImpactUsd_DESC_NULLS_FIRST",
+  maxLendableImpactUsd_DESC_NULLS_LAST = "maxLendableImpactUsd_DESC_NULLS_LAST",
+  maxLongPoolAmount_ASC = "maxLongPoolAmount_ASC",
+  maxLongPoolAmount_ASC_NULLS_FIRST = "maxLongPoolAmount_ASC_NULLS_FIRST",
+  maxLongPoolAmount_ASC_NULLS_LAST = "maxLongPoolAmount_ASC_NULLS_LAST",
+  maxLongPoolAmount_DESC = "maxLongPoolAmount_DESC",
+  maxLongPoolAmount_DESC_NULLS_FIRST = "maxLongPoolAmount_DESC_NULLS_FIRST",
+  maxLongPoolAmount_DESC_NULLS_LAST = "maxLongPoolAmount_DESC_NULLS_LAST",
+  maxLongPoolUsdForDeposit_ASC = "maxLongPoolUsdForDeposit_ASC",
+  maxLongPoolUsdForDeposit_ASC_NULLS_FIRST = "maxLongPoolUsdForDeposit_ASC_NULLS_FIRST",
+  maxLongPoolUsdForDeposit_ASC_NULLS_LAST = "maxLongPoolUsdForDeposit_ASC_NULLS_LAST",
+  maxLongPoolUsdForDeposit_DESC = "maxLongPoolUsdForDeposit_DESC",
+  maxLongPoolUsdForDeposit_DESC_NULLS_FIRST = "maxLongPoolUsdForDeposit_DESC_NULLS_FIRST",
+  maxLongPoolUsdForDeposit_DESC_NULLS_LAST = "maxLongPoolUsdForDeposit_DESC_NULLS_LAST",
+  maxOpenInterestLong_ASC = "maxOpenInterestLong_ASC",
+  maxOpenInterestLong_ASC_NULLS_FIRST = "maxOpenInterestLong_ASC_NULLS_FIRST",
+  maxOpenInterestLong_ASC_NULLS_LAST = "maxOpenInterestLong_ASC_NULLS_LAST",
+  maxOpenInterestLong_DESC = "maxOpenInterestLong_DESC",
+  maxOpenInterestLong_DESC_NULLS_FIRST = "maxOpenInterestLong_DESC_NULLS_FIRST",
+  maxOpenInterestLong_DESC_NULLS_LAST = "maxOpenInterestLong_DESC_NULLS_LAST",
+  maxOpenInterestShort_ASC = "maxOpenInterestShort_ASC",
+  maxOpenInterestShort_ASC_NULLS_FIRST = "maxOpenInterestShort_ASC_NULLS_FIRST",
+  maxOpenInterestShort_ASC_NULLS_LAST = "maxOpenInterestShort_ASC_NULLS_LAST",
+  maxOpenInterestShort_DESC = "maxOpenInterestShort_DESC",
+  maxOpenInterestShort_DESC_NULLS_FIRST = "maxOpenInterestShort_DESC_NULLS_FIRST",
+  maxOpenInterestShort_DESC_NULLS_LAST = "maxOpenInterestShort_DESC_NULLS_LAST",
+  maxPnlFactorForTradersLong_ASC = "maxPnlFactorForTradersLong_ASC",
+  maxPnlFactorForTradersLong_ASC_NULLS_FIRST = "maxPnlFactorForTradersLong_ASC_NULLS_FIRST",
+  maxPnlFactorForTradersLong_ASC_NULLS_LAST = "maxPnlFactorForTradersLong_ASC_NULLS_LAST",
+  maxPnlFactorForTradersLong_DESC = "maxPnlFactorForTradersLong_DESC",
+  maxPnlFactorForTradersLong_DESC_NULLS_FIRST = "maxPnlFactorForTradersLong_DESC_NULLS_FIRST",
+  maxPnlFactorForTradersLong_DESC_NULLS_LAST = "maxPnlFactorForTradersLong_DESC_NULLS_LAST",
+  maxPnlFactorForTradersShort_ASC = "maxPnlFactorForTradersShort_ASC",
+  maxPnlFactorForTradersShort_ASC_NULLS_FIRST = "maxPnlFactorForTradersShort_ASC_NULLS_FIRST",
+  maxPnlFactorForTradersShort_ASC_NULLS_LAST = "maxPnlFactorForTradersShort_ASC_NULLS_LAST",
+  maxPnlFactorForTradersShort_DESC = "maxPnlFactorForTradersShort_DESC",
+  maxPnlFactorForTradersShort_DESC_NULLS_FIRST = "maxPnlFactorForTradersShort_DESC_NULLS_FIRST",
+  maxPnlFactorForTradersShort_DESC_NULLS_LAST = "maxPnlFactorForTradersShort_DESC_NULLS_LAST",
+  maxPositionImpactFactorForLiquidations_ASC = "maxPositionImpactFactorForLiquidations_ASC",
+  maxPositionImpactFactorForLiquidations_ASC_NULLS_FIRST = "maxPositionImpactFactorForLiquidations_ASC_NULLS_FIRST",
+  maxPositionImpactFactorForLiquidations_ASC_NULLS_LAST = "maxPositionImpactFactorForLiquidations_ASC_NULLS_LAST",
+  maxPositionImpactFactorForLiquidations_DESC = "maxPositionImpactFactorForLiquidations_DESC",
+  maxPositionImpactFactorForLiquidations_DESC_NULLS_FIRST = "maxPositionImpactFactorForLiquidations_DESC_NULLS_FIRST",
+  maxPositionImpactFactorForLiquidations_DESC_NULLS_LAST = "maxPositionImpactFactorForLiquidations_DESC_NULLS_LAST",
+  maxPositionImpactFactorNegative_ASC = "maxPositionImpactFactorNegative_ASC",
+  maxPositionImpactFactorNegative_ASC_NULLS_FIRST = "maxPositionImpactFactorNegative_ASC_NULLS_FIRST",
+  maxPositionImpactFactorNegative_ASC_NULLS_LAST = "maxPositionImpactFactorNegative_ASC_NULLS_LAST",
+  maxPositionImpactFactorNegative_DESC = "maxPositionImpactFactorNegative_DESC",
+  maxPositionImpactFactorNegative_DESC_NULLS_FIRST = "maxPositionImpactFactorNegative_DESC_NULLS_FIRST",
+  maxPositionImpactFactorNegative_DESC_NULLS_LAST = "maxPositionImpactFactorNegative_DESC_NULLS_LAST",
+  maxPositionImpactFactorPositive_ASC = "maxPositionImpactFactorPositive_ASC",
+  maxPositionImpactFactorPositive_ASC_NULLS_FIRST = "maxPositionImpactFactorPositive_ASC_NULLS_FIRST",
+  maxPositionImpactFactorPositive_ASC_NULLS_LAST = "maxPositionImpactFactorPositive_ASC_NULLS_LAST",
+  maxPositionImpactFactorPositive_DESC = "maxPositionImpactFactorPositive_DESC",
+  maxPositionImpactFactorPositive_DESC_NULLS_FIRST = "maxPositionImpactFactorPositive_DESC_NULLS_FIRST",
+  maxPositionImpactFactorPositive_DESC_NULLS_LAST = "maxPositionImpactFactorPositive_DESC_NULLS_LAST",
+  maxShortPoolAmount_ASC = "maxShortPoolAmount_ASC",
+  maxShortPoolAmount_ASC_NULLS_FIRST = "maxShortPoolAmount_ASC_NULLS_FIRST",
+  maxShortPoolAmount_ASC_NULLS_LAST = "maxShortPoolAmount_ASC_NULLS_LAST",
+  maxShortPoolAmount_DESC = "maxShortPoolAmount_DESC",
+  maxShortPoolAmount_DESC_NULLS_FIRST = "maxShortPoolAmount_DESC_NULLS_FIRST",
+  maxShortPoolAmount_DESC_NULLS_LAST = "maxShortPoolAmount_DESC_NULLS_LAST",
+  maxShortPoolUsdForDeposit_ASC = "maxShortPoolUsdForDeposit_ASC",
+  maxShortPoolUsdForDeposit_ASC_NULLS_FIRST = "maxShortPoolUsdForDeposit_ASC_NULLS_FIRST",
+  maxShortPoolUsdForDeposit_ASC_NULLS_LAST = "maxShortPoolUsdForDeposit_ASC_NULLS_LAST",
+  maxShortPoolUsdForDeposit_DESC = "maxShortPoolUsdForDeposit_DESC",
+  maxShortPoolUsdForDeposit_DESC_NULLS_FIRST = "maxShortPoolUsdForDeposit_DESC_NULLS_FIRST",
+  maxShortPoolUsdForDeposit_DESC_NULLS_LAST = "maxShortPoolUsdForDeposit_DESC_NULLS_LAST",
+  minCollateralFactorForOpenInterestLong_ASC = "minCollateralFactorForOpenInterestLong_ASC",
+  minCollateralFactorForOpenInterestLong_ASC_NULLS_FIRST = "minCollateralFactorForOpenInterestLong_ASC_NULLS_FIRST",
+  minCollateralFactorForOpenInterestLong_ASC_NULLS_LAST = "minCollateralFactorForOpenInterestLong_ASC_NULLS_LAST",
+  minCollateralFactorForOpenInterestLong_DESC = "minCollateralFactorForOpenInterestLong_DESC",
+  minCollateralFactorForOpenInterestLong_DESC_NULLS_FIRST = "minCollateralFactorForOpenInterestLong_DESC_NULLS_FIRST",
+  minCollateralFactorForOpenInterestLong_DESC_NULLS_LAST = "minCollateralFactorForOpenInterestLong_DESC_NULLS_LAST",
+  minCollateralFactorForOpenInterestShort_ASC = "minCollateralFactorForOpenInterestShort_ASC",
+  minCollateralFactorForOpenInterestShort_ASC_NULLS_FIRST = "minCollateralFactorForOpenInterestShort_ASC_NULLS_FIRST",
+  minCollateralFactorForOpenInterestShort_ASC_NULLS_LAST = "minCollateralFactorForOpenInterestShort_ASC_NULLS_LAST",
+  minCollateralFactorForOpenInterestShort_DESC = "minCollateralFactorForOpenInterestShort_DESC",
+  minCollateralFactorForOpenInterestShort_DESC_NULLS_FIRST = "minCollateralFactorForOpenInterestShort_DESC_NULLS_FIRST",
+  minCollateralFactorForOpenInterestShort_DESC_NULLS_LAST = "minCollateralFactorForOpenInterestShort_DESC_NULLS_LAST",
+  minCollateralFactor_ASC = "minCollateralFactor_ASC",
+  minCollateralFactor_ASC_NULLS_FIRST = "minCollateralFactor_ASC_NULLS_FIRST",
+  minCollateralFactor_ASC_NULLS_LAST = "minCollateralFactor_ASC_NULLS_LAST",
+  minCollateralFactor_DESC = "minCollateralFactor_DESC",
+  minCollateralFactor_DESC_NULLS_FIRST = "minCollateralFactor_DESC_NULLS_FIRST",
+  minCollateralFactor_DESC_NULLS_LAST = "minCollateralFactor_DESC_NULLS_LAST",
+  minFundingFactorPerSecond_ASC = "minFundingFactorPerSecond_ASC",
+  minFundingFactorPerSecond_ASC_NULLS_FIRST = "minFundingFactorPerSecond_ASC_NULLS_FIRST",
+  minFundingFactorPerSecond_ASC_NULLS_LAST = "minFundingFactorPerSecond_ASC_NULLS_LAST",
+  minFundingFactorPerSecond_DESC = "minFundingFactorPerSecond_DESC",
+  minFundingFactorPerSecond_DESC_NULLS_FIRST = "minFundingFactorPerSecond_DESC_NULLS_FIRST",
+  minFundingFactorPerSecond_DESC_NULLS_LAST = "minFundingFactorPerSecond_DESC_NULLS_LAST",
+  minPositionImpactPoolAmount_ASC = "minPositionImpactPoolAmount_ASC",
+  minPositionImpactPoolAmount_ASC_NULLS_FIRST = "minPositionImpactPoolAmount_ASC_NULLS_FIRST",
+  minPositionImpactPoolAmount_ASC_NULLS_LAST = "minPositionImpactPoolAmount_ASC_NULLS_LAST",
+  minPositionImpactPoolAmount_DESC = "minPositionImpactPoolAmount_DESC",
+  minPositionImpactPoolAmount_DESC_NULLS_FIRST = "minPositionImpactPoolAmount_DESC_NULLS_FIRST",
+  minPositionImpactPoolAmount_DESC_NULLS_LAST = "minPositionImpactPoolAmount_DESC_NULLS_LAST",
+  openInterestReserveFactorLong_ASC = "openInterestReserveFactorLong_ASC",
+  openInterestReserveFactorLong_ASC_NULLS_FIRST = "openInterestReserveFactorLong_ASC_NULLS_FIRST",
+  openInterestReserveFactorLong_ASC_NULLS_LAST = "openInterestReserveFactorLong_ASC_NULLS_LAST",
+  openInterestReserveFactorLong_DESC = "openInterestReserveFactorLong_DESC",
+  openInterestReserveFactorLong_DESC_NULLS_FIRST = "openInterestReserveFactorLong_DESC_NULLS_FIRST",
+  openInterestReserveFactorLong_DESC_NULLS_LAST = "openInterestReserveFactorLong_DESC_NULLS_LAST",
+  openInterestReserveFactorShort_ASC = "openInterestReserveFactorShort_ASC",
+  openInterestReserveFactorShort_ASC_NULLS_FIRST = "openInterestReserveFactorShort_ASC_NULLS_FIRST",
+  openInterestReserveFactorShort_ASC_NULLS_LAST = "openInterestReserveFactorShort_ASC_NULLS_LAST",
+  openInterestReserveFactorShort_DESC = "openInterestReserveFactorShort_DESC",
+  openInterestReserveFactorShort_DESC_NULLS_FIRST = "openInterestReserveFactorShort_DESC_NULLS_FIRST",
+  openInterestReserveFactorShort_DESC_NULLS_LAST = "openInterestReserveFactorShort_DESC_NULLS_LAST",
+  optimalUsageFactorLong_ASC = "optimalUsageFactorLong_ASC",
+  optimalUsageFactorLong_ASC_NULLS_FIRST = "optimalUsageFactorLong_ASC_NULLS_FIRST",
+  optimalUsageFactorLong_ASC_NULLS_LAST = "optimalUsageFactorLong_ASC_NULLS_LAST",
+  optimalUsageFactorLong_DESC = "optimalUsageFactorLong_DESC",
+  optimalUsageFactorLong_DESC_NULLS_FIRST = "optimalUsageFactorLong_DESC_NULLS_FIRST",
+  optimalUsageFactorLong_DESC_NULLS_LAST = "optimalUsageFactorLong_DESC_NULLS_LAST",
+  optimalUsageFactorShort_ASC = "optimalUsageFactorShort_ASC",
+  optimalUsageFactorShort_ASC_NULLS_FIRST = "optimalUsageFactorShort_ASC_NULLS_FIRST",
+  optimalUsageFactorShort_ASC_NULLS_LAST = "optimalUsageFactorShort_ASC_NULLS_LAST",
+  optimalUsageFactorShort_DESC = "optimalUsageFactorShort_DESC",
+  optimalUsageFactorShort_DESC_NULLS_FIRST = "optimalUsageFactorShort_DESC_NULLS_FIRST",
+  optimalUsageFactorShort_DESC_NULLS_LAST = "optimalUsageFactorShort_DESC_NULLS_LAST",
+  poolValueMax_ASC = "poolValueMax_ASC",
+  poolValueMax_ASC_NULLS_FIRST = "poolValueMax_ASC_NULLS_FIRST",
+  poolValueMax_ASC_NULLS_LAST = "poolValueMax_ASC_NULLS_LAST",
+  poolValueMax_DESC = "poolValueMax_DESC",
+  poolValueMax_DESC_NULLS_FIRST = "poolValueMax_DESC_NULLS_FIRST",
+  poolValueMax_DESC_NULLS_LAST = "poolValueMax_DESC_NULLS_LAST",
+  poolValueMin_ASC = "poolValueMin_ASC",
+  poolValueMin_ASC_NULLS_FIRST = "poolValueMin_ASC_NULLS_FIRST",
+  poolValueMin_ASC_NULLS_LAST = "poolValueMin_ASC_NULLS_LAST",
+  poolValueMin_DESC = "poolValueMin_DESC",
+  poolValueMin_DESC_NULLS_FIRST = "poolValueMin_DESC_NULLS_FIRST",
+  poolValueMin_DESC_NULLS_LAST = "poolValueMin_DESC_NULLS_LAST",
+  poolValue_ASC = "poolValue_ASC",
+  poolValue_ASC_NULLS_FIRST = "poolValue_ASC_NULLS_FIRST",
+  poolValue_ASC_NULLS_LAST = "poolValue_ASC_NULLS_LAST",
+  poolValue_DESC = "poolValue_DESC",
+  poolValue_DESC_NULLS_FIRST = "poolValue_DESC_NULLS_FIRST",
+  poolValue_DESC_NULLS_LAST = "poolValue_DESC_NULLS_LAST",
+  positionFeeFactorForNegativeImpact_ASC = "positionFeeFactorForNegativeImpact_ASC",
+  positionFeeFactorForNegativeImpact_ASC_NULLS_FIRST = "positionFeeFactorForNegativeImpact_ASC_NULLS_FIRST",
+  positionFeeFactorForNegativeImpact_ASC_NULLS_LAST = "positionFeeFactorForNegativeImpact_ASC_NULLS_LAST",
+  positionFeeFactorForNegativeImpact_DESC = "positionFeeFactorForNegativeImpact_DESC",
+  positionFeeFactorForNegativeImpact_DESC_NULLS_FIRST = "positionFeeFactorForNegativeImpact_DESC_NULLS_FIRST",
+  positionFeeFactorForNegativeImpact_DESC_NULLS_LAST = "positionFeeFactorForNegativeImpact_DESC_NULLS_LAST",
+  positionFeeFactorForPositiveImpact_ASC = "positionFeeFactorForPositiveImpact_ASC",
+  positionFeeFactorForPositiveImpact_ASC_NULLS_FIRST = "positionFeeFactorForPositiveImpact_ASC_NULLS_FIRST",
+  positionFeeFactorForPositiveImpact_ASC_NULLS_LAST = "positionFeeFactorForPositiveImpact_ASC_NULLS_LAST",
+  positionFeeFactorForPositiveImpact_DESC = "positionFeeFactorForPositiveImpact_DESC",
+  positionFeeFactorForPositiveImpact_DESC_NULLS_FIRST = "positionFeeFactorForPositiveImpact_DESC_NULLS_FIRST",
+  positionFeeFactorForPositiveImpact_DESC_NULLS_LAST = "positionFeeFactorForPositiveImpact_DESC_NULLS_LAST",
+  positionImpactExponentFactor_ASC = "positionImpactExponentFactor_ASC",
+  positionImpactExponentFactor_ASC_NULLS_FIRST = "positionImpactExponentFactor_ASC_NULLS_FIRST",
+  positionImpactExponentFactor_ASC_NULLS_LAST = "positionImpactExponentFactor_ASC_NULLS_LAST",
+  positionImpactExponentFactor_DESC = "positionImpactExponentFactor_DESC",
+  positionImpactExponentFactor_DESC_NULLS_FIRST = "positionImpactExponentFactor_DESC_NULLS_FIRST",
+  positionImpactExponentFactor_DESC_NULLS_LAST = "positionImpactExponentFactor_DESC_NULLS_LAST",
+  positionImpactFactorNegative_ASC = "positionImpactFactorNegative_ASC",
+  positionImpactFactorNegative_ASC_NULLS_FIRST = "positionImpactFactorNegative_ASC_NULLS_FIRST",
+  positionImpactFactorNegative_ASC_NULLS_LAST = "positionImpactFactorNegative_ASC_NULLS_LAST",
+  positionImpactFactorNegative_DESC = "positionImpactFactorNegative_DESC",
+  positionImpactFactorNegative_DESC_NULLS_FIRST = "positionImpactFactorNegative_DESC_NULLS_FIRST",
+  positionImpactFactorNegative_DESC_NULLS_LAST = "positionImpactFactorNegative_DESC_NULLS_LAST",
+  positionImpactFactorPositive_ASC = "positionImpactFactorPositive_ASC",
+  positionImpactFactorPositive_ASC_NULLS_FIRST = "positionImpactFactorPositive_ASC_NULLS_FIRST",
+  positionImpactFactorPositive_ASC_NULLS_LAST = "positionImpactFactorPositive_ASC_NULLS_LAST",
+  positionImpactFactorPositive_DESC = "positionImpactFactorPositive_DESC",
+  positionImpactFactorPositive_DESC_NULLS_FIRST = "positionImpactFactorPositive_DESC_NULLS_FIRST",
+  positionImpactFactorPositive_DESC_NULLS_LAST = "positionImpactFactorPositive_DESC_NULLS_LAST",
+  positionImpactPoolAmount_ASC = "positionImpactPoolAmount_ASC",
+  positionImpactPoolAmount_ASC_NULLS_FIRST = "positionImpactPoolAmount_ASC_NULLS_FIRST",
+  positionImpactPoolAmount_ASC_NULLS_LAST = "positionImpactPoolAmount_ASC_NULLS_LAST",
+  positionImpactPoolAmount_DESC = "positionImpactPoolAmount_DESC",
+  positionImpactPoolAmount_DESC_NULLS_FIRST = "positionImpactPoolAmount_DESC_NULLS_FIRST",
+  positionImpactPoolAmount_DESC_NULLS_LAST = "positionImpactPoolAmount_DESC_NULLS_LAST",
+  positionImpactPoolDistributionRate_ASC = "positionImpactPoolDistributionRate_ASC",
+  positionImpactPoolDistributionRate_ASC_NULLS_FIRST = "positionImpactPoolDistributionRate_ASC_NULLS_FIRST",
+  positionImpactPoolDistributionRate_ASC_NULLS_LAST = "positionImpactPoolDistributionRate_ASC_NULLS_LAST",
+  positionImpactPoolDistributionRate_DESC = "positionImpactPoolDistributionRate_DESC",
+  positionImpactPoolDistributionRate_DESC_NULLS_FIRST = "positionImpactPoolDistributionRate_DESC_NULLS_FIRST",
+  positionImpactPoolDistributionRate_DESC_NULLS_LAST = "positionImpactPoolDistributionRate_DESC_NULLS_LAST",
+  reserveFactorLong_ASC = "reserveFactorLong_ASC",
+  reserveFactorLong_ASC_NULLS_FIRST = "reserveFactorLong_ASC_NULLS_FIRST",
+  reserveFactorLong_ASC_NULLS_LAST = "reserveFactorLong_ASC_NULLS_LAST",
+  reserveFactorLong_DESC = "reserveFactorLong_DESC",
+  reserveFactorLong_DESC_NULLS_FIRST = "reserveFactorLong_DESC_NULLS_FIRST",
+  reserveFactorLong_DESC_NULLS_LAST = "reserveFactorLong_DESC_NULLS_LAST",
+  reserveFactorShort_ASC = "reserveFactorShort_ASC",
+  reserveFactorShort_ASC_NULLS_FIRST = "reserveFactorShort_ASC_NULLS_FIRST",
+  reserveFactorShort_ASC_NULLS_LAST = "reserveFactorShort_ASC_NULLS_LAST",
+  reserveFactorShort_DESC = "reserveFactorShort_DESC",
+  reserveFactorShort_DESC_NULLS_FIRST = "reserveFactorShort_DESC_NULLS_FIRST",
+  reserveFactorShort_DESC_NULLS_LAST = "reserveFactorShort_DESC_NULLS_LAST",
+  shortOpenInterestInTokensUsingLongToken_ASC = "shortOpenInterestInTokensUsingLongToken_ASC",
+  shortOpenInterestInTokensUsingLongToken_ASC_NULLS_FIRST = "shortOpenInterestInTokensUsingLongToken_ASC_NULLS_FIRST",
+  shortOpenInterestInTokensUsingLongToken_ASC_NULLS_LAST = "shortOpenInterestInTokensUsingLongToken_ASC_NULLS_LAST",
+  shortOpenInterestInTokensUsingLongToken_DESC = "shortOpenInterestInTokensUsingLongToken_DESC",
+  shortOpenInterestInTokensUsingLongToken_DESC_NULLS_FIRST = "shortOpenInterestInTokensUsingLongToken_DESC_NULLS_FIRST",
+  shortOpenInterestInTokensUsingLongToken_DESC_NULLS_LAST = "shortOpenInterestInTokensUsingLongToken_DESC_NULLS_LAST",
+  shortOpenInterestInTokensUsingShortToken_ASC = "shortOpenInterestInTokensUsingShortToken_ASC",
+  shortOpenInterestInTokensUsingShortToken_ASC_NULLS_FIRST = "shortOpenInterestInTokensUsingShortToken_ASC_NULLS_FIRST",
+  shortOpenInterestInTokensUsingShortToken_ASC_NULLS_LAST = "shortOpenInterestInTokensUsingShortToken_ASC_NULLS_LAST",
+  shortOpenInterestInTokensUsingShortToken_DESC = "shortOpenInterestInTokensUsingShortToken_DESC",
+  shortOpenInterestInTokensUsingShortToken_DESC_NULLS_FIRST = "shortOpenInterestInTokensUsingShortToken_DESC_NULLS_FIRST",
+  shortOpenInterestInTokensUsingShortToken_DESC_NULLS_LAST = "shortOpenInterestInTokensUsingShortToken_DESC_NULLS_LAST",
+  shortOpenInterestInTokens_ASC = "shortOpenInterestInTokens_ASC",
+  shortOpenInterestInTokens_ASC_NULLS_FIRST = "shortOpenInterestInTokens_ASC_NULLS_FIRST",
+  shortOpenInterestInTokens_ASC_NULLS_LAST = "shortOpenInterestInTokens_ASC_NULLS_LAST",
+  shortOpenInterestInTokens_DESC = "shortOpenInterestInTokens_DESC",
+  shortOpenInterestInTokens_DESC_NULLS_FIRST = "shortOpenInterestInTokens_DESC_NULLS_FIRST",
+  shortOpenInterestInTokens_DESC_NULLS_LAST = "shortOpenInterestInTokens_DESC_NULLS_LAST",
+  shortOpenInterestUsd_ASC = "shortOpenInterestUsd_ASC",
+  shortOpenInterestUsd_ASC_NULLS_FIRST = "shortOpenInterestUsd_ASC_NULLS_FIRST",
+  shortOpenInterestUsd_ASC_NULLS_LAST = "shortOpenInterestUsd_ASC_NULLS_LAST",
+  shortOpenInterestUsd_DESC = "shortOpenInterestUsd_DESC",
+  shortOpenInterestUsd_DESC_NULLS_FIRST = "shortOpenInterestUsd_DESC_NULLS_FIRST",
+  shortOpenInterestUsd_DESC_NULLS_LAST = "shortOpenInterestUsd_DESC_NULLS_LAST",
+  shortOpenInterestUsingLongToken_ASC = "shortOpenInterestUsingLongToken_ASC",
+  shortOpenInterestUsingLongToken_ASC_NULLS_FIRST = "shortOpenInterestUsingLongToken_ASC_NULLS_FIRST",
+  shortOpenInterestUsingLongToken_ASC_NULLS_LAST = "shortOpenInterestUsingLongToken_ASC_NULLS_LAST",
+  shortOpenInterestUsingLongToken_DESC = "shortOpenInterestUsingLongToken_DESC",
+  shortOpenInterestUsingLongToken_DESC_NULLS_FIRST = "shortOpenInterestUsingLongToken_DESC_NULLS_FIRST",
+  shortOpenInterestUsingLongToken_DESC_NULLS_LAST = "shortOpenInterestUsingLongToken_DESC_NULLS_LAST",
+  shortOpenInterestUsingShortToken_ASC = "shortOpenInterestUsingShortToken_ASC",
+  shortOpenInterestUsingShortToken_ASC_NULLS_FIRST = "shortOpenInterestUsingShortToken_ASC_NULLS_FIRST",
+  shortOpenInterestUsingShortToken_ASC_NULLS_LAST = "shortOpenInterestUsingShortToken_ASC_NULLS_LAST",
+  shortOpenInterestUsingShortToken_DESC = "shortOpenInterestUsingShortToken_DESC",
+  shortOpenInterestUsingShortToken_DESC_NULLS_FIRST = "shortOpenInterestUsingShortToken_DESC_NULLS_FIRST",
+  shortOpenInterestUsingShortToken_DESC_NULLS_LAST = "shortOpenInterestUsingShortToken_DESC_NULLS_LAST",
+  shortPoolAmountAdjustment_ASC = "shortPoolAmountAdjustment_ASC",
+  shortPoolAmountAdjustment_ASC_NULLS_FIRST = "shortPoolAmountAdjustment_ASC_NULLS_FIRST",
+  shortPoolAmountAdjustment_ASC_NULLS_LAST = "shortPoolAmountAdjustment_ASC_NULLS_LAST",
+  shortPoolAmountAdjustment_DESC = "shortPoolAmountAdjustment_DESC",
+  shortPoolAmountAdjustment_DESC_NULLS_FIRST = "shortPoolAmountAdjustment_DESC_NULLS_FIRST",
+  shortPoolAmountAdjustment_DESC_NULLS_LAST = "shortPoolAmountAdjustment_DESC_NULLS_LAST",
+  shortPoolAmount_ASC = "shortPoolAmount_ASC",
+  shortPoolAmount_ASC_NULLS_FIRST = "shortPoolAmount_ASC_NULLS_FIRST",
+  shortPoolAmount_ASC_NULLS_LAST = "shortPoolAmount_ASC_NULLS_LAST",
+  shortPoolAmount_DESC = "shortPoolAmount_DESC",
+  shortPoolAmount_DESC_NULLS_FIRST = "shortPoolAmount_DESC_NULLS_FIRST",
+  shortPoolAmount_DESC_NULLS_LAST = "shortPoolAmount_DESC_NULLS_LAST",
+  shortTokenAddress_ASC = "shortTokenAddress_ASC",
+  shortTokenAddress_ASC_NULLS_FIRST = "shortTokenAddress_ASC_NULLS_FIRST",
+  shortTokenAddress_ASC_NULLS_LAST = "shortTokenAddress_ASC_NULLS_LAST",
+  shortTokenAddress_DESC = "shortTokenAddress_DESC",
+  shortTokenAddress_DESC_NULLS_FIRST = "shortTokenAddress_DESC_NULLS_FIRST",
+  shortTokenAddress_DESC_NULLS_LAST = "shortTokenAddress_DESC_NULLS_LAST",
+  swapFeeFactorForNegativeImpact_ASC = "swapFeeFactorForNegativeImpact_ASC",
+  swapFeeFactorForNegativeImpact_ASC_NULLS_FIRST = "swapFeeFactorForNegativeImpact_ASC_NULLS_FIRST",
+  swapFeeFactorForNegativeImpact_ASC_NULLS_LAST = "swapFeeFactorForNegativeImpact_ASC_NULLS_LAST",
+  swapFeeFactorForNegativeImpact_DESC = "swapFeeFactorForNegativeImpact_DESC",
+  swapFeeFactorForNegativeImpact_DESC_NULLS_FIRST = "swapFeeFactorForNegativeImpact_DESC_NULLS_FIRST",
+  swapFeeFactorForNegativeImpact_DESC_NULLS_LAST = "swapFeeFactorForNegativeImpact_DESC_NULLS_LAST",
+  swapFeeFactorForPositiveImpact_ASC = "swapFeeFactorForPositiveImpact_ASC",
+  swapFeeFactorForPositiveImpact_ASC_NULLS_FIRST = "swapFeeFactorForPositiveImpact_ASC_NULLS_FIRST",
+  swapFeeFactorForPositiveImpact_ASC_NULLS_LAST = "swapFeeFactorForPositiveImpact_ASC_NULLS_LAST",
+  swapFeeFactorForPositiveImpact_DESC = "swapFeeFactorForPositiveImpact_DESC",
+  swapFeeFactorForPositiveImpact_DESC_NULLS_FIRST = "swapFeeFactorForPositiveImpact_DESC_NULLS_FIRST",
+  swapFeeFactorForPositiveImpact_DESC_NULLS_LAST = "swapFeeFactorForPositiveImpact_DESC_NULLS_LAST",
+  swapImpactExponentFactor_ASC = "swapImpactExponentFactor_ASC",
+  swapImpactExponentFactor_ASC_NULLS_FIRST = "swapImpactExponentFactor_ASC_NULLS_FIRST",
+  swapImpactExponentFactor_ASC_NULLS_LAST = "swapImpactExponentFactor_ASC_NULLS_LAST",
+  swapImpactExponentFactor_DESC = "swapImpactExponentFactor_DESC",
+  swapImpactExponentFactor_DESC_NULLS_FIRST = "swapImpactExponentFactor_DESC_NULLS_FIRST",
+  swapImpactExponentFactor_DESC_NULLS_LAST = "swapImpactExponentFactor_DESC_NULLS_LAST",
+  swapImpactFactorNegative_ASC = "swapImpactFactorNegative_ASC",
+  swapImpactFactorNegative_ASC_NULLS_FIRST = "swapImpactFactorNegative_ASC_NULLS_FIRST",
+  swapImpactFactorNegative_ASC_NULLS_LAST = "swapImpactFactorNegative_ASC_NULLS_LAST",
+  swapImpactFactorNegative_DESC = "swapImpactFactorNegative_DESC",
+  swapImpactFactorNegative_DESC_NULLS_FIRST = "swapImpactFactorNegative_DESC_NULLS_FIRST",
+  swapImpactFactorNegative_DESC_NULLS_LAST = "swapImpactFactorNegative_DESC_NULLS_LAST",
+  swapImpactFactorPositive_ASC = "swapImpactFactorPositive_ASC",
+  swapImpactFactorPositive_ASC_NULLS_FIRST = "swapImpactFactorPositive_ASC_NULLS_FIRST",
+  swapImpactFactorPositive_ASC_NULLS_LAST = "swapImpactFactorPositive_ASC_NULLS_LAST",
+  swapImpactFactorPositive_DESC = "swapImpactFactorPositive_DESC",
+  swapImpactFactorPositive_DESC_NULLS_FIRST = "swapImpactFactorPositive_DESC_NULLS_FIRST",
+  swapImpactFactorPositive_DESC_NULLS_LAST = "swapImpactFactorPositive_DESC_NULLS_LAST",
+  swapImpactPoolAmountLong_ASC = "swapImpactPoolAmountLong_ASC",
+  swapImpactPoolAmountLong_ASC_NULLS_FIRST = "swapImpactPoolAmountLong_ASC_NULLS_FIRST",
+  swapImpactPoolAmountLong_ASC_NULLS_LAST = "swapImpactPoolAmountLong_ASC_NULLS_LAST",
+  swapImpactPoolAmountLong_DESC = "swapImpactPoolAmountLong_DESC",
+  swapImpactPoolAmountLong_DESC_NULLS_FIRST = "swapImpactPoolAmountLong_DESC_NULLS_FIRST",
+  swapImpactPoolAmountLong_DESC_NULLS_LAST = "swapImpactPoolAmountLong_DESC_NULLS_LAST",
+  swapImpactPoolAmountShort_ASC = "swapImpactPoolAmountShort_ASC",
+  swapImpactPoolAmountShort_ASC_NULLS_FIRST = "swapImpactPoolAmountShort_ASC_NULLS_FIRST",
+  swapImpactPoolAmountShort_ASC_NULLS_LAST = "swapImpactPoolAmountShort_ASC_NULLS_LAST",
+  swapImpactPoolAmountShort_DESC = "swapImpactPoolAmountShort_DESC",
+  swapImpactPoolAmountShort_DESC_NULLS_FIRST = "swapImpactPoolAmountShort_DESC_NULLS_FIRST",
+  swapImpactPoolAmountShort_DESC_NULLS_LAST = "swapImpactPoolAmountShort_DESC_NULLS_LAST",
+  thresholdForDecreaseFunding_ASC = "thresholdForDecreaseFunding_ASC",
+  thresholdForDecreaseFunding_ASC_NULLS_FIRST = "thresholdForDecreaseFunding_ASC_NULLS_FIRST",
+  thresholdForDecreaseFunding_ASC_NULLS_LAST = "thresholdForDecreaseFunding_ASC_NULLS_LAST",
+  thresholdForDecreaseFunding_DESC = "thresholdForDecreaseFunding_DESC",
+  thresholdForDecreaseFunding_DESC_NULLS_FIRST = "thresholdForDecreaseFunding_DESC_NULLS_FIRST",
+  thresholdForDecreaseFunding_DESC_NULLS_LAST = "thresholdForDecreaseFunding_DESC_NULLS_LAST",
+  thresholdForStableFunding_ASC = "thresholdForStableFunding_ASC",
+  thresholdForStableFunding_ASC_NULLS_FIRST = "thresholdForStableFunding_ASC_NULLS_FIRST",
+  thresholdForStableFunding_ASC_NULLS_LAST = "thresholdForStableFunding_ASC_NULLS_LAST",
+  thresholdForStableFunding_DESC = "thresholdForStableFunding_DESC",
+  thresholdForStableFunding_DESC_NULLS_FIRST = "thresholdForStableFunding_DESC_NULLS_FIRST",
+  thresholdForStableFunding_DESC_NULLS_LAST = "thresholdForStableFunding_DESC_NULLS_LAST",
+  totalBorrowingFees_ASC = "totalBorrowingFees_ASC",
+  totalBorrowingFees_ASC_NULLS_FIRST = "totalBorrowingFees_ASC_NULLS_FIRST",
+  totalBorrowingFees_ASC_NULLS_LAST = "totalBorrowingFees_ASC_NULLS_LAST",
+  totalBorrowingFees_DESC = "totalBorrowingFees_DESC",
+  totalBorrowingFees_DESC_NULLS_FIRST = "totalBorrowingFees_DESC_NULLS_FIRST",
+  totalBorrowingFees_DESC_NULLS_LAST = "totalBorrowingFees_DESC_NULLS_LAST",
+  virtualIndexTokenId_ASC = "virtualIndexTokenId_ASC",
+  virtualIndexTokenId_ASC_NULLS_FIRST = "virtualIndexTokenId_ASC_NULLS_FIRST",
+  virtualIndexTokenId_ASC_NULLS_LAST = "virtualIndexTokenId_ASC_NULLS_LAST",
+  virtualIndexTokenId_DESC = "virtualIndexTokenId_DESC",
+  virtualIndexTokenId_DESC_NULLS_FIRST = "virtualIndexTokenId_DESC_NULLS_FIRST",
+  virtualIndexTokenId_DESC_NULLS_LAST = "virtualIndexTokenId_DESC_NULLS_LAST",
+  virtualInventoryForPositions_ASC = "virtualInventoryForPositions_ASC",
+  virtualInventoryForPositions_ASC_NULLS_FIRST = "virtualInventoryForPositions_ASC_NULLS_FIRST",
+  virtualInventoryForPositions_ASC_NULLS_LAST = "virtualInventoryForPositions_ASC_NULLS_LAST",
+  virtualInventoryForPositions_DESC = "virtualInventoryForPositions_DESC",
+  virtualInventoryForPositions_DESC_NULLS_FIRST = "virtualInventoryForPositions_DESC_NULLS_FIRST",
+  virtualInventoryForPositions_DESC_NULLS_LAST = "virtualInventoryForPositions_DESC_NULLS_LAST",
+  virtualLongTokenId_ASC = "virtualLongTokenId_ASC",
+  virtualLongTokenId_ASC_NULLS_FIRST = "virtualLongTokenId_ASC_NULLS_FIRST",
+  virtualLongTokenId_ASC_NULLS_LAST = "virtualLongTokenId_ASC_NULLS_LAST",
+  virtualLongTokenId_DESC = "virtualLongTokenId_DESC",
+  virtualLongTokenId_DESC_NULLS_FIRST = "virtualLongTokenId_DESC_NULLS_FIRST",
+  virtualLongTokenId_DESC_NULLS_LAST = "virtualLongTokenId_DESC_NULLS_LAST",
+  virtualMarketId_ASC = "virtualMarketId_ASC",
+  virtualMarketId_ASC_NULLS_FIRST = "virtualMarketId_ASC_NULLS_FIRST",
+  virtualMarketId_ASC_NULLS_LAST = "virtualMarketId_ASC_NULLS_LAST",
+  virtualMarketId_DESC = "virtualMarketId_DESC",
+  virtualMarketId_DESC_NULLS_FIRST = "virtualMarketId_DESC_NULLS_FIRST",
+  virtualMarketId_DESC_NULLS_LAST = "virtualMarketId_DESC_NULLS_LAST",
+  virtualPoolAmountForLongToken_ASC = "virtualPoolAmountForLongToken_ASC",
+  virtualPoolAmountForLongToken_ASC_NULLS_FIRST = "virtualPoolAmountForLongToken_ASC_NULLS_FIRST",
+  virtualPoolAmountForLongToken_ASC_NULLS_LAST = "virtualPoolAmountForLongToken_ASC_NULLS_LAST",
+  virtualPoolAmountForLongToken_DESC = "virtualPoolAmountForLongToken_DESC",
+  virtualPoolAmountForLongToken_DESC_NULLS_FIRST = "virtualPoolAmountForLongToken_DESC_NULLS_FIRST",
+  virtualPoolAmountForLongToken_DESC_NULLS_LAST = "virtualPoolAmountForLongToken_DESC_NULLS_LAST",
+  virtualPoolAmountForShortToken_ASC = "virtualPoolAmountForShortToken_ASC",
+  virtualPoolAmountForShortToken_ASC_NULLS_FIRST = "virtualPoolAmountForShortToken_ASC_NULLS_FIRST",
+  virtualPoolAmountForShortToken_ASC_NULLS_LAST = "virtualPoolAmountForShortToken_ASC_NULLS_LAST",
+  virtualPoolAmountForShortToken_DESC = "virtualPoolAmountForShortToken_DESC",
+  virtualPoolAmountForShortToken_DESC_NULLS_FIRST = "virtualPoolAmountForShortToken_DESC_NULLS_FIRST",
+  virtualPoolAmountForShortToken_DESC_NULLS_LAST = "virtualPoolAmountForShortToken_DESC_NULLS_LAST",
+  virtualShortTokenId_ASC = "virtualShortTokenId_ASC",
+  virtualShortTokenId_ASC_NULLS_FIRST = "virtualShortTokenId_ASC_NULLS_FIRST",
+  virtualShortTokenId_ASC_NULLS_LAST = "virtualShortTokenId_ASC_NULLS_LAST",
+  virtualShortTokenId_DESC = "virtualShortTokenId_DESC",
+  virtualShortTokenId_DESC_NULLS_FIRST = "virtualShortTokenId_DESC_NULLS_FIRST",
+  virtualShortTokenId_DESC_NULLS_LAST = "virtualShortTokenId_DESC_NULLS_LAST",
+}
+
+export interface MarketInfoWhereInput {
+  AND?: InputMaybe<Array<MarketInfoWhereInput>>;
+  OR?: InputMaybe<Array<MarketInfoWhereInput>>;
+  aboveOptimalUsageBorrowingFactorLong_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aboveOptimalUsageBorrowingFactorLong_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aboveOptimalUsageBorrowingFactorLong_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aboveOptimalUsageBorrowingFactorLong_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  aboveOptimalUsageBorrowingFactorLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  aboveOptimalUsageBorrowingFactorLong_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aboveOptimalUsageBorrowingFactorLong_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aboveOptimalUsageBorrowingFactorLong_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aboveOptimalUsageBorrowingFactorLong_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  aboveOptimalUsageBorrowingFactorShort_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aboveOptimalUsageBorrowingFactorShort_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aboveOptimalUsageBorrowingFactorShort_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aboveOptimalUsageBorrowingFactorShort_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  aboveOptimalUsageBorrowingFactorShort_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  aboveOptimalUsageBorrowingFactorShort_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aboveOptimalUsageBorrowingFactorShort_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aboveOptimalUsageBorrowingFactorShort_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  aboveOptimalUsageBorrowingFactorShort_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  atomicSwapFeeFactor_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  atomicSwapFeeFactor_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  atomicSwapFeeFactor_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  atomicSwapFeeFactor_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  atomicSwapFeeFactor_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  atomicSwapFeeFactor_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  atomicSwapFeeFactor_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  atomicSwapFeeFactor_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  atomicSwapFeeFactor_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  baseBorrowingFactorLong_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  baseBorrowingFactorLong_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  baseBorrowingFactorLong_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  baseBorrowingFactorLong_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  baseBorrowingFactorLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  baseBorrowingFactorLong_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  baseBorrowingFactorLong_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  baseBorrowingFactorLong_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  baseBorrowingFactorLong_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  baseBorrowingFactorShort_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  baseBorrowingFactorShort_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  baseBorrowingFactorShort_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  baseBorrowingFactorShort_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  baseBorrowingFactorShort_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  baseBorrowingFactorShort_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  baseBorrowingFactorShort_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  baseBorrowingFactorShort_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  baseBorrowingFactorShort_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingExponentFactorLong_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingExponentFactorLong_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingExponentFactorLong_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingExponentFactorLong_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingExponentFactorLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  borrowingExponentFactorLong_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingExponentFactorLong_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingExponentFactorLong_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingExponentFactorLong_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingExponentFactorShort_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingExponentFactorShort_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingExponentFactorShort_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingExponentFactorShort_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingExponentFactorShort_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  borrowingExponentFactorShort_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingExponentFactorShort_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingExponentFactorShort_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingExponentFactorShort_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFactorLong_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorLong_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorLong_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorLong_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFactorLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  borrowingFactorLong_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorLong_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorLong_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorLong_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFactorPerSecondForLongs_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondForLongs_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondForLongs_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondForLongs_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFactorPerSecondForLongs_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  borrowingFactorPerSecondForLongs_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondForLongs_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondForLongs_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondForLongs_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFactorPerSecondForShorts_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondForShorts_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondForShorts_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondForShorts_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFactorPerSecondForShorts_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  borrowingFactorPerSecondForShorts_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondForShorts_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondForShorts_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorPerSecondForShorts_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFactorShort_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorShort_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorShort_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorShort_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFactorShort_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  borrowingFactorShort_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorShort_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorShort_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFactorShort_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  fundingDecreaseFactorPerSecond_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingDecreaseFactorPerSecond_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingDecreaseFactorPerSecond_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingDecreaseFactorPerSecond_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  fundingDecreaseFactorPerSecond_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  fundingDecreaseFactorPerSecond_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingDecreaseFactorPerSecond_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingDecreaseFactorPerSecond_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingDecreaseFactorPerSecond_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  fundingExponentFactor_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingExponentFactor_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingExponentFactor_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingExponentFactor_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  fundingExponentFactor_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  fundingExponentFactor_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingExponentFactor_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingExponentFactor_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingExponentFactor_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  fundingFactorPerSecond_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFactorPerSecond_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFactorPerSecond_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFactorPerSecond_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  fundingFactorPerSecond_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  fundingFactorPerSecond_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFactorPerSecond_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFactorPerSecond_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFactorPerSecond_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  fundingFactor_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFactor_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFactor_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFactor_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  fundingFactor_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  fundingFactor_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFactor_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFactor_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFactor_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  fundingIncreaseFactorPerSecond_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingIncreaseFactorPerSecond_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingIncreaseFactorPerSecond_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingIncreaseFactorPerSecond_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  fundingIncreaseFactorPerSecond_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  fundingIncreaseFactorPerSecond_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingIncreaseFactorPerSecond_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingIncreaseFactorPerSecond_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingIncreaseFactorPerSecond_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  indexTokenAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  indexTokenAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  indexTokenAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  indexTokenAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  indexTokenAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  indexTokenAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  indexTokenAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  indexTokenAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  indexTokenAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  indexTokenAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  indexTokenAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  indexTokenAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  indexTokenAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  indexTokenAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  indexTokenAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  indexTokenAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  indexTokenAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  isDisabled_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isDisabled_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isDisabled_not_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  lentPositionImpactPoolAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lentPositionImpactPoolAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lentPositionImpactPoolAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lentPositionImpactPoolAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  lentPositionImpactPoolAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  lentPositionImpactPoolAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lentPositionImpactPoolAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lentPositionImpactPoolAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  lentPositionImpactPoolAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longOpenInterestInTokensUsingLongToken_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokensUsingLongToken_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokensUsingLongToken_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokensUsingLongToken_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longOpenInterestInTokensUsingLongToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  longOpenInterestInTokensUsingLongToken_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokensUsingLongToken_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokensUsingLongToken_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokensUsingLongToken_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longOpenInterestInTokensUsingShortToken_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokensUsingShortToken_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokensUsingShortToken_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokensUsingShortToken_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longOpenInterestInTokensUsingShortToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  longOpenInterestInTokensUsingShortToken_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokensUsingShortToken_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokensUsingShortToken_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokensUsingShortToken_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longOpenInterestInTokens_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokens_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokens_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokens_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longOpenInterestInTokens_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  longOpenInterestInTokens_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokens_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokens_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestInTokens_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longOpenInterestUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longOpenInterestUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  longOpenInterestUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longOpenInterestUsingLongToken_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsingLongToken_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsingLongToken_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsingLongToken_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longOpenInterestUsingLongToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  longOpenInterestUsingLongToken_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsingLongToken_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsingLongToken_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsingLongToken_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longOpenInterestUsingShortToken_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsingShortToken_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsingShortToken_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsingShortToken_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longOpenInterestUsingShortToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  longOpenInterestUsingShortToken_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsingShortToken_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsingShortToken_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longOpenInterestUsingShortToken_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longPoolAmountAdjustment_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longPoolAmountAdjustment_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longPoolAmountAdjustment_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longPoolAmountAdjustment_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longPoolAmountAdjustment_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  longPoolAmountAdjustment_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longPoolAmountAdjustment_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longPoolAmountAdjustment_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longPoolAmountAdjustment_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longPoolAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longPoolAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longPoolAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longPoolAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longPoolAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  longPoolAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longPoolAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longPoolAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  longPoolAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  longTokenAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  longTokenAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  longTokenAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  longTokenAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  longTokenAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  longsPayShorts_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  longsPayShorts_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  longsPayShorts_not_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  marketTokenAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  marketTokenAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  marketTokenAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketTokenAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  marketTokenAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  marketTokenAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  marketTokenAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketTokenAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  marketTokenAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  marketTokenAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  marketTokenAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  marketTokenAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  marketTokenAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketTokenAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  marketTokenAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketTokenAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketTokenAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketTokenSupply_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  marketTokenSupply_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  marketTokenSupply_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  marketTokenSupply_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  marketTokenSupply_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  marketTokenSupply_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  marketTokenSupply_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  marketTokenSupply_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  marketTokenSupply_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxFundingFactorPerSecond_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxFundingFactorPerSecond_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxFundingFactorPerSecond_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxFundingFactorPerSecond_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxFundingFactorPerSecond_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxFundingFactorPerSecond_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxFundingFactorPerSecond_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxFundingFactorPerSecond_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxFundingFactorPerSecond_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxLendableImpactFactorForWithdrawals_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactFactorForWithdrawals_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactFactorForWithdrawals_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactFactorForWithdrawals_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxLendableImpactFactorForWithdrawals_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxLendableImpactFactorForWithdrawals_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactFactorForWithdrawals_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactFactorForWithdrawals_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactFactorForWithdrawals_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxLendableImpactFactor_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactFactor_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactFactor_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactFactor_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxLendableImpactFactor_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxLendableImpactFactor_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactFactor_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactFactor_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactFactor_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxLendableImpactUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxLendableImpactUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxLendableImpactUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLendableImpactUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxLongPoolAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLongPoolAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLongPoolAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLongPoolAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxLongPoolAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxLongPoolAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLongPoolAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLongPoolAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLongPoolAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxLongPoolUsdForDeposit_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLongPoolUsdForDeposit_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLongPoolUsdForDeposit_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLongPoolUsdForDeposit_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxLongPoolUsdForDeposit_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxLongPoolUsdForDeposit_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLongPoolUsdForDeposit_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLongPoolUsdForDeposit_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxLongPoolUsdForDeposit_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxOpenInterestLong_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxOpenInterestLong_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxOpenInterestLong_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxOpenInterestLong_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxOpenInterestLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxOpenInterestLong_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxOpenInterestLong_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxOpenInterestLong_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxOpenInterestLong_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxOpenInterestShort_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxOpenInterestShort_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxOpenInterestShort_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxOpenInterestShort_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxOpenInterestShort_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxOpenInterestShort_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxOpenInterestShort_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxOpenInterestShort_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxOpenInterestShort_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxPnlFactorForTradersLong_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPnlFactorForTradersLong_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPnlFactorForTradersLong_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPnlFactorForTradersLong_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxPnlFactorForTradersLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxPnlFactorForTradersLong_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPnlFactorForTradersLong_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPnlFactorForTradersLong_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPnlFactorForTradersLong_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxPnlFactorForTradersShort_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPnlFactorForTradersShort_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPnlFactorForTradersShort_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPnlFactorForTradersShort_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxPnlFactorForTradersShort_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxPnlFactorForTradersShort_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPnlFactorForTradersShort_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPnlFactorForTradersShort_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPnlFactorForTradersShort_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxPositionImpactFactorForLiquidations_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorForLiquidations_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorForLiquidations_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorForLiquidations_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxPositionImpactFactorForLiquidations_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxPositionImpactFactorForLiquidations_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorForLiquidations_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorForLiquidations_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorForLiquidations_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxPositionImpactFactorNegative_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorNegative_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorNegative_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorNegative_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxPositionImpactFactorNegative_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxPositionImpactFactorNegative_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorNegative_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorNegative_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorNegative_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxPositionImpactFactorPositive_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorPositive_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorPositive_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorPositive_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxPositionImpactFactorPositive_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxPositionImpactFactorPositive_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorPositive_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorPositive_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPositionImpactFactorPositive_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxShortPoolAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxShortPoolAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxShortPoolAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxShortPoolAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxShortPoolAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxShortPoolAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxShortPoolAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxShortPoolAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxShortPoolAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxShortPoolUsdForDeposit_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxShortPoolUsdForDeposit_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxShortPoolUsdForDeposit_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxShortPoolUsdForDeposit_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxShortPoolUsdForDeposit_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxShortPoolUsdForDeposit_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxShortPoolUsdForDeposit_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxShortPoolUsdForDeposit_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxShortPoolUsdForDeposit_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  minCollateralFactorForOpenInterestLong_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactorForOpenInterestLong_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactorForOpenInterestLong_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactorForOpenInterestLong_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  minCollateralFactorForOpenInterestLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  minCollateralFactorForOpenInterestLong_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactorForOpenInterestLong_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactorForOpenInterestLong_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactorForOpenInterestLong_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  minCollateralFactorForOpenInterestShort_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactorForOpenInterestShort_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactorForOpenInterestShort_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactorForOpenInterestShort_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  minCollateralFactorForOpenInterestShort_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  minCollateralFactorForOpenInterestShort_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactorForOpenInterestShort_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactorForOpenInterestShort_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactorForOpenInterestShort_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  minCollateralFactor_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactor_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactor_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactor_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  minCollateralFactor_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  minCollateralFactor_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactor_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactor_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minCollateralFactor_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  minFundingFactorPerSecond_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minFundingFactorPerSecond_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minFundingFactorPerSecond_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minFundingFactorPerSecond_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  minFundingFactorPerSecond_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  minFundingFactorPerSecond_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minFundingFactorPerSecond_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minFundingFactorPerSecond_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minFundingFactorPerSecond_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  minPositionImpactPoolAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minPositionImpactPoolAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minPositionImpactPoolAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minPositionImpactPoolAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  minPositionImpactPoolAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  minPositionImpactPoolAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minPositionImpactPoolAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minPositionImpactPoolAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minPositionImpactPoolAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  openInterestReserveFactorLong_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  openInterestReserveFactorLong_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  openInterestReserveFactorLong_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  openInterestReserveFactorLong_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  openInterestReserveFactorLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  openInterestReserveFactorLong_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  openInterestReserveFactorLong_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  openInterestReserveFactorLong_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  openInterestReserveFactorLong_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  openInterestReserveFactorShort_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  openInterestReserveFactorShort_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  openInterestReserveFactorShort_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  openInterestReserveFactorShort_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  openInterestReserveFactorShort_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  openInterestReserveFactorShort_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  openInterestReserveFactorShort_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  openInterestReserveFactorShort_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  openInterestReserveFactorShort_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  optimalUsageFactorLong_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  optimalUsageFactorLong_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  optimalUsageFactorLong_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  optimalUsageFactorLong_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  optimalUsageFactorLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  optimalUsageFactorLong_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  optimalUsageFactorLong_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  optimalUsageFactorLong_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  optimalUsageFactorLong_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  optimalUsageFactorShort_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  optimalUsageFactorShort_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  optimalUsageFactorShort_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  optimalUsageFactorShort_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  optimalUsageFactorShort_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  optimalUsageFactorShort_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  optimalUsageFactorShort_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  optimalUsageFactorShort_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  optimalUsageFactorShort_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  poolValueMax_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValueMax_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValueMax_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValueMax_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  poolValueMax_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  poolValueMax_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValueMax_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValueMax_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValueMax_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  poolValueMin_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValueMin_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValueMin_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValueMin_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  poolValueMin_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  poolValueMin_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValueMin_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValueMin_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValueMin_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  poolValue_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValue_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValue_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValue_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  poolValue_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  poolValue_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValue_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValue_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  poolValue_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionFeeFactorForNegativeImpact_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeFactorForNegativeImpact_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeFactorForNegativeImpact_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeFactorForNegativeImpact_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionFeeFactorForNegativeImpact_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  positionFeeFactorForNegativeImpact_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeFactorForNegativeImpact_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeFactorForNegativeImpact_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeFactorForNegativeImpact_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionFeeFactorForPositiveImpact_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeFactorForPositiveImpact_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeFactorForPositiveImpact_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeFactorForPositiveImpact_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionFeeFactorForPositiveImpact_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  positionFeeFactorForPositiveImpact_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeFactorForPositiveImpact_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeFactorForPositiveImpact_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeFactorForPositiveImpact_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionImpactExponentFactor_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactExponentFactor_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactExponentFactor_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactExponentFactor_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionImpactExponentFactor_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  positionImpactExponentFactor_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactExponentFactor_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactExponentFactor_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactExponentFactor_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionImpactFactorNegative_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactFactorNegative_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactFactorNegative_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactFactorNegative_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionImpactFactorNegative_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  positionImpactFactorNegative_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactFactorNegative_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactFactorNegative_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactFactorNegative_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionImpactFactorPositive_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactFactorPositive_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactFactorPositive_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactFactorPositive_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionImpactFactorPositive_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  positionImpactFactorPositive_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactFactorPositive_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactFactorPositive_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactFactorPositive_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionImpactPoolAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactPoolAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactPoolAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactPoolAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionImpactPoolAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  positionImpactPoolAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactPoolAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactPoolAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactPoolAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionImpactPoolDistributionRate_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactPoolDistributionRate_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactPoolDistributionRate_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactPoolDistributionRate_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionImpactPoolDistributionRate_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  positionImpactPoolDistributionRate_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactPoolDistributionRate_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactPoolDistributionRate_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionImpactPoolDistributionRate_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  reserveFactorLong_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reserveFactorLong_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reserveFactorLong_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reserveFactorLong_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  reserveFactorLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  reserveFactorLong_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reserveFactorLong_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reserveFactorLong_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reserveFactorLong_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  reserveFactorShort_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reserveFactorShort_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reserveFactorShort_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reserveFactorShort_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  reserveFactorShort_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  reserveFactorShort_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reserveFactorShort_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reserveFactorShort_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  reserveFactorShort_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortOpenInterestInTokensUsingLongToken_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokensUsingLongToken_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokensUsingLongToken_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokensUsingLongToken_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortOpenInterestInTokensUsingLongToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  shortOpenInterestInTokensUsingLongToken_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokensUsingLongToken_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokensUsingLongToken_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokensUsingLongToken_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortOpenInterestInTokensUsingShortToken_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokensUsingShortToken_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokensUsingShortToken_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokensUsingShortToken_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortOpenInterestInTokensUsingShortToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  shortOpenInterestInTokensUsingShortToken_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokensUsingShortToken_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokensUsingShortToken_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokensUsingShortToken_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortOpenInterestInTokens_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokens_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokens_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokens_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortOpenInterestInTokens_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  shortOpenInterestInTokens_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokens_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokens_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestInTokens_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortOpenInterestUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortOpenInterestUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  shortOpenInterestUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortOpenInterestUsingLongToken_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsingLongToken_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsingLongToken_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsingLongToken_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortOpenInterestUsingLongToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  shortOpenInterestUsingLongToken_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsingLongToken_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsingLongToken_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsingLongToken_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortOpenInterestUsingShortToken_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsingShortToken_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsingShortToken_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsingShortToken_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortOpenInterestUsingShortToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  shortOpenInterestUsingShortToken_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsingShortToken_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsingShortToken_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortOpenInterestUsingShortToken_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortPoolAmountAdjustment_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortPoolAmountAdjustment_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortPoolAmountAdjustment_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortPoolAmountAdjustment_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortPoolAmountAdjustment_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  shortPoolAmountAdjustment_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortPoolAmountAdjustment_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortPoolAmountAdjustment_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortPoolAmountAdjustment_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortPoolAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortPoolAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortPoolAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortPoolAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortPoolAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  shortPoolAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortPoolAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortPoolAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  shortPoolAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  shortTokenAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  shortTokenAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  shortTokenAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  shortTokenAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  shortTokenAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  swapFeeFactorForNegativeImpact_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapFeeFactorForNegativeImpact_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapFeeFactorForNegativeImpact_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapFeeFactorForNegativeImpact_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  swapFeeFactorForNegativeImpact_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  swapFeeFactorForNegativeImpact_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapFeeFactorForNegativeImpact_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapFeeFactorForNegativeImpact_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapFeeFactorForNegativeImpact_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  swapFeeFactorForPositiveImpact_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapFeeFactorForPositiveImpact_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapFeeFactorForPositiveImpact_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapFeeFactorForPositiveImpact_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  swapFeeFactorForPositiveImpact_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  swapFeeFactorForPositiveImpact_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapFeeFactorForPositiveImpact_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapFeeFactorForPositiveImpact_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapFeeFactorForPositiveImpact_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  swapImpactExponentFactor_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactExponentFactor_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactExponentFactor_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactExponentFactor_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  swapImpactExponentFactor_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  swapImpactExponentFactor_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactExponentFactor_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactExponentFactor_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactExponentFactor_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  swapImpactFactorNegative_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactFactorNegative_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactFactorNegative_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactFactorNegative_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  swapImpactFactorNegative_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  swapImpactFactorNegative_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactFactorNegative_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactFactorNegative_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactFactorNegative_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  swapImpactFactorPositive_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactFactorPositive_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactFactorPositive_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactFactorPositive_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  swapImpactFactorPositive_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  swapImpactFactorPositive_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactFactorPositive_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactFactorPositive_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactFactorPositive_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  swapImpactPoolAmountLong_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactPoolAmountLong_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactPoolAmountLong_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactPoolAmountLong_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  swapImpactPoolAmountLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  swapImpactPoolAmountLong_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactPoolAmountLong_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactPoolAmountLong_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactPoolAmountLong_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  swapImpactPoolAmountShort_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactPoolAmountShort_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactPoolAmountShort_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactPoolAmountShort_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  swapImpactPoolAmountShort_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  swapImpactPoolAmountShort_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactPoolAmountShort_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactPoolAmountShort_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  swapImpactPoolAmountShort_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  thresholdForDecreaseFunding_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  thresholdForDecreaseFunding_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  thresholdForDecreaseFunding_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  thresholdForDecreaseFunding_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  thresholdForDecreaseFunding_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  thresholdForDecreaseFunding_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  thresholdForDecreaseFunding_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  thresholdForDecreaseFunding_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  thresholdForDecreaseFunding_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  thresholdForStableFunding_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  thresholdForStableFunding_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  thresholdForStableFunding_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  thresholdForStableFunding_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  thresholdForStableFunding_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  thresholdForStableFunding_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  thresholdForStableFunding_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  thresholdForStableFunding_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  thresholdForStableFunding_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  totalBorrowingFees_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalBorrowingFees_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalBorrowingFees_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalBorrowingFees_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  totalBorrowingFees_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  totalBorrowingFees_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalBorrowingFees_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalBorrowingFees_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalBorrowingFees_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  virtualIndexTokenId_contains?: InputMaybe<Scalars["String"]["input"]>;
+  virtualIndexTokenId_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  virtualIndexTokenId_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  virtualIndexTokenId_eq?: InputMaybe<Scalars["String"]["input"]>;
+  virtualIndexTokenId_gt?: InputMaybe<Scalars["String"]["input"]>;
+  virtualIndexTokenId_gte?: InputMaybe<Scalars["String"]["input"]>;
+  virtualIndexTokenId_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  virtualIndexTokenId_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  virtualIndexTokenId_lt?: InputMaybe<Scalars["String"]["input"]>;
+  virtualIndexTokenId_lte?: InputMaybe<Scalars["String"]["input"]>;
+  virtualIndexTokenId_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  virtualIndexTokenId_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  virtualIndexTokenId_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  virtualIndexTokenId_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  virtualIndexTokenId_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  virtualIndexTokenId_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  virtualIndexTokenId_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  virtualInventoryForPositions_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualInventoryForPositions_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualInventoryForPositions_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualInventoryForPositions_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  virtualInventoryForPositions_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  virtualInventoryForPositions_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualInventoryForPositions_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualInventoryForPositions_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualInventoryForPositions_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  virtualLongTokenId_contains?: InputMaybe<Scalars["String"]["input"]>;
+  virtualLongTokenId_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  virtualLongTokenId_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  virtualLongTokenId_eq?: InputMaybe<Scalars["String"]["input"]>;
+  virtualLongTokenId_gt?: InputMaybe<Scalars["String"]["input"]>;
+  virtualLongTokenId_gte?: InputMaybe<Scalars["String"]["input"]>;
+  virtualLongTokenId_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  virtualLongTokenId_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  virtualLongTokenId_lt?: InputMaybe<Scalars["String"]["input"]>;
+  virtualLongTokenId_lte?: InputMaybe<Scalars["String"]["input"]>;
+  virtualLongTokenId_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  virtualLongTokenId_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  virtualLongTokenId_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  virtualLongTokenId_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  virtualLongTokenId_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  virtualLongTokenId_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  virtualLongTokenId_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  virtualMarketId_contains?: InputMaybe<Scalars["String"]["input"]>;
+  virtualMarketId_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  virtualMarketId_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  virtualMarketId_eq?: InputMaybe<Scalars["String"]["input"]>;
+  virtualMarketId_gt?: InputMaybe<Scalars["String"]["input"]>;
+  virtualMarketId_gte?: InputMaybe<Scalars["String"]["input"]>;
+  virtualMarketId_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  virtualMarketId_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  virtualMarketId_lt?: InputMaybe<Scalars["String"]["input"]>;
+  virtualMarketId_lte?: InputMaybe<Scalars["String"]["input"]>;
+  virtualMarketId_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  virtualMarketId_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  virtualMarketId_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  virtualMarketId_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  virtualMarketId_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  virtualMarketId_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  virtualMarketId_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  virtualPoolAmountForLongToken_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualPoolAmountForLongToken_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualPoolAmountForLongToken_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualPoolAmountForLongToken_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  virtualPoolAmountForLongToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  virtualPoolAmountForLongToken_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualPoolAmountForLongToken_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualPoolAmountForLongToken_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualPoolAmountForLongToken_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  virtualPoolAmountForShortToken_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualPoolAmountForShortToken_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualPoolAmountForShortToken_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualPoolAmountForShortToken_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  virtualPoolAmountForShortToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  virtualPoolAmountForShortToken_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualPoolAmountForShortToken_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualPoolAmountForShortToken_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  virtualPoolAmountForShortToken_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  virtualShortTokenId_contains?: InputMaybe<Scalars["String"]["input"]>;
+  virtualShortTokenId_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  virtualShortTokenId_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  virtualShortTokenId_eq?: InputMaybe<Scalars["String"]["input"]>;
+  virtualShortTokenId_gt?: InputMaybe<Scalars["String"]["input"]>;
+  virtualShortTokenId_gte?: InputMaybe<Scalars["String"]["input"]>;
+  virtualShortTokenId_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  virtualShortTokenId_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  virtualShortTokenId_lt?: InputMaybe<Scalars["String"]["input"]>;
+  virtualShortTokenId_lte?: InputMaybe<Scalars["String"]["input"]>;
+  virtualShortTokenId_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  virtualShortTokenId_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  virtualShortTokenId_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  virtualShortTokenId_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  virtualShortTokenId_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  virtualShortTokenId_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  virtualShortTokenId_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+}
+
+export interface MarketInfosConnection {
+  __typename?: "MarketInfosConnection";
+  edges: Array<MarketInfoEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export enum MarketOrderByInput {
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  indexToken_ASC = "indexToken_ASC",
+  indexToken_ASC_NULLS_FIRST = "indexToken_ASC_NULLS_FIRST",
+  indexToken_ASC_NULLS_LAST = "indexToken_ASC_NULLS_LAST",
+  indexToken_DESC = "indexToken_DESC",
+  indexToken_DESC_NULLS_FIRST = "indexToken_DESC_NULLS_FIRST",
+  indexToken_DESC_NULLS_LAST = "indexToken_DESC_NULLS_LAST",
+  longToken_ASC = "longToken_ASC",
+  longToken_ASC_NULLS_FIRST = "longToken_ASC_NULLS_FIRST",
+  longToken_ASC_NULLS_LAST = "longToken_ASC_NULLS_LAST",
+  longToken_DESC = "longToken_DESC",
+  longToken_DESC_NULLS_FIRST = "longToken_DESC_NULLS_FIRST",
+  longToken_DESC_NULLS_LAST = "longToken_DESC_NULLS_LAST",
+  shortToken_ASC = "shortToken_ASC",
+  shortToken_ASC_NULLS_FIRST = "shortToken_ASC_NULLS_FIRST",
+  shortToken_ASC_NULLS_LAST = "shortToken_ASC_NULLS_LAST",
+  shortToken_DESC = "shortToken_DESC",
+  shortToken_DESC_NULLS_FIRST = "shortToken_DESC_NULLS_FIRST",
+  shortToken_DESC_NULLS_LAST = "shortToken_DESC_NULLS_LAST",
+}
+
+export interface MarketPnlApr {
+  __typename?: "MarketPnlApr";
+  apr: Scalars["BigInt"]["output"];
+  marketAddress: Scalars["String"]["output"];
+  periodRealizedPnlLong: Scalars["BigInt"]["output"];
+  periodRealizedPnlShort: Scalars["BigInt"]["output"];
+  periodUnrealizedPnlLong: Scalars["BigInt"]["output"];
+  periodUnrealizedPnlShort: Scalars["BigInt"]["output"];
+  timeWeightedPoolValue: Scalars["BigInt"]["output"];
+}
+
+export interface MarketPnlAprsWhereInput {
+  marketAddresses?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  periodEnd: Scalars["Float"]["input"];
+  periodStart: Scalars["Float"]["input"];
+}
+
+export interface MarketWhereInput {
+  AND?: InputMaybe<Array<MarketWhereInput>>;
+  OR?: InputMaybe<Array<MarketWhereInput>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  indexToken_contains?: InputMaybe<Scalars["String"]["input"]>;
+  indexToken_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  indexToken_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  indexToken_eq?: InputMaybe<Scalars["String"]["input"]>;
+  indexToken_gt?: InputMaybe<Scalars["String"]["input"]>;
+  indexToken_gte?: InputMaybe<Scalars["String"]["input"]>;
+  indexToken_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  indexToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  indexToken_lt?: InputMaybe<Scalars["String"]["input"]>;
+  indexToken_lte?: InputMaybe<Scalars["String"]["input"]>;
+  indexToken_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  indexToken_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  indexToken_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  indexToken_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  indexToken_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  indexToken_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  indexToken_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  longToken_contains?: InputMaybe<Scalars["String"]["input"]>;
+  longToken_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  longToken_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  longToken_eq?: InputMaybe<Scalars["String"]["input"]>;
+  longToken_gt?: InputMaybe<Scalars["String"]["input"]>;
+  longToken_gte?: InputMaybe<Scalars["String"]["input"]>;
+  longToken_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  longToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  longToken_lt?: InputMaybe<Scalars["String"]["input"]>;
+  longToken_lte?: InputMaybe<Scalars["String"]["input"]>;
+  longToken_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  longToken_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  longToken_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  longToken_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  longToken_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  longToken_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  longToken_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  shortToken_contains?: InputMaybe<Scalars["String"]["input"]>;
+  shortToken_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  shortToken_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  shortToken_eq?: InputMaybe<Scalars["String"]["input"]>;
+  shortToken_gt?: InputMaybe<Scalars["String"]["input"]>;
+  shortToken_gte?: InputMaybe<Scalars["String"]["input"]>;
+  shortToken_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  shortToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  shortToken_lt?: InputMaybe<Scalars["String"]["input"]>;
+  shortToken_lte?: InputMaybe<Scalars["String"]["input"]>;
+  shortToken_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  shortToken_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  shortToken_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  shortToken_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  shortToken_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  shortToken_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  shortToken_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+}
+
+export interface MarketsConnection {
+  __typename?: "MarketsConnection";
+  edges: Array<MarketEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface MultichainFundingInfo {
+  __typename?: "MultichainFundingInfo";
+  account: Scalars["String"]["output"];
+  executedTimestamp?: Maybe<Scalars["Float"]["output"]>;
+  executedTxn?: Maybe<Scalars["String"]["output"]>;
+  expectedReceivedAmount: Scalars["BigInt"]["output"];
+  id: Scalars["String"]["output"];
+  isExecutionError?: Maybe<Scalars["Boolean"]["output"]>;
+  operation: Scalars["String"]["output"];
+  receivedAmount?: Maybe<Scalars["BigInt"]["output"]>;
+  receivedTimestamp?: Maybe<Scalars["Float"]["output"]>;
+  receivedTxn?: Maybe<Scalars["String"]["output"]>;
+  sentAmount: Scalars["BigInt"]["output"];
+  sentTimestamp: Scalars["Float"]["output"];
+  sentTxn: Scalars["String"]["output"];
+  settlementChainId: Scalars["Float"]["output"];
+  sourceChainId: Scalars["Float"]["output"];
+  step: Scalars["String"]["output"];
+  token: Scalars["String"]["output"];
+}
+
+export enum MultichainFundingOperation {
+  deposit = "deposit",
+  withdrawal = "withdrawal",
+}
+
+export interface MultichainFundingReceiveEvent {
+  __typename?: "MultichainFundingReceiveEvent";
+  deliveredTxn?: Maybe<Transaction>;
+  id: Scalars["String"]["output"];
+  isDeliveryError?: Maybe<Scalars["Boolean"]["output"]>;
+  isUncertain: Scalars["Boolean"]["output"];
+  operation: MultichainFundingOperation;
+  receivedAmount: Scalars["BigInt"]["output"];
+  receivedTxn: Transaction;
+  sourceChainId: Scalars["Int"]["output"];
+}
+
+export interface MultichainFundingReceiveEventEdge {
+  __typename?: "MultichainFundingReceiveEventEdge";
+  cursor: Scalars["String"]["output"];
+  node: MultichainFundingReceiveEvent;
+}
+
+export enum MultichainFundingReceiveEventOrderByInput {
+  deliveredTxn_blockNumber_ASC = "deliveredTxn_blockNumber_ASC",
+  deliveredTxn_blockNumber_ASC_NULLS_FIRST = "deliveredTxn_blockNumber_ASC_NULLS_FIRST",
+  deliveredTxn_blockNumber_ASC_NULLS_LAST = "deliveredTxn_blockNumber_ASC_NULLS_LAST",
+  deliveredTxn_blockNumber_DESC = "deliveredTxn_blockNumber_DESC",
+  deliveredTxn_blockNumber_DESC_NULLS_FIRST = "deliveredTxn_blockNumber_DESC_NULLS_FIRST",
+  deliveredTxn_blockNumber_DESC_NULLS_LAST = "deliveredTxn_blockNumber_DESC_NULLS_LAST",
+  deliveredTxn_chainId_ASC = "deliveredTxn_chainId_ASC",
+  deliveredTxn_chainId_ASC_NULLS_FIRST = "deliveredTxn_chainId_ASC_NULLS_FIRST",
+  deliveredTxn_chainId_ASC_NULLS_LAST = "deliveredTxn_chainId_ASC_NULLS_LAST",
+  deliveredTxn_chainId_DESC = "deliveredTxn_chainId_DESC",
+  deliveredTxn_chainId_DESC_NULLS_FIRST = "deliveredTxn_chainId_DESC_NULLS_FIRST",
+  deliveredTxn_chainId_DESC_NULLS_LAST = "deliveredTxn_chainId_DESC_NULLS_LAST",
+  deliveredTxn_from_ASC = "deliveredTxn_from_ASC",
+  deliveredTxn_from_ASC_NULLS_FIRST = "deliveredTxn_from_ASC_NULLS_FIRST",
+  deliveredTxn_from_ASC_NULLS_LAST = "deliveredTxn_from_ASC_NULLS_LAST",
+  deliveredTxn_from_DESC = "deliveredTxn_from_DESC",
+  deliveredTxn_from_DESC_NULLS_FIRST = "deliveredTxn_from_DESC_NULLS_FIRST",
+  deliveredTxn_from_DESC_NULLS_LAST = "deliveredTxn_from_DESC_NULLS_LAST",
+  deliveredTxn_hash_ASC = "deliveredTxn_hash_ASC",
+  deliveredTxn_hash_ASC_NULLS_FIRST = "deliveredTxn_hash_ASC_NULLS_FIRST",
+  deliveredTxn_hash_ASC_NULLS_LAST = "deliveredTxn_hash_ASC_NULLS_LAST",
+  deliveredTxn_hash_DESC = "deliveredTxn_hash_DESC",
+  deliveredTxn_hash_DESC_NULLS_FIRST = "deliveredTxn_hash_DESC_NULLS_FIRST",
+  deliveredTxn_hash_DESC_NULLS_LAST = "deliveredTxn_hash_DESC_NULLS_LAST",
+  deliveredTxn_id_ASC = "deliveredTxn_id_ASC",
+  deliveredTxn_id_ASC_NULLS_FIRST = "deliveredTxn_id_ASC_NULLS_FIRST",
+  deliveredTxn_id_ASC_NULLS_LAST = "deliveredTxn_id_ASC_NULLS_LAST",
+  deliveredTxn_id_DESC = "deliveredTxn_id_DESC",
+  deliveredTxn_id_DESC_NULLS_FIRST = "deliveredTxn_id_DESC_NULLS_FIRST",
+  deliveredTxn_id_DESC_NULLS_LAST = "deliveredTxn_id_DESC_NULLS_LAST",
+  deliveredTxn_timestamp_ASC = "deliveredTxn_timestamp_ASC",
+  deliveredTxn_timestamp_ASC_NULLS_FIRST = "deliveredTxn_timestamp_ASC_NULLS_FIRST",
+  deliveredTxn_timestamp_ASC_NULLS_LAST = "deliveredTxn_timestamp_ASC_NULLS_LAST",
+  deliveredTxn_timestamp_DESC = "deliveredTxn_timestamp_DESC",
+  deliveredTxn_timestamp_DESC_NULLS_FIRST = "deliveredTxn_timestamp_DESC_NULLS_FIRST",
+  deliveredTxn_timestamp_DESC_NULLS_LAST = "deliveredTxn_timestamp_DESC_NULLS_LAST",
+  deliveredTxn_to_ASC = "deliveredTxn_to_ASC",
+  deliveredTxn_to_ASC_NULLS_FIRST = "deliveredTxn_to_ASC_NULLS_FIRST",
+  deliveredTxn_to_ASC_NULLS_LAST = "deliveredTxn_to_ASC_NULLS_LAST",
+  deliveredTxn_to_DESC = "deliveredTxn_to_DESC",
+  deliveredTxn_to_DESC_NULLS_FIRST = "deliveredTxn_to_DESC_NULLS_FIRST",
+  deliveredTxn_to_DESC_NULLS_LAST = "deliveredTxn_to_DESC_NULLS_LAST",
+  deliveredTxn_transactionIndex_ASC = "deliveredTxn_transactionIndex_ASC",
+  deliveredTxn_transactionIndex_ASC_NULLS_FIRST = "deliveredTxn_transactionIndex_ASC_NULLS_FIRST",
+  deliveredTxn_transactionIndex_ASC_NULLS_LAST = "deliveredTxn_transactionIndex_ASC_NULLS_LAST",
+  deliveredTxn_transactionIndex_DESC = "deliveredTxn_transactionIndex_DESC",
+  deliveredTxn_transactionIndex_DESC_NULLS_FIRST = "deliveredTxn_transactionIndex_DESC_NULLS_FIRST",
+  deliveredTxn_transactionIndex_DESC_NULLS_LAST = "deliveredTxn_transactionIndex_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  isDeliveryError_ASC = "isDeliveryError_ASC",
+  isDeliveryError_ASC_NULLS_FIRST = "isDeliveryError_ASC_NULLS_FIRST",
+  isDeliveryError_ASC_NULLS_LAST = "isDeliveryError_ASC_NULLS_LAST",
+  isDeliveryError_DESC = "isDeliveryError_DESC",
+  isDeliveryError_DESC_NULLS_FIRST = "isDeliveryError_DESC_NULLS_FIRST",
+  isDeliveryError_DESC_NULLS_LAST = "isDeliveryError_DESC_NULLS_LAST",
+  isUncertain_ASC = "isUncertain_ASC",
+  isUncertain_ASC_NULLS_FIRST = "isUncertain_ASC_NULLS_FIRST",
+  isUncertain_ASC_NULLS_LAST = "isUncertain_ASC_NULLS_LAST",
+  isUncertain_DESC = "isUncertain_DESC",
+  isUncertain_DESC_NULLS_FIRST = "isUncertain_DESC_NULLS_FIRST",
+  isUncertain_DESC_NULLS_LAST = "isUncertain_DESC_NULLS_LAST",
+  operation_ASC = "operation_ASC",
+  operation_ASC_NULLS_FIRST = "operation_ASC_NULLS_FIRST",
+  operation_ASC_NULLS_LAST = "operation_ASC_NULLS_LAST",
+  operation_DESC = "operation_DESC",
+  operation_DESC_NULLS_FIRST = "operation_DESC_NULLS_FIRST",
+  operation_DESC_NULLS_LAST = "operation_DESC_NULLS_LAST",
+  receivedAmount_ASC = "receivedAmount_ASC",
+  receivedAmount_ASC_NULLS_FIRST = "receivedAmount_ASC_NULLS_FIRST",
+  receivedAmount_ASC_NULLS_LAST = "receivedAmount_ASC_NULLS_LAST",
+  receivedAmount_DESC = "receivedAmount_DESC",
+  receivedAmount_DESC_NULLS_FIRST = "receivedAmount_DESC_NULLS_FIRST",
+  receivedAmount_DESC_NULLS_LAST = "receivedAmount_DESC_NULLS_LAST",
+  receivedTxn_blockNumber_ASC = "receivedTxn_blockNumber_ASC",
+  receivedTxn_blockNumber_ASC_NULLS_FIRST = "receivedTxn_blockNumber_ASC_NULLS_FIRST",
+  receivedTxn_blockNumber_ASC_NULLS_LAST = "receivedTxn_blockNumber_ASC_NULLS_LAST",
+  receivedTxn_blockNumber_DESC = "receivedTxn_blockNumber_DESC",
+  receivedTxn_blockNumber_DESC_NULLS_FIRST = "receivedTxn_blockNumber_DESC_NULLS_FIRST",
+  receivedTxn_blockNumber_DESC_NULLS_LAST = "receivedTxn_blockNumber_DESC_NULLS_LAST",
+  receivedTxn_chainId_ASC = "receivedTxn_chainId_ASC",
+  receivedTxn_chainId_ASC_NULLS_FIRST = "receivedTxn_chainId_ASC_NULLS_FIRST",
+  receivedTxn_chainId_ASC_NULLS_LAST = "receivedTxn_chainId_ASC_NULLS_LAST",
+  receivedTxn_chainId_DESC = "receivedTxn_chainId_DESC",
+  receivedTxn_chainId_DESC_NULLS_FIRST = "receivedTxn_chainId_DESC_NULLS_FIRST",
+  receivedTxn_chainId_DESC_NULLS_LAST = "receivedTxn_chainId_DESC_NULLS_LAST",
+  receivedTxn_from_ASC = "receivedTxn_from_ASC",
+  receivedTxn_from_ASC_NULLS_FIRST = "receivedTxn_from_ASC_NULLS_FIRST",
+  receivedTxn_from_ASC_NULLS_LAST = "receivedTxn_from_ASC_NULLS_LAST",
+  receivedTxn_from_DESC = "receivedTxn_from_DESC",
+  receivedTxn_from_DESC_NULLS_FIRST = "receivedTxn_from_DESC_NULLS_FIRST",
+  receivedTxn_from_DESC_NULLS_LAST = "receivedTxn_from_DESC_NULLS_LAST",
+  receivedTxn_hash_ASC = "receivedTxn_hash_ASC",
+  receivedTxn_hash_ASC_NULLS_FIRST = "receivedTxn_hash_ASC_NULLS_FIRST",
+  receivedTxn_hash_ASC_NULLS_LAST = "receivedTxn_hash_ASC_NULLS_LAST",
+  receivedTxn_hash_DESC = "receivedTxn_hash_DESC",
+  receivedTxn_hash_DESC_NULLS_FIRST = "receivedTxn_hash_DESC_NULLS_FIRST",
+  receivedTxn_hash_DESC_NULLS_LAST = "receivedTxn_hash_DESC_NULLS_LAST",
+  receivedTxn_id_ASC = "receivedTxn_id_ASC",
+  receivedTxn_id_ASC_NULLS_FIRST = "receivedTxn_id_ASC_NULLS_FIRST",
+  receivedTxn_id_ASC_NULLS_LAST = "receivedTxn_id_ASC_NULLS_LAST",
+  receivedTxn_id_DESC = "receivedTxn_id_DESC",
+  receivedTxn_id_DESC_NULLS_FIRST = "receivedTxn_id_DESC_NULLS_FIRST",
+  receivedTxn_id_DESC_NULLS_LAST = "receivedTxn_id_DESC_NULLS_LAST",
+  receivedTxn_timestamp_ASC = "receivedTxn_timestamp_ASC",
+  receivedTxn_timestamp_ASC_NULLS_FIRST = "receivedTxn_timestamp_ASC_NULLS_FIRST",
+  receivedTxn_timestamp_ASC_NULLS_LAST = "receivedTxn_timestamp_ASC_NULLS_LAST",
+  receivedTxn_timestamp_DESC = "receivedTxn_timestamp_DESC",
+  receivedTxn_timestamp_DESC_NULLS_FIRST = "receivedTxn_timestamp_DESC_NULLS_FIRST",
+  receivedTxn_timestamp_DESC_NULLS_LAST = "receivedTxn_timestamp_DESC_NULLS_LAST",
+  receivedTxn_to_ASC = "receivedTxn_to_ASC",
+  receivedTxn_to_ASC_NULLS_FIRST = "receivedTxn_to_ASC_NULLS_FIRST",
+  receivedTxn_to_ASC_NULLS_LAST = "receivedTxn_to_ASC_NULLS_LAST",
+  receivedTxn_to_DESC = "receivedTxn_to_DESC",
+  receivedTxn_to_DESC_NULLS_FIRST = "receivedTxn_to_DESC_NULLS_FIRST",
+  receivedTxn_to_DESC_NULLS_LAST = "receivedTxn_to_DESC_NULLS_LAST",
+  receivedTxn_transactionIndex_ASC = "receivedTxn_transactionIndex_ASC",
+  receivedTxn_transactionIndex_ASC_NULLS_FIRST = "receivedTxn_transactionIndex_ASC_NULLS_FIRST",
+  receivedTxn_transactionIndex_ASC_NULLS_LAST = "receivedTxn_transactionIndex_ASC_NULLS_LAST",
+  receivedTxn_transactionIndex_DESC = "receivedTxn_transactionIndex_DESC",
+  receivedTxn_transactionIndex_DESC_NULLS_FIRST = "receivedTxn_transactionIndex_DESC_NULLS_FIRST",
+  receivedTxn_transactionIndex_DESC_NULLS_LAST = "receivedTxn_transactionIndex_DESC_NULLS_LAST",
+  sourceChainId_ASC = "sourceChainId_ASC",
+  sourceChainId_ASC_NULLS_FIRST = "sourceChainId_ASC_NULLS_FIRST",
+  sourceChainId_ASC_NULLS_LAST = "sourceChainId_ASC_NULLS_LAST",
+  sourceChainId_DESC = "sourceChainId_DESC",
+  sourceChainId_DESC_NULLS_FIRST = "sourceChainId_DESC_NULLS_FIRST",
+  sourceChainId_DESC_NULLS_LAST = "sourceChainId_DESC_NULLS_LAST",
+}
+
+export interface MultichainFundingReceiveEventWhereInput {
+  AND?: InputMaybe<Array<MultichainFundingReceiveEventWhereInput>>;
+  OR?: InputMaybe<Array<MultichainFundingReceiveEventWhereInput>>;
+  deliveredTxn?: InputMaybe<TransactionWhereInput>;
+  deliveredTxn_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  isDeliveryError_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isDeliveryError_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isDeliveryError_not_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isUncertain_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isUncertain_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isUncertain_not_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  operation_eq?: InputMaybe<MultichainFundingOperation>;
+  operation_in?: InputMaybe<Array<MultichainFundingOperation>>;
+  operation_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  operation_not_eq?: InputMaybe<MultichainFundingOperation>;
+  operation_not_in?: InputMaybe<Array<MultichainFundingOperation>>;
+  receivedAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  receivedAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  receivedAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  receivedAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  receivedAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  receivedAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  receivedAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  receivedAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  receivedAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  receivedTxn?: InputMaybe<TransactionWhereInput>;
+  receivedTxn_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  sourceChainId_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  sourceChainId_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  sourceChainId_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  sourceChainId_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  sourceChainId_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  sourceChainId_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  sourceChainId_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  sourceChainId_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  sourceChainId_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+}
+
+export interface MultichainFundingReceiveEventsConnection {
+  __typename?: "MultichainFundingReceiveEventsConnection";
+  edges: Array<MultichainFundingReceiveEventEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface MultichainFundingSendEvent {
+  __typename?: "MultichainFundingSendEvent";
+  account: Scalars["String"]["output"];
+  expectedReceivedAmount: Scalars["BigInt"]["output"];
+  id: Scalars["String"]["output"];
+  operation: MultichainFundingOperation;
+  sentAmount: Scalars["BigInt"]["output"];
+  settlementChainId: Scalars["Int"]["output"];
+  sourceChainId: Scalars["Int"]["output"];
+  token: Scalars["String"]["output"];
+  txn: Transaction;
+}
+
+export interface MultichainFundingSendEventEdge {
+  __typename?: "MultichainFundingSendEventEdge";
+  cursor: Scalars["String"]["output"];
+  node: MultichainFundingSendEvent;
+}
+
+export enum MultichainFundingSendEventOrderByInput {
+  account_ASC = "account_ASC",
+  account_ASC_NULLS_FIRST = "account_ASC_NULLS_FIRST",
+  account_ASC_NULLS_LAST = "account_ASC_NULLS_LAST",
+  account_DESC = "account_DESC",
+  account_DESC_NULLS_FIRST = "account_DESC_NULLS_FIRST",
+  account_DESC_NULLS_LAST = "account_DESC_NULLS_LAST",
+  expectedReceivedAmount_ASC = "expectedReceivedAmount_ASC",
+  expectedReceivedAmount_ASC_NULLS_FIRST = "expectedReceivedAmount_ASC_NULLS_FIRST",
+  expectedReceivedAmount_ASC_NULLS_LAST = "expectedReceivedAmount_ASC_NULLS_LAST",
+  expectedReceivedAmount_DESC = "expectedReceivedAmount_DESC",
+  expectedReceivedAmount_DESC_NULLS_FIRST = "expectedReceivedAmount_DESC_NULLS_FIRST",
+  expectedReceivedAmount_DESC_NULLS_LAST = "expectedReceivedAmount_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  operation_ASC = "operation_ASC",
+  operation_ASC_NULLS_FIRST = "operation_ASC_NULLS_FIRST",
+  operation_ASC_NULLS_LAST = "operation_ASC_NULLS_LAST",
+  operation_DESC = "operation_DESC",
+  operation_DESC_NULLS_FIRST = "operation_DESC_NULLS_FIRST",
+  operation_DESC_NULLS_LAST = "operation_DESC_NULLS_LAST",
+  sentAmount_ASC = "sentAmount_ASC",
+  sentAmount_ASC_NULLS_FIRST = "sentAmount_ASC_NULLS_FIRST",
+  sentAmount_ASC_NULLS_LAST = "sentAmount_ASC_NULLS_LAST",
+  sentAmount_DESC = "sentAmount_DESC",
+  sentAmount_DESC_NULLS_FIRST = "sentAmount_DESC_NULLS_FIRST",
+  sentAmount_DESC_NULLS_LAST = "sentAmount_DESC_NULLS_LAST",
+  settlementChainId_ASC = "settlementChainId_ASC",
+  settlementChainId_ASC_NULLS_FIRST = "settlementChainId_ASC_NULLS_FIRST",
+  settlementChainId_ASC_NULLS_LAST = "settlementChainId_ASC_NULLS_LAST",
+  settlementChainId_DESC = "settlementChainId_DESC",
+  settlementChainId_DESC_NULLS_FIRST = "settlementChainId_DESC_NULLS_FIRST",
+  settlementChainId_DESC_NULLS_LAST = "settlementChainId_DESC_NULLS_LAST",
+  sourceChainId_ASC = "sourceChainId_ASC",
+  sourceChainId_ASC_NULLS_FIRST = "sourceChainId_ASC_NULLS_FIRST",
+  sourceChainId_ASC_NULLS_LAST = "sourceChainId_ASC_NULLS_LAST",
+  sourceChainId_DESC = "sourceChainId_DESC",
+  sourceChainId_DESC_NULLS_FIRST = "sourceChainId_DESC_NULLS_FIRST",
+  sourceChainId_DESC_NULLS_LAST = "sourceChainId_DESC_NULLS_LAST",
+  token_ASC = "token_ASC",
+  token_ASC_NULLS_FIRST = "token_ASC_NULLS_FIRST",
+  token_ASC_NULLS_LAST = "token_ASC_NULLS_LAST",
+  token_DESC = "token_DESC",
+  token_DESC_NULLS_FIRST = "token_DESC_NULLS_FIRST",
+  token_DESC_NULLS_LAST = "token_DESC_NULLS_LAST",
+  txn_blockNumber_ASC = "txn_blockNumber_ASC",
+  txn_blockNumber_ASC_NULLS_FIRST = "txn_blockNumber_ASC_NULLS_FIRST",
+  txn_blockNumber_ASC_NULLS_LAST = "txn_blockNumber_ASC_NULLS_LAST",
+  txn_blockNumber_DESC = "txn_blockNumber_DESC",
+  txn_blockNumber_DESC_NULLS_FIRST = "txn_blockNumber_DESC_NULLS_FIRST",
+  txn_blockNumber_DESC_NULLS_LAST = "txn_blockNumber_DESC_NULLS_LAST",
+  txn_chainId_ASC = "txn_chainId_ASC",
+  txn_chainId_ASC_NULLS_FIRST = "txn_chainId_ASC_NULLS_FIRST",
+  txn_chainId_ASC_NULLS_LAST = "txn_chainId_ASC_NULLS_LAST",
+  txn_chainId_DESC = "txn_chainId_DESC",
+  txn_chainId_DESC_NULLS_FIRST = "txn_chainId_DESC_NULLS_FIRST",
+  txn_chainId_DESC_NULLS_LAST = "txn_chainId_DESC_NULLS_LAST",
+  txn_from_ASC = "txn_from_ASC",
+  txn_from_ASC_NULLS_FIRST = "txn_from_ASC_NULLS_FIRST",
+  txn_from_ASC_NULLS_LAST = "txn_from_ASC_NULLS_LAST",
+  txn_from_DESC = "txn_from_DESC",
+  txn_from_DESC_NULLS_FIRST = "txn_from_DESC_NULLS_FIRST",
+  txn_from_DESC_NULLS_LAST = "txn_from_DESC_NULLS_LAST",
+  txn_hash_ASC = "txn_hash_ASC",
+  txn_hash_ASC_NULLS_FIRST = "txn_hash_ASC_NULLS_FIRST",
+  txn_hash_ASC_NULLS_LAST = "txn_hash_ASC_NULLS_LAST",
+  txn_hash_DESC = "txn_hash_DESC",
+  txn_hash_DESC_NULLS_FIRST = "txn_hash_DESC_NULLS_FIRST",
+  txn_hash_DESC_NULLS_LAST = "txn_hash_DESC_NULLS_LAST",
+  txn_id_ASC = "txn_id_ASC",
+  txn_id_ASC_NULLS_FIRST = "txn_id_ASC_NULLS_FIRST",
+  txn_id_ASC_NULLS_LAST = "txn_id_ASC_NULLS_LAST",
+  txn_id_DESC = "txn_id_DESC",
+  txn_id_DESC_NULLS_FIRST = "txn_id_DESC_NULLS_FIRST",
+  txn_id_DESC_NULLS_LAST = "txn_id_DESC_NULLS_LAST",
+  txn_timestamp_ASC = "txn_timestamp_ASC",
+  txn_timestamp_ASC_NULLS_FIRST = "txn_timestamp_ASC_NULLS_FIRST",
+  txn_timestamp_ASC_NULLS_LAST = "txn_timestamp_ASC_NULLS_LAST",
+  txn_timestamp_DESC = "txn_timestamp_DESC",
+  txn_timestamp_DESC_NULLS_FIRST = "txn_timestamp_DESC_NULLS_FIRST",
+  txn_timestamp_DESC_NULLS_LAST = "txn_timestamp_DESC_NULLS_LAST",
+  txn_to_ASC = "txn_to_ASC",
+  txn_to_ASC_NULLS_FIRST = "txn_to_ASC_NULLS_FIRST",
+  txn_to_ASC_NULLS_LAST = "txn_to_ASC_NULLS_LAST",
+  txn_to_DESC = "txn_to_DESC",
+  txn_to_DESC_NULLS_FIRST = "txn_to_DESC_NULLS_FIRST",
+  txn_to_DESC_NULLS_LAST = "txn_to_DESC_NULLS_LAST",
+  txn_transactionIndex_ASC = "txn_transactionIndex_ASC",
+  txn_transactionIndex_ASC_NULLS_FIRST = "txn_transactionIndex_ASC_NULLS_FIRST",
+  txn_transactionIndex_ASC_NULLS_LAST = "txn_transactionIndex_ASC_NULLS_LAST",
+  txn_transactionIndex_DESC = "txn_transactionIndex_DESC",
+  txn_transactionIndex_DESC_NULLS_FIRST = "txn_transactionIndex_DESC_NULLS_FIRST",
+  txn_transactionIndex_DESC_NULLS_LAST = "txn_transactionIndex_DESC_NULLS_LAST",
+}
+
+export interface MultichainFundingSendEventWhereInput {
+  AND?: InputMaybe<Array<MultichainFundingSendEventWhereInput>>;
+  OR?: InputMaybe<Array<MultichainFundingSendEventWhereInput>>;
+  account_contains?: InputMaybe<Scalars["String"]["input"]>;
+  account_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  account_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_eq?: InputMaybe<Scalars["String"]["input"]>;
+  account_gt?: InputMaybe<Scalars["String"]["input"]>;
+  account_gte?: InputMaybe<Scalars["String"]["input"]>;
+  account_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  account_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  account_lt?: InputMaybe<Scalars["String"]["input"]>;
+  account_lte?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  account_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  expectedReceivedAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  expectedReceivedAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  expectedReceivedAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  expectedReceivedAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  expectedReceivedAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  expectedReceivedAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  expectedReceivedAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  expectedReceivedAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  expectedReceivedAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  operation_eq?: InputMaybe<MultichainFundingOperation>;
+  operation_in?: InputMaybe<Array<MultichainFundingOperation>>;
+  operation_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  operation_not_eq?: InputMaybe<MultichainFundingOperation>;
+  operation_not_in?: InputMaybe<Array<MultichainFundingOperation>>;
+  sentAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sentAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sentAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sentAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  sentAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  sentAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sentAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sentAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sentAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  settlementChainId_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  settlementChainId_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  settlementChainId_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  settlementChainId_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  settlementChainId_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  settlementChainId_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  settlementChainId_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  settlementChainId_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  settlementChainId_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  sourceChainId_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  sourceChainId_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  sourceChainId_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  sourceChainId_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  sourceChainId_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  sourceChainId_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  sourceChainId_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  sourceChainId_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  sourceChainId_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  token_contains?: InputMaybe<Scalars["String"]["input"]>;
+  token_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  token_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  token_eq?: InputMaybe<Scalars["String"]["input"]>;
+  token_gt?: InputMaybe<Scalars["String"]["input"]>;
+  token_gte?: InputMaybe<Scalars["String"]["input"]>;
+  token_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  token_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  token_lt?: InputMaybe<Scalars["String"]["input"]>;
+  token_lte?: InputMaybe<Scalars["String"]["input"]>;
+  token_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  token_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  token_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  token_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  token_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  token_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  token_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  txn?: InputMaybe<TransactionWhereInput>;
+  txn_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+}
+
+export interface MultichainFundingSendEventsConnection {
+  __typename?: "MultichainFundingSendEventsConnection";
+  edges: Array<MultichainFundingSendEventEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface MultichainFundingWhereInput {
+  account?: InputMaybe<Scalars["String"]["input"]>;
+  id?: InputMaybe<Scalars["String"]["input"]>;
+}
+
+export interface MultichainMetadata {
+  __typename?: "MultichainMetadata";
+  id: Scalars["String"]["output"];
+  lastBlockNumber: Scalars["Int"]["output"];
+  lastBlockTimestamp: Scalars["Int"]["output"];
+}
+
+export interface MultichainMetadataConnection {
+  __typename?: "MultichainMetadataConnection";
+  edges: Array<MultichainMetadataEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface MultichainMetadataEdge {
+  __typename?: "MultichainMetadataEdge";
+  cursor: Scalars["String"]["output"];
+  node: MultichainMetadata;
+}
+
+export enum MultichainMetadataOrderByInput {
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  lastBlockNumber_ASC = "lastBlockNumber_ASC",
+  lastBlockNumber_ASC_NULLS_FIRST = "lastBlockNumber_ASC_NULLS_FIRST",
+  lastBlockNumber_ASC_NULLS_LAST = "lastBlockNumber_ASC_NULLS_LAST",
+  lastBlockNumber_DESC = "lastBlockNumber_DESC",
+  lastBlockNumber_DESC_NULLS_FIRST = "lastBlockNumber_DESC_NULLS_FIRST",
+  lastBlockNumber_DESC_NULLS_LAST = "lastBlockNumber_DESC_NULLS_LAST",
+  lastBlockTimestamp_ASC = "lastBlockTimestamp_ASC",
+  lastBlockTimestamp_ASC_NULLS_FIRST = "lastBlockTimestamp_ASC_NULLS_FIRST",
+  lastBlockTimestamp_ASC_NULLS_LAST = "lastBlockTimestamp_ASC_NULLS_LAST",
+  lastBlockTimestamp_DESC = "lastBlockTimestamp_DESC",
+  lastBlockTimestamp_DESC_NULLS_FIRST = "lastBlockTimestamp_DESC_NULLS_FIRST",
+  lastBlockTimestamp_DESC_NULLS_LAST = "lastBlockTimestamp_DESC_NULLS_LAST",
+}
+
+export interface MultichainMetadataWhereInput {
+  AND?: InputMaybe<Array<MultichainMetadataWhereInput>>;
+  OR?: InputMaybe<Array<MultichainMetadataWhereInput>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  lastBlockNumber_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  lastBlockNumber_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  lastBlockNumber_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  lastBlockNumber_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  lastBlockNumber_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  lastBlockNumber_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  lastBlockNumber_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  lastBlockNumber_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  lastBlockNumber_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  lastBlockTimestamp_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  lastBlockTimestamp_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  lastBlockTimestamp_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  lastBlockTimestamp_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  lastBlockTimestamp_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  lastBlockTimestamp_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  lastBlockTimestamp_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  lastBlockTimestamp_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  lastBlockTimestamp_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+}
+
+export interface OnChainSetting {
+  __typename?: "OnChainSetting";
+  id: Scalars["String"]["output"];
+  key: Scalars["String"]["output"];
+  type: OnChainSettingType;
+  value: Scalars["String"]["output"];
+}
+
+export interface OnChainSettingEdge {
+  __typename?: "OnChainSettingEdge";
+  cursor: Scalars["String"]["output"];
+  node: OnChainSetting;
+}
+
+export enum OnChainSettingOrderByInput {
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  key_ASC = "key_ASC",
+  key_ASC_NULLS_FIRST = "key_ASC_NULLS_FIRST",
+  key_ASC_NULLS_LAST = "key_ASC_NULLS_LAST",
+  key_DESC = "key_DESC",
+  key_DESC_NULLS_FIRST = "key_DESC_NULLS_FIRST",
+  key_DESC_NULLS_LAST = "key_DESC_NULLS_LAST",
+  type_ASC = "type_ASC",
+  type_ASC_NULLS_FIRST = "type_ASC_NULLS_FIRST",
+  type_ASC_NULLS_LAST = "type_ASC_NULLS_LAST",
+  type_DESC = "type_DESC",
+  type_DESC_NULLS_FIRST = "type_DESC_NULLS_FIRST",
+  type_DESC_NULLS_LAST = "type_DESC_NULLS_LAST",
+  value_ASC = "value_ASC",
+  value_ASC_NULLS_FIRST = "value_ASC_NULLS_FIRST",
+  value_ASC_NULLS_LAST = "value_ASC_NULLS_LAST",
+  value_DESC = "value_DESC",
+  value_DESC_NULLS_FIRST = "value_DESC_NULLS_FIRST",
+  value_DESC_NULLS_LAST = "value_DESC_NULLS_LAST",
+}
+
+export enum OnChainSettingType {
+  bool = "bool",
+  bytes32 = "bytes32",
+  string = "string",
+  uint = "uint",
+}
+
+export interface OnChainSettingWhereInput {
+  AND?: InputMaybe<Array<OnChainSettingWhereInput>>;
+  OR?: InputMaybe<Array<OnChainSettingWhereInput>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  key_contains?: InputMaybe<Scalars["String"]["input"]>;
+  key_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  key_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  key_eq?: InputMaybe<Scalars["String"]["input"]>;
+  key_gt?: InputMaybe<Scalars["String"]["input"]>;
+  key_gte?: InputMaybe<Scalars["String"]["input"]>;
+  key_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  key_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  key_lt?: InputMaybe<Scalars["String"]["input"]>;
+  key_lte?: InputMaybe<Scalars["String"]["input"]>;
+  key_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  key_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  key_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  key_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  key_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  key_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  key_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  type_eq?: InputMaybe<OnChainSettingType>;
+  type_in?: InputMaybe<Array<OnChainSettingType>>;
+  type_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  type_not_eq?: InputMaybe<OnChainSettingType>;
+  type_not_in?: InputMaybe<Array<OnChainSettingType>>;
+  value_contains?: InputMaybe<Scalars["String"]["input"]>;
+  value_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  value_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  value_eq?: InputMaybe<Scalars["String"]["input"]>;
+  value_gt?: InputMaybe<Scalars["String"]["input"]>;
+  value_gte?: InputMaybe<Scalars["String"]["input"]>;
+  value_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  value_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  value_lt?: InputMaybe<Scalars["String"]["input"]>;
+  value_lte?: InputMaybe<Scalars["String"]["input"]>;
+  value_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  value_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  value_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  value_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  value_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  value_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  value_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+}
+
+export interface OnChainSettingsConnection {
+  __typename?: "OnChainSettingsConnection";
+  edges: Array<OnChainSettingEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface Order {
+  __typename?: "Order";
+  acceptablePrice: Scalars["BigInt"]["output"];
+  account: Scalars["String"]["output"];
+  callbackContract: Scalars["String"]["output"];
+  callbackGasLimit: Scalars["BigInt"]["output"];
+  cancelledReason?: Maybe<Scalars["String"]["output"]>;
+  cancelledReasonBytes?: Maybe<Scalars["String"]["output"]>;
+  cancelledTxn?: Maybe<Transaction>;
+  createdTxn: Transaction;
+  executedTxn?: Maybe<Transaction>;
+  executionFee: Scalars["BigInt"]["output"];
+  frozenReason?: Maybe<Scalars["String"]["output"]>;
+  frozenReasonBytes?: Maybe<Scalars["String"]["output"]>;
+  id: Scalars["String"]["output"];
+  initialCollateralDeltaAmount: Scalars["BigInt"]["output"];
+  initialCollateralTokenAddress: Scalars["String"]["output"];
+  isLong: Scalars["Boolean"]["output"];
+  marketAddress: Scalars["String"]["output"];
+  minOutputAmount: Scalars["BigInt"]["output"];
+  numberOfParts?: Maybe<Scalars["Int"]["output"]>;
+  orderType: Scalars["Int"]["output"];
+  receiver: Scalars["String"]["output"];
+  shouldUnwrapNativeToken: Scalars["Boolean"]["output"];
+  sizeDeltaUsd: Scalars["BigInt"]["output"];
+  srcChainId?: Maybe<Scalars["BigInt"]["output"]>;
+  status: OrderStatus;
+  swapPath: Array<Scalars["String"]["output"]>;
+  triggerPrice: Scalars["BigInt"]["output"];
+  twapGroupId?: Maybe<Scalars["String"]["output"]>;
+  uiFeeReceiver: Scalars["String"]["output"];
+  updatedAtBlock: Scalars["BigInt"]["output"];
+}
+
+export interface OrderEdge {
+  __typename?: "OrderEdge";
+  cursor: Scalars["String"]["output"];
+  node: Order;
+}
+
+export enum OrderOrderByInput {
+  acceptablePrice_ASC = "acceptablePrice_ASC",
+  acceptablePrice_ASC_NULLS_FIRST = "acceptablePrice_ASC_NULLS_FIRST",
+  acceptablePrice_ASC_NULLS_LAST = "acceptablePrice_ASC_NULLS_LAST",
+  acceptablePrice_DESC = "acceptablePrice_DESC",
+  acceptablePrice_DESC_NULLS_FIRST = "acceptablePrice_DESC_NULLS_FIRST",
+  acceptablePrice_DESC_NULLS_LAST = "acceptablePrice_DESC_NULLS_LAST",
+  account_ASC = "account_ASC",
+  account_ASC_NULLS_FIRST = "account_ASC_NULLS_FIRST",
+  account_ASC_NULLS_LAST = "account_ASC_NULLS_LAST",
+  account_DESC = "account_DESC",
+  account_DESC_NULLS_FIRST = "account_DESC_NULLS_FIRST",
+  account_DESC_NULLS_LAST = "account_DESC_NULLS_LAST",
+  callbackContract_ASC = "callbackContract_ASC",
+  callbackContract_ASC_NULLS_FIRST = "callbackContract_ASC_NULLS_FIRST",
+  callbackContract_ASC_NULLS_LAST = "callbackContract_ASC_NULLS_LAST",
+  callbackContract_DESC = "callbackContract_DESC",
+  callbackContract_DESC_NULLS_FIRST = "callbackContract_DESC_NULLS_FIRST",
+  callbackContract_DESC_NULLS_LAST = "callbackContract_DESC_NULLS_LAST",
+  callbackGasLimit_ASC = "callbackGasLimit_ASC",
+  callbackGasLimit_ASC_NULLS_FIRST = "callbackGasLimit_ASC_NULLS_FIRST",
+  callbackGasLimit_ASC_NULLS_LAST = "callbackGasLimit_ASC_NULLS_LAST",
+  callbackGasLimit_DESC = "callbackGasLimit_DESC",
+  callbackGasLimit_DESC_NULLS_FIRST = "callbackGasLimit_DESC_NULLS_FIRST",
+  callbackGasLimit_DESC_NULLS_LAST = "callbackGasLimit_DESC_NULLS_LAST",
+  cancelledReasonBytes_ASC = "cancelledReasonBytes_ASC",
+  cancelledReasonBytes_ASC_NULLS_FIRST = "cancelledReasonBytes_ASC_NULLS_FIRST",
+  cancelledReasonBytes_ASC_NULLS_LAST = "cancelledReasonBytes_ASC_NULLS_LAST",
+  cancelledReasonBytes_DESC = "cancelledReasonBytes_DESC",
+  cancelledReasonBytes_DESC_NULLS_FIRST = "cancelledReasonBytes_DESC_NULLS_FIRST",
+  cancelledReasonBytes_DESC_NULLS_LAST = "cancelledReasonBytes_DESC_NULLS_LAST",
+  cancelledReason_ASC = "cancelledReason_ASC",
+  cancelledReason_ASC_NULLS_FIRST = "cancelledReason_ASC_NULLS_FIRST",
+  cancelledReason_ASC_NULLS_LAST = "cancelledReason_ASC_NULLS_LAST",
+  cancelledReason_DESC = "cancelledReason_DESC",
+  cancelledReason_DESC_NULLS_FIRST = "cancelledReason_DESC_NULLS_FIRST",
+  cancelledReason_DESC_NULLS_LAST = "cancelledReason_DESC_NULLS_LAST",
+  cancelledTxn_blockNumber_ASC = "cancelledTxn_blockNumber_ASC",
+  cancelledTxn_blockNumber_ASC_NULLS_FIRST = "cancelledTxn_blockNumber_ASC_NULLS_FIRST",
+  cancelledTxn_blockNumber_ASC_NULLS_LAST = "cancelledTxn_blockNumber_ASC_NULLS_LAST",
+  cancelledTxn_blockNumber_DESC = "cancelledTxn_blockNumber_DESC",
+  cancelledTxn_blockNumber_DESC_NULLS_FIRST = "cancelledTxn_blockNumber_DESC_NULLS_FIRST",
+  cancelledTxn_blockNumber_DESC_NULLS_LAST = "cancelledTxn_blockNumber_DESC_NULLS_LAST",
+  cancelledTxn_chainId_ASC = "cancelledTxn_chainId_ASC",
+  cancelledTxn_chainId_ASC_NULLS_FIRST = "cancelledTxn_chainId_ASC_NULLS_FIRST",
+  cancelledTxn_chainId_ASC_NULLS_LAST = "cancelledTxn_chainId_ASC_NULLS_LAST",
+  cancelledTxn_chainId_DESC = "cancelledTxn_chainId_DESC",
+  cancelledTxn_chainId_DESC_NULLS_FIRST = "cancelledTxn_chainId_DESC_NULLS_FIRST",
+  cancelledTxn_chainId_DESC_NULLS_LAST = "cancelledTxn_chainId_DESC_NULLS_LAST",
+  cancelledTxn_from_ASC = "cancelledTxn_from_ASC",
+  cancelledTxn_from_ASC_NULLS_FIRST = "cancelledTxn_from_ASC_NULLS_FIRST",
+  cancelledTxn_from_ASC_NULLS_LAST = "cancelledTxn_from_ASC_NULLS_LAST",
+  cancelledTxn_from_DESC = "cancelledTxn_from_DESC",
+  cancelledTxn_from_DESC_NULLS_FIRST = "cancelledTxn_from_DESC_NULLS_FIRST",
+  cancelledTxn_from_DESC_NULLS_LAST = "cancelledTxn_from_DESC_NULLS_LAST",
+  cancelledTxn_hash_ASC = "cancelledTxn_hash_ASC",
+  cancelledTxn_hash_ASC_NULLS_FIRST = "cancelledTxn_hash_ASC_NULLS_FIRST",
+  cancelledTxn_hash_ASC_NULLS_LAST = "cancelledTxn_hash_ASC_NULLS_LAST",
+  cancelledTxn_hash_DESC = "cancelledTxn_hash_DESC",
+  cancelledTxn_hash_DESC_NULLS_FIRST = "cancelledTxn_hash_DESC_NULLS_FIRST",
+  cancelledTxn_hash_DESC_NULLS_LAST = "cancelledTxn_hash_DESC_NULLS_LAST",
+  cancelledTxn_id_ASC = "cancelledTxn_id_ASC",
+  cancelledTxn_id_ASC_NULLS_FIRST = "cancelledTxn_id_ASC_NULLS_FIRST",
+  cancelledTxn_id_ASC_NULLS_LAST = "cancelledTxn_id_ASC_NULLS_LAST",
+  cancelledTxn_id_DESC = "cancelledTxn_id_DESC",
+  cancelledTxn_id_DESC_NULLS_FIRST = "cancelledTxn_id_DESC_NULLS_FIRST",
+  cancelledTxn_id_DESC_NULLS_LAST = "cancelledTxn_id_DESC_NULLS_LAST",
+  cancelledTxn_timestamp_ASC = "cancelledTxn_timestamp_ASC",
+  cancelledTxn_timestamp_ASC_NULLS_FIRST = "cancelledTxn_timestamp_ASC_NULLS_FIRST",
+  cancelledTxn_timestamp_ASC_NULLS_LAST = "cancelledTxn_timestamp_ASC_NULLS_LAST",
+  cancelledTxn_timestamp_DESC = "cancelledTxn_timestamp_DESC",
+  cancelledTxn_timestamp_DESC_NULLS_FIRST = "cancelledTxn_timestamp_DESC_NULLS_FIRST",
+  cancelledTxn_timestamp_DESC_NULLS_LAST = "cancelledTxn_timestamp_DESC_NULLS_LAST",
+  cancelledTxn_to_ASC = "cancelledTxn_to_ASC",
+  cancelledTxn_to_ASC_NULLS_FIRST = "cancelledTxn_to_ASC_NULLS_FIRST",
+  cancelledTxn_to_ASC_NULLS_LAST = "cancelledTxn_to_ASC_NULLS_LAST",
+  cancelledTxn_to_DESC = "cancelledTxn_to_DESC",
+  cancelledTxn_to_DESC_NULLS_FIRST = "cancelledTxn_to_DESC_NULLS_FIRST",
+  cancelledTxn_to_DESC_NULLS_LAST = "cancelledTxn_to_DESC_NULLS_LAST",
+  cancelledTxn_transactionIndex_ASC = "cancelledTxn_transactionIndex_ASC",
+  cancelledTxn_transactionIndex_ASC_NULLS_FIRST = "cancelledTxn_transactionIndex_ASC_NULLS_FIRST",
+  cancelledTxn_transactionIndex_ASC_NULLS_LAST = "cancelledTxn_transactionIndex_ASC_NULLS_LAST",
+  cancelledTxn_transactionIndex_DESC = "cancelledTxn_transactionIndex_DESC",
+  cancelledTxn_transactionIndex_DESC_NULLS_FIRST = "cancelledTxn_transactionIndex_DESC_NULLS_FIRST",
+  cancelledTxn_transactionIndex_DESC_NULLS_LAST = "cancelledTxn_transactionIndex_DESC_NULLS_LAST",
+  createdTxn_blockNumber_ASC = "createdTxn_blockNumber_ASC",
+  createdTxn_blockNumber_ASC_NULLS_FIRST = "createdTxn_blockNumber_ASC_NULLS_FIRST",
+  createdTxn_blockNumber_ASC_NULLS_LAST = "createdTxn_blockNumber_ASC_NULLS_LAST",
+  createdTxn_blockNumber_DESC = "createdTxn_blockNumber_DESC",
+  createdTxn_blockNumber_DESC_NULLS_FIRST = "createdTxn_blockNumber_DESC_NULLS_FIRST",
+  createdTxn_blockNumber_DESC_NULLS_LAST = "createdTxn_blockNumber_DESC_NULLS_LAST",
+  createdTxn_chainId_ASC = "createdTxn_chainId_ASC",
+  createdTxn_chainId_ASC_NULLS_FIRST = "createdTxn_chainId_ASC_NULLS_FIRST",
+  createdTxn_chainId_ASC_NULLS_LAST = "createdTxn_chainId_ASC_NULLS_LAST",
+  createdTxn_chainId_DESC = "createdTxn_chainId_DESC",
+  createdTxn_chainId_DESC_NULLS_FIRST = "createdTxn_chainId_DESC_NULLS_FIRST",
+  createdTxn_chainId_DESC_NULLS_LAST = "createdTxn_chainId_DESC_NULLS_LAST",
+  createdTxn_from_ASC = "createdTxn_from_ASC",
+  createdTxn_from_ASC_NULLS_FIRST = "createdTxn_from_ASC_NULLS_FIRST",
+  createdTxn_from_ASC_NULLS_LAST = "createdTxn_from_ASC_NULLS_LAST",
+  createdTxn_from_DESC = "createdTxn_from_DESC",
+  createdTxn_from_DESC_NULLS_FIRST = "createdTxn_from_DESC_NULLS_FIRST",
+  createdTxn_from_DESC_NULLS_LAST = "createdTxn_from_DESC_NULLS_LAST",
+  createdTxn_hash_ASC = "createdTxn_hash_ASC",
+  createdTxn_hash_ASC_NULLS_FIRST = "createdTxn_hash_ASC_NULLS_FIRST",
+  createdTxn_hash_ASC_NULLS_LAST = "createdTxn_hash_ASC_NULLS_LAST",
+  createdTxn_hash_DESC = "createdTxn_hash_DESC",
+  createdTxn_hash_DESC_NULLS_FIRST = "createdTxn_hash_DESC_NULLS_FIRST",
+  createdTxn_hash_DESC_NULLS_LAST = "createdTxn_hash_DESC_NULLS_LAST",
+  createdTxn_id_ASC = "createdTxn_id_ASC",
+  createdTxn_id_ASC_NULLS_FIRST = "createdTxn_id_ASC_NULLS_FIRST",
+  createdTxn_id_ASC_NULLS_LAST = "createdTxn_id_ASC_NULLS_LAST",
+  createdTxn_id_DESC = "createdTxn_id_DESC",
+  createdTxn_id_DESC_NULLS_FIRST = "createdTxn_id_DESC_NULLS_FIRST",
+  createdTxn_id_DESC_NULLS_LAST = "createdTxn_id_DESC_NULLS_LAST",
+  createdTxn_timestamp_ASC = "createdTxn_timestamp_ASC",
+  createdTxn_timestamp_ASC_NULLS_FIRST = "createdTxn_timestamp_ASC_NULLS_FIRST",
+  createdTxn_timestamp_ASC_NULLS_LAST = "createdTxn_timestamp_ASC_NULLS_LAST",
+  createdTxn_timestamp_DESC = "createdTxn_timestamp_DESC",
+  createdTxn_timestamp_DESC_NULLS_FIRST = "createdTxn_timestamp_DESC_NULLS_FIRST",
+  createdTxn_timestamp_DESC_NULLS_LAST = "createdTxn_timestamp_DESC_NULLS_LAST",
+  createdTxn_to_ASC = "createdTxn_to_ASC",
+  createdTxn_to_ASC_NULLS_FIRST = "createdTxn_to_ASC_NULLS_FIRST",
+  createdTxn_to_ASC_NULLS_LAST = "createdTxn_to_ASC_NULLS_LAST",
+  createdTxn_to_DESC = "createdTxn_to_DESC",
+  createdTxn_to_DESC_NULLS_FIRST = "createdTxn_to_DESC_NULLS_FIRST",
+  createdTxn_to_DESC_NULLS_LAST = "createdTxn_to_DESC_NULLS_LAST",
+  createdTxn_transactionIndex_ASC = "createdTxn_transactionIndex_ASC",
+  createdTxn_transactionIndex_ASC_NULLS_FIRST = "createdTxn_transactionIndex_ASC_NULLS_FIRST",
+  createdTxn_transactionIndex_ASC_NULLS_LAST = "createdTxn_transactionIndex_ASC_NULLS_LAST",
+  createdTxn_transactionIndex_DESC = "createdTxn_transactionIndex_DESC",
+  createdTxn_transactionIndex_DESC_NULLS_FIRST = "createdTxn_transactionIndex_DESC_NULLS_FIRST",
+  createdTxn_transactionIndex_DESC_NULLS_LAST = "createdTxn_transactionIndex_DESC_NULLS_LAST",
+  executedTxn_blockNumber_ASC = "executedTxn_blockNumber_ASC",
+  executedTxn_blockNumber_ASC_NULLS_FIRST = "executedTxn_blockNumber_ASC_NULLS_FIRST",
+  executedTxn_blockNumber_ASC_NULLS_LAST = "executedTxn_blockNumber_ASC_NULLS_LAST",
+  executedTxn_blockNumber_DESC = "executedTxn_blockNumber_DESC",
+  executedTxn_blockNumber_DESC_NULLS_FIRST = "executedTxn_blockNumber_DESC_NULLS_FIRST",
+  executedTxn_blockNumber_DESC_NULLS_LAST = "executedTxn_blockNumber_DESC_NULLS_LAST",
+  executedTxn_chainId_ASC = "executedTxn_chainId_ASC",
+  executedTxn_chainId_ASC_NULLS_FIRST = "executedTxn_chainId_ASC_NULLS_FIRST",
+  executedTxn_chainId_ASC_NULLS_LAST = "executedTxn_chainId_ASC_NULLS_LAST",
+  executedTxn_chainId_DESC = "executedTxn_chainId_DESC",
+  executedTxn_chainId_DESC_NULLS_FIRST = "executedTxn_chainId_DESC_NULLS_FIRST",
+  executedTxn_chainId_DESC_NULLS_LAST = "executedTxn_chainId_DESC_NULLS_LAST",
+  executedTxn_from_ASC = "executedTxn_from_ASC",
+  executedTxn_from_ASC_NULLS_FIRST = "executedTxn_from_ASC_NULLS_FIRST",
+  executedTxn_from_ASC_NULLS_LAST = "executedTxn_from_ASC_NULLS_LAST",
+  executedTxn_from_DESC = "executedTxn_from_DESC",
+  executedTxn_from_DESC_NULLS_FIRST = "executedTxn_from_DESC_NULLS_FIRST",
+  executedTxn_from_DESC_NULLS_LAST = "executedTxn_from_DESC_NULLS_LAST",
+  executedTxn_hash_ASC = "executedTxn_hash_ASC",
+  executedTxn_hash_ASC_NULLS_FIRST = "executedTxn_hash_ASC_NULLS_FIRST",
+  executedTxn_hash_ASC_NULLS_LAST = "executedTxn_hash_ASC_NULLS_LAST",
+  executedTxn_hash_DESC = "executedTxn_hash_DESC",
+  executedTxn_hash_DESC_NULLS_FIRST = "executedTxn_hash_DESC_NULLS_FIRST",
+  executedTxn_hash_DESC_NULLS_LAST = "executedTxn_hash_DESC_NULLS_LAST",
+  executedTxn_id_ASC = "executedTxn_id_ASC",
+  executedTxn_id_ASC_NULLS_FIRST = "executedTxn_id_ASC_NULLS_FIRST",
+  executedTxn_id_ASC_NULLS_LAST = "executedTxn_id_ASC_NULLS_LAST",
+  executedTxn_id_DESC = "executedTxn_id_DESC",
+  executedTxn_id_DESC_NULLS_FIRST = "executedTxn_id_DESC_NULLS_FIRST",
+  executedTxn_id_DESC_NULLS_LAST = "executedTxn_id_DESC_NULLS_LAST",
+  executedTxn_timestamp_ASC = "executedTxn_timestamp_ASC",
+  executedTxn_timestamp_ASC_NULLS_FIRST = "executedTxn_timestamp_ASC_NULLS_FIRST",
+  executedTxn_timestamp_ASC_NULLS_LAST = "executedTxn_timestamp_ASC_NULLS_LAST",
+  executedTxn_timestamp_DESC = "executedTxn_timestamp_DESC",
+  executedTxn_timestamp_DESC_NULLS_FIRST = "executedTxn_timestamp_DESC_NULLS_FIRST",
+  executedTxn_timestamp_DESC_NULLS_LAST = "executedTxn_timestamp_DESC_NULLS_LAST",
+  executedTxn_to_ASC = "executedTxn_to_ASC",
+  executedTxn_to_ASC_NULLS_FIRST = "executedTxn_to_ASC_NULLS_FIRST",
+  executedTxn_to_ASC_NULLS_LAST = "executedTxn_to_ASC_NULLS_LAST",
+  executedTxn_to_DESC = "executedTxn_to_DESC",
+  executedTxn_to_DESC_NULLS_FIRST = "executedTxn_to_DESC_NULLS_FIRST",
+  executedTxn_to_DESC_NULLS_LAST = "executedTxn_to_DESC_NULLS_LAST",
+  executedTxn_transactionIndex_ASC = "executedTxn_transactionIndex_ASC",
+  executedTxn_transactionIndex_ASC_NULLS_FIRST = "executedTxn_transactionIndex_ASC_NULLS_FIRST",
+  executedTxn_transactionIndex_ASC_NULLS_LAST = "executedTxn_transactionIndex_ASC_NULLS_LAST",
+  executedTxn_transactionIndex_DESC = "executedTxn_transactionIndex_DESC",
+  executedTxn_transactionIndex_DESC_NULLS_FIRST = "executedTxn_transactionIndex_DESC_NULLS_FIRST",
+  executedTxn_transactionIndex_DESC_NULLS_LAST = "executedTxn_transactionIndex_DESC_NULLS_LAST",
+  executionFee_ASC = "executionFee_ASC",
+  executionFee_ASC_NULLS_FIRST = "executionFee_ASC_NULLS_FIRST",
+  executionFee_ASC_NULLS_LAST = "executionFee_ASC_NULLS_LAST",
+  executionFee_DESC = "executionFee_DESC",
+  executionFee_DESC_NULLS_FIRST = "executionFee_DESC_NULLS_FIRST",
+  executionFee_DESC_NULLS_LAST = "executionFee_DESC_NULLS_LAST",
+  frozenReasonBytes_ASC = "frozenReasonBytes_ASC",
+  frozenReasonBytes_ASC_NULLS_FIRST = "frozenReasonBytes_ASC_NULLS_FIRST",
+  frozenReasonBytes_ASC_NULLS_LAST = "frozenReasonBytes_ASC_NULLS_LAST",
+  frozenReasonBytes_DESC = "frozenReasonBytes_DESC",
+  frozenReasonBytes_DESC_NULLS_FIRST = "frozenReasonBytes_DESC_NULLS_FIRST",
+  frozenReasonBytes_DESC_NULLS_LAST = "frozenReasonBytes_DESC_NULLS_LAST",
+  frozenReason_ASC = "frozenReason_ASC",
+  frozenReason_ASC_NULLS_FIRST = "frozenReason_ASC_NULLS_FIRST",
+  frozenReason_ASC_NULLS_LAST = "frozenReason_ASC_NULLS_LAST",
+  frozenReason_DESC = "frozenReason_DESC",
+  frozenReason_DESC_NULLS_FIRST = "frozenReason_DESC_NULLS_FIRST",
+  frozenReason_DESC_NULLS_LAST = "frozenReason_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  initialCollateralDeltaAmount_ASC = "initialCollateralDeltaAmount_ASC",
+  initialCollateralDeltaAmount_ASC_NULLS_FIRST = "initialCollateralDeltaAmount_ASC_NULLS_FIRST",
+  initialCollateralDeltaAmount_ASC_NULLS_LAST = "initialCollateralDeltaAmount_ASC_NULLS_LAST",
+  initialCollateralDeltaAmount_DESC = "initialCollateralDeltaAmount_DESC",
+  initialCollateralDeltaAmount_DESC_NULLS_FIRST = "initialCollateralDeltaAmount_DESC_NULLS_FIRST",
+  initialCollateralDeltaAmount_DESC_NULLS_LAST = "initialCollateralDeltaAmount_DESC_NULLS_LAST",
+  initialCollateralTokenAddress_ASC = "initialCollateralTokenAddress_ASC",
+  initialCollateralTokenAddress_ASC_NULLS_FIRST = "initialCollateralTokenAddress_ASC_NULLS_FIRST",
+  initialCollateralTokenAddress_ASC_NULLS_LAST = "initialCollateralTokenAddress_ASC_NULLS_LAST",
+  initialCollateralTokenAddress_DESC = "initialCollateralTokenAddress_DESC",
+  initialCollateralTokenAddress_DESC_NULLS_FIRST = "initialCollateralTokenAddress_DESC_NULLS_FIRST",
+  initialCollateralTokenAddress_DESC_NULLS_LAST = "initialCollateralTokenAddress_DESC_NULLS_LAST",
+  isLong_ASC = "isLong_ASC",
+  isLong_ASC_NULLS_FIRST = "isLong_ASC_NULLS_FIRST",
+  isLong_ASC_NULLS_LAST = "isLong_ASC_NULLS_LAST",
+  isLong_DESC = "isLong_DESC",
+  isLong_DESC_NULLS_FIRST = "isLong_DESC_NULLS_FIRST",
+  isLong_DESC_NULLS_LAST = "isLong_DESC_NULLS_LAST",
+  marketAddress_ASC = "marketAddress_ASC",
+  marketAddress_ASC_NULLS_FIRST = "marketAddress_ASC_NULLS_FIRST",
+  marketAddress_ASC_NULLS_LAST = "marketAddress_ASC_NULLS_LAST",
+  marketAddress_DESC = "marketAddress_DESC",
+  marketAddress_DESC_NULLS_FIRST = "marketAddress_DESC_NULLS_FIRST",
+  marketAddress_DESC_NULLS_LAST = "marketAddress_DESC_NULLS_LAST",
+  minOutputAmount_ASC = "minOutputAmount_ASC",
+  minOutputAmount_ASC_NULLS_FIRST = "minOutputAmount_ASC_NULLS_FIRST",
+  minOutputAmount_ASC_NULLS_LAST = "minOutputAmount_ASC_NULLS_LAST",
+  minOutputAmount_DESC = "minOutputAmount_DESC",
+  minOutputAmount_DESC_NULLS_FIRST = "minOutputAmount_DESC_NULLS_FIRST",
+  minOutputAmount_DESC_NULLS_LAST = "minOutputAmount_DESC_NULLS_LAST",
+  numberOfParts_ASC = "numberOfParts_ASC",
+  numberOfParts_ASC_NULLS_FIRST = "numberOfParts_ASC_NULLS_FIRST",
+  numberOfParts_ASC_NULLS_LAST = "numberOfParts_ASC_NULLS_LAST",
+  numberOfParts_DESC = "numberOfParts_DESC",
+  numberOfParts_DESC_NULLS_FIRST = "numberOfParts_DESC_NULLS_FIRST",
+  numberOfParts_DESC_NULLS_LAST = "numberOfParts_DESC_NULLS_LAST",
+  orderType_ASC = "orderType_ASC",
+  orderType_ASC_NULLS_FIRST = "orderType_ASC_NULLS_FIRST",
+  orderType_ASC_NULLS_LAST = "orderType_ASC_NULLS_LAST",
+  orderType_DESC = "orderType_DESC",
+  orderType_DESC_NULLS_FIRST = "orderType_DESC_NULLS_FIRST",
+  orderType_DESC_NULLS_LAST = "orderType_DESC_NULLS_LAST",
+  receiver_ASC = "receiver_ASC",
+  receiver_ASC_NULLS_FIRST = "receiver_ASC_NULLS_FIRST",
+  receiver_ASC_NULLS_LAST = "receiver_ASC_NULLS_LAST",
+  receiver_DESC = "receiver_DESC",
+  receiver_DESC_NULLS_FIRST = "receiver_DESC_NULLS_FIRST",
+  receiver_DESC_NULLS_LAST = "receiver_DESC_NULLS_LAST",
+  shouldUnwrapNativeToken_ASC = "shouldUnwrapNativeToken_ASC",
+  shouldUnwrapNativeToken_ASC_NULLS_FIRST = "shouldUnwrapNativeToken_ASC_NULLS_FIRST",
+  shouldUnwrapNativeToken_ASC_NULLS_LAST = "shouldUnwrapNativeToken_ASC_NULLS_LAST",
+  shouldUnwrapNativeToken_DESC = "shouldUnwrapNativeToken_DESC",
+  shouldUnwrapNativeToken_DESC_NULLS_FIRST = "shouldUnwrapNativeToken_DESC_NULLS_FIRST",
+  shouldUnwrapNativeToken_DESC_NULLS_LAST = "shouldUnwrapNativeToken_DESC_NULLS_LAST",
+  sizeDeltaUsd_ASC = "sizeDeltaUsd_ASC",
+  sizeDeltaUsd_ASC_NULLS_FIRST = "sizeDeltaUsd_ASC_NULLS_FIRST",
+  sizeDeltaUsd_ASC_NULLS_LAST = "sizeDeltaUsd_ASC_NULLS_LAST",
+  sizeDeltaUsd_DESC = "sizeDeltaUsd_DESC",
+  sizeDeltaUsd_DESC_NULLS_FIRST = "sizeDeltaUsd_DESC_NULLS_FIRST",
+  sizeDeltaUsd_DESC_NULLS_LAST = "sizeDeltaUsd_DESC_NULLS_LAST",
+  srcChainId_ASC = "srcChainId_ASC",
+  srcChainId_ASC_NULLS_FIRST = "srcChainId_ASC_NULLS_FIRST",
+  srcChainId_ASC_NULLS_LAST = "srcChainId_ASC_NULLS_LAST",
+  srcChainId_DESC = "srcChainId_DESC",
+  srcChainId_DESC_NULLS_FIRST = "srcChainId_DESC_NULLS_FIRST",
+  srcChainId_DESC_NULLS_LAST = "srcChainId_DESC_NULLS_LAST",
+  status_ASC = "status_ASC",
+  status_ASC_NULLS_FIRST = "status_ASC_NULLS_FIRST",
+  status_ASC_NULLS_LAST = "status_ASC_NULLS_LAST",
+  status_DESC = "status_DESC",
+  status_DESC_NULLS_FIRST = "status_DESC_NULLS_FIRST",
+  status_DESC_NULLS_LAST = "status_DESC_NULLS_LAST",
+  triggerPrice_ASC = "triggerPrice_ASC",
+  triggerPrice_ASC_NULLS_FIRST = "triggerPrice_ASC_NULLS_FIRST",
+  triggerPrice_ASC_NULLS_LAST = "triggerPrice_ASC_NULLS_LAST",
+  triggerPrice_DESC = "triggerPrice_DESC",
+  triggerPrice_DESC_NULLS_FIRST = "triggerPrice_DESC_NULLS_FIRST",
+  triggerPrice_DESC_NULLS_LAST = "triggerPrice_DESC_NULLS_LAST",
+  twapGroupId_ASC = "twapGroupId_ASC",
+  twapGroupId_ASC_NULLS_FIRST = "twapGroupId_ASC_NULLS_FIRST",
+  twapGroupId_ASC_NULLS_LAST = "twapGroupId_ASC_NULLS_LAST",
+  twapGroupId_DESC = "twapGroupId_DESC",
+  twapGroupId_DESC_NULLS_FIRST = "twapGroupId_DESC_NULLS_FIRST",
+  twapGroupId_DESC_NULLS_LAST = "twapGroupId_DESC_NULLS_LAST",
+  uiFeeReceiver_ASC = "uiFeeReceiver_ASC",
+  uiFeeReceiver_ASC_NULLS_FIRST = "uiFeeReceiver_ASC_NULLS_FIRST",
+  uiFeeReceiver_ASC_NULLS_LAST = "uiFeeReceiver_ASC_NULLS_LAST",
+  uiFeeReceiver_DESC = "uiFeeReceiver_DESC",
+  uiFeeReceiver_DESC_NULLS_FIRST = "uiFeeReceiver_DESC_NULLS_FIRST",
+  uiFeeReceiver_DESC_NULLS_LAST = "uiFeeReceiver_DESC_NULLS_LAST",
+  updatedAtBlock_ASC = "updatedAtBlock_ASC",
+  updatedAtBlock_ASC_NULLS_FIRST = "updatedAtBlock_ASC_NULLS_FIRST",
+  updatedAtBlock_ASC_NULLS_LAST = "updatedAtBlock_ASC_NULLS_LAST",
+  updatedAtBlock_DESC = "updatedAtBlock_DESC",
+  updatedAtBlock_DESC_NULLS_FIRST = "updatedAtBlock_DESC_NULLS_FIRST",
+  updatedAtBlock_DESC_NULLS_LAST = "updatedAtBlock_DESC_NULLS_LAST",
+}
+
+export enum OrderStatus {
+  Cancelled = "Cancelled",
+  Created = "Created",
+  Executed = "Executed",
+  Frozen = "Frozen",
+}
+
+export interface OrderWhereInput {
+  AND?: InputMaybe<Array<OrderWhereInput>>;
+  OR?: InputMaybe<Array<OrderWhereInput>>;
+  acceptablePrice_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  acceptablePrice_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  acceptablePrice_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  acceptablePrice_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  acceptablePrice_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  acceptablePrice_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  acceptablePrice_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  acceptablePrice_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  acceptablePrice_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  account_contains?: InputMaybe<Scalars["String"]["input"]>;
+  account_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  account_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_eq?: InputMaybe<Scalars["String"]["input"]>;
+  account_gt?: InputMaybe<Scalars["String"]["input"]>;
+  account_gte?: InputMaybe<Scalars["String"]["input"]>;
+  account_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  account_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  account_lt?: InputMaybe<Scalars["String"]["input"]>;
+  account_lte?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  account_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  callbackContract_contains?: InputMaybe<Scalars["String"]["input"]>;
+  callbackContract_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  callbackContract_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  callbackContract_eq?: InputMaybe<Scalars["String"]["input"]>;
+  callbackContract_gt?: InputMaybe<Scalars["String"]["input"]>;
+  callbackContract_gte?: InputMaybe<Scalars["String"]["input"]>;
+  callbackContract_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  callbackContract_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  callbackContract_lt?: InputMaybe<Scalars["String"]["input"]>;
+  callbackContract_lte?: InputMaybe<Scalars["String"]["input"]>;
+  callbackContract_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  callbackContract_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  callbackContract_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  callbackContract_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  callbackContract_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  callbackContract_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  callbackContract_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  callbackGasLimit_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  callbackGasLimit_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  callbackGasLimit_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  callbackGasLimit_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  callbackGasLimit_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  callbackGasLimit_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  callbackGasLimit_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  callbackGasLimit_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  callbackGasLimit_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  cancelledReasonBytes_contains?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReasonBytes_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReasonBytes_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReasonBytes_eq?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReasonBytes_gt?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReasonBytes_gte?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReasonBytes_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  cancelledReasonBytes_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  cancelledReasonBytes_lt?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReasonBytes_lte?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReasonBytes_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReasonBytes_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReasonBytes_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReasonBytes_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReasonBytes_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  cancelledReasonBytes_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReasonBytes_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReason_contains?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReason_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReason_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReason_eq?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReason_gt?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReason_gte?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReason_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  cancelledReason_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  cancelledReason_lt?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReason_lte?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReason_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReason_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReason_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReason_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReason_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  cancelledReason_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledReason_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  cancelledTxn?: InputMaybe<TransactionWhereInput>;
+  cancelledTxn_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  createdTxn?: InputMaybe<TransactionWhereInput>;
+  createdTxn_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  executedTxn?: InputMaybe<TransactionWhereInput>;
+  executedTxn_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  executionFee_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionFee_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionFee_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionFee_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  executionFee_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  executionFee_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionFee_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionFee_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionFee_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  frozenReasonBytes_contains?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReasonBytes_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReasonBytes_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReasonBytes_eq?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReasonBytes_gt?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReasonBytes_gte?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReasonBytes_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  frozenReasonBytes_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  frozenReasonBytes_lt?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReasonBytes_lte?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReasonBytes_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReasonBytes_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReasonBytes_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReasonBytes_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReasonBytes_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  frozenReasonBytes_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReasonBytes_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReason_contains?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReason_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReason_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReason_eq?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReason_gt?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReason_gte?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReason_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  frozenReason_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  frozenReason_lt?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReason_lte?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReason_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReason_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReason_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReason_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReason_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  frozenReason_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  frozenReason_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralDeltaAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  initialCollateralDeltaAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  initialCollateralDeltaAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  initialCollateralDeltaAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  initialCollateralDeltaAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  initialCollateralDeltaAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  initialCollateralDeltaAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  initialCollateralDeltaAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  initialCollateralDeltaAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  initialCollateralTokenAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  initialCollateralTokenAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  initialCollateralTokenAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  initialCollateralTokenAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  isLong_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isLong_not_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  marketAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  marketAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  minOutputAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minOutputAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minOutputAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minOutputAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  minOutputAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  minOutputAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minOutputAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minOutputAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minOutputAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  numberOfParts_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  numberOfParts_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  numberOfParts_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  numberOfParts_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  numberOfParts_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  numberOfParts_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  numberOfParts_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  numberOfParts_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  numberOfParts_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  orderType_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  orderType_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  orderType_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  orderType_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  orderType_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  orderType_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  orderType_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  orderType_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  orderType_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  receiver_contains?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_eq?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_gt?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_gte?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  receiver_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  receiver_lt?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_lte?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  receiver_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  shouldUnwrapNativeToken_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  shouldUnwrapNativeToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  shouldUnwrapNativeToken_not_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  sizeDeltaUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  sizeDeltaUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  sizeDeltaUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  srcChainId_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  srcChainId_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  srcChainId_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  srcChainId_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  srcChainId_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  srcChainId_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  srcChainId_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  srcChainId_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  srcChainId_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  status_eq?: InputMaybe<OrderStatus>;
+  status_in?: InputMaybe<Array<OrderStatus>>;
+  status_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  status_not_eq?: InputMaybe<OrderStatus>;
+  status_not_in?: InputMaybe<Array<OrderStatus>>;
+  swapPath_containsAll?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  swapPath_containsAny?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  swapPath_containsNone?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  swapPath_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  triggerPrice_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  triggerPrice_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  triggerPrice_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  triggerPrice_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  triggerPrice_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  triggerPrice_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  triggerPrice_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  triggerPrice_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  triggerPrice_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  twapGroupId_contains?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_eq?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_gt?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_gte?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  twapGroupId_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  twapGroupId_lt?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_lte?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  twapGroupId_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_contains?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_eq?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_gt?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_gte?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  uiFeeReceiver_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  uiFeeReceiver_lt?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_lte?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  uiFeeReceiver_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  updatedAtBlock_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  updatedAtBlock_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  updatedAtBlock_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  updatedAtBlock_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  updatedAtBlock_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  updatedAtBlock_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  updatedAtBlock_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  updatedAtBlock_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  updatedAtBlock_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+}
+
+export interface OrdersConnection {
+  __typename?: "OrdersConnection";
+  edges: Array<OrderEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface PageInfo {
+  __typename?: "PageInfo";
+  endCursor: Scalars["String"]["output"];
+  hasNextPage: Scalars["Boolean"]["output"];
+  hasPreviousPage: Scalars["Boolean"]["output"];
+  startCursor: Scalars["String"]["output"];
+}
+
+export interface PerformanceSnapshotObject {
+  __typename?: "PerformanceSnapshotObject";
+  snapshotTimestamp: Scalars["String"]["output"];
+  uniswapV2Performance: Scalars["String"]["output"];
+}
+
+export interface PerformanceSnapshots {
+  __typename?: "PerformanceSnapshots";
+  address: Scalars["String"]["output"];
+  entity: Scalars["String"]["output"];
+  snapshots: Array<PerformanceSnapshotObject>;
+}
+
+export interface PerformanceWhereInput {
+  addresses?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  period: Scalars["String"]["input"];
+}
+
+export interface PeriodAccountStatObject {
+  __typename?: "PeriodAccountStatObject";
+  closedCount: Scalars["Float"]["output"];
+  cumsumCollateral: Scalars["BigInt"]["output"];
+  cumsumSize: Scalars["BigInt"]["output"];
+  id: Scalars["ID"]["output"];
+  losses: Scalars["Float"]["output"];
+  maxCapital: Scalars["BigInt"]["output"];
+  netCapital: Scalars["BigInt"]["output"];
+  realizedFees: Scalars["BigInt"]["output"];
+  realizedPnl: Scalars["BigInt"]["output"];
+  realizedPriceImpact: Scalars["BigInt"]["output"];
+  startUnrealizedFees: Scalars["BigInt"]["output"];
+  startUnrealizedPnl: Scalars["BigInt"]["output"];
+  startUnrealizedPriceImpact: Scalars["BigInt"]["output"];
+  sumMaxSize: Scalars["BigInt"]["output"];
+  volume: Scalars["BigInt"]["output"];
+  wins: Scalars["Float"]["output"];
+}
+
+export interface PnlAprSnapshot {
+  __typename?: "PnlAprSnapshot";
+  address: Scalars["String"]["output"];
+  apr: Scalars["BigInt"]["output"];
+  entityType: EntityType;
+  id: Scalars["String"]["output"];
+  snapshotTimestamp: Scalars["Int"]["output"];
+}
+
+export interface PnlAprSnapshotEdge {
+  __typename?: "PnlAprSnapshotEdge";
+  cursor: Scalars["String"]["output"];
+  node: PnlAprSnapshot;
+}
+
+export enum PnlAprSnapshotOrderByInput {
+  address_ASC = "address_ASC",
+  address_ASC_NULLS_FIRST = "address_ASC_NULLS_FIRST",
+  address_ASC_NULLS_LAST = "address_ASC_NULLS_LAST",
+  address_DESC = "address_DESC",
+  address_DESC_NULLS_FIRST = "address_DESC_NULLS_FIRST",
+  address_DESC_NULLS_LAST = "address_DESC_NULLS_LAST",
+  apr_ASC = "apr_ASC",
+  apr_ASC_NULLS_FIRST = "apr_ASC_NULLS_FIRST",
+  apr_ASC_NULLS_LAST = "apr_ASC_NULLS_LAST",
+  apr_DESC = "apr_DESC",
+  apr_DESC_NULLS_FIRST = "apr_DESC_NULLS_FIRST",
+  apr_DESC_NULLS_LAST = "apr_DESC_NULLS_LAST",
+  entityType_ASC = "entityType_ASC",
+  entityType_ASC_NULLS_FIRST = "entityType_ASC_NULLS_FIRST",
+  entityType_ASC_NULLS_LAST = "entityType_ASC_NULLS_LAST",
+  entityType_DESC = "entityType_DESC",
+  entityType_DESC_NULLS_FIRST = "entityType_DESC_NULLS_FIRST",
+  entityType_DESC_NULLS_LAST = "entityType_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  snapshotTimestamp_ASC = "snapshotTimestamp_ASC",
+  snapshotTimestamp_ASC_NULLS_FIRST = "snapshotTimestamp_ASC_NULLS_FIRST",
+  snapshotTimestamp_ASC_NULLS_LAST = "snapshotTimestamp_ASC_NULLS_LAST",
+  snapshotTimestamp_DESC = "snapshotTimestamp_DESC",
+  snapshotTimestamp_DESC_NULLS_FIRST = "snapshotTimestamp_DESC_NULLS_FIRST",
+  snapshotTimestamp_DESC_NULLS_LAST = "snapshotTimestamp_DESC_NULLS_LAST",
+}
+
+export interface PnlAprSnapshotWhereInput {
+  AND?: InputMaybe<Array<PnlAprSnapshotWhereInput>>;
+  OR?: InputMaybe<Array<PnlAprSnapshotWhereInput>>;
+  address_contains?: InputMaybe<Scalars["String"]["input"]>;
+  address_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  address_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_eq?: InputMaybe<Scalars["String"]["input"]>;
+  address_gt?: InputMaybe<Scalars["String"]["input"]>;
+  address_gte?: InputMaybe<Scalars["String"]["input"]>;
+  address_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  address_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  address_lt?: InputMaybe<Scalars["String"]["input"]>;
+  address_lte?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  address_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  address_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  address_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  apr_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  apr_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  apr_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  apr_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  apr_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  apr_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  apr_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  apr_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  apr_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  entityType_eq?: InputMaybe<EntityType>;
+  entityType_in?: InputMaybe<Array<EntityType>>;
+  entityType_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  entityType_not_eq?: InputMaybe<EntityType>;
+  entityType_not_in?: InputMaybe<Array<EntityType>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  snapshotTimestamp_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  snapshotTimestamp_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  snapshotTimestamp_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+}
+
+export interface PnlAprSnapshotsConnection {
+  __typename?: "PnlAprSnapshotsConnection";
+  edges: Array<PnlAprSnapshotEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface Position {
+  __typename?: "Position";
+  account: Scalars["String"]["output"];
+  accountStat: AccountStat;
+  collateralAmount: Scalars["BigInt"]["output"];
+  collateralToken: Scalars["String"]["output"];
+  entryPrice: Scalars["BigInt"]["output"];
+  id: Scalars["String"]["output"];
+  isLong: Scalars["Boolean"]["output"];
+  isSnapshot: Scalars["Boolean"]["output"];
+  market: Scalars["String"]["output"];
+  maxSize: Scalars["BigInt"]["output"];
+  openedAt: Scalars["Int"]["output"];
+  positionKey: Scalars["String"]["output"];
+  realizedFees: Scalars["BigInt"]["output"];
+  realizedPnl: Scalars["BigInt"]["output"];
+  realizedPriceImpact: Scalars["BigInt"]["output"];
+  sizeInTokens: Scalars["BigInt"]["output"];
+  sizeInUsd: Scalars["BigInt"]["output"];
+  snapshotTimestamp?: Maybe<Scalars["Int"]["output"]>;
+  unrealizedFees: Scalars["BigInt"]["output"];
+  unrealizedPnl: Scalars["BigInt"]["output"];
+  unrealizedPriceImpact: Scalars["BigInt"]["output"];
+}
+
+export interface PositionChange {
+  __typename?: "PositionChange";
+  account: Scalars["String"]["output"];
+  basePnlUsd: Scalars["BigInt"]["output"];
+  block: Scalars["Int"]["output"];
+  collateralAmount: Scalars["BigInt"]["output"];
+  collateralDeltaAmount: Scalars["BigInt"]["output"];
+  collateralToken: Scalars["String"]["output"];
+  collateralTokenPriceMin: Scalars["BigInt"]["output"];
+  executionPrice: Scalars["BigInt"]["output"];
+  feesAmount: Scalars["BigInt"]["output"];
+  id: Scalars["String"]["output"];
+  isLong: Scalars["Boolean"]["output"];
+  isWin?: Maybe<Scalars["Boolean"]["output"]>;
+  market: Scalars["String"]["output"];
+  maxSize: Scalars["BigInt"]["output"];
+  priceImpactAmount?: Maybe<Scalars["BigInt"]["output"]>;
+  priceImpactDiffUsd?: Maybe<Scalars["BigInt"]["output"]>;
+  priceImpactUsd: Scalars["BigInt"]["output"];
+  proportionalPendingImpactUsd?: Maybe<Scalars["BigInt"]["output"]>;
+  sizeDeltaUsd: Scalars["BigInt"]["output"];
+  sizeInUsd: Scalars["BigInt"]["output"];
+  timestamp: Scalars["Int"]["output"];
+  totalImpactUsd?: Maybe<Scalars["BigInt"]["output"]>;
+  type: PositionChangeType;
+}
+
+export interface PositionChangeEdge {
+  __typename?: "PositionChangeEdge";
+  cursor: Scalars["String"]["output"];
+  node: PositionChange;
+}
+
+export enum PositionChangeOrderByInput {
+  account_ASC = "account_ASC",
+  account_ASC_NULLS_FIRST = "account_ASC_NULLS_FIRST",
+  account_ASC_NULLS_LAST = "account_ASC_NULLS_LAST",
+  account_DESC = "account_DESC",
+  account_DESC_NULLS_FIRST = "account_DESC_NULLS_FIRST",
+  account_DESC_NULLS_LAST = "account_DESC_NULLS_LAST",
+  basePnlUsd_ASC = "basePnlUsd_ASC",
+  basePnlUsd_ASC_NULLS_FIRST = "basePnlUsd_ASC_NULLS_FIRST",
+  basePnlUsd_ASC_NULLS_LAST = "basePnlUsd_ASC_NULLS_LAST",
+  basePnlUsd_DESC = "basePnlUsd_DESC",
+  basePnlUsd_DESC_NULLS_FIRST = "basePnlUsd_DESC_NULLS_FIRST",
+  basePnlUsd_DESC_NULLS_LAST = "basePnlUsd_DESC_NULLS_LAST",
+  block_ASC = "block_ASC",
+  block_ASC_NULLS_FIRST = "block_ASC_NULLS_FIRST",
+  block_ASC_NULLS_LAST = "block_ASC_NULLS_LAST",
+  block_DESC = "block_DESC",
+  block_DESC_NULLS_FIRST = "block_DESC_NULLS_FIRST",
+  block_DESC_NULLS_LAST = "block_DESC_NULLS_LAST",
+  collateralAmount_ASC = "collateralAmount_ASC",
+  collateralAmount_ASC_NULLS_FIRST = "collateralAmount_ASC_NULLS_FIRST",
+  collateralAmount_ASC_NULLS_LAST = "collateralAmount_ASC_NULLS_LAST",
+  collateralAmount_DESC = "collateralAmount_DESC",
+  collateralAmount_DESC_NULLS_FIRST = "collateralAmount_DESC_NULLS_FIRST",
+  collateralAmount_DESC_NULLS_LAST = "collateralAmount_DESC_NULLS_LAST",
+  collateralDeltaAmount_ASC = "collateralDeltaAmount_ASC",
+  collateralDeltaAmount_ASC_NULLS_FIRST = "collateralDeltaAmount_ASC_NULLS_FIRST",
+  collateralDeltaAmount_ASC_NULLS_LAST = "collateralDeltaAmount_ASC_NULLS_LAST",
+  collateralDeltaAmount_DESC = "collateralDeltaAmount_DESC",
+  collateralDeltaAmount_DESC_NULLS_FIRST = "collateralDeltaAmount_DESC_NULLS_FIRST",
+  collateralDeltaAmount_DESC_NULLS_LAST = "collateralDeltaAmount_DESC_NULLS_LAST",
+  collateralTokenPriceMin_ASC = "collateralTokenPriceMin_ASC",
+  collateralTokenPriceMin_ASC_NULLS_FIRST = "collateralTokenPriceMin_ASC_NULLS_FIRST",
+  collateralTokenPriceMin_ASC_NULLS_LAST = "collateralTokenPriceMin_ASC_NULLS_LAST",
+  collateralTokenPriceMin_DESC = "collateralTokenPriceMin_DESC",
+  collateralTokenPriceMin_DESC_NULLS_FIRST = "collateralTokenPriceMin_DESC_NULLS_FIRST",
+  collateralTokenPriceMin_DESC_NULLS_LAST = "collateralTokenPriceMin_DESC_NULLS_LAST",
+  collateralToken_ASC = "collateralToken_ASC",
+  collateralToken_ASC_NULLS_FIRST = "collateralToken_ASC_NULLS_FIRST",
+  collateralToken_ASC_NULLS_LAST = "collateralToken_ASC_NULLS_LAST",
+  collateralToken_DESC = "collateralToken_DESC",
+  collateralToken_DESC_NULLS_FIRST = "collateralToken_DESC_NULLS_FIRST",
+  collateralToken_DESC_NULLS_LAST = "collateralToken_DESC_NULLS_LAST",
+  executionPrice_ASC = "executionPrice_ASC",
+  executionPrice_ASC_NULLS_FIRST = "executionPrice_ASC_NULLS_FIRST",
+  executionPrice_ASC_NULLS_LAST = "executionPrice_ASC_NULLS_LAST",
+  executionPrice_DESC = "executionPrice_DESC",
+  executionPrice_DESC_NULLS_FIRST = "executionPrice_DESC_NULLS_FIRST",
+  executionPrice_DESC_NULLS_LAST = "executionPrice_DESC_NULLS_LAST",
+  feesAmount_ASC = "feesAmount_ASC",
+  feesAmount_ASC_NULLS_FIRST = "feesAmount_ASC_NULLS_FIRST",
+  feesAmount_ASC_NULLS_LAST = "feesAmount_ASC_NULLS_LAST",
+  feesAmount_DESC = "feesAmount_DESC",
+  feesAmount_DESC_NULLS_FIRST = "feesAmount_DESC_NULLS_FIRST",
+  feesAmount_DESC_NULLS_LAST = "feesAmount_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  isLong_ASC = "isLong_ASC",
+  isLong_ASC_NULLS_FIRST = "isLong_ASC_NULLS_FIRST",
+  isLong_ASC_NULLS_LAST = "isLong_ASC_NULLS_LAST",
+  isLong_DESC = "isLong_DESC",
+  isLong_DESC_NULLS_FIRST = "isLong_DESC_NULLS_FIRST",
+  isLong_DESC_NULLS_LAST = "isLong_DESC_NULLS_LAST",
+  isWin_ASC = "isWin_ASC",
+  isWin_ASC_NULLS_FIRST = "isWin_ASC_NULLS_FIRST",
+  isWin_ASC_NULLS_LAST = "isWin_ASC_NULLS_LAST",
+  isWin_DESC = "isWin_DESC",
+  isWin_DESC_NULLS_FIRST = "isWin_DESC_NULLS_FIRST",
+  isWin_DESC_NULLS_LAST = "isWin_DESC_NULLS_LAST",
+  market_ASC = "market_ASC",
+  market_ASC_NULLS_FIRST = "market_ASC_NULLS_FIRST",
+  market_ASC_NULLS_LAST = "market_ASC_NULLS_LAST",
+  market_DESC = "market_DESC",
+  market_DESC_NULLS_FIRST = "market_DESC_NULLS_FIRST",
+  market_DESC_NULLS_LAST = "market_DESC_NULLS_LAST",
+  maxSize_ASC = "maxSize_ASC",
+  maxSize_ASC_NULLS_FIRST = "maxSize_ASC_NULLS_FIRST",
+  maxSize_ASC_NULLS_LAST = "maxSize_ASC_NULLS_LAST",
+  maxSize_DESC = "maxSize_DESC",
+  maxSize_DESC_NULLS_FIRST = "maxSize_DESC_NULLS_FIRST",
+  maxSize_DESC_NULLS_LAST = "maxSize_DESC_NULLS_LAST",
+  priceImpactAmount_ASC = "priceImpactAmount_ASC",
+  priceImpactAmount_ASC_NULLS_FIRST = "priceImpactAmount_ASC_NULLS_FIRST",
+  priceImpactAmount_ASC_NULLS_LAST = "priceImpactAmount_ASC_NULLS_LAST",
+  priceImpactAmount_DESC = "priceImpactAmount_DESC",
+  priceImpactAmount_DESC_NULLS_FIRST = "priceImpactAmount_DESC_NULLS_FIRST",
+  priceImpactAmount_DESC_NULLS_LAST = "priceImpactAmount_DESC_NULLS_LAST",
+  priceImpactDiffUsd_ASC = "priceImpactDiffUsd_ASC",
+  priceImpactDiffUsd_ASC_NULLS_FIRST = "priceImpactDiffUsd_ASC_NULLS_FIRST",
+  priceImpactDiffUsd_ASC_NULLS_LAST = "priceImpactDiffUsd_ASC_NULLS_LAST",
+  priceImpactDiffUsd_DESC = "priceImpactDiffUsd_DESC",
+  priceImpactDiffUsd_DESC_NULLS_FIRST = "priceImpactDiffUsd_DESC_NULLS_FIRST",
+  priceImpactDiffUsd_DESC_NULLS_LAST = "priceImpactDiffUsd_DESC_NULLS_LAST",
+  priceImpactUsd_ASC = "priceImpactUsd_ASC",
+  priceImpactUsd_ASC_NULLS_FIRST = "priceImpactUsd_ASC_NULLS_FIRST",
+  priceImpactUsd_ASC_NULLS_LAST = "priceImpactUsd_ASC_NULLS_LAST",
+  priceImpactUsd_DESC = "priceImpactUsd_DESC",
+  priceImpactUsd_DESC_NULLS_FIRST = "priceImpactUsd_DESC_NULLS_FIRST",
+  priceImpactUsd_DESC_NULLS_LAST = "priceImpactUsd_DESC_NULLS_LAST",
+  proportionalPendingImpactUsd_ASC = "proportionalPendingImpactUsd_ASC",
+  proportionalPendingImpactUsd_ASC_NULLS_FIRST = "proportionalPendingImpactUsd_ASC_NULLS_FIRST",
+  proportionalPendingImpactUsd_ASC_NULLS_LAST = "proportionalPendingImpactUsd_ASC_NULLS_LAST",
+  proportionalPendingImpactUsd_DESC = "proportionalPendingImpactUsd_DESC",
+  proportionalPendingImpactUsd_DESC_NULLS_FIRST = "proportionalPendingImpactUsd_DESC_NULLS_FIRST",
+  proportionalPendingImpactUsd_DESC_NULLS_LAST = "proportionalPendingImpactUsd_DESC_NULLS_LAST",
+  sizeDeltaUsd_ASC = "sizeDeltaUsd_ASC",
+  sizeDeltaUsd_ASC_NULLS_FIRST = "sizeDeltaUsd_ASC_NULLS_FIRST",
+  sizeDeltaUsd_ASC_NULLS_LAST = "sizeDeltaUsd_ASC_NULLS_LAST",
+  sizeDeltaUsd_DESC = "sizeDeltaUsd_DESC",
+  sizeDeltaUsd_DESC_NULLS_FIRST = "sizeDeltaUsd_DESC_NULLS_FIRST",
+  sizeDeltaUsd_DESC_NULLS_LAST = "sizeDeltaUsd_DESC_NULLS_LAST",
+  sizeInUsd_ASC = "sizeInUsd_ASC",
+  sizeInUsd_ASC_NULLS_FIRST = "sizeInUsd_ASC_NULLS_FIRST",
+  sizeInUsd_ASC_NULLS_LAST = "sizeInUsd_ASC_NULLS_LAST",
+  sizeInUsd_DESC = "sizeInUsd_DESC",
+  sizeInUsd_DESC_NULLS_FIRST = "sizeInUsd_DESC_NULLS_FIRST",
+  sizeInUsd_DESC_NULLS_LAST = "sizeInUsd_DESC_NULLS_LAST",
+  timestamp_ASC = "timestamp_ASC",
+  timestamp_ASC_NULLS_FIRST = "timestamp_ASC_NULLS_FIRST",
+  timestamp_ASC_NULLS_LAST = "timestamp_ASC_NULLS_LAST",
+  timestamp_DESC = "timestamp_DESC",
+  timestamp_DESC_NULLS_FIRST = "timestamp_DESC_NULLS_FIRST",
+  timestamp_DESC_NULLS_LAST = "timestamp_DESC_NULLS_LAST",
+  totalImpactUsd_ASC = "totalImpactUsd_ASC",
+  totalImpactUsd_ASC_NULLS_FIRST = "totalImpactUsd_ASC_NULLS_FIRST",
+  totalImpactUsd_ASC_NULLS_LAST = "totalImpactUsd_ASC_NULLS_LAST",
+  totalImpactUsd_DESC = "totalImpactUsd_DESC",
+  totalImpactUsd_DESC_NULLS_FIRST = "totalImpactUsd_DESC_NULLS_FIRST",
+  totalImpactUsd_DESC_NULLS_LAST = "totalImpactUsd_DESC_NULLS_LAST",
+  type_ASC = "type_ASC",
+  type_ASC_NULLS_FIRST = "type_ASC_NULLS_FIRST",
+  type_ASC_NULLS_LAST = "type_ASC_NULLS_LAST",
+  type_DESC = "type_DESC",
+  type_DESC_NULLS_FIRST = "type_DESC_NULLS_FIRST",
+  type_DESC_NULLS_LAST = "type_DESC_NULLS_LAST",
+}
+
+export enum PositionChangeType {
+  decrease = "decrease",
+  increase = "increase",
+}
+
+export interface PositionChangeWhereInput {
+  AND?: InputMaybe<Array<PositionChangeWhereInput>>;
+  OR?: InputMaybe<Array<PositionChangeWhereInput>>;
+  account_contains?: InputMaybe<Scalars["String"]["input"]>;
+  account_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  account_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_eq?: InputMaybe<Scalars["String"]["input"]>;
+  account_gt?: InputMaybe<Scalars["String"]["input"]>;
+  account_gte?: InputMaybe<Scalars["String"]["input"]>;
+  account_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  account_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  account_lt?: InputMaybe<Scalars["String"]["input"]>;
+  account_lte?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  account_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  basePnlUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  basePnlUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  basePnlUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  basePnlUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  basePnlUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  basePnlUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  basePnlUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  basePnlUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  basePnlUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  block_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  block_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  block_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  block_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  block_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  block_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  block_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  block_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  block_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  collateralAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  collateralAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  collateralAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  collateralDeltaAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralDeltaAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralDeltaAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralDeltaAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  collateralDeltaAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  collateralDeltaAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralDeltaAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralDeltaAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralDeltaAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  collateralTokenPriceMin_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  collateralTokenPriceMin_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  collateralTokenPriceMin_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  collateralToken_contains?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_eq?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_gt?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_gte?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  collateralToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  collateralToken_lt?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_lte?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  collateralToken_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  executionPrice_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionPrice_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionPrice_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionPrice_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  executionPrice_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  executionPrice_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionPrice_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionPrice_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionPrice_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  feesAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feesAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feesAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feesAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  feesAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  feesAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feesAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feesAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feesAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  isLong_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isLong_not_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isWin_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isWin_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isWin_not_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  market_contains?: InputMaybe<Scalars["String"]["input"]>;
+  market_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  market_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  market_eq?: InputMaybe<Scalars["String"]["input"]>;
+  market_gt?: InputMaybe<Scalars["String"]["input"]>;
+  market_gte?: InputMaybe<Scalars["String"]["input"]>;
+  market_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  market_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  market_lt?: InputMaybe<Scalars["String"]["input"]>;
+  market_lte?: InputMaybe<Scalars["String"]["input"]>;
+  market_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  market_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  market_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  market_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  market_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  market_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  market_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  maxSize_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxSize_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxSize_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxSize_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxSize_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxSize_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxSize_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxSize_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxSize_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  priceImpactAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  priceImpactAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  priceImpactAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  priceImpactDiffUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactDiffUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactDiffUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactDiffUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  priceImpactDiffUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  priceImpactDiffUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactDiffUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactDiffUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactDiffUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  priceImpactUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  priceImpactUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  priceImpactUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  proportionalPendingImpactUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  proportionalPendingImpactUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  proportionalPendingImpactUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  proportionalPendingImpactUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  proportionalPendingImpactUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  proportionalPendingImpactUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  proportionalPendingImpactUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  proportionalPendingImpactUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  proportionalPendingImpactUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  sizeDeltaUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  sizeDeltaUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  sizeDeltaUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  sizeInUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  sizeInUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  sizeInUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  timestamp_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  timestamp_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  timestamp_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  totalImpactUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalImpactUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalImpactUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalImpactUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  totalImpactUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  totalImpactUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalImpactUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalImpactUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalImpactUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  type_eq?: InputMaybe<PositionChangeType>;
+  type_in?: InputMaybe<Array<PositionChangeType>>;
+  type_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  type_not_eq?: InputMaybe<PositionChangeType>;
+  type_not_in?: InputMaybe<Array<PositionChangeType>>;
+}
+
+export interface PositionChangesConnection {
+  __typename?: "PositionChangesConnection";
+  edges: Array<PositionChangeEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface PositionEdge {
+  __typename?: "PositionEdge";
+  cursor: Scalars["String"]["output"];
+  node: Position;
+}
+
+export interface PositionFeesEntitiesConnection {
+  __typename?: "PositionFeesEntitiesConnection";
+  edges: Array<PositionFeesEntityEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface PositionFeesEntity {
+  __typename?: "PositionFeesEntity";
+  affiliate: Scalars["String"]["output"];
+  affiliateRewardAmount: Scalars["BigInt"]["output"];
+  borrowingFeeAmount: Scalars["BigInt"]["output"];
+  collateralTokenAddress: Scalars["String"]["output"];
+  collateralTokenPriceMax: Scalars["BigInt"]["output"];
+  collateralTokenPriceMin: Scalars["BigInt"]["output"];
+  eventName: Scalars["String"]["output"];
+  feeUsdForPool: Scalars["BigInt"]["output"];
+  fundingFeeAmount: Scalars["BigInt"]["output"];
+  id: Scalars["String"]["output"];
+  liquidationFeeAmount?: Maybe<Scalars["BigInt"]["output"]>;
+  marketAddress: Scalars["String"]["output"];
+  orderKey: Scalars["String"]["output"];
+  positionFeeAmount: Scalars["BigInt"]["output"];
+  totalRebateAmount: Scalars["BigInt"]["output"];
+  totalRebateFactor: Scalars["BigInt"]["output"];
+  trader: Scalars["String"]["output"];
+  traderDiscountAmount: Scalars["BigInt"]["output"];
+  transaction: Transaction;
+  type: PositionFeesEntityType;
+}
+
+export interface PositionFeesEntityEdge {
+  __typename?: "PositionFeesEntityEdge";
+  cursor: Scalars["String"]["output"];
+  node: PositionFeesEntity;
+}
+
+export enum PositionFeesEntityOrderByInput {
+  affiliateRewardAmount_ASC = "affiliateRewardAmount_ASC",
+  affiliateRewardAmount_ASC_NULLS_FIRST = "affiliateRewardAmount_ASC_NULLS_FIRST",
+  affiliateRewardAmount_ASC_NULLS_LAST = "affiliateRewardAmount_ASC_NULLS_LAST",
+  affiliateRewardAmount_DESC = "affiliateRewardAmount_DESC",
+  affiliateRewardAmount_DESC_NULLS_FIRST = "affiliateRewardAmount_DESC_NULLS_FIRST",
+  affiliateRewardAmount_DESC_NULLS_LAST = "affiliateRewardAmount_DESC_NULLS_LAST",
+  affiliate_ASC = "affiliate_ASC",
+  affiliate_ASC_NULLS_FIRST = "affiliate_ASC_NULLS_FIRST",
+  affiliate_ASC_NULLS_LAST = "affiliate_ASC_NULLS_LAST",
+  affiliate_DESC = "affiliate_DESC",
+  affiliate_DESC_NULLS_FIRST = "affiliate_DESC_NULLS_FIRST",
+  affiliate_DESC_NULLS_LAST = "affiliate_DESC_NULLS_LAST",
+  borrowingFeeAmount_ASC = "borrowingFeeAmount_ASC",
+  borrowingFeeAmount_ASC_NULLS_FIRST = "borrowingFeeAmount_ASC_NULLS_FIRST",
+  borrowingFeeAmount_ASC_NULLS_LAST = "borrowingFeeAmount_ASC_NULLS_LAST",
+  borrowingFeeAmount_DESC = "borrowingFeeAmount_DESC",
+  borrowingFeeAmount_DESC_NULLS_FIRST = "borrowingFeeAmount_DESC_NULLS_FIRST",
+  borrowingFeeAmount_DESC_NULLS_LAST = "borrowingFeeAmount_DESC_NULLS_LAST",
+  collateralTokenAddress_ASC = "collateralTokenAddress_ASC",
+  collateralTokenAddress_ASC_NULLS_FIRST = "collateralTokenAddress_ASC_NULLS_FIRST",
+  collateralTokenAddress_ASC_NULLS_LAST = "collateralTokenAddress_ASC_NULLS_LAST",
+  collateralTokenAddress_DESC = "collateralTokenAddress_DESC",
+  collateralTokenAddress_DESC_NULLS_FIRST = "collateralTokenAddress_DESC_NULLS_FIRST",
+  collateralTokenAddress_DESC_NULLS_LAST = "collateralTokenAddress_DESC_NULLS_LAST",
+  collateralTokenPriceMax_ASC = "collateralTokenPriceMax_ASC",
+  collateralTokenPriceMax_ASC_NULLS_FIRST = "collateralTokenPriceMax_ASC_NULLS_FIRST",
+  collateralTokenPriceMax_ASC_NULLS_LAST = "collateralTokenPriceMax_ASC_NULLS_LAST",
+  collateralTokenPriceMax_DESC = "collateralTokenPriceMax_DESC",
+  collateralTokenPriceMax_DESC_NULLS_FIRST = "collateralTokenPriceMax_DESC_NULLS_FIRST",
+  collateralTokenPriceMax_DESC_NULLS_LAST = "collateralTokenPriceMax_DESC_NULLS_LAST",
+  collateralTokenPriceMin_ASC = "collateralTokenPriceMin_ASC",
+  collateralTokenPriceMin_ASC_NULLS_FIRST = "collateralTokenPriceMin_ASC_NULLS_FIRST",
+  collateralTokenPriceMin_ASC_NULLS_LAST = "collateralTokenPriceMin_ASC_NULLS_LAST",
+  collateralTokenPriceMin_DESC = "collateralTokenPriceMin_DESC",
+  collateralTokenPriceMin_DESC_NULLS_FIRST = "collateralTokenPriceMin_DESC_NULLS_FIRST",
+  collateralTokenPriceMin_DESC_NULLS_LAST = "collateralTokenPriceMin_DESC_NULLS_LAST",
+  eventName_ASC = "eventName_ASC",
+  eventName_ASC_NULLS_FIRST = "eventName_ASC_NULLS_FIRST",
+  eventName_ASC_NULLS_LAST = "eventName_ASC_NULLS_LAST",
+  eventName_DESC = "eventName_DESC",
+  eventName_DESC_NULLS_FIRST = "eventName_DESC_NULLS_FIRST",
+  eventName_DESC_NULLS_LAST = "eventName_DESC_NULLS_LAST",
+  feeUsdForPool_ASC = "feeUsdForPool_ASC",
+  feeUsdForPool_ASC_NULLS_FIRST = "feeUsdForPool_ASC_NULLS_FIRST",
+  feeUsdForPool_ASC_NULLS_LAST = "feeUsdForPool_ASC_NULLS_LAST",
+  feeUsdForPool_DESC = "feeUsdForPool_DESC",
+  feeUsdForPool_DESC_NULLS_FIRST = "feeUsdForPool_DESC_NULLS_FIRST",
+  feeUsdForPool_DESC_NULLS_LAST = "feeUsdForPool_DESC_NULLS_LAST",
+  fundingFeeAmount_ASC = "fundingFeeAmount_ASC",
+  fundingFeeAmount_ASC_NULLS_FIRST = "fundingFeeAmount_ASC_NULLS_FIRST",
+  fundingFeeAmount_ASC_NULLS_LAST = "fundingFeeAmount_ASC_NULLS_LAST",
+  fundingFeeAmount_DESC = "fundingFeeAmount_DESC",
+  fundingFeeAmount_DESC_NULLS_FIRST = "fundingFeeAmount_DESC_NULLS_FIRST",
+  fundingFeeAmount_DESC_NULLS_LAST = "fundingFeeAmount_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  liquidationFeeAmount_ASC = "liquidationFeeAmount_ASC",
+  liquidationFeeAmount_ASC_NULLS_FIRST = "liquidationFeeAmount_ASC_NULLS_FIRST",
+  liquidationFeeAmount_ASC_NULLS_LAST = "liquidationFeeAmount_ASC_NULLS_LAST",
+  liquidationFeeAmount_DESC = "liquidationFeeAmount_DESC",
+  liquidationFeeAmount_DESC_NULLS_FIRST = "liquidationFeeAmount_DESC_NULLS_FIRST",
+  liquidationFeeAmount_DESC_NULLS_LAST = "liquidationFeeAmount_DESC_NULLS_LAST",
+  marketAddress_ASC = "marketAddress_ASC",
+  marketAddress_ASC_NULLS_FIRST = "marketAddress_ASC_NULLS_FIRST",
+  marketAddress_ASC_NULLS_LAST = "marketAddress_ASC_NULLS_LAST",
+  marketAddress_DESC = "marketAddress_DESC",
+  marketAddress_DESC_NULLS_FIRST = "marketAddress_DESC_NULLS_FIRST",
+  marketAddress_DESC_NULLS_LAST = "marketAddress_DESC_NULLS_LAST",
+  orderKey_ASC = "orderKey_ASC",
+  orderKey_ASC_NULLS_FIRST = "orderKey_ASC_NULLS_FIRST",
+  orderKey_ASC_NULLS_LAST = "orderKey_ASC_NULLS_LAST",
+  orderKey_DESC = "orderKey_DESC",
+  orderKey_DESC_NULLS_FIRST = "orderKey_DESC_NULLS_FIRST",
+  orderKey_DESC_NULLS_LAST = "orderKey_DESC_NULLS_LAST",
+  positionFeeAmount_ASC = "positionFeeAmount_ASC",
+  positionFeeAmount_ASC_NULLS_FIRST = "positionFeeAmount_ASC_NULLS_FIRST",
+  positionFeeAmount_ASC_NULLS_LAST = "positionFeeAmount_ASC_NULLS_LAST",
+  positionFeeAmount_DESC = "positionFeeAmount_DESC",
+  positionFeeAmount_DESC_NULLS_FIRST = "positionFeeAmount_DESC_NULLS_FIRST",
+  positionFeeAmount_DESC_NULLS_LAST = "positionFeeAmount_DESC_NULLS_LAST",
+  totalRebateAmount_ASC = "totalRebateAmount_ASC",
+  totalRebateAmount_ASC_NULLS_FIRST = "totalRebateAmount_ASC_NULLS_FIRST",
+  totalRebateAmount_ASC_NULLS_LAST = "totalRebateAmount_ASC_NULLS_LAST",
+  totalRebateAmount_DESC = "totalRebateAmount_DESC",
+  totalRebateAmount_DESC_NULLS_FIRST = "totalRebateAmount_DESC_NULLS_FIRST",
+  totalRebateAmount_DESC_NULLS_LAST = "totalRebateAmount_DESC_NULLS_LAST",
+  totalRebateFactor_ASC = "totalRebateFactor_ASC",
+  totalRebateFactor_ASC_NULLS_FIRST = "totalRebateFactor_ASC_NULLS_FIRST",
+  totalRebateFactor_ASC_NULLS_LAST = "totalRebateFactor_ASC_NULLS_LAST",
+  totalRebateFactor_DESC = "totalRebateFactor_DESC",
+  totalRebateFactor_DESC_NULLS_FIRST = "totalRebateFactor_DESC_NULLS_FIRST",
+  totalRebateFactor_DESC_NULLS_LAST = "totalRebateFactor_DESC_NULLS_LAST",
+  traderDiscountAmount_ASC = "traderDiscountAmount_ASC",
+  traderDiscountAmount_ASC_NULLS_FIRST = "traderDiscountAmount_ASC_NULLS_FIRST",
+  traderDiscountAmount_ASC_NULLS_LAST = "traderDiscountAmount_ASC_NULLS_LAST",
+  traderDiscountAmount_DESC = "traderDiscountAmount_DESC",
+  traderDiscountAmount_DESC_NULLS_FIRST = "traderDiscountAmount_DESC_NULLS_FIRST",
+  traderDiscountAmount_DESC_NULLS_LAST = "traderDiscountAmount_DESC_NULLS_LAST",
+  trader_ASC = "trader_ASC",
+  trader_ASC_NULLS_FIRST = "trader_ASC_NULLS_FIRST",
+  trader_ASC_NULLS_LAST = "trader_ASC_NULLS_LAST",
+  trader_DESC = "trader_DESC",
+  trader_DESC_NULLS_FIRST = "trader_DESC_NULLS_FIRST",
+  trader_DESC_NULLS_LAST = "trader_DESC_NULLS_LAST",
+  transaction_blockNumber_ASC = "transaction_blockNumber_ASC",
+  transaction_blockNumber_ASC_NULLS_FIRST = "transaction_blockNumber_ASC_NULLS_FIRST",
+  transaction_blockNumber_ASC_NULLS_LAST = "transaction_blockNumber_ASC_NULLS_LAST",
+  transaction_blockNumber_DESC = "transaction_blockNumber_DESC",
+  transaction_blockNumber_DESC_NULLS_FIRST = "transaction_blockNumber_DESC_NULLS_FIRST",
+  transaction_blockNumber_DESC_NULLS_LAST = "transaction_blockNumber_DESC_NULLS_LAST",
+  transaction_chainId_ASC = "transaction_chainId_ASC",
+  transaction_chainId_ASC_NULLS_FIRST = "transaction_chainId_ASC_NULLS_FIRST",
+  transaction_chainId_ASC_NULLS_LAST = "transaction_chainId_ASC_NULLS_LAST",
+  transaction_chainId_DESC = "transaction_chainId_DESC",
+  transaction_chainId_DESC_NULLS_FIRST = "transaction_chainId_DESC_NULLS_FIRST",
+  transaction_chainId_DESC_NULLS_LAST = "transaction_chainId_DESC_NULLS_LAST",
+  transaction_from_ASC = "transaction_from_ASC",
+  transaction_from_ASC_NULLS_FIRST = "transaction_from_ASC_NULLS_FIRST",
+  transaction_from_ASC_NULLS_LAST = "transaction_from_ASC_NULLS_LAST",
+  transaction_from_DESC = "transaction_from_DESC",
+  transaction_from_DESC_NULLS_FIRST = "transaction_from_DESC_NULLS_FIRST",
+  transaction_from_DESC_NULLS_LAST = "transaction_from_DESC_NULLS_LAST",
+  transaction_hash_ASC = "transaction_hash_ASC",
+  transaction_hash_ASC_NULLS_FIRST = "transaction_hash_ASC_NULLS_FIRST",
+  transaction_hash_ASC_NULLS_LAST = "transaction_hash_ASC_NULLS_LAST",
+  transaction_hash_DESC = "transaction_hash_DESC",
+  transaction_hash_DESC_NULLS_FIRST = "transaction_hash_DESC_NULLS_FIRST",
+  transaction_hash_DESC_NULLS_LAST = "transaction_hash_DESC_NULLS_LAST",
+  transaction_id_ASC = "transaction_id_ASC",
+  transaction_id_ASC_NULLS_FIRST = "transaction_id_ASC_NULLS_FIRST",
+  transaction_id_ASC_NULLS_LAST = "transaction_id_ASC_NULLS_LAST",
+  transaction_id_DESC = "transaction_id_DESC",
+  transaction_id_DESC_NULLS_FIRST = "transaction_id_DESC_NULLS_FIRST",
+  transaction_id_DESC_NULLS_LAST = "transaction_id_DESC_NULLS_LAST",
+  transaction_timestamp_ASC = "transaction_timestamp_ASC",
+  transaction_timestamp_ASC_NULLS_FIRST = "transaction_timestamp_ASC_NULLS_FIRST",
+  transaction_timestamp_ASC_NULLS_LAST = "transaction_timestamp_ASC_NULLS_LAST",
+  transaction_timestamp_DESC = "transaction_timestamp_DESC",
+  transaction_timestamp_DESC_NULLS_FIRST = "transaction_timestamp_DESC_NULLS_FIRST",
+  transaction_timestamp_DESC_NULLS_LAST = "transaction_timestamp_DESC_NULLS_LAST",
+  transaction_to_ASC = "transaction_to_ASC",
+  transaction_to_ASC_NULLS_FIRST = "transaction_to_ASC_NULLS_FIRST",
+  transaction_to_ASC_NULLS_LAST = "transaction_to_ASC_NULLS_LAST",
+  transaction_to_DESC = "transaction_to_DESC",
+  transaction_to_DESC_NULLS_FIRST = "transaction_to_DESC_NULLS_FIRST",
+  transaction_to_DESC_NULLS_LAST = "transaction_to_DESC_NULLS_LAST",
+  transaction_transactionIndex_ASC = "transaction_transactionIndex_ASC",
+  transaction_transactionIndex_ASC_NULLS_FIRST = "transaction_transactionIndex_ASC_NULLS_FIRST",
+  transaction_transactionIndex_ASC_NULLS_LAST = "transaction_transactionIndex_ASC_NULLS_LAST",
+  transaction_transactionIndex_DESC = "transaction_transactionIndex_DESC",
+  transaction_transactionIndex_DESC_NULLS_FIRST = "transaction_transactionIndex_DESC_NULLS_FIRST",
+  transaction_transactionIndex_DESC_NULLS_LAST = "transaction_transactionIndex_DESC_NULLS_LAST",
+  type_ASC = "type_ASC",
+  type_ASC_NULLS_FIRST = "type_ASC_NULLS_FIRST",
+  type_ASC_NULLS_LAST = "type_ASC_NULLS_LAST",
+  type_DESC = "type_DESC",
+  type_DESC_NULLS_FIRST = "type_DESC_NULLS_FIRST",
+  type_DESC_NULLS_LAST = "type_DESC_NULLS_LAST",
+}
+
+export enum PositionFeesEntityType {
+  PositionFeesCollected = "PositionFeesCollected",
+  PositionFeesInfo = "PositionFeesInfo",
+}
+
+export interface PositionFeesEntityWhereInput {
+  AND?: InputMaybe<Array<PositionFeesEntityWhereInput>>;
+  OR?: InputMaybe<Array<PositionFeesEntityWhereInput>>;
+  affiliateRewardAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  affiliateRewardAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  affiliateRewardAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  affiliateRewardAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  affiliateRewardAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  affiliateRewardAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  affiliateRewardAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  affiliateRewardAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  affiliateRewardAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  affiliate_contains?: InputMaybe<Scalars["String"]["input"]>;
+  affiliate_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  affiliate_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  affiliate_eq?: InputMaybe<Scalars["String"]["input"]>;
+  affiliate_gt?: InputMaybe<Scalars["String"]["input"]>;
+  affiliate_gte?: InputMaybe<Scalars["String"]["input"]>;
+  affiliate_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  affiliate_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  affiliate_lt?: InputMaybe<Scalars["String"]["input"]>;
+  affiliate_lte?: InputMaybe<Scalars["String"]["input"]>;
+  affiliate_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  affiliate_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  affiliate_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  affiliate_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  affiliate_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  affiliate_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  affiliate_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  borrowingFeeAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFeeAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  borrowingFeeAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  collateralTokenAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  collateralTokenAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  collateralTokenAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  collateralTokenAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  collateralTokenAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  collateralTokenAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  collateralTokenAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  collateralTokenAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  collateralTokenAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  collateralTokenAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  collateralTokenAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  collateralTokenAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  collateralTokenAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  collateralTokenAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  collateralTokenAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  collateralTokenAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  collateralTokenAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  collateralTokenPriceMax_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMax_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMax_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMax_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  collateralTokenPriceMax_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  collateralTokenPriceMax_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMax_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMax_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMax_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  collateralTokenPriceMin_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  collateralTokenPriceMin_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  collateralTokenPriceMin_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  eventName_contains?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_eq?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_gt?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_gte?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  eventName_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  eventName_lt?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_lte?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  eventName_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  feeUsdForPool_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdForPool_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdForPool_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdForPool_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  feeUsdForPool_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  feeUsdForPool_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdForPool_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdForPool_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  feeUsdForPool_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  fundingFeeAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFeeAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFeeAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFeeAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  fundingFeeAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  fundingFeeAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFeeAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFeeAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFeeAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  liquidationFeeAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  liquidationFeeAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  liquidationFeeAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  liquidationFeeAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  liquidationFeeAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  liquidationFeeAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  liquidationFeeAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  liquidationFeeAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  liquidationFeeAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  marketAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  marketAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_contains?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_eq?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_gt?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_gte?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  orderKey_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  orderKey_lt?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_lte?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  orderKey_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  positionFeeAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionFeeAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  positionFeeAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  totalRebateAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalRebateAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalRebateAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalRebateAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  totalRebateAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  totalRebateAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalRebateAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalRebateAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalRebateAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  totalRebateFactor_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalRebateFactor_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalRebateFactor_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalRebateFactor_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  totalRebateFactor_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  totalRebateFactor_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalRebateFactor_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalRebateFactor_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalRebateFactor_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  traderDiscountAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  traderDiscountAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  traderDiscountAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  traderDiscountAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  traderDiscountAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  traderDiscountAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  traderDiscountAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  traderDiscountAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  traderDiscountAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  trader_contains?: InputMaybe<Scalars["String"]["input"]>;
+  trader_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  trader_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  trader_eq?: InputMaybe<Scalars["String"]["input"]>;
+  trader_gt?: InputMaybe<Scalars["String"]["input"]>;
+  trader_gte?: InputMaybe<Scalars["String"]["input"]>;
+  trader_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  trader_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  trader_lt?: InputMaybe<Scalars["String"]["input"]>;
+  trader_lte?: InputMaybe<Scalars["String"]["input"]>;
+  trader_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  trader_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  trader_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  trader_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  trader_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  trader_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  trader_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  transaction?: InputMaybe<TransactionWhereInput>;
+  transaction_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  type_eq?: InputMaybe<PositionFeesEntityType>;
+  type_in?: InputMaybe<Array<PositionFeesEntityType>>;
+  type_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  type_not_eq?: InputMaybe<PositionFeesEntityType>;
+  type_not_in?: InputMaybe<Array<PositionFeesEntityType>>;
+}
+
+export interface PositionMarketVolumeInfo {
+  __typename?: "PositionMarketVolumeInfo";
+  market: Scalars["String"]["output"];
+  volume: Scalars["BigInt"]["output"];
+}
+
+export enum PositionOrderByInput {
+  accountStat_closedCount_ASC = "accountStat_closedCount_ASC",
+  accountStat_closedCount_ASC_NULLS_FIRST = "accountStat_closedCount_ASC_NULLS_FIRST",
+  accountStat_closedCount_ASC_NULLS_LAST = "accountStat_closedCount_ASC_NULLS_LAST",
+  accountStat_closedCount_DESC = "accountStat_closedCount_DESC",
+  accountStat_closedCount_DESC_NULLS_FIRST = "accountStat_closedCount_DESC_NULLS_FIRST",
+  accountStat_closedCount_DESC_NULLS_LAST = "accountStat_closedCount_DESC_NULLS_LAST",
+  accountStat_cumsumCollateral_ASC = "accountStat_cumsumCollateral_ASC",
+  accountStat_cumsumCollateral_ASC_NULLS_FIRST = "accountStat_cumsumCollateral_ASC_NULLS_FIRST",
+  accountStat_cumsumCollateral_ASC_NULLS_LAST = "accountStat_cumsumCollateral_ASC_NULLS_LAST",
+  accountStat_cumsumCollateral_DESC = "accountStat_cumsumCollateral_DESC",
+  accountStat_cumsumCollateral_DESC_NULLS_FIRST = "accountStat_cumsumCollateral_DESC_NULLS_FIRST",
+  accountStat_cumsumCollateral_DESC_NULLS_LAST = "accountStat_cumsumCollateral_DESC_NULLS_LAST",
+  accountStat_cumsumSize_ASC = "accountStat_cumsumSize_ASC",
+  accountStat_cumsumSize_ASC_NULLS_FIRST = "accountStat_cumsumSize_ASC_NULLS_FIRST",
+  accountStat_cumsumSize_ASC_NULLS_LAST = "accountStat_cumsumSize_ASC_NULLS_LAST",
+  accountStat_cumsumSize_DESC = "accountStat_cumsumSize_DESC",
+  accountStat_cumsumSize_DESC_NULLS_FIRST = "accountStat_cumsumSize_DESC_NULLS_FIRST",
+  accountStat_cumsumSize_DESC_NULLS_LAST = "accountStat_cumsumSize_DESC_NULLS_LAST",
+  accountStat_id_ASC = "accountStat_id_ASC",
+  accountStat_id_ASC_NULLS_FIRST = "accountStat_id_ASC_NULLS_FIRST",
+  accountStat_id_ASC_NULLS_LAST = "accountStat_id_ASC_NULLS_LAST",
+  accountStat_id_DESC = "accountStat_id_DESC",
+  accountStat_id_DESC_NULLS_FIRST = "accountStat_id_DESC_NULLS_FIRST",
+  accountStat_id_DESC_NULLS_LAST = "accountStat_id_DESC_NULLS_LAST",
+  accountStat_losses_ASC = "accountStat_losses_ASC",
+  accountStat_losses_ASC_NULLS_FIRST = "accountStat_losses_ASC_NULLS_FIRST",
+  accountStat_losses_ASC_NULLS_LAST = "accountStat_losses_ASC_NULLS_LAST",
+  accountStat_losses_DESC = "accountStat_losses_DESC",
+  accountStat_losses_DESC_NULLS_FIRST = "accountStat_losses_DESC_NULLS_FIRST",
+  accountStat_losses_DESC_NULLS_LAST = "accountStat_losses_DESC_NULLS_LAST",
+  accountStat_maxCapital_ASC = "accountStat_maxCapital_ASC",
+  accountStat_maxCapital_ASC_NULLS_FIRST = "accountStat_maxCapital_ASC_NULLS_FIRST",
+  accountStat_maxCapital_ASC_NULLS_LAST = "accountStat_maxCapital_ASC_NULLS_LAST",
+  accountStat_maxCapital_DESC = "accountStat_maxCapital_DESC",
+  accountStat_maxCapital_DESC_NULLS_FIRST = "accountStat_maxCapital_DESC_NULLS_FIRST",
+  accountStat_maxCapital_DESC_NULLS_LAST = "accountStat_maxCapital_DESC_NULLS_LAST",
+  accountStat_netCapital_ASC = "accountStat_netCapital_ASC",
+  accountStat_netCapital_ASC_NULLS_FIRST = "accountStat_netCapital_ASC_NULLS_FIRST",
+  accountStat_netCapital_ASC_NULLS_LAST = "accountStat_netCapital_ASC_NULLS_LAST",
+  accountStat_netCapital_DESC = "accountStat_netCapital_DESC",
+  accountStat_netCapital_DESC_NULLS_FIRST = "accountStat_netCapital_DESC_NULLS_FIRST",
+  accountStat_netCapital_DESC_NULLS_LAST = "accountStat_netCapital_DESC_NULLS_LAST",
+  accountStat_realizedFees_ASC = "accountStat_realizedFees_ASC",
+  accountStat_realizedFees_ASC_NULLS_FIRST = "accountStat_realizedFees_ASC_NULLS_FIRST",
+  accountStat_realizedFees_ASC_NULLS_LAST = "accountStat_realizedFees_ASC_NULLS_LAST",
+  accountStat_realizedFees_DESC = "accountStat_realizedFees_DESC",
+  accountStat_realizedFees_DESC_NULLS_FIRST = "accountStat_realizedFees_DESC_NULLS_FIRST",
+  accountStat_realizedFees_DESC_NULLS_LAST = "accountStat_realizedFees_DESC_NULLS_LAST",
+  accountStat_realizedPnl_ASC = "accountStat_realizedPnl_ASC",
+  accountStat_realizedPnl_ASC_NULLS_FIRST = "accountStat_realizedPnl_ASC_NULLS_FIRST",
+  accountStat_realizedPnl_ASC_NULLS_LAST = "accountStat_realizedPnl_ASC_NULLS_LAST",
+  accountStat_realizedPnl_DESC = "accountStat_realizedPnl_DESC",
+  accountStat_realizedPnl_DESC_NULLS_FIRST = "accountStat_realizedPnl_DESC_NULLS_FIRST",
+  accountStat_realizedPnl_DESC_NULLS_LAST = "accountStat_realizedPnl_DESC_NULLS_LAST",
+  accountStat_realizedPriceImpact_ASC = "accountStat_realizedPriceImpact_ASC",
+  accountStat_realizedPriceImpact_ASC_NULLS_FIRST = "accountStat_realizedPriceImpact_ASC_NULLS_FIRST",
+  accountStat_realizedPriceImpact_ASC_NULLS_LAST = "accountStat_realizedPriceImpact_ASC_NULLS_LAST",
+  accountStat_realizedPriceImpact_DESC = "accountStat_realizedPriceImpact_DESC",
+  accountStat_realizedPriceImpact_DESC_NULLS_FIRST = "accountStat_realizedPriceImpact_DESC_NULLS_FIRST",
+  accountStat_realizedPriceImpact_DESC_NULLS_LAST = "accountStat_realizedPriceImpact_DESC_NULLS_LAST",
+  accountStat_sumMaxSize_ASC = "accountStat_sumMaxSize_ASC",
+  accountStat_sumMaxSize_ASC_NULLS_FIRST = "accountStat_sumMaxSize_ASC_NULLS_FIRST",
+  accountStat_sumMaxSize_ASC_NULLS_LAST = "accountStat_sumMaxSize_ASC_NULLS_LAST",
+  accountStat_sumMaxSize_DESC = "accountStat_sumMaxSize_DESC",
+  accountStat_sumMaxSize_DESC_NULLS_FIRST = "accountStat_sumMaxSize_DESC_NULLS_FIRST",
+  accountStat_sumMaxSize_DESC_NULLS_LAST = "accountStat_sumMaxSize_DESC_NULLS_LAST",
+  accountStat_volume_ASC = "accountStat_volume_ASC",
+  accountStat_volume_ASC_NULLS_FIRST = "accountStat_volume_ASC_NULLS_FIRST",
+  accountStat_volume_ASC_NULLS_LAST = "accountStat_volume_ASC_NULLS_LAST",
+  accountStat_volume_DESC = "accountStat_volume_DESC",
+  accountStat_volume_DESC_NULLS_FIRST = "accountStat_volume_DESC_NULLS_FIRST",
+  accountStat_volume_DESC_NULLS_LAST = "accountStat_volume_DESC_NULLS_LAST",
+  accountStat_wins_ASC = "accountStat_wins_ASC",
+  accountStat_wins_ASC_NULLS_FIRST = "accountStat_wins_ASC_NULLS_FIRST",
+  accountStat_wins_ASC_NULLS_LAST = "accountStat_wins_ASC_NULLS_LAST",
+  accountStat_wins_DESC = "accountStat_wins_DESC",
+  accountStat_wins_DESC_NULLS_FIRST = "accountStat_wins_DESC_NULLS_FIRST",
+  accountStat_wins_DESC_NULLS_LAST = "accountStat_wins_DESC_NULLS_LAST",
+  account_ASC = "account_ASC",
+  account_ASC_NULLS_FIRST = "account_ASC_NULLS_FIRST",
+  account_ASC_NULLS_LAST = "account_ASC_NULLS_LAST",
+  account_DESC = "account_DESC",
+  account_DESC_NULLS_FIRST = "account_DESC_NULLS_FIRST",
+  account_DESC_NULLS_LAST = "account_DESC_NULLS_LAST",
+  collateralAmount_ASC = "collateralAmount_ASC",
+  collateralAmount_ASC_NULLS_FIRST = "collateralAmount_ASC_NULLS_FIRST",
+  collateralAmount_ASC_NULLS_LAST = "collateralAmount_ASC_NULLS_LAST",
+  collateralAmount_DESC = "collateralAmount_DESC",
+  collateralAmount_DESC_NULLS_FIRST = "collateralAmount_DESC_NULLS_FIRST",
+  collateralAmount_DESC_NULLS_LAST = "collateralAmount_DESC_NULLS_LAST",
+  collateralToken_ASC = "collateralToken_ASC",
+  collateralToken_ASC_NULLS_FIRST = "collateralToken_ASC_NULLS_FIRST",
+  collateralToken_ASC_NULLS_LAST = "collateralToken_ASC_NULLS_LAST",
+  collateralToken_DESC = "collateralToken_DESC",
+  collateralToken_DESC_NULLS_FIRST = "collateralToken_DESC_NULLS_FIRST",
+  collateralToken_DESC_NULLS_LAST = "collateralToken_DESC_NULLS_LAST",
+  entryPrice_ASC = "entryPrice_ASC",
+  entryPrice_ASC_NULLS_FIRST = "entryPrice_ASC_NULLS_FIRST",
+  entryPrice_ASC_NULLS_LAST = "entryPrice_ASC_NULLS_LAST",
+  entryPrice_DESC = "entryPrice_DESC",
+  entryPrice_DESC_NULLS_FIRST = "entryPrice_DESC_NULLS_FIRST",
+  entryPrice_DESC_NULLS_LAST = "entryPrice_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  isLong_ASC = "isLong_ASC",
+  isLong_ASC_NULLS_FIRST = "isLong_ASC_NULLS_FIRST",
+  isLong_ASC_NULLS_LAST = "isLong_ASC_NULLS_LAST",
+  isLong_DESC = "isLong_DESC",
+  isLong_DESC_NULLS_FIRST = "isLong_DESC_NULLS_FIRST",
+  isLong_DESC_NULLS_LAST = "isLong_DESC_NULLS_LAST",
+  isSnapshot_ASC = "isSnapshot_ASC",
+  isSnapshot_ASC_NULLS_FIRST = "isSnapshot_ASC_NULLS_FIRST",
+  isSnapshot_ASC_NULLS_LAST = "isSnapshot_ASC_NULLS_LAST",
+  isSnapshot_DESC = "isSnapshot_DESC",
+  isSnapshot_DESC_NULLS_FIRST = "isSnapshot_DESC_NULLS_FIRST",
+  isSnapshot_DESC_NULLS_LAST = "isSnapshot_DESC_NULLS_LAST",
+  market_ASC = "market_ASC",
+  market_ASC_NULLS_FIRST = "market_ASC_NULLS_FIRST",
+  market_ASC_NULLS_LAST = "market_ASC_NULLS_LAST",
+  market_DESC = "market_DESC",
+  market_DESC_NULLS_FIRST = "market_DESC_NULLS_FIRST",
+  market_DESC_NULLS_LAST = "market_DESC_NULLS_LAST",
+  maxSize_ASC = "maxSize_ASC",
+  maxSize_ASC_NULLS_FIRST = "maxSize_ASC_NULLS_FIRST",
+  maxSize_ASC_NULLS_LAST = "maxSize_ASC_NULLS_LAST",
+  maxSize_DESC = "maxSize_DESC",
+  maxSize_DESC_NULLS_FIRST = "maxSize_DESC_NULLS_FIRST",
+  maxSize_DESC_NULLS_LAST = "maxSize_DESC_NULLS_LAST",
+  openedAt_ASC = "openedAt_ASC",
+  openedAt_ASC_NULLS_FIRST = "openedAt_ASC_NULLS_FIRST",
+  openedAt_ASC_NULLS_LAST = "openedAt_ASC_NULLS_LAST",
+  openedAt_DESC = "openedAt_DESC",
+  openedAt_DESC_NULLS_FIRST = "openedAt_DESC_NULLS_FIRST",
+  openedAt_DESC_NULLS_LAST = "openedAt_DESC_NULLS_LAST",
+  positionKey_ASC = "positionKey_ASC",
+  positionKey_ASC_NULLS_FIRST = "positionKey_ASC_NULLS_FIRST",
+  positionKey_ASC_NULLS_LAST = "positionKey_ASC_NULLS_LAST",
+  positionKey_DESC = "positionKey_DESC",
+  positionKey_DESC_NULLS_FIRST = "positionKey_DESC_NULLS_FIRST",
+  positionKey_DESC_NULLS_LAST = "positionKey_DESC_NULLS_LAST",
+  realizedFees_ASC = "realizedFees_ASC",
+  realizedFees_ASC_NULLS_FIRST = "realizedFees_ASC_NULLS_FIRST",
+  realizedFees_ASC_NULLS_LAST = "realizedFees_ASC_NULLS_LAST",
+  realizedFees_DESC = "realizedFees_DESC",
+  realizedFees_DESC_NULLS_FIRST = "realizedFees_DESC_NULLS_FIRST",
+  realizedFees_DESC_NULLS_LAST = "realizedFees_DESC_NULLS_LAST",
+  realizedPnl_ASC = "realizedPnl_ASC",
+  realizedPnl_ASC_NULLS_FIRST = "realizedPnl_ASC_NULLS_FIRST",
+  realizedPnl_ASC_NULLS_LAST = "realizedPnl_ASC_NULLS_LAST",
+  realizedPnl_DESC = "realizedPnl_DESC",
+  realizedPnl_DESC_NULLS_FIRST = "realizedPnl_DESC_NULLS_FIRST",
+  realizedPnl_DESC_NULLS_LAST = "realizedPnl_DESC_NULLS_LAST",
+  realizedPriceImpact_ASC = "realizedPriceImpact_ASC",
+  realizedPriceImpact_ASC_NULLS_FIRST = "realizedPriceImpact_ASC_NULLS_FIRST",
+  realizedPriceImpact_ASC_NULLS_LAST = "realizedPriceImpact_ASC_NULLS_LAST",
+  realizedPriceImpact_DESC = "realizedPriceImpact_DESC",
+  realizedPriceImpact_DESC_NULLS_FIRST = "realizedPriceImpact_DESC_NULLS_FIRST",
+  realizedPriceImpact_DESC_NULLS_LAST = "realizedPriceImpact_DESC_NULLS_LAST",
+  sizeInTokens_ASC = "sizeInTokens_ASC",
+  sizeInTokens_ASC_NULLS_FIRST = "sizeInTokens_ASC_NULLS_FIRST",
+  sizeInTokens_ASC_NULLS_LAST = "sizeInTokens_ASC_NULLS_LAST",
+  sizeInTokens_DESC = "sizeInTokens_DESC",
+  sizeInTokens_DESC_NULLS_FIRST = "sizeInTokens_DESC_NULLS_FIRST",
+  sizeInTokens_DESC_NULLS_LAST = "sizeInTokens_DESC_NULLS_LAST",
+  sizeInUsd_ASC = "sizeInUsd_ASC",
+  sizeInUsd_ASC_NULLS_FIRST = "sizeInUsd_ASC_NULLS_FIRST",
+  sizeInUsd_ASC_NULLS_LAST = "sizeInUsd_ASC_NULLS_LAST",
+  sizeInUsd_DESC = "sizeInUsd_DESC",
+  sizeInUsd_DESC_NULLS_FIRST = "sizeInUsd_DESC_NULLS_FIRST",
+  sizeInUsd_DESC_NULLS_LAST = "sizeInUsd_DESC_NULLS_LAST",
+  snapshotTimestamp_ASC = "snapshotTimestamp_ASC",
+  snapshotTimestamp_ASC_NULLS_FIRST = "snapshotTimestamp_ASC_NULLS_FIRST",
+  snapshotTimestamp_ASC_NULLS_LAST = "snapshotTimestamp_ASC_NULLS_LAST",
+  snapshotTimestamp_DESC = "snapshotTimestamp_DESC",
+  snapshotTimestamp_DESC_NULLS_FIRST = "snapshotTimestamp_DESC_NULLS_FIRST",
+  snapshotTimestamp_DESC_NULLS_LAST = "snapshotTimestamp_DESC_NULLS_LAST",
+  unrealizedFees_ASC = "unrealizedFees_ASC",
+  unrealizedFees_ASC_NULLS_FIRST = "unrealizedFees_ASC_NULLS_FIRST",
+  unrealizedFees_ASC_NULLS_LAST = "unrealizedFees_ASC_NULLS_LAST",
+  unrealizedFees_DESC = "unrealizedFees_DESC",
+  unrealizedFees_DESC_NULLS_FIRST = "unrealizedFees_DESC_NULLS_FIRST",
+  unrealizedFees_DESC_NULLS_LAST = "unrealizedFees_DESC_NULLS_LAST",
+  unrealizedPnl_ASC = "unrealizedPnl_ASC",
+  unrealizedPnl_ASC_NULLS_FIRST = "unrealizedPnl_ASC_NULLS_FIRST",
+  unrealizedPnl_ASC_NULLS_LAST = "unrealizedPnl_ASC_NULLS_LAST",
+  unrealizedPnl_DESC = "unrealizedPnl_DESC",
+  unrealizedPnl_DESC_NULLS_FIRST = "unrealizedPnl_DESC_NULLS_FIRST",
+  unrealizedPnl_DESC_NULLS_LAST = "unrealizedPnl_DESC_NULLS_LAST",
+  unrealizedPriceImpact_ASC = "unrealizedPriceImpact_ASC",
+  unrealizedPriceImpact_ASC_NULLS_FIRST = "unrealizedPriceImpact_ASC_NULLS_FIRST",
+  unrealizedPriceImpact_ASC_NULLS_LAST = "unrealizedPriceImpact_ASC_NULLS_LAST",
+  unrealizedPriceImpact_DESC = "unrealizedPriceImpact_DESC",
+  unrealizedPriceImpact_DESC_NULLS_FIRST = "unrealizedPriceImpact_DESC_NULLS_FIRST",
+  unrealizedPriceImpact_DESC_NULLS_LAST = "unrealizedPriceImpact_DESC_NULLS_LAST",
+}
+
+export interface PositionTotalCollateralAmount {
+  __typename?: "PositionTotalCollateralAmount";
+  amount: Scalars["BigInt"]["output"];
+  token: Scalars["String"]["output"];
+}
+
+export interface PositionTotalCollateralAmountWhereInput {
+  marketAddress?: InputMaybe<Scalars["String"]["input"]>;
+}
+
+export interface PositionVolumeByAllMarketsWhereInput {
+  timestamp: Scalars["Float"]["input"];
+}
+
+export interface PositionVolumeWhereInput {
+  marketAddress?: InputMaybe<Scalars["String"]["input"]>;
+  timestamp: Scalars["Float"]["input"];
+}
+
+export interface PositionWhereInput {
+  AND?: InputMaybe<Array<PositionWhereInput>>;
+  OR?: InputMaybe<Array<PositionWhereInput>>;
+  accountStat?: InputMaybe<AccountStatWhereInput>;
+  accountStat_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  account_contains?: InputMaybe<Scalars["String"]["input"]>;
+  account_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  account_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_eq?: InputMaybe<Scalars["String"]["input"]>;
+  account_gt?: InputMaybe<Scalars["String"]["input"]>;
+  account_gte?: InputMaybe<Scalars["String"]["input"]>;
+  account_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  account_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  account_lt?: InputMaybe<Scalars["String"]["input"]>;
+  account_lte?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  account_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  collateralAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  collateralAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  collateralAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  collateralToken_contains?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_eq?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_gt?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_gte?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  collateralToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  collateralToken_lt?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_lte?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  collateralToken_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  collateralToken_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  entryPrice_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  entryPrice_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  entryPrice_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  entryPrice_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  entryPrice_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  entryPrice_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  entryPrice_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  entryPrice_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  entryPrice_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  isLong_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isLong_not_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isSnapshot_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isSnapshot_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isSnapshot_not_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  market_contains?: InputMaybe<Scalars["String"]["input"]>;
+  market_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  market_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  market_eq?: InputMaybe<Scalars["String"]["input"]>;
+  market_gt?: InputMaybe<Scalars["String"]["input"]>;
+  market_gte?: InputMaybe<Scalars["String"]["input"]>;
+  market_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  market_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  market_lt?: InputMaybe<Scalars["String"]["input"]>;
+  market_lte?: InputMaybe<Scalars["String"]["input"]>;
+  market_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  market_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  market_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  market_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  market_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  market_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  market_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  maxSize_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxSize_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxSize_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxSize_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxSize_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxSize_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxSize_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxSize_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxSize_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  openedAt_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  openedAt_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  openedAt_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  openedAt_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  openedAt_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  openedAt_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  openedAt_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  openedAt_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  openedAt_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  positionKey_contains?: InputMaybe<Scalars["String"]["input"]>;
+  positionKey_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  positionKey_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  positionKey_eq?: InputMaybe<Scalars["String"]["input"]>;
+  positionKey_gt?: InputMaybe<Scalars["String"]["input"]>;
+  positionKey_gte?: InputMaybe<Scalars["String"]["input"]>;
+  positionKey_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  positionKey_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  positionKey_lt?: InputMaybe<Scalars["String"]["input"]>;
+  positionKey_lte?: InputMaybe<Scalars["String"]["input"]>;
+  positionKey_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  positionKey_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  positionKey_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  positionKey_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  positionKey_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  positionKey_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  positionKey_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  realizedFees_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedFees_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedFees_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedFees_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  realizedFees_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  realizedFees_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedFees_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedFees_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedFees_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  realizedPnl_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPnl_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPnl_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPnl_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  realizedPnl_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  realizedPnl_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPnl_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPnl_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPnl_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  realizedPriceImpact_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPriceImpact_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPriceImpact_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPriceImpact_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  realizedPriceImpact_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  realizedPriceImpact_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPriceImpact_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPriceImpact_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  realizedPriceImpact_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  sizeInTokens_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInTokens_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInTokens_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInTokens_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  sizeInTokens_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  sizeInTokens_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInTokens_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInTokens_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInTokens_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  sizeInUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  sizeInUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  sizeInUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeInUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  snapshotTimestamp_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  snapshotTimestamp_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  snapshotTimestamp_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  unrealizedFees_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedFees_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedFees_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedFees_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  unrealizedFees_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  unrealizedFees_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedFees_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedFees_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedFees_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  unrealizedPnl_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedPnl_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedPnl_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedPnl_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  unrealizedPnl_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  unrealizedPnl_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedPnl_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedPnl_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedPnl_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  unrealizedPriceImpact_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedPriceImpact_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedPriceImpact_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedPriceImpact_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  unrealizedPriceImpact_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  unrealizedPriceImpact_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedPriceImpact_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedPriceImpact_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  unrealizedPriceImpact_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+}
+
+export interface PositionsConnection {
+  __typename?: "PositionsConnection";
+  edges: Array<PositionEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface Price {
+  __typename?: "Price";
+  id: Scalars["String"]["output"];
+  isSnapshot: Scalars["Boolean"]["output"];
+  maxPrice: Scalars["BigInt"]["output"];
+  minPrice: Scalars["BigInt"]["output"];
+  snapshotTimestamp?: Maybe<Scalars["Int"]["output"]>;
+  timestamp: Scalars["Int"]["output"];
+  token: Scalars["String"]["output"];
+  type: PriceType;
+}
+
+export interface PriceEdge {
+  __typename?: "PriceEdge";
+  cursor: Scalars["String"]["output"];
+  node: Price;
+}
+
+export enum PriceOrderByInput {
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  isSnapshot_ASC = "isSnapshot_ASC",
+  isSnapshot_ASC_NULLS_FIRST = "isSnapshot_ASC_NULLS_FIRST",
+  isSnapshot_ASC_NULLS_LAST = "isSnapshot_ASC_NULLS_LAST",
+  isSnapshot_DESC = "isSnapshot_DESC",
+  isSnapshot_DESC_NULLS_FIRST = "isSnapshot_DESC_NULLS_FIRST",
+  isSnapshot_DESC_NULLS_LAST = "isSnapshot_DESC_NULLS_LAST",
+  maxPrice_ASC = "maxPrice_ASC",
+  maxPrice_ASC_NULLS_FIRST = "maxPrice_ASC_NULLS_FIRST",
+  maxPrice_ASC_NULLS_LAST = "maxPrice_ASC_NULLS_LAST",
+  maxPrice_DESC = "maxPrice_DESC",
+  maxPrice_DESC_NULLS_FIRST = "maxPrice_DESC_NULLS_FIRST",
+  maxPrice_DESC_NULLS_LAST = "maxPrice_DESC_NULLS_LAST",
+  minPrice_ASC = "minPrice_ASC",
+  minPrice_ASC_NULLS_FIRST = "minPrice_ASC_NULLS_FIRST",
+  minPrice_ASC_NULLS_LAST = "minPrice_ASC_NULLS_LAST",
+  minPrice_DESC = "minPrice_DESC",
+  minPrice_DESC_NULLS_FIRST = "minPrice_DESC_NULLS_FIRST",
+  minPrice_DESC_NULLS_LAST = "minPrice_DESC_NULLS_LAST",
+  snapshotTimestamp_ASC = "snapshotTimestamp_ASC",
+  snapshotTimestamp_ASC_NULLS_FIRST = "snapshotTimestamp_ASC_NULLS_FIRST",
+  snapshotTimestamp_ASC_NULLS_LAST = "snapshotTimestamp_ASC_NULLS_LAST",
+  snapshotTimestamp_DESC = "snapshotTimestamp_DESC",
+  snapshotTimestamp_DESC_NULLS_FIRST = "snapshotTimestamp_DESC_NULLS_FIRST",
+  snapshotTimestamp_DESC_NULLS_LAST = "snapshotTimestamp_DESC_NULLS_LAST",
+  timestamp_ASC = "timestamp_ASC",
+  timestamp_ASC_NULLS_FIRST = "timestamp_ASC_NULLS_FIRST",
+  timestamp_ASC_NULLS_LAST = "timestamp_ASC_NULLS_LAST",
+  timestamp_DESC = "timestamp_DESC",
+  timestamp_DESC_NULLS_FIRST = "timestamp_DESC_NULLS_FIRST",
+  timestamp_DESC_NULLS_LAST = "timestamp_DESC_NULLS_LAST",
+  token_ASC = "token_ASC",
+  token_ASC_NULLS_FIRST = "token_ASC_NULLS_FIRST",
+  token_ASC_NULLS_LAST = "token_ASC_NULLS_LAST",
+  token_DESC = "token_DESC",
+  token_DESC_NULLS_FIRST = "token_DESC_NULLS_FIRST",
+  token_DESC_NULLS_LAST = "token_DESC_NULLS_LAST",
+  type_ASC = "type_ASC",
+  type_ASC_NULLS_FIRST = "type_ASC_NULLS_FIRST",
+  type_ASC_NULLS_LAST = "type_ASC_NULLS_LAST",
+  type_DESC = "type_DESC",
+  type_DESC_NULLS_FIRST = "type_DESC_NULLS_FIRST",
+  type_DESC_NULLS_LAST = "type_DESC_NULLS_LAST",
+}
+
+export enum PriceType {
+  glv = "glv",
+  gm = "gm",
+  onchainFeed = "onchainFeed",
+  v2 = "v2",
+}
+
+export interface PriceWhereInput {
+  AND?: InputMaybe<Array<PriceWhereInput>>;
+  OR?: InputMaybe<Array<PriceWhereInput>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  isSnapshot_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isSnapshot_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isSnapshot_not_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxPrice_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPrice_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPrice_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPrice_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  maxPrice_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  maxPrice_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPrice_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPrice_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  maxPrice_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  minPrice_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minPrice_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minPrice_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minPrice_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  minPrice_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  minPrice_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minPrice_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minPrice_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minPrice_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  snapshotTimestamp_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  snapshotTimestamp_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  snapshotTimestamp_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  snapshotTimestamp_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  timestamp_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  timestamp_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  timestamp_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  token_contains?: InputMaybe<Scalars["String"]["input"]>;
+  token_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  token_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  token_eq?: InputMaybe<Scalars["String"]["input"]>;
+  token_gt?: InputMaybe<Scalars["String"]["input"]>;
+  token_gte?: InputMaybe<Scalars["String"]["input"]>;
+  token_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  token_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  token_lt?: InputMaybe<Scalars["String"]["input"]>;
+  token_lte?: InputMaybe<Scalars["String"]["input"]>;
+  token_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  token_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  token_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  token_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  token_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  token_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  token_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  type_eq?: InputMaybe<PriceType>;
+  type_in?: InputMaybe<Array<PriceType>>;
+  type_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  type_not_eq?: InputMaybe<PriceType>;
+  type_not_in?: InputMaybe<Array<PriceType>>;
+}
+
+export interface PricesConnection {
+  __typename?: "PricesConnection";
+  edges: Array<PriceEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface ProcessorStatus {
+  __typename?: "ProcessorStatus";
+  id: Scalars["String"]["output"];
+  lastParsedBlockNumber: Scalars["Int"]["output"];
+  lastParsedBlockTimestamp: Scalars["Int"]["output"];
+  lastProcessorCallTimestamp: Scalars["Int"]["output"];
+}
+
+export interface ProcessorStatusEdge {
+  __typename?: "ProcessorStatusEdge";
+  cursor: Scalars["String"]["output"];
+  node: ProcessorStatus;
+}
+
+export enum ProcessorStatusOrderByInput {
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  lastParsedBlockNumber_ASC = "lastParsedBlockNumber_ASC",
+  lastParsedBlockNumber_ASC_NULLS_FIRST = "lastParsedBlockNumber_ASC_NULLS_FIRST",
+  lastParsedBlockNumber_ASC_NULLS_LAST = "lastParsedBlockNumber_ASC_NULLS_LAST",
+  lastParsedBlockNumber_DESC = "lastParsedBlockNumber_DESC",
+  lastParsedBlockNumber_DESC_NULLS_FIRST = "lastParsedBlockNumber_DESC_NULLS_FIRST",
+  lastParsedBlockNumber_DESC_NULLS_LAST = "lastParsedBlockNumber_DESC_NULLS_LAST",
+  lastParsedBlockTimestamp_ASC = "lastParsedBlockTimestamp_ASC",
+  lastParsedBlockTimestamp_ASC_NULLS_FIRST = "lastParsedBlockTimestamp_ASC_NULLS_FIRST",
+  lastParsedBlockTimestamp_ASC_NULLS_LAST = "lastParsedBlockTimestamp_ASC_NULLS_LAST",
+  lastParsedBlockTimestamp_DESC = "lastParsedBlockTimestamp_DESC",
+  lastParsedBlockTimestamp_DESC_NULLS_FIRST = "lastParsedBlockTimestamp_DESC_NULLS_FIRST",
+  lastParsedBlockTimestamp_DESC_NULLS_LAST = "lastParsedBlockTimestamp_DESC_NULLS_LAST",
+  lastProcessorCallTimestamp_ASC = "lastProcessorCallTimestamp_ASC",
+  lastProcessorCallTimestamp_ASC_NULLS_FIRST = "lastProcessorCallTimestamp_ASC_NULLS_FIRST",
+  lastProcessorCallTimestamp_ASC_NULLS_LAST = "lastProcessorCallTimestamp_ASC_NULLS_LAST",
+  lastProcessorCallTimestamp_DESC = "lastProcessorCallTimestamp_DESC",
+  lastProcessorCallTimestamp_DESC_NULLS_FIRST = "lastProcessorCallTimestamp_DESC_NULLS_FIRST",
+  lastProcessorCallTimestamp_DESC_NULLS_LAST = "lastProcessorCallTimestamp_DESC_NULLS_LAST",
+}
+
+export interface ProcessorStatusWhereInput {
+  AND?: InputMaybe<Array<ProcessorStatusWhereInput>>;
+  OR?: InputMaybe<Array<ProcessorStatusWhereInput>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  lastParsedBlockNumber_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  lastParsedBlockNumber_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  lastParsedBlockNumber_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  lastParsedBlockNumber_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  lastParsedBlockNumber_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  lastParsedBlockNumber_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  lastParsedBlockNumber_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  lastParsedBlockNumber_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  lastParsedBlockNumber_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  lastParsedBlockTimestamp_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  lastParsedBlockTimestamp_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  lastParsedBlockTimestamp_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  lastParsedBlockTimestamp_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  lastParsedBlockTimestamp_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  lastParsedBlockTimestamp_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  lastParsedBlockTimestamp_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  lastParsedBlockTimestamp_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  lastParsedBlockTimestamp_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  lastProcessorCallTimestamp_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  lastProcessorCallTimestamp_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  lastProcessorCallTimestamp_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  lastProcessorCallTimestamp_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  lastProcessorCallTimestamp_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  lastProcessorCallTimestamp_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  lastProcessorCallTimestamp_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  lastProcessorCallTimestamp_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  lastProcessorCallTimestamp_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+}
+
+export interface ProcessorStatusesConnection {
+  __typename?: "ProcessorStatusesConnection";
+  edges: Array<ProcessorStatusEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface Query {
+  __typename?: "Query";
+  accountPnlHistoryStats: Array<AccountPnlHistoryPointObject>;
+  accountPnlSummaryStats: Array<AccountPnlSummaryBucketObject>;
+  accountStatById?: Maybe<AccountStat>;
+  accountStats: Array<AccountStat>;
+  accountStatsConnection: AccountStatsConnection;
+  annualizedPerformance: Array<AnnualizedPerformanceObject>;
+  aprSnapshotById?: Maybe<AprSnapshot>;
+  aprSnapshots: Array<AprSnapshot>;
+  aprSnapshotsConnection: AprSnapshotsConnection;
+  borrowingRateSnapshotById?: Maybe<BorrowingRateSnapshot>;
+  borrowingRateSnapshots: Array<BorrowingRateSnapshot>;
+  borrowingRateSnapshotsConnection: BorrowingRateSnapshotsConnection;
+  claimActionById?: Maybe<ClaimAction>;
+  claimActions: Array<ClaimAction>;
+  claimActionsConnection: ClaimActionsConnection;
+  claimRefById?: Maybe<ClaimRef>;
+  claimRefs: Array<ClaimRef>;
+  claimRefsConnection: ClaimRefsConnection;
+  claimableCollateralById?: Maybe<ClaimableCollateral>;
+  claimableCollateralGroupById?: Maybe<ClaimableCollateralGroup>;
+  claimableCollateralGroups: Array<ClaimableCollateralGroup>;
+  claimableCollateralGroupsConnection: ClaimableCollateralGroupsConnection;
+  claimableCollaterals: Array<ClaimableCollateral>;
+  claimableCollateralsConnection: ClaimableCollateralsConnection;
+  claimableFundingFeeInfoById?: Maybe<ClaimableFundingFeeInfo>;
+  claimableFundingFeeInfos: Array<ClaimableFundingFeeInfo>;
+  claimableFundingFeeInfosConnection: ClaimableFundingFeeInfosConnection;
+  collectedFeesInfoById?: Maybe<CollectedFeesInfo>;
+  collectedFeesInfos: Array<CollectedFeesInfo>;
+  collectedFeesInfosConnection: CollectedFeesInfosConnection;
+  cumulativePnlById?: Maybe<CumulativePnl>;
+  cumulativePnls: Array<CumulativePnl>;
+  cumulativePnlsConnection: CumulativePnlsConnection;
+  cumulativePoolValueById?: Maybe<CumulativePoolValue>;
+  cumulativePoolValues: Array<CumulativePoolValue>;
+  cumulativePoolValuesConnection: CumulativePoolValuesConnection;
+  distributionById?: Maybe<Distribution>;
+  distributions: Array<Distribution>;
+  distributionsConnection: DistributionsConnection;
+  glvById?: Maybe<Glv>;
+  glvs: Array<Glv>;
+  glvsAprByPeriod: Array<GlvApr>;
+  glvsConnection: GlvsConnection;
+  glvsPnlAprByPeriod: Array<GlvPnlApr>;
+  marketById?: Maybe<Market>;
+  marketInfoById?: Maybe<MarketInfo>;
+  marketInfos: Array<MarketInfo>;
+  marketInfosConnection: MarketInfosConnection;
+  markets: Array<Market>;
+  marketsAprByPeriod: Array<MarketApr>;
+  marketsConnection: MarketsConnection;
+  marketsPnlAprByPeriod: Array<MarketPnlApr>;
+  multichainFunding: Array<MultichainFundingInfo>;
+  multichainFundingReceiveEventById?: Maybe<MultichainFundingReceiveEvent>;
+  multichainFundingReceiveEvents: Array<MultichainFundingReceiveEvent>;
+  multichainFundingReceiveEventsConnection: MultichainFundingReceiveEventsConnection;
+  multichainFundingSendEventById?: Maybe<MultichainFundingSendEvent>;
+  multichainFundingSendEvents: Array<MultichainFundingSendEvent>;
+  multichainFundingSendEventsConnection: MultichainFundingSendEventsConnection;
+  multichainMetadata: Array<MultichainMetadata>;
+  multichainMetadataById?: Maybe<MultichainMetadata>;
+  multichainMetadataConnection: MultichainMetadataConnection;
+  onChainSettingById?: Maybe<OnChainSetting>;
+  onChainSettings: Array<OnChainSetting>;
+  onChainSettingsConnection: OnChainSettingsConnection;
+  orderById?: Maybe<Order>;
+  orders: Array<Order>;
+  ordersConnection: OrdersConnection;
+  performanceSnapshots: Array<PerformanceSnapshots>;
+  periodAccountStats: Array<PeriodAccountStatObject>;
+  pnlAprSnapshotById?: Maybe<PnlAprSnapshot>;
+  pnlAprSnapshots: Array<PnlAprSnapshot>;
+  pnlAprSnapshotsConnection: PnlAprSnapshotsConnection;
+  positionById?: Maybe<Position>;
+  positionChangeById?: Maybe<PositionChange>;
+  positionChanges: Array<PositionChange>;
+  positionChangesConnection: PositionChangesConnection;
+  positionFeesEntities: Array<PositionFeesEntity>;
+  positionFeesEntitiesConnection: PositionFeesEntitiesConnection;
+  positionFeesEntityById?: Maybe<PositionFeesEntity>;
+  positionTotalCollateralAmount: Array<PositionTotalCollateralAmount>;
+  positions: Array<Position>;
+  positionsConnection: PositionsConnection;
+  positionsVolume: Array<PositionMarketVolumeInfo>;
+  positionsVolume24hByMarket: Scalars["BigInt"]["output"];
+  priceById?: Maybe<Price>;
+  prices: Array<Price>;
+  pricesConnection: PricesConnection;
+  processorStatusById?: Maybe<ProcessorStatus>;
+  processorStatuses: Array<ProcessorStatus>;
+  processorStatusesConnection: ProcessorStatusesConnection;
+  squidStatus: SquidStatus;
+  swapInfoById?: Maybe<SwapInfo>;
+  swapInfos: Array<SwapInfo>;
+  swapInfosConnection: SwapInfosConnection;
+  totalPositionChanges: Scalars["Float"]["output"];
+  tradeActionById?: Maybe<TradeAction>;
+  tradeActions: Array<TradeAction>;
+  tradeActionsConnection: TradeActionsConnection;
+  transactionById?: Maybe<Transaction>;
+  transactions: Array<Transaction>;
+  transactionsConnection: TransactionsConnection;
+}
+
+export interface QueryaccountPnlHistoryStatsArgs {
+  account: Scalars["String"]["input"];
+  from?: InputMaybe<Scalars["Int"]["input"]>;
+}
+
+export interface QueryaccountPnlSummaryStatsArgs {
+  account: Scalars["String"]["input"];
+}
+
+export interface QueryaccountStatByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QueryaccountStatsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<AccountStatOrderByInput>>;
+  where?: InputMaybe<AccountStatWhereInput>;
+}
+
+export interface QueryaccountStatsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<AccountStatOrderByInput>;
+  where?: InputMaybe<AccountStatWhereInput>;
+}
+
+export interface QueryannualizedPerformanceArgs {
+  where?: InputMaybe<PerformanceWhereInput>;
+}
+
+export interface QueryaprSnapshotByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QueryaprSnapshotsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<AprSnapshotOrderByInput>>;
+  where?: InputMaybe<AprSnapshotWhereInput>;
+}
+
+export interface QueryaprSnapshotsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<AprSnapshotOrderByInput>;
+  where?: InputMaybe<AprSnapshotWhereInput>;
+}
+
+export interface QueryborrowingRateSnapshotByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QueryborrowingRateSnapshotsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<BorrowingRateSnapshotOrderByInput>>;
+  where?: InputMaybe<BorrowingRateSnapshotWhereInput>;
+}
+
+export interface QueryborrowingRateSnapshotsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<BorrowingRateSnapshotOrderByInput>;
+  where?: InputMaybe<BorrowingRateSnapshotWhereInput>;
+}
+
+export interface QueryclaimActionByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QueryclaimActionsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<ClaimActionOrderByInput>>;
+  where?: InputMaybe<ClaimActionWhereInput>;
+}
+
+export interface QueryclaimActionsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<ClaimActionOrderByInput>;
+  where?: InputMaybe<ClaimActionWhereInput>;
+}
+
+export interface QueryclaimRefByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QueryclaimRefsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<ClaimRefOrderByInput>>;
+  where?: InputMaybe<ClaimRefWhereInput>;
+}
+
+export interface QueryclaimRefsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<ClaimRefOrderByInput>;
+  where?: InputMaybe<ClaimRefWhereInput>;
+}
+
+export interface QueryclaimableCollateralByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QueryclaimableCollateralGroupByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QueryclaimableCollateralGroupsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<ClaimableCollateralGroupOrderByInput>>;
+  where?: InputMaybe<ClaimableCollateralGroupWhereInput>;
+}
+
+export interface QueryclaimableCollateralGroupsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<ClaimableCollateralGroupOrderByInput>;
+  where?: InputMaybe<ClaimableCollateralGroupWhereInput>;
+}
+
+export interface QueryclaimableCollateralsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<ClaimableCollateralOrderByInput>>;
+  where?: InputMaybe<ClaimableCollateralWhereInput>;
+}
+
+export interface QueryclaimableCollateralsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<ClaimableCollateralOrderByInput>;
+  where?: InputMaybe<ClaimableCollateralWhereInput>;
+}
+
+export interface QueryclaimableFundingFeeInfoByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QueryclaimableFundingFeeInfosArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<ClaimableFundingFeeInfoOrderByInput>>;
+  where?: InputMaybe<ClaimableFundingFeeInfoWhereInput>;
+}
+
+export interface QueryclaimableFundingFeeInfosConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<ClaimableFundingFeeInfoOrderByInput>;
+  where?: InputMaybe<ClaimableFundingFeeInfoWhereInput>;
+}
+
+export interface QuerycollectedFeesInfoByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QuerycollectedFeesInfosArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<CollectedFeesInfoOrderByInput>>;
+  where?: InputMaybe<CollectedFeesInfoWhereInput>;
+}
+
+export interface QuerycollectedFeesInfosConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<CollectedFeesInfoOrderByInput>;
+  where?: InputMaybe<CollectedFeesInfoWhereInput>;
+}
+
+export interface QuerycumulativePnlByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QuerycumulativePnlsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<CumulativePnlOrderByInput>>;
+  where?: InputMaybe<CumulativePnlWhereInput>;
+}
+
+export interface QuerycumulativePnlsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<CumulativePnlOrderByInput>;
+  where?: InputMaybe<CumulativePnlWhereInput>;
+}
+
+export interface QuerycumulativePoolValueByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QuerycumulativePoolValuesArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<CumulativePoolValueOrderByInput>>;
+  where?: InputMaybe<CumulativePoolValueWhereInput>;
+}
+
+export interface QuerycumulativePoolValuesConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<CumulativePoolValueOrderByInput>;
+  where?: InputMaybe<CumulativePoolValueWhereInput>;
+}
+
+export interface QuerydistributionByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QuerydistributionsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<DistributionOrderByInput>>;
+  where?: InputMaybe<DistributionWhereInput>;
+}
+
+export interface QuerydistributionsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<DistributionOrderByInput>;
+  where?: InputMaybe<DistributionWhereInput>;
+}
+
+export interface QueryglvByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QueryglvsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<GlvOrderByInput>>;
+  where?: InputMaybe<GlvWhereInput>;
+}
+
+export interface QueryglvsAprByPeriodArgs {
+  where?: InputMaybe<GlvAprsWhereInputWhereInput>;
+}
+
+export interface QueryglvsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<GlvOrderByInput>;
+  where?: InputMaybe<GlvWhereInput>;
+}
+
+export interface QueryglvsPnlAprByPeriodArgs {
+  where?: InputMaybe<GlvPnlAprsWhereInputWhereInput>;
+}
+
+export interface QuerymarketByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QuerymarketInfoByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QuerymarketInfosArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<MarketInfoOrderByInput>>;
+  where?: InputMaybe<MarketInfoWhereInput>;
+}
+
+export interface QuerymarketInfosConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<MarketInfoOrderByInput>;
+  where?: InputMaybe<MarketInfoWhereInput>;
+}
+
+export interface QuerymarketsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<MarketOrderByInput>>;
+  where?: InputMaybe<MarketWhereInput>;
+}
+
+export interface QuerymarketsAprByPeriodArgs {
+  where?: InputMaybe<MarketAprsWhereInput>;
+}
+
+export interface QuerymarketsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<MarketOrderByInput>;
+  where?: InputMaybe<MarketWhereInput>;
+}
+
+export interface QuerymarketsPnlAprByPeriodArgs {
+  where?: InputMaybe<MarketPnlAprsWhereInput>;
+}
+
+export interface QuerymultichainFundingArgs {
+  where?: InputMaybe<MultichainFundingWhereInput>;
+}
+
+export interface QuerymultichainFundingReceiveEventByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QuerymultichainFundingReceiveEventsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<MultichainFundingReceiveEventOrderByInput>>;
+  where?: InputMaybe<MultichainFundingReceiveEventWhereInput>;
+}
+
+export interface QuerymultichainFundingReceiveEventsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<MultichainFundingReceiveEventOrderByInput>;
+  where?: InputMaybe<MultichainFundingReceiveEventWhereInput>;
+}
+
+export interface QuerymultichainFundingSendEventByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QuerymultichainFundingSendEventsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<MultichainFundingSendEventOrderByInput>>;
+  where?: InputMaybe<MultichainFundingSendEventWhereInput>;
+}
+
+export interface QuerymultichainFundingSendEventsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<MultichainFundingSendEventOrderByInput>;
+  where?: InputMaybe<MultichainFundingSendEventWhereInput>;
+}
+
+export interface QuerymultichainMetadataArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<MultichainMetadataOrderByInput>>;
+  where?: InputMaybe<MultichainMetadataWhereInput>;
+}
+
+export interface QuerymultichainMetadataByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QuerymultichainMetadataConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<MultichainMetadataOrderByInput>;
+  where?: InputMaybe<MultichainMetadataWhereInput>;
+}
+
+export interface QueryonChainSettingByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QueryonChainSettingsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<OnChainSettingOrderByInput>>;
+  where?: InputMaybe<OnChainSettingWhereInput>;
+}
+
+export interface QueryonChainSettingsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<OnChainSettingOrderByInput>;
+  where?: InputMaybe<OnChainSettingWhereInput>;
+}
+
+export interface QueryorderByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QueryordersArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<OrderOrderByInput>>;
+  where?: InputMaybe<OrderWhereInput>;
+}
+
+export interface QueryordersConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<OrderOrderByInput>;
+  where?: InputMaybe<OrderWhereInput>;
+}
+
+export interface QueryperformanceSnapshotsArgs {
+  where?: InputMaybe<PerformanceWhereInput>;
+}
+
+export interface QueryperiodAccountStatsArgs {
+  limit?: InputMaybe<Scalars["Float"]["input"]>;
+  offset?: InputMaybe<Scalars["Float"]["input"]>;
+  where?: InputMaybe<WhereInput>;
+}
+
+export interface QuerypnlAprSnapshotByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QuerypnlAprSnapshotsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<PnlAprSnapshotOrderByInput>>;
+  where?: InputMaybe<PnlAprSnapshotWhereInput>;
+}
+
+export interface QuerypnlAprSnapshotsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<PnlAprSnapshotOrderByInput>;
+  where?: InputMaybe<PnlAprSnapshotWhereInput>;
+}
+
+export interface QuerypositionByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QuerypositionChangeByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QuerypositionChangesArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<PositionChangeOrderByInput>>;
+  where?: InputMaybe<PositionChangeWhereInput>;
+}
+
+export interface QuerypositionChangesConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<PositionChangeOrderByInput>;
+  where?: InputMaybe<PositionChangeWhereInput>;
+}
+
+export interface QuerypositionFeesEntitiesArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<PositionFeesEntityOrderByInput>>;
+  where?: InputMaybe<PositionFeesEntityWhereInput>;
+}
+
+export interface QuerypositionFeesEntitiesConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<PositionFeesEntityOrderByInput>;
+  where?: InputMaybe<PositionFeesEntityWhereInput>;
+}
+
+export interface QuerypositionFeesEntityByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QuerypositionTotalCollateralAmountArgs {
+  where?: InputMaybe<PositionTotalCollateralAmountWhereInput>;
+}
+
+export interface QuerypositionsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<PositionOrderByInput>>;
+  where?: InputMaybe<PositionWhereInput>;
+}
+
+export interface QuerypositionsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<PositionOrderByInput>;
+  where?: InputMaybe<PositionWhereInput>;
+}
+
+export interface QuerypositionsVolumeArgs {
+  where?: InputMaybe<PositionVolumeByAllMarketsWhereInput>;
+}
+
+export interface QuerypositionsVolume24hByMarketArgs {
+  where?: InputMaybe<PositionVolumeWhereInput>;
+}
+
+export interface QuerypriceByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QuerypricesArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<PriceOrderByInput>>;
+  where?: InputMaybe<PriceWhereInput>;
+}
+
+export interface QuerypricesConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<PriceOrderByInput>;
+  where?: InputMaybe<PriceWhereInput>;
+}
+
+export interface QueryprocessorStatusByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QueryprocessorStatusesArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<ProcessorStatusOrderByInput>>;
+  where?: InputMaybe<ProcessorStatusWhereInput>;
+}
+
+export interface QueryprocessorStatusesConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<ProcessorStatusOrderByInput>;
+  where?: InputMaybe<ProcessorStatusWhereInput>;
+}
+
+export interface QueryswapInfoByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QueryswapInfosArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<SwapInfoOrderByInput>>;
+  where?: InputMaybe<SwapInfoWhereInput>;
+}
+
+export interface QueryswapInfosConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<SwapInfoOrderByInput>;
+  where?: InputMaybe<SwapInfoWhereInput>;
+}
+
+export interface QuerytradeActionByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QuerytradeActionsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<TradeActionOrderByInput>>;
+  where?: InputMaybe<TradeActionWhereInput>;
+}
+
+export interface QuerytradeActionsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<TradeActionOrderByInput>;
+  where?: InputMaybe<TradeActionWhereInput>;
+}
+
+export interface QuerytransactionByIdArgs {
+  id: Scalars["String"]["input"];
+}
+
+export interface QuerytransactionsArgs {
+  limit?: InputMaybe<Scalars["Int"]["input"]>;
+  offset?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy?: InputMaybe<Array<TransactionOrderByInput>>;
+  where?: InputMaybe<TransactionWhereInput>;
+}
+
+export interface QuerytransactionsConnectionArgs {
+  after?: InputMaybe<Scalars["String"]["input"]>;
+  first?: InputMaybe<Scalars["Int"]["input"]>;
+  orderBy: Array<TransactionOrderByInput>;
+  where?: InputMaybe<TransactionWhereInput>;
+}
+
+export interface SquidStatus {
+  __typename?: "SquidStatus";
+  finalizedHeight: Scalars["Float"]["output"];
+  height: Scalars["Float"]["output"];
+}
+
+export interface SwapInfo {
+  __typename?: "SwapInfo";
+  amountIn: Scalars["BigInt"]["output"];
+  amountInAfterFees: Scalars["BigInt"]["output"];
+  amountOut: Scalars["BigInt"]["output"];
+  id: Scalars["String"]["output"];
+  marketAddress: Scalars["String"]["output"];
+  orderKey: Scalars["String"]["output"];
+  priceImpactUsd: Scalars["BigInt"]["output"];
+  receiver: Scalars["String"]["output"];
+  tokenInAddress: Scalars["String"]["output"];
+  tokenInPrice: Scalars["BigInt"]["output"];
+  tokenOutAddress: Scalars["String"]["output"];
+  tokenOutPrice: Scalars["BigInt"]["output"];
+  transaction: Transaction;
+}
+
+export interface SwapInfoEdge {
+  __typename?: "SwapInfoEdge";
+  cursor: Scalars["String"]["output"];
+  node: SwapInfo;
+}
+
+export enum SwapInfoOrderByInput {
+  amountInAfterFees_ASC = "amountInAfterFees_ASC",
+  amountInAfterFees_ASC_NULLS_FIRST = "amountInAfterFees_ASC_NULLS_FIRST",
+  amountInAfterFees_ASC_NULLS_LAST = "amountInAfterFees_ASC_NULLS_LAST",
+  amountInAfterFees_DESC = "amountInAfterFees_DESC",
+  amountInAfterFees_DESC_NULLS_FIRST = "amountInAfterFees_DESC_NULLS_FIRST",
+  amountInAfterFees_DESC_NULLS_LAST = "amountInAfterFees_DESC_NULLS_LAST",
+  amountIn_ASC = "amountIn_ASC",
+  amountIn_ASC_NULLS_FIRST = "amountIn_ASC_NULLS_FIRST",
+  amountIn_ASC_NULLS_LAST = "amountIn_ASC_NULLS_LAST",
+  amountIn_DESC = "amountIn_DESC",
+  amountIn_DESC_NULLS_FIRST = "amountIn_DESC_NULLS_FIRST",
+  amountIn_DESC_NULLS_LAST = "amountIn_DESC_NULLS_LAST",
+  amountOut_ASC = "amountOut_ASC",
+  amountOut_ASC_NULLS_FIRST = "amountOut_ASC_NULLS_FIRST",
+  amountOut_ASC_NULLS_LAST = "amountOut_ASC_NULLS_LAST",
+  amountOut_DESC = "amountOut_DESC",
+  amountOut_DESC_NULLS_FIRST = "amountOut_DESC_NULLS_FIRST",
+  amountOut_DESC_NULLS_LAST = "amountOut_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  marketAddress_ASC = "marketAddress_ASC",
+  marketAddress_ASC_NULLS_FIRST = "marketAddress_ASC_NULLS_FIRST",
+  marketAddress_ASC_NULLS_LAST = "marketAddress_ASC_NULLS_LAST",
+  marketAddress_DESC = "marketAddress_DESC",
+  marketAddress_DESC_NULLS_FIRST = "marketAddress_DESC_NULLS_FIRST",
+  marketAddress_DESC_NULLS_LAST = "marketAddress_DESC_NULLS_LAST",
+  orderKey_ASC = "orderKey_ASC",
+  orderKey_ASC_NULLS_FIRST = "orderKey_ASC_NULLS_FIRST",
+  orderKey_ASC_NULLS_LAST = "orderKey_ASC_NULLS_LAST",
+  orderKey_DESC = "orderKey_DESC",
+  orderKey_DESC_NULLS_FIRST = "orderKey_DESC_NULLS_FIRST",
+  orderKey_DESC_NULLS_LAST = "orderKey_DESC_NULLS_LAST",
+  priceImpactUsd_ASC = "priceImpactUsd_ASC",
+  priceImpactUsd_ASC_NULLS_FIRST = "priceImpactUsd_ASC_NULLS_FIRST",
+  priceImpactUsd_ASC_NULLS_LAST = "priceImpactUsd_ASC_NULLS_LAST",
+  priceImpactUsd_DESC = "priceImpactUsd_DESC",
+  priceImpactUsd_DESC_NULLS_FIRST = "priceImpactUsd_DESC_NULLS_FIRST",
+  priceImpactUsd_DESC_NULLS_LAST = "priceImpactUsd_DESC_NULLS_LAST",
+  receiver_ASC = "receiver_ASC",
+  receiver_ASC_NULLS_FIRST = "receiver_ASC_NULLS_FIRST",
+  receiver_ASC_NULLS_LAST = "receiver_ASC_NULLS_LAST",
+  receiver_DESC = "receiver_DESC",
+  receiver_DESC_NULLS_FIRST = "receiver_DESC_NULLS_FIRST",
+  receiver_DESC_NULLS_LAST = "receiver_DESC_NULLS_LAST",
+  tokenInAddress_ASC = "tokenInAddress_ASC",
+  tokenInAddress_ASC_NULLS_FIRST = "tokenInAddress_ASC_NULLS_FIRST",
+  tokenInAddress_ASC_NULLS_LAST = "tokenInAddress_ASC_NULLS_LAST",
+  tokenInAddress_DESC = "tokenInAddress_DESC",
+  tokenInAddress_DESC_NULLS_FIRST = "tokenInAddress_DESC_NULLS_FIRST",
+  tokenInAddress_DESC_NULLS_LAST = "tokenInAddress_DESC_NULLS_LAST",
+  tokenInPrice_ASC = "tokenInPrice_ASC",
+  tokenInPrice_ASC_NULLS_FIRST = "tokenInPrice_ASC_NULLS_FIRST",
+  tokenInPrice_ASC_NULLS_LAST = "tokenInPrice_ASC_NULLS_LAST",
+  tokenInPrice_DESC = "tokenInPrice_DESC",
+  tokenInPrice_DESC_NULLS_FIRST = "tokenInPrice_DESC_NULLS_FIRST",
+  tokenInPrice_DESC_NULLS_LAST = "tokenInPrice_DESC_NULLS_LAST",
+  tokenOutAddress_ASC = "tokenOutAddress_ASC",
+  tokenOutAddress_ASC_NULLS_FIRST = "tokenOutAddress_ASC_NULLS_FIRST",
+  tokenOutAddress_ASC_NULLS_LAST = "tokenOutAddress_ASC_NULLS_LAST",
+  tokenOutAddress_DESC = "tokenOutAddress_DESC",
+  tokenOutAddress_DESC_NULLS_FIRST = "tokenOutAddress_DESC_NULLS_FIRST",
+  tokenOutAddress_DESC_NULLS_LAST = "tokenOutAddress_DESC_NULLS_LAST",
+  tokenOutPrice_ASC = "tokenOutPrice_ASC",
+  tokenOutPrice_ASC_NULLS_FIRST = "tokenOutPrice_ASC_NULLS_FIRST",
+  tokenOutPrice_ASC_NULLS_LAST = "tokenOutPrice_ASC_NULLS_LAST",
+  tokenOutPrice_DESC = "tokenOutPrice_DESC",
+  tokenOutPrice_DESC_NULLS_FIRST = "tokenOutPrice_DESC_NULLS_FIRST",
+  tokenOutPrice_DESC_NULLS_LAST = "tokenOutPrice_DESC_NULLS_LAST",
+  transaction_blockNumber_ASC = "transaction_blockNumber_ASC",
+  transaction_blockNumber_ASC_NULLS_FIRST = "transaction_blockNumber_ASC_NULLS_FIRST",
+  transaction_blockNumber_ASC_NULLS_LAST = "transaction_blockNumber_ASC_NULLS_LAST",
+  transaction_blockNumber_DESC = "transaction_blockNumber_DESC",
+  transaction_blockNumber_DESC_NULLS_FIRST = "transaction_blockNumber_DESC_NULLS_FIRST",
+  transaction_blockNumber_DESC_NULLS_LAST = "transaction_blockNumber_DESC_NULLS_LAST",
+  transaction_chainId_ASC = "transaction_chainId_ASC",
+  transaction_chainId_ASC_NULLS_FIRST = "transaction_chainId_ASC_NULLS_FIRST",
+  transaction_chainId_ASC_NULLS_LAST = "transaction_chainId_ASC_NULLS_LAST",
+  transaction_chainId_DESC = "transaction_chainId_DESC",
+  transaction_chainId_DESC_NULLS_FIRST = "transaction_chainId_DESC_NULLS_FIRST",
+  transaction_chainId_DESC_NULLS_LAST = "transaction_chainId_DESC_NULLS_LAST",
+  transaction_from_ASC = "transaction_from_ASC",
+  transaction_from_ASC_NULLS_FIRST = "transaction_from_ASC_NULLS_FIRST",
+  transaction_from_ASC_NULLS_LAST = "transaction_from_ASC_NULLS_LAST",
+  transaction_from_DESC = "transaction_from_DESC",
+  transaction_from_DESC_NULLS_FIRST = "transaction_from_DESC_NULLS_FIRST",
+  transaction_from_DESC_NULLS_LAST = "transaction_from_DESC_NULLS_LAST",
+  transaction_hash_ASC = "transaction_hash_ASC",
+  transaction_hash_ASC_NULLS_FIRST = "transaction_hash_ASC_NULLS_FIRST",
+  transaction_hash_ASC_NULLS_LAST = "transaction_hash_ASC_NULLS_LAST",
+  transaction_hash_DESC = "transaction_hash_DESC",
+  transaction_hash_DESC_NULLS_FIRST = "transaction_hash_DESC_NULLS_FIRST",
+  transaction_hash_DESC_NULLS_LAST = "transaction_hash_DESC_NULLS_LAST",
+  transaction_id_ASC = "transaction_id_ASC",
+  transaction_id_ASC_NULLS_FIRST = "transaction_id_ASC_NULLS_FIRST",
+  transaction_id_ASC_NULLS_LAST = "transaction_id_ASC_NULLS_LAST",
+  transaction_id_DESC = "transaction_id_DESC",
+  transaction_id_DESC_NULLS_FIRST = "transaction_id_DESC_NULLS_FIRST",
+  transaction_id_DESC_NULLS_LAST = "transaction_id_DESC_NULLS_LAST",
+  transaction_timestamp_ASC = "transaction_timestamp_ASC",
+  transaction_timestamp_ASC_NULLS_FIRST = "transaction_timestamp_ASC_NULLS_FIRST",
+  transaction_timestamp_ASC_NULLS_LAST = "transaction_timestamp_ASC_NULLS_LAST",
+  transaction_timestamp_DESC = "transaction_timestamp_DESC",
+  transaction_timestamp_DESC_NULLS_FIRST = "transaction_timestamp_DESC_NULLS_FIRST",
+  transaction_timestamp_DESC_NULLS_LAST = "transaction_timestamp_DESC_NULLS_LAST",
+  transaction_to_ASC = "transaction_to_ASC",
+  transaction_to_ASC_NULLS_FIRST = "transaction_to_ASC_NULLS_FIRST",
+  transaction_to_ASC_NULLS_LAST = "transaction_to_ASC_NULLS_LAST",
+  transaction_to_DESC = "transaction_to_DESC",
+  transaction_to_DESC_NULLS_FIRST = "transaction_to_DESC_NULLS_FIRST",
+  transaction_to_DESC_NULLS_LAST = "transaction_to_DESC_NULLS_LAST",
+  transaction_transactionIndex_ASC = "transaction_transactionIndex_ASC",
+  transaction_transactionIndex_ASC_NULLS_FIRST = "transaction_transactionIndex_ASC_NULLS_FIRST",
+  transaction_transactionIndex_ASC_NULLS_LAST = "transaction_transactionIndex_ASC_NULLS_LAST",
+  transaction_transactionIndex_DESC = "transaction_transactionIndex_DESC",
+  transaction_transactionIndex_DESC_NULLS_FIRST = "transaction_transactionIndex_DESC_NULLS_FIRST",
+  transaction_transactionIndex_DESC_NULLS_LAST = "transaction_transactionIndex_DESC_NULLS_LAST",
+}
+
+export interface SwapInfoWhereInput {
+  AND?: InputMaybe<Array<SwapInfoWhereInput>>;
+  OR?: InputMaybe<Array<SwapInfoWhereInput>>;
+  amountInAfterFees_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountInAfterFees_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountInAfterFees_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountInAfterFees_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  amountInAfterFees_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  amountInAfterFees_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountInAfterFees_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountInAfterFees_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountInAfterFees_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  amountIn_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountIn_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountIn_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountIn_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  amountIn_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  amountIn_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountIn_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountIn_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountIn_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  amountOut_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountOut_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountOut_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountOut_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  amountOut_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  amountOut_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountOut_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountOut_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  amountOut_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  marketAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_contains?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_eq?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_gt?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_gte?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  orderKey_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  orderKey_lt?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_lte?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  orderKey_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  priceImpactUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  priceImpactUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  priceImpactUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  receiver_contains?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_eq?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_gt?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_gte?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  receiver_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  receiver_lt?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_lte?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  receiver_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  receiver_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenInAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  tokenInAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  tokenInAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenInAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  tokenInAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  tokenInAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  tokenInAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenInAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  tokenInAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  tokenInAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  tokenInAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  tokenInAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  tokenInAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenInAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  tokenInAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenInAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenInAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenInPrice_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  tokenInPrice_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  tokenInPrice_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  tokenInPrice_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  tokenInPrice_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  tokenInPrice_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  tokenInPrice_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  tokenInPrice_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  tokenInPrice_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  tokenOutAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  tokenOutAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  tokenOutAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenOutAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  tokenOutAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  tokenOutAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  tokenOutAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenOutAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  tokenOutAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  tokenOutAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  tokenOutAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  tokenOutAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  tokenOutAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenOutAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  tokenOutAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  tokenOutAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenOutAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  tokenOutPrice_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  tokenOutPrice_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  tokenOutPrice_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  tokenOutPrice_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  tokenOutPrice_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  tokenOutPrice_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  tokenOutPrice_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  tokenOutPrice_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  tokenOutPrice_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  transaction?: InputMaybe<TransactionWhereInput>;
+  transaction_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+}
+
+export interface SwapInfosConnection {
+  __typename?: "SwapInfosConnection";
+  edges: Array<SwapInfoEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface TradeAction {
+  __typename?: "TradeAction";
+  acceptablePrice?: Maybe<Scalars["BigInt"]["output"]>;
+  account: Scalars["String"]["output"];
+  basePnlUsd?: Maybe<Scalars["BigInt"]["output"]>;
+  borrowingFeeAmount?: Maybe<Scalars["BigInt"]["output"]>;
+  collateralTokenPriceMax?: Maybe<Scalars["BigInt"]["output"]>;
+  collateralTokenPriceMin?: Maybe<Scalars["BigInt"]["output"]>;
+  contractTriggerPrice?: Maybe<Scalars["BigInt"]["output"]>;
+  eventName: Scalars["String"]["output"];
+  executionAmountOut?: Maybe<Scalars["BigInt"]["output"]>;
+  executionPrice?: Maybe<Scalars["BigInt"]["output"]>;
+  fundingFeeAmount?: Maybe<Scalars["BigInt"]["output"]>;
+  id: Scalars["String"]["output"];
+  indexTokenPriceMax?: Maybe<Scalars["BigInt"]["output"]>;
+  indexTokenPriceMin?: Maybe<Scalars["BigInt"]["output"]>;
+  initialCollateralDeltaAmount: Scalars["BigInt"]["output"];
+  initialCollateralTokenAddress: Scalars["String"]["output"];
+  isLong?: Maybe<Scalars["Boolean"]["output"]>;
+  liquidationFeeAmount?: Maybe<Scalars["BigInt"]["output"]>;
+  marketAddress?: Maybe<Scalars["String"]["output"]>;
+  minOutputAmount?: Maybe<Scalars["BigInt"]["output"]>;
+  numberOfParts?: Maybe<Scalars["Int"]["output"]>;
+  orderKey: Scalars["String"]["output"];
+  orderType: Scalars["Int"]["output"];
+  pnlUsd?: Maybe<Scalars["BigInt"]["output"]>;
+  positionFeeAmount?: Maybe<Scalars["BigInt"]["output"]>;
+  priceImpactAmount?: Maybe<Scalars["BigInt"]["output"]>;
+  priceImpactDiffUsd?: Maybe<Scalars["BigInt"]["output"]>;
+  priceImpactUsd?: Maybe<Scalars["BigInt"]["output"]>;
+  proportionalPendingImpactUsd?: Maybe<Scalars["BigInt"]["output"]>;
+  reason?: Maybe<Scalars["String"]["output"]>;
+  reasonBytes?: Maybe<Scalars["String"]["output"]>;
+  shouldUnwrapNativeToken?: Maybe<Scalars["Boolean"]["output"]>;
+  sizeDeltaUsd?: Maybe<Scalars["BigInt"]["output"]>;
+  srcChainId?: Maybe<Scalars["BigInt"]["output"]>;
+  swapPath: Array<Scalars["String"]["output"]>;
+  timestamp: Scalars["Int"]["output"];
+  totalImpactUsd?: Maybe<Scalars["BigInt"]["output"]>;
+  transaction: Transaction;
+  triggerPrice?: Maybe<Scalars["BigInt"]["output"]>;
+  twapGroupId?: Maybe<Scalars["String"]["output"]>;
+  uiFeeReceiver: Scalars["String"]["output"];
+}
+
+export interface TradeActionEdge {
+  __typename?: "TradeActionEdge";
+  cursor: Scalars["String"]["output"];
+  node: TradeAction;
+}
+
+export enum TradeActionOrderByInput {
+  acceptablePrice_ASC = "acceptablePrice_ASC",
+  acceptablePrice_ASC_NULLS_FIRST = "acceptablePrice_ASC_NULLS_FIRST",
+  acceptablePrice_ASC_NULLS_LAST = "acceptablePrice_ASC_NULLS_LAST",
+  acceptablePrice_DESC = "acceptablePrice_DESC",
+  acceptablePrice_DESC_NULLS_FIRST = "acceptablePrice_DESC_NULLS_FIRST",
+  acceptablePrice_DESC_NULLS_LAST = "acceptablePrice_DESC_NULLS_LAST",
+  account_ASC = "account_ASC",
+  account_ASC_NULLS_FIRST = "account_ASC_NULLS_FIRST",
+  account_ASC_NULLS_LAST = "account_ASC_NULLS_LAST",
+  account_DESC = "account_DESC",
+  account_DESC_NULLS_FIRST = "account_DESC_NULLS_FIRST",
+  account_DESC_NULLS_LAST = "account_DESC_NULLS_LAST",
+  basePnlUsd_ASC = "basePnlUsd_ASC",
+  basePnlUsd_ASC_NULLS_FIRST = "basePnlUsd_ASC_NULLS_FIRST",
+  basePnlUsd_ASC_NULLS_LAST = "basePnlUsd_ASC_NULLS_LAST",
+  basePnlUsd_DESC = "basePnlUsd_DESC",
+  basePnlUsd_DESC_NULLS_FIRST = "basePnlUsd_DESC_NULLS_FIRST",
+  basePnlUsd_DESC_NULLS_LAST = "basePnlUsd_DESC_NULLS_LAST",
+  borrowingFeeAmount_ASC = "borrowingFeeAmount_ASC",
+  borrowingFeeAmount_ASC_NULLS_FIRST = "borrowingFeeAmount_ASC_NULLS_FIRST",
+  borrowingFeeAmount_ASC_NULLS_LAST = "borrowingFeeAmount_ASC_NULLS_LAST",
+  borrowingFeeAmount_DESC = "borrowingFeeAmount_DESC",
+  borrowingFeeAmount_DESC_NULLS_FIRST = "borrowingFeeAmount_DESC_NULLS_FIRST",
+  borrowingFeeAmount_DESC_NULLS_LAST = "borrowingFeeAmount_DESC_NULLS_LAST",
+  collateralTokenPriceMax_ASC = "collateralTokenPriceMax_ASC",
+  collateralTokenPriceMax_ASC_NULLS_FIRST = "collateralTokenPriceMax_ASC_NULLS_FIRST",
+  collateralTokenPriceMax_ASC_NULLS_LAST = "collateralTokenPriceMax_ASC_NULLS_LAST",
+  collateralTokenPriceMax_DESC = "collateralTokenPriceMax_DESC",
+  collateralTokenPriceMax_DESC_NULLS_FIRST = "collateralTokenPriceMax_DESC_NULLS_FIRST",
+  collateralTokenPriceMax_DESC_NULLS_LAST = "collateralTokenPriceMax_DESC_NULLS_LAST",
+  collateralTokenPriceMin_ASC = "collateralTokenPriceMin_ASC",
+  collateralTokenPriceMin_ASC_NULLS_FIRST = "collateralTokenPriceMin_ASC_NULLS_FIRST",
+  collateralTokenPriceMin_ASC_NULLS_LAST = "collateralTokenPriceMin_ASC_NULLS_LAST",
+  collateralTokenPriceMin_DESC = "collateralTokenPriceMin_DESC",
+  collateralTokenPriceMin_DESC_NULLS_FIRST = "collateralTokenPriceMin_DESC_NULLS_FIRST",
+  collateralTokenPriceMin_DESC_NULLS_LAST = "collateralTokenPriceMin_DESC_NULLS_LAST",
+  contractTriggerPrice_ASC = "contractTriggerPrice_ASC",
+  contractTriggerPrice_ASC_NULLS_FIRST = "contractTriggerPrice_ASC_NULLS_FIRST",
+  contractTriggerPrice_ASC_NULLS_LAST = "contractTriggerPrice_ASC_NULLS_LAST",
+  contractTriggerPrice_DESC = "contractTriggerPrice_DESC",
+  contractTriggerPrice_DESC_NULLS_FIRST = "contractTriggerPrice_DESC_NULLS_FIRST",
+  contractTriggerPrice_DESC_NULLS_LAST = "contractTriggerPrice_DESC_NULLS_LAST",
+  eventName_ASC = "eventName_ASC",
+  eventName_ASC_NULLS_FIRST = "eventName_ASC_NULLS_FIRST",
+  eventName_ASC_NULLS_LAST = "eventName_ASC_NULLS_LAST",
+  eventName_DESC = "eventName_DESC",
+  eventName_DESC_NULLS_FIRST = "eventName_DESC_NULLS_FIRST",
+  eventName_DESC_NULLS_LAST = "eventName_DESC_NULLS_LAST",
+  executionAmountOut_ASC = "executionAmountOut_ASC",
+  executionAmountOut_ASC_NULLS_FIRST = "executionAmountOut_ASC_NULLS_FIRST",
+  executionAmountOut_ASC_NULLS_LAST = "executionAmountOut_ASC_NULLS_LAST",
+  executionAmountOut_DESC = "executionAmountOut_DESC",
+  executionAmountOut_DESC_NULLS_FIRST = "executionAmountOut_DESC_NULLS_FIRST",
+  executionAmountOut_DESC_NULLS_LAST = "executionAmountOut_DESC_NULLS_LAST",
+  executionPrice_ASC = "executionPrice_ASC",
+  executionPrice_ASC_NULLS_FIRST = "executionPrice_ASC_NULLS_FIRST",
+  executionPrice_ASC_NULLS_LAST = "executionPrice_ASC_NULLS_LAST",
+  executionPrice_DESC = "executionPrice_DESC",
+  executionPrice_DESC_NULLS_FIRST = "executionPrice_DESC_NULLS_FIRST",
+  executionPrice_DESC_NULLS_LAST = "executionPrice_DESC_NULLS_LAST",
+  fundingFeeAmount_ASC = "fundingFeeAmount_ASC",
+  fundingFeeAmount_ASC_NULLS_FIRST = "fundingFeeAmount_ASC_NULLS_FIRST",
+  fundingFeeAmount_ASC_NULLS_LAST = "fundingFeeAmount_ASC_NULLS_LAST",
+  fundingFeeAmount_DESC = "fundingFeeAmount_DESC",
+  fundingFeeAmount_DESC_NULLS_FIRST = "fundingFeeAmount_DESC_NULLS_FIRST",
+  fundingFeeAmount_DESC_NULLS_LAST = "fundingFeeAmount_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  indexTokenPriceMax_ASC = "indexTokenPriceMax_ASC",
+  indexTokenPriceMax_ASC_NULLS_FIRST = "indexTokenPriceMax_ASC_NULLS_FIRST",
+  indexTokenPriceMax_ASC_NULLS_LAST = "indexTokenPriceMax_ASC_NULLS_LAST",
+  indexTokenPriceMax_DESC = "indexTokenPriceMax_DESC",
+  indexTokenPriceMax_DESC_NULLS_FIRST = "indexTokenPriceMax_DESC_NULLS_FIRST",
+  indexTokenPriceMax_DESC_NULLS_LAST = "indexTokenPriceMax_DESC_NULLS_LAST",
+  indexTokenPriceMin_ASC = "indexTokenPriceMin_ASC",
+  indexTokenPriceMin_ASC_NULLS_FIRST = "indexTokenPriceMin_ASC_NULLS_FIRST",
+  indexTokenPriceMin_ASC_NULLS_LAST = "indexTokenPriceMin_ASC_NULLS_LAST",
+  indexTokenPriceMin_DESC = "indexTokenPriceMin_DESC",
+  indexTokenPriceMin_DESC_NULLS_FIRST = "indexTokenPriceMin_DESC_NULLS_FIRST",
+  indexTokenPriceMin_DESC_NULLS_LAST = "indexTokenPriceMin_DESC_NULLS_LAST",
+  initialCollateralDeltaAmount_ASC = "initialCollateralDeltaAmount_ASC",
+  initialCollateralDeltaAmount_ASC_NULLS_FIRST = "initialCollateralDeltaAmount_ASC_NULLS_FIRST",
+  initialCollateralDeltaAmount_ASC_NULLS_LAST = "initialCollateralDeltaAmount_ASC_NULLS_LAST",
+  initialCollateralDeltaAmount_DESC = "initialCollateralDeltaAmount_DESC",
+  initialCollateralDeltaAmount_DESC_NULLS_FIRST = "initialCollateralDeltaAmount_DESC_NULLS_FIRST",
+  initialCollateralDeltaAmount_DESC_NULLS_LAST = "initialCollateralDeltaAmount_DESC_NULLS_LAST",
+  initialCollateralTokenAddress_ASC = "initialCollateralTokenAddress_ASC",
+  initialCollateralTokenAddress_ASC_NULLS_FIRST = "initialCollateralTokenAddress_ASC_NULLS_FIRST",
+  initialCollateralTokenAddress_ASC_NULLS_LAST = "initialCollateralTokenAddress_ASC_NULLS_LAST",
+  initialCollateralTokenAddress_DESC = "initialCollateralTokenAddress_DESC",
+  initialCollateralTokenAddress_DESC_NULLS_FIRST = "initialCollateralTokenAddress_DESC_NULLS_FIRST",
+  initialCollateralTokenAddress_DESC_NULLS_LAST = "initialCollateralTokenAddress_DESC_NULLS_LAST",
+  isLong_ASC = "isLong_ASC",
+  isLong_ASC_NULLS_FIRST = "isLong_ASC_NULLS_FIRST",
+  isLong_ASC_NULLS_LAST = "isLong_ASC_NULLS_LAST",
+  isLong_DESC = "isLong_DESC",
+  isLong_DESC_NULLS_FIRST = "isLong_DESC_NULLS_FIRST",
+  isLong_DESC_NULLS_LAST = "isLong_DESC_NULLS_LAST",
+  liquidationFeeAmount_ASC = "liquidationFeeAmount_ASC",
+  liquidationFeeAmount_ASC_NULLS_FIRST = "liquidationFeeAmount_ASC_NULLS_FIRST",
+  liquidationFeeAmount_ASC_NULLS_LAST = "liquidationFeeAmount_ASC_NULLS_LAST",
+  liquidationFeeAmount_DESC = "liquidationFeeAmount_DESC",
+  liquidationFeeAmount_DESC_NULLS_FIRST = "liquidationFeeAmount_DESC_NULLS_FIRST",
+  liquidationFeeAmount_DESC_NULLS_LAST = "liquidationFeeAmount_DESC_NULLS_LAST",
+  marketAddress_ASC = "marketAddress_ASC",
+  marketAddress_ASC_NULLS_FIRST = "marketAddress_ASC_NULLS_FIRST",
+  marketAddress_ASC_NULLS_LAST = "marketAddress_ASC_NULLS_LAST",
+  marketAddress_DESC = "marketAddress_DESC",
+  marketAddress_DESC_NULLS_FIRST = "marketAddress_DESC_NULLS_FIRST",
+  marketAddress_DESC_NULLS_LAST = "marketAddress_DESC_NULLS_LAST",
+  minOutputAmount_ASC = "minOutputAmount_ASC",
+  minOutputAmount_ASC_NULLS_FIRST = "minOutputAmount_ASC_NULLS_FIRST",
+  minOutputAmount_ASC_NULLS_LAST = "minOutputAmount_ASC_NULLS_LAST",
+  minOutputAmount_DESC = "minOutputAmount_DESC",
+  minOutputAmount_DESC_NULLS_FIRST = "minOutputAmount_DESC_NULLS_FIRST",
+  minOutputAmount_DESC_NULLS_LAST = "minOutputAmount_DESC_NULLS_LAST",
+  numberOfParts_ASC = "numberOfParts_ASC",
+  numberOfParts_ASC_NULLS_FIRST = "numberOfParts_ASC_NULLS_FIRST",
+  numberOfParts_ASC_NULLS_LAST = "numberOfParts_ASC_NULLS_LAST",
+  numberOfParts_DESC = "numberOfParts_DESC",
+  numberOfParts_DESC_NULLS_FIRST = "numberOfParts_DESC_NULLS_FIRST",
+  numberOfParts_DESC_NULLS_LAST = "numberOfParts_DESC_NULLS_LAST",
+  orderKey_ASC = "orderKey_ASC",
+  orderKey_ASC_NULLS_FIRST = "orderKey_ASC_NULLS_FIRST",
+  orderKey_ASC_NULLS_LAST = "orderKey_ASC_NULLS_LAST",
+  orderKey_DESC = "orderKey_DESC",
+  orderKey_DESC_NULLS_FIRST = "orderKey_DESC_NULLS_FIRST",
+  orderKey_DESC_NULLS_LAST = "orderKey_DESC_NULLS_LAST",
+  orderType_ASC = "orderType_ASC",
+  orderType_ASC_NULLS_FIRST = "orderType_ASC_NULLS_FIRST",
+  orderType_ASC_NULLS_LAST = "orderType_ASC_NULLS_LAST",
+  orderType_DESC = "orderType_DESC",
+  orderType_DESC_NULLS_FIRST = "orderType_DESC_NULLS_FIRST",
+  orderType_DESC_NULLS_LAST = "orderType_DESC_NULLS_LAST",
+  pnlUsd_ASC = "pnlUsd_ASC",
+  pnlUsd_ASC_NULLS_FIRST = "pnlUsd_ASC_NULLS_FIRST",
+  pnlUsd_ASC_NULLS_LAST = "pnlUsd_ASC_NULLS_LAST",
+  pnlUsd_DESC = "pnlUsd_DESC",
+  pnlUsd_DESC_NULLS_FIRST = "pnlUsd_DESC_NULLS_FIRST",
+  pnlUsd_DESC_NULLS_LAST = "pnlUsd_DESC_NULLS_LAST",
+  positionFeeAmount_ASC = "positionFeeAmount_ASC",
+  positionFeeAmount_ASC_NULLS_FIRST = "positionFeeAmount_ASC_NULLS_FIRST",
+  positionFeeAmount_ASC_NULLS_LAST = "positionFeeAmount_ASC_NULLS_LAST",
+  positionFeeAmount_DESC = "positionFeeAmount_DESC",
+  positionFeeAmount_DESC_NULLS_FIRST = "positionFeeAmount_DESC_NULLS_FIRST",
+  positionFeeAmount_DESC_NULLS_LAST = "positionFeeAmount_DESC_NULLS_LAST",
+  priceImpactAmount_ASC = "priceImpactAmount_ASC",
+  priceImpactAmount_ASC_NULLS_FIRST = "priceImpactAmount_ASC_NULLS_FIRST",
+  priceImpactAmount_ASC_NULLS_LAST = "priceImpactAmount_ASC_NULLS_LAST",
+  priceImpactAmount_DESC = "priceImpactAmount_DESC",
+  priceImpactAmount_DESC_NULLS_FIRST = "priceImpactAmount_DESC_NULLS_FIRST",
+  priceImpactAmount_DESC_NULLS_LAST = "priceImpactAmount_DESC_NULLS_LAST",
+  priceImpactDiffUsd_ASC = "priceImpactDiffUsd_ASC",
+  priceImpactDiffUsd_ASC_NULLS_FIRST = "priceImpactDiffUsd_ASC_NULLS_FIRST",
+  priceImpactDiffUsd_ASC_NULLS_LAST = "priceImpactDiffUsd_ASC_NULLS_LAST",
+  priceImpactDiffUsd_DESC = "priceImpactDiffUsd_DESC",
+  priceImpactDiffUsd_DESC_NULLS_FIRST = "priceImpactDiffUsd_DESC_NULLS_FIRST",
+  priceImpactDiffUsd_DESC_NULLS_LAST = "priceImpactDiffUsd_DESC_NULLS_LAST",
+  priceImpactUsd_ASC = "priceImpactUsd_ASC",
+  priceImpactUsd_ASC_NULLS_FIRST = "priceImpactUsd_ASC_NULLS_FIRST",
+  priceImpactUsd_ASC_NULLS_LAST = "priceImpactUsd_ASC_NULLS_LAST",
+  priceImpactUsd_DESC = "priceImpactUsd_DESC",
+  priceImpactUsd_DESC_NULLS_FIRST = "priceImpactUsd_DESC_NULLS_FIRST",
+  priceImpactUsd_DESC_NULLS_LAST = "priceImpactUsd_DESC_NULLS_LAST",
+  proportionalPendingImpactUsd_ASC = "proportionalPendingImpactUsd_ASC",
+  proportionalPendingImpactUsd_ASC_NULLS_FIRST = "proportionalPendingImpactUsd_ASC_NULLS_FIRST",
+  proportionalPendingImpactUsd_ASC_NULLS_LAST = "proportionalPendingImpactUsd_ASC_NULLS_LAST",
+  proportionalPendingImpactUsd_DESC = "proportionalPendingImpactUsd_DESC",
+  proportionalPendingImpactUsd_DESC_NULLS_FIRST = "proportionalPendingImpactUsd_DESC_NULLS_FIRST",
+  proportionalPendingImpactUsd_DESC_NULLS_LAST = "proportionalPendingImpactUsd_DESC_NULLS_LAST",
+  reasonBytes_ASC = "reasonBytes_ASC",
+  reasonBytes_ASC_NULLS_FIRST = "reasonBytes_ASC_NULLS_FIRST",
+  reasonBytes_ASC_NULLS_LAST = "reasonBytes_ASC_NULLS_LAST",
+  reasonBytes_DESC = "reasonBytes_DESC",
+  reasonBytes_DESC_NULLS_FIRST = "reasonBytes_DESC_NULLS_FIRST",
+  reasonBytes_DESC_NULLS_LAST = "reasonBytes_DESC_NULLS_LAST",
+  reason_ASC = "reason_ASC",
+  reason_ASC_NULLS_FIRST = "reason_ASC_NULLS_FIRST",
+  reason_ASC_NULLS_LAST = "reason_ASC_NULLS_LAST",
+  reason_DESC = "reason_DESC",
+  reason_DESC_NULLS_FIRST = "reason_DESC_NULLS_FIRST",
+  reason_DESC_NULLS_LAST = "reason_DESC_NULLS_LAST",
+  shouldUnwrapNativeToken_ASC = "shouldUnwrapNativeToken_ASC",
+  shouldUnwrapNativeToken_ASC_NULLS_FIRST = "shouldUnwrapNativeToken_ASC_NULLS_FIRST",
+  shouldUnwrapNativeToken_ASC_NULLS_LAST = "shouldUnwrapNativeToken_ASC_NULLS_LAST",
+  shouldUnwrapNativeToken_DESC = "shouldUnwrapNativeToken_DESC",
+  shouldUnwrapNativeToken_DESC_NULLS_FIRST = "shouldUnwrapNativeToken_DESC_NULLS_FIRST",
+  shouldUnwrapNativeToken_DESC_NULLS_LAST = "shouldUnwrapNativeToken_DESC_NULLS_LAST",
+  sizeDeltaUsd_ASC = "sizeDeltaUsd_ASC",
+  sizeDeltaUsd_ASC_NULLS_FIRST = "sizeDeltaUsd_ASC_NULLS_FIRST",
+  sizeDeltaUsd_ASC_NULLS_LAST = "sizeDeltaUsd_ASC_NULLS_LAST",
+  sizeDeltaUsd_DESC = "sizeDeltaUsd_DESC",
+  sizeDeltaUsd_DESC_NULLS_FIRST = "sizeDeltaUsd_DESC_NULLS_FIRST",
+  sizeDeltaUsd_DESC_NULLS_LAST = "sizeDeltaUsd_DESC_NULLS_LAST",
+  srcChainId_ASC = "srcChainId_ASC",
+  srcChainId_ASC_NULLS_FIRST = "srcChainId_ASC_NULLS_FIRST",
+  srcChainId_ASC_NULLS_LAST = "srcChainId_ASC_NULLS_LAST",
+  srcChainId_DESC = "srcChainId_DESC",
+  srcChainId_DESC_NULLS_FIRST = "srcChainId_DESC_NULLS_FIRST",
+  srcChainId_DESC_NULLS_LAST = "srcChainId_DESC_NULLS_LAST",
+  timestamp_ASC = "timestamp_ASC",
+  timestamp_ASC_NULLS_FIRST = "timestamp_ASC_NULLS_FIRST",
+  timestamp_ASC_NULLS_LAST = "timestamp_ASC_NULLS_LAST",
+  timestamp_DESC = "timestamp_DESC",
+  timestamp_DESC_NULLS_FIRST = "timestamp_DESC_NULLS_FIRST",
+  timestamp_DESC_NULLS_LAST = "timestamp_DESC_NULLS_LAST",
+  totalImpactUsd_ASC = "totalImpactUsd_ASC",
+  totalImpactUsd_ASC_NULLS_FIRST = "totalImpactUsd_ASC_NULLS_FIRST",
+  totalImpactUsd_ASC_NULLS_LAST = "totalImpactUsd_ASC_NULLS_LAST",
+  totalImpactUsd_DESC = "totalImpactUsd_DESC",
+  totalImpactUsd_DESC_NULLS_FIRST = "totalImpactUsd_DESC_NULLS_FIRST",
+  totalImpactUsd_DESC_NULLS_LAST = "totalImpactUsd_DESC_NULLS_LAST",
+  transaction_blockNumber_ASC = "transaction_blockNumber_ASC",
+  transaction_blockNumber_ASC_NULLS_FIRST = "transaction_blockNumber_ASC_NULLS_FIRST",
+  transaction_blockNumber_ASC_NULLS_LAST = "transaction_blockNumber_ASC_NULLS_LAST",
+  transaction_blockNumber_DESC = "transaction_blockNumber_DESC",
+  transaction_blockNumber_DESC_NULLS_FIRST = "transaction_blockNumber_DESC_NULLS_FIRST",
+  transaction_blockNumber_DESC_NULLS_LAST = "transaction_blockNumber_DESC_NULLS_LAST",
+  transaction_chainId_ASC = "transaction_chainId_ASC",
+  transaction_chainId_ASC_NULLS_FIRST = "transaction_chainId_ASC_NULLS_FIRST",
+  transaction_chainId_ASC_NULLS_LAST = "transaction_chainId_ASC_NULLS_LAST",
+  transaction_chainId_DESC = "transaction_chainId_DESC",
+  transaction_chainId_DESC_NULLS_FIRST = "transaction_chainId_DESC_NULLS_FIRST",
+  transaction_chainId_DESC_NULLS_LAST = "transaction_chainId_DESC_NULLS_LAST",
+  transaction_from_ASC = "transaction_from_ASC",
+  transaction_from_ASC_NULLS_FIRST = "transaction_from_ASC_NULLS_FIRST",
+  transaction_from_ASC_NULLS_LAST = "transaction_from_ASC_NULLS_LAST",
+  transaction_from_DESC = "transaction_from_DESC",
+  transaction_from_DESC_NULLS_FIRST = "transaction_from_DESC_NULLS_FIRST",
+  transaction_from_DESC_NULLS_LAST = "transaction_from_DESC_NULLS_LAST",
+  transaction_hash_ASC = "transaction_hash_ASC",
+  transaction_hash_ASC_NULLS_FIRST = "transaction_hash_ASC_NULLS_FIRST",
+  transaction_hash_ASC_NULLS_LAST = "transaction_hash_ASC_NULLS_LAST",
+  transaction_hash_DESC = "transaction_hash_DESC",
+  transaction_hash_DESC_NULLS_FIRST = "transaction_hash_DESC_NULLS_FIRST",
+  transaction_hash_DESC_NULLS_LAST = "transaction_hash_DESC_NULLS_LAST",
+  transaction_id_ASC = "transaction_id_ASC",
+  transaction_id_ASC_NULLS_FIRST = "transaction_id_ASC_NULLS_FIRST",
+  transaction_id_ASC_NULLS_LAST = "transaction_id_ASC_NULLS_LAST",
+  transaction_id_DESC = "transaction_id_DESC",
+  transaction_id_DESC_NULLS_FIRST = "transaction_id_DESC_NULLS_FIRST",
+  transaction_id_DESC_NULLS_LAST = "transaction_id_DESC_NULLS_LAST",
+  transaction_timestamp_ASC = "transaction_timestamp_ASC",
+  transaction_timestamp_ASC_NULLS_FIRST = "transaction_timestamp_ASC_NULLS_FIRST",
+  transaction_timestamp_ASC_NULLS_LAST = "transaction_timestamp_ASC_NULLS_LAST",
+  transaction_timestamp_DESC = "transaction_timestamp_DESC",
+  transaction_timestamp_DESC_NULLS_FIRST = "transaction_timestamp_DESC_NULLS_FIRST",
+  transaction_timestamp_DESC_NULLS_LAST = "transaction_timestamp_DESC_NULLS_LAST",
+  transaction_to_ASC = "transaction_to_ASC",
+  transaction_to_ASC_NULLS_FIRST = "transaction_to_ASC_NULLS_FIRST",
+  transaction_to_ASC_NULLS_LAST = "transaction_to_ASC_NULLS_LAST",
+  transaction_to_DESC = "transaction_to_DESC",
+  transaction_to_DESC_NULLS_FIRST = "transaction_to_DESC_NULLS_FIRST",
+  transaction_to_DESC_NULLS_LAST = "transaction_to_DESC_NULLS_LAST",
+  transaction_transactionIndex_ASC = "transaction_transactionIndex_ASC",
+  transaction_transactionIndex_ASC_NULLS_FIRST = "transaction_transactionIndex_ASC_NULLS_FIRST",
+  transaction_transactionIndex_ASC_NULLS_LAST = "transaction_transactionIndex_ASC_NULLS_LAST",
+  transaction_transactionIndex_DESC = "transaction_transactionIndex_DESC",
+  transaction_transactionIndex_DESC_NULLS_FIRST = "transaction_transactionIndex_DESC_NULLS_FIRST",
+  transaction_transactionIndex_DESC_NULLS_LAST = "transaction_transactionIndex_DESC_NULLS_LAST",
+  triggerPrice_ASC = "triggerPrice_ASC",
+  triggerPrice_ASC_NULLS_FIRST = "triggerPrice_ASC_NULLS_FIRST",
+  triggerPrice_ASC_NULLS_LAST = "triggerPrice_ASC_NULLS_LAST",
+  triggerPrice_DESC = "triggerPrice_DESC",
+  triggerPrice_DESC_NULLS_FIRST = "triggerPrice_DESC_NULLS_FIRST",
+  triggerPrice_DESC_NULLS_LAST = "triggerPrice_DESC_NULLS_LAST",
+  twapGroupId_ASC = "twapGroupId_ASC",
+  twapGroupId_ASC_NULLS_FIRST = "twapGroupId_ASC_NULLS_FIRST",
+  twapGroupId_ASC_NULLS_LAST = "twapGroupId_ASC_NULLS_LAST",
+  twapGroupId_DESC = "twapGroupId_DESC",
+  twapGroupId_DESC_NULLS_FIRST = "twapGroupId_DESC_NULLS_FIRST",
+  twapGroupId_DESC_NULLS_LAST = "twapGroupId_DESC_NULLS_LAST",
+  uiFeeReceiver_ASC = "uiFeeReceiver_ASC",
+  uiFeeReceiver_ASC_NULLS_FIRST = "uiFeeReceiver_ASC_NULLS_FIRST",
+  uiFeeReceiver_ASC_NULLS_LAST = "uiFeeReceiver_ASC_NULLS_LAST",
+  uiFeeReceiver_DESC = "uiFeeReceiver_DESC",
+  uiFeeReceiver_DESC_NULLS_FIRST = "uiFeeReceiver_DESC_NULLS_FIRST",
+  uiFeeReceiver_DESC_NULLS_LAST = "uiFeeReceiver_DESC_NULLS_LAST",
+}
+
+export interface TradeActionWhereInput {
+  AND?: InputMaybe<Array<TradeActionWhereInput>>;
+  OR?: InputMaybe<Array<TradeActionWhereInput>>;
+  acceptablePrice_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  acceptablePrice_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  acceptablePrice_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  acceptablePrice_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  acceptablePrice_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  acceptablePrice_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  acceptablePrice_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  acceptablePrice_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  acceptablePrice_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  account_contains?: InputMaybe<Scalars["String"]["input"]>;
+  account_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  account_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_eq?: InputMaybe<Scalars["String"]["input"]>;
+  account_gt?: InputMaybe<Scalars["String"]["input"]>;
+  account_gte?: InputMaybe<Scalars["String"]["input"]>;
+  account_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  account_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  account_lt?: InputMaybe<Scalars["String"]["input"]>;
+  account_lte?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  account_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  account_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  account_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  basePnlUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  basePnlUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  basePnlUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  basePnlUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  basePnlUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  basePnlUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  basePnlUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  basePnlUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  basePnlUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFeeAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  borrowingFeeAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  borrowingFeeAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  borrowingFeeAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  collateralTokenPriceMax_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMax_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMax_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMax_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  collateralTokenPriceMax_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  collateralTokenPriceMax_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMax_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMax_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMax_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  collateralTokenPriceMin_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  collateralTokenPriceMin_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  collateralTokenPriceMin_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  collateralTokenPriceMin_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  contractTriggerPrice_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  contractTriggerPrice_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  contractTriggerPrice_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  contractTriggerPrice_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  contractTriggerPrice_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  contractTriggerPrice_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  contractTriggerPrice_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  contractTriggerPrice_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  contractTriggerPrice_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  eventName_contains?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_eq?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_gt?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_gte?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  eventName_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  eventName_lt?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_lte?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  eventName_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  eventName_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  executionAmountOut_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionAmountOut_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionAmountOut_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionAmountOut_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  executionAmountOut_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  executionAmountOut_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionAmountOut_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionAmountOut_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionAmountOut_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  executionPrice_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionPrice_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionPrice_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionPrice_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  executionPrice_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  executionPrice_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionPrice_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionPrice_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  executionPrice_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  fundingFeeAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFeeAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFeeAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFeeAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  fundingFeeAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  fundingFeeAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFeeAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFeeAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  fundingFeeAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  indexTokenPriceMax_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  indexTokenPriceMax_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  indexTokenPriceMax_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  indexTokenPriceMax_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  indexTokenPriceMax_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  indexTokenPriceMax_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  indexTokenPriceMax_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  indexTokenPriceMax_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  indexTokenPriceMax_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  indexTokenPriceMin_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  indexTokenPriceMin_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  indexTokenPriceMin_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  indexTokenPriceMin_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  indexTokenPriceMin_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  indexTokenPriceMin_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  indexTokenPriceMin_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  indexTokenPriceMin_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  indexTokenPriceMin_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  initialCollateralDeltaAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  initialCollateralDeltaAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  initialCollateralDeltaAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  initialCollateralDeltaAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  initialCollateralDeltaAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  initialCollateralDeltaAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  initialCollateralDeltaAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  initialCollateralDeltaAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  initialCollateralDeltaAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  initialCollateralTokenAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  initialCollateralTokenAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  initialCollateralTokenAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  initialCollateralTokenAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  initialCollateralTokenAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  isLong_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isLong_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  isLong_not_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  liquidationFeeAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  liquidationFeeAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  liquidationFeeAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  liquidationFeeAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  liquidationFeeAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  liquidationFeeAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  liquidationFeeAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  liquidationFeeAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  liquidationFeeAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  marketAddress_contains?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_eq?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_gt?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_gte?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddress_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  marketAddress_lt?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_lte?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  marketAddress_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  marketAddress_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  minOutputAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minOutputAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minOutputAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minOutputAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  minOutputAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  minOutputAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minOutputAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minOutputAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  minOutputAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  numberOfParts_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  numberOfParts_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  numberOfParts_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  numberOfParts_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  numberOfParts_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  numberOfParts_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  numberOfParts_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  numberOfParts_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  numberOfParts_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  orderKey_contains?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_eq?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_gt?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_gte?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  orderKey_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  orderKey_lt?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_lte?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  orderKey_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  orderKey_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  orderType_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  orderType_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  orderType_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  orderType_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  orderType_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  orderType_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  orderType_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  orderType_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  orderType_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  pnlUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  pnlUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  pnlUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  pnlUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  pnlUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  pnlUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  pnlUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  pnlUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  pnlUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionFeeAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  positionFeeAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  positionFeeAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  positionFeeAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  priceImpactAmount_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactAmount_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactAmount_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactAmount_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  priceImpactAmount_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  priceImpactAmount_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactAmount_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactAmount_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactAmount_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  priceImpactDiffUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactDiffUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactDiffUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactDiffUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  priceImpactDiffUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  priceImpactDiffUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactDiffUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactDiffUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactDiffUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  priceImpactUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  priceImpactUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  priceImpactUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  priceImpactUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  proportionalPendingImpactUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  proportionalPendingImpactUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  proportionalPendingImpactUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  proportionalPendingImpactUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  proportionalPendingImpactUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  proportionalPendingImpactUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  proportionalPendingImpactUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  proportionalPendingImpactUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  proportionalPendingImpactUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  reasonBytes_contains?: InputMaybe<Scalars["String"]["input"]>;
+  reasonBytes_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  reasonBytes_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  reasonBytes_eq?: InputMaybe<Scalars["String"]["input"]>;
+  reasonBytes_gt?: InputMaybe<Scalars["String"]["input"]>;
+  reasonBytes_gte?: InputMaybe<Scalars["String"]["input"]>;
+  reasonBytes_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  reasonBytes_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  reasonBytes_lt?: InputMaybe<Scalars["String"]["input"]>;
+  reasonBytes_lte?: InputMaybe<Scalars["String"]["input"]>;
+  reasonBytes_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  reasonBytes_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  reasonBytes_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  reasonBytes_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  reasonBytes_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  reasonBytes_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  reasonBytes_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  reason_contains?: InputMaybe<Scalars["String"]["input"]>;
+  reason_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  reason_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  reason_eq?: InputMaybe<Scalars["String"]["input"]>;
+  reason_gt?: InputMaybe<Scalars["String"]["input"]>;
+  reason_gte?: InputMaybe<Scalars["String"]["input"]>;
+  reason_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  reason_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  reason_lt?: InputMaybe<Scalars["String"]["input"]>;
+  reason_lte?: InputMaybe<Scalars["String"]["input"]>;
+  reason_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  reason_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  reason_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  reason_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  reason_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  reason_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  reason_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  shouldUnwrapNativeToken_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  shouldUnwrapNativeToken_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  shouldUnwrapNativeToken_not_eq?: InputMaybe<Scalars["Boolean"]["input"]>;
+  sizeDeltaUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  sizeDeltaUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  sizeDeltaUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  sizeDeltaUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  srcChainId_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  srcChainId_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  srcChainId_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  srcChainId_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  srcChainId_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  srcChainId_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  srcChainId_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  srcChainId_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  srcChainId_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  swapPath_containsAll?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  swapPath_containsAny?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  swapPath_containsNone?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  swapPath_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  timestamp_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  timestamp_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  timestamp_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  totalImpactUsd_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalImpactUsd_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalImpactUsd_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalImpactUsd_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  totalImpactUsd_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  totalImpactUsd_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalImpactUsd_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalImpactUsd_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  totalImpactUsd_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  transaction?: InputMaybe<TransactionWhereInput>;
+  transaction_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  triggerPrice_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  triggerPrice_gt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  triggerPrice_gte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  triggerPrice_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  triggerPrice_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  triggerPrice_lt?: InputMaybe<Scalars["BigInt"]["input"]>;
+  triggerPrice_lte?: InputMaybe<Scalars["BigInt"]["input"]>;
+  triggerPrice_not_eq?: InputMaybe<Scalars["BigInt"]["input"]>;
+  triggerPrice_not_in?: InputMaybe<Array<Scalars["BigInt"]["input"]>>;
+  twapGroupId_contains?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_eq?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_gt?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_gte?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  twapGroupId_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  twapGroupId_lt?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_lte?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  twapGroupId_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  twapGroupId_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_contains?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_eq?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_gt?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_gte?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  uiFeeReceiver_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  uiFeeReceiver_lt?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_lte?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  uiFeeReceiver_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  uiFeeReceiver_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+}
+
+export interface TradeActionsConnection {
+  __typename?: "TradeActionsConnection";
+  edges: Array<TradeActionEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface Transaction {
+  __typename?: "Transaction";
+  blockNumber: Scalars["Int"]["output"];
+  chainId: Scalars["Int"]["output"];
+  from: Scalars["String"]["output"];
+  hash: Scalars["String"]["output"];
+  id: Scalars["String"]["output"];
+  timestamp: Scalars["Int"]["output"];
+  to: Scalars["String"]["output"];
+  transactionIndex: Scalars["Int"]["output"];
+}
+
+export interface TransactionEdge {
+  __typename?: "TransactionEdge";
+  cursor: Scalars["String"]["output"];
+  node: Transaction;
+}
+
+export enum TransactionOrderByInput {
+  blockNumber_ASC = "blockNumber_ASC",
+  blockNumber_ASC_NULLS_FIRST = "blockNumber_ASC_NULLS_FIRST",
+  blockNumber_ASC_NULLS_LAST = "blockNumber_ASC_NULLS_LAST",
+  blockNumber_DESC = "blockNumber_DESC",
+  blockNumber_DESC_NULLS_FIRST = "blockNumber_DESC_NULLS_FIRST",
+  blockNumber_DESC_NULLS_LAST = "blockNumber_DESC_NULLS_LAST",
+  chainId_ASC = "chainId_ASC",
+  chainId_ASC_NULLS_FIRST = "chainId_ASC_NULLS_FIRST",
+  chainId_ASC_NULLS_LAST = "chainId_ASC_NULLS_LAST",
+  chainId_DESC = "chainId_DESC",
+  chainId_DESC_NULLS_FIRST = "chainId_DESC_NULLS_FIRST",
+  chainId_DESC_NULLS_LAST = "chainId_DESC_NULLS_LAST",
+  from_ASC = "from_ASC",
+  from_ASC_NULLS_FIRST = "from_ASC_NULLS_FIRST",
+  from_ASC_NULLS_LAST = "from_ASC_NULLS_LAST",
+  from_DESC = "from_DESC",
+  from_DESC_NULLS_FIRST = "from_DESC_NULLS_FIRST",
+  from_DESC_NULLS_LAST = "from_DESC_NULLS_LAST",
+  hash_ASC = "hash_ASC",
+  hash_ASC_NULLS_FIRST = "hash_ASC_NULLS_FIRST",
+  hash_ASC_NULLS_LAST = "hash_ASC_NULLS_LAST",
+  hash_DESC = "hash_DESC",
+  hash_DESC_NULLS_FIRST = "hash_DESC_NULLS_FIRST",
+  hash_DESC_NULLS_LAST = "hash_DESC_NULLS_LAST",
+  id_ASC = "id_ASC",
+  id_ASC_NULLS_FIRST = "id_ASC_NULLS_FIRST",
+  id_ASC_NULLS_LAST = "id_ASC_NULLS_LAST",
+  id_DESC = "id_DESC",
+  id_DESC_NULLS_FIRST = "id_DESC_NULLS_FIRST",
+  id_DESC_NULLS_LAST = "id_DESC_NULLS_LAST",
+  timestamp_ASC = "timestamp_ASC",
+  timestamp_ASC_NULLS_FIRST = "timestamp_ASC_NULLS_FIRST",
+  timestamp_ASC_NULLS_LAST = "timestamp_ASC_NULLS_LAST",
+  timestamp_DESC = "timestamp_DESC",
+  timestamp_DESC_NULLS_FIRST = "timestamp_DESC_NULLS_FIRST",
+  timestamp_DESC_NULLS_LAST = "timestamp_DESC_NULLS_LAST",
+  to_ASC = "to_ASC",
+  to_ASC_NULLS_FIRST = "to_ASC_NULLS_FIRST",
+  to_ASC_NULLS_LAST = "to_ASC_NULLS_LAST",
+  to_DESC = "to_DESC",
+  to_DESC_NULLS_FIRST = "to_DESC_NULLS_FIRST",
+  to_DESC_NULLS_LAST = "to_DESC_NULLS_LAST",
+  transactionIndex_ASC = "transactionIndex_ASC",
+  transactionIndex_ASC_NULLS_FIRST = "transactionIndex_ASC_NULLS_FIRST",
+  transactionIndex_ASC_NULLS_LAST = "transactionIndex_ASC_NULLS_LAST",
+  transactionIndex_DESC = "transactionIndex_DESC",
+  transactionIndex_DESC_NULLS_FIRST = "transactionIndex_DESC_NULLS_FIRST",
+  transactionIndex_DESC_NULLS_LAST = "transactionIndex_DESC_NULLS_LAST",
+}
+
+export interface TransactionWhereInput {
+  AND?: InputMaybe<Array<TransactionWhereInput>>;
+  OR?: InputMaybe<Array<TransactionWhereInput>>;
+  blockNumber_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  blockNumber_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  blockNumber_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  blockNumber_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  blockNumber_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  blockNumber_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  blockNumber_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  blockNumber_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  blockNumber_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  chainId_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  chainId_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  chainId_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  chainId_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  chainId_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  chainId_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  chainId_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  chainId_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  chainId_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  from_contains?: InputMaybe<Scalars["String"]["input"]>;
+  from_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  from_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  from_eq?: InputMaybe<Scalars["String"]["input"]>;
+  from_gt?: InputMaybe<Scalars["String"]["input"]>;
+  from_gte?: InputMaybe<Scalars["String"]["input"]>;
+  from_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  from_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  from_lt?: InputMaybe<Scalars["String"]["input"]>;
+  from_lte?: InputMaybe<Scalars["String"]["input"]>;
+  from_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  from_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  from_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  from_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  from_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  from_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  from_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  hash_contains?: InputMaybe<Scalars["String"]["input"]>;
+  hash_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  hash_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  hash_eq?: InputMaybe<Scalars["String"]["input"]>;
+  hash_gt?: InputMaybe<Scalars["String"]["input"]>;
+  hash_gte?: InputMaybe<Scalars["String"]["input"]>;
+  hash_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  hash_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  hash_lt?: InputMaybe<Scalars["String"]["input"]>;
+  hash_lte?: InputMaybe<Scalars["String"]["input"]>;
+  hash_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  hash_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  hash_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  hash_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  hash_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  hash_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  hash_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_gt?: InputMaybe<Scalars["String"]["input"]>;
+  id_gte?: InputMaybe<Scalars["String"]["input"]>;
+  id_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  id_lt?: InputMaybe<Scalars["String"]["input"]>;
+  id_lte?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  id_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  id_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  id_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  timestamp_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  timestamp_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  timestamp_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  timestamp_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  to_contains?: InputMaybe<Scalars["String"]["input"]>;
+  to_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  to_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  to_eq?: InputMaybe<Scalars["String"]["input"]>;
+  to_gt?: InputMaybe<Scalars["String"]["input"]>;
+  to_gte?: InputMaybe<Scalars["String"]["input"]>;
+  to_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  to_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  to_lt?: InputMaybe<Scalars["String"]["input"]>;
+  to_lte?: InputMaybe<Scalars["String"]["input"]>;
+  to_not_contains?: InputMaybe<Scalars["String"]["input"]>;
+  to_not_containsInsensitive?: InputMaybe<Scalars["String"]["input"]>;
+  to_not_endsWith?: InputMaybe<Scalars["String"]["input"]>;
+  to_not_eq?: InputMaybe<Scalars["String"]["input"]>;
+  to_not_in?: InputMaybe<Array<Scalars["String"]["input"]>>;
+  to_not_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  to_startsWith?: InputMaybe<Scalars["String"]["input"]>;
+  transactionIndex_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  transactionIndex_gt?: InputMaybe<Scalars["Int"]["input"]>;
+  transactionIndex_gte?: InputMaybe<Scalars["Int"]["input"]>;
+  transactionIndex_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+  transactionIndex_isNull?: InputMaybe<Scalars["Boolean"]["input"]>;
+  transactionIndex_lt?: InputMaybe<Scalars["Int"]["input"]>;
+  transactionIndex_lte?: InputMaybe<Scalars["Int"]["input"]>;
+  transactionIndex_not_eq?: InputMaybe<Scalars["Int"]["input"]>;
+  transactionIndex_not_in?: InputMaybe<Array<Scalars["Int"]["input"]>>;
+}
+
+export interface TransactionsConnection {
+  __typename?: "TransactionsConnection";
+  edges: Array<TransactionEdge>;
+  pageInfo: PageInfo;
+  totalCount: Scalars["Int"]["output"];
+}
+
+export interface WhereInput {
+  from?: InputMaybe<Scalars["Int"]["input"]>;
+  id_eq?: InputMaybe<Scalars["String"]["input"]>;
+  maxCapital_gte?: InputMaybe<Scalars["String"]["input"]>;
+  to?: InputMaybe<Scalars["Int"]["input"]>;
+}
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/swapStrategy.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/swapStrategy.ts
new file mode 100644
index 00000000..7802a5c9
--- /dev/null
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/swapStrategy.ts
@@ -0,0 +1,44 @@
+import {ExternalSwapQuote, SwapPathStats} from "./trade";
+
+type BaseSwapStrategy = {
+    amountIn: bigint;
+    amountOut: bigint;
+    usdIn: bigint;
+    usdOut: bigint;
+    priceIn: bigint;
+    priceOut: bigint;
+    feesUsd: bigint;
+  };
+  
+  export type NoSwapStrategy = BaseSwapStrategy & {
+    type: "noSwap";
+    externalSwapQuote: undefined;
+    swapPathStats: undefined;
+  };
+  
+  export type ExternalSwapStrategy = BaseSwapStrategy & {
+    type: "externalSwap";
+    externalSwapQuote: ExternalSwapQuote;
+    swapPathStats: undefined;
+  };
+  
+  export type InternalSwapStrategy = BaseSwapStrategy & {
+    type: "internalSwap";
+    swapPathStats: SwapPathStats;
+    externalSwapQuote: undefined;
+  };
+  
+  export type CombinedSwapStrategy = BaseSwapStrategy & {
+    type: "combinedSwap";
+    externalSwapQuote: ExternalSwapQuote;
+    swapPathStats: SwapPathStats;
+  };
+  
+  export type SwapStrategyForIncreaseOrders =
+    | NoSwapStrategy
+    | ExternalSwapStrategy
+    | InternalSwapStrategy
+    | CombinedSwapStrategy;
+  
+  export type SwapStrategyForSwapOrders = NoSwapStrategy | InternalSwapStrategy | CombinedSwapStrategy;
+  
\ No newline at end of file
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/tokens.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/tokens.ts
index a5dc4d39..3db9aa05 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/tokens.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/tokens.ts
@@ -1,3 +1,13 @@
+export type ERC20Address = string & { __brand: "ERC20Address" };
+export type NativeTokenSupportedAddress = string & { __brand: "NativeTokenSupportedAddress" };
+
+export type TokenAddressTypesMap = {
+  wrapped: ERC20Address;
+  native: NativeTokenSupportedAddress;
+};
+
+export type ContractPrice = bigint & { __brand: "contractPrice" };
+
 export type TokenCategory = "meme" | "layer1" | "layer2" | "defi";
 
 export type Token = {
@@ -19,6 +29,9 @@ export type Token = {
   reservesUrl?: string;
   imageUrl?: string;
   categories?: TokenCategory[];
+  isPermitSupported?: boolean;
+  isPermitDisabled?: boolean;
+  contractVersion?: string;
 
   isUsdg?: boolean;
   isNative?: boolean;
@@ -31,6 +44,7 @@ export type Token = {
   isV1Available?: boolean;
   isPlatformToken?: boolean;
   isPlatformTradingToken?: boolean;
+  isStaking?: boolean;
   shouldResetAllowance?: boolean;
 };
 
@@ -80,6 +94,28 @@ export type TokenInfo = Token & {
   maxLongCapacity?: bigint;
 };
 
+export type SignedTokenPermit = {
+  // account address
+  owner: string;
+  // spender contract address
+  spender: string;
+  // amount
+  value: bigint;
+  // validity period of the permit
+  deadline: bigint;
+  // ECDSA signature components
+  v: number;
+  r: string;
+  s: string;
+  // token address
+  token: string;
+  onchainParams: {
+    name: string;
+    version: string;
+    nonce: bigint;
+  };
+};
+
 export type InfoTokens = {
   [key: string]: TokenInfo;
 };
@@ -91,8 +127,16 @@ export type TokenPrices = {
 
 export type TokenData = Token & {
   prices: TokenPrices;
+  isGmxAccount?: boolean;
+  walletBalance?: bigint;
+  gmxAccountBalance?: bigint;
+  /**
+   * If isGmxAccount is true, then this is the gmx account balance
+   * If isGmxAccount is false, then this is the wallet balance
+   */
   balance?: bigint;
   totalSupply?: bigint;
+  hasPriceFeedProvider?: boolean;
 };
 
 export type TokensRatio = {
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/trade.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/trade.ts
index 2dbb2e1e..0020ab82 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/trade.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/trade.ts
@@ -1,6 +1,8 @@
-import { ExternalSwapFeeItem, FeeItem, SwapFeeItem } from "./fees.js";
-import { DecreasePositionSwapType, OrderType } from "./orders.js";
-import { MarketInfo } from "./markets.js";
+import {ExternalSwapFeeItem, FeeItem, SwapFeeItem} from "./fees.js";
+import {DecreasePositionSwapType, OrderType} from "./orders.js";
+import {TokensData} from "./tokens.js";
+import {SwapStrategyForIncreaseOrders} from "./swapStrategy.js";
+
 export enum TradeType {
   Long = "Long",
   Short = "Short",
@@ -12,6 +14,7 @@ export enum TradeMode {
   Limit = "Limit",
   StopMarket = "StopMarket",
   Trigger = "Trigger",
+  Twap = "TWAP",
 }
 
 export enum TriggerThresholdType {
@@ -33,6 +36,7 @@ export type TradeFlags = {
   isTrigger: boolean;
   isMarket: boolean;
   isLimit: boolean;
+  isTwap: boolean;
 };
 
 export type SwapAmounts = {
@@ -42,7 +46,7 @@ export type SwapAmounts = {
   usdOut: bigint;
   priceIn: bigint;
   priceOut: bigint;
-  swapPathStats: SwapPathStats | undefined;
+  swapStrategy: SwapStrategyForIncreaseOrders;
   minOutputAmount: bigint;
   uiFeeUsd?: bigint;
 };
@@ -54,8 +58,7 @@ export type IncreasePositionAmounts = {
   collateralDeltaAmount: bigint;
   collateralDeltaUsd: bigint;
 
-  swapPathStats: SwapPathStats | undefined;
-  externalSwapQuote: ExternalSwapQuote | undefined;
+  swapStrategy: SwapStrategyForIncreaseOrders;
   indexTokenAmount: bigint;
 
   sizeDeltaUsd: bigint;
@@ -71,6 +74,7 @@ export type IncreasePositionAmounts = {
   triggerThresholdType?: TriggerThresholdType;
   acceptablePrice: bigint;
   acceptablePriceDeltaBps: bigint;
+  recommendedAcceptablePriceDeltaBps: bigint;
 
   positionFeeUsd: bigint;
   uiFeeUsd: bigint;
@@ -107,8 +111,11 @@ export type DecreasePositionAmounts = {
   borrowingFeeUsd: bigint;
   fundingFeeUsd: bigint;
   swapProfitFeeUsd: bigint;
-  positionPriceImpactDeltaUsd: bigint;
+  proportionalPendingImpactDeltaUsd: bigint;
+  closePriceImpactDeltaUsd: bigint;
+  totalPendingImpactDeltaUsd: bigint;
   priceImpactDiffUsd: bigint;
+  balanceWasImproved: boolean;
   payedRemainingCollateralAmount: bigint;
 
   payedOutputUsd: bigint;
@@ -159,6 +166,8 @@ export type NextPositionValues = {
   nextPnlPercentage?: bigint;
   nextEntryPrice?: bigint;
   remainingCollateralFeesUsd?: bigint;
+  nextPendingImpactDeltaUsd?: bigint;
+  potentialPriceImpactDiffUsd?: bigint;
 };
 
 export type SwapStats = {
@@ -194,10 +203,13 @@ export type SwapPathStats = {
 
 export type MarketEdge = {
   marketAddress: string;
-  marketInfo: MarketInfo;
-  // from token
+  /**
+   * Token Address
+   */
   from: string;
-  // to token
+  /**
+   * Token Address
+   */
   to: string;
 };
 
@@ -207,9 +219,11 @@ export type SwapRoute = {
   liquidity: bigint;
 };
 
-export type MarketsGraph = {
-  abjacencyList: { [token: string]: MarketEdge[] };
-  edges: MarketEdge[];
+type TokenAddress = string;
+export type SwapPaths = {
+  [from: TokenAddress]: {
+    [to: TokenAddress]: TokenAddress[][];
+  };
 };
 
 export type SwapEstimator = (
@@ -219,38 +233,42 @@ export type SwapEstimator = (
   usdOut: bigint;
 };
 
-export type FindSwapPath = (usdIn: bigint, opts: { order?: ("liquidity" | "length")[] }) => SwapPathStats | undefined;
+export type NaiveSwapEstimator = (
+  e: MarketEdge,
+  usdIn: bigint
+) => {
+  /**
+   * 1.1 means output is 10% greater than input
+   * 0.9 means output is 10% less than input
+   */
+  swapYield: number;
+};
+
+export type NaiveNetworkEstimator = (
+  usdIn: bigint,
+  swapCount: number
+) => {
+  networkYield: number;
+  usdOut: bigint;
+};
+
+export type MarketEdgeLiquidityGetter = (e: MarketEdge) => bigint;
+
+export type SwapOptimizationOrderArray = ("liquidity" | "length")[];
+export type FindSwapPath = (usdIn: bigint, opts?: { order?: SwapOptimizationOrderArray }) => SwapPathStats | undefined;
 
 export type TradeFeesType = "swap" | "increase" | "decrease" | "edit";
 
 export enum ExternalSwapAggregator {
   OpenOcean = "openOcean",
+  BotanixStaking = "botanixStaking",
 }
 
-export type ExternalSwapOutput = {
-  aggregator: ExternalSwapAggregator;
-  inTokenAddress: string;
-  outTokenAddress: string;
-  amountIn: bigint;
-  amountOut: bigint;
-  usdIn: bigint | undefined;
-  usdOut: bigint | undefined;
-  priceIn: bigint | undefined;
-  priceOut: bigint | undefined;
-  feesUsd: bigint | undefined;
-  needSpenderApproval?: boolean;
-  txnData: {
-    to: string;
-    data: string;
-    value: bigint;
-    estimatedGas: bigint;
-  };
-};
-
 export type ExternalSwapQuote = {
   aggregator: ExternalSwapAggregator;
   inTokenAddress: string;
   outTokenAddress: string;
+  receiver: string;
   amountIn: bigint;
   amountOut: bigint;
   usdIn: bigint;
@@ -264,9 +282,24 @@ export type ExternalSwapQuote = {
     data: string;
     value: bigint;
     estimatedGas: bigint;
+    estimatedExecutionFee: bigint;
   };
 };
 
+export type ExternalSwapPath = {
+  aggregator: ExternalSwapAggregator;
+  inTokenAddress: string;
+  outTokenAddress: string;
+};
+
+export type ExternalSwapQuoteParams = {
+  chainId: number;
+  receiverAddress: string;
+  gasPrice: bigint | undefined;
+  tokensData: TokensData | undefined;
+  botanixStakingAssetsPerShare: bigint | undefined;
+};
+
 export type ExternalSwapCalculationStrategy = "byFromValue" | "leverageBySize";
 
 export type ExternalSwapInputs = {
@@ -287,9 +320,14 @@ export type TradeFees = {
   swapFees?: SwapFeeItem[];
   positionFee?: FeeItem;
   swapPriceImpact?: FeeItem;
-  positionPriceImpact?: FeeItem;
-  priceImpactDiff?: FeeItem;
   positionCollateralPriceImpact?: FeeItem;
+  proportionalPendingImpact?: FeeItem;
+  increasePositionPriceImpact?: FeeItem;
+  decreasePositionPriceImpact?: FeeItem;
+  totalPendingImpact?: FeeItem;
+  priceImpactDiff?: FeeItem;
+  positionNetPriceImpact?: FeeItem;
+  collateralNetPriceImpact?: FeeItem;
   collateralPriceImpactDiff?: FeeItem;
   positionFeeFactor?: bigint;
   borrowFee?: FeeItem;
@@ -316,4 +354,5 @@ export type TradeSearchParams = {
   pool?: string;
   collateral?: string;
   market?: string;
+  chainId?: string;
 };
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/tradeHistory.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/tradeHistory.ts
index c36db962..641f6849 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/types/tradeHistory.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/types/tradeHistory.ts
@@ -1,7 +1,6 @@
-import { BytesLike } from "./common";
-import { MarketInfo } from "./markets";
-import { OrderType } from "./orders";
-import { TokenData } from "./tokens";
+import {MarketInfo} from "./markets";
+import {OrderType} from "./orders";
+import {TokenData} from "./tokens";
 
 export enum TradeActionType {
   OrderCreated = "OrderCreated",
@@ -11,54 +10,9 @@ export enum TradeActionType {
   OrderFrozen = "OrderFrozen",
 }
 
-export type RawTradeAction = {
-  id: string;
-  eventName: TradeActionType;
-
-  account: string;
-  marketAddress?: string;
-  swapPath?: string[];
-  initialCollateralTokenAddress?: string;
-
-  initialCollateralDeltaAmount?: string;
-  sizeDeltaUsd?: string;
-  triggerPrice?: string;
-  acceptablePrice?: string;
-  executionPrice?: string;
-  minOutputAmount?: string;
-  executionAmountOut?: string;
-
-  priceImpactDiffUsd?: string;
-  priceImpactUsd?: string;
-  positionFeeAmount?: string;
-  borrowingFeeAmount?: string;
-  fundingFeeAmount?: string;
-  liquidationFeeAmount?: string;
-  pnlUsd?: string;
-  basePnlUsd?: string;
-
-  collateralTokenPriceMax?: string;
-  collateralTokenPriceMin?: string;
-
-  indexTokenPriceMin?: string;
-  indexTokenPriceMax?: string;
-
-  orderType: OrderType;
-  orderKey: string;
-  isLong?: boolean;
-  shouldUnwrapNativeToken?: boolean;
-
-  reason?: string;
-  reasonBytes?: BytesLike;
-
-  transaction: {
-    timestamp: number;
-    hash: string;
-  };
-};
-
 export type PositionTradeAction = {
   id: string;
+  srcChainId?: number;
   eventName: TradeActionType;
   marketInfo: MarketInfo;
   marketAddress: string;
@@ -91,16 +45,23 @@ export type PositionTradeAction = {
   reason?: string;
   reasonBytes?: string | Uint8Array;
   shouldUnwrapNativeToken: boolean;
+  totalImpactUsd?: bigint;
   liquidationFeeAmount?: bigint;
-
+  twapParams:
+    | {
+        twapGroupId: string;
+        numberOfParts: number;
+      }
+    | undefined;
+  timestamp: number;
   transaction: {
-    timestamp: number;
     hash: string;
   };
 };
 
 export type SwapTradeAction = {
   id: string;
+  srcChainId?: number;
   account: string;
   eventName: TradeActionType;
   initialCollateralTokenAddress: string;
@@ -113,12 +74,17 @@ export type SwapTradeAction = {
   executionAmountOut?: bigint;
   orderType: OrderType;
   orderKey: string;
-
   reason?: string;
   reasonBytes?: string | Uint8Array;
+  twapParams:
+    | {
+        twapGroupId: string;
+        numberOfParts: number;
+      }
+    | undefined;
 
+  timestamp: number;
   transaction: {
-    timestamp: number;
     hash: string;
   };
 };
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/__tests__/positions.spec.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/__tests__/positions.spec.ts
index 47c5e731..e0d012be 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/__tests__/positions.spec.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/__tests__/positions.spec.ts
@@ -113,6 +113,8 @@ describe("getPositionNetValue", () => {
       closingFeeUsd: 5n,
       uiFeeUsd: 20n,
       pnl: 200n,
+      totalPendingImpactDeltaUsd: 10n,
+      priceImpactDiffUsd: 15n,
     });
     // netValue = 1000n - (10n+15n) -5n -20n + 200n = 1000n -25n -5n -20n +200n=1150n
     expect(result).toBe(1150n);
@@ -168,6 +170,7 @@ describe("getLiquidationPrice", () => {
         minCollateralUsd: 100n,
         isLong: true,
         userReferralInfo: undefined,
+        pendingImpactAmount: 0n,
       })
     ).toBeUndefined();
     expect(
@@ -183,6 +186,7 @@ describe("getLiquidationPrice", () => {
         minCollateralUsd: 100n,
         isLong: true,
         userReferralInfo: undefined,
+        pendingImpactAmount: 0n,
       })
     ).toBeUndefined();
   });
@@ -207,6 +211,7 @@ describe("getLiquidationPrice", () => {
       minCollateralUsd: 200n,
       isLong: true,
       userReferralInfo: undefined,
+      pendingImpactAmount: 0n,
     });
     expect(result).toBeDefined();
   });
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/bigmath.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/bigmath.ts
index 7e389e2a..361303f5 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/bigmath.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/bigmath.ts
@@ -2,8 +2,14 @@ export const bigMath = {
   abs(x: bigint) {
     return x < 0n ? -x : x;
   },
-  mulDiv(x: bigint, y: bigint, z: bigint) {
-    return (x * y) / z;
+  mulDiv(x: bigint, y: bigint, z: bigint, roundUpMagnitude = false) {
+    const result = (x * y) / z;
+
+    if (roundUpMagnitude && this.mulmod(x, y, z) > 0n) {
+      return result + 1n;
+    }
+
+    return result;
   },
   max(max: bigint, ...rest: bigint[]) {
     return rest.reduce((currentMax, val) => (currentMax < val ? val : currentMax), max);
@@ -30,4 +36,10 @@ export const bigMath = {
   divRound(x: bigint, y: bigint) {
     return x / y + ((x % y) * 2n > y ? 1n : 0n);
   },
+  divRoundUp(x: bigint, y: bigint) {
+    return (x + y - 1n) / y;
+  },
+  mulmod(x: bigint, y: bigint, m: bigint): bigint {
+    return (x * y) % m;
+  },
 };
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/callContract.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/callContract.ts
index c510723b..fc0d55c8 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/callContract.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/callContract.ts
@@ -1,12 +1,16 @@
-import { Abi, Address, encodeFunctionData, PublicClient, withRetry } from "viem";
-import { getPrivyClient, getChainName } from '../../../plugins/custom/privy.js';
+import {Abi, Address, encodeFunctionData, PublicClient, withRetry} from "viem";
+import {getChainName, getPrivyClient} from '../../../plugins/custom/privy.js';
 
-import type { GmxSdk } from "../index.js";
-import { bigMath } from "./bigmath.js";
-import { GAS_PRICE_BUFFER_MAP, GAS_PRICE_PREMIUM_MAP, MAX_FEE_PER_GAS_MAP, MAX_PRIORITY_FEE_PER_GAS_MAP } from "../configs/chains.js";
-
-import { getChain } from "../configs/chains.js";
-import { BASIS_POINTS_DIVISOR_BIGINT } from "../configs/factors.js";
+import type {GmxSdk} from "../index.js";
+import {bigMath} from "./bigmath.js";
+import {
+  GAS_PRICE_BUFFER_MAP,
+  GAS_PRICE_PREMIUM_MAP,
+  getViemChain,
+  MAX_FEE_PER_GAS_MAP,
+  MAX_PRIORITY_FEE_PER_GAS_MAP
+} from "../configs/chains.js";
+import {BASIS_POINTS_DIVISOR_BIGINT} from "../configs/factors.js";
 
 export async function getGasPrice(client: PublicClient, chainId: number) {
   let maxFeePerGas = MAX_FEE_PER_GAS_MAP[chainId];
@@ -16,11 +20,11 @@ export async function getGasPrice(client: PublicClient, chainId: number) {
     () =>
       client.estimateFeesPerGas({
         type: "legacy",
-        chain: getChain(chainId),
+        chain: getViemChain(chainId),
       }),
     {
       delay: 200,
-      retryCount: 2,
+      retryCount: 1,
       shouldRetry: ({ error }) => {
         const isInvalidBlockError = error?.message?.includes("invalid value for value.hash");
 
@@ -189,7 +193,9 @@ export async function callContract(
       }
     };
 
-    console.log('param', param)
+    console.log('Address', sdk.config.account)
+    console.log('Method', method)
+    console.log('Params', params)
 
     const response = await privy.walletApi.ethereum.sendTransaction(param as any);
 
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/fees/getNaiveEstimatedGasBySwapCount.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/fees/getNaiveEstimatedGasBySwapCount.ts
new file mode 100644
index 00000000..da5f7c19
--- /dev/null
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/fees/getNaiveEstimatedGasBySwapCount.ts
@@ -0,0 +1,7 @@
+import type {GasLimitsConfig} from "../../types/fees.js";
+
+export function getNaiveEstimatedGasBySwapCount(singleSwap: GasLimitsConfig["singleSwap"], swapsCount: number): bigint {
+  const swapsCountBigint = BigInt(swapsCount);
+
+  return singleSwap * swapsCountBigint;
+}
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/fees/index.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/fees/index.ts
index 3f00caff..b19af487 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/fees/index.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/fees/index.ts
@@ -1,18 +1,30 @@
-import { HIGH_PRICE_IMPACT_BPS } from "../../configs/factors.js";
-import { FeeItem } from "../../types/fees.js";
-import { MarketInfo } from "../../types/markets.js";
-import { SwapStats } from "../../types/trade.js";
-import { bigMath } from "../bigmath.js";
-import { applyFactor, getBasisPoints, PRECISION } from "../numbers.js";
+import {HIGH_PRICE_IMPACT_BPS} from "../../configs/factors.js";
+import {FeeItem} from "../../types/fees.js";
+import {MarketInfo} from "../../types/markets.js";
+import {SwapStats} from "../../types/trade.js";
+import {bigMath} from "../bigmath.js";
+import {applyFactor, getBasisPoints, PRECISION} from "../numbers.js";
 
 export * from "./estimateOraclePriceCount.js";
 export * from "./executionFee.js";
 export * from "./priceImpact.js";
 
-export function getSwapFee(marketInfo: MarketInfo, swapAmount: bigint, forPositiveImpact: boolean) {
-  const factor = forPositiveImpact
-    ? marketInfo.swapFeeFactorForPositiveImpact
-    : marketInfo.swapFeeFactorForNegativeImpact;
+
+export function getSwapFee(
+  marketInfo: MarketInfo,
+  swapAmount: bigint,
+  balanceWasImproved: boolean,
+  isAtomicSwap: boolean
+) {
+  let factor: bigint;
+
+  if (isAtomicSwap) {
+    factor = BigInt(marketInfo.atomicSwapFeeFactor ?? 0);
+  } else {
+    factor = BigInt(balanceWasImproved
+      ? (marketInfo.swapFeeFactorForBalanceWasImproved ?? 0)
+      : (marketInfo.swapFeeFactorForBalanceWasNotImproved ?? 0));
+  }
 
   return applyFactor(swapAmount, factor);
 }
@@ -20,13 +32,13 @@ export function getSwapFee(marketInfo: MarketInfo, swapAmount: bigint, forPositi
 export function getPositionFee(
   marketInfo: MarketInfo,
   sizeDeltaUsd: bigint,
-  forPositiveImpact: boolean,
+  balanceWasImproved: boolean,
   referralInfo: { totalRebateFactor: bigint; discountFactor: bigint } | undefined,
   uiFeeFactor?: bigint
 ) {
-  const factor = forPositiveImpact
-    ? marketInfo.positionFeeFactorForPositiveImpact
-    : marketInfo.positionFeeFactorForNegativeImpact;
+  const factor = BigInt(balanceWasImproved
+    ? (marketInfo.positionFeeFactorForBalanceWasImproved ?? 0)
+    : (marketInfo.positionFeeFactorForBalanceWasNotImproved ?? 0));
 
   let positionFeeUsd = applyFactor(sizeDeltaUsd, factor);
   const uiFeeUsd = applyFactor(sizeDeltaUsd, uiFeeFactor ?? 0n);
@@ -58,7 +70,7 @@ export function getFundingFactorPerPeriod(marketInfo: MarketInfo, isLong: boolea
 
   let fundingForPayingSide = 0n;
   if (payingInterestUsd !== 0n) {
-    fundingForPayingSide = bigMath.mulDiv(fundingFactorPerSecond, largerInterestUsd, payingInterestUsd);
+    fundingForPayingSide = bigMath.mulDiv(BigInt(fundingFactorPerSecond ?? 0), largerInterestUsd, payingInterestUsd);
   }
   let fundingForReceivingSide = 0n;
   if (receivingInterestUsd !== 0n) {
@@ -86,9 +98,9 @@ export function getFundingFeeRateUsd(
 }
 
 export function getBorrowingFactorPerPeriod(marketInfo: MarketInfo, isLong: boolean, periodInSeconds: number) {
-  const factorPerSecond = isLong
-    ? marketInfo.borrowingFactorPerSecondForLongs
-    : marketInfo.borrowingFactorPerSecondForShorts;
+  const factorPerSecond = BigInt(isLong
+    ? (marketInfo.borrowingFactorPerSecondForLongs ?? 0)
+    : (marketInfo.borrowingFactorPerSecondForShorts ?? 0));
 
   return factorPerSecond * BigInt(periodInSeconds || 1);
 }
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/fees/priceImpact.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/fees/priceImpact.ts
index e563bd6b..ae269096 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/fees/priceImpact.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/fees/priceImpact.ts
@@ -1,10 +1,10 @@
-import { bigNumberify } from "../../modules/trades/trades.js";
-import { MarketInfo } from "../../types/markets.js";
-import { TokenData } from "../../types/tokens.js";
-import { bigMath } from "../bigmath.js";
-import { getTokenPoolType } from "../markets.js";
-import { applyFactor, expandDecimals, getBasisPoints, roundUpMagnitudeDivision } from "../numbers.js";
-import { convertToTokenAmount, convertToUsd, getMidPrice } from "../tokens.js";
+import {bigNumberify} from "../tradeHistory.js";
+import {MarketInfo} from "../../types/markets.js";
+import {TokenData} from "../../types/tokens.js";
+import {bigMath} from "../bigmath.js";
+import {getTokenPoolType} from "../markets.js";
+import {applyFactor, expandDecimals, getBasisPoints, roundUpMagnitudeDivision} from "../numbers.js";
+import {convertToTokenAmount, convertToUsd, getMidPrice} from "../tokens.js";
 
 export function getPriceImpactByAcceptablePrice(p: {
   sizeDeltaUsd: bigint;
@@ -69,38 +69,72 @@ export function getCappedPositionImpactUsd(
   marketInfo: MarketInfo,
   sizeDeltaUsd: bigint,
   isLong: boolean,
-  opts: { fallbackToZero?: boolean } = {}
+  isIncrease: boolean,
+  opts: { fallbackToZero?: boolean; shouldCapNegativeImpact?: boolean } = {}
 ) {
-  const priceImpactDeltaUsd = getPriceImpactForPosition(marketInfo, sizeDeltaUsd, isLong, opts);
+  sizeDeltaUsd = isIncrease ? sizeDeltaUsd : sizeDeltaUsd * -1n;
 
-  if (priceImpactDeltaUsd < 0) {
-    return priceImpactDeltaUsd;
+  const { priceImpactDeltaUsd, balanceWasImproved } = getPriceImpactForPosition(marketInfo, sizeDeltaUsd, isLong, opts);
+
+  if (priceImpactDeltaUsd < 0 && !opts.shouldCapNegativeImpact) {
+    return { priceImpactDeltaUsd, balanceWasImproved };
+  }
+
+  const cappedImpactUsd = capPositionImpactUsdByMaxPriceImpactFactor(marketInfo, sizeDeltaUsd, priceImpactDeltaUsd);
+
+  return {
+    priceImpactDeltaUsd: cappedImpactUsd,
+    balanceWasImproved,
+  };
+}
+
+export function capPositionImpactUsdByMaxImpactPool(marketInfo: MarketInfo, positionImpactDeltaUsd: bigint) {
+  if (positionImpactDeltaUsd < 0) {
+    return positionImpactDeltaUsd;
   }
 
   const { indexToken } = marketInfo;
-
-  const impactPoolAmount = marketInfo?.positionImpactPoolAmount;
-
+  const impactPoolAmount = marketInfo.positionImpactPoolAmount;
   const maxPriceImpactUsdBasedOnImpactPool = convertToUsd(
     impactPoolAmount,
     indexToken.decimals,
     indexToken.prices.minPrice
   )!;
 
-  let cappedImpactUsd = priceImpactDeltaUsd;
-
-  if (cappedImpactUsd > maxPriceImpactUsdBasedOnImpactPool) {
-    cappedImpactUsd = maxPriceImpactUsdBasedOnImpactPool;
+  if (positionImpactDeltaUsd > maxPriceImpactUsdBasedOnImpactPool) {
+    positionImpactDeltaUsd = maxPriceImpactUsdBasedOnImpactPool;
   }
 
-  const maxPriceImpactFactor = marketInfo.maxPositionImpactFactorPositive;
-  const maxPriceImpactUsdBasedOnMaxPriceImpactFactor = applyFactor(bigMath.abs(sizeDeltaUsd), maxPriceImpactFactor);
+  return positionImpactDeltaUsd;
+}
 
-  if (cappedImpactUsd > maxPriceImpactUsdBasedOnMaxPriceImpactFactor) {
-    cappedImpactUsd = maxPriceImpactUsdBasedOnMaxPriceImpactFactor;
+export function capPositionImpactUsdByMaxPriceImpactFactor(
+  marketInfo: MarketInfo,
+  sizeDeltaUsd: bigint,
+  positionImpactDeltaUsd: bigint
+) {
+  const { maxPositiveImpactFactor, maxNegativeImpactFactor } = getMaxPositionImpactFactors(marketInfo);
+
+  const maxPriceImapctFactor = positionImpactDeltaUsd > 0 ? maxPositiveImpactFactor : maxNegativeImpactFactor;
+
+  const maxPriceImpactUsdBasedOnMaxPriceImpactFactor = applyFactor(bigMath.abs(sizeDeltaUsd), maxPriceImapctFactor);
+
+  if (bigMath.abs(positionImpactDeltaUsd) > maxPriceImpactUsdBasedOnMaxPriceImpactFactor) {
+    positionImpactDeltaUsd = maxPriceImpactUsdBasedOnMaxPriceImpactFactor * (positionImpactDeltaUsd > 0 ? 1n : -1n);
   }
 
-  return cappedImpactUsd;
+  return positionImpactDeltaUsd;
+}
+
+export function getMaxPositionImpactFactors(marketInfo: MarketInfo) {
+  let maxPositiveImpactFactor = marketInfo.maxPositionImpactFactorPositive;
+  const maxNegativeImpactFactor = marketInfo.maxPositionImpactFactorNegative;
+
+  if (maxPositiveImpactFactor > maxNegativeImpactFactor) {
+    maxPositiveImpactFactor = maxNegativeImpactFactor;
+  }
+
+  return { maxPositiveImpactFactor, maxNegativeImpactFactor };
 }
 
 export function getPriceImpactForPosition(
@@ -118,7 +152,7 @@ export function getPriceImpactForPosition(
     isLong: isLong!,
   });
 
-  const priceImpactUsd = getPriceImpactUsd({
+  const { priceImpactDeltaUsd, balanceWasImproved } = getPriceImpactUsd({
     currentLongUsd,
     currentShortUsd,
     nextLongUsd,
@@ -129,12 +163,18 @@ export function getPriceImpactForPosition(
     fallbackToZero: opts.fallbackToZero,
   });
 
-  if (priceImpactUsd > 0) {
-    return priceImpactUsd;
+  if (priceImpactDeltaUsd > 0) {
+    return {
+      priceImpactDeltaUsd,
+      balanceWasImproved,
+    };
   }
 
   if (bigMath.abs(marketInfo.virtualInventoryForPositions) <= 0) {
-    return priceImpactUsd;
+    return {
+      priceImpactDeltaUsd,
+      balanceWasImproved,
+    };
   }
 
   const virtualInventoryParams = getNextOpenInterestForVirtualInventory({
@@ -143,7 +183,7 @@ export function getPriceImpactForPosition(
     isLong: isLong!,
   });
 
-  const priceImpactUsdForVirtualInventory = getPriceImpactUsd({
+  const { priceImpactDeltaUsd: priceImpactUsdForVirtualInventory } = getPriceImpactUsd({
     currentLongUsd: virtualInventoryParams.currentLongUsd,
     currentShortUsd: virtualInventoryParams.currentShortUsd,
     nextLongUsd: virtualInventoryParams.nextLongUsd,
@@ -154,7 +194,38 @@ export function getPriceImpactForPosition(
     fallbackToZero: opts.fallbackToZero,
   });
 
-  return priceImpactUsdForVirtualInventory < priceImpactUsd! ? priceImpactUsdForVirtualInventory : priceImpactUsd;
+  return {
+    priceImpactDeltaUsd:
+      priceImpactUsdForVirtualInventory < priceImpactDeltaUsd!
+        ? priceImpactUsdForVirtualInventory
+        : priceImpactDeltaUsd!,
+    balanceWasImproved,
+  };
+}
+
+export function getProportionalPendingImpactValues({
+  sizeInUsd,
+  pendingImpactAmount,
+  sizeDeltaUsd,
+  indexToken,
+}: {
+  sizeInUsd: bigint;
+  pendingImpactAmount: bigint;
+  sizeDeltaUsd: bigint;
+  indexToken: TokenData;
+}) {
+  const proportionalPendingImpactDeltaAmount =
+    sizeDeltaUsd !== 0n && sizeInUsd !== 0n
+      ? bigMath.mulDiv(pendingImpactAmount, sizeDeltaUsd, sizeInUsd, pendingImpactAmount < 0n)
+      : 0n;
+
+  const proportionalPendingImpactDeltaUsd = convertToUsd(
+    proportionalPendingImpactDeltaAmount,
+    indexToken.decimals,
+    proportionalPendingImpactDeltaAmount > 0 ? indexToken.prices.minPrice : indexToken.prices.maxPrice
+  )!;
+
+  return { proportionalPendingImpactDeltaAmount, proportionalPendingImpactDeltaUsd };
 }
 
 export function getPriceImpactForSwap(
@@ -190,7 +261,7 @@ export function getPriceImpactForSwap(
     shortDeltaUsd,
   });
 
-  const priceImpactUsd = getPriceImpactUsd({
+  const { priceImpactDeltaUsd, balanceWasImproved } = getPriceImpactUsd({
     currentLongUsd: longPoolUsd,
     currentShortUsd: shortPoolUsd,
     nextLongUsd: nextLongPoolUsd,
@@ -201,15 +272,21 @@ export function getPriceImpactForSwap(
     fallbackToZero: opts.fallbackToZero,
   });
 
-  if (priceImpactUsd > 0) {
-    return priceImpactUsd;
+  if (priceImpactDeltaUsd > 0) {
+    return {
+      priceImpactDeltaUsd,
+      balanceWasImproved,
+    };
   }
 
   const virtualInventoryLong = marketInfo.virtualPoolAmountForLongToken;
   const virtualInventoryShort = marketInfo.virtualPoolAmountForShortToken;
 
   if (virtualInventoryLong <= 0 || virtualInventoryShort <= 0) {
-    return priceImpactUsd;
+    return {
+      priceImpactDeltaUsd,
+      balanceWasImproved,
+    };
   }
 
   const virtualInventoryParams = getNextPoolAmountsParams({
@@ -222,7 +299,7 @@ export function getPriceImpactForSwap(
     shortDeltaUsd,
   });
 
-  const priceImpactUsdForVirtualInventory = getPriceImpactUsd({
+  const { priceImpactDeltaUsd: priceImpactUsdForVirtualInventory } = getPriceImpactUsd({
     currentLongUsd: virtualInventoryParams.longPoolUsd,
     currentShortUsd: virtualInventoryParams.shortPoolUsd,
     nextLongUsd: virtualInventoryParams.nextLongPoolUsd,
@@ -233,7 +310,13 @@ export function getPriceImpactForSwap(
     fallbackToZero: opts.fallbackToZero,
   });
 
-  return priceImpactUsdForVirtualInventory < priceImpactUsd! ? priceImpactUsdForVirtualInventory : priceImpactUsd;
+  return {
+    priceImpactDeltaUsd:
+      priceImpactUsdForVirtualInventory < priceImpactDeltaUsd!
+        ? priceImpactUsdForVirtualInventory
+        : priceImpactDeltaUsd!,
+    balanceWasImproved,
+  };
 }
 
 function getNextOpenInterestForVirtualInventory(p: { virtualInventory: bigint; usdDelta: bigint; isLong: boolean }) {
@@ -335,7 +418,10 @@ export function getPriceImpactUsd(p: {
 
   if (nextLongUsd < 0 || nextShortUsd < 0) {
     if (p.fallbackToZero) {
-      return 0n;
+      return {
+        priceImpactDeltaUsd: 0n,
+        balanceWasImproved: false,
+      };
     } else {
       throw new Error("Negative pool amount");
     }
@@ -346,13 +432,14 @@ export function getPriceImpactUsd(p: {
 
   const isSameSideRebalance = p.currentLongUsd < p.currentShortUsd === nextLongUsd < nextShortUsd;
 
-  let impactUsd: bigint;
+  let priceImpactDeltaUsd: bigint;
 
+  const balanceWasImproved = nextDiff < currentDiff;
   if (isSameSideRebalance) {
     const hasPositiveImpact = nextDiff < currentDiff;
     const factor = hasPositiveImpact ? p.factorPositive : p.factorNegative;
 
-    impactUsd = calculateImpactForSameSideRebalance({
+    priceImpactDeltaUsd = calculateImpactForSameSideRebalance({
       currentDiff,
       nextDiff,
       hasPositiveImpact,
@@ -360,7 +447,7 @@ export function getPriceImpactUsd(p: {
       exponentFactor: p.exponentFactor,
     });
   } else {
-    impactUsd = calculateImpactForCrossoverRebalance({
+    priceImpactDeltaUsd = calculateImpactForCrossoverRebalance({
       currentDiff,
       nextDiff,
       factorPositive: p.factorPositive,
@@ -369,7 +456,10 @@ export function getPriceImpactUsd(p: {
     });
   }
 
-  return impactUsd;
+  return {
+    priceImpactDeltaUsd,
+    balanceWasImproved,
+  };
 }
 
 /**
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/hash.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/hash.ts
index 64499f26..03c68e14 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/hash.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/hash.ts
@@ -1,9 +1,11 @@
-import {encodeAbiParameters, keccak256} from "viem";
+import {encodeAbiParameters, keccak256, stringToBytes} from "viem";
 import {LRUCache} from "./LruCache.js";
 
+export const ZERO_DATA = "0x";
+
 const dataCache = new LRUCache<string>(10_000);
 
-export function hashData(dataTypes, dataValues) {
+export function hashData(dataTypes: string[], dataValues: (string | number | bigint | boolean)[]) {
   const key = JSON.stringify({ dataTypes, dataValues }, (_, val) => (typeof val === "bigint" ? String(val) : val));
 
   if (dataCache.has(key)) {
@@ -12,7 +14,7 @@ export function hashData(dataTypes, dataValues) {
 
   // Convert dataTypes from array of strings to array of objects with 'type' property
   const abiParameters = dataTypes.map((type) => ({ type }));
-  const bytes = encodeAbiParameters(abiParameters, dataValues);
+  const bytes = encodeAbiParameters(abiParameters, dataValues as any);
   const hash = keccak256(bytes);
 
   dataCache.set(key, hash);
@@ -40,7 +42,8 @@ export function hashDataMap<
 ): {
   [K in keyof R]: string;
 } {
-  const result = {};
+  const result: Record<string, string> = {};
+
   for (const key of Object.keys(map)) {
     if (!map[key]) {
       continue;
@@ -55,3 +58,7 @@ export function hashDataMap<
     [K in keyof R]: string;
   };
 }
+
+export function keccakString(string: string) {
+  return keccak256(stringToBytes(string));
+}
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/marketKeysAndConfigs.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/marketKeysAndConfigs.ts
index 7dd78127..33615b29 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/marketKeysAndConfigs.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/marketKeysAndConfigs.ts
@@ -1,44 +1,50 @@
 import {hashDataMap} from "./hash.js";
 
 import {
-  BORROWING_EXPONENT_FACTOR_KEY,
-  BORROWING_FACTOR_KEY,
-  FUNDING_DECREASE_FACTOR_PER_SECOND,
-  FUNDING_EXPONENT_FACTOR_KEY,
-  FUNDING_FACTOR_KEY,
-  FUNDING_INCREASE_FACTOR_PER_SECOND,
-  IS_MARKET_DISABLED_KEY,
-  MAX_FUNDING_FACTOR_PER_SECOND,
-  MAX_OPEN_INTEREST_KEY,
-  MAX_PNL_FACTOR_FOR_TRADERS_KEY,
-  MAX_PNL_FACTOR_KEY,
-  MAX_POOL_AMOUNT_KEY,
-  MAX_POOL_USD_FOR_DEPOSIT_KEY,
-  MAX_POSITION_IMPACT_FACTOR_FOR_LIQUIDATIONS_KEY,
-  MAX_POSITION_IMPACT_FACTOR_KEY,
-  MIN_COLLATERAL_FACTOR_FOR_OPEN_INTEREST_MULTIPLIER_KEY,
-  MIN_COLLATERAL_FACTOR_KEY,
-  MIN_FUNDING_FACTOR_PER_SECOND,
-  MIN_POSITION_IMPACT_POOL_AMOUNT_KEY,
-  OPEN_INTEREST_IN_TOKENS_KEY,
-  OPEN_INTEREST_KEY,
-  OPEN_INTEREST_RESERVE_FACTOR_KEY,
-  POOL_AMOUNT_ADJUSTMENT_KEY,
-  POOL_AMOUNT_KEY,
-  POSITION_FEE_FACTOR_KEY,
-  POSITION_IMPACT_EXPONENT_FACTOR_KEY,
-  POSITION_IMPACT_FACTOR_KEY,
-  POSITION_IMPACT_POOL_AMOUNT_KEY,
-  POSITION_IMPACT_POOL_DISTRIBUTION_RATE_KEY,
-  RESERVE_FACTOR_KEY,
-  SWAP_FEE_FACTOR_KEY,
-  SWAP_IMPACT_EXPONENT_FACTOR_KEY,
-  SWAP_IMPACT_FACTOR_KEY,
-  SWAP_IMPACT_POOL_AMOUNT_KEY,
-  THRESHOLD_FOR_DECREASE_FUNDING,
-  THRESHOLD_FOR_STABLE_FUNDING,
-  VIRTUAL_MARKET_ID_KEY,
-  VIRTUAL_TOKEN_ID_KEY,
+    ATOMIC_SWAP_FEE_FACTOR_KEY,
+    BORROWING_EXPONENT_FACTOR_KEY,
+    BORROWING_FACTOR_KEY,
+    FUNDING_DECREASE_FACTOR_PER_SECOND,
+    FUNDING_EXPONENT_FACTOR_KEY,
+    FUNDING_FACTOR_KEY,
+    FUNDING_INCREASE_FACTOR_PER_SECOND,
+    IS_MARKET_DISABLED_KEY,
+    LENT_POSITION_IMPACT_POOL_AMOUNT_KEY,
+    MAX_FUNDING_FACTOR_PER_SECOND,
+    MAX_LENDABLE_IMPACT_FACTOR_FOR_WITHDRAWALS_KEY,
+    MAX_LENDABLE_IMPACT_FACTOR_KEY,
+    MAX_LENDABLE_IMPACT_USD_KEY,
+    MAX_OPEN_INTEREST_KEY,
+    MAX_PNL_FACTOR_FOR_TRADERS_KEY,
+    MAX_PNL_FACTOR_KEY,
+    MAX_POOL_AMOUNT_KEY,
+    MAX_POOL_USD_FOR_DEPOSIT_KEY,
+    MAX_POSITION_IMPACT_FACTOR_FOR_LIQUIDATIONS_KEY,
+    MAX_POSITION_IMPACT_FACTOR_KEY,
+    MIN_COLLATERAL_FACTOR_FOR_LIQUIDATION_KEY,
+    MIN_COLLATERAL_FACTOR_FOR_OPEN_INTEREST_MULTIPLIER_KEY,
+    MIN_COLLATERAL_FACTOR_KEY,
+    MIN_FUNDING_FACTOR_PER_SECOND,
+    MIN_POSITION_IMPACT_POOL_AMOUNT_KEY,
+    OPEN_INTEREST_IN_TOKENS_KEY,
+    OPEN_INTEREST_KEY,
+    OPEN_INTEREST_RESERVE_FACTOR_KEY,
+    POOL_AMOUNT_ADJUSTMENT_KEY,
+    POOL_AMOUNT_KEY,
+    POSITION_FEE_FACTOR_KEY,
+    POSITION_IMPACT_EXPONENT_FACTOR_KEY,
+    POSITION_IMPACT_FACTOR_KEY,
+    POSITION_IMPACT_POOL_AMOUNT_KEY,
+    POSITION_IMPACT_POOL_DISTRIBUTION_RATE_KEY,
+    RESERVE_FACTOR_KEY,
+    SWAP_FEE_FACTOR_KEY,
+    SWAP_IMPACT_EXPONENT_FACTOR_KEY,
+    SWAP_IMPACT_FACTOR_KEY,
+    SWAP_IMPACT_POOL_AMOUNT_KEY,
+    THRESHOLD_FOR_DECREASE_FUNDING,
+    THRESHOLD_FOR_STABLE_FUNDING,
+    VIRTUAL_MARKET_ID_KEY,
+    VIRTUAL_TOKEN_ID_KEY,
 } from "../configs/dataStore.js";
 import {MarketConfig} from "../configs/markets.js";
 
@@ -161,6 +167,14 @@ export function hashMarketConfigKeys(market: MarketConfig) {
       ["bytes32", "bytes32", "address", "bool"],
       [MAX_PNL_FACTOR_KEY, MAX_PNL_FACTOR_FOR_TRADERS_KEY, marketAddress, false],
     ],
+    positionFeeFactorForBalanceWasImproved: [
+      ["bytes32", "address", "bool"],
+      [POSITION_FEE_FACTOR_KEY, marketAddress, true],
+    ],
+    positionFeeFactorForBalanceWasNotImproved: [
+      ["bytes32", "address", "bool"],
+      [POSITION_FEE_FACTOR_KEY, marketAddress, false],
+    ],
     positionFeeFactorForPositiveImpact: [
       ["bytes32", "address", "bool"],
       [POSITION_FEE_FACTOR_KEY, marketAddress, true],
@@ -189,10 +203,30 @@ export function hashMarketConfigKeys(market: MarketConfig) {
       ["bytes32", "address"],
       [MAX_POSITION_IMPACT_FACTOR_FOR_LIQUIDATIONS_KEY, marketAddress],
     ],
+    maxLendableImpactFactor: [
+      ["bytes32", "address"],
+      [MAX_LENDABLE_IMPACT_FACTOR_KEY, marketAddress],
+    ],
+    maxLendableImpactFactorForWithdrawals: [
+      ["bytes32", "address"],
+      [MAX_LENDABLE_IMPACT_FACTOR_FOR_WITHDRAWALS_KEY, marketAddress],
+    ],
+    maxLendableImpactUsd: [
+      ["bytes32", "address"],
+      [MAX_LENDABLE_IMPACT_USD_KEY, marketAddress],
+    ],
+    lentPositionImpactPoolAmount: [
+      ["bytes32", "address"],
+      [LENT_POSITION_IMPACT_POOL_AMOUNT_KEY, marketAddress],
+    ],
     minCollateralFactor: [
       ["bytes32", "address"],
       [MIN_COLLATERAL_FACTOR_KEY, marketAddress],
     ],
+    minCollateralFactorForLiquidation: [
+      ["bytes32", "address"],
+      [MIN_COLLATERAL_FACTOR_FOR_LIQUIDATION_KEY, marketAddress],
+    ],
     minCollateralFactorForOpenInterestLong: [
       ["bytes32", "address", "bool"],
       [MIN_COLLATERAL_FACTOR_FOR_OPEN_INTEREST_MULTIPLIER_KEY, marketAddress, true],
@@ -205,6 +239,14 @@ export function hashMarketConfigKeys(market: MarketConfig) {
       ["bytes32", "address"],
       [POSITION_IMPACT_EXPONENT_FACTOR_KEY, marketAddress],
     ],
+    swapFeeFactorForBalanceWasImproved: [
+      ["bytes32", "address", "bool"],
+      [SWAP_FEE_FACTOR_KEY, marketAddress, true],
+    ],
+    swapFeeFactorForBalanceWasNotImproved: [
+      ["bytes32", "address", "bool"],
+      [SWAP_FEE_FACTOR_KEY, marketAddress, false],
+    ],
     swapFeeFactorForPositiveImpact: [
       ["bytes32", "address", "bool"],
       [SWAP_FEE_FACTOR_KEY, marketAddress, true],
@@ -213,6 +255,10 @@ export function hashMarketConfigKeys(market: MarketConfig) {
       ["bytes32", "address", "bool"],
       [SWAP_FEE_FACTOR_KEY, marketAddress, false],
     ],
+    atomicSwapFeeFactor: [
+      ["bytes32", "address"],
+      [ATOMIC_SWAP_FEE_FACTOR_KEY, marketAddress],
+    ],
     swapImpactFactorPositive: [
       ["bytes32", "address", "bool"],
       [SWAP_IMPACT_FACTOR_KEY, marketAddress, true],
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/markets.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/markets.ts
index 3d9d327c..be93a2d5 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/markets.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/markets.ts
@@ -15,6 +15,14 @@ export function getMarketFullName(p: { longToken: Token; shortToken: Token; inde
 }
 
 export function getMarketIndexName(p: ({ indexToken: Token } | { glvToken: Token }) & { isSpotOnly: boolean }) {
+  if (p.isSpotOnly) {
+    return `SWAP-ONLY`;
+  }
+
+  return `${getMarketBaseName(p)}/USD`;
+}
+
+export function getMarketBaseName(p: ({ indexToken: Token } | { glvToken: Token }) & { isSpotOnly: boolean }) {
   const { isSpotOnly } = p;
 
   const firstToken = "indexToken" in p ? p.indexToken : p.glvToken;
@@ -25,13 +33,13 @@ export function getMarketIndexName(p: ({ indexToken: Token } | { glvToken: Token
 
   const prefix = getTokenVisualMultiplier(firstToken);
 
-  return `${prefix}${firstToken.baseSymbol || firstToken.symbol}/USD`;
+  return `${prefix}${firstToken.baseSymbol || firstToken.symbol}`;
 }
 
-export function getMarketPoolName(p: { longToken: Token; shortToken: Token }) {
+export function getMarketPoolName(p: { longToken: Token; shortToken: Token }, separator = "-") {
   const { longToken, shortToken } = p;
 
-  return `${longToken.symbol}-${shortToken.symbol}`;
+  return `${longToken.symbol}${separator}${shortToken.symbol}`;
 }
 
 export function getContractMarketPrices(tokensData: TokensData, market: Market): ContractMarketPrices | undefined {
@@ -213,3 +221,9 @@ export function getPriceForPnl(prices: TokenPrices, isLong: boolean, maximize: b
 
   return maximize ? prices.minPrice : prices.maxPrice;
 }
+
+export function getIsMarketAvailableForExpressSwaps(marketInfo: MarketInfo) {
+  return [marketInfo.indexToken, marketInfo.longToken, marketInfo.shortToken].every(
+    (token) => token.hasPriceFeedProvider
+  );
+}
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/multicall.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/multicall.ts
index 01d09b14..752c2efb 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/multicall.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/multicall.ts
@@ -1,8 +1,8 @@
-import { AbiId, abis as allAbis } from "../abis/index.js";
-import { GmxSdk } from "../index.js";
-import { sleep } from "./common.js";
+import {AbiId, abis as allAbis} from "../abis/index.js";
+import {GmxSdk} from "../index.js";
+import {sleep} from "./common.js";
 
-export const MAX_TIMEOUT = 20000;
+export const MAX_TIMEOUT = 60000; // Increased from 20s to 60s
 
 export type MulticallProviderUrls = {
   primary: string;
@@ -33,13 +33,33 @@ export class Multicall {
     return this.sdk.chainId;
   }
 
-  async call(request: MulticallRequestConfig<any>, maxTimeout: number) {
+  async call(request: MulticallRequestConfig<any>, maxTimeout: number, retryCount: number = 0) {
     const client = this.sdk.publicClient;
 
     if (!client) {
       throw new Error("Public client is not initialized");
     }
 
+    const MAX_RETRIES = 3;
+    const BASE_DELAY = 1000; // 1 second base delay
+
+    try {
+      return await this.executeMulticallWithRetry(request, maxTimeout, retryCount, MAX_RETRIES, BASE_DELAY);
+    } catch (error) {
+      // If all retries failed, throw the error
+      throw error;
+    }
+  }
+
+  private async executeMulticallWithRetry(
+    request: MulticallRequestConfig<any>, 
+    maxTimeout: number, 
+    retryCount: number, 
+    maxRetries: number, 
+    baseDelay: number
+  ) {
+    const client = this.sdk.publicClient;
+
     const originalKeys: {
       contractKey: string;
       callKey: string;
@@ -47,7 +67,7 @@ export class Multicall {
 
     const abis: any = {};
 
-    const encodedPayload: { address: string; abi: any; functionName: string; args: any }[] = [];
+    const encodedPayload: { address: `0x${string}`; abi: any; functionName: string; args: any }[] = [];
 
     const contractKeys = Object.keys(request);
 
@@ -78,7 +98,7 @@ export class Multicall {
         });
 
         encodedPayload.push({
-          address: contractCallConfig.contractAddress,
+          address: contractCallConfig.contractAddress as `0x${string}`,
           functionName: call.methodName,
           args: call.params,
           abi,
@@ -93,7 +113,7 @@ export class Multicall {
         data: {},
       };
 
-      response.forEach(({ result, status, error }, i) => {
+      response.forEach(({ result, status, error }: { result: any; status: string; error: any }, i: number) => {
         const { contractKey, callKey } = originalKeys[i];
 
         if (status === "success") {
@@ -134,33 +154,65 @@ export class Multicall {
 
     const timeoutController = new AbortController();
 
-    const result = await Promise.race([
-      // @ts-ignore
-      client.multicall({ contracts: encodedPayload as any }),
-      sleep(maxTimeout, timeoutController.signal).then(() => Promise.reject(new Error("multicall timeout"))),
-    ])
-      .then((response) => {
-        timeoutController.abort();
-        return processResponse(response);
-      })
-      .catch((_viemError) => {
-        timeoutController.abort();
-        const e = new Error(_viemError.message.slice(0, 150));
+    const multicallPromise = (client.multicall as any)({ contracts: encodedPayload });
+    const timeoutPromise = sleep(maxTimeout, timeoutController.signal).then(() => Promise.reject(new Error("multicall timeout")));
+    
+    try {
+      const result = await Promise.race([multicallPromise, timeoutPromise])
+        .then((response) => {
+          timeoutController.abort();
+          return processResponse(response);
+        });
 
-        /* eslint-disable-next-line */
-        console.error(e);
+      if (result.success) {
+        return result;
+      }
 
-        throw e;
-      });
+      /* eslint-disable-next-line */
+      console.error(result.errors);
 
-    if (result.success) {
       return result;
+    } catch (error) {
+      timeoutController.abort();
+      
+      // Better error handling to distinguish between different types of errors
+      let errorMessage = error.message || 'Unknown multicall error';
+      let shouldRetry = false;
+      
+      if (errorMessage.includes('timeout') || errorMessage.includes('TIMEOUT')) {
+        errorMessage = 'multicall timeout';
+        shouldRetry = true;
+      } else if (errorMessage.includes('RPC') || errorMessage.includes('rpc')) {
+        errorMessage = 'RPC error: ' + errorMessage;
+        shouldRetry = true;
+      } else if (errorMessage.includes('network') || errorMessage.includes('NETWORK')) {
+        errorMessage = 'Network error: ' + errorMessage;
+        shouldRetry = true;
+      } else if (errorMessage.includes('rate limit') || errorMessage.includes('RATE_LIMIT')) {
+        errorMessage = 'Rate limit error: ' + errorMessage;
+        shouldRetry = true;
+      } else {
+        errorMessage = 'Multicall error: ' + errorMessage.slice(0, 150);
+        shouldRetry = false; // Don't retry for other types of errors
+      }
+
+      // If we should retry and haven't exceeded max retries, retry with exponential backoff
+      if (shouldRetry && retryCount < maxRetries) {
+        const delay = baseDelay * Math.pow(2, retryCount); // Exponential backoff
+        console.log(`Multicall failed (attempt ${retryCount + 1}/${maxRetries + 1}), retrying in ${delay}ms: ${errorMessage}`);
+        
+        await sleep(delay);
+        return this.executeMulticallWithRetry(request, maxTimeout, retryCount + 1, maxRetries, baseDelay);
+      }
+
+      const e = new Error(errorMessage);
+      e.name = 'MulticallError';
+
+      /* eslint-disable-next-line */
+      console.error('Multicall failed after all retries:', e.message);
+
+      throw e;
     }
-
-    /* eslint-disable-next-line */
-    console.error(result.errors);
-
-    return result;
   }
 }
 
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/numbers.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/numbers.ts
index aa8a6471..7c307dc6 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/numbers.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/numbers.ts
@@ -1,13 +1,33 @@
-import {BASIS_POINTS_DIVISOR_BIGINT} from "../configs/factors.js";
+import {formatUnits, parseUnits} from "viem/utils";
+import {bigMath} from "./bigmath.js";
+
+export type Numeric = number | bigint;
+export type BigNumberish = string | Numeric;
+
+export const USD_DECIMALS = 30;
+
+export const BASIS_POINTS_DIVISOR = 10000;
+export const BASIS_POINTS_DIVISOR_BIGINT = 10000n;
+export const BASIS_POINTS_DECIMALS = 4;
 
-export const PRECISION = expandDecimals(1, 30);
 export const PRECISION_DECIMALS = 30;
+export const PRECISION = expandDecimals(1, PRECISION_DECIMALS);
 
 export const BN_ZERO = 0n;
 export const BN_ONE = 1n;
 export const BN_NEGATIVE_ONE = -1n;
 
-export function expandDecimals(n: bigint | number, decimals: number): bigint {
+export const MaxUint256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+
+export const PERCENT_PRECISION_DECIMALS = PRECISION_DECIMALS - 2;
+
+const MAX_EXCEEDING_THRESHOLD = "1000000000";
+const MIN_EXCEEDING_THRESHOLD = "0.01";
+
+export const TRIGGER_PREFIX_ABOVE = ">";
+export const TRIGGER_PREFIX_BELOW = "<";
+
+export function expandDecimals(n: BigNumberish, decimals: number): bigint {
   return BigInt(n) * 10n ** BigInt(decimals);
 }
 
@@ -62,6 +82,13 @@ export function numberToBigint(value: number, decimals: number) {
   return negative ? -res : res;
 }
 
+export const trimZeroDecimals = (amount: string) => {
+  if (parseFloat(amount) === parseInt(amount)) {
+    return parseInt(amount).toString();
+  }
+  return amount;
+};
+
 export function bigintToNumber(value: bigint, decimals: number) {
   const negative = value < 0;
   if (negative) value *= -1n;
@@ -76,3 +103,702 @@ export function bigintToNumber(value: bigint, decimals: number) {
 export function adjustForDecimals(amount: bigint, divDecimals: number, mulDecimals: number) {
   return (amount * expandDecimals(1, mulDecimals)) / expandDecimals(1, divDecimals);
 }
+
+export function formatUsd(
+  usd?: bigint,
+  opts: {
+    fallbackToZero?: boolean;
+    displayDecimals?: number;
+    maxThreshold?: string | null;
+    minThreshold?: string;
+    displayPlus?: boolean;
+    visualMultiplier?: number;
+  } = {}
+) {
+  const { fallbackToZero = false, displayDecimals = 2 } = opts;
+
+  if (typeof usd !== "bigint") {
+    if (fallbackToZero) {
+      usd = 0n;
+    } else {
+      return undefined;
+    }
+  }
+
+  if (opts.visualMultiplier) {
+    usd *= BigInt(opts.visualMultiplier);
+  }
+
+  const defaultMinThreshold = displayDecimals > 1 ? "0." + "0".repeat(displayDecimals - 1) + "1" : undefined;
+
+  const exceedingInfo = getLimitedDisplay(usd, USD_DECIMALS, {
+    maxThreshold: opts.maxThreshold,
+    minThreshold: opts.minThreshold ?? defaultMinThreshold,
+  });
+
+  const maybePlus = opts.displayPlus ? "+" : "";
+  const sign = usd < 0n ? "-" : maybePlus;
+  const symbol = exceedingInfo.symbol ? `${exceedingInfo.symbol} ` : "";
+  const displayUsd = formatAmount(exceedingInfo.value, USD_DECIMALS, displayDecimals, true);
+  return `${symbol}${sign}$\u200a${displayUsd}`;
+}
+
+export function formatDeltaUsd(
+  deltaUsd?: bigint,
+  percentage?: bigint,
+  opts: { fallbackToZero?: boolean; showPlusForZero?: boolean } = {}
+) {
+  if (typeof deltaUsd !== "bigint") {
+    if (opts.fallbackToZero) {
+      return `${formatUsd(0n)} (${formatAmount(0n, 2, 2)}%)`;
+    }
+
+    return undefined;
+  }
+
+  const sign = getPlusOrMinusSymbol(deltaUsd, { showPlusForZero: opts.showPlusForZero });
+
+  const exceedingInfo = getLimitedDisplay(deltaUsd, USD_DECIMALS);
+  const percentageStr = percentage !== undefined ? ` (${sign}${formatPercentage(bigMath.abs(percentage))})` : "";
+  const deltaUsdStr = formatAmount(exceedingInfo.value, USD_DECIMALS, 2, true);
+  const symbol = exceedingInfo.symbol ? `${exceedingInfo.symbol} ` : "";
+
+  return `${symbol}${sign}$\u200a${deltaUsdStr}${percentageStr}`;
+}
+
+export function formatPercentage(
+  percentage?: bigint,
+  opts: { fallbackToZero?: boolean; signed?: boolean; displayDecimals?: number; bps?: boolean } = {}
+) {
+  const { fallbackToZero = false, signed = false, displayDecimals = 2, bps = true } = opts;
+
+  if (percentage === undefined) {
+    if (fallbackToZero) {
+      return `${formatAmount(0n, PERCENT_PRECISION_DECIMALS, displayDecimals)}%`;
+    }
+
+    return undefined;
+  }
+
+  const sign = signed ? `${getPlusOrMinusSymbol(percentage)}\u200a` : "";
+
+  return `${sign}${formatAmount(bigMath.abs(percentage), bps ? 2 : PERCENT_PRECISION_DECIMALS, displayDecimals)}%`;
+}
+
+export function formatTokenAmount(
+  amount?: bigint,
+  tokenDecimals?: number,
+  symbol?: string,
+  opts: {
+    showAllSignificant?: boolean;
+    displayDecimals?: number;
+    fallbackToZero?: boolean;
+    useCommas?: boolean;
+    minThreshold?: string;
+    maxThreshold?: string;
+    displayPlus?: boolean;
+    isStable?: boolean;
+  } = {}
+) {
+  const {
+    showAllSignificant = false,
+    fallbackToZero = false,
+    useCommas = false,
+    minThreshold = "0",
+    maxThreshold,
+  } = opts;
+
+  const displayDecimals = opts.displayDecimals ?? (opts.isStable ? 2 : 4);
+
+  const symbolStr = symbol ? ` ${symbol}` : "";
+
+  if (typeof amount !== "bigint" || !tokenDecimals) {
+    if (fallbackToZero) {
+      amount = 0n;
+      tokenDecimals = displayDecimals;
+    } else {
+      return undefined;
+    }
+  }
+
+  let amountStr: string;
+
+  const maybePlus = opts.displayPlus ? "+" : "";
+  const sign = amount < 0n ? "-" : maybePlus;
+
+  if (showAllSignificant) {
+    amountStr = formatAmountFree(amount, tokenDecimals, tokenDecimals);
+  } else {
+    const exceedingInfo = getLimitedDisplay(amount, tokenDecimals, { maxThreshold, minThreshold });
+    const symbol = exceedingInfo.symbol ? `${exceedingInfo.symbol} ` : "";
+    amountStr = `${symbol}${sign}${formatAmount(exceedingInfo.value, tokenDecimals, displayDecimals, useCommas, undefined)}`;
+  }
+
+  return `${amountStr}${symbolStr}`;
+}
+
+export function formatTokenAmountWithUsd(
+  tokenAmount?: bigint,
+  usdAmount?: bigint,
+  tokenSymbol?: string,
+  tokenDecimals?: number,
+  opts: {
+    fallbackToZero?: boolean;
+    displayDecimals?: number;
+    displayPlus?: boolean;
+    isStable?: boolean;
+  } = {}
+) {
+  if (typeof tokenAmount !== "bigint" || typeof usdAmount !== "bigint" || !tokenSymbol || !tokenDecimals) {
+    if (!opts.fallbackToZero) {
+      return undefined;
+    }
+  }
+
+  const tokenStr = formatTokenAmount(tokenAmount, tokenDecimals, tokenSymbol, {
+    ...opts,
+    useCommas: true,
+    displayPlus: opts.displayPlus,
+  });
+
+  const usdStr = formatUsd(usdAmount, {
+    fallbackToZero: opts.fallbackToZero,
+    displayPlus: opts.displayPlus,
+  });
+
+  return `${tokenStr} (${usdStr})`;
+}
+
+/**
+ *
+ * @param opts.signed - Default `true`. whether to display a `+` or `-` sign for all non-zero values.
+ */
+export function formatRatePercentage(rate?: bigint, opts?: { displayDecimals?: number; signed?: boolean }) {
+  if (typeof rate !== "bigint") {
+    return "-";
+  }
+
+  const signed = opts?.signed ?? true;
+  const plurOrMinus = signed ? getPlusOrMinusSymbol(rate) : "";
+
+  const amount = bigMath.abs(rate * 100n);
+  return `${plurOrMinus}\u200a${formatAmount(amount, 30, opts?.displayDecimals ?? 4)}%`;
+}
+
+export function formatUsdPrice(price?: bigint, opts: Parameters<typeof formatUsd>[1] = {}) {
+  if (price === undefined) {
+    return;
+  }
+
+  if (price < 0n) {
+    return "NA";
+  }
+
+  const decimals = calculateDisplayDecimals(price, undefined, opts.visualMultiplier);
+
+  return formatUsd(price, {
+    ...opts,
+    displayDecimals: decimals,
+  });
+}
+
+export function formatPercentageDisplay(percentage: number, hideThreshold?: number) {
+  if (hideThreshold && percentage < hideThreshold) {
+    return "";
+  }
+
+  return `${percentage}%`;
+}
+
+export function formatAmountHuman(
+  amount: BigNumberish | undefined,
+  tokenDecimals: number,
+  showDollar = false,
+  displayDecimals = 1
+) {
+  if (amount === undefined) {
+    return "...";
+  }
+
+  let n = Number(formatAmount(amount, tokenDecimals));
+  // For large numbers, we can neglect the decimals to avoid decimals in cases like 9999999.99999
+  if (n >= 1_000_000) {
+    n = Math.round(n);
+  }
+  const isNegative = n < 0;
+  const absN = Math.abs(n);
+  const sign = showDollar ? "$\u200a" : "";
+
+  if (absN >= 1_000_000_000) {
+    return `${isNegative ? "-" : ""}${sign}${(absN / 1_000_000_000).toFixed(displayDecimals)}b`;
+  }
+
+  if (absN >= 1_000_000) {
+    return `${isNegative ? "-" : ""}${sign}${(absN / 1_000_000).toFixed(displayDecimals)}m`;
+  }
+
+  if (absN >= 1000) {
+    return `${isNegative ? "-" : ""}${sign}${(absN / 1_000).toFixed(displayDecimals)}k`;
+  }
+
+  return `${isNegative ? "-" : ""}${sign}${absN.toFixed(displayDecimals)}`;
+}
+
+export function formatBalanceAmount(
+  amount: bigint,
+  tokenDecimals: number,
+  tokenSymbol?: string,
+  {
+    showZero = false,
+    toExponential = true,
+    isStable = false,
+    signed = false,
+  }: {
+    showZero?: boolean;
+    toExponential?: boolean;
+    isStable?: boolean;
+    signed?: boolean;
+  } = {}
+): string {
+  if (amount === undefined) return "-";
+
+  if (amount === 0n) {
+    if (showZero === true) {
+      if (tokenSymbol) {
+        if (isStable) {
+          return `0.00 ${tokenSymbol}`;
+        }
+        return `0.0000 ${tokenSymbol}`;
+      }
+      if (isStable) {
+        return "0.00";
+      }
+      return "0.0000";
+    }
+
+    return "-";
+  }
+
+  const sign = signed || amount < 0n ? getPlusOrMinusSymbol(amount) : "";
+  const absAmount = bigMath.abs(amount);
+  const absAmountFloat = bigintToNumber(absAmount, tokenDecimals);
+
+  let value = "";
+
+  const baseDecimals = isStable ? 2 : 4;
+  if (absAmountFloat >= 1) value = formatAmount(absAmount, tokenDecimals, baseDecimals, true);
+  else if (absAmountFloat >= 0.1) value = formatAmount(absAmount, tokenDecimals, baseDecimals + 1, true);
+  else if (absAmountFloat >= 0.01) value = formatAmount(absAmount, tokenDecimals, baseDecimals + 2, true);
+  else if (absAmountFloat >= 0.001) value = formatAmount(absAmount, tokenDecimals, baseDecimals + 3, true);
+  else if (absAmountFloat >= 1e-8) value = formatAmount(absAmount, tokenDecimals, 8, true);
+  else {
+    if (toExponential) {
+      value = bigintToNumber(absAmount, tokenDecimals).toExponential(2);
+    } else {
+      value = bigintToNumber(absAmount, tokenDecimals).toFixed(8);
+    }
+  }
+
+  if (tokenSymbol) {
+    // Non-breaking space
+    return `${sign}${value} ${tokenSymbol}`;
+  }
+
+  return `${sign}${value}`;
+}
+
+export function formatFactor(factor: bigint) {
+  if (factor == 0n) {
+    return "0";
+  }
+
+  if (bigMath.abs(factor) > PRECISION * 1000n) {
+    return (factor / PRECISION).toString();
+  }
+
+  const trailingZeroes =
+    bigMath
+      .abs(factor)
+      .toString()
+      .match(/^(.+?)(?<zeroes>0*)$/)?.groups?.zeroes?.length || 0;
+  const factorDecimals = 30 - trailingZeroes;
+  return formatAmount(factor, 30, factorDecimals);
+}
+export function numberWithCommas(x: BigNumberish, { showDollar = false }: { showDollar?: boolean } = {}) {
+  if (x === undefined || x === null) {
+    return "...";
+  }
+
+  const parts = x.toString().split(".");
+  parts[0] = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  return `${showDollar ? "$\u200a" : ""}${parts.join(".")}`;
+}
+
+export const formatAmount = (
+  amount: BigNumberish | undefined,
+  tokenDecimals: number,
+  displayDecimals?: number,
+  useCommas?: boolean,
+  defaultValue?: string,
+  visualMultiplier?: number
+) => {
+  if (defaultValue === undefined || defaultValue === null) {
+    defaultValue = "...";
+  }
+  if (amount === undefined || amount === null || amount === "") {
+    return defaultValue;
+  }
+  if (displayDecimals === undefined) {
+    displayDecimals = 4;
+  }
+  const amountBigInt = roundWithDecimals(BigInt(amount) * BigInt(visualMultiplier ?? 1), {
+    displayDecimals,
+    decimals: tokenDecimals,
+  });
+  let amountStr = formatUnits(amountBigInt, tokenDecimals);
+  amountStr = limitDecimals(amountStr, displayDecimals);
+  if (displayDecimals !== 0) {
+    amountStr = padDecimals(amountStr, displayDecimals);
+  }
+  if (useCommas) {
+    return numberWithCommas(amountStr);
+  }
+  return amountStr;
+};
+
+export const formatKeyAmount = <T extends {}>(
+  map: T | undefined,
+  key: keyof T,
+  tokenDecimals: number,
+  displayDecimals: number,
+  useCommas?: boolean
+) => {
+  const value = map ? map[key] ?? undefined : undefined;
+  if (value === undefined || value === null) {
+    return "...";
+  }
+
+  return formatAmount(value as bigint, tokenDecimals, displayDecimals, useCommas);
+};
+
+export const formatArrayAmount = (
+  arr: any[],
+  index: number,
+  tokenDecimals: number,
+  displayDecimals?: number,
+  useCommas?: boolean
+) => {
+  if (!arr || arr[index] === undefined || arr[index] === null) {
+    return "...";
+  }
+
+  return formatAmount(arr[index], tokenDecimals, displayDecimals, useCommas);
+};
+
+export const formatAmountFree = (amount: BigNumberish, tokenDecimals: number, displayDecimals?: number) => {
+  if (amount === undefined || amount === null) {
+    return "...";
+  }
+
+  amount = BigInt(amount);
+
+  let amountStr = formatUnits(amount, tokenDecimals);
+  amountStr = limitDecimals(amountStr, displayDecimals);
+  return trimZeroDecimals(amountStr);
+};
+
+export function getLimitedDisplay(
+  amount: bigint,
+  tokenDecimals: number,
+  opts: { maxThreshold?: BigNumberish | null; minThreshold?: BigNumberish } = {}
+) {
+  const { maxThreshold = MAX_EXCEEDING_THRESHOLD, minThreshold = MIN_EXCEEDING_THRESHOLD } = opts;
+  const max = maxThreshold === null ? null : expandDecimals(BigInt(maxThreshold), tokenDecimals);
+  const min = parseUnits(minThreshold.toString(), tokenDecimals);
+  const absAmount = bigMath.abs(amount);
+
+  if (absAmount == 0n) {
+    return {
+      symbol: "",
+      value: absAmount,
+    };
+  }
+
+  const symbol = max !== null && absAmount > max ? TRIGGER_PREFIX_ABOVE : absAmount < min ? TRIGGER_PREFIX_BELOW : "";
+  const value = max !== null && absAmount > max ? max : absAmount < min ? min : absAmount;
+
+  return {
+    symbol,
+    value,
+  };
+}
+
+export const limitDecimals = (amount: BigNumberish, maxDecimals?: number) => {
+  let amountStr = amount.toString();
+  if (maxDecimals === undefined) {
+    return amountStr;
+  }
+  if (maxDecimals === 0) {
+    return amountStr.split(".")[0];
+  }
+  const dotIndex = amountStr.indexOf(".");
+  if (dotIndex !== -1) {
+    let decimals = amountStr.length - dotIndex - 1;
+    if (decimals > maxDecimals) {
+      amountStr = amountStr.substr(0, amountStr.length - (decimals - maxDecimals));
+    }
+  }
+
+  return amountStr;
+};
+
+export const padDecimals = (amount: BigNumberish, minDecimals: number) => {
+  let amountStr = amount.toString();
+  const dotIndex = amountStr.indexOf(".");
+  if (dotIndex !== -1) {
+    const decimals = amountStr.length - dotIndex - 1;
+    if (decimals < minDecimals) {
+      amountStr = amountStr.padEnd(amountStr.length + (minDecimals - decimals), "0");
+    }
+  } else {
+    amountStr = amountStr + "." + "0".repeat(minDecimals);
+  }
+  return amountStr;
+};
+
+export function getPlusOrMinusSymbol(value?: bigint, opts: { showPlusForZero?: boolean } = {}): string {
+  if (value === undefined) {
+    return "";
+  }
+
+  const { showPlusForZero = false } = opts;
+  return value === 0n ? (showPlusForZero ? "+" : "") : value < 0n ? "-" : "+";
+}
+
+export function roundWithDecimals(value: BigNumberish, opts: { displayDecimals: number; decimals: number }): bigint {
+  if (opts.displayDecimals === opts.decimals) {
+    return BigInt(value);
+  }
+
+  let valueString = value.toString();
+  let isNegative = false;
+
+  if (valueString[0] === "-") {
+    valueString = valueString.slice(1);
+    isNegative = true;
+  }
+
+  if (valueString.length < opts.decimals) {
+    valueString = valueString.padStart(opts.decimals, "0");
+  }
+
+  const mainPart = valueString.slice(0, valueString.length - opts.decimals + opts.displayDecimals);
+  const partToRound = valueString.slice(valueString.length - opts.decimals + opts.displayDecimals);
+
+  let mainPartBigInt = BigInt(mainPart);
+
+  let returnValue = mainPartBigInt;
+
+  if (partToRound.length !== 0) {
+    if (Number(partToRound[0]) >= 5) {
+      mainPartBigInt += 1n;
+    }
+
+    returnValue = BigInt(mainPartBigInt.toString() + new Array(partToRound.length).fill("0").join(""));
+  }
+
+  return isNegative ? returnValue * -1n : returnValue;
+}
+
+// TODO: Remove this function
+export function toBigNumberWithDecimals(value: string, decimals: number): bigint {
+  if (!value) return BN_ZERO;
+
+  const parts = value.split(".");
+  const integerPart = parts[0];
+  const decimalPart = parts.length > 1 ? parts[1] : "";
+
+  const paddingZeros = decimals - decimalPart.length;
+
+  if (paddingZeros >= 0) {
+    const result = integerPart + decimalPart + "0".repeat(paddingZeros);
+    return BigInt(result);
+  } else {
+    const result = integerPart + decimalPart.substring(0, decimals);
+    return BigInt(result);
+  }
+}
+
+/**
+ *
+ * @deprecated Use BigInt instead
+ */
+export function bigNumberify(n?: BigNumberish | null | undefined) {
+  try {
+    if (n === undefined) throw new Error("n is undefined");
+    if (n === null) throw new Error("n is null");
+
+    return BigInt(n);
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.error("bigNumberify error", e);
+    return undefined;
+  }
+}
+
+export const parseValue = (value: string, tokenDecimals: number) => {
+  const pValue = parseFloat(value);
+
+  if (isNaN(pValue)) {
+    return undefined;
+  }
+  value = limitDecimals(value, tokenDecimals);
+  const amount = parseUnits(value, tokenDecimals);
+  return bigNumberify(amount);
+};
+
+export function roundUpDivision(a: bigint, b: bigint) {
+  return (a + b - 1n) / b;
+}
+
+export function roundToTwoDecimals(n: number) {
+  return Math.round(n * 100) / 100;
+}
+
+export function roundToOrder(n: bigint, significantDigits = 1) {
+  const decimals = Math.max(n.toString().length - significantDigits, 0);
+  return (n / expandDecimals(1, decimals)) * expandDecimals(1, decimals);
+}
+
+export function roundBigIntToDecimals(value: bigint, tokenDecimals: number, roundToDecimals: number): bigint {
+  const excessDecimals = tokenDecimals - roundToDecimals;
+  const divisor = BigInt(10 ** excessDecimals);
+  const scaledValue = value / divisor;
+  const remainder = scaledValue % 10n;
+  const roundedValue = remainder >= 5n ? scaledValue + 10n - remainder : scaledValue - remainder;
+  return roundedValue * divisor;
+}
+
+export function minBigNumber(...args: bigint[]) {
+  if (!args.length) return undefined;
+
+  return args.reduce((acc, num) => (num < acc ? num : acc), args[0]);
+}
+
+export function maxbigint(...args: bigint[]) {
+  if (!args.length) return undefined;
+
+  return args.reduce((acc, num) => (num > acc ? num : acc), args[0]);
+}
+
+export function removeTrailingZeros(amount: string | number) {
+  const amountWithoutZeros = Number(amount);
+  if (!amountWithoutZeros) return amount;
+  return amountWithoutZeros;
+}
+
+type SerializedBigIntsInObject<T> = {
+  [P in keyof T]: T[P] extends bigint
+    ? { type: "bigint"; value: bigint }
+    : T[P] extends object
+      ? SerializedBigIntsInObject<T[P]>
+      : T[P];
+};
+
+type DeserializeBigIntInObject<T> = {
+  [P in keyof T]: T[P] extends { type: "bigint"; value: bigint }
+    ? bigint
+    : T[P] extends object
+      ? DeserializeBigIntInObject<T[P]>
+      : T[P];
+};
+
+export function serializeBigIntsInObject<T extends object>(obj: T): SerializedBigIntsInObject<T> {
+  const result: any = Array.isArray(obj) ? [] : {};
+  for (const key in obj) {
+    const value = obj[key];
+    if (typeof value === "bigint") {
+      result[key] = { type: "bigint", value: String(value) };
+    } else if (value && typeof value === "object") {
+      result[key] = serializeBigIntsInObject(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+export function deserializeBigIntsInObject<T extends object>(obj: T): DeserializeBigIntInObject<T> {
+  const result: any = Array.isArray(obj) ? [] : {};
+  for (const key in obj) {
+    const value = obj[key];
+    if (
+      typeof value === "object" &&
+      value !== null &&
+      (("type" in value && value.type === "bigint") || ("_type" in value && value._type === "BigNumber"))
+    ) {
+      if ("value" in value && typeof value.value === "string") {
+        result[key] = BigInt(value.value);
+      } else if ("hex" in value && typeof value.hex === "string") {
+        if (value.hex.startsWith("-")) {
+          result[key] = BigInt(value.hex.slice(1)) * -1n;
+        } else {
+          result[key] = BigInt(value.hex);
+        }
+      }
+    } else if (value && typeof value === "object") {
+      result[key] = deserializeBigIntsInObject(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+export function calculateDisplayDecimals(
+  price?: bigint,
+  decimals = USD_DECIMALS,
+  visualMultiplier = 1,
+  isStable = false
+) {
+  if (price === undefined || price === 0n) return 2;
+  const priceNumber = bigintToNumber(bigMath.abs(price) * BigInt(visualMultiplier), decimals);
+
+  if (isNaN(priceNumber)) return 2;
+  if (isStable) {
+    if (priceNumber >= 0.1) return 2;
+    if (priceNumber >= 0.01) return 3;
+    if (priceNumber >= 0.001) return 4;
+    if (priceNumber >= 0.0001) return 5;
+    if (priceNumber >= 0.00001) return 6;
+    if (priceNumber >= 0.000001) return 7;
+    if (priceNumber >= 0.0000001) return 8;
+    if (priceNumber >= 0.00000001) return 9;
+  } else {
+    if (priceNumber >= 1000) return 2;
+    if (priceNumber >= 100) return 3;
+    if (priceNumber >= 1) return 4;
+    if (priceNumber >= 0.1) return 5;
+    if (priceNumber >= 0.01) return 6;
+    if (priceNumber >= 0.0001) return 7;
+    if (priceNumber >= 0.00001) return 8;
+  }
+
+  return 9;
+}
+
+export function clamp(value: number, min: number, max: number): number {
+  return Math.max(min, Math.min(value, max));
+}
+
+export function absDiffBps(value: bigint, base: bigint) {
+  if ((value === 0n && base !== 0n) || (value !== 0n && base === 0n)) {
+    return BASIS_POINTS_DIVISOR_BIGINT;
+  }
+
+  if (value === 0n && base === 0n) {
+    return 0n;
+  }
+
+  return bigMath.mulDiv(bigMath.abs(value - base), BASIS_POINTS_DIVISOR_BIGINT, base);
+}
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/objects.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/objects.ts
index c513f733..50a3693b 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/objects.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/objects.ts
@@ -1,3 +1,5 @@
+import isPlainObject from "lodash/isPlainObject.js";
+
 export function setByKey<T>(obj: { [key: string]: T }, key: string, data: T) {
   return { ...obj, [key]: data };
 }
@@ -19,3 +21,30 @@ export function deleteByKey<T>(obj: { [key: string]: T }, key: string) {
   delete newObj[key];
   return newObj;
 }
+
+export function objectKeysDeep(obj: Record<string, any>, depth = 1): string[] {
+  const keys = new Set<string>();
+
+  const scanQueue: {
+    obj: Record<string, any>;
+    currentDepth: number;
+  }[] = [{ obj, currentDepth: 0 }];
+
+  while (scanQueue.length > 0) {
+    const { obj, currentDepth } = scanQueue.pop()!;
+
+    if (currentDepth > depth) {
+      continue;
+    }
+
+    for (const key of Object.keys(obj)) {
+      keys.add(key);
+
+      if (isPlainObject(obj[key])) {
+        scanQueue.push({ obj: obj[key], currentDepth: currentDepth + 1 });
+      }
+    }
+  }
+
+  return Array.from(keys);
+}
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/orders.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/orders.ts
index 0c9ca886..8bf88852 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/orders.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/orders.ts
@@ -6,7 +6,7 @@ import {bigMath} from "./bigmath.js";
 import {getByKey} from "./objects.js";
 import {parsePositionKey} from "./positions.js";
 import {getOrderThresholdType} from "./prices.js";
-import { getSwapPathOutputAddresses, getSwapPathStats } from "./swap/index.js";
+import {getSwapPathOutputAddresses, getSwapPathStats} from "./swap/index.js";
 import {
     convertToTokenAmount,
     convertToUsd,
@@ -100,6 +100,7 @@ export function getOrderInfo(p: {
       )!,
       shouldUnwrapNativeToken: order.shouldUnwrapNativeToken,
       shouldApplyPriceImpact: true,
+      isAtomicSwap: false,
     });
 
     const priceImpactAmount = convertToTokenAmount(
@@ -114,7 +115,7 @@ export function getOrderInfo(p: {
       targetCollateralToken.prices.minPrice
     );
 
-    let toAmount;
+    let toAmount = order.minOutputAmount;
     let triggerRatio;
 
     const isLimitSwapOrder = isLimitSwapOrderType(order.orderType);
@@ -153,6 +154,8 @@ export function getOrderInfo(p: {
       triggerRatio,
       initialCollateralToken,
       targetCollateralToken,
+      isSwap: true,
+      isTwap: false,
     };
 
     return orderInfo;
@@ -191,9 +194,13 @@ export function getOrderInfo(p: {
       )!,
       shouldUnwrapNativeToken: order.shouldUnwrapNativeToken,
       shouldApplyPriceImpact: true,
+      isAtomicSwap: false,
     });
 
-    const triggerThresholdType = getOrderThresholdType(order.orderType, order.isLong);
+    let triggerThresholdType;
+    if (!isMarketOrderType(order.orderType)) {
+      triggerThresholdType = getOrderThresholdType(order.orderType, order.isLong);
+    }
 
     const orderInfo: PositionOrderInfo = {
       ...order,
@@ -205,6 +212,8 @@ export function getOrderInfo(p: {
       acceptablePrice,
       triggerPrice,
       triggerThresholdType,
+      isSwap: false,
+      isTwap: false,
     };
 
     return orderInfo;
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/positions.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/positions.ts
index aabf0ede..5ae4e700 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/positions.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/positions.ts
@@ -1,13 +1,20 @@
 import {bigMath} from "./bigmath.js";
-import {applyFactor, expandDecimals} from "./numbers.js";
-import {getCappedPoolPnl, getMarketPnl, getPoolUsdWithoutPnl} from "./markets.js";
+import {applyFactor, expandDecimals, PRECISION} from "./numbers.js";
+import {getCappedPoolPnl, getMarketPnl, getOpenInterestUsd, getPoolUsdWithoutPnl} from "./markets.js";
 import {convertToUsd, getIsEquivalentTokens} from "./tokens.js";
 import {BASIS_POINTS_DIVISOR_BIGINT} from "../configs/factors.js";
 import {Token, TokenData} from "../types/tokens.js";
 import {UserReferralInfo} from "../types/referrals.js";
 import {MarketInfo} from "../types/markets.js";
-import {getPriceImpactForPosition} from "./fees/priceImpact.js";
+import {
+    capPositionImpactUsdByMaxImpactPool,
+    capPositionImpactUsdByMaxPriceImpactFactor,
+    getMaxPositionImpactFactors,
+    getPriceImpactForPosition,
+    getProportionalPendingImpactValues
+} from "./fees/priceImpact.js";
 import {getPositionFee} from "./fees/index.js";
+import {PositionInfoLoaded} from "../types/positions.js";
 
 export function getPositionKey(account: string, marketAddress: string, collateralAddress: string, isLong: boolean) {
   return `${account}:${marketAddress}:${collateralAddress}:${isLong}`;
@@ -78,6 +85,8 @@ export function getPositionPendingFeesUsd(p: { pendingFundingFeesUsd: bigint; pe
 }
 
 export function getPositionNetValue(p: {
+  totalPendingImpactDeltaUsd: bigint;
+  priceImpactDiffUsd: bigint;
   collateralUsd: bigint;
   pendingFundingFeesUsd: bigint;
   pendingBorrowingFeesUsd: bigint;
@@ -85,11 +94,42 @@ export function getPositionNetValue(p: {
   closingFeeUsd: bigint;
   uiFeeUsd: bigint;
 }) {
-  const { pnl, closingFeeUsd, collateralUsd, uiFeeUsd } = p;
+  const { pnl, closingFeeUsd, collateralUsd, uiFeeUsd, totalPendingImpactDeltaUsd, priceImpactDiffUsd } = p;
 
   const pendingFeesUsd = getPositionPendingFeesUsd(p);
 
-  return collateralUsd - pendingFeesUsd - closingFeeUsd - uiFeeUsd + pnl;
+  return (
+    collateralUsd - pendingFeesUsd - closingFeeUsd - uiFeeUsd + pnl + totalPendingImpactDeltaUsd + priceImpactDiffUsd
+  );
+}
+
+export function getPositionPnlAfterFees({
+  pnl,
+  pendingBorrowingFeesUsd,
+  pendingFundingFeesUsd,
+  closingFeeUsd,
+  uiFeeUsd,
+  totalPendingImpactDeltaUsd,
+  priceImpactDiffUsd,
+}: {
+  pnl: bigint;
+  pendingBorrowingFeesUsd: bigint;
+  pendingFundingFeesUsd: bigint;
+  closingFeeUsd: bigint;
+  uiFeeUsd: bigint;
+  totalPendingImpactDeltaUsd: bigint;
+  priceImpactDiffUsd: bigint;
+}) {
+  const pnlAfterFees =
+    pnl -
+    pendingBorrowingFeesUsd -
+    pendingFundingFeesUsd -
+    closingFeeUsd -
+    uiFeeUsd +
+    totalPendingImpactDeltaUsd +
+    priceImpactDiffUsd;
+
+  return pnlAfterFees;
 }
 
 export function getLeverage(p: {
@@ -121,6 +161,7 @@ export function getLiquidationPrice(p: {
   marketInfo: MarketInfo;
   pendingFundingFeesUsd: bigint;
   pendingBorrowingFeesUsd: bigint;
+  pendingImpactAmount: bigint;
   minCollateralUsd: bigint;
   isLong: boolean;
   useMaxPriceImpact?: boolean;
@@ -135,6 +176,7 @@ export function getLiquidationPrice(p: {
     collateralToken,
     pendingFundingFeesUsd,
     pendingBorrowingFeesUsd,
+    pendingImpactAmount,
     minCollateralUsd,
     isLong,
     userReferralInfo,
@@ -158,19 +200,29 @@ export function getLiquidationPrice(p: {
   if (useMaxPriceImpact) {
     priceImpactDeltaUsd = maxNegativePriceImpactUsd;
   } else {
-    priceImpactDeltaUsd = getPriceImpactForPosition(marketInfo, -sizeInUsd, isLong, { fallbackToZero: true });
+    const priceImpactForPosition = getPriceImpactForPosition(marketInfo, -sizeInUsd, isLong, { fallbackToZero: true });
+    priceImpactDeltaUsd = priceImpactForPosition.priceImpactDeltaUsd;
 
-    if (priceImpactDeltaUsd < maxNegativePriceImpactUsd) {
-      priceImpactDeltaUsd = maxNegativePriceImpactUsd;
+    if (priceImpactDeltaUsd > 0) {
+      priceImpactDeltaUsd = capPositionImpactUsdByMaxPriceImpactFactor(marketInfo, sizeInUsd, priceImpactDeltaUsd);
     }
 
-    // Ignore positive price impact
+    const pendingImpactUsd = convertToUsd(
+      pendingImpactAmount,
+      marketInfo.indexToken.decimals,
+      pendingImpactAmount > 0 ? marketInfo.indexToken.prices.minPrice : marketInfo.indexToken.prices.maxPrice
+    )!;
+
+    priceImpactDeltaUsd = priceImpactDeltaUsd + pendingImpactUsd;
+
     if (priceImpactDeltaUsd > 0) {
       priceImpactDeltaUsd = 0n;
+    } else if (priceImpactDeltaUsd < maxNegativePriceImpactUsd) {
+      priceImpactDeltaUsd = maxNegativePriceImpactUsd;
     }
   }
 
-  let liquidationCollateralUsd = applyFactor(sizeInUsd, marketInfo.minCollateralFactor);
+  let liquidationCollateralUsd = applyFactor(sizeInUsd, marketInfo.minCollateralFactorForLiquidation);
   if (liquidationCollateralUsd < minCollateralUsd) {
     liquidationCollateralUsd = minCollateralUsd;
   }
@@ -223,3 +275,88 @@ export function getLiquidationPrice(p: {
 
   return liquidationPrice;
 }
+
+export function getNetPriceImpactDeltaUsdForDecrease({
+  marketInfo,
+  sizeInUsd,
+  pendingImpactAmount,
+  priceImpactDeltaUsd,
+  sizeDeltaUsd,
+}: {
+  marketInfo: MarketInfo;
+  sizeInUsd: bigint;
+  pendingImpactAmount: bigint;
+  sizeDeltaUsd: bigint;
+  priceImpactDeltaUsd: bigint;
+}) {
+  const { proportionalPendingImpactDeltaUsd } = getProportionalPendingImpactValues({
+    sizeInUsd,
+    sizeDeltaUsd,
+    pendingImpactAmount,
+    indexToken: marketInfo.indexToken,
+  });
+
+  let totalImpactDeltaUsd = priceImpactDeltaUsd + proportionalPendingImpactDeltaUsd;
+
+  const priceImpactDiffUsd = getPriceImpactDiffUsd({
+    totalImpactDeltaUsd,
+    marketInfo,
+    sizeDeltaUsd,
+  });
+
+  if (totalImpactDeltaUsd > 0) {
+    totalImpactDeltaUsd = capPositionImpactUsdByMaxPriceImpactFactor(marketInfo, sizeDeltaUsd, totalImpactDeltaUsd);
+  }
+
+  totalImpactDeltaUsd = capPositionImpactUsdByMaxImpactPool(marketInfo, totalImpactDeltaUsd);
+
+  return {
+    totalImpactDeltaUsd,
+    proportionalPendingImpactDeltaUsd,
+    priceImpactDiffUsd,
+  };
+}
+
+export function getPriceImpactDiffUsd({
+  totalImpactDeltaUsd,
+  marketInfo,
+  sizeDeltaUsd,
+}: {
+  totalImpactDeltaUsd: bigint;
+  marketInfo: MarketInfo;
+  sizeDeltaUsd: bigint;
+}) {
+  if (totalImpactDeltaUsd > 0) {
+    return 0n;
+  }
+
+  const { maxNegativeImpactFactor } = getMaxPositionImpactFactors(marketInfo);
+
+  const maxNegativeImpactUsd = -applyFactor(sizeDeltaUsd, maxNegativeImpactFactor);
+
+  let priceImpactDiffUsd = 0n;
+
+  if (totalImpactDeltaUsd < maxNegativeImpactUsd) {
+    priceImpactDiffUsd = maxNegativeImpactUsd - totalImpactDeltaUsd;
+  }
+
+  return priceImpactDiffUsd;
+}
+
+export function getMinCollateralFactorForPosition(position: PositionInfoLoaded, openInterestDelta: bigint) {
+  const marketInfo = position.marketInfo;
+
+  const isLong = position.isLong;
+  const openInterest = getOpenInterestUsd(marketInfo, isLong) + openInterestDelta;
+  const minCollateralFactorMultiplier = isLong
+    ? marketInfo.minCollateralFactorForOpenInterestLong
+    : marketInfo.minCollateralFactorForOpenInterestShort;
+  let minCollateralFactor = bigMath.mulDiv(openInterest, minCollateralFactorMultiplier, PRECISION);
+  const minCollateralFactorForMarket = marketInfo.minCollateralFactor;
+
+  if (minCollateralFactorForMarket > minCollateralFactor) {
+    minCollateralFactor = minCollateralFactorForMarket;
+  }
+
+  return minCollateralFactor;
+}
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/prices.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/prices.ts
index 98e45ca1..63ab78b9 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/prices.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/prices.ts
@@ -1,15 +1,12 @@
-import { BASIS_POINTS_DIVISOR_BIGINT, DEFAULT_ACCEPTABLE_PRICE_IMPACT_BUFFER } from "../configs/factors.js";
-import { MarketInfo } from "../types/markets.js";
-import { OrderType } from "../types/orders.js";
-import { TokenPrices } from "../types/tokens.js";
-import { getPriceImpactByAcceptablePrice } from "./fees/index.js";
-import { bigMath } from "./bigmath.js";
-import { getCappedPositionImpactUsd } from "./fees/index.js";
-import { convertToTokenAmount } from "./tokens.js";
-import { expandDecimals, getBasisPoints } from "./numbers.js";
-import { roundUpMagnitudeDivision } from "./numbers.js";
-import { applyFactor } from "./numbers.js";
-import { TriggerThresholdType } from "../types/trade.js";
+import {BASIS_POINTS_DIVISOR_BIGINT, DEFAULT_ACCEPTABLE_PRICE_IMPACT_BUFFER} from "../configs/factors.js";
+import {MarketInfo} from "../types/markets.js";
+import {OrderType} from "../types/orders.js";
+import {TokenPrices} from "../types/tokens.js";
+import {getCappedPositionImpactUsd, getPriceImpactByAcceptablePrice} from "./fees/index.js";
+import {bigMath} from "./bigmath.js";
+import {convertToTokenAmount} from "./tokens.js";
+import {expandDecimals, getBasisPoints, roundUpMagnitudeDivision} from "./numbers.js";
+import {TriggerThresholdType} from "../types/trade.js";
 
 export function getMarkPrice(p: { prices: TokenPrices; isIncrease: boolean; isLong: boolean }) {
   const { prices, isIncrease, isLong } = p;
@@ -44,12 +41,13 @@ export function getOrderThresholdType(orderType: OrderType, isLong: boolean) {
     return isLong ? TriggerThresholdType.Below : TriggerThresholdType.Above;
   }
 
-  throw new Error("Invalid trigger order type");
+  return undefined;
 }
 
 export function getAcceptablePriceInfo(p: {
   marketInfo: MarketInfo;
   isIncrease: boolean;
+  isLimit: boolean;
   isLong: boolean;
   indexPrice: bigint;
   sizeDeltaUsd: bigint;
@@ -61,9 +59,12 @@ export function getAcceptablePriceInfo(p: {
   const values = {
     acceptablePrice: 0n,
     acceptablePriceDeltaBps: 0n,
+    cappedPriceImpactDeltaUsd: 0n,
+    cappedPriceImpactDeltaAmount: 0n,
     priceImpactDeltaAmount: 0n,
     priceImpactDeltaUsd: 0n,
     priceImpactDiffUsd: 0n,
+    balanceWasImproved: false,
   };
 
   if (sizeDeltaUsd <= 0 || indexPrice == 0n) {
@@ -94,23 +95,24 @@ export function getAcceptablePriceInfo(p: {
     return values;
   }
 
-  values.priceImpactDeltaUsd = getCappedPositionImpactUsd(
+  const { priceImpactDeltaUsd, balanceWasImproved } = getCappedPositionImpactUsd(
     marketInfo,
-    isIncrease ? sizeDeltaUsd : sizeDeltaUsd * -1n,
+    sizeDeltaUsd,
     isLong,
+    isIncrease,
     {
       fallbackToZero: !isIncrease,
+      shouldCapNegativeImpact: false,
     }
   );
 
-  if (!isIncrease && values.priceImpactDeltaUsd < 0) {
-    const minPriceImpactUsd = applyFactor(sizeDeltaUsd, marketInfo.maxPositionImpactFactorNegative) * -1n;
-
-    if (values.priceImpactDeltaUsd < minPriceImpactUsd) {
-      values.priceImpactDiffUsd = minPriceImpactUsd - values.priceImpactDeltaUsd;
-      values.priceImpactDeltaUsd = minPriceImpactUsd;
-    }
-  }
+  /**
+   * We display this value as price impact on action (increase or decrease)
+   * But for acceptable price calculation uncapped price impact is used
+   * Also on decrease action we calculate totalImpactUsd which will be deducted from the collateral
+   */
+  values.priceImpactDeltaUsd = priceImpactDeltaUsd;
+  values.balanceWasImproved = balanceWasImproved;
 
   if (values.priceImpactDeltaUsd > 0) {
     values.priceImpactDeltaAmount = convertToTokenAmount(
@@ -125,12 +127,24 @@ export function getAcceptablePriceInfo(p: {
     );
   }
 
+  // Use uncapped price impact for the acceptable price calculation
+  const { priceImpactDeltaUsd: priceImpactDeltaUsdForAcceptablePrice } = getCappedPositionImpactUsd(
+    marketInfo,
+    sizeDeltaUsd,
+    isLong,
+    isIncrease,
+    {
+      fallbackToZero: !isIncrease,
+      shouldCapNegativeImpact: false,
+    }
+  );
+
   const acceptablePriceValues = getAcceptablePriceByPriceImpact({
     isIncrease,
     isLong,
     indexPrice,
     sizeDeltaUsd,
-    priceImpactDeltaUsd: values.priceImpactDeltaUsd,
+    priceImpactDeltaUsd: priceImpactDeltaUsdForAcceptablePrice,
   });
 
   values.acceptablePrice = acceptablePriceValues.acceptablePrice;
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/simulateExecuteOrder.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/simulateExecuteOrder.ts
index fbbf057d..45b5ab96 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/simulateExecuteOrder.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/simulateExecuteOrder.ts
@@ -1,16 +1,16 @@
-import { Abi, Address, decodeErrorResult, encodeFunctionData, withRetry } from "viem";
+import {Abi, Address, decodeErrorResult, encodeFunctionData, withRetry} from "viem";
 
 
-import { getContract } from "../configs/contracts.js";
-import { convertTokenAddress } from "../configs/tokens.js";
+import {getContract} from "../configs/contracts.js";
+import {convertTokenAddress} from "../configs/tokens.js";
 
-import { SwapPricingType } from "../types/orders.js";
-import { TokenPrices, TokensData } from "../types/tokens.js";
-import { convertToContractPrice, getTokenData } from "./tokens.js";
+import {SwapPricingType} from "../types/orders.js";
+import {TokenPrices, TokensData} from "../types/tokens.js";
+import {convertToContractPrice, getTokenData} from "./tokens.js";
 
-import type { GmxSdk } from "../index.js";
-import { extractError } from "./contracts.js";
-import { abis } from "../abis/index.js";
+import type {GmxSdk} from "../index.js";
+import {extractError} from "./contracts.js";
+import {abis} from "../abis/index.js";
 
 export type PriceOverrides = {
   [address: string]: TokenPrices | undefined;
@@ -42,6 +42,7 @@ export async function simulateExecuteOrder(sdk: GmxSdk, p: SimulateExecuteParams
     abi: abis.Multicall as Abi,
     functionName: "getCurrentBlockTimestamp",
     args: [],
+    authorizationList: [],
   });
 
   const blockNumber = await client.getBlockNumber();
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/botanixStaking.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/botanixStaking.ts
new file mode 100644
index 00000000..fb78735b
--- /dev/null
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/botanixStaking.ts
@@ -0,0 +1,110 @@
+import {encodeFunctionData} from "viem";
+
+import StBTCABI from "../../abis/StBTC.json" with {type: "json"};
+import {BOTANIX} from "../../configs/chains.js";
+import {getContract} from "../../configs/contracts.js";
+import {TokensData} from "../../types/tokens.js";
+import {ExternalSwapAggregator, ExternalSwapQuote} from "../../types/trade.js";
+import {bigMath} from "../bigmath.js";
+import {BASIS_POINTS_DIVISOR_BIGINT, getBasisPoints} from "../numbers.js";
+import {AVAILABLE_BOTANIX_DEPOSIT_PAIRS, AVAILABLE_BOTANIX_WITHDRAW_PAIRS} from "./externalSwapPath.js";
+import {convertToUsd, getMidPrice, getTokenData} from "../tokens.js";
+
+const COEF_REDUCER = getBasisPoints(1n, 10000n);
+
+export const getBotanixStakingExternalSwapQuote = ({
+  tokenInAddress,
+  tokenOutAddress,
+  amountIn,
+  gasPrice,
+  receiverAddress,
+  tokensData,
+  assetsPerShare,
+}: {
+  tokenInAddress: string;
+  tokenOutAddress: string;
+  amountIn: bigint;
+  gasPrice: bigint;
+  receiverAddress: string;
+  tokensData: TokensData;
+  assetsPerShare: bigint;
+}): ExternalSwapQuote | undefined => {
+  const inTokenData = getTokenData(tokensData, tokenInAddress);
+  const outTokenData = getTokenData(tokensData, tokenOutAddress);
+
+  const assetsPerShareRate = getBasisPoints(assetsPerShare, 10n ** 18n) - COEF_REDUCER;
+  const sharesPerAssetRate = getBasisPoints(10n ** 18n, assetsPerShare) - COEF_REDUCER;
+
+  if (!inTokenData || !outTokenData) {
+    return undefined;
+  }
+
+  if (AVAILABLE_BOTANIX_DEPOSIT_PAIRS.some((pair) => pair.from === tokenInAddress && pair.to === tokenOutAddress)) {
+    const priceIn = getMidPrice(inTokenData.prices);
+    const priceOut = bigMath.mulDiv(priceIn, sharesPerAssetRate, BASIS_POINTS_DIVISOR_BIGINT);
+    const usdIn = convertToUsd(amountIn, inTokenData.decimals, priceIn);
+    const amountOut =
+      amountIn > 0n ? bigMath.mulDiv(amountIn, sharesPerAssetRate, BASIS_POINTS_DIVISOR_BIGINT) - gasPrice : 0n;
+    const usdOut = amountOut > 0n ? convertToUsd(amountOut, outTokenData.decimals, priceOut) : 0n;
+    return {
+      aggregator: ExternalSwapAggregator.BotanixStaking,
+      inTokenAddress: tokenInAddress,
+      outTokenAddress: tokenOutAddress,
+      receiver: receiverAddress,
+      amountIn,
+      amountOut,
+      usdIn: usdIn!,
+      usdOut: usdOut!,
+      priceIn,
+      priceOut,
+      feesUsd: gasPrice,
+      needSpenderApproval: true,
+      txnData: {
+        to: getContract(BOTANIX, "StBTC"),
+        data: encodeFunctionData({
+          abi: StBTCABI.abi,
+          functionName: "deposit",
+          args: [amountIn, receiverAddress],
+        }),
+        value: 0n,
+        estimatedGas: gasPrice,
+        estimatedExecutionFee: gasPrice,
+      },
+    };
+  }
+
+  if (AVAILABLE_BOTANIX_WITHDRAW_PAIRS.some((pair) => pair.from === tokenInAddress && pair.to === tokenOutAddress)) {
+    const priceIn = getMidPrice(inTokenData.prices);
+    const priceOut = bigMath.mulDiv(priceIn, assetsPerShareRate, BASIS_POINTS_DIVISOR_BIGINT);
+    const usdIn = convertToUsd(amountIn, inTokenData.decimals, priceIn);
+    const amountOut =
+      amountIn > 0n ? bigMath.mulDiv(amountIn, assetsPerShareRate, BASIS_POINTS_DIVISOR_BIGINT) - gasPrice : 0n;
+    const usdOut = amountOut > 0n ? convertToUsd(amountOut, outTokenData.decimals, priceOut) : 0n;
+
+    return {
+      aggregator: ExternalSwapAggregator.BotanixStaking,
+      inTokenAddress: tokenInAddress,
+      outTokenAddress: tokenOutAddress,
+      receiver: receiverAddress,
+      amountIn,
+      amountOut,
+      usdIn: usdIn!,
+      usdOut: usdOut!,
+      priceIn,
+      priceOut,
+      feesUsd: gasPrice,
+      needSpenderApproval: true,
+      txnData: {
+        to: getContract(BOTANIX, "StBTC"),
+        data: encodeFunctionData({
+          abi: StBTCABI.abi,
+          functionName: "withdraw",
+          args: [amountIn, receiverAddress, getContract(BOTANIX, "ExternalHandler")],
+        }),
+        value: 0n,
+        estimatedGas: gasPrice,
+        estimatedExecutionFee: gasPrice,
+      },
+    };
+  }
+};
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/buildMarketsAdjacencyGraph.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/buildMarketsAdjacencyGraph.ts
new file mode 100644
index 00000000..fdae5ae9
--- /dev/null
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/buildMarketsAdjacencyGraph.ts
@@ -0,0 +1,41 @@
+import type {MarketConfig} from "../../configs/markets.js";
+
+type FromTokenAddress = string;
+type ToTokenAddress = string;
+type MarketAddress = string;
+
+export type MarketsGraph = {
+  [from: FromTokenAddress]: {
+    [to: ToTokenAddress]: MarketAddress[];
+  };
+};
+
+export function buildMarketsAdjacencyGraph(marketsMap: Record<string, MarketConfig>): MarketsGraph {
+  const graph: MarketsGraph = {};
+
+  for (const marketTokenAddress in marketsMap) {
+    const { longTokenAddress, shortTokenAddress } = marketsMap[marketTokenAddress];
+
+    const isSameCollaterals = longTokenAddress === shortTokenAddress;
+
+    if (isSameCollaterals) {
+      const tokenAddress = longTokenAddress;
+
+      graph[tokenAddress] = graph[tokenAddress] || {};
+      graph[tokenAddress][tokenAddress] = graph[tokenAddress][tokenAddress] || [];
+      graph[tokenAddress][tokenAddress].push(marketTokenAddress);
+
+      continue;
+    }
+
+    graph[longTokenAddress] = graph[longTokenAddress] || {};
+    graph[longTokenAddress][shortTokenAddress] = graph[longTokenAddress][shortTokenAddress] || [];
+    graph[longTokenAddress][shortTokenAddress].push(marketTokenAddress);
+
+    graph[shortTokenAddress] = graph[shortTokenAddress] || {};
+    graph[shortTokenAddress][longTokenAddress] = graph[shortTokenAddress][longTokenAddress] || [];
+    graph[shortTokenAddress][longTokenAddress].push(marketTokenAddress);
+  }
+
+  return graph;
+}
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/buildSwapStrategy.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/buildSwapStrategy.ts
new file mode 100644
index 00000000..06b0b731
--- /dev/null
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/buildSwapStrategy.ts
@@ -0,0 +1,311 @@
+import {MarketsInfoData} from "../../types/markets.js";
+import {SwapStrategyForSwapOrders} from "../../types/swapStrategy.js";
+import {TokenData} from "../../types/tokens.js";
+import {ExternalSwapQuoteParams, SwapOptimizationOrderArray} from "../../types/trade.js";
+import {bigMath} from "../../utils/bigmath.js";
+import {
+    convertToTokenAmount,
+    convertToUsd,
+    getIsEquivalentTokens,
+    getIsStake,
+    getIsUnstake,
+    getMidPrice,
+} from "../../utils/tokens.js";
+
+import {getAvailableExternalSwapPaths} from "./externalSwapPath.js";
+import {getExternalSwapQuoteByPath} from "./externalSwapQuoteByPath.js";
+import {createFindSwapPath} from "./swapPath.js";
+
+/*
+  Order/Priority of getting swap strategy:
+  1. Check if it needs a swap and return noSwap if tokens are equivalent, stake or unstake [noSwap]
+  2. Check if there is a swap path stats for the internal swap quote and return internalSwap if there is [internalSwap]
+  3. Check if there is a combined swap strategy and return combinedSwap if there is [combinedSwap]
+  4. Return defaultSwapStrategy (noSwap) if there is no other swap strategy [noSwap]
+*/
+
+export function buildSwapStrategy({
+  amountIn,
+  tokenIn,
+  tokenOut,
+  marketsInfoData,
+  chainId,
+  swapOptimizationOrder,
+  externalSwapQuoteParams,
+}: {
+  chainId: number;
+  amountIn: bigint;
+  tokenIn: TokenData;
+  tokenOut: TokenData;
+  marketsInfoData: MarketsInfoData | undefined;
+  swapOptimizationOrder: SwapOptimizationOrderArray | undefined;
+  externalSwapQuoteParams: ExternalSwapQuoteParams;
+}): SwapStrategyForSwapOrders {
+  const priceIn = tokenIn.prices.minPrice;
+  const usdIn = convertToUsd(amountIn, tokenIn.decimals, priceIn)!;
+
+  if (amountIn < 0n) {
+    amountIn = 0n;
+  }
+
+  const defaultSwapStrategy: SwapStrategyForSwapOrders = {
+    type: "noSwap",
+    externalSwapQuote: undefined,
+    swapPathStats: undefined,
+    amountIn,
+    amountOut: convertToTokenAmount(usdIn, tokenOut.decimals, tokenOut.prices.maxPrice)!,
+    usdIn,
+    usdOut: usdIn,
+    priceIn,
+    priceOut: tokenOut.prices.maxPrice,
+    feesUsd: 0n,
+  };
+
+  if (getIsEquivalentTokens(tokenIn, tokenOut) || getIsStake(tokenIn, tokenOut) || getIsUnstake(tokenIn, tokenOut)) {
+    return defaultSwapStrategy;
+  }
+
+  const findSwapPath = createFindSwapPath({
+    chainId,
+    fromTokenAddress: tokenIn.address,
+    toTokenAddress: tokenOut.address,
+    marketsInfoData,
+    isExpressFeeSwap: false,
+  });
+
+  const swapPathStats = findSwapPath(usdIn, { order: swapOptimizationOrder });
+
+  if (swapPathStats) {
+    return {
+      type: "internalSwap",
+      swapPathStats,
+      externalSwapQuote: undefined,
+      amountIn,
+      amountOut: swapPathStats.amountOut,
+      usdIn: usdIn,
+      usdOut: swapPathStats.usdOut,
+      priceIn: priceIn,
+      priceOut: tokenOut.prices.maxPrice,
+      feesUsd: usdIn - swapPathStats.usdOut,
+    };
+  }
+
+  const availableExternalSwapPaths = getAvailableExternalSwapPaths({ chainId, fromTokenAddress: tokenIn.address });
+
+  const suitableSwapPath = availableExternalSwapPaths.find((path) => {
+    const findSwapPath = createFindSwapPath({
+      chainId,
+      fromTokenAddress: path.outTokenAddress,
+      toTokenAddress: tokenOut.address,
+      marketsInfoData,
+      isExpressFeeSwap: false,
+    });
+
+    const swapPathStats = findSwapPath(usdIn);
+
+    return Boolean(swapPathStats);
+  });
+
+  if (suitableSwapPath && suitableSwapPath.outTokenAddress !== tokenOut.address) {
+    const externalSwapQuoteForCombinedSwap = getExternalSwapQuoteByPath({
+      amountIn,
+      externalSwapPath: suitableSwapPath,
+      externalSwapQuoteParams,
+    });
+    const findSwapPathForSuitableSwapPath = createFindSwapPath({
+      chainId,
+      fromTokenAddress: suitableSwapPath.outTokenAddress,
+      toTokenAddress: tokenOut.address,
+      marketsInfoData,
+      isExpressFeeSwap: false,
+    });
+
+    const swapPathStatsForCombinedSwap = externalSwapQuoteForCombinedSwap
+      ? findSwapPathForSuitableSwapPath(externalSwapQuoteForCombinedSwap.usdOut)
+      : undefined;
+
+    return externalSwapQuoteForCombinedSwap && swapPathStatsForCombinedSwap
+      ? {
+          type: "combinedSwap",
+          externalSwapQuote: externalSwapQuoteForCombinedSwap,
+          swapPathStats: swapPathStatsForCombinedSwap,
+          amountIn,
+          amountOut: swapPathStatsForCombinedSwap.amountOut,
+          usdIn: externalSwapQuoteForCombinedSwap.usdIn,
+          usdOut: swapPathStatsForCombinedSwap.usdOut,
+          priceIn: externalSwapQuoteForCombinedSwap.priceIn,
+          priceOut: tokenOut.prices.maxPrice,
+          feesUsd: BigInt(externalSwapQuoteForCombinedSwap.usdIn - swapPathStatsForCombinedSwap.usdOut),
+        }
+      : defaultSwapStrategy;
+  }
+
+  return defaultSwapStrategy;
+}
+
+// Used for getting swap amounts by to value
+export function buildReverseSwapStrategy({
+  amountOut,
+  tokenIn,
+  tokenOut,
+  marketsInfoData,
+  chainId,
+  externalSwapQuoteParams,
+  swapOptimizationOrder,
+}: {
+  chainId: number;
+  amountOut: bigint;
+  tokenIn: TokenData;
+  tokenOut: TokenData;
+  marketsInfoData: MarketsInfoData | undefined;
+  externalSwapQuoteParams: ExternalSwapQuoteParams;
+  swapOptimizationOrder: SwapOptimizationOrderArray | undefined;
+}): SwapStrategyForSwapOrders {
+  const priceIn = getMidPrice(tokenIn.prices);
+  const priceOut = getMidPrice(tokenOut.prices);
+
+  const preferredUsdOut = convertToUsd(amountOut, tokenOut.decimals, getMidPrice(tokenOut.prices))!;
+  const approximateAmountIn = convertToTokenAmount(preferredUsdOut, tokenIn.decimals, getMidPrice(tokenIn.prices))!;
+  const approximateUsdIn = preferredUsdOut;
+
+  const defaultSwapStrategy: SwapStrategyForSwapOrders = {
+    type: "noSwap",
+    externalSwapQuote: undefined,
+    swapPathStats: undefined,
+    amountIn: approximateAmountIn,
+    amountOut: amountOut,
+    usdIn: approximateUsdIn,
+    usdOut: preferredUsdOut,
+    priceIn,
+    priceOut,
+    feesUsd: 0n,
+  };
+
+  if (getIsEquivalentTokens(tokenIn, tokenOut) || getIsStake(tokenIn, tokenOut) || getIsUnstake(tokenIn, tokenOut)) {
+    return defaultSwapStrategy;
+  }
+
+  const findSwapPath = createFindSwapPath({
+    chainId,
+    fromTokenAddress: tokenIn.address,
+    toTokenAddress: tokenOut.address,
+    marketsInfoData,
+    isExpressFeeSwap: false,
+  });
+
+  const approximateSwapPathStats = findSwapPath(approximateUsdIn, { order: swapOptimizationOrder });
+
+  if (approximateSwapPathStats) {
+    // Increase or decrease usdIn the same way preferred usdOut is different from swapStrategy.usdOut
+    // preferred_in / approximate_in = preferred_out / approximate_out
+    // preferred_in = approximate_in * preferred_out / approximate_out
+    const adjustedUsdIn =
+      approximateSwapPathStats.usdOut > 0
+        ? bigMath.mulDiv(approximateUsdIn, preferredUsdOut, approximateSwapPathStats.usdOut)
+        : 0n;
+    const adjustedAmountIn = convertToTokenAmount(adjustedUsdIn, tokenIn.decimals, getMidPrice(tokenIn.prices))!;
+
+    const adjustedSwapPathStats = findSwapPath(adjustedUsdIn, { order: swapOptimizationOrder });
+
+    if (adjustedSwapPathStats) {
+      return {
+        type: "internalSwap",
+        swapPathStats: adjustedSwapPathStats,
+        externalSwapQuote: undefined,
+        amountIn: adjustedAmountIn,
+        amountOut: adjustedSwapPathStats.amountOut,
+        usdIn: adjustedUsdIn,
+        usdOut: adjustedSwapPathStats.usdOut,
+        priceIn: priceIn,
+        priceOut: priceOut,
+        feesUsd: adjustedUsdIn - adjustedSwapPathStats.usdOut,
+      };
+    }
+  }
+
+  const availableExternalSwapPaths = getAvailableExternalSwapPaths({ chainId, fromTokenAddress: tokenIn.address });
+
+  const suitableSwapPath = availableExternalSwapPaths.find((path) => {
+    if (path.outTokenAddress !== tokenOut.address) return false;
+
+    const findSwapPath = createFindSwapPath({
+      chainId,
+      fromTokenAddress: tokenIn.address,
+      toTokenAddress: path.inTokenAddress,
+      marketsInfoData,
+      isExpressFeeSwap: false,
+    });
+
+    const swapPathStats = findSwapPath(approximateUsdIn);
+
+    return Boolean(swapPathStats);
+  });
+
+  if (suitableSwapPath) {
+    const approximateExternalSwapQuoteForCombinedSwap = getExternalSwapQuoteByPath({
+      amountIn: approximateAmountIn,
+      externalSwapPath: suitableSwapPath,
+      externalSwapQuoteParams,
+    });
+
+    if (!approximateExternalSwapQuoteForCombinedSwap) {
+      return defaultSwapStrategy;
+    }
+
+    const findSwapPathForSuitableSwapPath = createFindSwapPath({
+      chainId,
+      fromTokenAddress: tokenIn.address,
+      toTokenAddress: suitableSwapPath.inTokenAddress,
+      marketsInfoData,
+      isExpressFeeSwap: false,
+    });
+
+    const approximateSwapPathStatsForCombinedSwap = findSwapPathForSuitableSwapPath(
+      approximateExternalSwapQuoteForCombinedSwap.usdOut
+    );
+
+    if (!approximateSwapPathStatsForCombinedSwap) {
+      return defaultSwapStrategy;
+    }
+
+    const adjustedUsdIn =
+      approximateSwapPathStatsForCombinedSwap.usdOut > 0
+        ? bigMath.mulDiv(approximateUsdIn, preferredUsdOut, approximateSwapPathStatsForCombinedSwap.usdOut)
+        : 0n;
+
+    const adjustedAmountIn = convertToTokenAmount(adjustedUsdIn, tokenIn.decimals, getMidPrice(tokenIn.prices))!;
+
+    const adjustedExternalSwapQuoteForCombinedSwap = getExternalSwapQuoteByPath({
+      amountIn: adjustedAmountIn,
+      externalSwapPath: suitableSwapPath,
+      externalSwapQuoteParams,
+    });
+
+    if (!adjustedExternalSwapQuoteForCombinedSwap) {
+      return defaultSwapStrategy;
+    }
+
+    const adjustedSwapPathStatsForCombinedSwap = findSwapPathForSuitableSwapPath(
+      adjustedExternalSwapQuoteForCombinedSwap.usdOut
+    );
+
+    if (!adjustedSwapPathStatsForCombinedSwap) {
+      return defaultSwapStrategy;
+    }
+
+    return {
+      type: "combinedSwap",
+      externalSwapQuote: adjustedExternalSwapQuoteForCombinedSwap,
+      swapPathStats: adjustedSwapPathStatsForCombinedSwap,
+      amountIn: adjustedAmountIn,
+      amountOut: adjustedSwapPathStatsForCombinedSwap.amountOut,
+      usdIn: adjustedExternalSwapQuoteForCombinedSwap.usdIn,
+      usdOut: adjustedSwapPathStatsForCombinedSwap.usdOut,
+      priceIn: adjustedExternalSwapQuoteForCombinedSwap.priceIn,
+      priceOut: priceOut,
+      feesUsd: BigInt(adjustedExternalSwapQuoteForCombinedSwap.usdIn - adjustedSwapPathStatsForCombinedSwap.usdOut),
+    };
+  }
+
+  return defaultSwapStrategy;
+}
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/constants.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/constants.ts
new file mode 100644
index 00000000..943b2dba
--- /dev/null
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/constants.ts
@@ -0,0 +1,2 @@
+export const MAX_EDGE_PATH_LENGTH = 3;
+export const DEFAULT_NAIVE_TOP_PATHS_COUNT = 3;
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/externalSwapPath.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/externalSwapPath.ts
new file mode 100644
index 00000000..aed6eb81
--- /dev/null
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/externalSwapPath.ts
@@ -0,0 +1,49 @@
+import {BOTANIX} from "../../configs/chains.js";
+import {getTokenBySymbol, NATIVE_TOKEN_ADDRESS} from "../../configs/tokens.js";
+import {ExternalSwapAggregator, ExternalSwapPath} from "../../types/trade.js";
+
+const BBTC_ADDRESS = NATIVE_TOKEN_ADDRESS;
+const PBTC_ADDRESS = getTokenBySymbol(BOTANIX, "PBTC").address;
+const STBTC_ADDRESS = getTokenBySymbol(BOTANIX, "STBTC").address;
+
+export const AVAILABLE_BOTANIX_DEPOSIT_PAIRS = [
+  {
+    from: BBTC_ADDRESS,
+    to: STBTC_ADDRESS,
+  },
+  {
+    from: PBTC_ADDRESS,
+    to: STBTC_ADDRESS,
+  },
+];
+
+export const AVAILABLE_BOTANIX_WITHDRAW_PAIRS = [
+  {
+    from: STBTC_ADDRESS,
+    to: PBTC_ADDRESS,
+  },
+];
+
+const getBotanixStakingExternalSwapPaths = ({ fromTokenAddress }: { fromTokenAddress: string }): ExternalSwapPath[] => {
+  return [...AVAILABLE_BOTANIX_DEPOSIT_PAIRS, ...AVAILABLE_BOTANIX_WITHDRAW_PAIRS]
+    .filter((pair) => pair.from === fromTokenAddress)
+    .map((pair) => ({
+      aggregator: ExternalSwapAggregator.BotanixStaking,
+      inTokenAddress: pair.from,
+      outTokenAddress: pair.to,
+    }));
+};
+
+export const getAvailableExternalSwapPaths = ({
+  chainId,
+  fromTokenAddress,
+}: {
+  chainId: number;
+  fromTokenAddress: string;
+}): ExternalSwapPath[] => {
+  if (chainId === BOTANIX) {
+    return getBotanixStakingExternalSwapPaths({ fromTokenAddress });
+  }
+
+  return [];
+};
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/externalSwapQuoteByPath.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/externalSwapQuoteByPath.ts
new file mode 100644
index 00000000..51c865c8
--- /dev/null
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/externalSwapQuoteByPath.ts
@@ -0,0 +1,42 @@
+import {
+  ExternalSwapAggregator,
+  ExternalSwapPath,
+  ExternalSwapQuote,
+  ExternalSwapQuoteParams
+} from "../../types/trade.js";
+
+import {getBotanixStakingExternalSwapQuote} from "./botanixStaking.js";
+
+export const getExternalSwapQuoteByPath = ({
+  amountIn,
+  externalSwapPath,
+  externalSwapQuoteParams,
+}: {
+  amountIn: bigint;
+  externalSwapPath: ExternalSwapPath;
+  externalSwapQuoteParams: ExternalSwapQuoteParams;
+}): ExternalSwapQuote | undefined => {
+  if (
+    amountIn === undefined ||
+    externalSwapQuoteParams.gasPrice === undefined ||
+    externalSwapQuoteParams.tokensData === undefined ||
+    externalSwapQuoteParams.botanixStakingAssetsPerShare === undefined ||
+    externalSwapQuoteParams.receiverAddress === undefined
+  ) {
+    return undefined;
+  }
+
+  if (externalSwapPath.aggregator === ExternalSwapAggregator.BotanixStaking) {
+    return getBotanixStakingExternalSwapQuote({
+      tokenInAddress: externalSwapPath.inTokenAddress,
+      tokenOutAddress: externalSwapPath.outTokenAddress,
+      amountIn,
+      gasPrice: externalSwapQuoteParams.gasPrice,
+      receiverAddress: externalSwapQuoteParams.receiverAddress,
+      tokensData: externalSwapQuoteParams.tokensData,
+      assetsPerShare: externalSwapQuoteParams.botanixStakingAssetsPerShare,
+    });
+  }
+
+  return undefined;
+};
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/findReachableTokens.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/findReachableTokens.ts
new file mode 100644
index 00000000..8215ef9f
--- /dev/null
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/findReachableTokens.ts
@@ -0,0 +1,49 @@
+import {objectKeysDeep} from "../objects.js";
+import type {MarketsGraph} from "./buildMarketsAdjacencyGraph.js";
+import {MAX_EDGE_PATH_LENGTH} from "./constants.js";
+
+export function findReachableTokens(graph: MarketsGraph): Record<string, string[]> {
+  const reachableTokens: Record<string, string[]> = {};
+
+  const allTokens = objectKeysDeep(graph, 1).sort();
+
+  for (const startToken of allTokens) {
+    type TokenSearchState = {
+      currentToken: string;
+      pathLength: number;
+    };
+
+    const searchQueue: TokenSearchState[] = [
+      {
+        currentToken: startToken,
+        pathLength: 0,
+      },
+    ];
+    const visitedTokens = new Set<string>();
+
+    while (searchQueue.length > 0) {
+      const { currentToken, pathLength } = searchQueue.shift()!;
+
+      if (visitedTokens.has(currentToken)) {
+        continue;
+      }
+
+      visitedTokens.add(currentToken);
+
+      if (pathLength >= MAX_EDGE_PATH_LENGTH) {
+        continue;
+      }
+
+      for (const nextToken in graph[currentToken]) {
+        searchQueue.push({
+          currentToken: nextToken,
+          pathLength: pathLength + 1,
+        });
+      }
+    }
+
+    reachableTokens[startToken] = Array.from(visitedTokens);
+  }
+
+  return reachableTokens;
+}
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/findSwapPathsBetweenTokens.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/findSwapPathsBetweenTokens.ts
new file mode 100644
index 00000000..e620445b
--- /dev/null
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/findSwapPathsBetweenTokens.ts
@@ -0,0 +1,96 @@
+import type {SwapPaths} from "../../types/trade.js";
+import {objectKeysDeep} from "../objects.js";
+
+import type {MarketsGraph} from "./buildMarketsAdjacencyGraph";
+import {MAX_EDGE_PATH_LENGTH} from "./constants.js";
+
+export function findSwapPathsBetweenTokens(graph: MarketsGraph): SwapPaths {
+  const swapRoutes: SwapPaths = {};
+
+  const allTokens = objectKeysDeep(graph, 1).sort();
+
+  for (const tokenAAddress of allTokens) {
+    swapRoutes[tokenAAddress] = {};
+
+    let empty = true;
+    for (const tokenBAddress of allTokens) {
+      if (tokenAAddress === tokenBAddress || swapRoutes[tokenBAddress]?.[tokenAAddress]) {
+        continue;
+      }
+
+      const result: Record<string, string[]> = {};
+
+      type SwapPathNode = {
+        currentToken: string;
+        tokenPath: string[];
+      };
+
+      const searchQueue: SwapPathNode[] = [
+        {
+          currentToken: tokenAAddress,
+          tokenPath: [tokenAAddress],
+        },
+      ];
+
+      while (searchQueue.length > 0) {
+        const { currentToken, tokenPath } = searchQueue.shift()!;
+
+        // Example
+        // ... -> ANIME -> USDC -> ANIME
+        // There is only one edge from ANIME to USDC, so we skip this path
+        // Because its almost always a guaranteed loss
+        if (tokenPath.length >= 3) {
+          const lastToken = tokenPath[tokenPath.length - 1];
+          const secondLastToken = tokenPath[tokenPath.length - 2];
+          const thirdLastToken = tokenPath[tokenPath.length - 3];
+
+          if (lastToken === thirdLastToken) {
+            const lastEdge = graph[lastToken]?.[secondLastToken];
+            if (lastEdge && lastEdge.length === 1) {
+              continue;
+            }
+          }
+        }
+
+        if (tokenPath.length >= 2) {
+          const lastToken = tokenPath[tokenPath.length - 1];
+          const secondLastToken = tokenPath[tokenPath.length - 2];
+
+          if (lastToken === secondLastToken) {
+            continue;
+          }
+        }
+
+        if (currentToken === tokenBAddress) {
+          const intermediateTokenPath = tokenPath.slice(1, -1);
+          const pathKey = intermediateTokenPath.join(",");
+          if (!result[pathKey]) {
+            result[pathKey] = intermediateTokenPath;
+          }
+        }
+
+        if (tokenPath.length >= MAX_EDGE_PATH_LENGTH + 1) {
+          continue;
+        }
+
+        for (const nextToken in graph[currentToken]) {
+          searchQueue.push({
+            currentToken: nextToken,
+            tokenPath: [...tokenPath, nextToken],
+          });
+        }
+      }
+
+      if (Object.keys(result).length > 0) {
+        empty = false;
+        swapRoutes[tokenAAddress][tokenBAddress] = Object.values(result);
+      }
+    }
+
+    if (empty) {
+      delete swapRoutes[tokenAAddress];
+    }
+  }
+
+  return swapRoutes;
+}
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/preparedSwapData.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/preparedSwapData.ts
new file mode 100644
index 00000000..96d8655c
--- /dev/null
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/preparedSwapData.ts
@@ -0,0 +1,43 @@
+import {MARKETS} from "../../configs/markets.js";
+import {SwapPaths} from "../../types/trade.js";
+
+import {buildMarketsAdjacencyGraph, MarketsGraph} from "./buildMarketsAdjacencyGraph.js";
+import {findReachableTokens} from "./findReachableTokens.js";
+import {findSwapPathsBetweenTokens} from "./findSwapPathsBetweenTokens.js";
+
+const MARKETS_ADJACENCY_GRAPH: {
+  [chainId: number]: MarketsGraph;
+} = {};
+
+for (const chainId in MARKETS) {
+  const markets = MARKETS[chainId];
+  const chainGraph = buildMarketsAdjacencyGraph(markets);
+
+  MARKETS_ADJACENCY_GRAPH[chainId] = chainGraph;
+}
+
+const TOKEN_SWAP_PATHS: {
+  [chainId: number]: SwapPaths;
+} = {};
+
+for (const chainId in MARKETS) {
+  const chainGraph = MARKETS_ADJACENCY_GRAPH[chainId];
+  const chainSwapPaths = findSwapPathsBetweenTokens(chainGraph);
+
+  TOKEN_SWAP_PATHS[chainId] = chainSwapPaths;
+}
+
+const REACHABLE_TOKENS: {
+  [chainId: number]: {
+    [token: string]: string[];
+  };
+} = {};
+
+for (const chainId in MARKETS) {
+  const chainGraph = MARKETS_ADJACENCY_GRAPH[chainId];
+  const chainReachableTokens = findReachableTokens(chainGraph);
+
+  REACHABLE_TOKENS[chainId] = chainReachableTokens;
+}
+
+export { MARKETS_ADJACENCY_GRAPH, REACHABLE_TOKENS, TOKEN_SWAP_PATHS };
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/swapPath.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/swapPath.ts
index 5260aaf8..fb950eaf 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/swapPath.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/swapPath.ts
@@ -1,72 +1,215 @@
-import { convertTokenAddress, getWrappedToken, NATIVE_TOKEN_ADDRESS } from "../../configs/tokens.js";
-import { MarketsInfoData } from "../../types/markets.js";
-import { FindSwapPath, MarketsGraph, SwapEstimator, SwapRoute } from "../../types/trade.js";
-import { findAllPaths, getBestSwapPath } from "./swapRouting.js";
-import { getSwapPathStats } from "./swapStats.js";
-import { getSwapPathComparator } from "./swapValues.js";
+import {MarketConfig, MARKETS} from "../../configs/markets.js";
+import {convertTokenAddress, getWrappedToken, NATIVE_TOKEN_ADDRESS} from "../../configs/tokens.js";
+import {GasLimitsConfig} from "../../types/fees.js";
+import {MarketsInfoData} from "../../types/markets.js";
+import {TokensData} from "../../types/tokens.js";
+import {FindSwapPath, SwapPathStats} from "../../types/trade.js";
+import {LRUCache} from "../LruCache.js";
+import {getIsMarketAvailableForExpressSwaps} from "../markets.js";
+
+import {buildMarketsAdjacencyGraph, MarketsGraph} from "./buildMarketsAdjacencyGraph.js";
+import {
+    createMarketEdgeLiquidityGetter,
+    createNaiveNetworkEstimator,
+    createNaiveSwapEstimator,
+    createSwapEstimator,
+    getBestSwapPath,
+    getMarketAdjacencyGraph,
+    getMaxLiquidityMarketSwapPathFromTokenSwapPaths,
+    getNaiveBestMarketSwapPathsFromTokenSwapPaths,
+    getTokenSwapPathsForTokenPairPrebuilt,
+    marketRouteToMarketEdges,
+} from "./swapRouting.js";
+import {getSwapPathStats} from "./swapStats.js";
 
 export const getWrappedAddress = (chainId: number, address: string | undefined) => {
   return address ? convertTokenAddress(chainId, address, "wrapped") : undefined;
 };
 
-export const findAllSwapPaths = (params: {
-  chainId: number;
-  fromTokenAddress: string | undefined;
-  toTokenAddress: string | undefined;
-  marketsInfoData: MarketsInfoData;
-  graph: MarketsGraph | undefined;
-  wrappedFromAddress: string | undefined;
-  wrappedToAddress: string | undefined;
-}) => {
-  const { chainId, fromTokenAddress, toTokenAddress, marketsInfoData, graph, wrappedFromAddress, wrappedToAddress } =
-    params;
+const DEBUG_MARKET_ADJACENCY_GRAPH_CACHE = new LRUCache<MarketsGraph>(100);
 
-  if (!marketsInfoData) return undefined;
-
-  const wrappedToken = getWrappedToken(chainId);
-  const isWrap = fromTokenAddress === NATIVE_TOKEN_ADDRESS && toTokenAddress === wrappedToken.address;
-  const isUnwrap = fromTokenAddress === wrappedToken.address && toTokenAddress === NATIVE_TOKEN_ADDRESS;
-  const isSameToken = fromTokenAddress === toTokenAddress;
-
-  if (!graph || !wrappedFromAddress || !wrappedToAddress || isWrap || isUnwrap || isSameToken) {
-    return undefined;
+function buildMarketAdjacencyGraph(chainId: number, disabledMarkets?: string[] | undefined) {
+  if (!disabledMarkets?.length) {
+    return getMarketAdjacencyGraph(chainId);
   }
 
-  return findAllPaths(marketsInfoData, graph, wrappedFromAddress, wrappedToAddress)?.sort((a, b) =>
-    b.liquidity - a.liquidity > 0 ? 1 : -1
+  const cacheKey = `${chainId}-${JSON.stringify(disabledMarkets)}`;
+
+  const cachedGraph = DEBUG_MARKET_ADJACENCY_GRAPH_CACHE.get(cacheKey);
+
+  if (cachedGraph) {
+    return cachedGraph;
+  }
+
+  const disabledMarketAddresses = disabledMarkets;
+
+  const strippedMarkets = Object.fromEntries(
+    Object.entries(MARKETS[chainId]).filter(([marketAddress]) => !disabledMarketAddresses.includes(marketAddress))
   );
-};
+
+  const graph = buildMarketsAdjacencyGraph(strippedMarkets as Record<string, MarketConfig>);
+
+  DEBUG_MARKET_ADJACENCY_GRAPH_CACHE.set(cacheKey, graph);
+
+  return graph;
+}
+
+const FALLBACK_FIND_SWAP_PATH: FindSwapPath = () => undefined;
 
 export const createFindSwapPath = (params: {
   chainId: number;
   fromTokenAddress: string | undefined;
   toTokenAddress: string | undefined;
   marketsInfoData: MarketsInfoData | undefined;
-  estimator: SwapEstimator | undefined;
-  allPaths: SwapRoute[] | undefined;
+  /**
+   * Pass gas limits to take into account gas costs in swap path
+   */
+  gasEstimationParams?:
+    | {
+        gasPrice: bigint;
+        gasLimits: GasLimitsConfig;
+        tokensData: TokensData;
+      }
+    | undefined;
+  isExpressFeeSwap: boolean | undefined;
+  disabledMarkets?: string[] | undefined;
+  manualPath?: string[] | undefined;
+  maxSwapPathLength?: number | undefined;
 }): FindSwapPath => {
-  const { chainId, fromTokenAddress, toTokenAddress, marketsInfoData, estimator, allPaths } = params;
+  const {
+    chainId,
+    fromTokenAddress,
+    toTokenAddress,
+    marketsInfoData,
+    disabledMarkets,
+    manualPath,
+    gasEstimationParams,
+    isExpressFeeSwap,
+    maxSwapPathLength,
+  } = params;
+  const wrappedFromAddress = getWrappedAddress(chainId, fromTokenAddress);
+  const wrappedToAddress = getWrappedAddress(chainId, toTokenAddress);
   const wrappedToken = getWrappedToken(chainId);
 
-  const findSwapPath: FindSwapPath = (usdIn: bigint, opts: { order?: ("liquidity" | "length")[] }) => {
-    if (!allPaths?.length || !estimator || !marketsInfoData || !fromTokenAddress) {
+  let tokenSwapPaths =
+    wrappedFromAddress && wrappedToAddress
+      ? getTokenSwapPathsForTokenPairPrebuilt(chainId, wrappedFromAddress, wrappedToAddress)
+      : [];
+
+  if (maxSwapPathLength) {
+    /**
+     * As tokenSwapPath contains what tokens can we between input and output token,
+     * restricting intermediate tokens to 0 would mean we filter out any non-direct market swaps,
+     * length of 1 would mean all 2-step swaps
+     */
+    const nonDirectPathLength = maxSwapPathLength - 1;
+    tokenSwapPaths = tokenSwapPaths.filter((path) => path.length <= nonDirectPathLength);
+  }
+
+  const finalDisabledMarkets = [...(disabledMarkets ?? [])];
+
+  if (isExpressFeeSwap) {
+    const expressSwapUnavailableMarkets = Object.values(marketsInfoData ?? {})
+      .filter((market) => !getIsMarketAvailableForExpressSwaps(market))
+      .map((market) => market.marketTokenAddress);
+
+    finalDisabledMarkets.push(...expressSwapUnavailableMarkets);
+  }
+
+  const isAtomicSwap = Boolean(isExpressFeeSwap);
+
+  const marketAdjacencyGraph = buildMarketAdjacencyGraph(chainId, finalDisabledMarkets);
+
+  const cache: Record<string, SwapPathStats | undefined> = {};
+
+  if (!marketsInfoData) {
+    return FALLBACK_FIND_SWAP_PATH;
+  }
+
+  const marketEdgeLiquidityGetter = createMarketEdgeLiquidityGetter(marketsInfoData);
+  const naiveEstimator = createNaiveSwapEstimator(marketsInfoData, isAtomicSwap);
+  const naiveNetworkEstimator = gasEstimationParams
+    ? createNaiveNetworkEstimator({
+        gasLimits: gasEstimationParams.gasLimits,
+        tokensData: gasEstimationParams.tokensData,
+        gasPrice: gasEstimationParams.gasPrice,
+        chainId,
+      })
+    : undefined;
+  const estimator = createSwapEstimator(marketsInfoData, isAtomicSwap);
+
+  const findSwapPath: FindSwapPath = (usdIn: bigint, opts?: { order?: ("liquidity" | "length")[] }) => {
+    if (tokenSwapPaths.length === 0 || !fromTokenAddress || !wrappedFromAddress || !wrappedToAddress) {
       return undefined;
     }
 
+    const cacheKey = `${usdIn}-${opts?.order?.join("-") || "none"}`;
+    if (cache[cacheKey]) {
+      return cache[cacheKey];
+    }
+
     let swapPath: string[] | undefined = undefined;
-    const sortedPaths = opts.order ? [...allPaths].sort(getSwapPathComparator(opts.order ?? [])) : allPaths;
 
-    if (opts.order) {
-      swapPath = sortedPaths[0].path;
+    if (manualPath !== undefined) {
+      swapPath = manualPath;
+    } else if (opts?.order || usdIn === 0n) {
+      const primaryOrder = opts?.order?.at(0) === "length" ? "length" : "liquidity";
+
+      if (!marketEdgeLiquidityGetter) {
+        swapPath = undefined;
+      } else {
+        let applicableTokenSwapPaths = tokenSwapPaths;
+
+        if (primaryOrder === "length") {
+          const shortestLength = Math.min(...tokenSwapPaths.map((path) => path.length));
+          applicableTokenSwapPaths = tokenSwapPaths.filter((path) => path.length === shortestLength);
+        }
+
+        const maxLiquidityPathInfo = getMaxLiquidityMarketSwapPathFromTokenSwapPaths({
+          graph: marketAdjacencyGraph,
+          tokenSwapPaths: applicableTokenSwapPaths,
+          tokenInAddress: wrappedFromAddress,
+          tokenOutAddress: wrappedToAddress,
+          getLiquidity: marketEdgeLiquidityGetter,
+        });
+
+        if (maxLiquidityPathInfo) {
+          swapPath = maxLiquidityPathInfo.path;
+        }
+      }
     } else {
-      swapPath = getBestSwapPath(allPaths, usdIn, estimator);
+      if (naiveEstimator) {
+        const naiveSwapRoutes = getNaiveBestMarketSwapPathsFromTokenSwapPaths({
+          graph: marketAdjacencyGraph,
+          tokenSwapPaths,
+          usdIn,
+          tokenInAddress: wrappedFromAddress,
+          tokenOutAddress: wrappedToAddress,
+          estimator: naiveEstimator,
+          networkEstimator: naiveNetworkEstimator,
+        });
+
+        if (naiveSwapRoutes?.length) {
+          const edges = naiveSwapRoutes.map((path) =>
+            marketRouteToMarketEdges(path, wrappedFromAddress, marketsInfoData)
+          );
+
+          swapPath = getBestSwapPath({
+            routes: edges,
+            usdIn,
+            estimator,
+            networkEstimator: naiveNetworkEstimator,
+          })?.map((edge) => edge.marketAddress);
+        }
+      }
     }
 
     if (!swapPath) {
+      cache[cacheKey] = undefined;
       return undefined;
     }
 
-    return getSwapPathStats({
+    let result: SwapPathStats | undefined = getSwapPathStats({
       marketsInfoData,
       swapPath,
       initialCollateralAddress: fromTokenAddress,
@@ -74,7 +217,12 @@ export const createFindSwapPath = (params: {
       shouldUnwrapNativeToken: toTokenAddress === NATIVE_TOKEN_ADDRESS,
       shouldApplyPriceImpact: true,
       usdIn,
+      isAtomicSwap,
     });
+
+    cache[cacheKey] = result;
+
+    return result;
   };
 
   return findSwapPath;
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/swapRouting.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/swapRouting.ts
index 5218b5b0..78b15aca 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/swapRouting.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/swapRouting.ts
@@ -1,122 +1,45 @@
-import { MarketInfo, MarketsInfoData } from "../../types/markets.js";
-import { MarketEdge, SwapEstimator, SwapRoute } from "../../types/trade.js";
-import { MarketsGraph } from "../../types/trade.js";
-import { bigMath } from "../bigmath.js";
-import { getAvailableUsdLiquidityForCollateral } from "../markets.js";
-import { getMaxSwapPathLiquidity, getSwapCapacityUsd, getSwapStats } from "./swapStats.js";
-import { SWAP_GRAPH_MAX_MARKETS_PER_TOKEN } from "../../configs/markets.js";
+import {maxUint256} from "viem";
 
-export function limitMarketsPerTokens(
-  markets: MarketInfo[],
-  limit: number = SWAP_GRAPH_MAX_MARKETS_PER_TOKEN
-): MarketInfo[] {
-  const marketsByTokens: { [token: string]: MarketInfo[] } = {};
+import {GasLimitsConfig} from "../../types/fees.js";
+import {MarketsInfoData} from "../../types/markets.js";
+import {TokensData} from "../../types/tokens.js";
+import {
+    MarketEdge,
+    MarketEdgeLiquidityGetter,
+    NaiveNetworkEstimator,
+    NaiveSwapEstimator,
+    SwapEstimator,
+    SwapPaths,
+} from "../../types/trade.js";
+import {bigMath} from "../../utils/bigmath.js";
+import {estimateOrderOraclePriceCount, getExecutionFee} from "../../utils/fees/index.js";
+import {getNaiveEstimatedGasBySwapCount} from "../../utils/fees/getNaiveEstimatedGasBySwapCount.js";
+import {getAvailableUsdLiquidityForCollateral, getTokenPoolType} from "../../utils/markets.js";
+import {bigintToNumber, PRECISION, PRECISION_DECIMALS} from "../../utils/numbers.js";
+import {getByKey} from "../../utils/objects.js";
+import {MarketsGraph} from "../../utils/swap/buildMarketsAdjacencyGraph.js";
+import {DEFAULT_NAIVE_TOP_PATHS_COUNT} from "../../utils/swap/constants.js";
+import {MARKETS_ADJACENCY_GRAPH, REACHABLE_TOKENS, TOKEN_SWAP_PATHS} from "../../utils/swap/preparedSwapData.js";
 
-  for (const market of markets) {
-    if (market.isSameCollaterals || market.isDisabled) {
-      continue;
-    }
+import {getSwapStats} from "./swapStats.js";
 
-    const { longTokenAddress, shortTokenAddress } = market;
-
-    marketsByTokens[longTokenAddress] = marketsByTokens[longTokenAddress] || [];
-    marketsByTokens[longTokenAddress].push(market);
-
-    marketsByTokens[shortTokenAddress] = marketsByTokens[shortTokenAddress] || [];
-    marketsByTokens[shortTokenAddress].push(market);
-  }
-
-  const resultMarkets: { [marketAddress: string]: MarketInfo } = {};
-
-  const tokenAddresses = Object.keys(marketsByTokens);
-
-  for (const tokenAddress of tokenAddresses) {
-    const markets = marketsByTokens[tokenAddress];
-
-    const sortedMarkets = markets.sort((m1, m2) => {
-      const liq1 = getAvailableUsdLiquidityForCollateral(m1, m1.longTokenAddress === tokenAddress);
-      const cap1 = getSwapCapacityUsd(m1, m1.longTokenAddress === tokenAddress);
-
-      const limit1 = bigMath.min(liq1, cap1);
-
-      const liq2 = getAvailableUsdLiquidityForCollateral(m2, m2.longTokenAddress === tokenAddress);
-      const cap2 = getSwapCapacityUsd(m2, m2.longTokenAddress === tokenAddress);
-
-      const limit2 = bigMath.min(liq2, cap2);
-
-      return Number(limit2 - limit1);
-    });
-
-    let marketsPerTokenCount = 0;
-
-    for (const market of sortedMarkets) {
-      if (marketsPerTokenCount >= limit) {
-        break;
-      }
-
-      if (resultMarkets[market.marketTokenAddress]) {
-        marketsPerTokenCount++;
-        continue;
-      }
-
-      marketsPerTokenCount++;
-      resultMarkets[market.marketTokenAddress] = market;
-    }
-  }
-
-  return Object.values(resultMarkets);
-}
-
-export function getMarketsGraph(markets: MarketInfo[]): MarketsGraph {
-  const graph: MarketsGraph = {
-    abjacencyList: {},
-    edges: [],
-  };
-
-  const limitedMarkets = limitMarketsPerTokens(markets);
-
-  for (const market of limitedMarkets) {
-    const { longTokenAddress, shortTokenAddress, marketTokenAddress, isSameCollaterals, isDisabled } = market;
-
-    if (isSameCollaterals || isDisabled) {
-      continue;
-    }
-
-    const longShortEdge: MarketEdge = {
-      marketInfo: market,
-      marketAddress: marketTokenAddress,
-      from: longTokenAddress,
-      to: shortTokenAddress,
-    };
-
-    const shortLongEdge: MarketEdge = {
-      marketInfo: market,
-      marketAddress: marketTokenAddress,
-      from: shortTokenAddress,
-      to: longTokenAddress,
-    };
-
-    graph.abjacencyList[longTokenAddress] = graph.abjacencyList[longTokenAddress] || [];
-    graph.abjacencyList[longTokenAddress].push(longShortEdge);
-    graph.abjacencyList[shortTokenAddress] = graph.abjacencyList[shortTokenAddress] || [];
-    graph.abjacencyList[shortTokenAddress].push(shortLongEdge);
-
-    graph.edges.push(longShortEdge, shortLongEdge);
-  }
-
-  return graph;
-}
-
-export const createSwapEstimator = (marketsInfoData: MarketsInfoData): SwapEstimator => {
+export const createSwapEstimator = (marketsInfoData: MarketsInfoData, isAtomicSwap: boolean): SwapEstimator => {
   return (e: MarketEdge, usdIn: bigint) => {
     const marketInfo = marketsInfoData[e.marketAddress];
 
+    if (!marketInfo || marketInfo.isDisabled) {
+      return {
+        usdOut: 0n,
+      };
+    }
+
     const swapStats = getSwapStats({
       marketInfo,
       usdIn,
       tokenInAddress: e.from,
       tokenOutAddress: e.to,
       shouldApplyPriceImpact: true,
+      isAtomicSwap,
     });
 
     const isOutLiquidity = swapStats?.isOutLiquidity;
@@ -135,23 +58,111 @@ export const createSwapEstimator = (marketsInfoData: MarketsInfoData): SwapEstim
   };
 };
 
-export function getBestSwapPath(routes: SwapRoute[], usdIn: bigint, estimator: SwapEstimator) {
+export const createMarketEdgeLiquidityGetter = (marketsInfoData: MarketsInfoData): MarketEdgeLiquidityGetter => {
+  return (e: MarketEdge) => {
+    const marketInfo = getByKey(marketsInfoData, e.marketAddress);
+
+    if (!marketInfo || marketInfo.isDisabled) {
+      return 0n;
+    }
+
+    const isTokenOutLong = getTokenPoolType(marketInfo, e.to) === "long";
+    const liquidity = getAvailableUsdLiquidityForCollateral(marketInfo, isTokenOutLong);
+
+    return liquidity;
+  };
+};
+
+export const createNaiveSwapEstimator = (
+  marketsInfoData: MarketsInfoData,
+  isAtomicSwap: boolean
+): NaiveSwapEstimator => {
+  return (e: MarketEdge, usdIn: bigint) => {
+    let marketInfo = marketsInfoData[e.marketAddress];
+
+    if (marketInfo === undefined || marketInfo.isDisabled) {
+      return { swapYield: 0 };
+    }
+
+    const swapStats = getSwapStats({
+      marketInfo,
+      usdIn,
+      tokenInAddress: e.from,
+      tokenOutAddress: e.to,
+      shouldApplyPriceImpact: true,
+      isAtomicSwap,
+    });
+
+    const usdOut = swapStats?.usdOut;
+
+    if (usdOut === undefined || usdOut === 0n || swapStats.isOutCapacity || swapStats.isOutLiquidity) {
+      return { swapYield: 0 };
+    }
+
+    const swapYield = bigintToNumber((usdOut * PRECISION) / usdIn, PRECISION_DECIMALS);
+
+    return { swapYield };
+  };
+};
+
+export const createNaiveNetworkEstimator = ({
+  gasLimits,
+  tokensData,
+  gasPrice,
+  chainId,
+}: {
+  gasLimits: GasLimitsConfig;
+  tokensData: TokensData;
+  gasPrice: bigint;
+  chainId: number;
+}): NaiveNetworkEstimator => {
+  return (usdIn: bigint, swapsCount: number) => {
+    const estimatedGas = getNaiveEstimatedGasBySwapCount(gasLimits.singleSwap, swapsCount);
+    if (estimatedGas === null || estimatedGas === undefined) return { networkYield: 1.0, usdOut: usdIn };
+
+    const oraclePriceCount = estimateOrderOraclePriceCount(swapsCount);
+
+    const feeUsd = getExecutionFee(chainId, gasLimits, tokensData, estimatedGas, gasPrice, oraclePriceCount)?.feeUsd;
+    if (feeUsd === undefined) return { networkYield: 1.0, usdOut: usdIn };
+
+    const networkYield = bigintToNumber(bigMath.mulDiv(usdIn, PRECISION, usdIn + feeUsd), PRECISION_DECIMALS);
+
+    return { networkYield, usdOut: usdIn - feeUsd };
+  };
+};
+
+export function getBestSwapPath({
+  routes,
+  usdIn,
+  estimator,
+  networkEstimator,
+}: {
+  routes: MarketEdge[][];
+  usdIn: bigint;
+  estimator: SwapEstimator;
+  networkEstimator?: NaiveNetworkEstimator;
+}): MarketEdge[] | undefined {
   if (routes.length === 0) {
     return undefined;
   }
 
-  let bestPath = routes[0].path;
+  let bestRoute = routes[0];
   let bestUsdOut = 0n;
 
   for (const route of routes) {
     try {
-      const pathUsdOut = route.edges.reduce((prevUsdOut, edge) => {
+      let pathUsdOut = route.reduce((prevUsdOut, edge) => {
         const { usdOut } = estimator(edge, prevUsdOut);
         return usdOut;
       }, usdIn);
 
+      if (networkEstimator) {
+        const { usdOut } = networkEstimator(pathUsdOut, route.length);
+        pathUsdOut = usdOut;
+      }
+
       if (pathUsdOut > bestUsdOut) {
-        bestPath = route.path;
+        bestRoute = route;
         bestUsdOut = pathUsdOut;
       }
     } catch (e) {
@@ -159,57 +170,433 @@ export function getBestSwapPath(routes: SwapRoute[], usdIn: bigint, estimator: S
     }
   }
 
-  return bestPath;
+  return bestRoute;
 }
 
-export function findAllPaths(
-  marketsInfoData: MarketsInfoData,
-  graph: MarketsGraph,
-  from: string,
-  to: string,
-  maxDepth = 3
-): SwapRoute[] | undefined {
-  const routes: SwapRoute[] = [];
+export function getNaiveBestMarketSwapPathsFromTokenSwapPaths({
+  graph,
+  tokenSwapPaths,
+  usdIn,
+  tokenInAddress,
+  tokenOutAddress,
+  estimator,
+  topPathsCount = DEFAULT_NAIVE_TOP_PATHS_COUNT,
+  networkEstimator,
+}: {
+  graph: MarketsGraph;
+  tokenSwapPaths: string[][];
+  usdIn: bigint;
+  tokenInAddress: string;
+  tokenOutAddress: string;
+  estimator: NaiveSwapEstimator;
+  topPathsCount?: number;
+  networkEstimator?: NaiveNetworkEstimator;
+}): string[][] {
+  // This seems to be true, because for any path if we have performed swaps to and from token
+  // The best markets sequence is the same
+  const cachedBestMarketForTokenEdge: Record<
+    // Key: tokenHopFromAddress-tokenHopToAddress-count
+    string,
+    {
+      marketAddress: string;
+      swapYield: number;
+    }
+  > = {};
 
-  const edges = graph.abjacencyList[from];
+  const calculatedCache: Record<
+    // From token address
+    string,
+    Record<
+      // To token address
+      string,
+      Record<
+        // Market address
+        string,
+        number
+      >
+    >
+  > = {};
 
-  if (!edges?.length) {
+  const topPaths: {
+    marketPath: string[];
+    swapYield: number;
+  }[] = [];
+
+  const networkYieldCache: Record<number, number> = {};
+
+  for (const pathType of tokenSwapPaths) {
+    const marketPath: string[] = [];
+    let pathTypeSwapYield = 1;
+    let bad = false;
+
+    // Just how many times we have swapped from token A to token B
+    const tokenSwapCounter: Record<
+      // From token address
+      string,
+      Record<
+        // To token address
+        string,
+        number
+      >
+    > = {};
+
+    for (let hopIndex = 0; hopIndex <= pathType.length; hopIndex++) {
+      const tokenHopFromAddress = hopIndex === 0 ? tokenInAddress : pathType[hopIndex - 1];
+      const tokenHopToAddress = hopIndex === pathType.length ? tokenOutAddress : pathType[hopIndex];
+
+      // prevTokenAddress -> tokenAddress
+      // get all markets for prevTokenAddress -> tokenAddress
+      const marketAddresses = getMarketsForTokenPair(graph, tokenHopFromAddress, tokenHopToAddress);
+
+      if (marketAddresses.length === 0) {
+        bad = true;
+        break;
+      }
+
+      const tokenSwapCount = tokenSwapCounter[tokenHopFromAddress]?.[tokenHopToAddress] || 0;
+
+      const key = `${tokenHopFromAddress}-${tokenHopToAddress}-${tokenSwapCount}`;
+
+      let bestMarketInfo:
+        | {
+            marketAddress: string;
+            swapYield: number;
+          }
+        | undefined = cachedBestMarketForTokenEdge[key];
+
+      if (!bestMarketInfo) {
+        calculatedCache[tokenHopFromAddress] = calculatedCache[tokenHopFromAddress] || {};
+        calculatedCache[tokenHopFromAddress][tokenHopToAddress] =
+          calculatedCache[tokenHopFromAddress][tokenHopToAddress] || {};
+
+        bestMarketInfo = getBestMarketForTokenEdge({
+          marketAddresses,
+          usdIn,
+          tokenInAddress: tokenHopFromAddress,
+          tokenOutAddress: tokenHopToAddress,
+          estimator,
+          marketPath,
+          calculatedCache: calculatedCache[tokenHopFromAddress][tokenHopToAddress],
+        });
+
+        if (!bestMarketInfo) {
+          bad = true;
+          break;
+        }
+
+        cachedBestMarketForTokenEdge[key] = bestMarketInfo;
+      }
+
+      if (bestMarketInfo.swapYield === 0) {
+        bad = true;
+        break;
+      }
+
+      pathTypeSwapYield *= bestMarketInfo.swapYield;
+      marketPath.push(bestMarketInfo.marketAddress);
+
+      tokenSwapCounter[tokenHopFromAddress] = tokenSwapCounter[tokenHopFromAddress] || {};
+      tokenSwapCounter[tokenHopFromAddress][tokenHopToAddress] =
+        (tokenSwapCounter[tokenHopFromAddress][tokenHopToAddress] || 0) + 1;
+    }
+
+    if (bad) {
+      continue;
+    }
+
+    if (topPaths.length < topPathsCount) {
+      topPaths.push({ marketPath: marketPath, swapYield: pathTypeSwapYield });
+    } else {
+      let adjustedPathTypeSwapYield = pathTypeSwapYield;
+
+      if (networkEstimator) {
+        let networkYield = networkYieldCache[marketPath.length];
+
+        if (networkYield === undefined) {
+          networkYield = networkEstimator(usdIn, marketPath.length).networkYield;
+
+          networkYieldCache[marketPath.length] = networkYield;
+        }
+
+        adjustedPathTypeSwapYield = adjustedPathTypeSwapYield * networkYield;
+      }
+
+      //  if yield is greater than any of the top paths, replace the one with the lowest yield
+      let minSwapYield = topPaths[0].swapYield;
+      let minSwapYieldIndex = 0;
+      for (let i = 1; i < topPaths.length; i++) {
+        if (topPaths[i].swapYield < minSwapYield) {
+          minSwapYield = topPaths[i].swapYield;
+          minSwapYieldIndex = i;
+        }
+      }
+      if (adjustedPathTypeSwapYield > minSwapYield) {
+        topPaths[minSwapYieldIndex] = { marketPath: marketPath, swapYield: adjustedPathTypeSwapYield };
+      }
+    }
+  }
+
+  return topPaths.map((p) => p.marketPath);
+}
+
+export function getMarketsForTokenPair(graph: MarketsGraph, tokenAAddress: string, tokenBAddress: string): string[] {
+  if (graph[tokenAAddress]?.[tokenBAddress]) {
+    return graph[tokenAAddress][tokenBAddress];
+  }
+
+  if (graph[tokenBAddress]?.[tokenAAddress]) {
+    return graph[tokenBAddress][tokenAAddress];
+  }
+
+  return [];
+}
+
+export function getBestMarketForTokenEdge({
+  marketAddresses,
+  usdIn,
+  tokenInAddress,
+  tokenOutAddress,
+  estimator,
+  marketPath,
+  calculatedCache,
+}: {
+  marketAddresses: string[];
+  usdIn: bigint;
+  tokenInAddress: string;
+  tokenOutAddress: string;
+  estimator: NaiveSwapEstimator;
+  marketPath?: string[];
+  calculatedCache?: Record<
+    // Key: market address
+    string,
+    number
+  >;
+}):
+  | {
+      marketAddress: string;
+      swapYield: number;
+    }
+  | undefined {
+  let bestMarketAddress = marketAddresses[0];
+  let bestYield = 0;
+  let found = false;
+
+  for (const marketAddress of marketAddresses) {
+    if (marketPath && marketPath.includes(marketAddress)) {
+      continue;
+    }
+
+    let swapYield: number | undefined = undefined;
+
+    const key = marketAddress;
+    if (calculatedCache) {
+      swapYield = calculatedCache[key];
+    }
+
+    if (swapYield === undefined) {
+      swapYield = estimator(
+        {
+          marketAddress,
+          from: tokenInAddress,
+          to: tokenOutAddress,
+        },
+        usdIn
+      ).swapYield;
+
+      if (calculatedCache) {
+        calculatedCache[key] = swapYield;
+      }
+    }
+
+    if (swapYield > bestYield) {
+      bestYield = swapYield;
+      bestMarketAddress = marketAddress;
+      found = true;
+    }
+  }
+
+  if (!found) {
     return undefined;
   }
 
-  for (const e of edges) {
-    dfs(e, [], [], {});
-  }
-
-  function dfs(edge: MarketEdge, path: string[], pathEdges: MarketEdge[], visited: { [edgeId: string]: boolean }) {
-    // avoid too deep paths and cycles
-    if (path.length >= maxDepth || visited[edge.marketAddress]) {
-      return;
-    }
-
-    visited[edge.marketAddress] = true;
-    pathEdges.push(edge);
-    path.push(edge.marketAddress);
-
-    if (edge.to === to) {
-      routes.push({
-        edges: pathEdges,
-        path: path,
-        liquidity: getMaxSwapPathLiquidity({ marketsInfoData, swapPath: path, initialCollateralAddress: from }),
-      });
-      return;
-    }
-
-    const edges = graph.abjacencyList[edge.to];
-
-    if (!edges?.length) {
-      return;
-    }
-
-    for (const e of edges) {
-      dfs(e, [...path], [...pathEdges], { ...visited });
-    }
-  }
-
-  return routes;
+  return {
+    marketAddress: bestMarketAddress,
+    swapYield: bestYield,
+  };
+}
+
+export function marketRouteToMarketEdges(
+  marketPath: string[],
+  from: string,
+  marketsInfoData: MarketsInfoData
+): MarketEdge[] {
+  let edges: MarketEdge[] = [];
+
+  for (let i = 0; i < marketPath.length; i++) {
+    const currentFrom = i === 0 ? from : edges[i - 1].to;
+    const currentTo =
+      marketsInfoData[marketPath[i]].longTokenAddress === currentFrom
+        ? marketsInfoData[marketPath[i]].shortTokenAddress
+        : marketsInfoData[marketPath[i]].longTokenAddress;
+
+    edges.push({ from: currentFrom, to: currentTo, marketAddress: marketPath[i] });
+  }
+
+  return edges;
+}
+
+export function getTokenSwapPathsForTokenPair(
+  tokenSwapPaths: SwapPaths,
+  tokenAAddress: string,
+  tokenBAddress: string
+): string[][] {
+  if (tokenSwapPaths[tokenAAddress]?.[tokenBAddress]) {
+    return tokenSwapPaths[tokenAAddress][tokenBAddress];
+  }
+
+  if (tokenSwapPaths[tokenBAddress]?.[tokenAAddress]) {
+    return tokenSwapPaths[tokenBAddress][tokenAAddress].map((route) => [...route].reverse());
+  }
+
+  return [];
+}
+
+export function getTokenSwapPathsForTokenPairPrebuilt(chainId: number, from: string, to: string): string[][] {
+  return getTokenSwapPathsForTokenPair(TOKEN_SWAP_PATHS[chainId], from, to);
+}
+
+export function getMarketAdjacencyGraph(chainId: number): MarketsGraph {
+  return MARKETS_ADJACENCY_GRAPH[chainId];
+}
+
+export function findAllReachableTokens(chainId: number, from: string): string[] {
+  return REACHABLE_TOKENS[chainId][from];
+}
+
+export function getMaxLiquidityMarketSwapPathFromTokenSwapPaths({
+  graph,
+  tokenSwapPaths,
+  tokenInAddress,
+  tokenOutAddress,
+  getLiquidity,
+}: {
+  graph: MarketsGraph;
+  tokenSwapPaths: string[][];
+  tokenInAddress: string;
+  tokenOutAddress: string;
+  getLiquidity: MarketEdgeLiquidityGetter;
+}): { path: string[]; liquidity: bigint } | undefined {
+  // go through all edges and find best yield market for it
+
+  const cachedMaxLiquidityMarketForTokenEdge: Record<
+    string,
+    Record<
+      string,
+      {
+        marketAddress: string;
+        liquidity: bigint;
+      }
+    >
+  > = {};
+
+  let bestMarketPath: string[] | undefined = undefined;
+  let bestLiquidity = 0n;
+
+  for (const pathType of tokenSwapPaths) {
+    let bad = false;
+    let bestMarketPathForPathType: string[] = [];
+    let pathTypeBestLiquidity = maxUint256;
+
+    for (let hopIndex = 0; hopIndex <= pathType.length; hopIndex++) {
+      const tokenFromAddress = hopIndex === 0 ? tokenInAddress : pathType[hopIndex - 1];
+      const tokenToAddress = hopIndex === pathType.length ? tokenOutAddress : pathType[hopIndex];
+
+      // prevTokenAddress -> tokenAddress
+      // get all markets for prevTokenAddress -> tokenAddress
+      const markets = getMarketsForTokenPair(graph, tokenFromAddress, tokenToAddress);
+
+      if (markets.length === 0) {
+        bad = true;
+        break;
+      }
+
+      let bestMarketInfo:
+        | {
+            marketAddress: string;
+            liquidity: bigint;
+          }
+        | undefined = cachedMaxLiquidityMarketForTokenEdge[tokenFromAddress]?.[tokenToAddress];
+
+      if (!bestMarketInfo) {
+        bestMarketInfo = getMaxLiquidityMarketForTokenEdge({
+          markets,
+          tokenInAddress,
+          tokenOutAddress,
+          getLiquidity,
+        });
+
+        cachedMaxLiquidityMarketForTokenEdge[tokenFromAddress] =
+          cachedMaxLiquidityMarketForTokenEdge[tokenFromAddress] || {};
+        cachedMaxLiquidityMarketForTokenEdge[tokenFromAddress][tokenToAddress] = bestMarketInfo;
+      }
+
+      bestMarketPathForPathType.push(bestMarketInfo.marketAddress);
+
+      if (bestMarketInfo.liquidity < pathTypeBestLiquidity) {
+        pathTypeBestLiquidity = bestMarketInfo.liquidity;
+      }
+
+      if (pathTypeBestLiquidity < bestLiquidity) {
+        bad = true;
+        break;
+      }
+    }
+
+    if (bad) {
+      continue;
+    }
+
+    if (pathTypeBestLiquidity > bestLiquidity) {
+      bestLiquidity = pathTypeBestLiquidity;
+      bestMarketPath = bestMarketPathForPathType;
+    }
+  }
+
+  return bestMarketPath ? { path: bestMarketPath, liquidity: bestLiquidity } : undefined;
+}
+
+export function getMaxLiquidityMarketForTokenEdge({
+  markets,
+  tokenInAddress,
+  tokenOutAddress,
+  getLiquidity,
+}: {
+  markets: string[];
+  tokenInAddress: string;
+  tokenOutAddress: string;
+  getLiquidity: MarketEdgeLiquidityGetter;
+}): {
+  marketAddress: string;
+  liquidity: bigint;
+} {
+  let bestMarketAddress = markets[0];
+  let bestLiquidity = 0n;
+
+  for (const market of markets) {
+    const liquidity = getLiquidity({
+      marketAddress: market,
+      from: tokenInAddress,
+      to: tokenOutAddress,
+    });
+
+    if (liquidity > bestLiquidity) {
+      bestLiquidity = liquidity;
+      bestMarketAddress = market;
+    }
+  }
+
+  return {
+    marketAddress: bestMarketAddress,
+    liquidity: bestLiquidity,
+  };
 }
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/swapStats.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/swapStats.ts
index 2f5b7d78..6dfbb5a3 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/swapStats.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/swapStats.ts
@@ -1,11 +1,14 @@
-import { NATIVE_TOKEN_ADDRESS } from "../../configs/tokens.js";
-import { MarketInfo, MarketsInfoData } from "../../types/markets.js";
-import { getByKey } from "../objects.js";
-import { getAvailableUsdLiquidityForCollateral, getOppositeCollateral, getTokenPoolType } from "../markets.js";
-import { SwapPathStats, SwapStats } from "../../types/trade.js";
-import { convertToTokenAmount, convertToUsd, getMidPrice } from "../tokens.js";
-import { applySwapImpactWithCap, getPriceImpactForSwap, getSwapFee } from "../fees/index.js";
-import { maxUint256 } from "viem";
+import {maxUint256} from "viem";
+
+import {NATIVE_TOKEN_ADDRESS} from "../../configs/tokens.js";
+import {MarketInfo, MarketsInfoData} from "../../types/markets.js";
+import {SwapPathStats, SwapStats} from "../../types/trade.js";
+
+import {getByKey} from "../objects.js";
+import {convertToTokenAmount, convertToUsd, getMidPrice} from "../tokens.js";
+import {getAvailableUsdLiquidityForCollateral, getOppositeCollateral, getTokenPoolType} from "../markets.js";
+import {getSwapFee} from "../fees/index.js";
+import {applySwapImpactWithCap, getPriceImpactForSwap} from "../fees/priceImpact.js";
 
 export function getSwapCapacityUsd(marketInfo: MarketInfo, isLong: boolean) {
   const poolAmount = isLong ? marketInfo.longPoolAmount : marketInfo.shortPoolAmount;
@@ -118,6 +121,7 @@ export function getSwapPathStats(p: {
   usdIn: bigint;
   shouldUnwrapNativeToken: boolean;
   shouldApplyPriceImpact: boolean;
+  isAtomicSwap: boolean;
 }): SwapPathStats | undefined {
   const {
     marketsInfoData,
@@ -127,6 +131,7 @@ export function getSwapPathStats(p: {
     shouldUnwrapNativeToken,
     shouldApplyPriceImpact,
     wrappedNativeTokenAddress,
+    isAtomicSwap,
   } = p;
 
   if (swapPath.length === 0) {
@@ -147,7 +152,17 @@ export function getSwapPathStats(p: {
     const marketAddress = swapPath[i];
     const marketInfo = marketsInfoData[marketAddress];
 
-    tokenOutAddress = getOppositeCollateral(marketInfo, tokenInAddress)!.address;
+    if (!marketInfo) {
+      return undefined;
+    }
+
+    const nextTokenOutAddress = getOppositeCollateral(marketInfo, tokenInAddress)?.address;
+
+    if (!nextTokenOutAddress) {
+      return undefined;
+    }
+
+    tokenOutAddress = nextTokenOutAddress;
 
     if (i === swapPath.length - 1 && shouldUnwrapNativeToken && tokenOutAddress === wrappedNativeTokenAddress) {
       tokenOutAddress = NATIVE_TOKEN_ADDRESS;
@@ -159,6 +174,7 @@ export function getSwapPathStats(p: {
       tokenOutAddress,
       usdIn: usdOut,
       shouldApplyPriceImpact,
+      isAtomicSwap,
     });
 
     tokenInAddress = swapStep.tokenOutAddress;
@@ -178,7 +194,7 @@ export function getSwapPathStats(p: {
 
   return {
     swapPath,
-    tokenInAddress,
+    tokenInAddress: initialCollateralAddress,
     tokenOutAddress,
     targetMarketAddress,
     swapSteps,
@@ -196,8 +212,9 @@ export function getSwapStats(p: {
   tokenOutAddress: string;
   usdIn: bigint;
   shouldApplyPriceImpact: boolean;
+  isAtomicSwap: boolean;
 }): SwapStats {
-  const { marketInfo, tokenInAddress, tokenOutAddress, usdIn, shouldApplyPriceImpact } = p;
+  const { marketInfo, tokenInAddress, tokenOutAddress, usdIn, shouldApplyPriceImpact, isAtomicSwap } = p;
 
   const isWrap = tokenInAddress === NATIVE_TOKEN_ADDRESS;
   const isUnwrap = tokenOutAddress === NATIVE_TOKEN_ADDRESS;
@@ -214,10 +231,19 @@ export function getSwapStats(p: {
   const amountIn = convertToTokenAmount(usdIn, tokenIn.decimals, priceIn)!;
 
   let priceImpactDeltaUsd: bigint;
+  let balanceWasImproved: boolean;
 
   try {
-    priceImpactDeltaUsd = getPriceImpactForSwap(marketInfo, tokenIn, tokenOut, usdIn, usdIn * -1n);
+    const priceImpactValues = getPriceImpactForSwap(marketInfo, tokenIn, tokenOut, usdIn, usdIn * -1n);
+    priceImpactDeltaUsd = priceImpactValues.priceImpactDeltaUsd;
+    balanceWasImproved = priceImpactValues.balanceWasImproved;
   } catch (e) {
+    // Approximate if the market would be out of capacity
+    const capacityUsd = getSwapCapacityUsd(marketInfo, getTokenPoolType(marketInfo, tokenInAddress) === "long");
+    const swapFeeUsd = getSwapFee(marketInfo, usdIn, false, isAtomicSwap);
+    const usdInAfterFees = usdIn - swapFeeUsd;
+    const isOutCapacity = capacityUsd < usdInAfterFees;
+
     return {
       swapFeeUsd: 0n,
       swapFeeAmount: 0n,
@@ -233,11 +259,12 @@ export function getSwapStats(p: {
       amountOut: 0n,
       usdOut: 0n,
       isOutLiquidity: true,
+      isOutCapacity,
     };
   }
 
-  const swapFeeAmount = getSwapFee(marketInfo, amountIn, priceImpactDeltaUsd > 0);
-  const swapFeeUsd = getSwapFee(marketInfo, usdIn, priceImpactDeltaUsd > 0);
+  const swapFeeAmount = getSwapFee(marketInfo, amountIn, balanceWasImproved, isAtomicSwap);
+  const swapFeeUsd = getSwapFee(marketInfo, usdIn, balanceWasImproved, isAtomicSwap);
 
   const amountInAfterFees = amountIn - swapFeeAmount;
   const usdInAfterFees = usdIn - swapFeeUsd;
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/swapValues.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/swapValues.ts
index d6deabdc..b231d755 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/swapValues.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/swap/swapValues.ts
@@ -1,13 +1,22 @@
-import type {FindSwapPath, SwapAmounts} from "../../types/trade.js";
-import {SwapRoute} from "../../types/trade.js";
-import type {TokenData, TokensRatio} from "../../types/tokens.js";
-
 import {BASIS_POINTS_DIVISOR_BIGINT} from "../../configs/factors.js";
+import {MarketsInfoData} from "../../types/markets.js";
+import {InternalSwapStrategy, NoSwapStrategy} from "../../types/swapStrategy.js";
+import type {TokenData, TokensRatio} from "../../types/tokens.js";
+import type {FindSwapPath, SwapAmounts, SwapOptimizationOrderArray} from "../../types/trade.js";
+import {ExternalSwapQuoteParams, SwapRoute} from "../../types/trade.js";
+import {bigMath} from "../../utils/bigmath.js";
+import {getTotalSwapVolumeFromSwapStats} from "../../utils/fees/index.js";
+import {applyFactor} from "../../utils/numbers.js";
+import {
+    convertToTokenAmount,
+    convertToUsd,
+    getAmountByRatio,
+    getIsEquivalentTokens,
+    getIsStake,
+    getIsUnstake,
+} from "../../utils/tokens.js";
 
-import {applyFactor} from "../numbers.js";
-import {bigMath} from "../bigmath.js";
-import {convertToTokenAmount, convertToUsd, getAmountByRatio, getIsEquivalentTokens} from "../tokens.js";
-import {getTotalSwapVolumeFromSwapStats} from "../fees/index.js";
+import {buildReverseSwapStrategy, buildSwapStrategy} from "./buildSwapStrategy.js";
 
 export function getSwapAmountsByFromValue(p: {
   tokenIn: TokenData;
@@ -15,7 +24,220 @@ export function getSwapAmountsByFromValue(p: {
   amountIn: bigint;
   triggerRatio?: TokensRatio;
   isLimit: boolean;
-  swapOptimizationOrder?: Parameters<FindSwapPath>[1]["order"];
+  swapOptimizationOrder?: SwapOptimizationOrderArray;
+  allowedSwapSlippageBps?: bigint;
+  uiFeeFactor: bigint;
+  marketsInfoData: MarketsInfoData | undefined;
+  chainId: number;
+  externalSwapQuoteParams: ExternalSwapQuoteParams | undefined;
+  findSwapPath: FindSwapPath;
+}): SwapAmounts {
+  const {
+    tokenIn,
+    tokenOut,
+    amountIn,
+    triggerRatio,
+    isLimit,
+    swapOptimizationOrder,
+    uiFeeFactor,
+    allowedSwapSlippageBps,
+    marketsInfoData,
+    chainId,
+    externalSwapQuoteParams,
+  } = p;
+
+  if (!externalSwapQuoteParams) {
+    return getSwapAmountsByFromValueDefault(p);
+  }
+
+  const swapStrategy = buildSwapStrategy({
+    amountIn,
+    tokenIn,
+    tokenOut,
+    marketsInfoData,
+    chainId,
+    swapOptimizationOrder,
+    externalSwapQuoteParams,
+  });
+
+  const swapPathStats = swapStrategy.swapPathStats;
+
+  const totalSwapVolume = getTotalSwapVolumeFromSwapStats(swapPathStats?.swapSteps);
+  const swapUiFeeUsd = applyFactor(totalSwapVolume, uiFeeFactor);
+  const swapUiFeeAmount = convertToTokenAmount(swapUiFeeUsd, tokenOut.decimals, swapStrategy.priceOut)!;
+
+  const defaultAmounts: SwapAmounts = {
+    amountIn,
+    usdIn: swapStrategy.usdIn,
+    amountOut: swapStrategy.amountOut,
+    usdOut: swapStrategy.usdOut,
+    minOutputAmount: swapStrategy.amountOut,
+    priceIn: swapStrategy.priceIn,
+    priceOut: swapStrategy.priceOut,
+    swapStrategy,
+  };
+
+  let amountOut = swapStrategy.amountOut;
+  let usdOut = swapStrategy.usdOut;
+  let minOutputAmount = 0n;
+
+  if (isLimit) {
+    if (!triggerRatio) {
+      return defaultAmounts;
+    }
+
+    amountOut = getAmountByRatio({
+      fromToken: tokenIn,
+      toToken: tokenOut,
+      fromTokenAmount: amountIn,
+      ratio: triggerRatio.ratio,
+      shouldInvertRatio: triggerRatio.largestToken.address === tokenOut.address,
+      allowedSwapSlippageBps,
+    });
+
+    usdOut = convertToUsd(amountOut, tokenOut.decimals, swapStrategy.priceOut)!;
+    amountOut = convertToTokenAmount(usdOut, tokenOut.decimals, swapStrategy.priceOut)!;
+    minOutputAmount = amountOut;
+  } else {
+    usdOut = swapStrategy.usdOut - swapUiFeeUsd;
+    amountOut = swapStrategy.amountOut - swapUiFeeAmount;
+    minOutputAmount = amountOut;
+  }
+
+  if (amountOut < 0) {
+    amountOut = 0n;
+    usdOut = 0n;
+    minOutputAmount = 0n;
+  }
+
+  return {
+    amountIn,
+    usdIn: swapStrategy.usdIn,
+    amountOut,
+    usdOut,
+    priceIn: swapStrategy.priceIn,
+    priceOut: swapStrategy.priceOut,
+    minOutputAmount,
+    swapStrategy,
+  };
+}
+
+export function getSwapAmountsByToValue(p: {
+  tokenIn: TokenData;
+  tokenOut: TokenData;
+  amountOut: bigint;
+  triggerRatio?: TokensRatio;
+  isLimit: boolean;
+  swapOptimizationOrder?: SwapOptimizationOrderArray;
+  allowedSwapSlippageBps?: bigint;
+  uiFeeFactor: bigint;
+  marketsInfoData: MarketsInfoData | undefined;
+  chainId: number;
+  externalSwapQuoteParams: ExternalSwapQuoteParams | undefined;
+  findSwapPath: FindSwapPath;
+}): SwapAmounts {
+  const {
+    tokenIn,
+    tokenOut,
+    amountOut,
+    triggerRatio,
+    isLimit,
+    uiFeeFactor,
+    swapOptimizationOrder,
+    allowedSwapSlippageBps,
+    marketsInfoData,
+    chainId,
+    externalSwapQuoteParams,
+  } = p;
+
+  if (!externalSwapQuoteParams) {
+    return getSwapAmountsByToValueDefault(p);
+  }
+
+  const swapStrategy = buildReverseSwapStrategy({
+    amountOut,
+    tokenIn,
+    tokenOut,
+    marketsInfoData,
+    chainId,
+    externalSwapQuoteParams,
+    swapOptimizationOrder,
+  });
+
+  const uiFeeUsd = applyFactor(swapStrategy.usdIn, uiFeeFactor);
+
+  const defaultAmounts: SwapAmounts = {
+    amountIn: swapStrategy.amountIn,
+    usdIn: swapStrategy.usdIn,
+    amountOut: swapStrategy.amountOut,
+    usdOut: swapStrategy.usdOut,
+    minOutputAmount: swapStrategy.amountOut,
+    priceIn: swapStrategy.priceIn,
+    priceOut: swapStrategy.priceOut,
+    swapStrategy,
+  };
+
+  if (!swapStrategy.swapPathStats) {
+    return defaultAmounts;
+  }
+
+  let amountIn = swapStrategy.amountIn;
+  let usdIn = swapStrategy.usdIn;
+  let minOutputAmount = 0n;
+
+  if (isLimit) {
+    if (!triggerRatio) {
+      return defaultAmounts;
+    }
+
+    amountIn = getAmountByRatio({
+      fromToken: tokenOut,
+      toToken: tokenIn,
+      fromTokenAmount: amountOut,
+      ratio: triggerRatio.ratio,
+      shouldInvertRatio: triggerRatio.largestToken.address === tokenIn.address,
+    });
+
+    usdIn = convertToUsd(amountIn, tokenIn.decimals, swapStrategy.priceIn)!;
+    if (allowedSwapSlippageBps !== undefined) {
+      usdIn += bigMath.mulDiv(usdIn, allowedSwapSlippageBps ?? 0n, BASIS_POINTS_DIVISOR_BIGINT);
+    } else {
+      usdIn =
+        usdIn +
+        swapStrategy.swapPathStats.totalSwapFeeUsd +
+        uiFeeUsd -
+        swapStrategy.swapPathStats.totalSwapPriceImpactDeltaUsd;
+    }
+    amountIn = convertToTokenAmount(usdIn, tokenIn.decimals, swapStrategy.priceIn)!;
+  } else {
+    usdIn = swapStrategy.usdIn + uiFeeUsd;
+    amountIn = convertToTokenAmount(usdIn, tokenIn.decimals, swapStrategy.priceIn)!;
+  }
+
+  if (amountIn < 0) {
+    amountIn = 0n;
+    usdIn = 0n;
+  }
+
+  return {
+    amountIn: swapStrategy.amountIn,
+    amountOut: swapStrategy.amountOut,
+    usdIn,
+    minOutputAmount,
+    usdOut: swapStrategy.usdOut,
+    priceIn: swapStrategy.priceIn,
+    priceOut: swapStrategy.priceOut,
+    swapStrategy,
+  };
+}
+
+function getSwapAmountsByFromValueDefault(p: {
+  tokenIn: TokenData;
+  tokenOut: TokenData;
+  amountIn: bigint;
+  triggerRatio?: TokensRatio;
+  isLimit: boolean;
+  swapOptimizationOrder?: SwapOptimizationOrderArray;
   allowedSwapSlippageBps?: bigint;
   findSwapPath: FindSwapPath;
   uiFeeFactor: bigint;
@@ -41,6 +263,19 @@ export function getSwapAmountsByFromValue(p: {
   let usdOut = 0n;
   let minOutputAmount = 0n;
 
+  const defaultSwapStrategy: NoSwapStrategy = {
+    type: "noSwap",
+    externalSwapQuote: undefined,
+    swapPathStats: undefined,
+    amountIn,
+    amountOut,
+    usdIn,
+    usdOut,
+    priceIn,
+    priceOut,
+    feesUsd: 0n,
+  };
+
   const defaultAmounts: SwapAmounts = {
     amountIn,
     usdIn,
@@ -49,7 +284,7 @@ export function getSwapAmountsByFromValue(p: {
     minOutputAmount,
     priceIn,
     priceOut,
-    swapPathStats: undefined,
+    swapStrategy: defaultSwapStrategy,
   };
 
   if (amountIn <= 0) {
@@ -61,6 +296,19 @@ export function getSwapAmountsByFromValue(p: {
     usdOut = usdIn;
     minOutputAmount = amountOut;
 
+    const swapStrategy: NoSwapStrategy = {
+      type: "noSwap",
+      externalSwapQuote: undefined,
+      swapPathStats: undefined,
+      amountIn,
+      amountOut,
+      usdIn,
+      usdOut,
+      priceIn,
+      priceOut,
+      feesUsd: 0n,
+    };
+
     return {
       amountIn,
       usdIn,
@@ -69,23 +317,21 @@ export function getSwapAmountsByFromValue(p: {
       minOutputAmount,
       priceIn,
       priceOut,
-      swapPathStats: undefined,
+      swapStrategy,
     };
   }
 
-  const swapPathStats = findSwapPath(defaultAmounts.usdIn, { order: swapOptimizationOrder });
+  if (getIsStake(tokenIn, tokenOut) || getIsUnstake(tokenIn, tokenOut)) {
+    return getPlainSwapAmountsByFromToken(tokenIn, tokenOut, amountIn);
+  }
 
-  console.log("🔍 Swap Path Stats Debug:");
-  console.log("  - swapPathStats found:", !!swapPathStats);
-  console.log("  - swapPathStats.swapPath:", swapPathStats?.swapPath);
-  console.log("  - usdIn:", defaultAmounts.usdIn.toString());
+  const swapPathStats = findSwapPath(defaultAmounts.usdIn, { order: swapOptimizationOrder });
 
   const totalSwapVolume = getTotalSwapVolumeFromSwapStats(swapPathStats?.swapSteps);
   const swapUiFeeUsd = applyFactor(totalSwapVolume, uiFeeFactor);
   const swapUiFeeAmount = convertToTokenAmount(swapUiFeeUsd, tokenOut.decimals, priceOut)!;
 
   if (!swapPathStats) {
-    console.log("❌ No swap path found, returning default amounts");
     return defaultAmounts;
   }
 
@@ -118,6 +364,19 @@ export function getSwapAmountsByFromValue(p: {
     minOutputAmount = 0n;
   }
 
+  const swapStrategy: InternalSwapStrategy = {
+    type: "internalSwap",
+    externalSwapQuote: undefined,
+    swapPathStats,
+    amountIn,
+    amountOut,
+    usdIn,
+    usdOut,
+    priceIn,
+    priceOut,
+    feesUsd: usdIn - usdOut,
+  };
+
   return {
     amountIn,
     usdIn,
@@ -126,18 +385,18 @@ export function getSwapAmountsByFromValue(p: {
     priceIn,
     priceOut,
     minOutputAmount,
-    swapPathStats,
+    swapStrategy,
   };
 }
 
-export function getSwapAmountsByToValue(p: {
+function getSwapAmountsByToValueDefault(p: {
   tokenIn: TokenData;
   tokenOut: TokenData;
   amountOut: bigint;
   triggerRatio?: TokensRatio;
   isLimit: boolean;
   findSwapPath: FindSwapPath;
-  swapOptimizationOrder?: Parameters<FindSwapPath>[1]["order"];
+  swapOptimizationOrder?: SwapOptimizationOrderArray;
   allowedSwapSlippageBps?: bigint;
   uiFeeFactor: bigint;
 }): SwapAmounts {
@@ -164,6 +423,19 @@ export function getSwapAmountsByToValue(p: {
   let amountIn = 0n;
   let usdIn = 0n;
 
+  const defaultSwapStrategy: NoSwapStrategy = {
+    type: "noSwap",
+    externalSwapQuote: undefined,
+    swapPathStats: undefined,
+    amountIn,
+    amountOut,
+    usdIn,
+    usdOut,
+    priceIn,
+    priceOut,
+    feesUsd: 0n,
+  };
+
   const defaultAmounts: SwapAmounts = {
     amountIn,
     usdIn,
@@ -172,7 +444,7 @@ export function getSwapAmountsByToValue(p: {
     minOutputAmount,
     priceIn,
     priceOut,
-    swapPathStats: undefined,
+    swapStrategy: defaultSwapStrategy,
   };
 
   if (amountOut <= 0) {
@@ -183,6 +455,19 @@ export function getSwapAmountsByToValue(p: {
     amountIn = amountOut;
     usdIn = usdOut;
 
+    const swapStrategy: NoSwapStrategy = {
+      type: "noSwap",
+      externalSwapQuote: undefined,
+      swapPathStats: undefined,
+      amountIn,
+      amountOut,
+      usdIn,
+      usdOut,
+      priceIn,
+      priceOut,
+      feesUsd: 0n,
+    };
+
     return {
       amountIn,
       usdIn,
@@ -191,10 +476,14 @@ export function getSwapAmountsByToValue(p: {
       minOutputAmount,
       priceIn,
       priceOut,
-      swapPathStats: undefined,
+      swapStrategy,
     };
   }
 
+  if (getIsStake(tokenIn, tokenOut) || getIsUnstake(tokenIn, tokenOut)) {
+    return getPlainSwapAmountsByToToken(tokenIn, tokenOut, amountOut);
+  }
+
   const baseUsdIn = usdOut;
   const swapPathStats = findSwapPath(baseUsdIn, { order: swapOptimizationOrder });
 
@@ -234,6 +523,19 @@ export function getSwapAmountsByToValue(p: {
     usdIn = 0n;
   }
 
+  const swapStrategy: InternalSwapStrategy = {
+    type: "internalSwap",
+    externalSwapQuote: undefined,
+    swapPathStats,
+    amountIn,
+    amountOut,
+    usdIn,
+    usdOut,
+    priceIn,
+    priceOut,
+    feesUsd: usdIn - usdOut,
+  };
+
   return {
     amountIn,
     usdIn,
@@ -242,11 +544,11 @@ export function getSwapAmountsByToValue(p: {
     minOutputAmount,
     priceIn,
     priceOut,
-    swapPathStats,
+    swapStrategy,
   };
 }
 
-export function getSwapPathComparator(order: Parameters<FindSwapPath>[1]["order"]) {
+export function getSwapPathComparator(order?: SwapOptimizationOrderArray | undefined) {
   return function (a: SwapRoute, b: SwapRoute) {
     for (const field of order || []) {
       const isLiquidity = field === "liquidity";
@@ -265,3 +567,67 @@ export function getSwapPathComparator(order: Parameters<FindSwapPath>[1]["order"
     return 0;
   };
 }
+
+function getPlainSwapAmountsByFromToken(tokenIn: TokenData, tokenOut: TokenData, amountIn: bigint): SwapAmounts {
+  const usdIn = convertToUsd(amountIn, tokenIn.decimals, tokenIn.prices.minPrice)!;
+  const usdOut = usdIn;
+  const amountOut = convertToTokenAmount(usdOut, tokenOut.decimals, tokenOut.prices.maxPrice)!;
+  const priceIn = tokenIn.prices.minPrice;
+  const priceOut = tokenOut.prices.maxPrice;
+
+  const swapStrategy: NoSwapStrategy = {
+    type: "noSwap",
+    externalSwapQuote: undefined,
+    swapPathStats: undefined,
+    amountIn,
+    amountOut,
+    usdIn,
+    usdOut,
+    priceIn,
+    priceOut,
+    feesUsd: 0n,
+  };
+
+  return {
+    amountIn,
+    usdIn,
+    amountOut,
+    usdOut,
+    minOutputAmount: amountOut,
+    priceIn,
+    priceOut,
+    swapStrategy,
+  };
+}
+
+function getPlainSwapAmountsByToToken(tokenIn: TokenData, tokenOut: TokenData, amountOut: bigint): SwapAmounts {
+  const priceIn = tokenIn.prices.minPrice;
+  const priceOut = tokenOut.prices.maxPrice;
+  const usdOut = convertToUsd(amountOut, tokenOut.decimals, priceOut)!;
+  const usdIn = usdOut;
+  const amountIn = convertToTokenAmount(usdIn, tokenIn.decimals, priceIn)!;
+
+  const swapStrategy: NoSwapStrategy = {
+    type: "noSwap",
+    externalSwapQuote: undefined,
+    swapPathStats: undefined,
+    amountIn,
+    amountOut,
+    usdIn,
+    usdOut,
+    priceIn,
+    priceOut,
+    feesUsd: 0n,
+  };
+
+  return {
+    amountIn,
+    usdIn,
+    amountOut,
+    usdOut,
+    minOutputAmount: amountOut,
+    priceIn,
+    priceOut,
+    swapStrategy,
+  };
+}
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/testUtil.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/testUtil.ts
index dac35892..eb778c4f 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/testUtil.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/testUtil.ts
@@ -1,11 +1,11 @@
 import {createTestClient, http, publicActions, walletActions} from "viem";
 
-import {ARBITRUM, getChain} from "../configs/chains.js";
+import {ARBITRUM, ContractsChainId, getViemChain} from "../configs/chains.js";
 
 import {GmxSdk} from "../index.js";
 
 const client = createTestClient({
-  chain: getChain(ARBITRUM),
+  chain: getViemChain(ARBITRUM),
   mode: "hardhat",
   transport: http(),
 })
@@ -13,7 +13,7 @@ const client = createTestClient({
   .extend(walletActions);
 
 export const arbitrumSdkConfig = {
-  chainId: ARBITRUM,
+  chainId: ARBITRUM as ContractsChainId,
   account: "0x9f7198eb1b9Ccc0Eb7A07eD228d8FbC12963ea33",
   oracleUrl: "https://arbitrum-api.gmxinfra.io",
   rpcUrl: "https://arb1.arbitrum.io/rpc",
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/tokens.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/tokens.ts
index ffdea0f1..a69b8fb8 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/tokens.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/tokens.ts
@@ -1,4 +1,12 @@
-import {Token, TokenPrices, TokensData, TokensRatio, TokensRatioAndSlippage} from "../types/tokens.js";
+import {
+    ContractPrice,
+    Token,
+    TokenData,
+    TokenPrices,
+    TokensData,
+    TokensRatio,
+    TokensRatioAndSlippage
+} from "../types/tokens.js";
 import {adjustForDecimals, expandDecimals, PRECISION} from "./numbers.js";
 import {NATIVE_TOKEN_ADDRESS} from "../configs/tokens.js";
 import {BASIS_POINTS_DIVISOR_BIGINT, DEFAULT_ALLOWED_SWAP_SLIPPAGE_BPS} from "../configs/factors.js";
@@ -8,8 +16,8 @@ export function parseContractPrice(price: bigint, tokenDecimals: number) {
   return price * expandDecimals(1, tokenDecimals);
 }
 
-export function convertToContractPrice(price: bigint, tokenDecimals: number) {
-  return price / expandDecimals(1, tokenDecimals);
+export function convertToContractPrice(price: bigint, tokenDecimals: number): ContractPrice {
+  return (price / expandDecimals(1, tokenDecimals)) as ContractPrice;
 }
 
 export function convertToContractTokenPrices(prices: TokenPrices, tokenDecimals: number) {
@@ -43,6 +51,29 @@ export function convertToUsd(
   return (tokenAmount * price) / expandDecimals(1, tokenDecimals);
 }
 
+export function convertBetweenTokens(
+  tokenAmount: bigint | undefined,
+  fromToken: TokenData | undefined,
+  toToken: TokenData | undefined,
+  maximize: boolean
+) {
+  if (tokenAmount === undefined || fromToken === undefined || toToken === undefined) {
+    return undefined;
+  }
+
+  if (getIsEquivalentTokens(fromToken, toToken)) {
+    return tokenAmount;
+  }
+
+  const fromPrice = maximize ? fromToken.prices.maxPrice : fromToken.prices.minPrice;
+  const toPrice = maximize ? toToken.prices.minPrice : toToken.prices.maxPrice;
+
+  const usd = convertToUsd(tokenAmount, fromToken.decimals, fromPrice)!;
+  const amount = convertToTokenAmount(usd, toToken.decimals, toPrice)!;
+
+  return amount;
+}
+
 export function getMidPrice(prices: TokenPrices) {
   return (prices.minPrice + prices.maxPrice) / 2n;
 }
@@ -187,6 +218,15 @@ export function getIsUnwrap(token1: Token, token2: Token) {
   return token1.isWrapped && token2.isNative;
 }
 
+export function getIsStake(token1: Token, token2: Token) {
+  return (token1.isWrapped || token1.isNative) && token2.isStaking;
+}
+
+export function getIsUnstake(token1: Token, token2: Token) {
+  // can't unstake straight to native token
+  return token1.isStaking && token2.isWrapped;
+}
+
 export function getTokensRatioByPrice(p: {
   fromToken: Token;
   toToken: Token;
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/trade/decrease.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/trade/decrease.ts
new file mode 100644
index 00000000..5a45442b
--- /dev/null
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/trade/decrease.ts
@@ -0,0 +1,727 @@
+import {DEFAULT_ACCEPTABLE_PRICE_IMPACT_BUFFER} from "../../configs/factors.js";
+import {MarketInfo} from "../../types/markets.js";
+import {DecreasePositionSwapType, OrderType} from "../../types/orders.js";
+import {PositionInfo, PositionInfoLoaded} from "../../types/positions.js";
+import {UserReferralInfo} from "../../types/referrals.js";
+import {TokenData} from "../../types/tokens.js";
+import {DecreasePositionAmounts, NextPositionValues} from "../../types/trade.js";
+import {bigMath} from "../../utils/bigmath.js";
+import {getPositionFee} from "../../utils/fees/index.js";
+import {
+    applyFactor,
+    BASIS_POINTS_DIVISOR_BIGINT,
+    expandDecimals,
+    getBasisPoints,
+    MaxUint256,
+    roundUpDivision,
+    USD_DECIMALS,
+} from "../../utils/numbers.js";
+import {
+    getLeverage,
+    getLiquidationPrice,
+    getMinCollateralFactorForPosition,
+    getNetPriceImpactDeltaUsdForDecrease,
+    getPositionPnlUsd,
+} from "../../utils/positions.js";
+import {
+    getAcceptablePriceInfo,
+    getDefaultAcceptablePriceImpactBps,
+    getMarkPrice,
+    getOrderThresholdType,
+} from "../../utils/prices.js";
+import {getSwapStats} from "../../utils/swap/index.js";
+import {convertToTokenAmount, convertToUsd, getIsEquivalentTokens} from "../../utils/tokens.js";
+
+export function getDecreasePositionAmounts(p: {
+  marketInfo: MarketInfo;
+  collateralToken: TokenData;
+  isLong: boolean;
+  position: PositionInfoLoaded | undefined;
+  closeSizeUsd: bigint;
+  keepLeverage: boolean;
+  triggerPrice?: bigint;
+  fixedAcceptablePriceImpactBps?: bigint;
+  acceptablePriceImpactBuffer?: number;
+  userReferralInfo: UserReferralInfo | undefined;
+  minCollateralUsd: bigint;
+  minPositionSizeUsd: bigint;
+  uiFeeFactor: bigint;
+  isLimit?: boolean;
+  limitPrice?: bigint;
+  triggerOrderType?: DecreasePositionAmounts["triggerOrderType"];
+
+  receiveToken?: TokenData;
+}) {
+  const {
+    marketInfo,
+    collateralToken,
+    isLong,
+    position,
+    closeSizeUsd,
+    keepLeverage,
+    triggerPrice,
+    fixedAcceptablePriceImpactBps,
+    acceptablePriceImpactBuffer,
+    userReferralInfo,
+    minCollateralUsd,
+    minPositionSizeUsd,
+    uiFeeFactor,
+    triggerOrderType: orderType,
+    receiveToken: receiveTokenArg,
+  } = p;
+
+  const { indexToken } = marketInfo;
+  const receiveToken = receiveTokenArg ?? collateralToken;
+
+  const values: DecreasePositionAmounts = {
+    isFullClose: false,
+    sizeDeltaUsd: 0n,
+    sizeDeltaInTokens: 0n,
+    collateralDeltaUsd: 0n,
+    collateralDeltaAmount: 0n,
+
+    indexPrice: 0n,
+    collateralPrice: 0n,
+    triggerPrice: 0n,
+    acceptablePrice: 0n,
+
+    proportionalPendingImpactDeltaUsd: 0n,
+    closePriceImpactDeltaUsd: 0n,
+    totalPendingImpactDeltaUsd: 0n,
+    priceImpactDiffUsd: 0n,
+    balanceWasImproved: false,
+    acceptablePriceDeltaBps: 0n,
+    recommendedAcceptablePriceDeltaBps: 0n,
+
+    estimatedPnl: 0n,
+    estimatedPnlPercentage: 0n,
+    realizedPnl: 0n,
+    realizedPnlPercentage: 0n,
+
+    positionFeeUsd: 0n,
+    uiFeeUsd: 0n,
+    swapUiFeeUsd: 0n,
+    borrowingFeeUsd: 0n,
+    fundingFeeUsd: 0n,
+    feeDiscountUsd: 0n,
+    swapProfitFeeUsd: 0n,
+    payedOutputUsd: 0n,
+    payedRemainingCollateralUsd: 0n,
+    payedRemainingCollateralAmount: 0n,
+
+    receiveTokenAmount: 0n,
+    receiveUsd: 0n,
+
+    triggerOrderType: orderType,
+    triggerThresholdType: undefined,
+    decreaseSwapType: DecreasePositionSwapType.NoSwap,
+  };
+
+  const pnlToken = isLong ? marketInfo.longToken : marketInfo.shortToken;
+
+  values.decreaseSwapType = getDecreaseSwapType(pnlToken, collateralToken, receiveToken);
+
+  const markPrice = getMarkPrice({ prices: indexToken.prices, isIncrease: false, isLong });
+  const isTrigger = orderType !== undefined;
+
+  if (orderType) {
+    values.triggerPrice = triggerPrice;
+    values.indexPrice = triggerPrice ?? markPrice;
+
+    values.collateralPrice = getIsEquivalentTokens(indexToken, collateralToken)
+      ? triggerPrice ?? markPrice
+      : collateralToken.prices.minPrice;
+
+    values.triggerThresholdType = getOrderThresholdType(orderType, isLong);
+  } else {
+    values.indexPrice = markPrice;
+    values.collateralPrice = collateralToken.prices.minPrice;
+  }
+
+  if (closeSizeUsd <= 0) {
+    return values;
+  }
+
+  values.sizeDeltaUsd = closeSizeUsd;
+
+  if (!position || position.sizeInUsd <= 0 || position.sizeInTokens <= 0) {
+    applyAcceptablePrice({
+      position,
+      marketInfo,
+      isLong,
+      isTrigger,
+      fixedAcceptablePriceImpactBps,
+      acceptablePriceImpactBuffer,
+      values,
+    });
+
+    const positionFeeInfo = getPositionFee(
+      marketInfo,
+      values.sizeDeltaUsd,
+      values.balanceWasImproved,
+      userReferralInfo
+    );
+
+    values.positionFeeUsd = positionFeeInfo.positionFeeUsd;
+    values.feeDiscountUsd = positionFeeInfo.discountUsd;
+    values.uiFeeUsd = applyFactor(values.sizeDeltaUsd, uiFeeFactor);
+
+    const totalFeesUsd = getTotalFeesUsdForDecrease({
+      positionFeeUsd: values.positionFeeUsd,
+      borrowingFeeUsd: 0n,
+      fundingFeeUsd: 0n,
+      swapProfitFeeUsd: 0n,
+      swapUiFeeUsd: 0n,
+      uiFeeUsd: values.uiFeeUsd,
+      pnlUsd: 0n,
+      totalPendingImpactDeltaUsd: values.totalPendingImpactDeltaUsd,
+    });
+
+    values.payedOutputUsd = totalFeesUsd;
+
+    return values;
+  }
+
+  const estimatedCollateralUsd = convertToUsd(
+    position.collateralAmount,
+    collateralToken.decimals,
+    values.collateralPrice
+  )!;
+
+  let estimatedCollateralDeltaUsd = 0n;
+
+  if (keepLeverage) {
+    estimatedCollateralDeltaUsd = bigMath.mulDiv(values.sizeDeltaUsd, estimatedCollateralUsd, position.sizeInUsd);
+  }
+
+  values.isFullClose = getIsFullClose({
+    position,
+    sizeDeltaUsd: values.sizeDeltaUsd,
+    indexPrice: values.indexPrice,
+    remainingCollateralUsd: estimatedCollateralUsd - estimatedCollateralDeltaUsd,
+    minCollateralUsd,
+    minPositionSizeUsd,
+  });
+
+  if (values.isFullClose) {
+    values.sizeDeltaUsd = position.sizeInUsd;
+    values.sizeDeltaInTokens = position.sizeInTokens;
+  } else {
+    if (position.isLong) {
+      values.sizeDeltaInTokens = roundUpDivision(position.sizeInTokens * values.sizeDeltaUsd, position.sizeInUsd);
+    } else {
+      values.sizeDeltaInTokens = bigMath.mulDiv(position.sizeInTokens, values.sizeDeltaUsd, position.sizeInUsd);
+    }
+  }
+
+  // PNL
+  values.estimatedPnl = getPositionPnlUsd({
+    marketInfo,
+    sizeInUsd: position.sizeInUsd,
+    sizeInTokens: position.sizeInTokens,
+    markPrice: values.indexPrice,
+    isLong,
+  });
+
+  values.realizedPnl = bigMath.mulDiv(values.estimatedPnl, values.sizeDeltaInTokens, position.sizeInTokens);
+  values.realizedPnlPercentage =
+    estimatedCollateralUsd !== 0n ? getBasisPoints(values.realizedPnl, estimatedCollateralUsd) : 0n;
+  values.estimatedPnlPercentage =
+    estimatedCollateralUsd !== 0n ? getBasisPoints(values.estimatedPnl, estimatedCollateralUsd) : 0n;
+
+  applyAcceptablePrice({
+    position,
+    marketInfo,
+    isLong,
+    isTrigger,
+    fixedAcceptablePriceImpactBps,
+    acceptablePriceImpactBuffer,
+    values,
+  });
+
+  // Profit
+  let profitUsd = 0n;
+  if (values.realizedPnl > 0) {
+    profitUsd = profitUsd + values.realizedPnl;
+  }
+  if (values.totalPendingImpactDeltaUsd > 0) {
+    profitUsd = profitUsd + values.totalPendingImpactDeltaUsd;
+  }
+  const profitAmount = convertToTokenAmount(profitUsd, collateralToken.decimals, values.collateralPrice)!;
+
+  // Fees
+  const positionFeeInfo = getPositionFee(marketInfo, values.sizeDeltaUsd, values.balanceWasImproved, userReferralInfo);
+  const estimatedPositionFeeCost = estimateCollateralCost(
+    positionFeeInfo.positionFeeUsd,
+    collateralToken,
+    values.collateralPrice
+  );
+  const estimatedDiscountCost = estimateCollateralCost(
+    positionFeeInfo.discountUsd,
+    collateralToken,
+    values.collateralPrice
+  );
+
+  values.positionFeeUsd = estimatedPositionFeeCost.usd;
+  values.feeDiscountUsd = estimatedDiscountCost.usd;
+  values.uiFeeUsd = applyFactor(values.sizeDeltaUsd, uiFeeFactor);
+
+  const borrowFeeCost = estimateCollateralCost(
+    position.pendingBorrowingFeesUsd,
+    collateralToken,
+    values.collateralPrice
+  );
+
+  values.borrowingFeeUsd = borrowFeeCost.usd;
+
+  const fundingFeeCost = estimateCollateralCost(
+    position.pendingFundingFeesUsd,
+    collateralToken,
+    values.collateralPrice
+  );
+
+  values.fundingFeeUsd = fundingFeeCost.usd;
+
+  if (profitUsd > 0 && values.decreaseSwapType === DecreasePositionSwapType.SwapPnlTokenToCollateralToken) {
+    const swapProfitStats = getSwapStats({
+      marketInfo,
+      tokenInAddress: pnlToken.address,
+      tokenOutAddress: collateralToken.address,
+      usdIn: profitUsd,
+      shouldApplyPriceImpact: true,
+      isAtomicSwap: false,
+    });
+
+    values.swapProfitFeeUsd = swapProfitStats.swapFeeUsd - swapProfitStats.priceImpactDeltaUsd;
+    values.swapUiFeeUsd = applyFactor(swapProfitStats.usdIn, uiFeeFactor);
+  } else {
+    values.swapProfitFeeUsd = 0n;
+  }
+
+  const totalFeesUsd = getTotalFeesUsdForDecrease({
+    positionFeeUsd: values.positionFeeUsd,
+    borrowingFeeUsd: values.borrowingFeeUsd,
+    fundingFeeUsd: values.fundingFeeUsd,
+    swapProfitFeeUsd: values.swapProfitFeeUsd,
+    swapUiFeeUsd: values.swapUiFeeUsd,
+    uiFeeUsd: values.uiFeeUsd,
+    pnlUsd: values.realizedPnl,
+    totalPendingImpactDeltaUsd: values.totalPendingImpactDeltaUsd,
+  });
+
+  const payedInfo = payForCollateralCost({
+    initialCostUsd: totalFeesUsd,
+    collateralToken,
+    collateralPrice: values.collateralPrice,
+    outputAmount: profitAmount,
+    remainingCollateralAmount: position.collateralAmount,
+  });
+
+  values.payedOutputUsd = convertToUsd(payedInfo.paidOutputAmount, collateralToken.decimals, values.collateralPrice)!;
+  values.payedRemainingCollateralAmount = payedInfo.paidRemainingCollateralAmount;
+  values.payedRemainingCollateralUsd = convertToUsd(
+    payedInfo.paidRemainingCollateralAmount,
+    collateralToken.decimals,
+    values.collateralPrice
+  )!;
+
+  // Collateral delta
+  if (values.isFullClose) {
+    values.collateralDeltaUsd = estimatedCollateralUsd;
+    values.collateralDeltaAmount = position.collateralAmount;
+    values.receiveTokenAmount = payedInfo.outputAmount + payedInfo.remainingCollateralAmount;
+  } else if (
+    keepLeverage &&
+    position.sizeInUsd > 0 &&
+    estimatedCollateralUsd > 0 &&
+    payedInfo.remainingCollateralAmount > 0
+  ) {
+    const remainingCollateralUsd = convertToUsd(
+      payedInfo.remainingCollateralAmount,
+      collateralToken.decimals,
+      values.collateralPrice
+    )!;
+    const nextSizeInUsd = position.sizeInUsd - values.sizeDeltaUsd;
+    const leverageWithoutPnl = getLeverage({
+      sizeInUsd: position.sizeInUsd,
+      collateralUsd: estimatedCollateralUsd,
+      pendingBorrowingFeesUsd: position.pendingBorrowingFeesUsd,
+      pendingFundingFeesUsd: position.pendingFundingFeesUsd,
+      pnl: undefined,
+    });
+
+    values.collateralDeltaUsd =
+      /**
+       * 1. @see https://app.asana.com/0/1204313444805313/1207549197964321/f
+       * 2. leverageWithoutPnl may be zero if sizeInUsd is defaulted to 0n when position not ready yet
+       */
+      leverageWithoutPnl !== undefined && leverageWithoutPnl !== 0n
+        ? remainingCollateralUsd - bigMath.mulDiv(nextSizeInUsd, BASIS_POINTS_DIVISOR_BIGINT, leverageWithoutPnl)
+        : 0n;
+    values.collateralDeltaAmount = convertToTokenAmount(
+      values.collateralDeltaUsd,
+      collateralToken.decimals,
+      values.collateralPrice
+    )!;
+    values.receiveTokenAmount = payedInfo.outputAmount + values.collateralDeltaAmount;
+  } else {
+    values.collateralDeltaUsd = 0n;
+    values.collateralDeltaAmount = 0n;
+    values.receiveTokenAmount = payedInfo.outputAmount;
+  }
+
+  values.receiveUsd = convertToUsd(values.receiveTokenAmount, collateralToken.decimals, values.collateralPrice)!;
+
+  return values;
+}
+
+export function getIsFullClose(p: {
+  position: PositionInfoLoaded;
+  sizeDeltaUsd: bigint;
+  indexPrice: bigint;
+  remainingCollateralUsd: bigint;
+  minCollateralUsd: bigint;
+  minPositionSizeUsd: bigint;
+}) {
+  const { position, sizeDeltaUsd, indexPrice, remainingCollateralUsd, minCollateralUsd, minPositionSizeUsd } = p;
+  const { marketInfo, isLong } = position;
+
+  if (position.sizeInUsd - sizeDeltaUsd < expandDecimals(1, USD_DECIMALS)) {
+    return true;
+  }
+
+  const estimatedPnl = getPositionPnlUsd({
+    marketInfo,
+    sizeInUsd: position.sizeInUsd,
+    sizeInTokens: position.sizeInTokens,
+    markPrice: indexPrice,
+    isLong,
+  });
+
+  const realizedPnl = bigMath.mulDiv(estimatedPnl, sizeDeltaUsd, position.sizeInUsd);
+
+  const estimatedRemainingPnl = estimatedPnl - realizedPnl;
+
+  if (realizedPnl < 0) {
+    const estimatedRemainingCollateralUsd = remainingCollateralUsd - realizedPnl;
+
+    let minCollateralFactor = isLong
+      ? marketInfo.minCollateralFactorForOpenInterestLong
+      : marketInfo.minCollateralFactorForOpenInterestShort;
+
+    const minCollateralFactorForMarket = marketInfo.minCollateralFactor;
+
+    if (minCollateralFactorForMarket > minCollateralFactor) {
+      minCollateralFactor = minCollateralFactorForMarket;
+    }
+
+    const minCollateralUsdForLeverage = applyFactor(position.sizeInUsd, minCollateralFactor);
+    const willCollateralBeSufficient = estimatedRemainingCollateralUsd >= minCollateralUsdForLeverage;
+
+    if (!willCollateralBeSufficient) {
+      if (
+        estimatedRemainingCollateralUsd + estimatedRemainingPnl < minCollateralUsd ||
+        position.sizeInUsd - sizeDeltaUsd < minPositionSizeUsd
+      ) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+export function getMinCollateralUsdForLeverage(position: PositionInfoLoaded, openInterestDelta: bigint) {
+  const minCollateralFactor = getMinCollateralFactorForPosition(position, openInterestDelta);
+  return applyFactor(position.sizeInUsd, minCollateralFactor);
+}
+
+export function payForCollateralCost(p: {
+  initialCostUsd: bigint;
+  collateralToken: TokenData;
+  collateralPrice: bigint;
+  outputAmount: bigint;
+  remainingCollateralAmount: bigint;
+}) {
+  const { initialCostUsd, collateralToken, collateralPrice, outputAmount, remainingCollateralAmount } = p;
+
+  const values = {
+    outputAmount: BigInt(outputAmount),
+    remainingCollateralAmount: BigInt(remainingCollateralAmount),
+    paidOutputAmount: 0n,
+    paidRemainingCollateralAmount: 0n,
+  };
+
+  let remainingCostAmount = convertToTokenAmount(initialCostUsd, collateralToken.decimals, collateralPrice)!;
+
+  if (remainingCostAmount == 0n) {
+    return values;
+  }
+
+  if (values.outputAmount > 0) {
+    if (values.outputAmount > remainingCostAmount) {
+      values.outputAmount = values.outputAmount - remainingCostAmount;
+      values.paidOutputAmount = remainingCostAmount;
+      remainingCostAmount = 0n;
+    } else {
+      remainingCostAmount = remainingCostAmount - values.outputAmount;
+      values.paidOutputAmount = values.outputAmount;
+      values.outputAmount = 0n;
+    }
+  }
+
+  if (remainingCostAmount == 0n) {
+    return values;
+  }
+
+  if (values.remainingCollateralAmount > remainingCostAmount) {
+    values.remainingCollateralAmount = values.remainingCollateralAmount - remainingCostAmount;
+    values.paidRemainingCollateralAmount = remainingCostAmount;
+    remainingCostAmount = 0n;
+  } else {
+    remainingCostAmount = remainingCostAmount - remainingCollateralAmount;
+    values.paidRemainingCollateralAmount = values.remainingCollateralAmount;
+    values.remainingCollateralAmount = 0n;
+  }
+
+  return values;
+}
+
+function applyAcceptablePrice(p: {
+  position: PositionInfoLoaded | undefined;
+  marketInfo: MarketInfo;
+  isLong: boolean;
+  isTrigger: boolean;
+  fixedAcceptablePriceImpactBps?: bigint;
+  acceptablePriceImpactBuffer?: number;
+  values: DecreasePositionAmounts;
+}) {
+  const {
+    position,
+    marketInfo,
+    isLong,
+    values,
+    isTrigger,
+    fixedAcceptablePriceImpactBps,
+    acceptablePriceImpactBuffer,
+  } = p;
+
+  const acceptablePriceInfo = getAcceptablePriceInfo({
+    marketInfo,
+    isIncrease: false,
+    isLimit: false,
+    isLong,
+    indexPrice: values.indexPrice,
+    sizeDeltaUsd: values.sizeDeltaUsd,
+  });
+
+  values.acceptablePrice = acceptablePriceInfo.acceptablePrice;
+  values.acceptablePriceDeltaBps = acceptablePriceInfo.acceptablePriceDeltaBps;
+  values.balanceWasImproved = acceptablePriceInfo.balanceWasImproved;
+
+  const totalImpactValues = getNetPriceImpactDeltaUsdForDecrease({
+    marketInfo,
+    sizeInUsd: position?.sizeInUsd ?? 0n,
+    pendingImpactAmount: position?.pendingImpactAmount ?? 0n,
+    sizeDeltaUsd: values.sizeDeltaUsd,
+    priceImpactDeltaUsd: acceptablePriceInfo.priceImpactDeltaUsd,
+  });
+
+  values.closePriceImpactDeltaUsd = acceptablePriceInfo.priceImpactDeltaUsd;
+  values.totalPendingImpactDeltaUsd = totalImpactValues.totalImpactDeltaUsd;
+  values.proportionalPendingImpactDeltaUsd = totalImpactValues.proportionalPendingImpactDeltaUsd;
+  values.priceImpactDiffUsd = totalImpactValues.priceImpactDiffUsd;
+
+  if (isTrigger) {
+    if (values.triggerOrderType === OrderType.StopLossDecrease) {
+      if (isLong) {
+        values.acceptablePrice = 0n;
+      } else {
+        values.acceptablePrice = MaxUint256;
+      }
+    } else {
+      let maxNegativePriceImpactBps = fixedAcceptablePriceImpactBps;
+      values.recommendedAcceptablePriceDeltaBps = getDefaultAcceptablePriceImpactBps({
+        isIncrease: false,
+        isLong,
+        indexPrice: values.indexPrice,
+        sizeDeltaUsd: values.sizeDeltaUsd,
+        priceImpactDeltaUsd: values.closePriceImpactDeltaUsd,
+        acceptablePriceImapctBuffer: acceptablePriceImpactBuffer || DEFAULT_ACCEPTABLE_PRICE_IMPACT_BUFFER,
+      });
+
+      if (maxNegativePriceImpactBps === undefined) {
+        maxNegativePriceImpactBps = values.recommendedAcceptablePriceDeltaBps;
+      }
+
+      const triggerAcceptablePriceInfo = getAcceptablePriceInfo({
+        marketInfo,
+        isIncrease: false,
+        isLimit: false,
+        isLong,
+        indexPrice: values.indexPrice,
+        sizeDeltaUsd: values.sizeDeltaUsd,
+        maxNegativePriceImpactBps,
+      });
+
+      values.acceptablePrice = triggerAcceptablePriceInfo.acceptablePrice;
+      values.acceptablePriceDeltaBps = triggerAcceptablePriceInfo.acceptablePriceDeltaBps;
+    }
+  }
+
+  return values;
+}
+
+export function estimateCollateralCost(baseUsd: bigint, collateralToken: TokenData, collateralPrice: bigint) {
+  const amount = convertToTokenAmount(baseUsd, collateralToken.decimals, collateralToken.prices.minPrice)!;
+  const usd = convertToUsd(amount, collateralToken.decimals, collateralPrice)!;
+
+  return {
+    amount,
+    usd,
+  };
+}
+
+export function getTotalFeesUsdForDecrease({
+  positionFeeUsd,
+  borrowingFeeUsd,
+  fundingFeeUsd,
+  swapProfitFeeUsd,
+  swapUiFeeUsd,
+  uiFeeUsd,
+  pnlUsd,
+  totalPendingImpactDeltaUsd,
+}: {
+  positionFeeUsd: bigint;
+  borrowingFeeUsd: bigint;
+  fundingFeeUsd: bigint;
+  swapProfitFeeUsd: bigint;
+  swapUiFeeUsd: bigint;
+  uiFeeUsd: bigint;
+  pnlUsd: bigint;
+  totalPendingImpactDeltaUsd: bigint;
+}) {
+  const negativePriceImpactUsd = totalPendingImpactDeltaUsd < 0 ? bigMath.abs(totalPendingImpactDeltaUsd) : 0n;
+  const negativePnlUsd = pnlUsd < 0 ? bigMath.abs(pnlUsd) : 0n;
+
+  const totalFeesUsd =
+    positionFeeUsd +
+    borrowingFeeUsd +
+    fundingFeeUsd +
+    swapProfitFeeUsd +
+    swapUiFeeUsd +
+    uiFeeUsd +
+    negativePnlUsd +
+    negativePriceImpactUsd;
+
+  return totalFeesUsd;
+}
+
+export function getNextPositionValuesForDecreaseTrade(p: {
+  existingPosition?: PositionInfo;
+  marketInfo: MarketInfo;
+  collateralToken: TokenData;
+  sizeDeltaUsd: bigint;
+  sizeDeltaInTokens: bigint;
+  realizedPnl: bigint;
+  estimatedPnl: bigint;
+  collateralDeltaUsd: bigint;
+  collateralDeltaAmount: bigint;
+  payedRemainingCollateralUsd: bigint;
+  payedRemainingCollateralAmount: bigint;
+  proportionalPendingImpactDeltaUsd: bigint;
+  showPnlInLeverage: boolean;
+  isLong: boolean;
+  minCollateralUsd: bigint;
+  userReferralInfo: UserReferralInfo | undefined;
+}): NextPositionValues {
+  const {
+    existingPosition,
+    marketInfo,
+    collateralToken,
+    sizeDeltaUsd,
+    sizeDeltaInTokens,
+    realizedPnl,
+    estimatedPnl,
+    collateralDeltaUsd,
+    collateralDeltaAmount,
+    payedRemainingCollateralUsd,
+    payedRemainingCollateralAmount,
+    showPnlInLeverage,
+    proportionalPendingImpactDeltaUsd,
+    isLong,
+    minCollateralUsd,
+    userReferralInfo,
+  } = p;
+
+  const nextSizeUsd = existingPosition ? existingPosition.sizeInUsd - sizeDeltaUsd : 0n;
+  const nextSizeInTokens = existingPosition ? existingPosition.sizeInTokens - sizeDeltaInTokens : 0n;
+
+  let nextCollateralUsd = existingPosition
+    ? existingPosition.collateralUsd - collateralDeltaUsd - payedRemainingCollateralUsd
+    : 0n;
+
+  if (nextCollateralUsd < 0) {
+    nextCollateralUsd = 0n;
+  }
+
+  let nextCollateralAmount = existingPosition
+    ? existingPosition.collateralAmount - collateralDeltaAmount - payedRemainingCollateralAmount
+    : 0n;
+
+  if (nextCollateralAmount < 0) {
+    nextCollateralAmount = 0n;
+  }
+
+  const nextPnl = estimatedPnl ? estimatedPnl - realizedPnl : 0n;
+
+  const nextPnlPercentage = nextCollateralUsd !== 0n ? getBasisPoints(nextPnl, nextCollateralUsd) : 0n;
+
+  const nextLeverage = getLeverage({
+    sizeInUsd: nextSizeUsd,
+    collateralUsd: nextCollateralUsd,
+    pnl: showPnlInLeverage ? nextPnl : undefined,
+    pendingBorrowingFeesUsd: 0n, // deducted on order
+    pendingFundingFeesUsd: 0n, // deducted on order
+  });
+
+  const nextLiqPrice = getLiquidationPrice({
+    marketInfo,
+    collateralToken,
+    sizeInTokens: nextSizeInTokens,
+    sizeInUsd: nextSizeUsd,
+    collateralUsd: nextCollateralUsd,
+    collateralAmount: nextCollateralAmount,
+    minCollateralUsd,
+    userReferralInfo,
+    pendingImpactAmount: existingPosition?.pendingImpactAmount ?? 0n,
+    pendingBorrowingFeesUsd: 0n, // deducted on order
+    pendingFundingFeesUsd: 0n, // deducted on order
+    isLong: isLong,
+  });
+
+  const nextPendingImpactDeltaUsd =
+    existingPosition?.pendingImpactUsd !== undefined && proportionalPendingImpactDeltaUsd !== undefined
+      ? existingPosition.pendingImpactUsd - proportionalPendingImpactDeltaUsd
+      : 0n;
+
+  return {
+    nextSizeUsd,
+    nextCollateralUsd,
+    nextLiqPrice,
+    nextPnl,
+    nextPnlPercentage,
+    nextLeverage,
+    nextPendingImpactDeltaUsd,
+  };
+}
+
+function getDecreaseSwapType(pnlToken: TokenData, collateralToken: TokenData, receiveToken: TokenData) {
+  if (getIsEquivalentTokens(pnlToken, collateralToken)) {
+    return DecreasePositionSwapType.NoSwap;
+  } else if (getIsEquivalentTokens(pnlToken, receiveToken)) {
+    return DecreasePositionSwapType.SwapCollateralTokenToPnlToken;
+  } else {
+    return DecreasePositionSwapType.SwapPnlTokenToCollateralToken;
+  }
+}
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/trade/amounts.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/trade/increase.ts
similarity index 57%
rename from src/Managing.Web3Proxy/src/generated/gmxsdk/utils/trade/amounts.ts
rename to src/Managing.Web3Proxy/src/generated/gmxsdk/utils/trade/increase.ts
index 91cab5e6..04b0301c 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/trade/amounts.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/trade/increase.ts
@@ -1,26 +1,45 @@
-import { ExternalSwapQuote, FindSwapPath, TriggerThresholdType } from "../../types/trade.js";
+import {maxUint256} from "viem";
 
-import { TokenData, TokensRatio } from "../../types/tokens.js";
-
-import { BASIS_POINTS_DIVISOR_BIGINT } from "../../configs/factors.js";
-import { MarketInfo } from "../../types/markets.js";
-import { OrderType } from "../../types/orders.js";
-import { PositionInfo } from "../../types/positions.js";
-import { UserReferralInfo } from "../../types/referrals.js";
-import { IncreasePositionAmounts } from "../../types/trade.js";
-import { bigMath } from "../bigmath.js";
-import { getPositionFee, getPriceImpactForPosition, getTotalSwapVolumeFromSwapStats } from "../fees/index.js";
-import { applyFactor } from "../numbers.js";
-import { getLeverage } from "../positions.js";
+import {BASIS_POINTS_DIVISOR_BIGINT, DEFAULT_ACCEPTABLE_PRICE_IMPACT_BUFFER} from "../../configs/factors.js";
+import {MarketInfo, MarketsInfoData} from "../../types/markets.js";
+import {OrderType} from "../../types/orders.js";
+import {PositionInfo} from "../../types/positions.js";
+import {UserReferralInfo} from "../../types/referrals.js";
+import {ExternalSwapStrategy, NoSwapStrategy} from "../../types/swapStrategy.js";
+import {TokenData, TokensRatio} from "../../types/tokens.js";
 import {
-  getAcceptablePriceInfo,
-  getDefaultAcceptablePriceImpactBps,
-  getMarkPrice,
-  getOrderThresholdType,
-} from "../prices.js";
-import { getSwapAmountsByFromValue, getSwapAmountsByToValue } from "../swap/index.js";
-import { convertToTokenAmount, convertToUsd, getIsEquivalentTokens, getTokensRatioByPrice } from "../tokens.js";
-import { maxUint256 } from "viem";
+    ExternalSwapQuote,
+    ExternalSwapQuoteParams,
+    FindSwapPath,
+    IncreasePositionAmounts,
+    NextPositionValues,
+    SwapOptimizationOrderArray,
+    TriggerThresholdType,
+} from "../../types/trade.js";
+import {bigMath} from "../../utils/bigmath.js";
+import {
+    capPositionImpactUsdByMaxImpactPool,
+    capPositionImpactUsdByMaxPriceImpactFactor,
+    getPositionFee,
+    getPriceImpactForPosition,
+    getTotalSwapVolumeFromSwapStats,
+} from "../../utils/fees/index.js";
+import {applyFactor} from "../../utils/numbers.js";
+import {
+    getEntryPrice,
+    getLeverage,
+    getLiquidationPrice,
+    getPositionPnlUsd,
+    getPriceImpactDiffUsd,
+} from "../../utils/positions.js";
+import {
+    getAcceptablePriceInfo,
+    getDefaultAcceptablePriceImpactBps,
+    getMarkPrice,
+    getOrderThresholdType,
+} from "../../utils/prices.js";
+import {getSwapAmountsByFromValue, getSwapAmountsByToValue} from "../../utils/swap/index.js";
+import {convertToTokenAmount, convertToUsd, getIsEquivalentTokens, getTokensRatioByPrice} from "../../utils/tokens.js";
 
 type IncreasePositionParams = {
   marketInfo: MarketInfo;
@@ -41,6 +60,9 @@ type IncreasePositionParams = {
   strategy: "leverageBySize" | "leverageByCollateral" | "independent";
   findSwapPath: FindSwapPath;
   uiFeeFactor: bigint;
+  marketsInfoData: MarketsInfoData | undefined;
+  chainId: number;
+  externalSwapQuoteParams: ExternalSwapQuoteParams | undefined;
 };
 
 export function getIncreasePositionAmounts(p: IncreasePositionParams): IncreasePositionAmounts {
@@ -63,8 +85,24 @@ export function getIncreasePositionAmounts(p: IncreasePositionParams): IncreaseP
     userReferralInfo,
     uiFeeFactor,
     strategy,
+    marketsInfoData,
+    chainId,
+    externalSwapQuoteParams,
   } = p;
 
+  const swapStrategy: NoSwapStrategy = {
+    type: "noSwap",
+    externalSwapQuote: undefined,
+    swapPathStats: undefined,
+    amountIn: 0n,
+    amountOut: 0n,
+    usdIn: 0n,
+    usdOut: 0n,
+    priceIn: 0n,
+    priceOut: 0n,
+    feesUsd: 0n,
+  };
+
   const values: IncreasePositionAmounts = {
     initialCollateralAmount: 0n,
     initialCollateralUsd: 0n,
@@ -72,8 +110,7 @@ export function getIncreasePositionAmounts(p: IncreasePositionParams): IncreaseP
     collateralDeltaAmount: 0n,
     collateralDeltaUsd: 0n,
 
-    swapPathStats: undefined,
-    externalSwapQuote: undefined,
+    swapStrategy,
 
     indexTokenAmount: 0n,
 
@@ -88,6 +125,7 @@ export function getIncreasePositionAmounts(p: IncreasePositionParams): IncreaseP
     triggerPrice: 0n,
     acceptablePrice: 0n,
     acceptablePriceDeltaBps: 0n,
+    recommendedAcceptablePriceDeltaBps: 0n,
 
     positionFeeUsd: 0n,
     uiFeeUsd: 0n,
@@ -103,7 +141,7 @@ export function getIncreasePositionAmounts(p: IncreasePositionParams): IncreaseP
 
   const isLimit = limitOrderType !== undefined;
 
-  const swapOptimizationOrder: Parameters<FindSwapPath>[1]["order"] = isLimit ? ["length", "liquidity"] : undefined;
+  const swapOptimizationOrder: SwapOptimizationOrderArray | undefined = isLimit ? ["length", "liquidity"] : undefined;
 
   const prices = getIncreasePositionPrices({
     triggerPrice,
@@ -143,32 +181,39 @@ export function getIncreasePositionAmounts(p: IncreasePositionParams): IncreaseP
       values.initialCollateralPrice
     )!;
 
-    values.externalSwapQuote = externalSwapQuote;
-    const swapAmounts = getSwapAmountsByFromValue({
-      tokenIn: initialCollateralToken,
-      tokenOut: collateralToken,
-      amountIn: initialCollateralAmount,
-      isLimit: false,
-      findSwapPath,
-      uiFeeFactor,
-      swapOptimizationOrder,
-    });
-    values.swapPathStats = swapAmounts.swapPathStats;
+    if (externalSwapQuote) {
+      const swapStrategy: ExternalSwapStrategy = {
+        type: "externalSwap",
+        externalSwapQuote,
+        swapPathStats: undefined,
+        ...externalSwapQuote,
+      };
 
-    const swapAmountOut = values.externalSwapQuote?.amountOut ?? swapAmounts.amountOut;
+      values.swapStrategy = swapStrategy;
+    } else {
+      const swapAmounts = getSwapAmountsByFromValue({
+        tokenIn: initialCollateralToken,
+        tokenOut: collateralToken,
+        amountIn: initialCollateralAmount,
+        isLimit: false,
+        findSwapPath,
+        uiFeeFactor,
+        swapOptimizationOrder,
+        marketsInfoData,
+        chainId,
+        externalSwapQuoteParams,
+      });
+
+      values.swapStrategy = swapAmounts.swapStrategy;
+    }
+
+    const swapAmountOut = values.swapStrategy.amountOut;
     const baseCollateralUsd = convertToUsd(swapAmountOut, collateralToken.decimals, values.collateralPrice)!;
     const baseSizeDeltaUsd = bigMath.mulDiv(baseCollateralUsd, leverage, BASIS_POINTS_DIVISOR_BIGINT);
-    const basePriceImpactDeltaUsd = getPriceImpactForPosition(marketInfo, baseSizeDeltaUsd, isLong);
-    const basePositionFeeInfo = getPositionFee(
-      marketInfo,
-      baseSizeDeltaUsd,
-      basePriceImpactDeltaUsd > 0,
-      userReferralInfo
-    );
+    const { balanceWasImproved } = getPriceImpactForPosition(marketInfo, baseSizeDeltaUsd, isLong);
+    const basePositionFeeInfo = getPositionFee(marketInfo, baseSizeDeltaUsd, balanceWasImproved, userReferralInfo);
     const baseUiFeeUsd = applyFactor(baseSizeDeltaUsd, uiFeeFactor);
-    const totalSwapVolumeUsd = !values.externalSwapQuote
-      ? getTotalSwapVolumeFromSwapStats(values.swapPathStats?.swapSteps)
-      : 0n;
+    const totalSwapVolumeUsd = getTotalSwapVolumeFromSwapStats(values.swapStrategy.swapPathStats?.swapSteps);
     values.swapUiFeeUsd = applyFactor(totalSwapVolumeUsd, uiFeeFactor);
 
     values.sizeDeltaUsd = bigMath.mulDiv(
@@ -179,12 +224,7 @@ export function getIncreasePositionAmounts(p: IncreasePositionParams): IncreaseP
 
     values.indexTokenAmount = convertToTokenAmount(values.sizeDeltaUsd, indexToken.decimals, values.indexPrice)!;
 
-    const positionFeeInfo = getPositionFee(
-      marketInfo,
-      values.sizeDeltaUsd,
-      basePriceImpactDeltaUsd > 0,
-      userReferralInfo
-    );
+    const positionFeeInfo = getPositionFee(marketInfo, values.sizeDeltaUsd, balanceWasImproved, userReferralInfo);
     values.positionFeeUsd = positionFeeInfo.positionFeeUsd;
     values.feeDiscountUsd = positionFeeInfo.discountUsd;
     values.uiFeeUsd = applyFactor(values.sizeDeltaUsd, uiFeeFactor);
@@ -212,14 +252,9 @@ export function getIncreasePositionAmounts(p: IncreasePositionParams): IncreaseP
     values.indexTokenAmount = indexTokenAmount;
     values.sizeDeltaUsd = convertToUsd(indexTokenAmount, indexToken.decimals, values.indexPrice)!;
 
-    const basePriceImpactDeltaUsd = getPriceImpactForPosition(marketInfo, values.sizeDeltaUsd, isLong);
+    const { balanceWasImproved } = getPriceImpactForPosition(marketInfo, values.sizeDeltaUsd, isLong);
 
-    const positionFeeInfo = getPositionFee(
-      marketInfo,
-      values.sizeDeltaUsd,
-      basePriceImpactDeltaUsd > 0,
-      userReferralInfo
-    );
+    const positionFeeInfo = getPositionFee(marketInfo, values.sizeDeltaUsd, balanceWasImproved, userReferralInfo);
 
     values.positionFeeUsd = positionFeeInfo.positionFeeUsd;
     values.feeDiscountUsd = positionFeeInfo.discountUsd;
@@ -241,18 +276,31 @@ export function getIncreasePositionAmounts(p: IncreasePositionParams): IncreaseP
     values.collateralDeltaUsd = collateralDeltaUsd;
     values.collateralDeltaAmount = collateralDeltaAmount;
 
-    values.externalSwapQuote = externalSwapQuote;
+    if (externalSwapQuote) {
+      const swapStrategy: ExternalSwapStrategy = {
+        type: "externalSwap",
+        externalSwapQuote,
+        swapPathStats: undefined,
+        ...externalSwapQuote,
+      };
 
-    const swapAmounts = getSwapAmountsByToValue({
-      tokenIn: initialCollateralToken,
-      tokenOut: collateralToken,
-      amountOut: baseCollateralAmount,
-      isLimit: false,
-      findSwapPath,
-      uiFeeFactor,
-    });
-    values.swapPathStats = swapAmounts.swapPathStats;
-    const swapAmountIn = values.externalSwapQuote?.amountIn ?? swapAmounts.amountIn;
+      values.swapStrategy = swapStrategy;
+    } else {
+      const swapAmounts = getSwapAmountsByToValue({
+        tokenIn: initialCollateralToken,
+        tokenOut: collateralToken,
+        amountOut: baseCollateralAmount,
+        isLimit: false,
+        findSwapPath,
+        uiFeeFactor,
+        marketsInfoData,
+        chainId,
+        externalSwapQuoteParams,
+      });
+      values.swapStrategy = swapAmounts.swapStrategy;
+    }
+
+    const swapAmountIn = values.swapStrategy.amountIn;
 
     values.initialCollateralAmount = swapAmountIn;
     values.initialCollateralUsd = convertToUsd(
@@ -265,15 +313,9 @@ export function getIncreasePositionAmounts(p: IncreasePositionParams): IncreaseP
       values.indexTokenAmount = indexTokenAmount;
       values.sizeDeltaUsd = convertToUsd(indexTokenAmount, indexToken.decimals, values.indexPrice)!;
 
-      const basePriceImpactDeltaUsd = getPriceImpactForPosition(marketInfo, values.sizeDeltaUsd, isLong);
-
-      const positionFeeInfo = getPositionFee(
-        marketInfo,
-        values.sizeDeltaUsd,
-        basePriceImpactDeltaUsd > 0,
-        userReferralInfo
-      );
+      const { balanceWasImproved } = getPriceImpactForPosition(marketInfo, values.sizeDeltaUsd, isLong);
 
+      const positionFeeInfo = getPositionFee(marketInfo, values.sizeDeltaUsd, balanceWasImproved, userReferralInfo);
       values.positionFeeUsd = positionFeeInfo.positionFeeUsd;
       values.feeDiscountUsd = positionFeeInfo.discountUsd;
       values.uiFeeUsd = applyFactor(values.sizeDeltaUsd, uiFeeFactor);
@@ -287,21 +329,37 @@ export function getIncreasePositionAmounts(p: IncreasePositionParams): IncreaseP
         values.initialCollateralPrice
       )!;
 
-      values.externalSwapQuote = externalSwapQuote;
+      if (externalSwapQuote) {
+        const swapStrategy: ExternalSwapStrategy = {
+          type: "externalSwap",
+          externalSwapQuote,
+          swapPathStats: undefined,
+          ...externalSwapQuote,
+        };
 
-      const swapAmounts = getSwapAmountsByFromValue({
-        tokenIn: initialCollateralToken,
-        tokenOut: collateralToken,
-        amountIn: initialCollateralAmount,
-        isLimit: false,
-        findSwapPath,
-        uiFeeFactor,
-        swapOptimizationOrder,
-      });
+        values.swapStrategy = swapStrategy;
+      } else {
+        const swapAmounts = getSwapAmountsByFromValue({
+          tokenIn: initialCollateralToken,
+          tokenOut: collateralToken,
+          amountIn: initialCollateralAmount,
+          isLimit: false,
+          findSwapPath,
+          uiFeeFactor,
+          swapOptimizationOrder,
+          marketsInfoData,
+          chainId,
+          externalSwapQuoteParams,
+        });
+        values.swapStrategy = swapAmounts.swapStrategy;
+      }
 
-      values.swapPathStats = swapAmounts.swapPathStats;
-      const swapAmountIn = values.externalSwapQuote?.amountIn ?? swapAmounts.amountIn;
-      const baseCollateralUsd = convertToUsd(swapAmountIn, collateralToken.decimals, values.collateralPrice)!;
+      const swapAmountIn = values.swapStrategy.amountIn;
+      const baseCollateralUsd = convertToUsd(
+        swapAmountIn,
+        initialCollateralToken.decimals,
+        values.initialCollateralPrice
+      )!;
 
       values.collateralDeltaUsd =
         baseCollateralUsd -
@@ -330,12 +388,14 @@ export function getIncreasePositionAmounts(p: IncreasePositionParams): IncreaseP
   const acceptablePriceInfo = getAcceptablePriceInfo({
     marketInfo,
     isIncrease: true,
+    isLimit,
     isLong,
     indexPrice: values.indexPrice,
     sizeDeltaUsd: values.sizeDeltaUsd,
   });
 
   values.positionPriceImpactDeltaUsd = acceptablePriceInfo.priceImpactDeltaUsd;
+
   values.acceptablePrice = acceptablePriceInfo.acceptablePrice;
   values.acceptablePriceDeltaBps = acceptablePriceInfo.acceptablePriceDeltaBps;
 
@@ -348,20 +408,23 @@ export function getIncreasePositionAmounts(p: IncreasePositionParams): IncreaseP
       }
     } else {
       let maxNegativePriceImpactBps = fixedAcceptablePriceImpactBps;
+      values.recommendedAcceptablePriceDeltaBps = getDefaultAcceptablePriceImpactBps({
+        isIncrease: true,
+        isLong,
+        indexPrice: values.indexPrice,
+        sizeDeltaUsd: values.sizeDeltaUsd,
+        priceImpactDeltaUsd: values.positionPriceImpactDeltaUsd,
+        acceptablePriceImapctBuffer: acceptablePriceImpactBuffer || DEFAULT_ACCEPTABLE_PRICE_IMPACT_BUFFER,
+      });
+
       if (maxNegativePriceImpactBps === undefined) {
-        maxNegativePriceImpactBps = getDefaultAcceptablePriceImpactBps({
-          isIncrease: true,
-          isLong,
-          indexPrice: values.indexPrice,
-          sizeDeltaUsd: values.sizeDeltaUsd,
-          priceImpactDeltaUsd: values.positionPriceImpactDeltaUsd,
-          acceptablePriceImapctBuffer: acceptablePriceImpactBuffer,
-        });
+        maxNegativePriceImpactBps = values.recommendedAcceptablePriceDeltaBps;
       }
 
       const limitAcceptablePriceInfo = getAcceptablePriceInfo({
         marketInfo,
         isIncrease: true,
+        isLimit,
         isLong,
         indexPrice: values.indexPrice,
         sizeDeltaUsd: values.sizeDeltaUsd,
@@ -373,24 +436,8 @@ export function getIncreasePositionAmounts(p: IncreasePositionParams): IncreaseP
     }
   }
 
-  let priceImpactAmount = 0n;
-
-  if (values.positionPriceImpactDeltaUsd > 0) {
-    const price = triggerPrice !== undefined && triggerPrice > 0 ? triggerPrice : indexToken.prices.maxPrice;
-    priceImpactAmount = convertToTokenAmount(values.positionPriceImpactDeltaUsd, indexToken.decimals, price)!;
-  } else {
-    const price = triggerPrice !== undefined && triggerPrice > 0 ? triggerPrice : indexToken.prices.minPrice;
-    priceImpactAmount = convertToTokenAmount(values.positionPriceImpactDeltaUsd, indexToken.decimals, price)!;
-  }
-
   values.sizeDeltaInTokens = convertToTokenAmount(values.sizeDeltaUsd, indexToken.decimals, values.indexPrice)!;
 
-  if (isLong) {
-    values.sizeDeltaInTokens = values.sizeDeltaInTokens + priceImpactAmount;
-  } else {
-    values.sizeDeltaInTokens = values.sizeDeltaInTokens - priceImpactAmount;
-  }
-
   return values;
 }
 
@@ -515,3 +562,115 @@ export function getIncreasePositionPrices({
     triggerPrice,
   };
 }
+
+export function getNextPositionValuesForIncreaseTrade(p: {
+  existingPosition?: PositionInfo;
+  marketInfo: MarketInfo;
+  collateralToken: TokenData;
+  positionPriceImpactDeltaUsd: bigint;
+  sizeDeltaUsd: bigint;
+  sizeDeltaInTokens: bigint;
+  collateralDeltaUsd: bigint;
+  collateralDeltaAmount: bigint;
+  indexPrice: bigint;
+  isLong: boolean;
+  showPnlInLeverage: boolean;
+  minCollateralUsd: bigint;
+  userReferralInfo: UserReferralInfo | undefined;
+}): NextPositionValues {
+  const {
+    existingPosition,
+    marketInfo,
+    collateralToken,
+    sizeDeltaUsd,
+    sizeDeltaInTokens,
+    collateralDeltaUsd,
+    collateralDeltaAmount,
+    indexPrice,
+    isLong,
+    showPnlInLeverage,
+    minCollateralUsd,
+    userReferralInfo,
+    positionPriceImpactDeltaUsd,
+  } = p;
+
+  const nextCollateralUsd = existingPosition ? existingPosition.collateralUsd + collateralDeltaUsd : collateralDeltaUsd;
+
+  const nextCollateralAmount = existingPosition
+    ? existingPosition.collateralAmount + collateralDeltaAmount
+    : collateralDeltaAmount;
+
+  const nextSizeUsd = existingPosition ? existingPosition.sizeInUsd + sizeDeltaUsd : sizeDeltaUsd;
+  const nextSizeInTokens = existingPosition ? existingPosition.sizeInTokens + sizeDeltaInTokens : sizeDeltaInTokens;
+
+  const nextEntryPrice =
+    getEntryPrice({
+      sizeInUsd: nextSizeUsd,
+      sizeInTokens: nextSizeInTokens,
+      indexToken: marketInfo.indexToken,
+    }) ?? indexPrice;
+
+  const nextPnl = existingPosition
+    ? getPositionPnlUsd({
+        marketInfo,
+        sizeInUsd: nextSizeUsd,
+        sizeInTokens: nextSizeInTokens,
+        markPrice: indexPrice,
+        isLong,
+      })
+    : undefined;
+
+  const nextLeverage = getLeverage({
+    sizeInUsd: nextSizeUsd,
+    collateralUsd: nextCollateralUsd,
+    pnl: showPnlInLeverage ? nextPnl : undefined,
+    pendingBorrowingFeesUsd: 0n, // deducted on order
+    pendingFundingFeesUsd: 0n, // deducted on order
+  });
+
+  const nextLiqPrice = getLiquidationPrice({
+    marketInfo,
+    collateralToken,
+    sizeInUsd: nextSizeUsd,
+    sizeInTokens: nextSizeInTokens,
+    collateralUsd: nextCollateralUsd,
+    collateralAmount: nextCollateralAmount,
+    minCollateralUsd,
+    pendingBorrowingFeesUsd: 0n, // deducted on order
+    pendingFundingFeesUsd: 0n, // deducted on order
+    pendingImpactAmount: existingPosition?.pendingImpactAmount ?? 0n,
+    isLong: isLong,
+    userReferralInfo,
+  });
+
+  let nextPendingImpactDeltaUsd =
+    existingPosition?.pendingImpactUsd !== undefined
+      ? existingPosition.pendingImpactUsd + positionPriceImpactDeltaUsd
+      : positionPriceImpactDeltaUsd;
+
+  const potentialPriceImpactDiffUsd = getPriceImpactDiffUsd({
+    totalImpactDeltaUsd: nextPendingImpactDeltaUsd,
+    marketInfo,
+    sizeDeltaUsd: nextSizeUsd,
+  });
+
+  if (nextPendingImpactDeltaUsd > 0) {
+    nextPendingImpactDeltaUsd = capPositionImpactUsdByMaxPriceImpactFactor(
+      marketInfo,
+      nextSizeUsd,
+      nextPendingImpactDeltaUsd
+    );
+  }
+
+  nextPendingImpactDeltaUsd = capPositionImpactUsdByMaxImpactPool(marketInfo, nextPendingImpactDeltaUsd);
+
+  return {
+    nextSizeUsd,
+    nextCollateralUsd,
+    nextEntryPrice,
+    nextLeverage,
+    nextLiqPrice,
+    nextPendingImpactDeltaUsd,
+    potentialPriceImpactDiffUsd,
+  };
+}
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/trade/trade.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/trade/trade.ts
index f6dcedc4..21d8f71a 100644
--- a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/trade/trade.ts
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/trade/trade.ts
@@ -1,15 +1,16 @@
-import { BASIS_POINTS_DIVISOR, BASIS_POINTS_DIVISOR_BIGINT } from "../../configs/factors.js";
-import { DecreasePositionSwapType } from "../../types/orders.js";
+import {BASIS_POINTS_DIVISOR, BASIS_POINTS_DIVISOR_BIGINT} from "../../configs/factors.js";
+import {DecreasePositionSwapType} from "../../types/orders.js";
 import {
-  DecreasePositionAmounts,
-  IncreasePositionAmounts,
-  SwapAmounts,
-  TradeFlags,
-  TradeMode,
-  TradeType,
+    DecreasePositionAmounts,
+    IncreasePositionAmounts,
+    SwapAmounts,
+    TradeFlags,
+    TradeMode,
+    TradeType,
 } from "../../types/trade.js";
-import { bigMath } from "../bigmath.js";
-import { getShouldUseMaxPrice } from "../prices.js";
+
+import {bigMath} from "../bigmath.js";
+import {getShouldUseMaxPrice} from "../prices.js";
 
 export function applySlippageToPrice(allowedSlippage: number, price: bigint, isIncrease: boolean, isLong: boolean) {
   const shouldIncreasePrice = getShouldUseMaxPrice(isIncrease, isLong);
@@ -42,10 +43,10 @@ export function getSwapCount({
 }) {
   if (isSwap) {
     if (!swapAmounts) return undefined;
-    return swapAmounts.swapPathStats?.swapPath.length ?? 0;
+    return swapAmounts.swapStrategy.swapPathStats?.swapPath.length ?? 0;
   } else if (isIncrease) {
     if (!increaseAmounts) return undefined;
-    return increaseAmounts.swapPathStats?.swapPath.length ?? 0;
+    return increaseAmounts.swapStrategy.swapPathStats?.swapPath.length ?? 0;
   } else {
     if (decreaseAmounts?.decreaseSwapType === undefined) return undefined;
     return decreaseAmounts.decreaseSwapType !== DecreasePositionSwapType.NoSwap ? 1 : 0;
@@ -60,7 +61,8 @@ export const createTradeFlags = (tradeType: TradeType, tradeMode: TradeMode): Tr
   const isMarket = tradeMode === TradeMode.Market;
   const isLimit = tradeMode === TradeMode.Limit || tradeMode === TradeMode.StopMarket;
   const isTrigger = tradeMode === TradeMode.Trigger;
-  const isIncrease = isPosition && (isMarket || isLimit);
+  const isTwap = tradeMode === TradeMode.Twap;
+  const isIncrease = isPosition && (isMarket || isLimit || isTwap);
 
   const tradeFlags: TradeFlags = {
     isLong,
@@ -71,6 +73,7 @@ export const createTradeFlags = (tradeType: TradeType, tradeMode: TradeMode): Tr
     isMarket,
     isLimit,
     isTrigger,
+    isTwap,
   };
 
   return tradeFlags;
diff --git a/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/tradeHistory.ts b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/tradeHistory.ts
new file mode 100644
index 00000000..05381c7c
--- /dev/null
+++ b/src/Managing.Web3Proxy/src/generated/gmxsdk/utils/tradeHistory.ts
@@ -0,0 +1,179 @@
+import {getAddress} from "viem";
+
+import type {MarketsInfoData} from "../types/markets.js";
+import type {TradeAction as SubsquidTradeAction} from "../types/subsquid.js";
+import {Token, TokensData} from "../types/tokens.js";
+import type {PositionTradeAction, SwapTradeAction} from "../types/tradeHistory.js";
+import {TradeActionType} from "../types/tradeHistory.js";
+
+import {getByKey} from "./objects.js";
+import {isIncreaseOrderType, isSwapOrderType} from "./orders.js";
+import {getSwapPathOutputAddresses} from "./swap/swapStats.js";
+import {parseContractPrice} from "./tokens.js";
+
+export function createRawTradeActionTransformer(
+  marketsInfoData: MarketsInfoData,
+  wrappedToken: Token,
+  tokensData: TokensData
+): (
+  value: SubsquidTradeAction,
+  index: number,
+  array: SubsquidTradeAction[]
+) => SwapTradeAction | PositionTradeAction | undefined {
+  return (rawAction) => {
+    const orderType = Number(rawAction.orderType);
+
+    if (isSwapOrderType(orderType)) {
+      const initialCollateralTokenAddress = getAddress(rawAction.initialCollateralTokenAddress!);
+      const swapPath = rawAction.swapPath!.map((address) => getAddress(address));
+
+      const swapPathOutputAddresses = getSwapPathOutputAddresses({
+        marketsInfoData,
+        swapPath,
+        initialCollateralAddress: initialCollateralTokenAddress,
+        wrappedNativeTokenAddress: wrappedToken.address,
+        shouldUnwrapNativeToken: rawAction.shouldUnwrapNativeToken!,
+        isIncrease: false,
+      });
+
+      const initialCollateralToken = getByKey(tokensData, initialCollateralTokenAddress)!;
+      const targetCollateralToken = getByKey(tokensData, swapPathOutputAddresses.outTokenAddress)!;
+
+      if (!initialCollateralToken || !targetCollateralToken) {
+        return undefined;
+      }
+
+      const tradeAction: SwapTradeAction = {
+        id: rawAction.id,
+        srcChainId: rawAction.srcChainId ? Number(rawAction.srcChainId) : undefined,
+        eventName: rawAction.eventName as TradeActionType,
+        account: rawAction.account,
+        swapPath,
+        orderType,
+        orderKey: rawAction.orderKey,
+        initialCollateralTokenAddress: rawAction.initialCollateralTokenAddress!,
+        initialCollateralDeltaAmount: bigNumberify(rawAction.initialCollateralDeltaAmount)!,
+        minOutputAmount: bigNumberify(rawAction.minOutputAmount)!,
+        executionAmountOut: rawAction.executionAmountOut ? bigNumberify(rawAction.executionAmountOut) : undefined,
+        shouldUnwrapNativeToken: rawAction.shouldUnwrapNativeToken!,
+        targetCollateralToken,
+        initialCollateralToken,
+        timestamp: rawAction.timestamp,
+        transaction: rawAction.transaction,
+        reason: rawAction.reason ?? undefined,
+        reasonBytes: rawAction.reasonBytes ?? undefined,
+        twapParams:
+          rawAction.twapGroupId && rawAction.numberOfParts
+            ? {
+                twapGroupId: rawAction.twapGroupId,
+                numberOfParts: rawAction.numberOfParts,
+              }
+            : undefined,
+      };
+
+      return tradeAction;
+    } else {
+      const marketAddress = getAddress(rawAction.marketAddress!);
+      const marketInfo = getByKey(marketsInfoData, marketAddress);
+      const indexToken = marketInfo?.indexToken;
+      const initialCollateralTokenAddress = getAddress(rawAction.initialCollateralTokenAddress!);
+      const swapPath = rawAction.swapPath!.map((address) => getAddress(address));
+      const swapPathOutputAddresses = getSwapPathOutputAddresses({
+        marketsInfoData,
+        swapPath,
+        initialCollateralAddress: initialCollateralTokenAddress,
+        wrappedNativeTokenAddress: wrappedToken.address,
+        shouldUnwrapNativeToken: rawAction.shouldUnwrapNativeToken!,
+        isIncrease: isIncreaseOrderType(rawAction.orderType),
+      });
+      const initialCollateralToken = getByKey(tokensData, initialCollateralTokenAddress);
+      const targetCollateralToken = getByKey(tokensData, swapPathOutputAddresses.outTokenAddress);
+
+      if (!marketInfo || !indexToken || !initialCollateralToken || !targetCollateralToken) {
+        return undefined;
+      }
+
+      const tradeAction: PositionTradeAction = {
+        id: rawAction.id,
+        eventName: rawAction.eventName as TradeActionType,
+        account: rawAction.account,
+        marketAddress,
+        marketInfo,
+        srcChainId: rawAction.srcChainId ? Number(rawAction.srcChainId) : undefined,
+        indexToken,
+        swapPath,
+        initialCollateralTokenAddress,
+        initialCollateralToken,
+        targetCollateralToken,
+        initialCollateralDeltaAmount: bigNumberify(rawAction.initialCollateralDeltaAmount)!,
+        sizeDeltaUsd: bigNumberify(rawAction.sizeDeltaUsd)!,
+        triggerPrice: rawAction.triggerPrice
+          ? parseContractPrice(bigNumberify(rawAction.triggerPrice)!, indexToken.decimals)
+          : undefined,
+        acceptablePrice: parseContractPrice(bigNumberify(rawAction.acceptablePrice)!, indexToken.decimals),
+        executionPrice: rawAction.executionPrice
+          ? parseContractPrice(bigNumberify(rawAction.executionPrice)!, indexToken.decimals)
+          : undefined,
+        minOutputAmount: bigNumberify(rawAction.minOutputAmount)!,
+
+        collateralTokenPriceMax: rawAction.collateralTokenPriceMax
+          ? parseContractPrice(bigNumberify(rawAction.collateralTokenPriceMax)!, initialCollateralToken.decimals)
+          : undefined,
+
+        collateralTokenPriceMin: rawAction.collateralTokenPriceMin
+          ? parseContractPrice(bigNumberify(rawAction.collateralTokenPriceMin)!, initialCollateralToken.decimals)
+          : undefined,
+
+        indexTokenPriceMin: rawAction.indexTokenPriceMin
+          ? parseContractPrice(BigInt(rawAction.indexTokenPriceMin), indexToken.decimals)
+          : undefined,
+        indexTokenPriceMax: rawAction.indexTokenPriceMax
+          ? parseContractPrice(BigInt(rawAction.indexTokenPriceMax), indexToken.decimals)
+          : undefined,
+
+        orderType,
+        orderKey: rawAction.orderKey,
+        isLong: rawAction.isLong!,
+        pnlUsd: rawAction.pnlUsd ? BigInt(rawAction.pnlUsd) : undefined,
+        basePnlUsd: rawAction.basePnlUsd ? BigInt(rawAction.basePnlUsd) : undefined,
+
+        priceImpactDiffUsd: rawAction.priceImpactDiffUsd ? BigInt(rawAction.priceImpactDiffUsd) : undefined,
+        priceImpactUsd: rawAction.priceImpactUsd ? BigInt(rawAction.priceImpactUsd) : undefined,
+        totalImpactUsd: rawAction.totalImpactUsd ? BigInt(rawAction.totalImpactUsd) : undefined,
+        positionFeeAmount: rawAction.positionFeeAmount ? BigInt(rawAction.positionFeeAmount) : undefined,
+        borrowingFeeAmount: rawAction.borrowingFeeAmount ? BigInt(rawAction.borrowingFeeAmount) : undefined,
+        fundingFeeAmount: rawAction.fundingFeeAmount ? BigInt(rawAction.fundingFeeAmount) : undefined,
+        liquidationFeeAmount: rawAction.liquidationFeeAmount ? BigInt(rawAction.liquidationFeeAmount) : undefined,
+
+        reason: rawAction.reason ?? undefined,
+        reasonBytes: rawAction.reasonBytes ?? undefined,
+
+        transaction: rawAction.transaction,
+        timestamp: rawAction.timestamp,
+        shouldUnwrapNativeToken: rawAction.shouldUnwrapNativeToken!,
+        twapParams:
+          rawAction.twapGroupId && rawAction.numberOfParts
+            ? {
+                twapGroupId: rawAction.twapGroupId,
+                numberOfParts: rawAction.numberOfParts,
+              }
+            : undefined,
+      };
+
+      return tradeAction;
+    }
+  };
+}
+
+export function bigNumberify(n?: bigint | string | null | undefined) {
+  try {
+    if (n === undefined) throw new Error("n is undefined");
+    if (n === null) throw new Error("n is null");
+
+    return BigInt(n);
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.error("bigNumberify error", e);
+    return undefined;
+  }
+}
diff --git a/src/Managing.Web3Proxy/src/plugins/custom/gmx.ts b/src/Managing.Web3Proxy/src/plugins/custom/gmx.ts
index f43108ac..a9472e79 100644
--- a/src/Managing.Web3Proxy/src/plugins/custom/gmx.ts
+++ b/src/Managing.Web3Proxy/src/plugins/custom/gmx.ts
@@ -5,17 +5,11 @@ import {GmxSdk} from '../../generated/gmxsdk/index.js'
 
 import {arbitrum} from 'viem/chains';
 import {getTokenBySymbol} from '../../generated/gmxsdk/configs/tokens.js';
-import {
-    Position,
-    PositionStatus,
-    Trade,
-    TradeDirection,
-    TradeStatus,
-    TradeType
-} from '../../generated/ManagingApiTypes.js';
+import {createSwapOrderTxn} from '../../generated/gmxsdk/modules/orders/transactions/createSwapOrderTxn.js';
+
 import {MarketInfo, MarketsInfoData} from '../../generated/gmxsdk/types/markets.js';
 import {MarketConfig, MARKETS} from '../../generated/gmxsdk/configs/markets.js'
-import {ARBITRUM} from '../../generated/gmxsdk/configs/chains.js'
+import {ARBITRUM, ContractsChainId} from '../../generated/gmxsdk/configs/chains.js'
 import {TokenData, TokensData} from '../../generated/gmxsdk/types/tokens.js';
 import {getByKey} from '../../generated/gmxsdk/utils/objects.js';
 import {GmxSdkConfig} from '../../generated/gmxsdk/types/sdk.js';
@@ -35,9 +29,17 @@ import {handleError} from '../../utils/errorHandler.js';
 import {Abi, zeroHash} from 'viem';
 import {CLAIMABLE_FUNDING_AMOUNT} from '../../generated/gmxsdk/configs/dataStore.js';
 import {hashDataMap, hashString} from '../../generated/gmxsdk/utils/hash.js';
-import {getContract} from '../../generated/gmxsdk/configs/contracts.js';
+import {ContractName, getContract} from '../../generated/gmxsdk/configs/contracts.js';
 import {abis} from '../../generated/gmxsdk/abis/index.js';
 import {approveContractImpl, getTokenAllowance} from './privy.js';
+import {
+    Position,
+    PositionStatus,
+    Trade,
+    TradeDirection,
+    TradeStatus,
+    TradeType
+} from '../../generated/ManagingApiTypes.js';
 
 // Cache implementation for markets info data
 interface CacheEntry {
@@ -50,12 +52,53 @@ interface CacheEntry {
 
 const CACHE_TTL = 30 * 60 * 1000; // 30 minutes in milliseconds
 const marketsCache = new Map<string, CacheEntry>();
+const MAX_CACHE_SIZE = 5; // Limit cache size to prevent memory issues
+const OPERATION_TIMEOUT = 30000; // 30 seconds timeout for operations
+
+const MEMORY_WARNING_THRESHOLD = 0.8; // Warn when memory usage exceeds 80%
+
+// Memory monitoring function
+function checkMemoryUsage() {
+    const used = process.memoryUsage();
+    const total = used.heapTotal;
+    const usage = used.heapUsed / total;
+    
+    if (usage > MEMORY_WARNING_THRESHOLD) {
+        console.warn(`⚠️  High memory usage detected: ${(usage * 100).toFixed(1)}% (${Math.round(used.heapUsed / 1024 / 1024)}MB / ${Math.round(total / 1024 / 1024)}MB)`);
+        
+        // Clear cache if memory usage is too high
+        if (usage > 0.9) {
+            console.warn(`🧹 Clearing markets cache due to high memory usage`);
+            marketsCache.clear();
+            pendingRequests.clear();
+        }
+    }
+}
 
 // Fallback RPC configuration
 const FALLBACK_RPC_URL = "https://radial-shy-cherry.arbitrum-mainnet.quiknode.pro/098e57e961b05b24bcde008c4ca02fff6fb13b51/";
 const PRIMARY_RPC_URL = "https://arb1.arbitrum.io/rpc";
 const MAX_RETRY_ATTEMPTS = 2; // Only allow one retry to prevent infinite loops
 
+
+/**
+ * Wrapper function to add timeout to operations
+ * @param operation The operation to execute
+ * @param timeoutMs Timeout in milliseconds
+ * @returns Promise that rejects if timeout is exceeded
+ */
+async function withTimeout<T>(
+    operation: Promise<T>,
+    timeoutMs: number
+): Promise<T> {
+    return Promise.race([
+        operation,
+        new Promise<never>((_, reject) => 
+            setTimeout(() => reject(new Error(`Operation timed out after ${timeoutMs}ms`)), timeoutMs)
+        )
+    ]);
+}
+
 /**
  * Generic fallback method for GMX operations that can retry with a fallback RPC
  * @param operation The operation function to execute
@@ -70,13 +113,20 @@ async function executeWithFallback<T>(
 ): Promise<T> {
     try {
         console.log(`🔄 Executing operation with retry count: ${retryCount}, RPC: ${retryCount === 0 ? 'Primary' : 'Fallback'}`);
-        return await operation(sdk, retryCount);
+        return await withTimeout(operation(sdk, retryCount), OPERATION_TIMEOUT);
     } catch (error) {
         // Check if this is a multicall timeout error and we haven't exceeded retry limit
         const errorMessage = error instanceof Error ? error.message : String(error);
         const isMulticallTimeout = errorMessage.toLowerCase().includes('multicall timeout') || 
                                   errorMessage.toLowerCase().includes('timeout') ||
-                                  errorMessage.toLowerCase().includes('rpc error');
+                                  errorMessage.toLowerCase().includes('rpc error') ||
+                                  errorMessage.toLowerCase().includes('network error') ||
+                                  errorMessage.toLowerCase().includes('rate limit error') ||
+                                  errorMessage.toLowerCase().includes('http request failed') ||
+                                  errorMessage.toLowerCase().includes('503') ||
+                                  errorMessage.toLowerCase().includes('allocation failed') ||
+                                  errorMessage.toLowerCase().includes('heap out of memory') ||
+                                  errorMessage.toLowerCase().includes('contract function execution error');
         
         if (isMulticallTimeout && retryCount < MAX_RETRY_ATTEMPTS) {
             console.log(`🔄 Multicall timeout detected (attempt ${retryCount + 1}/${MAX_RETRY_ATTEMPTS + 1}), retrying with fallback RPC...`);
@@ -113,7 +163,13 @@ async function executeWithFallback<T>(
  * @param sdk The GMX SDK client
  * @returns Markets info data and tokens data
  */
+// Add a promise cache to prevent concurrent calls to the same endpoint
+const pendingRequests = new Map<string, Promise<{ marketsInfoData: MarketsInfoData; tokensData: TokensData }>>();
+
 async function getMarketsInfoWithCache(sdk: GmxSdk): Promise<{ marketsInfoData: MarketsInfoData; tokensData: TokensData }> {
+    // Check memory usage before proceeding
+    checkMemoryUsage();
+    
     const cacheKey = `markets_${sdk.chainId}`;
     const now = Date.now();
     const cached = marketsCache.get(cacheKey);
@@ -125,18 +181,118 @@ async function getMarketsInfoWithCache(sdk: GmxSdk): Promise<{ marketsInfoData:
         return cached.data as { marketsInfoData: MarketsInfoData; tokensData: TokensData };
     }
 
-    const data = await sdk.markets.getMarketsInfo();
-    
-    if (!data.marketsInfoData || !data.tokensData) {
-        throw new Error("Invalid response from GMX: missing markets or tokens info");
+    // Check if there's already a pending request for this chain
+    if (pendingRequests.has(cacheKey)) {
+        return pendingRequests.get(cacheKey)!;
     }
 
-    marketsCache.set(cacheKey, {
-        data: data as { marketsInfoData: MarketsInfoData; tokensData: TokensData },
-        timestamp: now
-    });
+    // Create a new request and cache the promise
+    const requestPromise = (async () => {
+        try {
+            console.log(`🔄 Fetching markets info for chain ${sdk.chainId}...`);
+            const data = await withTimeout(sdk.markets.getMarketsInfo(), OPERATION_TIMEOUT);
+            
+            if (!data.marketsInfoData || !data.tokensData) {
+                throw new Error("Invalid response from GMX: missing markets or tokens info");
+            }
 
-    return data as { marketsInfoData: MarketsInfoData; tokensData: TokensData };
+            // Implement cache size limit to prevent memory issues
+            if (marketsCache.size >= MAX_CACHE_SIZE) {
+                // Remove the oldest entry
+                const oldestKey = marketsCache.keys().next().value;
+                marketsCache.delete(oldestKey);
+            }
+            
+            marketsCache.set(cacheKey, {
+                data: data as { marketsInfoData: MarketsInfoData; tokensData: TokensData },
+                timestamp: now
+            });
+
+            console.log(`✅ Markets info cached for chain ${sdk.chainId}`);
+            return data as { marketsInfoData: MarketsInfoData; tokensData: TokensData };
+        } catch (error) {
+            console.error(`❌ Failed to fetch markets info for chain ${sdk.chainId}:`, error);
+            
+            // If RPC is failing, return empty data to prevent memory issues
+            const emptyData = {
+                marketsInfoData: {} as MarketsInfoData,
+                tokensData: {} as TokensData
+            };
+            
+            // Cache the empty data for a shorter time to allow retries
+            marketsCache.set(cacheKey, {
+                data: emptyData,
+                timestamp: now - (CACHE_TTL - 60000) // Cache for only 1 minute
+            });
+            
+            console.log(`⚠️  Returning empty markets data for chain ${sdk.chainId} due to RPC failure`);
+            return emptyData;
+        } finally {
+            // Remove the pending request when done
+            pendingRequests.delete(cacheKey);
+        }
+    })();
+
+    pendingRequests.set(cacheKey, requestPromise);
+    return requestPromise;
+}
+
+/**
+ * Private helper to approve a contract for a token
+ * @param sdk The GMX SDK client
+ * @param fromTicker The token ticker symbol
+ * @param fromTokenData The token data
+ * @param fromTokenAmount The amount to approve
+ * @param contractName The contract name to approve
+ * @returns Promise<void>
+ */
+async function approveTokenForContract(
+    sdk: GmxSdk,
+    fromTicker: string,
+    fromTokenData: TokenData,
+    fromTokenAmount: bigint,
+    contractName: string
+): Promise<void> {
+    // If ticker ETH no need to check allowance
+    if (fromTicker === "ETH") {
+        console.log(`✅ ETH no need to check allowance`);
+        return;
+    }
+
+    try {
+        const contractAddress = getContract(sdk.chainId, contractName as ContractName);
+        
+        const currentAllowance = await getTokenAllowance(
+            sdk.account,
+            fromTokenData.address,
+            contractAddress
+        );
+
+        console.log(`Current allowance for ${fromTicker}:`, currentAllowance);
+        console.log(`Required amount:`, fromTokenAmount);
+
+        if (currentAllowance < fromTokenAmount) {
+            console.log(`🔧 Insufficient allowance for ${fromTicker}. Auto-approving ${contractName}...`);
+            
+            // Approve maximum amount (2^256 - 1) to avoid future approval transactions
+            const maxApprovalAmount = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
+            const approvalHash = await approveContractImpl(
+                sdk.account,
+                fromTokenData.address,
+                contractAddress,
+                sdk.chainId,
+                maxApprovalAmount
+            );
+            
+            console.log(`✅ Token approval successful! Hash: ${approvalHash}`);
+            console.log(`📝 Approved maximum amount ${fromTicker} for ${contractName}`);
+        } else {
+            console.log(`✅ Sufficient allowance already exists for ${fromTicker}`);
+        }
+    } catch (allowanceError) {
+        console.warn('Could not check or approve token allowance:', allowanceError);
+        throw new Error(`Failed to handle token allowance: ${allowanceError instanceof Error ? allowanceError.message : 'Unknown error'}`);
+    }
 }
 
 /**
@@ -250,57 +406,13 @@ export async function createGmxClientWithRpc(
             oracleUrl: "https://arbitrum-api.gmxinfra.io",
             rpcUrl: rpcUrl,
             subsquidUrl: "https://gmx.squids.live/gmx-synthetics-arbitrum:prod/api/graphql",
-            subgraphUrl: "https://subgraph.satsuma-prod.com/3b2ced13c8d9/gmx/synthetics-arbitrum-stats/api",
             settings: {
                 uiFeeReceiverAccount: process.env.GMX_UI_FEE_RECEIVER
             },
             markets: {
-                "0x4D3Eb91efd36C2b74181F34B111bc1E91a0d0cb4": {
-                    isListed: false,
-                },
                 "0xdf034cd3df9a80eABFA0556232a91E03Ca67D5Cb": {
                     isListed: false,
                 },
-                "0x9e79146b3A022Af44E0708c6794F03Ef798381A5": {
-                    isListed: false,
-                },
-                "0x2523B89298908FEf4c5e5bd6F55F20926e22058f": {
-                    isListed: false,
-                },
-                "0x7c54D547FAD72f8AFbf6E5b04403A0168b654C6f": {
-                    isListed: false,
-                },
-                "0x39AC3C494950A4363D739201BA5A0861265C9ae5": {
-                    isListed: false,
-                },
-                "0x0e46941F9bfF8d0784BFfa3d0D7883CDb82D7aE7": {
-                    isListed: false,
-                },
-                "0x4C0Bb704529Fa49A26bD854802d70206982c6f1B": {
-                    isListed: false,
-                },
-                "0x672fEA44f4583DdaD620d60C1Ac31021F47558Cb": {
-                    isListed: false,
-                },
-                "0x8263bC3766a09f6dD4Bab04b4bf8D45F2B0973FF": {
-                    isListed: false,
-                },
-                "0x6eb8f24C5870c543875E4D9518c971ccB804520F": {
-                    isListed: false,
-                },
-                "0x40dAEAc02dCf6b3c51F9151f532C21DCEF2F7E63": {
-                    isListed: false,
-                },
-                "0x3B7f4e4Cf2fa43df013d2B32673e6A01d29ab2Ac": {
-                    isListed: false,
-                },
-                "0x9f0849FB830679829d1FB759b11236D375D15C78": { 
-                    isListed: false,
-                },
-                "0xa29FfE4152B65A0347512Ae5c6A4Bbc7a3d6d51B": {
-                    isListed: false,
-                }
-
             }
         };
 
@@ -392,6 +504,9 @@ export const openGmxPositionImpl = async (
                 takeProfitPrice: takeProfitPrice ? numberToBigint(takeProfitPrice, 30) : undefined,
                 acceptablePriceImpactBuffer: 150,
                 limitPrice: limitPrice,
+                // Add required fields from BaseOptionalParams
+                marketsInfoData: marketsInfoData,
+                tokensData: tokensData,
             };
 
             console.log('📋 Position params:', {
@@ -593,8 +708,22 @@ function getMarketInfoFromTicker(ticker: string, marketsInfoData: MarketsInfoDat
 }
 
 export function getTokenDataFromTicker(ticker: string, tokensData: TokensData): TokenData {
-    const token = getTokenBySymbol(arbitrum.id, ticker);
-    return getByKey(tokensData, token.address);
+    console.log(`🔍 Looking up token for ticker: ${ticker}`);
+    const token = getTokenBySymbol(arbitrum.id, ticker, { version: "v2", isSynthetic: false });
+    console.log(`📋 Token found:`, {
+        symbol: token.symbol,
+        address: token.address,
+        decimals: token.decimals,
+        isNative: token.isNative
+    });
+    const tokenData = getByKey(tokensData, token.address);
+    console.log(`📊 Token data:`, {
+        address: tokenData?.address,
+        decimals: tokenData?.decimals,
+        isNative: tokenData?.isNative,
+        symbol: tokenData?.symbol
+    });
+    return tokenData;
 }
 
 /**
@@ -681,7 +810,10 @@ export const closeGmxPositionImpl = async (
                 borrowingFeeUsd: 0n,
                 fundingFeeUsd: 0n,
                 swapProfitFeeUsd: 0n,
-                positionPriceImpactDeltaUsd: 0n,
+                proportionalPendingImpactDeltaUsd: 0n,
+                closePriceImpactDeltaUsd: 0n,
+                totalPendingImpactDeltaUsd: 0n,
+                balanceWasImproved: false,
                 priceImpactDiffUsd: 0n,
                 payedRemainingCollateralAmount: 0n,
                 payedOutputUsd: 0n,
@@ -696,7 +828,7 @@ export const closeGmxPositionImpl = async (
                 triggerPrice: position.markPrice,
             }
 
-            const params2 = {
+            const params = {
                 marketInfo,
                 marketsInfoData,
                 tokensData,
@@ -704,11 +836,11 @@ export const closeGmxPositionImpl = async (
                 allowedSlippage: 30,
                 decreaseAmounts,
                 collateralToken: position.marketInfo.shortToken,
-                referralCodeForTxn: encodeReferralCode("kaigen_ai"),
+                referralCode: encodeReferralCode("kaigen_ai"),
             }
 
             // Execute the close position order
-            await sdk.orders.createDecreaseOrder(params2);
+            await sdk.orders.createDecreaseOrder(params);
 
             return "hash";
         }, sdk, 0
@@ -833,7 +965,9 @@ export const getGmxTradeImpl = async (
                         status: TradeStatus.PendingOpen, // Assuming these are pending orders
                         tradeType: order.orderType == OrderType.LimitIncrease ? TradeType.Limit : TradeType.Market,
                         date: new Date(Number(order.updatedAtTime) * 1000), // Convert BigInt to Number first
-                        exchangeOrderId: order.key
+                        exchangeOrderId: order.key,
+                        fee: 0, // Add missing fee property
+                        message: "" // Add missing message property
                     } as Trade;
                 });
 
@@ -884,7 +1018,8 @@ export const getGmxPositionsImpl = async (
 ): Promise<Position[]> => {
     return executeWithFallback(
         async (sdk, retryCount) => {
-            const {marketsInfoData, tokensData} = await sdk.markets.getMarketsInfo();
+            // Fetch market info and tokens data once for all positions
+            const {marketsInfoData, tokensData} = await getMarketsInfoWithCache(sdk);
 
             const positionsInfo = await sdk.positions.getPositionsInfo({
                 marketsInfoData,
@@ -892,7 +1027,71 @@ export const getGmxPositionsImpl = async (
                 showPnlInLeverage: true,
             });
 
-            const positions = Object.values(positionsInfo).map(async (pos) => {
+            // Fetch all orders once for all positions to avoid multiple API calls
+            const orders = await sdk.orders.getOrders({
+                account: sdk.account,
+                marketsInfoData,
+                tokensData
+            });
+
+            // Group orders by ticker for efficient lookup
+            const ordersByTicker = new Map<string, Trade[]>();
+            Object.values(orders.ordersInfoData).forEach(order => {
+                if ('marketInfo' in order) {
+                    const ticker = order.marketInfo.indexToken.symbol.toUpperCase();
+                    if (!ordersByTicker.has(ticker)) {
+                        ordersByTicker.set(ticker, []);
+                    }
+                    
+                    const positionOrder = order as PositionOrderInfo;
+                    const priceDecimals = calculateDisplayDecimals(
+                        positionOrder.indexToken.prices?.minPrice,
+                        undefined,
+                        positionOrder.indexToken.visualMultiplier
+                    );
+
+                    const triggerPrice = order.contractTriggerPrice ?? 0n;
+                    const sizeDelta = order.sizeDeltaUsd ?? 0n;
+                    const initialCollateral = order.initialCollateralDeltaAmount ?? 0n;
+
+                    let leverage = 2;
+                    if (initialCollateral !== 0n) {
+                        const size = Number(sizeDelta) / 1e30;
+                        const collateral = Number(initialCollateral) / 1e6;
+                        if (collateral > 0) {
+                            leverage = Math.round(size / collateral);
+                        }
+                    }
+
+                    const displayPrice = formatUsd(positionOrder.triggerPrice, {
+                        displayDecimals: priceDecimals,
+                        visualMultiplier: positionOrder.indexToken?.visualMultiplier,
+                    });
+
+                    const numericPrice = Number(displayPrice.replace(/[^0-9.]/g, ''));
+                    const sizeInTokens = Number(sizeDelta) / Number(triggerPrice);
+                    const scaledTokenSize = sizeInTokens * 1e-30;
+
+                    const trade: Trade = {
+                        id: order.key,
+                        ticker: ticker,
+                        direction: order.isLong ? TradeDirection.Short : TradeDirection.Long,
+                        price: numericPrice,
+                        quantity: scaledTokenSize,
+                        leverage: leverage,
+                        status: TradeStatus.PendingOpen,
+                        tradeType: order.orderType == OrderType.LimitIncrease ? TradeType.Limit : TradeType.Market,
+                        date: new Date(Number(order.updatedAtTime) * 1000),
+                        exchangeOrderId: order.key,
+                        fee: 0,
+                        message: ""
+                    } as Trade;
+
+                    ordersByTicker.get(ticker)!.push(trade);
+                }
+            });
+
+            const positions = Object.values(positionsInfo).map((pos) => {
                 // Fix leverage calculation to avoid exponential notation issues
                 let leverage = 1; // Default to 1x leverage
 
@@ -914,8 +1113,8 @@ export const getGmxPositionsImpl = async (
                 const collateralDecimals = pos.isLong ? pos.marketInfo.shortToken.decimals : pos.marketInfo.longToken.decimals;
 
                 const ticker = pos.marketInfo.indexToken.symbol;
-                // get SL and TP from the position
-                const trades = await getGmxTradeImpl(sdk, ticker);
+                // Get trades from the pre-fetched orders by ticker
+                const trades = ordersByTicker.get(ticker.toUpperCase()) || [];
 
                 // Calculate proper price display decimals
                 const priceDecimals = calculateDisplayDecimals(
@@ -983,11 +1182,11 @@ export const getGmxPositionsImpl = async (
                 } as unknown as Position; // Use unknown assertion due to missing fields in target Position type
 
                 if (stopLoss) {
-                    position.stopLoss = stopLoss;
+                    position.StopLoss = stopLoss;
                 }
 
                 if (takeProfit) {
-                    position.takeProfit1 = takeProfit;
+                    position.TakeProfit1 = takeProfit;
                 }
 
                 // build the open trade base on the current position object
@@ -996,15 +1195,15 @@ export const getGmxPositionsImpl = async (
                     price: numericEntryPrice,
                     quantity: tokenSize,
                     leverage: leverage,
-                    status: TradeStatus.PendingOpen,
+                    status: TradeStatus.Filled,
                 } as Trade;
 
-                position.open = open;
+                position.Open = open;
 
                 return position;
             });
 
-            return Promise.all(positions);
+            return positions;
         }, sdk, retryCount
     );
 };
@@ -1073,25 +1272,30 @@ export default fp(async (fastify) => {
     fastify.decorateRequest('swapGmxTokens', swapGmxTokens)
     fastify.decorateRequest('checkGmxTokenAllowances', checkGmxTokenAllowances)
 
-    // Pre-populate and refresh the markets cache on startup
-    fastify.addHook('onReady', async () => {
+    // Set up cache refresh without blocking plugin registration
+    setupCacheRefresh();
+    
+    // Initialize cache asynchronously without blocking
+    setImmediate(async () => {
         try {
             await getMarketsData();
-            setupCacheRefresh();
         } catch (error) {
-            console.error('Initial cache population failed:', error);
-            process.exit(1);
+            console.warn('Initial cache population failed, but continuing:', error);
+            // The cache will be populated when first needed
         }
     });
 
-    try {
-        const sdk = await getClientForAddress("0x0000000000000000000000000000000000000000");
-        fastify.log.info('GMX client initialized successfully');
-        fastify.log.info('GMX UI Fee Receiver:', sdk.config.settings.uiFeeReceiverAccount);
-    } catch (error) {
-        fastify.log.error('Failed to initialize GMX client:', error);
-        throw error;
-    }
+    // Initialize GMX client asynchronously without blocking
+    setImmediate(async () => {
+        try {
+            const sdk = await getClientForAddress("0x0000000000000000000000000000000000000000");
+            fastify.log.info('GMX client initialized successfully');
+            fastify.log.info('GMX UI Fee Receiver:', sdk.config.settings.uiFeeReceiverAccount);
+        } catch (error) {
+            fastify.log.warn('GMX client initialization failed, but continuing:', error);
+            // The client will be initialized when actually needed
+        }
+    });
 })
 
 export const getGmxRebateStatsImpl = async (
@@ -1759,57 +1963,47 @@ export const swapGmxTokensImpl = async (
             const fromTokenData = getTokenDataFromTicker(fromTicker, tokensData);
             const toTokenData = getTokenDataFromTicker(toTicker, tokensData);
 
-            console.log("fromTokenData", fromTokenData);
+            console.log(`🔄 Swap details:`, {
+                fromTicker,
+                toTicker,
+                fromTokenAddress: fromTokenData?.address,
+                fromTokenIsNative: fromTokenData?.isNative,
+                toTokenAddress: toTokenData?.address,
+                toTokenIsNative: toTokenData?.isNative
+            });
+            
             if (!fromTokenData || !toTokenData) {
                 throw new Error(`Token data not found for ${fromTicker} or ${toTicker}`);
             }
-
+            
+            // Check for zero addresses (but allow native tokens like ETH)
+            if (fromTokenData.address === "0x0000000000000000000000000000000000000000" && !fromTokenData.isNative) {
+                throw new Error(`From token ${fromTicker} has zero address - token not found or invalid`);
+            }
+            if (toTokenData.address === "0x0000000000000000000000000000000000000000" && !toTokenData.isNative) {
+                throw new Error(`To token ${toTicker} has zero address - token not found or invalid`);
+            }
+            
             // Calculate the from token amount with proper decimals
             const fromTokenAmount = BigInt(Math.floor(amount * Math.pow(10, fromTokenData.decimals)));
-
-            // Check and handle token allowance for ExchangeRouter contract
-            const syntheticsRouterRouterAddress = getContract(sdk.chainId, "SyntheticsRouter");
             
-            // If ticker ETH no need to check allowance
-            if (fromTicker === "ETH") {
-                console.log(`✅ ETH no need to check allowance`);
-            }else {
-                try {
-                    const currentAllowance = await getTokenAllowance(
-                        sdk.account,
-                        fromTokenData.address,
-                        syntheticsRouterRouterAddress
-                    );
 
-                    console.log(`Current allowance for ${fromTicker}:`, currentAllowance.toString());
-                    console.log(`Required amount:`, fromTokenAmount.toString());
+            // Check and handle token allowance for SyntheticsRouter contract
+            await approveTokenForContract(
+                sdk,
+                fromTicker,
+                fromTokenData,
+                fromTokenAmount,
+                "SyntheticsRouter"
+            );
 
-                    if (currentAllowance < fromTokenAmount) {
-                        console.log(`🔧 Insufficient allowance for ${fromTicker}. Auto-approving ExchangeRouter...`);
-                        
-                        // Calculate a reasonable approval amount (use the larger of required amount or 1000 tokens)
-                        const tokenUnit = BigInt(Math.pow(10, fromTokenData.decimals));
-                        const minApprovalAmount = tokenUnit * 1000n; // 1000 tokens
-                        const approvalAmount = fromTokenAmount > minApprovalAmount ? fromTokenAmount : minApprovalAmount;
-                        
-                        const approvalHash = await approveContractImpl(
-                            sdk.account,
-                            fromTokenData.address,
-                            syntheticsRouterRouterAddress,
-                            sdk.chainId,
-                            approvalAmount
-                        );
-                        
-                        console.log(`✅ Token approval successful! Hash: ${approvalHash}`);
-                        console.log(`📝 Approved ${approvalAmount.toString()} ${fromTicker} for ExchangeRouter`);
-                    } else {
-                        console.log(`✅ Sufficient allowance already exists for ${fromTicker}`);
-                    }
-                } catch (allowanceError) {
-                    console.warn('Could not check or approve token allowance:', allowanceError);
-                    throw new Error(`Failed to handle token allowance: ${allowanceError instanceof Error ? allowanceError.message : 'Unknown error'}`);
-                }
-            }
+            await approveTokenForContract(
+                sdk,
+                fromTicker,
+                fromTokenData,
+                fromTokenAmount,
+                "ExchangeRouter"
+            );
 
             // Calculate trigger price for limit orders
             let triggerPrice: bigint | undefined;
@@ -1821,23 +2015,44 @@ export const swapGmxTokensImpl = async (
             // Convert slippage percentage to basis points
             const allowedSlippageBps = Math.floor(allowedSlippage * 100); // Convert percentage to basis points
 
-            // Create SwapParams for the SDK
-            const swapParams = {
-                fromAmount: fromTokenAmount,
-                fromTokenAddress: fromTokenData.address,
-                toTokenAddress: toTokenData.address,
-                allowedSlippageBps: allowedSlippageBps,
-                referralCodeForTxn: encodeReferralCode("kaigen_ai"),
-                skipSimulation: true,
-            } as SwapParams;
 
-            console.log("swapParams", swapParams);
+            // Try using the SDK's built-in swap method first
+            try {
+                const swapParams = {
+                    fromAmount: fromTokenAmount,
+                    fromTokenAddress: fromTokenData.address,
+                    toTokenAddress: toTokenData.address,
+                    allowedSlippageBps: allowedSlippageBps,
+                    referralCodeForTxn: encodeReferralCode("kaigen_ai"),
+                    skipSimulation: true,
+                } as SwapParams;
 
-            swapParams.marketsInfoData = marketsInfoData;
-            swapParams.tokensData = tokensData;
+                swapParams.marketsInfoData = marketsInfoData;
+                swapParams.tokensData = tokensData;
 
-            // Use the SDK's built-in swap method
-            await sdk.orders.swap(swapParams);
+                console.log('🔄 Attempting SDK swap...');
+                await sdk.orders.swap(swapParams);
+                console.log('✅ SDK swap successful!');
+            } catch (sdkError) {
+                console.log('❌ SDK swap failed, trying alternative approach:', sdkError);
+                
+                // Fall back to createSwapOrderTxn directly with simpler parameters
+                console.log('🔄 Attempting direct createSwapOrderTxn...');
+                await createSwapOrderTxn(sdk, {
+                    fromTokenAddress: fromTokenData.address,
+                    fromTokenAmount: fromTokenAmount,
+                    toTokenAddress: toTokenData.address,
+                    swapPath: [fromTokenData.address, toTokenData.address],
+                    orderType: OrderType.MarketSwap,
+                    minOutputAmount: BigInt(Math.floor(amount * Math.pow(10, toTokenData.decimals) * (1 - allowedSlippage / 100))),
+                    referralCode: encodeReferralCode("kaigen_ai"),
+                    executionFee: 100000000000000000n, // 0.1 ETH as execution fee
+                    allowedSlippage: allowedSlippageBps,
+                    tokensData: tokensData,
+                    skipSimulation: true,
+                });
+                console.log('✅ Direct createSwapOrderTxn successful!');
+            }
 
             return "swap_order_created";
         }, sdk, 0
@@ -1925,7 +2140,7 @@ export async function swapGmxTokens(
 export const checkGmxTokenAllowances = async (
     account: string,
     tokenAddress: string,
-    chainId: number = ARBITRUM
+    chainId: ContractsChainId = ARBITRUM
 ): Promise<{
     exchangeRouter: bigint;
     orderVault: bigint;
diff --git a/src/Managing.Web3Proxy/src/plugins/custom/privy.ts b/src/Managing.Web3Proxy/src/plugins/custom/privy.ts
index bc40dcc5..2f204a20 100644
--- a/src/Managing.Web3Proxy/src/plugins/custom/privy.ts
+++ b/src/Managing.Web3Proxy/src/plugins/custom/privy.ts
@@ -11,8 +11,8 @@ import {ARBITRUM} from '../../generated/gmxsdk/configs/chains.js'
 import {TOKENS} from '../../generated/gmxsdk/configs/tokens.js'
 import {CONTRACTS} from '../../generated/gmxsdk/configs/contracts.js'
 import {getClientForAddress, getTokenDataFromTicker} from './gmx.js'
-import {Balance, Chain, Ticker} from '../../generated/ManagingApiTypes.js'
 import {Address} from 'viem'
+import {Balance, Chain, Ticker} from '../../generated/ManagingApiTypes.js'
 
 // Load environment variables
 dotenv.config()
@@ -59,10 +59,10 @@ export const getPrivyClient = (fastify?: FastifyInstance): PrivyClient => {
   const authKey = fastify?.config?.PRIVY_AUTHORIZATION_KEY || process.env.PRIVY_AUTHORIZATION_KEY;
 
   if (!appId || !appSecret || !authKey) {
-    console.error('Missing Privy environment variables:');
-    console.error('PRIVY_APP_ID:', appId ? 'present' : 'missing');
-    console.error('PRIVY_APP_SECRET:', appSecret ? 'present' : 'missing');
-    console.error('PRIVY_AUTHORIZATION_KEY:', authKey ? 'present' : 'missing');
+    console.warn('Missing Privy environment variables:');
+    console.warn('PRIVY_APP_ID:', appId ? 'present' : 'missing');
+    console.warn('PRIVY_APP_SECRET:', appSecret ? 'present' : 'missing');
+    console.warn('PRIVY_AUTHORIZATION_KEY:', authKey ? 'present' : 'missing');
     throw new Error('Missing required Privy environment variables');
   }
 
@@ -822,7 +822,7 @@ export const sendTokenImpl = async (
   senderAddress: string,
   recipientAddress: string,
   ticker: string,
-  amount: bigint,
+  amount: string,
   chainId?: number,
 ): Promise<string> => {
   try {
@@ -830,6 +830,30 @@ export const sendTokenImpl = async (
     const networkName = getChainName(chainId);
     const privy = getPrivyClient();
 
+    // Handle decimal numbers with comma separators and convert to proper token units
+    // Replace comma with period for decimal parsing
+    const normalizedAmount = amount.replace(',', '.');
+    
+    // Parse as float first
+    const amountFloat = parseFloat(normalizedAmount);
+    
+    if (isNaN(amountFloat)) {
+      throw new Error(`Invalid amount format: ${amount}`);
+    }
+    
+    // Get token decimals from GMX configuration based on chain ID
+    const chainTokens = TOKENS[chainId];
+    const token = chainTokens?.find(t => t.symbol === ticker);
+    
+    if (!token) {
+      throw new Error(`Token not found: ${ticker} on chain ${chainId}`);
+    }
+    
+    const tokenDecimals = token.decimals;
+    const amountInSmallestUnit = Math.floor(amountFloat * Math.pow(10, tokenDecimals));
+    
+    const amountBigInt = BigInt(amountInSmallestUnit);
+
     if (ticker === 'ETH') {
       // Native ETH transfer: no allowance, no data, value is amount as hex string
       const { hash } = await privy.walletApi.ethereum.sendTransaction({
@@ -838,7 +862,7 @@ export const sendTokenImpl = async (
         caip2: networkName as string,
         transaction: {
           to: recipientAddress as Address,
-          value: '0x' + amount.toString(16), // value in wei as hex string
+          value: '0x' + amountBigInt.toString(16), // value in wei as hex string
           chainId: chainId,
         },
       } as any);
@@ -854,21 +878,21 @@ export const sendTokenImpl = async (
     // Check if sender has sufficient allowance for the token transfer
     const senderAllowance = await getTokenAllowance(senderAddress, tokenData.address, senderAddress);
     // If insufficient allowance, approve the token first
-    if (senderAllowance < amount) {
-      console.log(`Insufficient allowance (${senderAllowance}). Approving token for amount: ${amount}`);
+    if (senderAllowance < amountBigInt) {
+      console.log(`Insufficient allowance (${senderAllowance}). Approving token for amount: ${amountBigInt}`);
       await approveContractImpl(
         senderAddress,
         tokenData.address,
         senderAddress, // Approve self to spend tokens
         chainId,
-        amount
+        amountBigInt
       );
       console.log('Token approval completed');
     }
     // Create contract interface for ERC20 token
     const contractInterface = new ethers.Interface(Token.abi);
     // Amount is already in the smallest units (wei), so we don't need to convert it
-    const transferAmount = amount;
+    const transferAmount = amountBigInt;
     // Encode the transfer function call
     const data = contractInterface.encodeFunctionData("transfer", [recipientAddress, transferAmount]);
     // Send the transaction
@@ -1123,7 +1147,7 @@ export async function sendToken(
   senderAddress: string,
   recipientAddress: string,
   ticker: string,
-  amount: bigint,
+  amount: string,
   chainId?: number
 ) {
   try {
@@ -1148,7 +1172,13 @@ export async function sendToken(
       throw new Error('Token ticker is required for token transfer');
     }
     
-    if (!amount || amount <= 0n) {
+    if (!amount) {
+      throw new Error('Amount is required for token transfer');
+    }
+    
+    // Validate amount
+    const amountFloat = parseFloat(amount.replace(',', '.'));
+    if (isNaN(amountFloat) || amountFloat <= 0) {
       throw new Error('Valid amount is required for token transfer');
     }
     
@@ -1191,7 +1221,7 @@ export default fp(async (fastify) => {
     return initAddress.call(this, reply, address);
   });
 
-  fastify.decorateRequest('sendToken', async function(this: FastifyRequest, reply: FastifyReply, senderAddress: string, recipientAddress: string, ticker: string, amount: bigint, chainId?: number) {
+  fastify.decorateRequest('sendToken', async function(this: FastifyRequest, reply: FastifyReply, senderAddress: string, recipientAddress: string, ticker: string, amount: string, chainId?: number) {
     return sendToken.call(this, reply, senderAddress, recipientAddress, ticker, amount, chainId);
   });
 
@@ -1202,7 +1232,7 @@ export default fp(async (fastify) => {
   // Test the Privy client initialization
   try {
     const testClient = getPrivyClient(fastify);
-    fastify.log.info('Privy client initialized successfully');
+    fastify.log.info('Privy client initialized successfully', (await testClient.getAppSettings()).id);
   } catch (error) {
     fastify.log.error('Failed to initialize Privy client:', error);
     throw error;
diff --git a/src/Managing.Web3Proxy/src/routes/api/gmx/index.ts b/src/Managing.Web3Proxy/src/routes/api/gmx/index.ts
index 0cff8379..858825aa 100644
--- a/src/Managing.Web3Proxy/src/routes/api/gmx/index.ts
+++ b/src/Managing.Web3Proxy/src/routes/api/gmx/index.ts
@@ -1,6 +1,6 @@
 import {FastifyPluginAsyncTypebox} from '@fastify/type-provider-typebox'
 import {Type} from '@sinclair/typebox'
-import {TradeDirection} from '../../../generated/ManagingApiTypes'
+import {TradeDirection} from '../../../generated/ManagingApiTypes.js'
 import {
     getClaimableFundingFeesImpl,
     getClaimableUiFeesImpl,
diff --git a/src/Managing.Web3Proxy/src/routes/api/privy/index.ts b/src/Managing.Web3Proxy/src/routes/api/privy/index.ts
index 534fe008..c5bec67b 100644
--- a/src/Managing.Web3Proxy/src/routes/api/privy/index.ts
+++ b/src/Managing.Web3Proxy/src/routes/api/privy/index.ts
@@ -1,7 +1,5 @@
 import {FastifyPluginAsyncTypebox, Type} from '@fastify/type-provider-typebox'
 import {handleError} from '../../../utils/errorHandler.js'
-import {TOKENS} from '../../../generated/gmxsdk/configs/tokens.js'
-import {ARBITRUM} from '../../../generated/gmxsdk/configs/chains.js'
 import {Ticker} from '../../../generated/ManagingApiTypes.js'
 
 const plugin: FastifyPluginAsyncTypebox = async (fastify) => {
@@ -112,37 +110,8 @@ const plugin: FastifyPluginAsyncTypebox = async (fastify) => {
       try {
         const { senderAddress, recipientAddress, ticker, amount, chainId } = request.body;
         
-        // Handle decimal numbers with comma separators and convert to proper token units
-        let amountBigInt: bigint;
-        
-        if (typeof amount === 'string') {
-          // Replace comma with period for decimal parsing
-          const normalizedAmount = amount.replace(',', '.');
-          
-          // Parse as float first
-          const amountFloat = parseFloat(normalizedAmount);
-          
-          if (isNaN(amountFloat)) {
-            throw new Error(`Invalid amount format: ${amount}`);
-          }
-          
-          // Get token decimals from GMX configuration
-          const chainTokens = TOKENS[ARBITRUM];
-          const token = chainTokens.find(t => t.symbol === ticker);
-          
-          if (!token) {
-            throw new Error(`Token not found: ${ticker}`);
-          }
-          
-          const tokenDecimals = token.decimals;
-          const amountInSmallestUnit = Math.floor(amountFloat * Math.pow(10, tokenDecimals));
-          
-          amountBigInt = BigInt(amountInSmallestUnit);
-        } else {
-          amountBigInt = BigInt(amount);
-        }
-        
-        return await request.sendToken(reply, senderAddress, recipientAddress, ticker, amountBigInt, chainId);
+        // Pass amount directly to sendTokenImpl - it will handle decimal conversion internally
+        return await request.sendToken(reply, senderAddress, recipientAddress, ticker, amount, chainId);
       } catch (error) {
         return handleError(request, reply, error, 'privy/send-token');
       }
diff --git a/src/Managing.Web3Proxy/src/routes/home.ts b/src/Managing.Web3Proxy/src/routes/home.ts
index 51abdaee..e142b2ce 100644
--- a/src/Managing.Web3Proxy/src/routes/home.ts
+++ b/src/Managing.Web3Proxy/src/routes/home.ts
@@ -136,7 +136,8 @@ const plugin: FastifyPluginAsyncTypebox = async (fastify) => {
         message: 'GMX SDK successfully initialized',
         data: { 
           responseTimeMs: responseTime,
-          uiFeeFactor: uiFeeFactor.toString()
+          uiFeeFactor: uiFeeFactor.toString(),
+          uiFeeReceiverAccount: sdk.config.settings?.uiFeeReceiverAccount
         }
       };
     } catch (error) {
diff --git a/src/Managing.Web3Proxy/test/plugins/claim-gmx-funding-fees.test.ts b/src/Managing.Web3Proxy/test/plugins/claim-gmx-funding-fees.test.ts
index dfa97bb4..cd39c6fc 100644
--- a/src/Managing.Web3Proxy/test/plugins/claim-gmx-funding-fees.test.ts
+++ b/src/Managing.Web3Proxy/test/plugins/claim-gmx-funding-fees.test.ts
@@ -3,7 +3,7 @@ import assert from 'node:assert';
 import {claimGmxFundingFeesImpl, getClientForAddress} from '../../src/plugins/custom/gmx.js';
 
 test('GMX Claim Funding Fees', async (t) => {
-    const testAccount = '0xbBA4eaA534cbD0EcAed5E2fD6036Aec2E7eE309f';
+    const testAccount = '0x0af60b5c1c349744ef8fa8c4ed78ee1a0d392fe9';
 
     await t.test('should claim funding fees for valid account', async () => {
         try {
diff --git a/src/Managing.Web3Proxy/test/plugins/close-position.test.ts b/src/Managing.Web3Proxy/test/plugins/close-position.test.ts
index 29872c2a..b7fdd9c3 100644
--- a/src/Managing.Web3Proxy/test/plugins/close-position.test.ts
+++ b/src/Managing.Web3Proxy/test/plugins/close-position.test.ts
@@ -5,11 +5,11 @@ import {TradeDirection} from '../../src/generated/ManagingApiTypes'
 
 test('GMX Position Closing', async (t) => {
     await t.test('should close a long position for BTC', async () => {
-        const sdk = await getClientForAddress('0x0b4A132cb6ed8fa66953bf61a53D0B91DaCaAd78')
+        const sdk = await getClientForAddress('0x932167388dD9aad41149b3cA23eBD489E2E2DD78')
 
         const result = await closeGmxPositionImpl(
             sdk,
-            "BTC",
+            "ETH",
             TradeDirection.Long
         )
         console.log('Position closing result:', result)
diff --git a/src/Managing.Web3Proxy/test/plugins/send-token.test.ts b/src/Managing.Web3Proxy/test/plugins/send-token.test.ts
new file mode 100644
index 00000000..4b746ba7
--- /dev/null
+++ b/src/Managing.Web3Proxy/test/plugins/send-token.test.ts
@@ -0,0 +1,48 @@
+import {describe, it} from 'node:test'
+import assert from 'node:assert'
+import {sendTokenImpl} from '../../src/plugins/custom/privy.js'
+import {Ticker} from '../../src/generated/ManagingApiTypes.js'
+import {ARBITRUM} from '../../src/generated/gmxsdk/configs/chains.js'
+
+describe('send token implementation', () => {
+
+  it('should send USDC token successfully', async () => {
+    try {
+      // Test addresses - you can replace these with actual addresses
+      const senderAddress = '0x0af60b5c1c349744ef8fa8c4ed78ee1a0d392fe9'
+      const recipientAddress = '0xeba3adc12481db743884bbd11f2a75e0c4cffcf6'
+      
+      // Amount as string (will be converted to smallest units internally)
+      const amount = "0.000547" // ETH amount
+      const ticker = Ticker.ETH
+      
+      console.log('Testing token transfer:')
+      console.log('Sender:', senderAddress)
+      console.log('Recipient:', recipientAddress)
+      console.log('Amount:', amount.toString())
+      console.log('Ticker:', ticker)
+      
+      const result = await sendTokenImpl(
+        senderAddress,
+        recipientAddress,
+        ticker,
+        amount,
+        ARBITRUM
+      )
+      
+      // Verify the result is a transaction hash (string starting with 0x)
+      assert.strictEqual(typeof result, 'string')
+      assert.strictEqual(result.startsWith('0x'), true)
+      assert.strictEqual(result.length, 66) // Standard transaction hash length
+      
+      console.log('Transaction hash:', result)
+      
+    } catch (error) {
+      console.log('Error during token transfer:', error)
+      
+      // Test that the error is related to actual execution rather than parameter validation
+      // This could be due to insufficient balance, allowance, or network issues
+      assert.fail(`Token transfer failed: ${error.message}`)
+    }
+  })
+})
diff --git a/src/Managing.Web3Proxy/test/plugins/swap-tokens.test.ts b/src/Managing.Web3Proxy/test/plugins/swap-tokens.test.ts
index c0f7b187..ec545b71 100644
--- a/src/Managing.Web3Proxy/test/plugins/swap-tokens.test.ts
+++ b/src/Managing.Web3Proxy/test/plugins/swap-tokens.test.ts
@@ -1,29 +1,30 @@
 import {describe, it} from 'node:test'
 import assert from 'node:assert'
 import {getClientForAddress, swapGmxTokensImpl} from '../../src/plugins/custom/gmx.js'
-import {Ticker} from '../../src/generated/ManagingApiTypes'
+import {Ticker} from '../../src/generated/ManagingApiTypes.js'
 
 describe('swap tokens implementation', () => {
 
-  it('should swap USDC to ETH successfully', async () => {
+  it('should swap SOL to USDC successfully', async () => {
     try {
-      const testAccount = '0x0AF60B5C1c349744Ef8fa8c4ed78Ee1A0d392Fe9'
+      const testAccount = '0xbBA4eaA534cbD0EcAed5E2fD6036Aec2E7eE309f'
       const sdk = await getClientForAddress(testAccount)
 
       console.log('Account', sdk.account)
-      const result = await swapGmxTokensImpl(
-        sdk,
-        Ticker.SOL,  // fromTicker
-        Ticker.USDC,   // toTicker   
-        0.001     // amount
-      )
+        const result = await swapGmxTokensImpl(
+          sdk,
+          Ticker.PENDLE,  
+          Ticker.USDC,   
+          13.339559522 
+        )
       
       assert.strictEqual(typeof result, 'string')
       assert.strictEqual(result, 'swap_order_created')
     } catch (error) {
+      console.log('error', error)
+
       // Test that the error is related to actual execution rather than parameter validation
-      assert.ok(error instanceof Error)
-      console.log('Expected error during test execution:', error.message)
+      assert.fail(error.message)
     }
   })
 })
diff --git a/src/Managing.WebApp/src/generated/ManagingApi.ts b/src/Managing.WebApp/src/generated/ManagingApi.ts
index 444cf0f7..7b298aec 100644
--- a/src/Managing.WebApp/src/generated/ManagingApi.ts
+++ b/src/Managing.WebApp/src/generated/ManagingApi.ts
@@ -332,8 +332,8 @@ export class AccountClient extends AuthorizedApiBase {
         return Promise.resolve<SwapInfos>(null as any);
     }
 
-    account_GetExchangeApprovalStatus(): Promise<ExchangeApprovalStatus[]> {
-        let url_ = this.baseUrl + "/Account/exchange-approval-status";
+    account_GetExchangeApprovalStatus(): Promise<ExchangeInitializedStatus[]> {
+        let url_ = this.baseUrl + "/Account/exchanges-initialized-status";
         url_ = url_.replace(/[?&]$/, "");
 
         let options_: RequestInit = {
@@ -350,13 +350,13 @@ export class AccountClient extends AuthorizedApiBase {
         });
     }
 
-    protected processAccount_GetExchangeApprovalStatus(response: Response): Promise<ExchangeApprovalStatus[]> {
+    protected processAccount_GetExchangeApprovalStatus(response: Response): Promise<ExchangeInitializedStatus[]> {
         const status = response.status;
         let _headers: any = {}; if (response.headers && response.headers.forEach) { response.headers.forEach((v: any, k: any) => _headers[k] = v); };
         if (status === 200) {
             return response.text().then((_responseText) => {
             let result200: any = null;
-            result200 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver) as ExchangeApprovalStatus[];
+            result200 = _responseText === "" ? null : JSON.parse(_responseText, this.jsonParseReviver) as ExchangeInitializedStatus[];
             return result200;
             });
         } else if (status !== 200 && status !== 204) {
@@ -364,7 +364,7 @@ export class AccountClient extends AuthorizedApiBase {
             return throwException("An unexpected server error occurred.", status, _responseText, _headers);
             });
         }
-        return Promise.resolve<ExchangeApprovalStatus[]>(null as any);
+        return Promise.resolve<ExchangeInitializedStatus[]>(null as any);
     }
 }
 
@@ -3771,9 +3771,9 @@ export interface SendTokenRequest {
     chainId?: number | null;
 }
 
-export interface ExchangeApprovalStatus {
+export interface ExchangeInitializedStatus {
     exchange?: TradingExchanges;
-    isApproved?: boolean;
+    isInitialized?: boolean;
 }
 
 export interface Backtest {
diff --git a/src/Managing.WebApp/src/generated/ManagingApiTypes.ts b/src/Managing.WebApp/src/generated/ManagingApiTypes.ts
index 14e59cac..01961df5 100644
--- a/src/Managing.WebApp/src/generated/ManagingApiTypes.ts
+++ b/src/Managing.WebApp/src/generated/ManagingApiTypes.ts
@@ -219,9 +219,9 @@ export interface SendTokenRequest {
     chainId?: number | null;
 }
 
-export interface ExchangeApprovalStatus {
+export interface ExchangeInitializedStatus {
     exchange?: TradingExchanges;
-    isApproved?: boolean;
+    isInitialized?: boolean;
 }
 
 export interface Backtest {
diff --git a/src/Managing.WebApp/src/pages/settingsPage/account/accountRowDetails.tsx b/src/Managing.WebApp/src/pages/settingsPage/account/accountRowDetails.tsx
index 0ad2c633..f476bbc4 100644
--- a/src/Managing.WebApp/src/pages/settingsPage/account/accountRowDetails.tsx
+++ b/src/Managing.WebApp/src/pages/settingsPage/account/accountRowDetails.tsx
@@ -206,12 +206,12 @@ const AccountRowDetails: React.FC<IAccountRowDetailProps> = ({
               <div
                 key={status.exchange}
                 className={`badge ${
-                  status.isApproved 
+                  status.isInitialized 
                     ? 'badge-success' 
                     : 'badge-outline'
                 }`}
               >
-                {status.exchange}: {status.isApproved ? 'Approved' : 'Not Approved'}
+                {status.exchange}: {status.isInitialized ? 'Initialized' : 'Not Initialized'}
               </div>
             ))}
           </div>