lynx-client 0.0.13 → 0.0.14

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.tradeIntentsVerifierPayloadTypes = exports.liquidityIntentsVerifierPayloadTypes = exports.chipsIntentsVerifierPayloadTypes = exports.PoolAccountantV1Service = exports.PNLRService = exports.AcceptableImplementationClaimableAdminService = exports.LexPoolV1Service = exports.OnBehalfTradingService = exports.TradeIntentsVerifierService = exports.LiquidityIntentsVerifierService = exports.ChipsIntentsVerifierService = void 0;
+exports.tradeIntentsVerifierPayloadTypes = exports.liquidityIntentsVerifierPayloadTypes = exports.chipsIntentsVerifierPayloadTypes = exports.PoolAccountantV1Service = exports.PNLRService = exports.AcceptableImplementationClaimableAdminService = exports.LexPoolV1Service = exports.WrappedNativeEngineChipHelperService = exports.EngineChipService = exports.OnBehalfTradingService = 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);
@@ -41,6 +41,8 @@ __exportStar(require("./lib/addresses/systemAddresses"), exports);
 __exportStar(require("./lib/contractsIntegration/deployedContractsConnector"), exports);
 __exportStar(require("./lib/contractsIntegration/TradersPortalService"), exports);
 __exportStar(require("./lib/contractsIntegration/TradingFloorService"), exports);
+__exportStar(require("./lib/contractsIntegration/TriggersService"), exports);
+__exportStar(require("./lib/contractsIntegration/OrderBookService"), 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");
@@ -49,6 +51,10 @@ var TradeIntentsVerifierService_1 = require("./lib/contractsIntegration/TradeInt
 Object.defineProperty(exports, "TradeIntentsVerifierService", { enumerable: true, get: function () { return TradeIntentsVerifierService_1.TradeIntentsVerifierService; } });
 var OnBehalfTradingService_1 = require("./lib/contractsIntegration/OnBehalfTradingService");
 Object.defineProperty(exports, "OnBehalfTradingService", { enumerable: true, get: function () { return OnBehalfTradingService_1.OnBehalfTradingService; } });
+var EngineChipService_1 = require("./lib/contractsIntegration/EngineChipService");
+Object.defineProperty(exports, "EngineChipService", { enumerable: true, get: function () { return EngineChipService_1.EngineChipService; } });
+var WrappedNativeEngineChipHelperService_1 = require("./lib/contractsIntegration/WrappedNativeEngineChipHelperService");
+Object.defineProperty(exports, "WrappedNativeEngineChipHelperService", { enumerable: true, get: function () { return WrappedNativeEngineChipHelperService_1.WrappedNativeEngineChipHelperService; } });
 var LexPoolV1Service_1 = require("./lib/contractsIntegration/LexPoolV1Service");
 Object.defineProperty(exports, "LexPoolV1Service", { enumerable: true, get: function () { return LexPoolV1Service_1.LexPoolV1Service; } });
 var AcceptableImplementationClaimableAdminService_1 = require("./lib/contractsIntegration/AcceptableImplementationClaimableAdminService");
@@ -83,5 +89,8 @@ __exportStar(require("./lib/typechain/factories/contracts/Lynx/IntentsVerifier/L
 __exportStar(require("./lib/typechain/factories/contracts/Lynx/IntentsVerifier/TradeIntentsVerifierV1__factory"), exports);
 // Contract factory export for OnBehalfTrading
 __exportStar(require("./lib/typechain/factories/contracts/Lynx/OnBehalfTrading/OnBehalfTradingV1__factory"), exports);
+// Contract factory exports for Chips
+__exportStar(require("./lib/typechain/factories/contracts/Lynx/Chips/EngineChip/EngineChip__factory"), exports);
+__exportStar(require("./lib/typechain/factories/contracts/Peripheral/Chips/WrappedNativeEngineChipHelper__factory"), exports);
 // Developer Experience utilities
 __exportStar(require("./lib/devex"), exports);

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

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EngineChipService = void 0;
+const EngineChip__factory_1 = require("../../typechain/factories/contracts/Lynx/Chips/EngineChip/EngineChip__factory");
+// ============ ERC20 Operations Implementation ============
+class ERC20Operations {
+    constructor(contract, isSigner) {
+        this.contract = contract;
+        this.isSigner = isSigner;
+    }
+    async name() {
+        return await this.contract.name();
+    }
+    async symbol() {
+        return await this.contract.symbol();
+    }
+    async decimals() {
+        return await this.contract.decimals();
+    }
+    async totalSupply() {
+        return await this.contract.totalSupply();
+    }
+    async balanceOf(account) {
+        return await this.contract.balanceOf(account);
+    }
+    async allowance(owner, spender) {
+        return await this.contract.allowance(owner, spender);
+    }
+    async approve(spender, value) {
+        if (!this.isSigner) {
+            throw new Error("EngineChipService: Write operations require a signer");
+        }
+        return await this.contract.approve(spender, value);
+    }
+    async transfer(to, value) {
+        if (!this.isSigner) {
+            throw new Error("EngineChipService: Write operations require a signer");
+        }
+        return await this.contract.transfer(to, value);
+    }
+    async transferFrom(from, to, value) {
+        if (!this.isSigner) {
+            throw new Error("EngineChipService: Write operations require a signer");
+        }
+        return await this.contract.transferFrom(from, to, value);
+    }
+}
+// ============ Minting Operations Implementation ============
+class MintingOperations {
+    constructor(contract, isSigner) {
+        this.contract = contract;
+        this.isSigner = isSigner;
+    }
+    async mintChip(toAddress, amount) {
+        if (!this.isSigner) {
+            throw new Error("EngineChipService: Write operations require a signer");
+        }
+        return await this.contract.mintChip(toAddress, amount);
+    }
+    async isMintingPaused() {
+        return await this.contract.isMintingPaused();
+    }
+    async setIsMintingPaused(value) {
+        if (!this.isSigner) {
+            throw new Error("EngineChipService: Write operations require a signer");
+        }
+        return await this.contract.setIsMintingPaused(value);
+    }
+    async setMintController(mintController) {
+        if (!this.isSigner) {
+            throw new Error("EngineChipService: Write operations require a signer");
+        }
+        return await this.contract.setMintController(mintController);
+    }
+    async mintController() {
+        return await this.contract.mintController();
+    }
+}
+// ============ Burning Operations Implementation ============
+class BurningOperations {
+    constructor(contract, isSigner) {
+        this.contract = contract;
+        this.isSigner = isSigner;
+    }
+    async burnChip(receiver, amount) {
+        if (!this.isSigner) {
+            throw new Error("EngineChipService: Write operations require a signer");
+        }
+        return await this.contract.burnChip(receiver, amount);
+    }
+    async burnChipAndCall(amount, payload) {
+        if (!this.isSigner) {
+            throw new Error("EngineChipService: Write operations require a signer");
+        }
+        return await this.contract.burnChipAndCall(amount, payload);
+    }
+    async setBurnController(burnController) {
+        if (!this.isSigner) {
+            throw new Error("EngineChipService: Write operations require a signer");
+        }
+        return await this.contract.setBurnController(burnController);
+    }
+    async setBurnHandler(handler) {
+        if (!this.isSigner) {
+            throw new Error("EngineChipService: Write operations require a signer");
+        }
+        return await this.contract.setBurnHandler(handler);
+    }
+    async burnController() {
+        return await this.contract.burnController();
+    }
+    async burnHandler() {
+        return await this.contract.burnHandler();
+    }
+}
+// ============ Admin Functions Implementation ============
+class AdminFunctions {
+    constructor(contract, isSigner) {
+        this.contract = contract;
+        this.isSigner = isSigner;
+    }
+    async setPendingAdmin(newPendingAdmin) {
+        if (!this.isSigner) {
+            throw new Error("EngineChipService: Write operations require a signer");
+        }
+        return await this.contract._setPendingAdmin(newPendingAdmin);
+    }
+    async acceptAdmin() {
+        if (!this.isSigner) {
+            throw new Error("EngineChipService: Write operations require a signer");
+        }
+        return await this.contract._acceptAdmin();
+    }
+    async sweepTokens(token, amount) {
+        if (!this.isSigner) {
+            throw new Error("EngineChipService: Write operations require a signer");
+        }
+        return await this.contract.sweepTokens(token, amount);
+    }
+    async sweepNative(amount) {
+        if (!this.isSigner) {
+            throw new Error("EngineChipService: Write operations require a signer");
+        }
+        return await this.contract.sweepNative(amount);
+    }
+}
+// ============ Auto Approval Management Implementation ============
+class AutoApprovalManagement {
+    constructor(contract, isSigner) {
+        this.contract = contract;
+        this.isSigner = isSigner;
+    }
+    async setAutoApprovedSpenderForRole(role, spender) {
+        if (!this.isSigner) {
+            throw new Error("EngineChipService: Write operations require a signer");
+        }
+        return await this.contract.setAutoApprovedSpenderForRole(role, spender);
+    }
+    async getAutoApprovedSpenderAddressByRole(role) {
+        return await this.contract.getAutoApprovedSpenderAddressByRole(role);
+    }
+    async autoApproved(address) {
+        return await this.contract.autoApproved(address);
+    }
+    async autoApprovedSpendersByRoles(roleHash) {
+        return await this.contract.autoApprovedSpendersByRoles(roleHash);
+    }
+}
+// ============ View Functions Implementation ============
+class ViewFunctions {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async exchangeRate() {
+        return await this.contract.exchangeRate();
+    }
+    async underlyingToken() {
+        return await this.contract.underlyingToken();
+    }
+    async chipMode() {
+        return await this.contract.chipMode();
+    }
+    async registry() {
+        return await this.contract.registry();
+    }
+    async SELF_UNIT_SCALE() {
+        return await this.contract.SELF_UNIT_SCALE();
+    }
+    async getChipConfiguration() {
+        const [name, symbol, decimals, totalSupply, underlyingToken, exchangeRate, chipMode, selfUnitScale,] = await Promise.all([
+            this.contract.name(),
+            this.contract.symbol(),
+            this.contract.decimals(),
+            this.contract.totalSupply(),
+            this.contract.underlyingToken(),
+            this.contract.exchangeRate(),
+            this.contract.chipMode(),
+            this.contract.SELF_UNIT_SCALE(),
+        ]);
+        return {
+            name,
+            symbol,
+            decimals,
+            totalSupply,
+            underlyingToken,
+            exchangeRate,
+            chipMode,
+            selfUnitScale,
+        };
+    }
+    async getChipControllers() {
+        const [mintController, burnController, burnHandler] = await Promise.all([
+            this.contract.mintController(),
+            this.contract.burnController(),
+            this.contract.burnHandler(),
+        ]);
+        return {
+            mintController,
+            burnController,
+            burnHandler,
+        };
+    }
+    async getChipMintingState() {
+        const isMintingPaused = await this.contract.isMintingPaused();
+        return {
+            isMintingPaused,
+        };
+    }
+}
+// ============ Pendable Admin Implementation ============
+class PendableAdmin {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async admin() {
+        return await this.contract.admin();
+    }
+    async pendingAdmin() {
+        return await this.contract.pendingAdmin();
+    }
+}
+// ============ Lynx Versioned Contract Implementation ============
+class LynxVersionedContract {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async getContractName() {
+        // EngineChip may not have versioning methods, return the contract name
+        return "EngineChip";
+    }
+    async getContractVersion() {
+        // EngineChip may not have versioning methods, return a default version
+        return "1.0.0";
+    }
+    async CONTRACT_NAME() {
+        return "EngineChip";
+    }
+    async CONTRACT_VERSION() {
+        return "1.0.0";
+    }
+}
+// ============ Main Service Class ============
+/**
+ * Service for interacting with the EngineChip contract
+ * Manages ERC20 chip token operations including minting, burning, and administration
+ */
+class EngineChipService {
+    constructor(signerOrProvider, address) {
+        this.contract = EngineChip__factory_1.EngineChip__factory.connect(address, signerOrProvider);
+        this.isSigner = "sendTransaction" in signerOrProvider;
+        // Initialize all function groups using separate classes
+        this.erc20Operations = new ERC20Operations(this.contract, this.isSigner);
+        this.mintingOperations = new MintingOperations(this.contract, this.isSigner);
+        this.burningOperations = new BurningOperations(this.contract, this.isSigner);
+        this.adminFunctions = new AdminFunctions(this.contract, this.isSigner);
+        this.autoApprovalManagement = new AutoApprovalManagement(this.contract, this.isSigner);
+        this.viewFunctions = new ViewFunctions(this.contract);
+        this.pendableAdmin = new PendableAdmin(this.contract);
+        this.lynxVersionedContract = new LynxVersionedContract(this.contract);
+    }
+    /**
+     * Get the underlying contract instance
+     * Useful for accessing contract methods directly when needed
+     */
+    getContract() {
+        return this.contract;
+    }
+}
+exports.EngineChipService = EngineChipService;

package/dist/cjs/lib/contractsIntegration/EngineChipService/IEngineChipService.js

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

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

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

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

@@ -92,8 +92,7 @@ class PermissionManagement {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");
         }
-        const tx = await this.contract.setPermissions(payloads);
-        await tx.wait();
+        return await this.contract.setPermissions(payloads);
     }
 }
 // ============ Configuration Implementation ============
@@ -169,6 +168,30 @@ class AdminFunctions {
         const tx = await this.contract.setDynamicRoleCallers(callers, roleNames);
         await tx.wait();
     }
+    async adminRevokeSpecificPermission(owner, spender, token) {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        return await this.contract.adminRevokeSpecificPermission(owner, spender, token);
+    }
+    async adminBatchRevokeSpecificPermissions(owners, spenders, tokens) {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        return await this.contract.adminBatchRevokeSpecificPermissions(owners, spenders, tokens);
+    }
+    async adminRevokeAllPermissionsFromOwner(owner, spender) {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        return await this.contract.adminRevokeAllPermissionsFromOwner(owner, spender);
+    }
+    async adminPermanentlyRevokeSpender(owner, spender) {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        return await this.contract.adminPermanentlyRevokeSpender(owner, spender);
+    }
     async setPendingAdmin(newPendingAdmin) {
         if (!this.isSigner) {
             throw new Error("OnBehalfTradingService: Write operations require a signer");

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

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

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

@@ -131,6 +131,12 @@ class Settings {
     async actionFees(actionType) {
         return this.tradingContract.actionFees(actionType);
     }
+    async limitsMarginFraction() {
+        return this.tradingContract.limitsMarginFraction();
+    }
+    async setLimitsMarginFraction(limitsMarginFraction) {
+        return this.tradingContract.setLimitsMarginFraction(limitsMarginFraction);
+    }
 }
 class Constants {
     constructor(tradingContract) {

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

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

package/dist/cjs/lib/contractsIntegration/WrappedNativeEngineChipHelperService/IWrappedNativeEngineChipHelperService.js

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

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrappedNativeEngineChipHelperService = void 0;
+const WrappedNativeEngineChipHelper__factory_1 = require("../../typechain/factories/contracts/Peripheral/Chips/WrappedNativeEngineChipHelper__factory");
+// ============ Wrap And Mint Implementation ============
+class WrapAndMint {
+    constructor(contract, isSigner) {
+        this.contract = contract;
+        this.isSigner = isSigner;
+    }
+    async wrapNativeAndMintEngineChip() {
+        if (!this.isSigner) {
+            throw new Error("WrappedNativeEngineChipHelperService: Write operations require a signer");
+        }
+        return await this.contract.wrapNativeAndMintEngineChip();
+    }
+}
+// ============ Burn Handling Implementation ============
+class BurnHandling {
+    constructor(contract, isSigner) {
+        this.contract = contract;
+        this.isSigner = isSigner;
+    }
+    async handleBurn(burner, arg1, underlyingAmount, arg3) {
+        if (!this.isSigner) {
+            throw new Error("WrappedNativeEngineChipHelperService: Write operations require a signer");
+        }
+        return await this.contract.handleBurn(burner, arg1, underlyingAmount, arg3);
+    }
+}
+// ============ View Functions Implementation ============
+class ViewFunctions {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async wrappedNativeEngineChip() {
+        return await this.contract.wrappedNativeEngineChip();
+    }
+    async wrappedNativeToken() {
+        return await this.contract.wrappedNativeToken();
+    }
+    async wrappedNativeReturnsUint256() {
+        return await this.contract.wrappedNativeReturnsUint256();
+    }
+}
+// ============ Main Service Class ============
+/**
+ * Service for interacting with the WrappedNativeEngineChipHelper contract
+ * Facilitates wrapping native tokens (like ETH) into wrapped native tokens (like WETH)
+ * and then minting the corresponding engine chips
+ */
+class WrappedNativeEngineChipHelperService {
+    constructor(signerOrProvider, address) {
+        this.contract = WrappedNativeEngineChipHelper__factory_1.WrappedNativeEngineChipHelper__factory.connect(address, signerOrProvider);
+        this.isSigner = "sendTransaction" in signerOrProvider;
+        // Initialize all function groups using separate classes
+        this.wrapAndMint = new WrapAndMint(this.contract, this.isSigner);
+        this.burnHandling = new BurnHandling(this.contract, this.isSigner);
+        this.viewFunctions = new ViewFunctions(this.contract);
+    }
+    /**
+     * Get the underlying contract instance
+     * Useful for accessing contract methods directly when needed
+     */
+    getContract() {
+        return this.contract;
+    }
+}
+exports.WrappedNativeEngineChipHelperService = WrappedNativeEngineChipHelperService;

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

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

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

@@ -33,6 +33,12 @@ exports.createChipsIntentsVerifierService = createChipsIntentsVerifierService;
 exports.createLiquidityIntentsVerifierService = createLiquidityIntentsVerifierService;
 exports.createTradeIntentsVerifierService = createTradeIntentsVerifierService;
 exports.createOnBehalfTradingService = createOnBehalfTradingService;
+exports.connectToEngineChipForSigner = connectToEngineChipForSigner;
+exports.connectToEngineChip = connectToEngineChip;
+exports.createEngineChipService = createEngineChipService;
+exports.connectToWrappedNativeEngineChipHelperForSigner = connectToWrappedNativeEngineChipHelperForSigner;
+exports.connectToWrappedNativeEngineChipHelper = connectToWrappedNativeEngineChipHelper;
+exports.createWrappedNativeEngineChipHelperService = createWrappedNativeEngineChipHelperService;
 const TradingFloorLens__factory_1 = require("../typechain/factories/contracts/Peripheral/Lens/TradingFloorLens__factory");
 const LexLens__factory_1 = require("../typechain/factories/contracts/Peripheral/Lens/LexLens__factory");
 const RegistryProxy__factory_1 = require("../typechain/factories/contracts/Lynx/Registry/RegistryProxy__factory");
@@ -55,6 +61,10 @@ const LiquidityIntentsVerifierService_1 = require("./LiquidityIntentsVerifierSer
 const TradeIntentsVerifierService_1 = require("./TradeIntentsVerifierService");
 const OnBehalfTradingV1__factory_1 = require("../typechain/factories/contracts/Lynx/OnBehalfTrading/OnBehalfTradingV1__factory");
 const OnBehalfTradingService_1 = require("./OnBehalfTradingService");
+const EngineChip__factory_1 = require("../typechain/factories/contracts/Lynx/Chips/EngineChip/EngineChip__factory");
+const EngineChipService_1 = require("./EngineChipService");
+const WrappedNativeEngineChipHelper__factory_1 = require("../typechain/factories/contracts/Peripheral/Chips/WrappedNativeEngineChipHelper__factory");
+const WrappedNativeEngineChipHelperService_1 = require("./WrappedNativeEngineChipHelperService");
 //
 // ***** Registry & Proxy *****
 //
@@ -193,3 +203,27 @@ function createTradeIntentsVerifierService(signerOrProvider, address) {
 function createOnBehalfTradingService(signerOrProvider, address) {
     return new OnBehalfTradingService_1.OnBehalfTradingService(signerOrProvider, address);
 }
+//
+// ***** EngineChip *****
+//
+function connectToEngineChipForSigner(signer, address) {
+    return EngineChip__factory_1.EngineChip__factory.connect(address, signer);
+}
+function connectToEngineChip(provider, address) {
+    return EngineChip__factory_1.EngineChip__factory.connect(address, provider);
+}
+function createEngineChipService(signerOrProvider, address) {
+    return new EngineChipService_1.EngineChipService(signerOrProvider, address);
+}
+//
+// ***** WrappedNativeEngineChipHelper *****
+//
+function connectToWrappedNativeEngineChipHelperForSigner(signer, address) {
+    return WrappedNativeEngineChipHelper__factory_1.WrappedNativeEngineChipHelper__factory.connect(address, signer);
+}
+function connectToWrappedNativeEngineChipHelper(provider, address) {
+    return WrappedNativeEngineChipHelper__factory_1.WrappedNativeEngineChipHelper__factory.connect(address, provider);
+}
+function createWrappedNativeEngineChipHelperService(signerOrProvider, address) {
+    return new WrappedNativeEngineChipHelperService_1.WrappedNativeEngineChipHelperService(signerOrProvider, address);
+}

package/dist/cjs/lib/typechain/contracts/Lynx/Chips/EngineChip/EngineChip.js

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

package/dist/cjs/lib/typechain/contracts/Peripheral/Chips/WrappedNativeEngineChipHelper.js

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