lynx-client 0.0.2 → 0.0.4

package/README.md

@@ -105,7 +105,6 @@ const identifier = buildPositionRequestIdentifier({
   trader: await signer.getAddress(),
   pairId: 1, // BTC/USD
   settlementAsset: "0x...", // USDC address
-  positionIndex: 0
 });
 
 const params = buildPositionRequestParams({

package/dist/cjs/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradeIntentsVerifierService = exports.LiquidityIntentsVerifierService = exports.ChipsIntentsVerifierService = void 0;
 __exportStar(require("./lib/chains/chainConstants"), exports);
 __exportStar(require("./lib/chains/chainTypes"), exports);
 __exportStar(require("./lib/utils/addresses"), exports);
@@ -39,6 +40,13 @@ __exportStar(require("./lib/addresses/lensAddresses"), exports);
 __exportStar(require("./lib/addresses/systemAddresses"), exports);
 __exportStar(require("./lib/contractsIntegration/deployedContractsConnector"), exports);
 __exportStar(require("./lib/contractsIntegration/TradersPortalService"), exports);
+__exportStar(require("./lib/contractsIntegration/TradingFloorService"), exports);
+var ChipsIntentsVerifierService_1 = require("./lib/contractsIntegration/ChipsIntentsVerifierService");
+Object.defineProperty(exports, "ChipsIntentsVerifierService", { enumerable: true, get: function () { return ChipsIntentsVerifierService_1.ChipsIntentsVerifierService; } });
+var LiquidityIntentsVerifierService_1 = require("./lib/contractsIntegration/LiquidityIntentsVerifierService");
+Object.defineProperty(exports, "LiquidityIntentsVerifierService", { enumerable: true, get: function () { return LiquidityIntentsVerifierService_1.LiquidityIntentsVerifierService; } });
+var TradeIntentsVerifierService_1 = require("./lib/contractsIntegration/TradeIntentsVerifierService");
+Object.defineProperty(exports, "TradeIntentsVerifierService", { enumerable: true, get: function () { return TradeIntentsVerifierService_1.TradeIntentsVerifierService; } });
 __exportStar(require("./lib/contractsIntegration/IntentsVerifierLensService"), exports);
 __exportStar(require("./lib/contractsIntegration/TriggersAndPortalLensService"), exports);
 __exportStar(require("./lib/contractsIntegration/TradingFloorLensService"), exports);
@@ -47,9 +55,13 @@ __exportStar(require("./lib/typechain/contracts/Peripheral/Lens/IntentsVerifierL
 __exportStar(require("./lib/typechain/contracts/Peripheral/Lens/TriggersAndPortalLens"), exports);
 __exportStar(require("./lib/typechain/contracts/Peripheral/Lens/LexLens"), exports);
 __exportStar(require("./lib/typechain/contracts/Peripheral/Lens/TradingFloorLens"), exports);
+// Intents Verifier types are exported through their respective services to avoid conflicts
 __exportStar(require("./lib/typechain/factories/contracts/Peripheral/Lens/IntentsVerifierLens__factory"), exports);
 __exportStar(require("./lib/typechain/factories/contracts/Peripheral/Lens/TriggersAndPortalLens__factory"), exports);
 __exportStar(require("./lib/typechain/factories/contracts/Peripheral/Lens/LexLens__factory"), exports);
 __exportStar(require("./lib/typechain/factories/contracts/Peripheral/Lens/TradingFloorLens__factory"), exports);
+__exportStar(require("./lib/typechain/factories/contracts/Lynx/IntentsVerifier/ChipsIntentsVerifierV1__factory"), exports);
+__exportStar(require("./lib/typechain/factories/contracts/Lynx/IntentsVerifier/LiquidityIntentsVerifierV1__factory"), exports);
+__exportStar(require("./lib/typechain/factories/contracts/Lynx/IntentsVerifier/TradeIntentsVerifierV1__factory"), exports);
 // Developer Experience utilities
 __exportStar(require("./lib/devex"), exports);

package/dist/cjs/lib/addresses/lensAddresses.js

@@ -3,27 +3,27 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LensAddresses = void 0;
 exports.LensAddresses = {
     boba: {
-        lexLens: "0xCcFaDF4E72d5b2D382555E0eb72a1BF6F7f0EF7F",
-        tradingFloorLensLens: "0xed9D263917921cb5f0B9a59c5083beA4075F33e7",
-        intentsVerifierLens: "0x8F33670B7a076793D178D340AD70Cc097DD03739",
-        triggersAndPortalLens: "0xA03312361D07dfAe0C517a441C69BFA9E84e38bf",
+        intentsVerifierLens: "0x7DfA2F609573AB8eD8cA231498FF4E8f1e7d31Fa",
+        lexLens: "0xE4Ebc518A2Fb771057E8E1e85296a72a4587e11E",
+        tradingFloorLensLens: "0x7f68e8Ba4176683594342d9C39De22b93daC45E3",
+        triggersAndPortalLens: "0x5c3d344C24e4Cd7DDCdd15C660095FFb160d42e5",
     },
     sonic: {
-        lexLens: "0xBcb1D4ACbc844ba5FC0aA411b98aebD4A508B65F",
-        tradingFloorLensLens: "0xa5802951D972372f1385e9Ac83df738b3323d0A8",
-        intentsVerifierLens: "0xDBe9130AAe593Ec73a838ce286fa84c193bceFA1",
-        triggersAndPortalLens: "0xaA96df0a4F01212169c2347dc23D5AEb89924839",
+        intentsVerifierLens: "0x0C1Fcd85856b5564a87ae378336b7CC0c139C5f7",
+        lexLens: "0xc8939875FeC9a0A2f1757272165f8F53659C47c4",
+        tradingFloorLensLens: "0x50631a46BEe1E63e46C3eDceE3d5af33E5904681",
+        triggersAndPortalLens: "0x7976e6E8145a11aB17D61497dfa0524999Ab6d3c",
     },
     fantom: {
-        lexLens: "0xB5A5041654391a720953D346367D3A3BE9c3d47B",
-        tradingFloorLensLens: "0x2B913d10452c93Bb7184B5B4fb7e3724452fE0fB",
-        intentsVerifierLens: "0x5cf3613de36106C10674778C5748FAf9630c3D94",
-        triggersAndPortalLens: "0x9544C73C97BD292a1F09ef671A5f8CcDf9Ff5429",
+        intentsVerifierLens: "",
+        lexLens: "",
+        tradingFloorLensLens: "",
+        triggersAndPortalLens: "",
     },
     flare: {
-        lexLens: "0x812Ea46a0618f923ae473eb239a89A8169b34B85",
-        tradingFloorLensLens: "0x13d878F3C3f32400A727662af7dfAdBc8b389637",
-        intentsVerifierLens: "0x33576dFbA7Ed5E3F8F744132D6885cE106178161",
-        triggersAndPortalLens: "0x625D49B0258BB8277516C07494910d420FA31B06",
+        intentsVerifierLens: "0x1CdA9C57526e0CDF97f63c2c0CD460a16f9855F5",
+        lexLens: "0x76CDbA9107a89af6Dda81655f26FBE67e1d4a749",
+        tradingFloorLensLens: "0x731cDbfF121a313c9af0146826E2A78cCBE9FF66",
+        triggersAndPortalLens: "0x36D550DbA557a930f0Dfcb4796c593b2215D52Af",
     },
 };

package/dist/cjs/lib/contractsIntegration/ChipsIntentsVerifierService/ChipsIntentsVerifierService.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChipsIntentsVerifierService = void 0;
+const ChipsIntentsVerifierV1__factory_1 = require("../../typechain/factories/contracts/Lynx/IntentsVerifier/ChipsIntentsVerifierV1__factory");
+class ChipsIntentsVerifierService {
+    constructor(signerOrProvider, address) {
+        this.contract = ChipsIntentsVerifierV1__factory_1.ChipsIntentsVerifierV1__factory.connect(address, signerOrProvider);
+        this.isSigner = 'sendTransaction' in signerOrProvider;
+    }
+    async domainSeparatorForAsset(chip) {
+        return await this.contract.domainSeparatorForAsset(chip);
+    }
+    async domainSeparatorForChain(chainId) {
+        return await this.contract.domainSeparatorForChain(chainId);
+    }
+    async chipOutFeeForChip(chip) {
+        return await this.contract.chipOutFeeForChip(chip);
+    }
+    async feesReceiver() {
+        return await this.contract.feesReceiver();
+    }
+    async intentsPermissions(user) {
+        return await this.contract.intentsPermissions(user);
+    }
+    async setIntentsPermissions(oftChip, dynAddressSuffix) {
+        if (!this.isSigner) {
+            throw new Error("ChipsIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.setIntentsPermissions(oftChip, dynAddressSuffix);
+        await tx.wait();
+    }
+    async forceChipOut(chip, holder, amount, value) {
+        if (!this.isSigner) {
+            throw new Error("ChipsIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.forceChipOut(chip, holder, amount, { value: value || 0n });
+        await tx.wait();
+    }
+    async interactOnBehalf_chipOut(chip, holder, amount, value) {
+        if (!this.isSigner) {
+            throw new Error("ChipsIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.interactOnBehalf_chipOut(chip, holder, amount, { value: value || 0n });
+        await tx.wait();
+    }
+    async verifyIntent_chipOut(payload, v, r, s, value) {
+        if (!this.isSigner) {
+            throw new Error("ChipsIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.verifyIntent_chipOut(payload, v, r, s, { value: value || 0n });
+        await tx.wait();
+    }
+    async verifyIntent_chipOutAndUnwrap(payload, v, r, s, value) {
+        if (!this.isSigner) {
+            throw new Error("ChipsIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.verifyIntent_chipOutAndUnwrap(payload, v, r, s, { value: value || 0n });
+        await tx.wait();
+    }
+    async getLZDstChainIdFromChip(chip) {
+        return await this.contract.getLZDstChainIdFromChip(chip);
+    }
+    async getLZDstChainIdFromEvmChainId(evmChainId) {
+        return await this.contract.getLZDstChainIdFromEvmChainId(evmChainId);
+    }
+    async evmIdToLzEid(evmChainId) {
+        return await this.contract.evmIdToLzEid(evmChainId);
+    }
+    async getWrapNativeChipInOutHelper(oftChip) {
+        return await this.contract.getWrapNativeChipInOutHelper(oftChip);
+    }
+    async sourceChainIdForAsset(asset) {
+        return await this.contract.sourceChainIdForAsset(asset);
+    }
+    async processedSignatures(signature) {
+        return await this.contract.processedSignatures(signature);
+    }
+    async admin() {
+        return await this.contract.admin();
+    }
+    async pendingAdmin() {
+        return await this.contract.pendingAdmin();
+    }
+    async registry() {
+        return await this.contract.registry();
+    }
+    async wrapNativeChipInOutHelpers(oftChip) {
+        return await this.contract.wrapNativeChipInOutHelpers(oftChip);
+    }
+}
+exports.ChipsIntentsVerifierService = ChipsIntentsVerifierService;

package/dist/cjs/lib/contractsIntegration/ChipsIntentsVerifierService/IChipsIntentsVerifierService.js

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

package/dist/cjs/lib/contractsIntegration/ChipsIntentsVerifierService/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChipsIntentsVerifierService = void 0;
+var ChipsIntentsVerifierService_1 = require("./ChipsIntentsVerifierService");
+Object.defineProperty(exports, "ChipsIntentsVerifierService", { enumerable: true, get: function () { return ChipsIntentsVerifierService_1.ChipsIntentsVerifierService; } });

package/dist/cjs/lib/contractsIntegration/IntentsVerifierLensService/IIntentsVerifierLensService.js

@@ -1,15 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EMPTY_HASH_BASED_INTENTS_VERIFIER_REQUEST_BUILDING_INFO = exports.EMPTY_ACCOUNT_BASED_INTENTS_VERIFIER_REQUEST_BUILDING_INFO = void 0;
-exports.EMPTY_ACCOUNT_BASED_INTENTS_VERIFIER_REQUEST_BUILDING_INFO = {
-    verifier: "",
-    account: "",
-    actionType: 0,
-    currentNonce: 0,
-};
-exports.EMPTY_HASH_BASED_INTENTS_VERIFIER_REQUEST_BUILDING_INFO = {
-    verifier: "",
-    hash: "",
-    actionType: 0,
-    currentNonce: 0,
-};

package/dist/cjs/lib/contractsIntegration/IntentsVerifierLensService/IntentsVerifierLensService.js

@@ -2,38 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IntentsVerifierLensService = void 0;
 const IntentsVerifierLens__factory_1 = require("../../typechain/factories/contracts/Peripheral/Lens/IntentsVerifierLens__factory");
-const ethersTypes_1 = require("../../utils/ethersTypes");
-const IIntentsVerifierLensService_1 = require("./IIntentsVerifierLensService");
 class IntentsVerifierLensService {
     constructor(signerOrProvider, address) {
         this.contract = IntentsVerifierLens__factory_1.IntentsVerifierLens__factory.connect(address, signerOrProvider);
     }
-    async getRequestBuildingInfoForChipsIntentsVerifier(account, actionType) {
-        const result = await this.contract.getRequestBuildingInfoForChipsIntentsVerifier(account, BigInt(actionType));
-        const baseStruct = (0, ethersTypes_1.ethersStructResponseToObject)(result, IIntentsVerifierLensService_1.EMPTY_ACCOUNT_BASED_INTENTS_VERIFIER_REQUEST_BUILDING_INFO);
-        return {
-            ...baseStruct,
-            actionType: Number(baseStruct.actionType),
-            currentNonce: Number(baseStruct.currentNonce),
-        };
+    async getRequestBuildingInfoForChipsIntentsVerifier() {
+        return await this.contract.getRequestBuildingInfoForChipsIntentsVerifier();
     }
-    async getRequestBuildingInfoForLiquidityIntentsVerifier(account, actionType) {
-        const result = await this.contract.getRequestBuildingInfoForLiquidityIntentsVerifier(account, BigInt(actionType));
-        const baseStruct = (0, ethersTypes_1.ethersStructResponseToObject)(result, IIntentsVerifierLensService_1.EMPTY_ACCOUNT_BASED_INTENTS_VERIFIER_REQUEST_BUILDING_INFO);
-        return {
-            ...baseStruct,
-            actionType: Number(baseStruct.actionType),
-            currentNonce: Number(baseStruct.currentNonce),
-        };
+    async getRequestBuildingInfoForLiquidityIntentsVerifier() {
+        return await this.contract.getRequestBuildingInfoForLiquidityIntentsVerifier();
     }
-    async getRequestBuildingInfoForTradeIntentsVerifier(positionId, actionType) {
-        const result = await this.contract.getRequestBuildingInfoForTradeIntentsVerifier(positionId, BigInt(actionType));
-        const baseStruct = (0, ethersTypes_1.ethersStructResponseToObject)(result, IIntentsVerifierLensService_1.EMPTY_HASH_BASED_INTENTS_VERIFIER_REQUEST_BUILDING_INFO);
-        return {
-            ...baseStruct,
-            actionType: Number(baseStruct.actionType),
-            currentNonce: Number(baseStruct.currentNonce),
-        };
+    async getRequestBuildingInfoForTradeIntentsVerifier() {
+        return await this.contract.getRequestBuildingInfoForTradeIntentsVerifier();
     }
     async registry() {
         return await this.contract.registry();

package/dist/cjs/lib/contractsIntegration/LiquidityIntentsVerifierService/ILiquidityIntentsVerifierService.js

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

package/dist/cjs/lib/contractsIntegration/LiquidityIntentsVerifierService/LiquidityIntentsVerifierService.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiquidityIntentsVerifierService = void 0;
+const LiquidityIntentsVerifierV1__factory_1 = require("../../typechain/factories/contracts/Lynx/IntentsVerifier/LiquidityIntentsVerifierV1__factory");
+class LiquidityIntentsVerifierService {
+    constructor(signerOrProvider, address) {
+        this.contract = LiquidityIntentsVerifierV1__factory_1.LiquidityIntentsVerifierV1__factory.connect(address, signerOrProvider);
+        this.isSigner = 'sendTransaction' in signerOrProvider;
+    }
+    async domainSeparatorForAsset(pool) {
+        return await this.contract.domainSeparatorForAsset(pool);
+    }
+    async domainSeparatorForChain(chainId) {
+        return await this.contract.domainSeparatorForChain(chainId);
+    }
+    async intentsPermissions(user) {
+        return await this.contract.intentsPermissions(user);
+    }
+    async setIntentsPermissions(oftChip, dynAddressSuffix) {
+        if (!this.isSigner) {
+            throw new Error("LiquidityIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.setIntentsPermissions(oftChip, dynAddressSuffix);
+        await tx.wait();
+    }
+    async interactOnBehalf_epochDeposit(pool, liquidityProvider, amount, minAmountOut, domain, referralCode, value) {
+        if (!this.isSigner) {
+            throw new Error("LiquidityIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.interactOnBehalf_epochDeposit(pool, liquidityProvider, amount, minAmountOut, domain, referralCode, { value: value || 0n });
+        await tx.wait();
+    }
+    async interactOnBehalf_epochRedeem(pool, liquidityProvider, amount, minAmountOut, value) {
+        if (!this.isSigner) {
+            throw new Error("LiquidityIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.interactOnBehalf_epochRedeem(pool, liquidityProvider, amount, minAmountOut, { value: value || 0n });
+        await tx.wait();
+    }
+    async verifyIntent_epochDeposit(payload, v, r, s, domain, referralCode, value) {
+        if (!this.isSigner) {
+            throw new Error("LiquidityIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.verifyIntent_epochDeposit(payload, v, r, s, domain, referralCode, { value: value || 0n });
+        await tx.wait();
+    }
+    async verifyIntent_epochRedeem(payload, v, r, s, value) {
+        if (!this.isSigner) {
+            throw new Error("LiquidityIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.verifyIntent_epochRedeem(payload, v, r, s, { value: value || 0n });
+        await tx.wait();
+    }
+    async admin() {
+        return await this.contract.admin();
+    }
+    async pendingAdmin() {
+        return await this.contract.pendingAdmin();
+    }
+    async registry() {
+        return await this.contract.registry();
+    }
+    async sourceChainIdForAsset(asset) {
+        return await this.contract.sourceChainIdForAsset(asset);
+    }
+    async processedSignatures(signature) {
+        return await this.contract.processedSignatures(signature);
+    }
+}
+exports.LiquidityIntentsVerifierService = LiquidityIntentsVerifierService;

package/dist/cjs/lib/contractsIntegration/LiquidityIntentsVerifierService/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiquidityIntentsVerifierService = void 0;
+var LiquidityIntentsVerifierService_1 = require("./LiquidityIntentsVerifierService");
+Object.defineProperty(exports, "LiquidityIntentsVerifierService", { enumerable: true, get: function () { return LiquidityIntentsVerifierService_1.LiquidityIntentsVerifierService; } });

package/dist/cjs/lib/contractsIntegration/TradeIntentsVerifierService/ITradeIntentsVerifierService.js

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

package/dist/cjs/lib/contractsIntegration/TradeIntentsVerifierService/TradeIntentsVerifierService.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradeIntentsVerifierService = void 0;
+const TradeIntentsVerifierV1__factory_1 = require("../../typechain/factories/contracts/Lynx/IntentsVerifier/TradeIntentsVerifierV1__factory");
+class TradeIntentsVerifierService {
+    constructor(signerOrProvider, address) {
+        this.contract = TradeIntentsVerifierV1__factory_1.TradeIntentsVerifierV1__factory.connect(address, signerOrProvider);
+        this.isSigner = 'sendTransaction' in signerOrProvider;
+    }
+    async domainSeparatorForAsset(settlementAsset) {
+        return await this.contract.domainSeparatorForAsset(settlementAsset);
+    }
+    async domainSeparatorForChain(chainId) {
+        return await this.contract.domainSeparatorForChain(chainId);
+    }
+    async intentsPermissions(user) {
+        return await this.contract.intentsPermissions(user);
+    }
+    async setIntentsPermissions(oftChip, dynAddressSuffix) {
+        if (!this.isSigner) {
+            throw new Error("TradeIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.setIntentsPermissions(oftChip, dynAddressSuffix);
+        await tx.wait();
+    }
+    async verifyIntent_traderRequest_openNewPosition(payload, v, r, s, domain, referralCode, runCapTests, value) {
+        if (!this.isSigner) {
+            throw new Error("TradeIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.verifyIntent_traderRequest_openNewPosition(payload, v, r, s, domain, referralCode, runCapTests, { value: value || 0n });
+        await tx.wait();
+    }
+    async verifyIntent_traderRequest_marketClosePosition(payload, v, r, s, value) {
+        if (!this.isSigner) {
+            throw new Error("TradeIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.verifyIntent_traderRequest_marketClosePosition(payload, v, r, s, { value: value || 0n });
+        await tx.wait();
+    }
+    async verifyIntent_traderAction_updatePendingLimitPosition(payload, v, r, s, value) {
+        if (!this.isSigner) {
+            throw new Error("TradeIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.verifyIntent_traderAction_updatePendingLimitPosition(payload, v, r, s, { value: value || 0n });
+        await tx.wait();
+    }
+    async verifyIntent_traderAction_cancelPendingLimitPosition(payload, v, r, s, value) {
+        if (!this.isSigner) {
+            throw new Error("TradeIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.verifyIntent_traderAction_cancelPendingLimitPosition(payload, v, r, s, { value: value || 0n });
+        await tx.wait();
+    }
+    async verifyIntent_traderRequest_updatePositionSingleField(payload, v, r, s, value) {
+        if (!this.isSigner) {
+            throw new Error("TradeIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.verifyIntent_traderRequest_updatePositionSingleField(payload, v, r, s, { value: value || 0n });
+        await tx.wait();
+    }
+    async verifyIntent_traderRequest_updatePositionDoubleField(payload, v, r, s, value) {
+        if (!this.isSigner) {
+            throw new Error("TradeIntentsVerifierService: Write operations require a signer");
+        }
+        const tx = await this.contract.verifyIntent_traderRequest_updatePositionDoubleField(payload, v, r, s, { value: value || 0n });
+        await tx.wait();
+    }
+    async admin() {
+        return await this.contract.admin();
+    }
+    async pendingAdmin() {
+        return await this.contract.pendingAdmin();
+    }
+    async registry() {
+        return await this.contract.registry();
+    }
+    async sourceChainIdForAsset(asset) {
+        return await this.contract.sourceChainIdForAsset(asset);
+    }
+    async processedSignatures(signature) {
+        return await this.contract.processedSignatures(signature);
+    }
+    async domainSeparatorsForPosition(positionId) {
+        return await this.contract.domainSeparatorsForPosition(positionId);
+    }
+    async tradersForPosition(positionId) {
+        return await this.contract.tradersForPosition(positionId);
+    }
+    async settlementAssetsForPosition(positionId) {
+        return await this.contract.settlementAssetsForPosition(positionId);
+    }
+    async getTradingFloor() {
+        return await this.contract.getTradingFloor();
+    }
+    async getTradersPortal() {
+        return await this.contract.getTradersPortal();
+    }
+}
+exports.TradeIntentsVerifierService = TradeIntentsVerifierService;

package/dist/cjs/lib/contractsIntegration/TradeIntentsVerifierService/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradeIntentsVerifierService = void 0;
+var TradeIntentsVerifierService_1 = require("./TradeIntentsVerifierService");
+Object.defineProperty(exports, "TradeIntentsVerifierService", { enumerable: true, get: function () { return TradeIntentsVerifierService_1.TradeIntentsVerifierService; } });

package/dist/cjs/lib/contractsIntegration/TradersPortalService/TradersPortalUtils.js

@@ -15,7 +15,6 @@ function buildPositionRequestIdentifier(params) {
         trader: params.trader,
         pairId: BigInt(params.pairId),
         settlementAsset: params.settlementAsset,
-        positionIndex: BigInt(params.positionIndex),
     };
 }
 /**

package/dist/cjs/lib/contractsIntegration/TradingFloorLensService/ITradingFloorLensService.js

@@ -32,9 +32,7 @@ exports.EMPTY_COMPLETE_POSITION_DATA = {
 exports.EMPTY_POSITIONS_RESULT = {
     positions: [],
     positionsCount: 0,
-    settlementAssetsLastIndex: 0,
-    pairIdsLastIndex: 0,
-    pairTraderLastIndex: 0,
+    traderLastIndex: 0,
     done: false,
 };
 exports.EMPTY_POSITION_LIQUIDATION_INFO = {
@@ -47,15 +45,13 @@ exports.EMPTY_POSITION_LIQUIDATION_INFO = {
 exports.EMPTY_LIQUIDATION_RESULT = {
     positionsLiquidationInfo: [],
     positionsCount: 0,
-    settlementAssetsLastIndex: 0,
-    pairIdsLastIndex: 0,
-    pairTraderLastIndex: 0,
+    traderLastIndex: 0,
     positionLastIndex: 0,
     done: false,
 };
 exports.EMPTY_TRADE_PARAMS = {
     tradingFloor: "",
-    maxTradesPerPair: 0,
+    maxTradesPerTrader: 0,
     maxSlF: 0,
     maxSanityProfitF: 0,
 };

package/dist/cjs/lib/contractsIntegration/TradingFloorLensService/TradingFloorLensService.js

@@ -45,12 +45,9 @@ class TradingFloorLensService {
     async getAllPositionsDataForAllTraders(params) {
         const contractParams = {
             tradingFloor: params.tradingFloor,
-            settlementAssetsStartIndex: BigInt(params.settlementAssetsStartIndex),
-            pairIdsStartIndex: BigInt(params.pairIdsStartIndex),
-            pairTraderStartIndex: BigInt(params.pairTraderStartIndex),
+            traderStartIndex: BigInt(params.traderStartIndex),
             positionsLimit: BigInt(params.positionsLimit),
         };
-        // @ts-ignore
         const result = await this.contract.getAllPositionsDataForAllTraders.staticCall(contractParams);
         const baseResult = (0, ethersTypes_1.ethersStructResponseToObject)(result, ITradingFloorLensService_1.EMPTY_POSITIONS_RESULT);
         // Convert positions and filter out empty ones
@@ -61,44 +58,23 @@ class TradingFloorLensService {
             ...baseResult,
             positions: convertedPositions,
             positionsCount: Number(baseResult.positionsCount),
-            settlementAssetsLastIndex: Number(baseResult.settlementAssetsLastIndex),
-            pairIdsLastIndex: Number(baseResult.pairIdsLastIndex),
-            pairTraderLastIndex: Number(baseResult.pairTraderLastIndex),
+            traderLastIndex: Number(baseResult.traderLastIndex),
         };
     }
-    async getAllPositionsDataForAllTradersInDimension(tradingFloor, settlementAsset, arraySize) {
-        // @ts-ignore
-        const result = await this.contract.getAllPositionsDataForAllTradersInDimension.staticCall(tradingFloor, settlementAsset, BigInt(arraySize));
-        // Convert and filter out empty positions (collateral = 0)
-        return result
-            .filter((pos) => pos.collateral > 0n)
-            .map((pos) => convertPositionData(pos));
-    }
-    async getAllPositionsDataForTraderInDimension(tradingFloor, settlementAsset, trader) {
-        // @ts-ignore
-        const result = await this.contract.getAllPositionsDataForTraderInDimension.staticCall(tradingFloor, settlementAsset, trader);
-        // Convert and filter out empty positions (collateral = 0)
-        return result
-            .filter((pos) => pos.collateral > 0n)
-            .map((pos) => convertPositionData(pos));
-    }
     async getAllPositionsLiquidationInfo(params, phases) {
         const contractParams = {
             tradingFloor: params.tradingFloor,
-            settlementAssetsStartIndex: BigInt(params.settlementAssetsStartIndex),
-            pairIdsStartIndex: BigInt(params.pairIdsStartIndex),
-            pairTraderStartIndex: BigInt(params.pairTraderStartIndex),
+            traderStartIndex: BigInt(params.traderStartIndex),
             positionStartIndex: BigInt(params.positionStartIndex),
             positionsLimit: BigInt(params.positionsLimit),
         };
         let result;
         if (phases !== undefined) {
-            // @ts-ignore
-            result = await this.contract["getAllPositionsLiquidationInfo((address,uint256,uint256,uint256,uint16,uint256),uint8[])"].staticCall(contractParams, phases.map(p => BigInt(p)));
+            result = await this.contract["getAllPositionsLiquidationInfo((address,uint256,uint16,uint256),uint8[])"].staticCall(contractParams, phases.map((p) => BigInt(p)));
         }
         else {
-            // @ts-ignore
-            result = await this.contract["getAllPositionsLiquidationInfo((address,uint256,uint256,uint256,uint16,uint256))"].staticCall(contractParams);
+            result =
+                await this.contract["getAllPositionsLiquidationInfo((address,uint256,uint16,uint256))"].staticCall(contractParams);
         }
         const baseResult = (0, ethersTypes_1.ethersStructResponseToObject)(result, ITradingFloorLensService_1.EMPTY_LIQUIDATION_RESULT);
         const convertedPositions = result.positionsLiquidationInfo.map((pos) => convertLiquidationInfo(pos));
@@ -106,39 +82,27 @@ class TradingFloorLensService {
             ...baseResult,
             positionsLiquidationInfo: convertedPositions,
             positionsCount: Number(baseResult.positionsCount),
-            settlementAssetsLastIndex: Number(baseResult.settlementAssetsLastIndex),
-            pairIdsLastIndex: Number(baseResult.pairIdsLastIndex),
-            pairTraderLastIndex: Number(baseResult.pairTraderLastIndex),
+            traderLastIndex: Number(baseResult.traderLastIndex),
             positionLastIndex: Number(baseResult.positionLastIndex),
         };
     }
     async getCompletePositionData(tradingFloor, positionId) {
-        // @ts-ignore
         const result = await this.contract.getCompletePositionData.staticCall(tradingFloor, positionId);
         return convertPositionData(result);
     }
-    async getPositionDataInPairsForTrader(tradingFloor, settlementAsset, trader, pairIds) {
-        // @ts-ignore
-        const result = await this.contract.getPositionDataInPairsForTrader.staticCall(tradingFloor, settlementAsset, trader, pairIds.map(id => BigInt(id)));
-        // Convert and filter out empty positions (collateral = 0)
-        return result
-            .filter((pos) => pos.collateral > 0n)
-            .map((pos) => convertPositionData(pos));
-    }
-    async getPositionsDataInPairForTrader(tradingFloor, settlementAsset, trader, pairId) {
-        // @ts-ignore
-        const result = await this.contract.getPositionsDataInPairForTrader.staticCall(tradingFloor, settlementAsset, trader, BigInt(pairId));
+    async getPositionsDataForTrader(tradingFloor, trader) {
+        const result = await this.contract.getPositionsDataForTrader.staticCall(tradingFloor, trader);
         // Convert and filter out empty positions (collateral = 0)
         return result
             .filter((pos) => pos.collateral > 0n)
             .map((pos) => convertPositionData(pos));
     }
     async getTradingFloorTradeParams(tradingFloor) {
-        const result = await this.contract.getTradingFloorTradeParams(tradingFloor);
+        const result = await this.contract.getTradingFloorTradeParams.staticCall(tradingFloor);
         // Result is a tuple/array-like object, extract the named properties
         return {
             tradingFloor: result.tradingFloor,
-            maxTradesPerPair: Number(result.maxTradesPerPair),
+            maxTradesPerTrader: Number(result.maxTradesPerTrader),
             maxSlF: Number(result.maxSlF),
             maxSanityProfitF: Number(result.maxSanityProfitF),
         };