lynx-client 0.0.10 → 0.0.12

package/README.md

@@ -86,7 +86,47 @@ const arbitrumAddresses = LynxSystemAddresses.arbitrum;
 
 ### Contract Services
 
-The SDK provides service wrappers for all Lynx contracts:
+The SDK provides service wrappers for all Lynx contracts, organized using a consistent grouped interface pattern:
+
+#### Service Architecture
+
+All services follow a grouped interface pattern for better organization:
+
+```typescript
+// Example: TradingFloor Service Structure
+const tradingFloor = createTradingFloorService(signer, address);
+
+// Grouped by functionality
+tradingFloor.positionQueries       // Position-related queries
+tradingFloor.settlementAndPool     // Settlement and pool operations
+tradingFloor.traderTracking        // Trader tracking functions
+tradingFloor.tradingParameters     // Trading parameters
+tradingFloor.fees                  // Fee information
+tradingFloor.deprecated            // Deprecated functions
+
+// Standardized accessors
+tradingFloor.pendableAdmin         // Admin functions
+tradingFloor.pendableImplementation // Implementation functions
+tradingFloor.lynxVersionedContract  // Version information
+tradingFloor.contractReferences    // Other contract addresses
+tradingFloor.constants             // Protocol constants
+```
+
+```typescript
+// Example: OnBehalfTrading Service Structure
+const onBehalfTrading = new OnBehalfTradingService(signer, address);
+
+// Grouped by functionality
+onBehalfTrading.permissionQueries     // Permission validation and queries
+onBehalfTrading.permissionManagement  // Grant/revoke permissions
+onBehalfTrading.configuration         // Contract configuration
+onBehalfTrading.adminFunctions        // Admin operations
+
+// Standardized accessors
+onBehalfTrading.pendableAdmin         // Admin functions
+onBehalfTrading.lynxVersionedContract  // Version information
+onBehalfTrading.contractReferences    // Other contract addresses
+```
 
 #### Trading Operations
 
@@ -228,6 +268,49 @@ const configs = await triggers.getTriggersConfigurations();
 const pairConfigs = await triggers.getPairConfigsInTriggers(1); // Pair ID 1
 ```
 
+### Delegated Trading with OnBehalfTrading
+
+The OnBehalfTrading service enables users to grant trading permissions to other addresses with specific limits and durations:
+
+```typescript
+import { OnBehalfTradingService } from 'lynx-client';
+
+const onBehalfTrading = new OnBehalfTradingService(signer, onBehalfTradingAddress);
+
+// Grant permission to a trader
+await onBehalfTrading.permissionManagement.grantPermission(
+  traderAddress,
+  tokenAddress,
+  ethers.parseUnits("1000", 18), // 1000 token limit
+  86400n // 24 hours duration
+);
+
+// Check if permission is valid
+const isValid = await onBehalfTrading.permissionQueries.isPermissionValid(
+  ownerAddress,
+  traderAddress,
+  tokenAddress
+);
+
+// Get remaining amount
+const remaining = await onBehalfTrading.permissionQueries.getRemainingAmount(
+  ownerAddress,
+  traderAddress,
+  tokenAddress
+);
+
+// Revoke permissions
+await onBehalfTrading.permissionManagement.revokePermission(
+  traderAddress,
+  tokenAddress
+);
+
+// Get all active permissions for an owner
+const allPermissions = await onBehalfTrading.permissionQueries.getAllActivePermissions(
+  ownerAddress
+);
+```
+
 ### LEX Pool Operations
 
 ```typescript
@@ -244,6 +327,85 @@ const supplierState = await lexLens.getLexPoolSupplierState(
 const feeConfigs = await lexLens.getAllFeeConfigurationsInLex(lexPoolAddress);
 ```
 
+## Standardized Contract Interfaces
+
+The SDK provides standardized interfaces for common contract patterns, ensuring consistent access across all services:
+
+### Common Interfaces
+
+#### ILynxVersionedContract
+All Lynx contracts implement versioning for transparency and upgradeability tracking:
+
+```typescript
+import { createTradingFloorService } from 'lynx-client';
+
+const tradingFloor = createTradingFloorService(signer, tradingFloorAddress);
+
+// Access version information through standardized property
+const name = await tradingFloor.lynxVersionedContract.getContractName();
+const version = await tradingFloor.lynxVersionedContract.getContractVersion();
+const contractName = await tradingFloor.lynxVersionedContract.CONTRACT_NAME();
+const contractVersion = await tradingFloor.lynxVersionedContract.CONTRACT_VERSION();
+```
+
+#### IPendableAdmin
+Contracts with two-step admin transfer for enhanced security:
+
+```typescript
+// All services with admin functionality use the same accessor
+const currentAdmin = await tradingFloor.pendableAdmin.admin();
+const pendingAdmin = await tradingFloor.pendableAdmin.pendingAdmin();
+
+// Same pattern works across all services
+const triggersAdmin = await triggers.pendableAdmin.admin();
+const pnlrAdmin = await pnlr.pendableAdmin.admin();
+```
+
+#### IPendableImplementation
+Upgradeable contracts with two-step implementation updates:
+
+```typescript
+// Access implementation details through standardized property
+const implementation = await tradingFloor.pendableImplementation.implementation();
+const pendingImpl = await tradingFloor.pendableImplementation.pendingImplementation();
+
+// OrderBook also uses the same pattern
+const orderBookImpl = await orderBook.pendableImplementation.implementation();
+```
+
+### Standardized Accessor Patterns
+
+All services follow consistent naming conventions for common functionality:
+
+| Property | Interface | Description |
+|----------|-----------|-------------|
+| `lynxVersionedContract` | `ILynxVersionedContract` | Contract version information |
+| `pendableAdmin` | `IPendableAdmin` | Admin transfer functionality |
+| `pendableImplementation` | `IPendableImplementation` | Implementation upgrade functionality |
+| `contractReferences` | Service-specific | References to other contracts |
+| `constants` | Service-specific | Protocol constants and scales |
+
+Example with multiple services:
+
+```typescript
+// TradingFloor Service
+const tf = createTradingFloorService(signer, address);
+await tf.pendableAdmin.admin(); // Admin functionality
+await tf.pendableImplementation.implementation(); // Implementation info
+await tf.lynxVersionedContract.getContractVersion(); // Version info
+await tf.contractReferences.registry(); // Other contract addresses
+
+// PNLR Service (no implementation pattern)
+const pnlr = createPNLRService(signer, address);
+await pnlr.pendableAdmin.admin(); // Admin functionality
+await pnlr.lynxVersionedContract.getContractVersion(); // Version info
+
+// Triggers Service (no implementation pattern)
+const triggers = createTriggersService(signer, address);
+await triggers.pendableAdmin.admin(); // Admin functionality
+await triggers.contractReferences.orderBook(); // Other contract addresses
+```
+
 ## Type Safety
 
 The SDK provides comprehensive TypeScript types for all contract interactions:
@@ -253,7 +415,10 @@ import {
   TPositionRequestIdentifierStruct,
   TPositionRequestParamsStruct,
   TSinglePositionStruct,
-  TPairConfigsInTriggersStruct
+  TPairConfigsInTriggersStruct,
+  ILynxVersionedContract,
+  IPendableAdmin,
+  IPendableImplementation
 } from 'lynx-client';
 
 // All contract structs are properly typed
@@ -261,6 +426,10 @@ const position = await tradingFloorLens.getCompletePositionData(tradingFloorAddr
 console.log(position.trader); // string
 console.log(position.collateral); // bigint
 console.log(position.leverage); // bigint
+
+// Common interfaces ensure type safety
+const service: { pendableAdmin: IPendableAdmin } = tradingFloor;
+const admin = await service.pendableAdmin.admin(); // Type-safe access
 ```
 
 ## Error Handling
@@ -359,6 +528,27 @@ const ethUsd = TPairIds.ETH_USD;
    }
    ```
 
+## Migration Guide
+
+### From Previous Versions
+
+If you're upgrading from an earlier version, note these changes to standardized accessors:
+
+```typescript
+// Old pattern (mixed grouping)
+const admin = await tradingFloor.administration.admin();
+const version = await tradingFloor.contractInfo.getContractVersion();
+
+// New pattern (standardized accessors)
+const admin = await tradingFloor.pendableAdmin.admin();
+const version = await tradingFloor.lynxVersionedContract.getContractVersion();
+```
+
+Key changes:
+- `administration` → Split into `pendableAdmin` and `contractReferences`
+- `contractInfo` → Split into `lynxVersionedContract` and `contractReferences`
+- Consistent naming across all services
+
 ## Development
 
 ### Building

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.TradeIntentsVerifierService = exports.LiquidityIntentsVerifierService = exports.ChipsIntentsVerifierService = void 0;
+exports.tradeIntentsVerifierPayloadTypes = exports.liquidityIntentsVerifierPayloadTypes = exports.chipsIntentsVerifierPayloadTypes = 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);
@@ -47,6 +47,8 @@ var LiquidityIntentsVerifierService_1 = require("./lib/contractsIntegration/Liqu
 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; } });
+var OnBehalfTradingService_1 = require("./lib/contractsIntegration/OnBehalfTradingService");
+Object.defineProperty(exports, "OnBehalfTradingService", { enumerable: true, get: function () { return OnBehalfTradingService_1.OnBehalfTradingService; } });
 __exportStar(require("./lib/contractsIntegration/IntentsVerifierLensService"), exports);
 __exportStar(require("./lib/contractsIntegration/TriggersAndPortalLensService"), exports);
 __exportStar(require("./lib/contractsIntegration/TradingFloorLensService"), exports);
@@ -71,5 +73,7 @@ __exportStar(require("./lib/typechain/factories/contracts/Peripheral/Lens/Tradin
 __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);
+// Contract factory export for OnBehalfTrading
+__exportStar(require("./lib/typechain/factories/contracts/Lynx/OnBehalfTrading/OnBehalfTradingV1__factory"), exports);
 // Developer Experience utilities
 __exportStar(require("./lib/devex"), exports);

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

@@ -196,6 +196,7 @@ class LexPoolV1Service {
             SELF_UNIT_SCALE: () => this.lexPoolContract.SELF_UNIT_SCALE(),
             PRECISION: () => this.lexPoolContract.PRECISION(),
             FRACTION_SCALE: () => this.lexPoolContract.FRACTION_SCALE(),
+            LEVERAGE_SCALE: () => this.lexPoolContract.LEVERAGE_SCALE(),
         };
     }
     createContractInfoGroup() {

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

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

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

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OnBehalfTradingService = void 0;
+const OnBehalfTradingV1__factory_1 = require("../../typechain/factories/contracts/Lynx/OnBehalfTrading/OnBehalfTradingV1__factory");
+// ============ Permission Queries Implementation ============
+class PermissionQueries {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async isPermissionValid(owner, spender, token) {
+        return await this.contract.isPermissionValid(owner, spender, token);
+    }
+    async getRemainingAmount(owner, spender, token) {
+        return await this.contract.getRemainingAmount(owner, spender, token);
+    }
+    async getPermission(owner, spender, token) {
+        const permission = await this.contract.permissions(owner, spender, token);
+        return {
+            amountLimit: permission.amountLimit,
+            amountUsed: permission.amountUsed,
+            expiryTime: permission.expiryTime,
+            isActive: permission.isActive,
+        };
+    }
+    async permanentlyRevoked(owner, spender) {
+        return await this.contract.permanentlyRevoked(owner, spender);
+    }
+    async hasActivePermissions(owner) {
+        return await this.contract.hasActivePermissions(owner);
+    }
+    async getActivePermissionCount(owner) {
+        return await this.contract.getActivePermissionCount(owner);
+    }
+    async getActiveSpenders(owner) {
+        return await this.contract.getActiveSpenders(owner);
+    }
+    async getActiveTokensForSpender(owner, spender) {
+        return await this.contract.getActiveTokensForSpender(owner, spender);
+    }
+    async getAllActivePermissions(owner) {
+        const result = await this.contract.getAllActivePermissions(owner);
+        return {
+            spenders: result.spenders,
+            tokens: result.tokens,
+            permissionData: result.permissionData.map((p) => ({
+                amountLimit: p.amountLimit,
+                amountUsed: p.amountUsed,
+                expiryTime: p.expiryTime,
+                isActive: p.isActive,
+            })),
+        };
+    }
+    async requirePermission(owner, spender, token) {
+        await this.contract.requirePermission(owner, spender, token);
+    }
+}
+// ============ Permission Management Implementation ============
+class PermissionManagement {
+    constructor(contract, isSigner) {
+        this.contract = contract;
+        this.isSigner = isSigner;
+    }
+    async grantPermission(spender, token, amountLimit, duration) {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        const tx = await this.contract.grantPermission(spender, token, amountLimit, duration);
+        await tx.wait();
+    }
+    async revokePermission(spender, token) {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        const tx = await this.contract.revokePermission(spender, token);
+        await tx.wait();
+    }
+    async revokeAllPermissions(spender) {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        const tx = await this.contract.revokeAllPermissions(spender);
+        await tx.wait();
+    }
+    async chargePermission(owner, spender, token, amount) {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        const tx = await this.contract.chargePermission(owner, spender, token, amount);
+        await tx.wait();
+    }
+    async setPermissions(payloads) {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        const tx = await this.contract.setPermissions(payloads);
+        await tx.wait();
+    }
+}
+// ============ Configuration Implementation ============
+class Configuration {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async isPaused() {
+        return await this.contract.isPaused();
+    }
+    async maxPermissionDuration() {
+        return await this.contract.maxPermissionDuration();
+    }
+    async maxPermissionAmountPerToken(token) {
+        return await this.contract.maxPermissionAmountPerToken(token);
+    }
+    async getContractConfiguration(tokensToQuery) {
+        const config = await this.contract.getContractConfiguration(tokensToQuery);
+        return {
+            isPausedState: config.isPausedState,
+            maxDuration: config.maxDuration,
+            tokenMaxAmounts: config.tokenMaxAmounts,
+            registryAddress: config.registryAddress,
+            tradersPortalAddress: config.tradersPortalAddress,
+        };
+    }
+}
+// ============ Admin Functions Implementation ============
+class AdminFunctions {
+    constructor(contract, isSigner) {
+        this.contract = contract;
+        this.isSigner = isSigner;
+    }
+    async setMaxPermissionDuration(maxDuration) {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        const tx = await this.contract.setMaxPermissionDuration(maxDuration);
+        await tx.wait();
+    }
+    async setMaxPermissionAmountForToken(token, maxAmount) {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        const tx = await this.contract.setMaxPermissionAmountForToken(token, maxAmount);
+        await tx.wait();
+    }
+    async setMaxPermissionAmountsForTokens(tokens, maxAmounts) {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        const tx = await this.contract.setMaxPermissionAmountsForTokens(tokens, maxAmounts);
+        await tx.wait();
+    }
+    async togglePause() {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        const tx = await this.contract.togglePause();
+        await tx.wait();
+    }
+    async setDynamicRoleCaller(caller, roleName) {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        const tx = await this.contract.setDynamicRoleCaller(caller, roleName);
+        await tx.wait();
+    }
+    async setDynamicRoleCallers(callers, roleNames) {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        const tx = await this.contract.setDynamicRoleCallers(callers, roleNames);
+        await tx.wait();
+    }
+    async setPendingAdmin(newPendingAdmin) {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        const tx = await this.contract._setPendingAdmin(newPendingAdmin);
+        await tx.wait();
+    }
+    async acceptAdmin() {
+        if (!this.isSigner) {
+            throw new Error("OnBehalfTradingService: Write operations require a signer");
+        }
+        const tx = await this.contract._acceptAdmin();
+        await tx.wait();
+    }
+}
+// ============ Contract References Implementation ============
+class ContractReferences {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async registry() {
+        return await this.contract.registry();
+    }
+    async dynamicRoleCallers(address) {
+        return await this.contract.dynamicRoleCallers(address);
+    }
+}
+// ============ 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() {
+        return await this.contract.getContractName();
+    }
+    async getContractVersion() {
+        return await this.contract.getContractVersion();
+    }
+    async CONTRACT_NAME() {
+        return await this.contract.CONTRACT_NAME();
+    }
+    async CONTRACT_VERSION() {
+        return await this.contract.CONTRACT_VERSION();
+    }
+}
+// ============ Main Service Class ============
+/**
+ * Service for interacting with the OnBehalfTrading contract
+ * Manages delegated trading permissions between users
+ */
+class OnBehalfTradingService {
+    constructor(signerOrProvider, address) {
+        this.contract = OnBehalfTradingV1__factory_1.OnBehalfTradingV1__factory.connect(address, signerOrProvider);
+        this.isSigner = "sendTransaction" in signerOrProvider;
+        // Initialize all function groups using separate classes
+        this.permissionQueries = new PermissionQueries(this.contract);
+        this.permissionManagement = new PermissionManagement(this.contract, this.isSigner);
+        this.configuration = new Configuration(this.contract);
+        this.adminFunctions = new AdminFunctions(this.contract, this.isSigner);
+        this.contractReferences = new ContractReferences(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.OnBehalfTradingService = OnBehalfTradingService;

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

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

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

@@ -28,7 +28,7 @@ class OrderManagement {
         return this.orderBookContract.updateOrderIdPositionInList(positionId);
     }
 }
-class ContractInfo {
+class ContractReferences {
     constructor(orderBookContract) {
         this.orderBookContract = orderBookContract;
     }
@@ -38,12 +38,22 @@ class ContractInfo {
     async tradingFloor() {
         return this.orderBookContract.tradingFloor();
     }
+}
+class PendableAdmin {
+    constructor(orderBookContract) {
+        this.orderBookContract = orderBookContract;
+    }
     async admin() {
         return this.orderBookContract.admin();
     }
     async pendingAdmin() {
         return this.orderBookContract.pendingAdmin();
     }
+}
+class PendableImplementation {
+    constructor(orderBookContract) {
+        this.orderBookContract = orderBookContract;
+    }
     async implementation() {
         return this.orderBookContract.implementation();
     }
@@ -84,7 +94,9 @@ class OrderBookService {
         this.signerOrProvider = signerOrProvider;
         this.orderBookContract = OrderBookV1__factory_1.OrderBookV1__factory.connect(address, signerOrProvider);
         this.orderManagement = new OrderManagement(this.orderBookContract);
-        this.contractInfo = new ContractInfo(this.orderBookContract);
+        this.contractReferences = new ContractReferences(this.orderBookContract);
+        this.pendableAdmin = new PendableAdmin(this.orderBookContract);
+        this.pendableImplementation = new PendableImplementation(this.orderBookContract);
         this.administration = new Administration(this.orderBookContract);
         this.constants = new Constants(this.orderBookContract);
     }

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

@@ -70,7 +70,7 @@ class PNLRFunctionsGroup_Configuration {
         return this.contract.priceValidatorType();
     }
 }
-class PNLRFunctionsGroup_ContractInfo {
+class PNLRFunctionsGroup_PendableAdmin {
     constructor(contract) {
         this.contract = contract;
     }
@@ -80,12 +80,6 @@ class PNLRFunctionsGroup_ContractInfo {
     async pendingAdmin() {
         return this.contract.pendingAdmin();
     }
-    async getContractName() {
-        return this.contract.getContractName();
-    }
-    async getContractVersion() {
-        return this.contract.getContractVersion();
-    }
 }
 class PNLRFunctionsGroup_AdminManagement {
     constructor(contract) {
@@ -98,10 +92,16 @@ class PNLRFunctionsGroup_AdminManagement {
         return this.contract._acceptAdmin();
     }
 }
-class PNLRFunctionsGroup_Constants {
+class PNLRFunctionsGroup_LynxVersionedContract {
     constructor(contract) {
         this.contract = contract;
     }
+    async getContractName() {
+        return this.contract.getContractName();
+    }
+    async getContractVersion() {
+        return this.contract.getContractVersion();
+    }
     async CONTRACT_NAME() {
         return this.contract.CONTRACT_NAME();
     }
@@ -117,8 +117,8 @@ class PNLRService {
         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);
+        this.pendableAdmin = new PNLRFunctionsGroup_PendableAdmin(this.pnlrContract);
+        this.lynxVersionedContract = new PNLRFunctionsGroup_LynxVersionedContract(this.pnlrContract);
     }
 }
 exports.PNLRService = PNLRService;