lynx-client 0.0.5 → 0.0.7

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

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolAccountantV1Service = void 0;
+const PoolAccountantV1__factory_1 = require("../../typechain/factories/contracts/Lynx/Lex/PoolAccountant/PoolAccountantV1__factory");
+// Note: registerOpenTrade, registerCloseTrade, and registerUpdateTp are internal protocol functions
+// called only by other Lynx contracts and are not exposed for external use
+class PoolAccountantV1FunctionsGroup_TradeUtilities {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async adjustClosePrice(closePrice, tp, long) {
+        return this.contract.adjustClosePrice(closePrice, tp, long);
+    }
+    async generatePositionHashId(settlementAsset, trader, pairId, index) {
+        return this.contract.generatePositionHashId(settlementAsset, trader, pairId, index);
+    }
+}
+class PoolAccountantV1FunctionsGroup_FeeCalculations {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async calcClosingFee(pairId, collateral, leverage) {
+        return this.contract.calcClosingFee(pairId, collateral, leverage);
+    }
+    async calcPerformanceFee(pairId, collateral, profitPrecision) {
+        return this.contract.calcPerformanceFee(pairId, collateral, profitPrecision);
+    }
+    async calcTradeDynamicFees(positionId, pairId, long, collateral, leverage, openPrice, tp) {
+        const result = await this.contract.calcTradeDynamicFees.staticCall(positionId, pairId, long, collateral, leverage, openPrice, tp);
+        return {
+            interest: result.interest,
+            funding: result.funding,
+        };
+    }
+    async calcBorrowAmount(collateral, leverage, long, openPrice, tp) {
+        return this.contract.calcBorrowAmount(collateral, leverage, long, openPrice, tp);
+    }
+    async calcAbsoluteSkew(openInterestLong, openInterestShort, additionIsLong, additionOpenInterest) {
+        return this.contract.calcAbsoluteSkew(openInterestLong, openInterestShort, additionIsLong, additionOpenInterest);
+    }
+    async calcAccrueFundingValues(pairId) {
+        const result = await this.contract.calcAccrueFundingValues(pairId);
+        return {
+            freshened: result.freshened,
+            valueLong: result.valueLong,
+            valueShort: result.valueShort,
+            protocolFundingShare: result.protocolFundingShare,
+        };
+    }
+}
+// Similarly implement other groups...
+// For brevity, I'll create a simplified version with the main structure
+class PoolAccountantV1Service {
+    constructor(signerOrProvider, address) {
+        this.poolAccountantContract = PoolAccountantV1__factory_1.PoolAccountantV1__factory.connect(address, signerOrProvider);
+        this.tradeUtilities = new PoolAccountantV1FunctionsGroup_TradeUtilities(this.poolAccountantContract);
+        this.feeCalculations = new PoolAccountantV1FunctionsGroup_FeeCalculations(this.poolAccountantContract);
+        this.verification = this.createVerificationGroup();
+        // Initialize other groups with direct method mappings
+        this.funding = this.createFundingGroup();
+        this.interest = this.createInterestGroup();
+        this.liquidation = this.createLiquidationGroup();
+        this.tradeValues = this.createTradeValuesGroup();
+        this.pairManagement = this.createPairManagementGroup();
+        this.adminConfiguration = this.createAdminConfigurationGroup();
+        this.poolInteraction = this.createPoolInteractionGroup();
+        this.stateVariables = this.createStateVariablesGroup();
+        this.contractInfo = this.createContractInfoGroup();
+        this.constants = this.createConstantsGroup();
+    }
+    createVerificationGroup() {
+        return {
+            verifyLeveragedPosition: async (pairIndex, collateral, leverage) => {
+                const result = await this.poolAccountantContract.verifyLeveragedPosition(pairIndex, collateral, leverage);
+                return result;
+            },
+            verifyOpenFee: async (pairIndex, leveragedPosition) => {
+                const result = await this.poolAccountantContract.verifyOpenFee(pairIndex, leveragedPosition);
+                return {
+                    openFee: result[0],
+                    lexPartFee: result[1],
+                };
+            },
+            verifyPerformanceFee: (pairIndex, collateral) => this.poolAccountantContract.verifyPerformanceFee(pairIndex, collateral),
+            verifyMaxPercentProfit: (openPrice, targetPrice, leverage, long) => this.poolAccountantContract.verifyMaxPercentProfit(openPrice, targetPrice, leverage, long),
+            verifyUtilizationForTraders: (totalBorrows, totalReserves, unrealizedFunding) => this.poolAccountantContract.verifyUtilizationForTraders(totalBorrows, totalReserves, unrealizedFunding),
+        };
+    }
+    createFundingGroup() {
+        return {
+            accrueFunding: async (pairId) => {
+                const result = await this.poolAccountantContract.accrueFunding.staticCall(pairId);
+                return {
+                    valueLong: result[0],
+                    valueShort: result[1],
+                    protocolFundingShare: result[2],
+                };
+            },
+            calcAccrueFundingValues: (pairId) => this.poolAccountantContract
+                .calcAccrueFundingValues(pairId)
+                .then((r) => ({
+                freshened: r.freshened,
+                valueLong: r.valueLong,
+                valueShort: r.valueShort,
+                protocolFundingShare: r.protocolFundingShare,
+            })),
+            fundingIndicesCalculation: (oiLong, oiShort, fundingRate, timeDiff) => this.poolAccountantContract
+                .fundingIndicesCalculation(oiLong, oiShort, fundingRate, timeDiff)
+                .then((r) => ({
+                indexLongChange: r.indexLongChange,
+                indexShortChange: r.indexShortChange,
+                protocolFundingShare: r.protocolFundingShare,
+            })),
+            getTradeFunding: (positionId, pairId, long, collateral, leverage) => this.poolAccountantContract.getTradeFunding.staticCall(positionId, pairId, long, collateral, leverage),
+            getTradeFundingPure: (accFundingPerOi, endAccFundingPerOi, collateral, leverage) => this.poolAccountantContract.getTradeFundingPure(accFundingPerOi, endAccFundingPerOi, collateral, leverage),
+            getTradeInitialAccFundingPerOi: (positionId) => this.poolAccountantContract.getTradeInitialAccFundingPerOi(positionId),
+            getAccFundingLong: (pairIndex) => this.poolAccountantContract.getAccFundingLong(pairIndex),
+            getAccFundingShort: (pairIndex) => this.poolAccountantContract.getAccFundingShort(pairIndex),
+            getAccFundingUpdateBlock: (pairIndex) => this.poolAccountantContract.getAccFundingUpdateBlock(pairIndex),
+        };
+    }
+    createInterestGroup() {
+        return {
+            getTradeInterest: (positionId, borrowAmount) => this.poolAccountantContract.getTradeInterest.staticCall(positionId, borrowAmount),
+            getTradeInterestPure: (tradeAccInterest, borrowsAndInterestShare, borrowIndex, accBorrowIndex) => this.poolAccountantContract.getTradeInterestPure(tradeAccInterest, borrowsAndInterestShare, borrowIndex, accBorrowIndex),
+            getTradeInitialAccBorrowIndex: (positionId) => this.poolAccountantContract.getTradeInitialAccBorrowIndex(positionId),
+            accrueInterest: async (availableCash) => {
+                const result = await this.poolAccountantContract["accrueInterest(uint256)"].staticCall(availableCash);
+                return {
+                    totalInterestNew: result[0],
+                    interestShareNew: result[1],
+                    borrowIndexNew: result[2],
+                };
+            },
+        };
+    }
+    createLiquidationGroup() {
+        return {
+            getTradeLiquidationPrice: (positionId, pairId, openPrice, tp, long, collateral, leverage) => this.poolAccountantContract.getTradeLiquidationPrice.staticCall(positionId, pairId, openPrice, tp, long, collateral, leverage),
+            getTradeLiquidationPriceView: (openPrice, long, collateral, leverage, interest, funding, closingFee) => this.poolAccountantContract.getTradeLiquidationPriceView(openPrice, long, collateral, leverage, interest, funding, closingFee),
+        };
+    }
+    createTradeValuesGroup() {
+        return {
+            getTradeValueView: (collateral, profitPrecision, interest, funding, closingFee, liquidation) => this.poolAccountantContract.getTradeValueView(collateral, profitPrecision, interest, funding, closingFee, liquidation),
+            getTradeClosingValues: async (positionId, pairId, collateral, leverage, long, openPrice, tp, closePrice, isLiquidation) => {
+                const params = {
+                    collateral,
+                    leverage,
+                    long,
+                    openPrice,
+                    tp,
+                };
+                const result = await this.poolAccountantContract.getTradeClosingValues.staticCall(positionId, pairId, params, closePrice, isLiquidation);
+                return {
+                    tradeValue: result[0],
+                    safeClosingFee: result[1],
+                    profitPrecision: result[2],
+                    interest: result[3],
+                    funding: result[4],
+                };
+            },
+        };
+    }
+    createPairManagementGroup() {
+        return {
+            pairTotalOpenInterest: (pairIndex) => this.poolAccountantContract.pairTotalOpenInterest(pairIndex),
+            calcAbsoluteSkew: (openInterestLong, openInterestShort, additionIsLong, additionOpenInterest) => this.poolAccountantContract.calcAbsoluteSkew(openInterestLong, openInterestShort, additionIsLong, additionOpenInterest),
+            pricePnL: (pairId, price) => this.poolAccountantContract.pricePnL(pairId, price),
+        };
+    }
+    createAdminConfigurationGroup() {
+        return {
+            setTradeIncentivizer: (incentivizer) => this.poolAccountantContract.setTradeIncentivizer(incentivizer),
+            setMaxGainF: (maxGainF) => this.poolAccountantContract.setMaxGainF(maxGainF),
+            setFrm: (frm) => this.poolAccountantContract.setFrm(frm),
+            setMinOpenFee: (min) => this.poolAccountantContract.setMinOpenFee(min),
+            setLexPartF: (partF) => this.poolAccountantContract.setLexPartF(partF),
+            setFundingRateMax: (maxValue) => this.poolAccountantContract.setFundingRateMax(maxValue),
+            setLiquidationThresholdF: (threshold) => this.poolAccountantContract.setLiquidationThresholdF(threshold),
+            setLiquidationFeeF: (fee) => this.poolAccountantContract.setLiquidationFeeF(fee),
+            setIrm: (irm) => this.poolAccountantContract.setIrm(irm),
+            setIrmHard: (irm) => this.poolAccountantContract.setIrmHard(irm),
+            setInterestShareFactor: (factor) => this.poolAccountantContract.setInterestShareFactor(factor),
+            setFundingShareFactor: (factor) => this.poolAccountantContract.setFundingShareFactor(factor),
+            setBorrowRateMax: (rate) => this.poolAccountantContract.setBorrowRateMax(rate),
+            setMaxTotalBorrows: (maxBorrows) => this.poolAccountantContract.setMaxTotalBorrows(maxBorrows),
+            setMaxVirtualUtilization: (maxUtilization) => this.poolAccountantContract.setMaxVirtualUtilization(maxUtilization),
+        };
+    }
+    createPoolInteractionGroup() {
+        return {
+            readAndZeroReserves: async () => {
+                const result = await this.poolAccountantContract.readAndZeroReserves.staticCall();
+                return {
+                    accumulatedInterestShare: result[0],
+                    accFundingShare: result[1],
+                };
+            },
+        };
+    }
+    createStateVariablesGroup() {
+        return {
+            // Interest and borrowing state
+            borrowIndex: () => this.poolAccountantContract.borrowIndex(),
+            borrowRateMax: () => this.poolAccountantContract.borrowRateMax(),
+            totalBorrows: () => this.poolAccountantContract.totalBorrows(),
+            totalInterest: () => this.poolAccountantContract.totalInterest(),
+            interestShare: () => this.poolAccountantContract.interestShare(),
+            interestShareFactor: () => this.poolAccountantContract.interestShareFactor(),
+            // Funding state
+            fundingRateMax: () => this.poolAccountantContract.fundingRateMax(),
+            fundingShare: () => this.poolAccountantContract.fundingShare(),
+            fundingShareFactor: () => this.poolAccountantContract.fundingShareFactor(),
+            unrealizedFunding: () => this.poolAccountantContract.unrealizedFunding(),
+            realizedFundingSurplusDeficit: () => this.poolAccountantContract.realizedFundingSurplusDeficit(),
+            // Configuration
+            maxGainF: () => this.poolAccountantContract.maxGainF(),
+            liquidationFeeF: () => this.poolAccountantContract.liquidationFeeF(),
+            liquidationThresholdF: () => this.poolAccountantContract.liquidationThresholdF(),
+            maxTotalBorrows: () => this.poolAccountantContract.maxTotalBorrows(),
+            maxVirtualUtilization: () => this.poolAccountantContract.maxVirtualUtilization(),
+            minOpenFee: () => this.poolAccountantContract.minOpenFee(),
+            lexPartF: () => this.poolAccountantContract.lexPartF(),
+            // Contract references
+            lexPool: () => this.poolAccountantContract.lexPool(),
+            tradingFloor: () => this.poolAccountantContract.tradingFloor(),
+            tradeIncentivizer: () => this.poolAccountantContract.tradeIncentivizer(),
+            frm: () => this.poolAccountantContract.frm(),
+            irm: () => this.poolAccountantContract.irm(),
+            underlying: () => this.poolAccountantContract.underlying(),
+            // Timestamps
+            accrualBlockTimestamp: () => this.poolAccountantContract.accrualBlockTimestamp(),
+        };
+    }
+    createContractInfoGroup() {
+        return {
+            admin: () => this.poolAccountantContract.admin(),
+            pendingAdmin: () => this.poolAccountantContract.pendingAdmin(),
+            implementation: () => this.poolAccountantContract.implementation(),
+            pendingImplementation: () => this.poolAccountantContract.pendingImplementation(),
+            registry: () => this.poolAccountantContract.registry(),
+        };
+    }
+    createConstantsGroup() {
+        return {
+            ACCURACY_IMPROVEMENT_SCALE: () => this.poolAccountantContract.ACCURACY_IMPROVEMENT_SCALE(),
+            FRACTION_SCALE: () => this.poolAccountantContract.FRACTION_SCALE(),
+            LEVERAGE_SCALE: () => this.poolAccountantContract.LEVERAGE_SCALE(),
+            PRECISION: () => this.poolAccountantContract.PRECISION(),
+        };
+    }
+}
+exports.PoolAccountantV1Service = PoolAccountantV1Service;

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

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

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

@@ -11,23 +11,23 @@ exports.EMPTY_COMPLETE_POSITION_DATA = {
     collateral: 0n,
     phase: 0,
     inPhaseSince: 0,
-    leverage: 0,
+    leverage: 0n,
     long: false,
-    openPrice: 0,
-    spreadReductionF: 0,
-    minPrice: 0,
-    maxPrice: 0,
+    openPrice: 0n,
+    spreadReductionF: 0n,
+    minPrice: 0n,
+    maxPrice: 0n,
     tpLastUpdated: 0,
     slLastUpdated: 0,
-    tp: 0,
-    sl: 0,
+    tp: 0n,
+    sl: 0n,
     pendingUpdateOrderType: 0,
     pendingUpdateOrderTimestamp: 0,
     pendingUpdateOrderFieldAValue: 0n,
     pendingUpdateOrderFieldBValue: 0n,
     funding: 0n,
     borrowInterest: 0n,
-    liquidationPrice: 0,
+    liquidationPrice: 0n,
 };
 exports.EMPTY_POSITIONS_RESULT = {
     positions: [],
@@ -40,7 +40,7 @@ exports.EMPTY_POSITION_LIQUIDATION_INFO = {
     phase: 0,
     funding: 0n,
     borrowInterest: 0n,
-    liquidationPrice: 0,
+    liquidationPrice: 0n,
 };
 exports.EMPTY_LIQUIDATION_RESULT = {
     positionsLiquidationInfo: [],

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

@@ -13,18 +13,18 @@ function convertPositionData(pos) {
         positionIndex: Number(baseStruct.positionIndex),
         phase: Number(baseStruct.phase),
         inPhaseSince: Number(baseStruct.inPhaseSince),
-        leverage: Number(baseStruct.leverage),
-        openPrice: Number(baseStruct.openPrice),
-        spreadReductionF: Number(baseStruct.spreadReductionF),
-        minPrice: Number(baseStruct.minPrice),
-        maxPrice: Number(baseStruct.maxPrice),
+        leverage: baseStruct.leverage,
+        openPrice: baseStruct.openPrice,
+        spreadReductionF: baseStruct.spreadReductionF,
+        minPrice: baseStruct.minPrice,
+        maxPrice: baseStruct.maxPrice,
         tpLastUpdated: Number(baseStruct.tpLastUpdated),
         slLastUpdated: Number(baseStruct.slLastUpdated),
-        tp: Number(baseStruct.tp),
-        sl: Number(baseStruct.sl),
+        tp: baseStruct.tp,
+        sl: baseStruct.sl,
         pendingUpdateOrderType: Number(baseStruct.pendingUpdateOrderType),
         pendingUpdateOrderTimestamp: Number(baseStruct.pendingUpdateOrderTimestamp),
-        liquidationPrice: Number(baseStruct.liquidationPrice),
+        liquidationPrice: baseStruct.liquidationPrice,
     };
 }
 function convertLiquidationInfo(pos) {
@@ -32,7 +32,7 @@ function convertLiquidationInfo(pos) {
     return {
         ...baseStruct,
         phase: Number(baseStruct.phase),
-        liquidationPrice: Number(baseStruct.liquidationPrice),
+        liquidationPrice: baseStruct.liquidationPrice,
     };
 }
 class TradingFloorLensService {

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

@@ -127,6 +127,15 @@ class TradingFloorService {
     async positionIdToActivePositionIndex(trader, positionId) {
         return this.tradingFloorContract.positionIdToActivePositionIndex(trader, positionId);
     }
+    async getActivePositionIdsForTrader(trader) {
+        return this.tradingFloorContract.getActivePositionIdsForTrader(trader);
+    }
+    async getNextPositionIndexForTrader(trader) {
+        return this.tradingFloorContract.getNextPositionIndexForTrader(trader);
+    }
+    async pairTradersLastUsedPositionIndex(trader) {
+        return this.tradingFloorContract.pairTradersLastUsedPositionIndex(trader);
+    }
     // Read-only Functions - Trading Parameters
     async maxSanityProfitF() {
         return this.tradingFloorContract.maxSanityProfitF();
@@ -157,6 +166,19 @@ class TradingFloorService {
     async registry() {
         return this.tradingFloorContract.registry();
     }
+    // Contract Information
+    async getContractName() {
+        return this.tradingFloorContract.getContractName();
+    }
+    async getContractVersion() {
+        return this.tradingFloorContract.getContractVersion();
+    }
+    async CONTRACT_NAME() {
+        return this.tradingFloorContract.CONTRACT_NAME();
+    }
+    async CONTRACT_VERSION() {
+        return this.tradingFloorContract.CONTRACT_VERSION();
+    }
     // Constants
     async ACCURACY_IMPROVEMENT_SCALE() {
         return this.tradingFloorContract.ACCURACY_IMPROVEMENT_SCALE();

package/dist/cjs/lib/typechain/contracts/AdministrationContracts/AcceptableImplementationClaimableAdmin.js

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

package/dist/cjs/lib/typechain/contracts/Lynx/Lex/PNLR/PNLR.js

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

package/dist/cjs/lib/typechain/contracts/Lynx/Lex/PoolAccountant/PoolAccountantV1.js

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

package/dist/cjs/lib/typechain/contracts/Lynx/interfaces/IPriceValidatorV1.js

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

package/dist/cjs/lib/typechain/factories/contracts/AdministrationContracts/AcceptableImplementationClaimableAdmin__factory.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcceptableImplementationClaimableAdmin__factory = void 0;
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+const ethers_1 = require("ethers");
+const _abi = [
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "_initialAdmin",
+                type: "address",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "constructor",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: false,
+                internalType: "address",
+                name: "oldAdmin",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "newAdmin",
+                type: "address",
+            },
+        ],
+        name: "NewAdmin",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: false,
+                internalType: "address",
+                name: "oldImplementation",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "newImplementation",
+                type: "address",
+            },
+        ],
+        name: "NewImplementation",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: false,
+                internalType: "address",
+                name: "oldPendingAdmin",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "newPendingAdmin",
+                type: "address",
+            },
+        ],
+        name: "NewPendingAdmin",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: false,
+                internalType: "address",
+                name: "oldPendingImplementation",
+                type: "address",
+            },
+            {
+                indexed: false,
+                internalType: "address",
+                name: "newPendingImplementation",
+                type: "address",
+            },
+        ],
+        name: "NewPendingImplementation",
+        type: "event",
+    },
+    {
+        stateMutability: "payable",
+        type: "fallback",
+    },
+    {
+        inputs: [],
+        name: "_acceptAdmin",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "_acceptImplementation",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "newPendingAdmin",
+                type: "address",
+            },
+        ],
+        name: "_setPendingAdmin",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            {
+                internalType: "address",
+                name: "newPendingImplementation",
+                type: "address",
+            },
+        ],
+        name: "_setPendingImplementation",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "admin",
+        outputs: [
+            {
+                internalType: "address",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "implementation",
+        outputs: [
+            {
+                internalType: "address",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "pendingAdmin",
+        outputs: [
+            {
+                internalType: "address",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "pendingImplementation",
+        outputs: [
+            {
+                internalType: "address",
+                name: "",
+                type: "address",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        stateMutability: "payable",
+        type: "receive",
+    },
+];
+const _bytecode = "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";
+const isSuperArgs = (xs) => xs.length > 1;
+class AcceptableImplementationClaimableAdmin__factory extends ethers_1.ContractFactory {
+    constructor(...args) {
+        if (isSuperArgs(args)) {
+            super(...args);
+        }
+        else {
+            super(_abi, _bytecode, args[0]);
+        }
+    }
+    getDeployTransaction(_initialAdmin, overrides) {
+        return super.getDeployTransaction(_initialAdmin, overrides || {});
+    }
+    deploy(_initialAdmin, overrides) {
+        return super.deploy(_initialAdmin, overrides || {});
+    }
+    connect(runner) {
+        return super.connect(runner);
+    }
+    static createInterface() {
+        return new ethers_1.Interface(_abi);
+    }
+    static connect(address, runner) {
+        return new ethers_1.Contract(address, _abi, runner);
+    }
+}
+exports.AcceptableImplementationClaimableAdmin__factory = AcceptableImplementationClaimableAdmin__factory;
+AcceptableImplementationClaimableAdmin__factory.bytecode = _bytecode;
+AcceptableImplementationClaimableAdmin__factory.abi = _abi;