lynx-client 0.0.4 → 0.0.6

package/dist/cjs/index.js

@@ -14,7 +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;
+exports.tradeIntentsVerifierPayloadTypes = exports.liquidityIntentsVerifierPayloadTypes = exports.chipsIntentsVerifierPayloadTypes = 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);
@@ -55,11 +55,19 @@ __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
+// Intents Verifier payload types for EIP-712 signature generation
+var chipsIntentsVerifierPayloadTypes_1 = require("./lib/typechain/lynxSystem/intentsVerifiers/chipsIntentsVerifier/chipsIntentsVerifierPayloadTypes");
+Object.defineProperty(exports, "chipsIntentsVerifierPayloadTypes", { enumerable: true, get: function () { return chipsIntentsVerifierPayloadTypes_1.chipsIntentsVerifierPayloadTypes; } });
+var liquidityIntentsVerifierPayloadTypes_1 = require("./lib/typechain/lynxSystem/intentsVerifiers/liquidityIntentsVerifier/liquidityIntentsVerifierPayloadTypes");
+Object.defineProperty(exports, "liquidityIntentsVerifierPayloadTypes", { enumerable: true, get: function () { return liquidityIntentsVerifierPayloadTypes_1.liquidityIntentsVerifierPayloadTypes; } });
+var tradeIntentsVerifierPayloadTypes_1 = require("./lib/typechain/lynxSystem/intentsVerifiers/tradeIntentsVerifier/tradeIntentsVerifierPayloadTypes");
+Object.defineProperty(exports, "tradeIntentsVerifierPayloadTypes", { enumerable: true, get: function () { return tradeIntentsVerifierPayloadTypes_1.tradeIntentsVerifierPayloadTypes; } });
+// Contract factory exports for Lens contracts
 __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);
+// Contract factory exports for Intents Verifiers
 __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);

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcceptableImplementationClaimableAdminService = void 0;
+const AcceptableImplementationClaimableAdmin__factory_1 = require("../../typechain/factories/contracts/AdministrationContracts/AcceptableImplementationClaimableAdmin__factory");
+class AcceptableImplementationClaimableAdminFunctionsGroup_AdminManagement {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async _setPendingAdmin(newPendingAdmin) {
+        return this.contract._setPendingAdmin(newPendingAdmin);
+    }
+    async _acceptAdmin() {
+        return this.contract._acceptAdmin();
+    }
+}
+class AcceptableImplementationClaimableAdminFunctionsGroup_ImplementationManagement {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async _setPendingImplementation(newPendingImplementation) {
+        return this.contract._setPendingImplementation(newPendingImplementation);
+    }
+    async _acceptImplementation() {
+        // This function modifies state and returns a uint status code (0 on success) via transaction receipt
+        return this.contract._acceptImplementation();
+    }
+}
+class AcceptableImplementationClaimableAdminFunctionsGroup_StateVariables {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async admin() {
+        return this.contract.admin();
+    }
+    async pendingAdmin() {
+        return this.contract.pendingAdmin();
+    }
+    async implementation() {
+        return this.contract.implementation();
+    }
+    async pendingImplementation() {
+        return this.contract.pendingImplementation();
+    }
+}
+class AcceptableImplementationClaimableAdminService {
+    constructor(signerOrProvider, address) {
+        this.proxyContract = AcceptableImplementationClaimableAdmin__factory_1.AcceptableImplementationClaimableAdmin__factory.connect(address, signerOrProvider);
+        this.adminManagement = new AcceptableImplementationClaimableAdminFunctionsGroup_AdminManagement(this.proxyContract);
+        this.implementationManagement = new AcceptableImplementationClaimableAdminFunctionsGroup_ImplementationManagement(this.proxyContract);
+        this.stateVariables = new AcceptableImplementationClaimableAdminFunctionsGroup_StateVariables(this.proxyContract);
+    }
+}
+exports.AcceptableImplementationClaimableAdminService = AcceptableImplementationClaimableAdminService;

package/dist/cjs/lib/contractsIntegration/AcceptableImplementationClaimableAdminService/IAcceptableImplementationClaimableAdminService.js

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

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

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

package/dist/cjs/lib/contractsIntegration/LexPoolV1Service/ILexPoolV1Service.js

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

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

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LexPoolV1Service = void 0;
+const LexPoolV1__factory_1 = require("../../typechain/factories/contracts/Lynx/Lex/LexPool/LexPoolV1__factory");
+class LexPoolV1FunctionsGroup_Initialization {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async _become(proxy) {
+        return this.contract._become(proxy);
+    }
+    async initialize(underlying, tradingFloor, epochDuration) {
+        return this.contract.initialize(underlying, tradingFloor, epochDuration);
+    }
+}
+class LexPoolV1FunctionsGroup_AdminConfiguration {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async setPoolAccountant(poolAccountant) {
+        return this.contract.setPoolAccountant(poolAccountant);
+    }
+    async setPnlRole(pnl) {
+        return this.contract.setPnlRole(pnl);
+    }
+    async setMaxExtraWithdrawalAmountF(maxExtra) {
+        return this.contract.setMaxExtraWithdrawalAmountF(maxExtra);
+    }
+    async setEpochsDelayDeposit(delay) {
+        return this.contract.setEpochsDelayDeposit(delay);
+    }
+    async setEpochsDelayRedeem(delay) {
+        return this.contract.setEpochsDelayRedeem(delay);
+    }
+    async setEpochDuration(duration) {
+        return this.contract.setEpochDuration(duration);
+    }
+    async setMinDepositAmount(amount) {
+        return this.contract.setMinDepositAmount(amount);
+    }
+    async toggleImmediateDepositAllowed() {
+        return this.contract.toggleImmediateDepositAllowed();
+    }
+    async reduceReserves(to) {
+        const result = await this.contract.reduceReserves.staticCall(to);
+        return {
+            interestShare: result[0],
+            totalFundingShare: result[1],
+        };
+    }
+}
+class LexPoolV1FunctionsGroup_UserDeposits {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async immediateDeposit(depositAmount, domain, referralCode) {
+        return this.contract.immediateDeposit(depositAmount, domain, referralCode);
+    }
+    async requestDeposit(amount, minAmountOut, domain, referralCode) {
+        return this.contract.requestDeposit(amount, minAmountOut, domain, referralCode);
+    }
+    async requestDepositViaIntent(user, amount, minAmountOut, domain, referralCode) {
+        return this.contract.requestDepositViaIntent(user, amount, minAmountOut, domain, referralCode);
+    }
+}
+class LexPoolV1FunctionsGroup_UserRedeems {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async requestRedeem(amount, minAmountOut) {
+        return this.contract.requestRedeem(amount, minAmountOut);
+    }
+    async requestRedeemViaIntent(user, amount, minAmountOut) {
+        return this.contract.requestRedeemViaIntent(user, amount, minAmountOut);
+    }
+}
+class LexPoolV1FunctionsGroup_Processing {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async processDeposit(users) {
+        const result = await this.contract.processDeposit.staticCall(users);
+        return {
+            amountDeposited: result[0],
+            amountCanceled: result[1],
+            counterDeposited: result[2],
+            counterCanceled: result[3],
+        };
+    }
+    async processRedeems(users) {
+        const result = await this.contract.processRedeems.staticCall(users);
+        return {
+            amountRedeemed: result[0],
+            amountCanceled: result[1],
+            counterRedeemed: result[2],
+            counterCanceled: result[3],
+        };
+    }
+    async cancelDeposits(users, epochs) {
+        return this.contract.cancelDeposits(users, epochs);
+    }
+    async cancelRedeems(users, epochs) {
+        return this.contract.cancelRedeems(users, epochs);
+    }
+}
+class LexPoolV1FunctionsGroup_EpochManagement {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async nextEpoch(totalUnrealizedPricePnL) {
+        return this.contract.nextEpoch.staticCall(totalUnrealizedPricePnL);
+    }
+}
+class LexPoolV1FunctionsGroup_TradingFloorInteraction {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async sendAssetToTrader(to, amount) {
+        return this.contract.sendAssetToTrader(to, amount);
+    }
+}
+class LexPoolV1Service {
+    constructor(signerOrProvider, address) {
+        this.lexPoolContract = LexPoolV1__factory_1.LexPoolV1__factory.connect(address, signerOrProvider);
+        this.initialization = new LexPoolV1FunctionsGroup_Initialization(this.lexPoolContract);
+        this.adminConfiguration = new LexPoolV1FunctionsGroup_AdminConfiguration(this.lexPoolContract);
+        this.userDeposits = new LexPoolV1FunctionsGroup_UserDeposits(this.lexPoolContract);
+        this.userRedeems = new LexPoolV1FunctionsGroup_UserRedeems(this.lexPoolContract);
+        this.processing = new LexPoolV1FunctionsGroup_Processing(this.lexPoolContract);
+        this.epochManagement = new LexPoolV1FunctionsGroup_EpochManagement(this.lexPoolContract);
+        this.tradingFloorInteraction = new LexPoolV1FunctionsGroup_TradingFloorInteraction(this.lexPoolContract);
+        // Initialize remaining groups with direct method mappings
+        this.viewFunctions = this.createViewFunctionsGroup();
+        this.stateVariables = this.createStateVariablesGroup();
+        this.erc20 = this.createERC20Group();
+        this.constants = this.createConstantsGroup();
+        this.contractInfo = this.createContractInfoGroup();
+    }
+    createViewFunctionsGroup() {
+        return {
+            calcNextEpochStartMin: () => this.lexPoolContract.calcNextEpochStartMin(),
+            currentBalanceInternal: () => this.lexPoolContract.currentBalanceInternal(),
+            underlyingBalanceForExchangeRate: () => this.lexPoolContract.underlyingBalanceForExchangeRate(),
+            virtualBalanceForUtilization: (extraAmount, unrealizedFunding) => this.lexPoolContract["virtualBalanceForUtilization(uint256,int256)"](extraAmount, unrealizedFunding),
+            virtualBalanceForUtilizationCurrent: () => this.lexPoolContract["virtualBalanceForUtilization()"](),
+            currentVirtualUtilization: (totalBorrows, interestShare, unrealizedFunding) => this.lexPoolContract["currentVirtualUtilization(uint256,uint256,int256)"](totalBorrows, interestShare, unrealizedFunding),
+            currentVirtualUtilizationSimple: () => this.lexPoolContract["currentVirtualUtilization()"](),
+            isUtilizationForLPsValid: () => this.lexPoolContract.isUtilizationForLPsValid(),
+            underlyingAmountToOwnAmount: (underlyingAmount) => this.lexPoolContract.underlyingAmountToOwnAmount(underlyingAmount),
+            getDepositorsCount: (epoch) => this.lexPoolContract.getDepositorsCount(epoch),
+            getRedeemersCount: (epoch) => this.lexPoolContract.getRedeemersCount(epoch),
+            getDepositors: (epoch, indexFrom, count) => this.lexPoolContract.getDepositors(epoch, indexFrom, count),
+            getRedeemers: (epoch, indexFrom, count) => this.lexPoolContract.getRedeemers(epoch, indexFrom, count),
+        };
+    }
+    createStateVariablesGroup() {
+        return {
+            // Configuration
+            underlyingDecimals: () => this.lexPoolContract.underlyingDecimals(),
+            epochDuration: () => this.lexPoolContract.epochDuration(),
+            epochsDelayDeposit: () => this.lexPoolContract.epochsDelayDeposit(),
+            epochsDelayRedeem: () => this.lexPoolContract.epochsDelayRedeem(),
+            minDepositAmount: () => this.lexPoolContract.minDepositAmount(),
+            maxExtraWithdrawalAmountF: () => this.lexPoolContract.maxExtraWithdrawalAmountF(),
+            immediateDepositAllowed: () => this.lexPoolContract.immediateDepositAllowed(),
+            // Epoch state
+            currentEpoch: () => this.lexPoolContract.currentEpoch(),
+            nextEpochStartMin: () => this.lexPoolContract.nextEpochStartMin(),
+            currentExchangeRate: () => this.lexPoolContract.currentExchangeRate(),
+            // Pending amounts
+            pendingDepositAmount: () => this.lexPoolContract.pendingDepositAmount(),
+            pendingWithdrawalAmount: () => this.lexPoolContract.pendingWithdrawalAmount(),
+            // Contract references
+            poolAccountant: () => this.lexPoolContract.poolAccountant(),
+            pnlRole: () => this.lexPoolContract.pnlRole(),
+            underlying: () => this.lexPoolContract.underlying(),
+            registry: () => this.lexPoolContract.registry(),
+            tradingFloor: () => this.lexPoolContract.tradingFloor(),
+        };
+    }
+    createERC20Group() {
+        return {
+            name: () => this.lexPoolContract.name(),
+            symbol: () => this.lexPoolContract.symbol(),
+            decimals: () => this.lexPoolContract.decimals(),
+            totalSupply: () => this.lexPoolContract.totalSupply(),
+            balanceOf: (account) => this.lexPoolContract.balanceOf(account),
+            allowance: (owner, spender) => this.lexPoolContract.allowance(owner, spender),
+            transfer: (to, amount) => this.lexPoolContract.transfer(to, amount),
+            transferFrom: (from, to, amount) => this.lexPoolContract.transferFrom(from, to, amount),
+            approve: (spender, amount) => this.lexPoolContract.approve(spender, amount),
+        };
+    }
+    createConstantsGroup() {
+        return {
+            SELF_UNIT_SCALE: () => this.lexPoolContract.SELF_UNIT_SCALE(),
+            PRECISION: () => this.lexPoolContract.PRECISION(),
+            FRACTION_SCALE: () => this.lexPoolContract.FRACTION_SCALE(),
+        };
+    }
+    createContractInfoGroup() {
+        return {
+            admin: () => this.lexPoolContract.admin(),
+            pendingAdmin: () => this.lexPoolContract.pendingAdmin(),
+            implementation: () => this.lexPoolContract.implementation(),
+            pendingImplementation: () => this.lexPoolContract.pendingImplementation(),
+        };
+    }
+}
+exports.LexPoolV1Service = LexPoolV1Service;

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

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

package/dist/cjs/lib/contractsIntegration/PNLRService/IPNLRService.js

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

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

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PNLRService = void 0;
+const PNLR__factory_1 = require("../../typechain/factories/contracts/Lynx/Lex/PNLR/PNLR__factory");
+class PNLRFunctionsGroup_EpochManagement {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async advanceEpoch(pool, pairsPrices, value) {
+        const options = value ? { value } : {};
+        return this.contract.advanceEpoch(pool, pairsPrices, options);
+    }
+    async advanceEpochAllowMissingZeroOI(pool, pairsPrices, value) {
+        const options = value ? { value } : {};
+        return this.contract.advanceEpochAllowMissingZeroOI(pool, pairsPrices, options);
+    }
+}
+class PNLRFunctionsGroup_PnLCalculation {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async calculateUnrealizedPricePnl(poolAccountant, pairsPrices, value) {
+        // Payable view function - value parameter is optional for gas estimation
+        return this.contract.calculateUnrealizedPricePnl.staticCall(poolAccountant, pairsPrices);
+    }
+    async calculateUnrealizedPricePnlAllowMissingZeroOI(poolAccountant, pairsPrices, value) {
+        // Payable view function - value parameter is optional for gas estimation
+        return this.contract.calculateUnrealizedPricePnlAllowMissingZeroOI.staticCall(poolAccountant, pairsPrices);
+    }
+    async pairsTradersPricePnl(poolAccountant, pairsPrices, value) {
+        // Payable view function - value parameter is optional for gas estimation
+        return this.contract.pairsTradersPricePnl.staticCall(poolAccountant, pairsPrices);
+    }
+    async pairsTradersPricePnlWithMissingPairs(poolAccountant, pairsPrices, allowMissingZeroOI, value) {
+        // Payable view function - value parameter is optional for gas estimation
+        return this.contract.pairsTradersPricePnlWithMissingPairs.staticCall(poolAccountant, pairsPrices, allowMissingZeroOI);
+    }
+}
+class PNLRFunctionsGroup_PermissionManagement {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async allowEpochAdvancingAccount(account) {
+        return this.contract.allowEpochAdvancingAccount(account);
+    }
+    async disallowEpochAdvancingAccount(account) {
+        return this.contract.disallowEpochAdvancingAccount(account);
+    }
+    async isAllowedToTrigger(account) {
+        return this.contract.isAllowedToTrigger(account);
+    }
+    async getAllTriggerPermissionedAccounts() {
+        return this.contract.getAllTriggerPermissionedAccounts();
+    }
+}
+class PNLRFunctionsGroup_Configuration {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async maxPriceDelay() {
+        return this.contract.maxPriceDelay();
+    }
+    async setMaxPriceDelay(delay) {
+        return this.contract.setMaxPriceDelay(delay);
+    }
+    async priceValidator() {
+        return this.contract.priceValidator();
+    }
+    async priceValidatorType() {
+        return this.contract.priceValidatorType();
+    }
+}
+class PNLRFunctionsGroup_ContractInfo {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async admin() {
+        return this.contract.admin();
+    }
+    async pendingAdmin() {
+        return this.contract.pendingAdmin();
+    }
+    async getContractName() {
+        return this.contract.getContractName();
+    }
+    async getContractVersion() {
+        return this.contract.getContractVersion();
+    }
+}
+class PNLRFunctionsGroup_AdminManagement {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async _setPendingAdmin(newPendingAdmin) {
+        return this.contract._setPendingAdmin(newPendingAdmin);
+    }
+    async _acceptAdmin() {
+        return this.contract._acceptAdmin();
+    }
+}
+class PNLRFunctionsGroup_Constants {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async CONTRACT_NAME() {
+        return this.contract.CONTRACT_NAME();
+    }
+    async CONTRACT_VERSION() {
+        return this.contract.CONTRACT_VERSION();
+    }
+}
+class PNLRService {
+    constructor(signerOrProvider, address) {
+        this.pnlrContract = PNLR__factory_1.PNLR__factory.connect(address, signerOrProvider);
+        this.epochManagement = new PNLRFunctionsGroup_EpochManagement(this.pnlrContract);
+        this.pnlCalculation = new PNLRFunctionsGroup_PnLCalculation(this.pnlrContract);
+        this.permissionManagement = new PNLRFunctionsGroup_PermissionManagement(this.pnlrContract);
+        this.configuration = new PNLRFunctionsGroup_Configuration(this.pnlrContract);
+        this.adminManagement = new PNLRFunctionsGroup_AdminManagement(this.pnlrContract);
+        this.contractInfo = new PNLRFunctionsGroup_ContractInfo(this.pnlrContract);
+        this.constants = new PNLRFunctionsGroup_Constants(this.pnlrContract);
+    }
+}
+exports.PNLRService = PNLRService;

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

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

package/dist/cjs/lib/contractsIntegration/PoolAccountantV1Service/IPoolAccountantV1Service.js

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